2 * Copyright (c) 1996-2001 Vojtech Pavlik
6 * Analog joystick and gamepad driver for Linux
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 * Should you need to contact me, the author, you can do so either by
25 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
26 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
29 #include <linux/delay.h>
30 #include <linux/kernel.h>
31 #include <linux/module.h>
32 #include <linux/slab.h>
33 #include <linux/bitops.h>
34 #include <linux/init.h>
35 #include <linux/input.h>
36 #include <linux/gameport.h>
37 #include <linux/jiffies.h>
38 #include <linux/timex.h>
39 #include <linux/timekeeping.h>
41 #define DRIVER_DESC "Analog joystick and gamepad driver"
43 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
44 MODULE_DESCRIPTION(DRIVER_DESC
);
45 MODULE_LICENSE("GPL");
47 static bool use_ktime
= true;
48 module_param(use_ktime
, bool, 0400);
49 MODULE_PARM_DESC(use_ktime
, "Use ktime for measuring I/O speed");
55 #define ANALOG_PORTS 16
57 static char *js
[ANALOG_PORTS
];
58 static unsigned int js_nargs
;
59 static int analog_options
[ANALOG_PORTS
];
60 module_param_array_named(map
, js
, charp
, &js_nargs
, 0);
61 MODULE_PARM_DESC(map
, "Describes analog joysticks type/capabilities");
64 * Times, feature definitions.
67 #define ANALOG_RUDDER 0x00004
68 #define ANALOG_THROTTLE 0x00008
69 #define ANALOG_AXES_STD 0x0000f
70 #define ANALOG_BTNS_STD 0x000f0
72 #define ANALOG_BTNS_CHF 0x00100
73 #define ANALOG_HAT1_CHF 0x00200
74 #define ANALOG_HAT2_CHF 0x00400
75 #define ANALOG_HAT_FCS 0x00800
76 #define ANALOG_HATS_ALL 0x00e00
77 #define ANALOG_BTN_TL 0x01000
78 #define ANALOG_BTN_TR 0x02000
79 #define ANALOG_BTN_TL2 0x04000
80 #define ANALOG_BTN_TR2 0x08000
81 #define ANALOG_BTNS_TLR 0x03000
82 #define ANALOG_BTNS_TLR2 0x0c000
83 #define ANALOG_BTNS_GAMEPAD 0x0f000
85 #define ANALOG_HBTN_CHF 0x10000
86 #define ANALOG_ANY_CHF 0x10700
87 #define ANALOG_SAITEK 0x20000
88 #define ANALOG_EXTENSIONS 0x7ff00
89 #define ANALOG_GAMEPAD 0x80000
91 #define ANALOG_MAX_TIME 3 /* 3 ms */
92 #define ANALOG_LOOP_TIME 2000 /* 2 * loop */
93 #define ANALOG_SAITEK_DELAY 200 /* 200 us */
94 #define ANALOG_SAITEK_TIME 2000 /* 2000 us */
95 #define ANALOG_AXIS_TIME 2 /* 2 * refresh */
96 #define ANALOG_INIT_RETRIES 8 /* 8 times */
97 #define ANALOG_FUZZ_BITS 2 /* 2 bit more */
98 #define ANALOG_FUZZ_MAGIC 36 /* 36 u*ms/loop */
100 #define ANALOG_MAX_NAME_LENGTH 128
101 #define ANALOG_MAX_PHYS_LENGTH 32
103 static short analog_axes
[] = { ABS_X
, ABS_Y
, ABS_RUDDER
, ABS_THROTTLE
};
104 static short analog_hats
[] = { ABS_HAT0X
, ABS_HAT0Y
, ABS_HAT1X
, ABS_HAT1Y
, ABS_HAT2X
, ABS_HAT2Y
};
105 static short analog_pads
[] = { BTN_Y
, BTN_Z
, BTN_TL
, BTN_TR
};
106 static short analog_exts
[] = { ANALOG_HAT1_CHF
, ANALOG_HAT2_CHF
, ANALOG_HAT_FCS
};
107 static short analog_pad_btn
[] = { BTN_A
, BTN_B
, BTN_C
, BTN_X
, BTN_TL2
, BTN_TR2
, BTN_SELECT
, BTN_START
, BTN_MODE
, BTN_BASE
};
108 static short analog_joy_btn
[] = { BTN_TRIGGER
, BTN_THUMB
, BTN_TOP
, BTN_TOP2
, BTN_BASE
, BTN_BASE2
,
109 BTN_BASE3
, BTN_BASE4
, BTN_BASE5
, BTN_BASE6
};
111 static unsigned char analog_chf
[] = { 0xf, 0x0, 0x1, 0x9, 0x2, 0x4, 0xc, 0x8, 0x3, 0x5, 0xb, 0x7, 0xd, 0xe, 0xa, 0x6 };
114 struct input_dev
*dev
;
117 char name
[ANALOG_MAX_NAME_LENGTH
];
118 char phys
[ANALOG_MAX_PHYS_LENGTH
];
122 struct gameport
*gameport
;
123 struct analog analog
[2];
144 #include <linux/i8253.h>
146 #define GET_TIME(x) do { if (cpu_has_tsc) rdtscl(x); else x = get_time_pit(); } while (0)
147 #define DELTA(x,y) (cpu_has_tsc ? ((y) - (x)) : ((x) - (y) + ((x) < (y) ? PIT_TICK_RATE / HZ : 0)))
148 #define TIME_NAME (cpu_has_tsc?"TSC":"PIT")
149 static unsigned int get_time_pit(void)
154 raw_spin_lock_irqsave(&i8253_lock
, flags
);
157 count
|= inb_p(0x40) << 8;
158 raw_spin_unlock_irqrestore(&i8253_lock
, flags
);
162 #elif defined(__x86_64__)
163 #define GET_TIME(x) rdtscl(x)
164 #define DELTA(x,y) ((y)-(x))
165 #define TIME_NAME "TSC"
166 #elif defined(__alpha__) || defined(CONFIG_MN10300) || defined(CONFIG_ARM) || defined(CONFIG_ARM64) || defined(CONFIG_TILE)
167 #define GET_TIME(x) do { x = get_cycles(); } while (0)
168 #define DELTA(x,y) ((y)-(x))
169 #define TIME_NAME "get_cycles"
172 static unsigned long analog_faketime
= 0;
173 #define GET_TIME(x) do { x = analog_faketime++; } while(0)
174 #define DELTA(x,y) ((y)-(x))
175 #define TIME_NAME "Unreliable"
176 #warning Precise timer not defined for this architecture.
179 static inline u64
get_time(void)
182 return ktime_get_ns();
190 static inline unsigned int delta(u64 x
, u64 y
)
195 return DELTA((unsigned int)x
, (unsigned int)y
);
199 * analog_decode() decodes analog joystick data and reports input events.
202 static void analog_decode(struct analog
*analog
, int *axes
, int *initial
, int buttons
)
204 struct input_dev
*dev
= analog
->dev
;
207 if (analog
->mask
& ANALOG_HAT_FCS
)
208 for (i
= 0; i
< 4; i
++)
209 if (axes
[3] < ((initial
[3] * ((i
<< 1) + 1)) >> 3)) {
210 buttons
|= 1 << (i
+ 14);
214 for (i
= j
= 0; i
< 6; i
++)
215 if (analog
->mask
& (0x10 << i
))
216 input_report_key(dev
, analog
->buttons
[j
++], (buttons
>> i
) & 1);
218 if (analog
->mask
& ANALOG_HBTN_CHF
)
219 for (i
= 0; i
< 4; i
++)
220 input_report_key(dev
, analog
->buttons
[j
++], (buttons
>> (i
+ 10)) & 1);
222 if (analog
->mask
& ANALOG_BTN_TL
)
223 input_report_key(dev
, analog_pads
[0], axes
[2] < (initial
[2] >> 1));
224 if (analog
->mask
& ANALOG_BTN_TR
)
225 input_report_key(dev
, analog_pads
[1], axes
[3] < (initial
[3] >> 1));
226 if (analog
->mask
& ANALOG_BTN_TL2
)
227 input_report_key(dev
, analog_pads
[2], axes
[2] > (initial
[2] + (initial
[2] >> 1)));
228 if (analog
->mask
& ANALOG_BTN_TR2
)
229 input_report_key(dev
, analog_pads
[3], axes
[3] > (initial
[3] + (initial
[3] >> 1)));
231 for (i
= j
= 0; i
< 4; i
++)
232 if (analog
->mask
& (1 << i
))
233 input_report_abs(dev
, analog_axes
[j
++], axes
[i
]);
235 for (i
= j
= 0; i
< 3; i
++)
236 if (analog
->mask
& analog_exts
[i
]) {
237 input_report_abs(dev
, analog_hats
[j
++],
238 ((buttons
>> ((i
<< 2) + 7)) & 1) - ((buttons
>> ((i
<< 2) + 9)) & 1));
239 input_report_abs(dev
, analog_hats
[j
++],
240 ((buttons
>> ((i
<< 2) + 8)) & 1) - ((buttons
>> ((i
<< 2) + 6)) & 1));
247 * analog_cooked_read() reads analog joystick data.
250 static int analog_cooked_read(struct analog_port
*port
)
252 struct gameport
*gameport
= port
->gameport
;
253 u64 time
[4], start
, loop
, now
;
254 unsigned int loopout
, timeout
;
255 unsigned char data
[4], this, last
;
259 loopout
= (ANALOG_LOOP_TIME
* port
->loop
) / 1000;
260 timeout
= ANALOG_MAX_TIME
* port
->speed
;
262 local_irq_save(flags
);
263 gameport_trigger(gameport
);
265 local_irq_restore(flags
);
276 this = gameport_read(gameport
) & port
->mask
;
278 local_irq_restore(flags
);
280 if ((last
^ this) && (delta(loop
, now
) < loopout
)) {
281 data
[i
] = last
^ this;
286 } while (this && (i
< 4) && (delta(start
, now
) < timeout
));
290 for (--i
; i
>= 0; i
--) {
292 for (j
= 0; j
< 4; j
++)
293 if (data
[i
] & (1 << j
))
294 port
->axes
[j
] = (delta(start
, time
[i
]) << ANALOG_FUZZ_BITS
) / port
->loop
;
297 return -(this != port
->mask
);
300 static int analog_button_read(struct analog_port
*port
, char saitek
, char chf
)
304 int strobe
= gameport_time(port
->gameport
, ANALOG_SAITEK_TIME
);
306 u
= gameport_read(port
->gameport
);
309 port
->buttons
= (~u
>> 4) & 0xf;
315 while ((~u
& 0xf0) && (i
< 16) && t
) {
316 port
->buttons
|= 1 << analog_chf
[(~u
>> 4) & 0xf];
317 if (!saitek
) return 0;
318 udelay(ANALOG_SAITEK_DELAY
);
320 gameport_trigger(port
->gameport
);
321 while (((u
= gameport_read(port
->gameport
)) & port
->mask
) && t
) t
--;
325 return -(!t
|| (i
== 16));
329 * analog_poll() repeatedly polls the Analog joysticks.
332 static void analog_poll(struct gameport
*gameport
)
334 struct analog_port
*port
= gameport_get_drvdata(gameport
);
337 char saitek
= !!(port
->analog
[0].mask
& ANALOG_SAITEK
);
338 char chf
= !!(port
->analog
[0].mask
& ANALOG_ANY_CHF
);
341 port
->bads
-= gameport_cooked_read(port
->gameport
, port
->axes
, &port
->buttons
);
343 port
->buttons
= port
->buttons
? (1 << analog_chf
[port
->buttons
]) : 0;
346 if (!port
->axtime
--) {
347 port
->bads
-= analog_cooked_read(port
);
348 port
->bads
-= analog_button_read(port
, saitek
, chf
);
350 port
->axtime
= ANALOG_AXIS_TIME
- 1;
353 analog_button_read(port
, saitek
, chf
);
357 for (i
= 0; i
< 2; i
++)
358 if (port
->analog
[i
].mask
)
359 analog_decode(port
->analog
+ i
, port
->axes
, port
->initial
, port
->buttons
);
363 * analog_open() is a callback from the input open routine.
366 static int analog_open(struct input_dev
*dev
)
368 struct analog_port
*port
= input_get_drvdata(dev
);
370 gameport_start_polling(port
->gameport
);
375 * analog_close() is a callback from the input close routine.
378 static void analog_close(struct input_dev
*dev
)
380 struct analog_port
*port
= input_get_drvdata(dev
);
382 gameport_stop_polling(port
->gameport
);
386 * analog_calibrate_timer() calibrates the timer and computes loop
387 * and timeout values for a joystick port.
390 static void analog_calibrate_timer(struct analog_port
*port
)
392 struct gameport
*gameport
= port
->gameport
;
393 unsigned int i
, t
, tx
;
398 port
->speed
= 1000000;
400 local_irq_save(flags
);
403 analog_faketime
+= 830;
408 local_irq_restore(flags
);
410 port
->speed
= delta(t1
, t2
) - delta(t2
, t3
);
415 for (i
= 0; i
< 50; i
++) {
416 local_irq_save(flags
);
418 for (t
= 0; t
< 50; t
++) {
419 gameport_read(gameport
);
423 local_irq_restore(flags
);
425 t
= delta(t1
, t2
) - delta(t2
, t3
);
429 port
->loop
= tx
/ 50;
433 * analog_name() constructs a name for an analog joystick.
436 static void analog_name(struct analog
*analog
)
438 snprintf(analog
->name
, sizeof(analog
->name
), "Analog %d-axis %d-button",
439 hweight8(analog
->mask
& ANALOG_AXES_STD
),
440 hweight8(analog
->mask
& ANALOG_BTNS_STD
) + !!(analog
->mask
& ANALOG_BTNS_CHF
) * 2 +
441 hweight16(analog
->mask
& ANALOG_BTNS_GAMEPAD
) + !!(analog
->mask
& ANALOG_HBTN_CHF
) * 4);
443 if (analog
->mask
& ANALOG_HATS_ALL
)
444 snprintf(analog
->name
, sizeof(analog
->name
), "%s %d-hat",
445 analog
->name
, hweight16(analog
->mask
& ANALOG_HATS_ALL
));
447 if (analog
->mask
& ANALOG_HAT_FCS
)
448 strlcat(analog
->name
, " FCS", sizeof(analog
->name
));
449 if (analog
->mask
& ANALOG_ANY_CHF
)
450 strlcat(analog
->name
, (analog
->mask
& ANALOG_SAITEK
) ? " Saitek" : " CHF",
451 sizeof(analog
->name
));
453 strlcat(analog
->name
, (analog
->mask
& ANALOG_GAMEPAD
) ? " gamepad": " joystick",
454 sizeof(analog
->name
));
458 * analog_init_device()
461 static int analog_init_device(struct analog_port
*port
, struct analog
*analog
, int index
)
463 struct input_dev
*input_dev
;
464 int i
, j
, t
, v
, w
, x
, y
, z
;
468 snprintf(analog
->phys
, sizeof(analog
->phys
),
469 "%s/input%d", port
->gameport
->phys
, index
);
470 analog
->buttons
= (analog
->mask
& ANALOG_GAMEPAD
) ? analog_pad_btn
: analog_joy_btn
;
472 analog
->dev
= input_dev
= input_allocate_device();
476 input_dev
->name
= analog
->name
;
477 input_dev
->phys
= analog
->phys
;
478 input_dev
->id
.bustype
= BUS_GAMEPORT
;
479 input_dev
->id
.vendor
= GAMEPORT_ID_VENDOR_ANALOG
;
480 input_dev
->id
.product
= analog
->mask
>> 4;
481 input_dev
->id
.version
= 0x0100;
482 input_dev
->dev
.parent
= &port
->gameport
->dev
;
484 input_set_drvdata(input_dev
, port
);
486 input_dev
->open
= analog_open
;
487 input_dev
->close
= analog_close
;
489 input_dev
->evbit
[0] = BIT_MASK(EV_KEY
) | BIT_MASK(EV_ABS
);
491 for (i
= j
= 0; i
< 4; i
++)
492 if (analog
->mask
& (1 << i
)) {
496 y
= (port
->axes
[0] + port
->axes
[1]) >> 1;
497 z
= y
- port
->axes
[i
];
502 if ((i
== 2 || i
== 3) && (j
== 2 || j
== 3) && (z
> (y
>> 3)))
505 if (analog
->mask
& ANALOG_SAITEK
) {
506 if (i
== 2) x
= port
->axes
[i
];
511 input_set_abs_params(input_dev
, t
, v
, (x
<< 1) - v
, port
->fuzz
, w
);
515 for (i
= j
= 0; i
< 3; i
++)
516 if (analog
->mask
& analog_exts
[i
])
517 for (x
= 0; x
< 2; x
++) {
518 t
= analog_hats
[j
++];
519 input_set_abs_params(input_dev
, t
, -1, 1, 0, 0);
522 for (i
= j
= 0; i
< 4; i
++)
523 if (analog
->mask
& (0x10 << i
))
524 set_bit(analog
->buttons
[j
++], input_dev
->keybit
);
526 if (analog
->mask
& ANALOG_BTNS_CHF
)
527 for (i
= 0; i
< 2; i
++)
528 set_bit(analog
->buttons
[j
++], input_dev
->keybit
);
530 if (analog
->mask
& ANALOG_HBTN_CHF
)
531 for (i
= 0; i
< 4; i
++)
532 set_bit(analog
->buttons
[j
++], input_dev
->keybit
);
534 for (i
= 0; i
< 4; i
++)
535 if (analog
->mask
& (ANALOG_BTN_TL
<< i
))
536 set_bit(analog_pads
[i
], input_dev
->keybit
);
538 analog_decode(analog
, port
->axes
, port
->initial
, port
->buttons
);
540 error
= input_register_device(analog
->dev
);
542 input_free_device(analog
->dev
);
550 * analog_init_devices() sets up device-specific values and registers the input devices.
553 static int analog_init_masks(struct analog_port
*port
)
556 struct analog
*analog
= port
->analog
;
562 if ((port
->mask
& 3) != 3 && port
->mask
!= 0xc) {
563 printk(KERN_WARNING
"analog.c: Unknown joystick device found "
564 "(data=%#x, %s), probably not analog joystick.\n",
565 port
->mask
, port
->gameport
->phys
);
570 i
= analog_options
[0]; /* FIXME !!! - need to specify options for different ports */
572 analog
[0].mask
= i
& 0xfffff;
574 analog
[0].mask
&= ~(ANALOG_AXES_STD
| ANALOG_HAT_FCS
| ANALOG_BTNS_GAMEPAD
)
575 | port
->mask
| ((port
->mask
<< 8) & ANALOG_HAT_FCS
)
576 | ((port
->mask
<< 10) & ANALOG_BTNS_TLR
) | ((port
->mask
<< 12) & ANALOG_BTNS_TLR2
);
578 analog
[0].mask
&= ~(ANALOG_HAT2_CHF
)
579 | ((analog
[0].mask
& ANALOG_HBTN_CHF
) ? 0 : ANALOG_HAT2_CHF
);
581 analog
[0].mask
&= ~(ANALOG_THROTTLE
| ANALOG_BTN_TR
| ANALOG_BTN_TR2
)
582 | ((~analog
[0].mask
& ANALOG_HAT_FCS
) >> 8)
583 | ((~analog
[0].mask
& ANALOG_HAT_FCS
) << 2)
584 | ((~analog
[0].mask
& ANALOG_HAT_FCS
) << 4);
586 analog
[0].mask
&= ~(ANALOG_THROTTLE
| ANALOG_RUDDER
)
587 | (((~analog
[0].mask
& ANALOG_BTNS_TLR
) >> 10)
588 & ((~analog
[0].mask
& ANALOG_BTNS_TLR2
) >> 12));
590 analog
[1].mask
= ((i
>> 20) & 0xff) | ((i
>> 12) & 0xf0000);
592 analog
[1].mask
&= (analog
[0].mask
& ANALOG_EXTENSIONS
) ? ANALOG_GAMEPAD
593 : (((ANALOG_BTNS_STD
| port
->mask
) & ~analog
[0].mask
) | ANALOG_GAMEPAD
);
597 for (i
= 0; i
< 4; i
++) max
[i
] = port
->axes
[i
] << 1;
599 if ((analog
[0].mask
& 0x7) == 0x7) max
[2] = (max
[0] + max
[1]) >> 1;
600 if ((analog
[0].mask
& 0xb) == 0xb) max
[3] = (max
[0] + max
[1]) >> 1;
601 if ((analog
[0].mask
& ANALOG_BTN_TL
) && !(analog
[0].mask
& ANALOG_BTN_TL2
)) max
[2] >>= 1;
602 if ((analog
[0].mask
& ANALOG_BTN_TR
) && !(analog
[0].mask
& ANALOG_BTN_TR2
)) max
[3] >>= 1;
603 if ((analog
[0].mask
& ANALOG_HAT_FCS
)) max
[3] >>= 1;
605 gameport_calibrate(port
->gameport
, port
->axes
, max
);
608 for (i
= 0; i
< 4; i
++)
609 port
->initial
[i
] = port
->axes
[i
];
611 return -!(analog
[0].mask
|| analog
[1].mask
);
614 static int analog_init_port(struct gameport
*gameport
, struct gameport_driver
*drv
, struct analog_port
*port
)
618 port
->gameport
= gameport
;
620 gameport_set_drvdata(gameport
, port
);
622 if (!gameport_open(gameport
, drv
, GAMEPORT_MODE_RAW
)) {
624 analog_calibrate_timer(port
);
626 gameport_trigger(gameport
);
627 t
= gameport_read(gameport
);
628 msleep(ANALOG_MAX_TIME
);
629 port
->mask
= (gameport_read(gameport
) ^ t
) & t
& 0xf;
630 port
->fuzz
= (port
->speed
* ANALOG_FUZZ_MAGIC
) / port
->loop
/ 1000 + ANALOG_FUZZ_BITS
;
632 for (i
= 0; i
< ANALOG_INIT_RETRIES
; i
++) {
633 if (!analog_cooked_read(port
))
635 msleep(ANALOG_MAX_TIME
);
640 msleep(ANALOG_MAX_TIME
);
641 t
= gameport_time(gameport
, ANALOG_MAX_TIME
* 1000);
642 gameport_trigger(gameport
);
643 while ((gameport_read(port
->gameport
) & port
->mask
) && (u
< t
))
645 udelay(ANALOG_SAITEK_DELAY
);
646 t
= gameport_time(gameport
, ANALOG_SAITEK_TIME
);
647 gameport_trigger(gameport
);
648 while ((gameport_read(port
->gameport
) & port
->mask
) && (v
< t
))
651 if (v
< (u
>> 1)) { /* FIXME - more than one port */
652 analog_options
[0] |= /* FIXME - more than one port */
653 ANALOG_SAITEK
| ANALOG_BTNS_CHF
| ANALOG_HBTN_CHF
| ANALOG_HAT1_CHF
;
657 gameport_close(gameport
);
660 if (!gameport_open(gameport
, drv
, GAMEPORT_MODE_COOKED
)) {
662 for (i
= 0; i
< ANALOG_INIT_RETRIES
; i
++)
663 if (!gameport_cooked_read(gameport
, port
->axes
, &port
->buttons
))
665 for (i
= 0; i
< 4; i
++)
666 if (port
->axes
[i
] != -1)
667 port
->mask
|= 1 << i
;
669 port
->fuzz
= gameport
->fuzz
;
674 return gameport_open(gameport
, drv
, GAMEPORT_MODE_RAW
);
677 static int analog_connect(struct gameport
*gameport
, struct gameport_driver
*drv
)
679 struct analog_port
*port
;
683 if (!(port
= kzalloc(sizeof(struct analog_port
), GFP_KERNEL
)))
686 err
= analog_init_port(gameport
, drv
, port
);
690 err
= analog_init_masks(port
);
694 gameport_set_poll_handler(gameport
, analog_poll
);
695 gameport_set_poll_interval(gameport
, 10);
697 for (i
= 0; i
< 2; i
++)
698 if (port
->analog
[i
].mask
) {
699 err
= analog_init_device(port
, port
->analog
+ i
, i
);
706 fail3
: while (--i
>= 0)
707 if (port
->analog
[i
].mask
)
708 input_unregister_device(port
->analog
[i
].dev
);
709 fail2
: gameport_close(gameport
);
710 fail1
: gameport_set_drvdata(gameport
, NULL
);
715 static void analog_disconnect(struct gameport
*gameport
)
717 struct analog_port
*port
= gameport_get_drvdata(gameport
);
720 for (i
= 0; i
< 2; i
++)
721 if (port
->analog
[i
].mask
)
722 input_unregister_device(port
->analog
[i
].dev
);
723 gameport_close(gameport
);
724 gameport_set_drvdata(gameport
, NULL
);
725 printk(KERN_INFO
"analog.c: %d out of %d reads (%d%%) on %s failed\n",
726 port
->bads
, port
->reads
, port
->reads
? (port
->bads
* 100 / port
->reads
) : 0,
727 port
->gameport
->phys
);
731 struct analog_types
{
736 static struct analog_types analog_types
[] = {
737 { "none", 0x00000000 },
738 { "auto", 0x000000ff },
739 { "2btn", 0x0000003f },
740 { "y-joy", 0x0cc00033 },
741 { "y-pad", 0x8cc80033 },
742 { "fcs", 0x000008f7 },
743 { "chf", 0x000002ff },
744 { "fullchf", 0x000007ff },
745 { "gamepad", 0x000830f3 },
746 { "gamepad8", 0x0008f0f3 },
750 static void analog_parse_options(void)
755 for (i
= 0; i
< js_nargs
; i
++) {
757 for (j
= 0; analog_types
[j
].name
; j
++)
758 if (!strcmp(analog_types
[j
].name
, js
[i
])) {
759 analog_options
[i
] = analog_types
[j
].value
;
762 if (analog_types
[j
].name
) continue;
764 analog_options
[i
] = simple_strtoul(js
[i
], &end
, 0);
765 if (end
!= js
[i
]) continue;
767 analog_options
[i
] = 0xff;
768 if (!strlen(js
[i
])) continue;
770 printk(KERN_WARNING
"analog.c: Bad config for port %d - \"%s\"\n", i
, js
[i
]);
773 for (; i
< ANALOG_PORTS
; i
++)
774 analog_options
[i
] = 0xff;
778 * The gameport device structure.
781 static struct gameport_driver analog_drv
= {
785 .description
= DRIVER_DESC
,
786 .connect
= analog_connect
,
787 .disconnect
= analog_disconnect
,
790 static int __init
analog_init(void)
792 analog_parse_options();
793 return gameport_register_driver(&analog_drv
);
796 static void __exit
analog_exit(void)
798 gameport_unregister_driver(&analog_drv
);
801 module_init(analog_init
);
802 module_exit(analog_exit
);