1 /* 2 * Copyright (c) 1999-2001 Vojtech Pavlik 3 * 4 * Based on the work of: 5 * Andree Borrmann Mats Sjövall 6 */ 7 8 /* 9 * Atari, Amstrad, Commodore, Amiga, Sega, etc. joystick driver for Linux 10 */ 11 12 /* 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License as published by 15 * the Free Software Foundation; either version 2 of the License, or 16 * (at your option) any later version. 17 * 18 * This program is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 * GNU General Public License for more details. 22 * 23 * You should have received a copy of the GNU General Public License 24 * along with this program; if not, write to the Free Software 25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 26 * 27 * Should you need to contact me, the author, you can do so either by 28 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail: 29 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic 30 */ 31 32 #include <linux/kernel.h> 33 #include <linux/module.h> 34 #include <linux/delay.h> 35 #include <linux/init.h> 36 #include <linux/parport.h> 37 #include <linux/input.h> 38 #include <linux/mutex.h> 39 #include <linux/slab.h> 40 41 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>"); 42 MODULE_DESCRIPTION("Atari, Amstrad, Commodore, Amiga, Sega, etc. joystick driver"); 43 MODULE_LICENSE("GPL"); 44 45 struct db9_config { 46 int args[2]; 47 unsigned int nargs; 48 }; 49 50 #define DB9_MAX_PORTS 3 51 static struct db9_config db9_cfg[DB9_MAX_PORTS]; 52 53 module_param_array_named(dev, db9_cfg[0].args, int, &db9_cfg[0].nargs, 0); 54 MODULE_PARM_DESC(dev, "Describes first attached device (<parport#>,<type>)"); 55 module_param_array_named(dev2, db9_cfg[1].args, int, &db9_cfg[1].nargs, 0); 56 MODULE_PARM_DESC(dev2, "Describes second attached device (<parport#>,<type>)"); 57 module_param_array_named(dev3, db9_cfg[2].args, int, &db9_cfg[2].nargs, 0); 58 MODULE_PARM_DESC(dev3, "Describes third attached device (<parport#>,<type>)"); 59 60 #define DB9_ARG_PARPORT 0 61 #define DB9_ARG_MODE 1 62 63 #define DB9_MULTI_STICK 0x01 64 #define DB9_MULTI2_STICK 0x02 65 #define DB9_GENESIS_PAD 0x03 66 #define DB9_GENESIS5_PAD 0x05 67 #define DB9_GENESIS6_PAD 0x06 68 #define DB9_SATURN_PAD 0x07 69 #define DB9_MULTI_0802 0x08 70 #define DB9_MULTI_0802_2 0x09 71 #define DB9_CD32_PAD 0x0A 72 #define DB9_SATURN_DPP 0x0B 73 #define DB9_SATURN_DPP_2 0x0C 74 #define DB9_MAX_PAD 0x0D 75 76 #define DB9_UP 0x01 77 #define DB9_DOWN 0x02 78 #define DB9_LEFT 0x04 79 #define DB9_RIGHT 0x08 80 #define DB9_FIRE1 0x10 81 #define DB9_FIRE2 0x20 82 #define DB9_FIRE3 0x40 83 #define DB9_FIRE4 0x80 84 85 #define DB9_NORMAL 0x0a 86 #define DB9_NOSELECT 0x08 87 88 #define DB9_GENESIS6_DELAY 14 89 #define DB9_REFRESH_TIME HZ/100 90 91 #define DB9_MAX_DEVICES 2 92 93 struct db9_mode_data { 94 const char *name; 95 const short *buttons; 96 int n_buttons; 97 int n_pads; 98 int n_axis; 99 int bidirectional; 100 int reverse; 101 }; 102 103 struct db9 { 104 struct input_dev *dev[DB9_MAX_DEVICES]; 105 struct timer_list timer; 106 struct pardevice *pd; 107 int mode; 108 int used; 109 int parportno; 110 struct mutex mutex; 111 char phys[DB9_MAX_DEVICES][32]; 112 }; 113 114 static struct db9 *db9_base[3]; 115 116 static const short db9_multi_btn[] = { BTN_TRIGGER, BTN_THUMB }; 117 static const short db9_genesis_btn[] = { BTN_START, BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, BTN_MODE }; 118 static const short db9_cd32_btn[] = { BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, BTN_TL, BTN_TR, BTN_START }; 119 static const short db9_abs[] = { ABS_X, ABS_Y, ABS_RX, ABS_RY, ABS_RZ, ABS_Z, ABS_HAT0X, ABS_HAT0Y, ABS_HAT1X, ABS_HAT1Y }; 120 121 static const struct db9_mode_data db9_modes[] = { 122 { NULL, NULL, 0, 0, 0, 0, 0 }, 123 { "Multisystem joystick", db9_multi_btn, 1, 1, 2, 1, 1 }, 124 { "Multisystem joystick (2 fire)", db9_multi_btn, 2, 1, 2, 1, 1 }, 125 { "Genesis pad", db9_genesis_btn, 4, 1, 2, 1, 1 }, 126 { NULL, NULL, 0, 0, 0, 0, 0 }, 127 { "Genesis 5 pad", db9_genesis_btn, 6, 1, 2, 1, 1 }, 128 { "Genesis 6 pad", db9_genesis_btn, 8, 1, 2, 1, 1 }, 129 { "Saturn pad", db9_cd32_btn, 9, 6, 7, 0, 1 }, 130 { "Multisystem (0.8.0.2) joystick", db9_multi_btn, 1, 1, 2, 1, 1 }, 131 { "Multisystem (0.8.0.2-dual) joystick", db9_multi_btn, 1, 2, 2, 1, 1 }, 132 { "Amiga CD-32 pad", db9_cd32_btn, 7, 1, 2, 1, 1 }, 133 { "Saturn dpp", db9_cd32_btn, 9, 6, 7, 0, 0 }, 134 { "Saturn dpp dual", db9_cd32_btn, 9, 12, 7, 0, 0 }, 135 }; 136 137 /* 138 * Saturn controllers 139 */ 140 #define DB9_SATURN_DELAY 300 141 static const int db9_saturn_byte[] = { 1, 1, 1, 2, 2, 2, 2, 2, 1 }; 142 static const unsigned char db9_saturn_mask[] = { 0x04, 0x01, 0x02, 0x40, 0x20, 0x10, 0x08, 0x80, 0x08 }; 143 144 /* 145 * db9_saturn_write_sub() writes 2 bit data. 146 */ 147 static void db9_saturn_write_sub(struct parport *port, int type, unsigned char data, int powered, int pwr_sub) 148 { 149 unsigned char c; 150 151 switch (type) { 152 case 1: /* DPP1 */ 153 c = 0x80 | 0x30 | (powered ? 0x08 : 0) | (pwr_sub ? 0x04 : 0) | data; 154 parport_write_data(port, c); 155 break; 156 case 2: /* DPP2 */ 157 c = 0x40 | data << 4 | (powered ? 0x08 : 0) | (pwr_sub ? 0x04 : 0) | 0x03; 158 parport_write_data(port, c); 159 break; 160 case 0: /* DB9 */ 161 c = ((((data & 2) ? 2 : 0) | ((data & 1) ? 4 : 0)) ^ 0x02) | !powered; 162 parport_write_control(port, c); 163 break; 164 } 165 } 166 167 /* 168 * gc_saturn_read_sub() reads 4 bit data. 169 */ 170 static unsigned char db9_saturn_read_sub(struct parport *port, int type) 171 { 172 unsigned char data; 173 174 if (type) { 175 /* DPP */ 176 data = parport_read_status(port) ^ 0x80; 177 return (data & 0x80 ? 1 : 0) | (data & 0x40 ? 2 : 0) 178 | (data & 0x20 ? 4 : 0) | (data & 0x10 ? 8 : 0); 179 } else { 180 /* DB9 */ 181 data = parport_read_data(port) & 0x0f; 182 return (data & 0x8 ? 1 : 0) | (data & 0x4 ? 2 : 0) 183 | (data & 0x2 ? 4 : 0) | (data & 0x1 ? 8 : 0); 184 } 185 } 186 187 /* 188 * db9_saturn_read_analog() sends clock and reads 8 bit data. 189 */ 190 static unsigned char db9_saturn_read_analog(struct parport *port, int type, int powered) 191 { 192 unsigned char data; 193 194 db9_saturn_write_sub(port, type, 0, powered, 0); 195 udelay(DB9_SATURN_DELAY); 196 data = db9_saturn_read_sub(port, type) << 4; 197 db9_saturn_write_sub(port, type, 2, powered, 0); 198 udelay(DB9_SATURN_DELAY); 199 data |= db9_saturn_read_sub(port, type); 200 return data; 201 } 202 203 /* 204 * db9_saturn_read_packet() reads whole saturn packet at connector 205 * and returns device identifier code. 206 */ 207 static unsigned char db9_saturn_read_packet(struct parport *port, unsigned char *data, int type, int powered) 208 { 209 int i, j; 210 unsigned char tmp; 211 212 db9_saturn_write_sub(port, type, 3, powered, 0); 213 data[0] = db9_saturn_read_sub(port, type); 214 switch (data[0] & 0x0f) { 215 case 0xf: 216 /* 1111 no pad */ 217 return data[0] = 0xff; 218 case 0x4: case 0x4 | 0x8: 219 /* ?100 : digital controller */ 220 db9_saturn_write_sub(port, type, 0, powered, 1); 221 data[2] = db9_saturn_read_sub(port, type) << 4; 222 db9_saturn_write_sub(port, type, 2, powered, 1); 223 data[1] = db9_saturn_read_sub(port, type) << 4; 224 db9_saturn_write_sub(port, type, 1, powered, 1); 225 data[1] |= db9_saturn_read_sub(port, type); 226 db9_saturn_write_sub(port, type, 3, powered, 1); 227 /* data[2] |= db9_saturn_read_sub(port, type); */ 228 data[2] |= data[0]; 229 return data[0] = 0x02; 230 case 0x1: 231 /* 0001 : analog controller or multitap */ 232 db9_saturn_write_sub(port, type, 2, powered, 0); 233 udelay(DB9_SATURN_DELAY); 234 data[0] = db9_saturn_read_analog(port, type, powered); 235 if (data[0] != 0x41) { 236 /* read analog controller */ 237 for (i = 0; i < (data[0] & 0x0f); i++) 238 data[i + 1] = db9_saturn_read_analog(port, type, powered); 239 db9_saturn_write_sub(port, type, 3, powered, 0); 240 return data[0]; 241 } else { 242 /* read multitap */ 243 if (db9_saturn_read_analog(port, type, powered) != 0x60) 244 return data[0] = 0xff; 245 for (i = 0; i < 60; i += 10) { 246 data[i] = db9_saturn_read_analog(port, type, powered); 247 if (data[i] != 0xff) 248 /* read each pad */ 249 for (j = 0; j < (data[i] & 0x0f); j++) 250 data[i + j + 1] = db9_saturn_read_analog(port, type, powered); 251 } 252 db9_saturn_write_sub(port, type, 3, powered, 0); 253 return 0x41; 254 } 255 case 0x0: 256 /* 0000 : mouse */ 257 db9_saturn_write_sub(port, type, 2, powered, 0); 258 udelay(DB9_SATURN_DELAY); 259 tmp = db9_saturn_read_analog(port, type, powered); 260 if (tmp == 0xff) { 261 for (i = 0; i < 3; i++) 262 data[i + 1] = db9_saturn_read_analog(port, type, powered); 263 db9_saturn_write_sub(port, type, 3, powered, 0); 264 return data[0] = 0xe3; 265 } 266 default: 267 return data[0]; 268 } 269 } 270 271 /* 272 * db9_saturn_report() analyzes packet and reports. 273 */ 274 static int db9_saturn_report(unsigned char id, unsigned char data[60], struct input_dev *devs[], int n, int max_pads) 275 { 276 struct input_dev *dev; 277 int tmp, i, j; 278 279 tmp = (id == 0x41) ? 60 : 10; 280 for (j = 0; j < tmp && n < max_pads; j += 10, n++) { 281 dev = devs[n]; 282 switch (data[j]) { 283 case 0x16: /* multi controller (analog 4 axis) */ 284 input_report_abs(dev, db9_abs[5], data[j + 6]); 285 case 0x15: /* mission stick (analog 3 axis) */ 286 input_report_abs(dev, db9_abs[3], data[j + 4]); 287 input_report_abs(dev, db9_abs[4], data[j + 5]); 288 case 0x13: /* racing controller (analog 1 axis) */ 289 input_report_abs(dev, db9_abs[2], data[j + 3]); 290 case 0x34: /* saturn keyboard (udlr ZXC ASD QE Esc) */ 291 case 0x02: /* digital pad (digital 2 axis + buttons) */ 292 input_report_abs(dev, db9_abs[0], !(data[j + 1] & 128) - !(data[j + 1] & 64)); 293 input_report_abs(dev, db9_abs[1], !(data[j + 1] & 32) - !(data[j + 1] & 16)); 294 for (i = 0; i < 9; i++) 295 input_report_key(dev, db9_cd32_btn[i], ~data[j + db9_saturn_byte[i]] & db9_saturn_mask[i]); 296 break; 297 case 0x19: /* mission stick x2 (analog 6 axis + buttons) */ 298 input_report_abs(dev, db9_abs[0], !(data[j + 1] & 128) - !(data[j + 1] & 64)); 299 input_report_abs(dev, db9_abs[1], !(data[j + 1] & 32) - !(data[j + 1] & 16)); 300 for (i = 0; i < 9; i++) 301 input_report_key(dev, db9_cd32_btn[i], ~data[j + db9_saturn_byte[i]] & db9_saturn_mask[i]); 302 input_report_abs(dev, db9_abs[2], data[j + 3]); 303 input_report_abs(dev, db9_abs[3], data[j + 4]); 304 input_report_abs(dev, db9_abs[4], data[j + 5]); 305 /* 306 input_report_abs(dev, db9_abs[8], (data[j + 6] & 128 ? 0 : 1) - (data[j + 6] & 64 ? 0 : 1)); 307 input_report_abs(dev, db9_abs[9], (data[j + 6] & 32 ? 0 : 1) - (data[j + 6] & 16 ? 0 : 1)); 308 */ 309 input_report_abs(dev, db9_abs[6], data[j + 7]); 310 input_report_abs(dev, db9_abs[7], data[j + 8]); 311 input_report_abs(dev, db9_abs[5], data[j + 9]); 312 break; 313 case 0xd3: /* sankyo ff (analog 1 axis + stop btn) */ 314 input_report_key(dev, BTN_A, data[j + 3] & 0x80); 315 input_report_abs(dev, db9_abs[2], data[j + 3] & 0x7f); 316 break; 317 case 0xe3: /* shuttle mouse (analog 2 axis + buttons. signed value) */ 318 input_report_key(dev, BTN_START, data[j + 1] & 0x08); 319 input_report_key(dev, BTN_A, data[j + 1] & 0x04); 320 input_report_key(dev, BTN_C, data[j + 1] & 0x02); 321 input_report_key(dev, BTN_B, data[j + 1] & 0x01); 322 input_report_abs(dev, db9_abs[2], data[j + 2] ^ 0x80); 323 input_report_abs(dev, db9_abs[3], (0xff-(data[j + 3] ^ 0x80))+1); /* */ 324 break; 325 case 0xff: 326 default: /* no pad */ 327 input_report_abs(dev, db9_abs[0], 0); 328 input_report_abs(dev, db9_abs[1], 0); 329 for (i = 0; i < 9; i++) 330 input_report_key(dev, db9_cd32_btn[i], 0); 331 break; 332 } 333 } 334 return n; 335 } 336 337 static int db9_saturn(int mode, struct parport *port, struct input_dev *devs[]) 338 { 339 unsigned char id, data[60]; 340 int type, n, max_pads; 341 int tmp, i; 342 343 switch (mode) { 344 case DB9_SATURN_PAD: 345 type = 0; 346 n = 1; 347 break; 348 case DB9_SATURN_DPP: 349 type = 1; 350 n = 1; 351 break; 352 case DB9_SATURN_DPP_2: 353 type = 1; 354 n = 2; 355 break; 356 default: 357 return -1; 358 } 359 max_pads = min(db9_modes[mode].n_pads, DB9_MAX_DEVICES); 360 for (tmp = 0, i = 0; i < n; i++) { 361 id = db9_saturn_read_packet(port, data, type + i, 1); 362 tmp = db9_saturn_report(id, data, devs, tmp, max_pads); 363 } 364 return 0; 365 } 366 367 static void db9_timer(unsigned long private) 368 { 369 struct db9 *db9 = (void *) private; 370 struct parport *port = db9->pd->port; 371 struct input_dev *dev = db9->dev[0]; 372 struct input_dev *dev2 = db9->dev[1]; 373 int data, i; 374 375 switch (db9->mode) { 376 case DB9_MULTI_0802_2: 377 378 data = parport_read_data(port) >> 3; 379 380 input_report_abs(dev2, ABS_X, (data & DB9_RIGHT ? 0 : 1) - (data & DB9_LEFT ? 0 : 1)); 381 input_report_abs(dev2, ABS_Y, (data & DB9_DOWN ? 0 : 1) - (data & DB9_UP ? 0 : 1)); 382 input_report_key(dev2, BTN_TRIGGER, ~data & DB9_FIRE1); 383 384 case DB9_MULTI_0802: 385 386 data = parport_read_status(port) >> 3; 387 388 input_report_abs(dev, ABS_X, (data & DB9_RIGHT ? 0 : 1) - (data & DB9_LEFT ? 0 : 1)); 389 input_report_abs(dev, ABS_Y, (data & DB9_DOWN ? 0 : 1) - (data & DB9_UP ? 0 : 1)); 390 input_report_key(dev, BTN_TRIGGER, data & DB9_FIRE1); 391 break; 392 393 case DB9_MULTI_STICK: 394 395 data = parport_read_data(port); 396 397 input_report_abs(dev, ABS_X, (data & DB9_RIGHT ? 0 : 1) - (data & DB9_LEFT ? 0 : 1)); 398 input_report_abs(dev, ABS_Y, (data & DB9_DOWN ? 0 : 1) - (data & DB9_UP ? 0 : 1)); 399 input_report_key(dev, BTN_TRIGGER, ~data & DB9_FIRE1); 400 break; 401 402 case DB9_MULTI2_STICK: 403 404 data = parport_read_data(port); 405 406 input_report_abs(dev, ABS_X, (data & DB9_RIGHT ? 0 : 1) - (data & DB9_LEFT ? 0 : 1)); 407 input_report_abs(dev, ABS_Y, (data & DB9_DOWN ? 0 : 1) - (data & DB9_UP ? 0 : 1)); 408 input_report_key(dev, BTN_TRIGGER, ~data & DB9_FIRE1); 409 input_report_key(dev, BTN_THUMB, ~data & DB9_FIRE2); 410 break; 411 412 case DB9_GENESIS_PAD: 413 414 parport_write_control(port, DB9_NOSELECT); 415 data = parport_read_data(port); 416 417 input_report_abs(dev, ABS_X, (data & DB9_RIGHT ? 0 : 1) - (data & DB9_LEFT ? 0 : 1)); 418 input_report_abs(dev, ABS_Y, (data & DB9_DOWN ? 0 : 1) - (data & DB9_UP ? 0 : 1)); 419 input_report_key(dev, BTN_B, ~data & DB9_FIRE1); 420 input_report_key(dev, BTN_C, ~data & DB9_FIRE2); 421 422 parport_write_control(port, DB9_NORMAL); 423 data = parport_read_data(port); 424 425 input_report_key(dev, BTN_A, ~data & DB9_FIRE1); 426 input_report_key(dev, BTN_START, ~data & DB9_FIRE2); 427 break; 428 429 case DB9_GENESIS5_PAD: 430 431 parport_write_control(port, DB9_NOSELECT); 432 data = parport_read_data(port); 433 434 input_report_abs(dev, ABS_X, (data & DB9_RIGHT ? 0 : 1) - (data & DB9_LEFT ? 0 : 1)); 435 input_report_abs(dev, ABS_Y, (data & DB9_DOWN ? 0 : 1) - (data & DB9_UP ? 0 : 1)); 436 input_report_key(dev, BTN_B, ~data & DB9_FIRE1); 437 input_report_key(dev, BTN_C, ~data & DB9_FIRE2); 438 439 parport_write_control(port, DB9_NORMAL); 440 data = parport_read_data(port); 441 442 input_report_key(dev, BTN_A, ~data & DB9_FIRE1); 443 input_report_key(dev, BTN_X, ~data & DB9_FIRE2); 444 input_report_key(dev, BTN_Y, ~data & DB9_LEFT); 445 input_report_key(dev, BTN_START, ~data & DB9_RIGHT); 446 break; 447 448 case DB9_GENESIS6_PAD: 449 450 parport_write_control(port, DB9_NOSELECT); /* 1 */ 451 udelay(DB9_GENESIS6_DELAY); 452 data = parport_read_data(port); 453 454 input_report_abs(dev, ABS_X, (data & DB9_RIGHT ? 0 : 1) - (data & DB9_LEFT ? 0 : 1)); 455 input_report_abs(dev, ABS_Y, (data & DB9_DOWN ? 0 : 1) - (data & DB9_UP ? 0 : 1)); 456 input_report_key(dev, BTN_B, ~data & DB9_FIRE1); 457 input_report_key(dev, BTN_C, ~data & DB9_FIRE2); 458 459 parport_write_control(port, DB9_NORMAL); 460 udelay(DB9_GENESIS6_DELAY); 461 data = parport_read_data(port); 462 463 input_report_key(dev, BTN_A, ~data & DB9_FIRE1); 464 input_report_key(dev, BTN_START, ~data & DB9_FIRE2); 465 466 parport_write_control(port, DB9_NOSELECT); /* 2 */ 467 udelay(DB9_GENESIS6_DELAY); 468 parport_write_control(port, DB9_NORMAL); 469 udelay(DB9_GENESIS6_DELAY); 470 parport_write_control(port, DB9_NOSELECT); /* 3 */ 471 udelay(DB9_GENESIS6_DELAY); 472 data=parport_read_data(port); 473 474 input_report_key(dev, BTN_X, ~data & DB9_LEFT); 475 input_report_key(dev, BTN_Y, ~data & DB9_DOWN); 476 input_report_key(dev, BTN_Z, ~data & DB9_UP); 477 input_report_key(dev, BTN_MODE, ~data & DB9_RIGHT); 478 479 parport_write_control(port, DB9_NORMAL); 480 udelay(DB9_GENESIS6_DELAY); 481 parport_write_control(port, DB9_NOSELECT); /* 4 */ 482 udelay(DB9_GENESIS6_DELAY); 483 parport_write_control(port, DB9_NORMAL); 484 break; 485 486 case DB9_SATURN_PAD: 487 case DB9_SATURN_DPP: 488 case DB9_SATURN_DPP_2: 489 490 db9_saturn(db9->mode, port, db9->dev); 491 break; 492 493 case DB9_CD32_PAD: 494 495 data = parport_read_data(port); 496 497 input_report_abs(dev, ABS_X, (data & DB9_RIGHT ? 0 : 1) - (data & DB9_LEFT ? 0 : 1)); 498 input_report_abs(dev, ABS_Y, (data & DB9_DOWN ? 0 : 1) - (data & DB9_UP ? 0 : 1)); 499 500 parport_write_control(port, 0x0a); 501 502 for (i = 0; i < 7; i++) { 503 data = parport_read_data(port); 504 parport_write_control(port, 0x02); 505 parport_write_control(port, 0x0a); 506 input_report_key(dev, db9_cd32_btn[i], ~data & DB9_FIRE2); 507 } 508 509 parport_write_control(port, 0x00); 510 break; 511 } 512 513 input_sync(dev); 514 515 mod_timer(&db9->timer, jiffies + DB9_REFRESH_TIME); 516 } 517 518 static int db9_open(struct input_dev *dev) 519 { 520 struct db9 *db9 = input_get_drvdata(dev); 521 struct parport *port = db9->pd->port; 522 int err; 523 524 err = mutex_lock_interruptible(&db9->mutex); 525 if (err) 526 return err; 527 528 if (!db9->used++) { 529 parport_claim(db9->pd); 530 parport_write_data(port, 0xff); 531 if (db9_modes[db9->mode].reverse) { 532 parport_data_reverse(port); 533 parport_write_control(port, DB9_NORMAL); 534 } 535 mod_timer(&db9->timer, jiffies + DB9_REFRESH_TIME); 536 } 537 538 mutex_unlock(&db9->mutex); 539 return 0; 540 } 541 542 static void db9_close(struct input_dev *dev) 543 { 544 struct db9 *db9 = input_get_drvdata(dev); 545 struct parport *port = db9->pd->port; 546 547 mutex_lock(&db9->mutex); 548 if (!--db9->used) { 549 del_timer_sync(&db9->timer); 550 parport_write_control(port, 0x00); 551 parport_data_forward(port); 552 parport_release(db9->pd); 553 } 554 mutex_unlock(&db9->mutex); 555 } 556 557 static void db9_attach(struct parport *pp) 558 { 559 struct db9 *db9; 560 const struct db9_mode_data *db9_mode; 561 struct pardevice *pd; 562 struct input_dev *input_dev; 563 int i, j, port_idx; 564 int mode; 565 struct pardev_cb db9_parport_cb; 566 567 for (port_idx = 0; port_idx < DB9_MAX_PORTS; port_idx++) { 568 if (db9_cfg[port_idx].nargs == 0 || 569 db9_cfg[port_idx].args[DB9_ARG_PARPORT] < 0) 570 continue; 571 572 if (db9_cfg[port_idx].args[DB9_ARG_PARPORT] == pp->number) 573 break; 574 } 575 576 if (port_idx == DB9_MAX_PORTS) { 577 pr_debug("Not using parport%d.\n", pp->number); 578 return; 579 } 580 581 mode = db9_cfg[port_idx].args[DB9_ARG_MODE]; 582 583 if (mode < 1 || mode >= DB9_MAX_PAD || !db9_modes[mode].n_buttons) { 584 printk(KERN_ERR "db9.c: Bad device type %d\n", mode); 585 return; 586 } 587 588 db9_mode = &db9_modes[mode]; 589 590 if (db9_mode->bidirectional && !(pp->modes & PARPORT_MODE_TRISTATE)) { 591 printk(KERN_ERR "db9.c: specified parport is not bidirectional\n"); 592 return; 593 } 594 595 memset(&db9_parport_cb, 0, sizeof(db9_parport_cb)); 596 db9_parport_cb.flags = PARPORT_FLAG_EXCL; 597 598 pd = parport_register_dev_model(pp, "db9", &db9_parport_cb, port_idx); 599 if (!pd) { 600 printk(KERN_ERR "db9.c: parport busy already - lp.o loaded?\n"); 601 return; 602 } 603 604 db9 = kzalloc(sizeof(struct db9), GFP_KERNEL); 605 if (!db9) 606 goto err_unreg_pardev; 607 608 mutex_init(&db9->mutex); 609 db9->pd = pd; 610 db9->mode = mode; 611 db9->parportno = pp->number; 612 init_timer(&db9->timer); 613 db9->timer.data = (long) db9; 614 db9->timer.function = db9_timer; 615 616 for (i = 0; i < (min(db9_mode->n_pads, DB9_MAX_DEVICES)); i++) { 617 618 db9->dev[i] = input_dev = input_allocate_device(); 619 if (!input_dev) { 620 printk(KERN_ERR "db9.c: Not enough memory for input device\n"); 621 goto err_unreg_devs; 622 } 623 624 snprintf(db9->phys[i], sizeof(db9->phys[i]), 625 "%s/input%d", db9->pd->port->name, i); 626 627 input_dev->name = db9_mode->name; 628 input_dev->phys = db9->phys[i]; 629 input_dev->id.bustype = BUS_PARPORT; 630 input_dev->id.vendor = 0x0002; 631 input_dev->id.product = mode; 632 input_dev->id.version = 0x0100; 633 634 input_set_drvdata(input_dev, db9); 635 636 input_dev->open = db9_open; 637 input_dev->close = db9_close; 638 639 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 640 for (j = 0; j < db9_mode->n_buttons; j++) 641 set_bit(db9_mode->buttons[j], input_dev->keybit); 642 for (j = 0; j < db9_mode->n_axis; j++) { 643 if (j < 2) 644 input_set_abs_params(input_dev, db9_abs[j], -1, 1, 0, 0); 645 else 646 input_set_abs_params(input_dev, db9_abs[j], 1, 255, 0, 0); 647 } 648 649 if (input_register_device(input_dev)) 650 goto err_free_dev; 651 } 652 653 db9_base[port_idx] = db9; 654 return; 655 656 err_free_dev: 657 input_free_device(db9->dev[i]); 658 err_unreg_devs: 659 while (--i >= 0) 660 input_unregister_device(db9->dev[i]); 661 kfree(db9); 662 err_unreg_pardev: 663 parport_unregister_device(pd); 664 } 665 666 static void db9_detach(struct parport *port) 667 { 668 int i; 669 struct db9 *db9; 670 671 for (i = 0; i < DB9_MAX_PORTS; i++) { 672 if (db9_base[i] && db9_base[i]->parportno == port->number) 673 break; 674 } 675 676 if (i == DB9_MAX_PORTS) 677 return; 678 679 db9 = db9_base[i]; 680 db9_base[i] = NULL; 681 682 for (i = 0; i < min(db9_modes[db9->mode].n_pads, DB9_MAX_DEVICES); i++) 683 input_unregister_device(db9->dev[i]); 684 parport_unregister_device(db9->pd); 685 kfree(db9); 686 } 687 688 static struct parport_driver db9_parport_driver = { 689 .name = "db9", 690 .match_port = db9_attach, 691 .detach = db9_detach, 692 .devmodel = true, 693 }; 694 695 static int __init db9_init(void) 696 { 697 int i; 698 int have_dev = 0; 699 700 for (i = 0; i < DB9_MAX_PORTS; i++) { 701 if (db9_cfg[i].nargs == 0 || db9_cfg[i].args[DB9_ARG_PARPORT] < 0) 702 continue; 703 704 if (db9_cfg[i].nargs < 2) { 705 printk(KERN_ERR "db9.c: Device type must be specified.\n"); 706 return -EINVAL; 707 } 708 709 have_dev = 1; 710 } 711 712 if (!have_dev) 713 return -ENODEV; 714 715 return parport_register_driver(&db9_parport_driver); 716 } 717 718 static void __exit db9_exit(void) 719 { 720 parport_unregister_driver(&db9_parport_driver); 721 } 722 723 module_init(db9_init); 724 module_exit(db9_exit); 725