drivers/char/joystick/joy-spaceorb.c

   1 /*
   2  *  joy-spaceorb.c  Version 0.1
   3  *
   4  *  Copyright (c) 1998 David Thompson
   5  *  Copyright (c) 1999 Vojtech Pavlik
   6  *
   7  *  Sponsored by SuSE
   8  */
   9
  10 /*
  11  * This is a module for the Linux joystick driver, supporting
  12  * the SpaceTec SpaceOrb 360 and SpaceBall Avenger 6dof controllers.
  13  */
  14
  15 /*
  16  * This program is free software; you can redistribute it and/or modify
  17  * it under the terms of the GNU General Public License as published by
  18  * the Free Software Foundation; either version 2 of the License, or
  19  * (at your option) any later version.
  20  *
  21  * This program is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  * GNU General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License
  27  * along with this program; if not, write to the Free Software
  28  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  29  *
  30  *  Should you need to contact me, the author, you can do so either by
  31  * e-mail - mail your message to <vojtech@suse.cz>, or by paper mail:
  32  * Vojtech Pavlik, Ucitelska 1576, Prague 8, 182 00 Czech Republic
  33  */
  34
  35 #include <asm/io.h>
  36 #include <asm/system.h>
  37 #include <linux/errno.h>
  38 #include <linux/joystick.h>
  39 #include <linux/kernel.h>
  40 #include <linux/module.h>
  41 #include <linux/tty.h>
  42 #include <linux/init.h>
  43
  44 /*
  45  * Constants.
  46  */
  47
  48 #define N_JOYSTICK_ORB          15
  49 #define JS_ORB_MAX_LENGTH       64
  50
  51 /*
  52  * List of SpaceOrbs.
  53  */
  54
  55 static struct js_port* js_orb_port = NULL;
  56
  57 /*
  58  * Per-Orb data.
  59  */
  60
  61 struct js_orb_info {
  62         struct tty_struct* tty;
  63         struct js_port* port;
  64         int idx;
  65         unsigned char data[JS_ORB_MAX_LENGTH];
  66         int js;
  67         char used;
  68 };
  69
  70 static unsigned char js_orb_xor[] = "SpaceWare";
  71
  72 static unsigned char *js_orb_errors[] = { "EEPROM storing 0 failed", "Receive queue overflow", "Transmit queue timeout",
  73                 "Bad packet", "Power brown-out", "EEPROM checksum error", "Hardware fault" };
  74
  75 /*
  76  * js_orb_process_packet() decodes packets the driver receives from the
  77  * SpaceOrb.
  78  */
  79
  80 static void js_orb_process_packet(struct js_orb_info* info)
  81 {
  82         int i;
  83         int **axes = info->port->axes;
  84         int **buttons = info->port->buttons;
  85         unsigned char *data = info->data;
  86         unsigned char c = 0;
  87
  88         if (info->idx < 2) return;
  89         for (i = 0; i < info->idx; i++) c ^= data[i];
  90         if (c) return;
  91
  92         switch (info->data[0]) {
  93
  94                 case 'R':                               /* Reset packet */
  95                         info->data[info->idx - 1] = 0;
  96                         for (i = 1; i < info->idx && info->data[i] == ' '; i++);
  97                         printk(KERN_INFO "js%d: SpaceOrb 360 [%s] on %s%d\n",
  98                                 info->js, info->data + i, info->tty->driver.name,
  99                                 MINOR(info->tty->device) - info->tty->driver.minor_start);
 100                         break;
 101
 102                 case 'D':                               /* Ball + button data */
 103                         if (info->idx != 12) return;
 104                         if (!info->port->devs[0]) return;
 105                         for (i = 0; i < 9; i++) info->data[i+2] ^= js_orb_xor[i];
 106                         axes[0][0] = ( data[2]         << 3) | (data[ 3] >> 4);
 107                         axes[0][1] = ((data[3] & 0x0f) << 6) | (data[ 4] >> 1);
 108                         axes[0][2] = ((data[4] & 0x01) << 9) | (data[ 5] << 2) | (data[4] >> 5);
 109                         axes[0][3] = ((data[6] & 0x1f) << 5) | (data[ 7] >> 2);
 110                         axes[0][4] = ((data[7] & 0x03) << 8) | (data[ 8] << 1) | (data[7] >> 6);
 111                         axes[0][5] = ((data[9] & 0x3f) << 4) | (data[10] >> 3);
 112                         for(i = 0; i < 6; i ++) if (axes[0][i] & 0x200) axes[0][i] -= 1024;
 113                         buttons[0][0] = data[1];
 114                         break;
 115
 116                 case 'K':                               /* Button data */
 117                         if (info->idx != 5) return;
 118                         if (!info->port->devs[0]) return;
 119                         buttons[0][0] = data[2];
 120                         break;
 121
 122                 case 'E':                               /* Error packet */
 123                         if (info->idx != 4) return;
 124                         printk(KERN_ERR "joy-spaceorb: Device error. [ ");
 125                         for (i = 0; i < 7; i++)
 126                                 if (data[1] & (1 << i))
 127                                         printk("%s ", js_orb_errors[i]);
 128                         printk("]\n");
 129                         break;
 130
 131                 case 'N':                               /* Null region */
 132                         if (info->idx != 3) return;
 133                         break;
 134
 135                 case 'P':                               /* Pulse (update) speed */
 136                         if (info->idx != 4) return;
 137                         break;
 138
 139                 default:
 140                         printk("joy-spaceorb: Unknown packet %d length %d:", data[0], info->idx);
 141                         for (i = 0; i < info->idx; i++) printk(" %02x", data[i]);
 142                         printk("\n");
 143                         return;
 144         }
 145 }
 146
 147 /*
 148  * js_orb_open() is a callback from the joystick device open routine.
 149  */
 150
 151 static int js_orb_open(struct js_dev *jd)
 152 {
 153         struct js_orb_info *info = jd->port->info;
 154         info->used++;
 155         return 0;
 156 }
 157
 158 /*
 159  * js_orb_close() is a callback from the joystick device release routine.
 160  */
 161
 162 static int js_orb_close(struct js_dev *jd)
 163 {
 164         struct js_orb_info *info = jd->port->info;
 165         if (!--info->used) {
 166                 js_unregister_device(jd->port->devs[0]);
 167                 js_orb_port = js_unregister_port(jd->port);
 168         }
 169         return 0;
 170 }
 171
 172 /*
 173  * js_orb_init_corr() initializes the correction values for the SpaceOrb.
 174  */
 175
 176 static void __init js_orb_init_corr(struct js_corr **corr)
 177 {
 178         int j;
 179
 180         for (j = 0; j < 6; j++) {
 181                 corr[0][j].type = JS_CORR_BROKEN;
 182                 corr[0][j].prec = 0;
 183                 corr[0][j].coef[0] = 0 ;
 184                 corr[0][j].coef[1] = 0 ;
 185                 corr[0][j].coef[2] = (1 << 29) / 511;
 186                 corr[0][j].coef[3] = (1 << 29) / 511;
 187         }
 188 }
 189
 190 /*
 191  * js_orb_ldisc_open() is the routine that is called upon setting our line
 192  * discipline on a tty.
 193  */
 194
 195 static int js_orb_ldisc_open(struct tty_struct *tty)
 196 {
 197         struct js_orb_info iniinfo;
 198         struct js_orb_info *info = &iniinfo;
 199
 200         MOD_INC_USE_COUNT;
 201
 202         info->tty = tty;
 203         info->idx = 0;
 204         info->used = 1;
 205
 206         js_orb_port = js_register_port(js_orb_port, info, 1, sizeof(struct js_orb_info), NULL);
 207
 208         info = js_orb_port->info;
 209         info->port = js_orb_port;
 210         tty->disc_data = info;
 211
 212         info->js = js_register_device(js_orb_port, 0, 6, 7, "SpaceOrb 360", THIS_MODULE, js_orb_open, js_orb_close);
 213
 214         js_orb_init_corr(js_orb_port->corr);
 215
 216         return 0;
 217 }
 218
 219 /*
 220  * js_orb_ldisc_close() is the opposite of js_orb_ldisc_open()
 221  */
 222
 223 static void js_orb_ldisc_close(struct tty_struct *tty)
 224 {
 225         struct js_orb_info* info = (struct js_orb_info*) tty->disc_data;
 226         if (!--info->used) {
 227                 js_unregister_device(info->port->devs[0]);
 228                 js_orb_port = js_unregister_port(info->port);
 229         }
 230         MOD_DEC_USE_COUNT;
 231 }
 232
 233 /*
 234  * js_orb_ldisc_receive() is called by the low level driver when characters
 235  * are ready for us. We then buffer them for further processing, or call the
 236  * packet processing routine.
 237  */
 238
 239 static void js_orb_ldisc_receive(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
 240 {
 241         struct js_orb_info* info = (struct js_orb_info*) tty->disc_data;
 242         int i;
 243
 244         for (i = 0; i < count; i++) {
 245                 if (~cp[i] & 0x80) {
 246                         if (info->idx) js_orb_process_packet(info);
 247                         info->idx = 0;
 248                 }
 249                 if (info->idx < JS_ORB_MAX_LENGTH)
 250                         info->data[info->idx++] = cp[i] & 0x7f;
 251         }
 252 }
 253
 254 /*
 255  * js_orb_ldisc_room() reports how much room we do have for receiving data.
 256  * Although we in fact have infinite room, we need to specify some value
 257  * here, so why not the size of our packet buffer. It's big anyway.
 258  */
 259
 260 static int js_orb_ldisc_room(struct tty_struct *tty)
 261 {
 262         return JS_ORB_MAX_LENGTH;
 263 }
 264
 265 /*
 266  * The line discipline structure.
 267  */
 268
 269 static struct tty_ldisc js_orb_ldisc = {
 270         magic:          TTY_LDISC_MAGIC,
 271         name:           "spaceorb",
 272         open:           js_orb_ldisc_open,
 273         close:          js_orb_ldisc_close,
 274         receive_buf:    js_orb_ldisc_receive,
 275         receive_room:   js_orb_ldisc_room,
 276 };
 277
 278 /*
 279  * The functions for inserting/removing us as a module.
 280  */
 281
 282 #ifdef MODULE
 283 int init_module(void)
 284 #else
 285 int __init js_orb_init(void)
 286 #endif
 287 {
 288         if (tty_register_ldisc(N_JOYSTICK_ORB, &js_orb_ldisc)) {
 289                 printk(KERN_ERR "joy-spaceorb: Error registering line discipline.\n");
 290                 return -ENODEV;
 291         }
 292
 293         return  0;
 294 }
 295
 296 #ifdef MODULE
 297 void cleanup_module(void)
 298 {
 299         tty_register_ldisc(N_JOYSTICK_ORB, NULL);
 300 }
 301 #endif