Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * NES, SNES, N64, MultiSystem, PSX gamepad driver for Linux | |
3 | * | |
ab0c3443 DT |
4 | * Copyright (c) 1999-2004 Vojtech Pavlik <vojtech@suse.cz> |
5 | * Copyright (c) 2004 Peter Nelson <rufus-kernel@hackish.org> | |
1da177e4 LT |
6 | * |
7 | * Based on the work of: | |
ab0c3443 DT |
8 | * Andree Borrmann John Dahlstrom |
9 | * David Kuder Nathan Hand | |
b157d55e | 10 | * Raphael Assenat |
1da177e4 LT |
11 | */ |
12 | ||
13 | /* | |
14 | * This program is free software; you can redistribute it and/or modify | |
15 | * it under the terms of the GNU General Public License as published by | |
16 | * the Free Software Foundation; either version 2 of the License, or | |
17 | * (at your option) any later version. | |
18 | * | |
19 | * This program is distributed in the hope that it will be useful, | |
20 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
21 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
22 | * GNU General Public License for more details. | |
23 | * | |
24 | * You should have received a copy of the GNU General Public License | |
25 | * along with this program; if not, write to the Free Software | |
26 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
27 | * | |
28 | * Should you need to contact me, the author, you can do so either by | |
29 | * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail: | |
30 | * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic | |
31 | */ | |
32 | ||
a1e12747 DT |
33 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
34 | ||
1da177e4 LT |
35 | #include <linux/kernel.h> |
36 | #include <linux/delay.h> | |
37 | #include <linux/module.h> | |
1da177e4 LT |
38 | #include <linux/init.h> |
39 | #include <linux/parport.h> | |
40 | #include <linux/input.h> | |
72ba9f0c | 41 | #include <linux/mutex.h> |
5a0e3ad6 | 42 | #include <linux/slab.h> |
1da177e4 LT |
43 | |
44 | MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>"); | |
45 | MODULE_DESCRIPTION("NES, SNES, N64, MultiSystem, PSX gamepad driver"); | |
46 | MODULE_LICENSE("GPL"); | |
47 | ||
17dd3f0f DT |
48 | #define GC_MAX_PORTS 3 |
49 | #define GC_MAX_DEVICES 5 | |
1da177e4 | 50 | |
17dd3f0f DT |
51 | struct gc_config { |
52 | int args[GC_MAX_DEVICES + 1]; | |
78167236 | 53 | unsigned int nargs; |
17dd3f0f DT |
54 | }; |
55 | ||
78167236 | 56 | static struct gc_config gc_cfg[GC_MAX_PORTS] __initdata; |
1da177e4 | 57 | |
78167236 | 58 | module_param_array_named(map, gc_cfg[0].args, int, &gc_cfg[0].nargs, 0); |
17dd3f0f | 59 | MODULE_PARM_DESC(map, "Describes first set of devices (<parport#>,<pad1>,<pad2>,..<pad5>)"); |
78167236 | 60 | module_param_array_named(map2, gc_cfg[1].args, int, &gc_cfg[1].nargs, 0); |
17dd3f0f | 61 | MODULE_PARM_DESC(map2, "Describes second set of devices"); |
78167236 | 62 | module_param_array_named(map3, gc_cfg[2].args, int, &gc_cfg[2].nargs, 0); |
17dd3f0f | 63 | MODULE_PARM_DESC(map3, "Describes third set of devices"); |
1da177e4 | 64 | |
1da177e4 LT |
65 | /* see also gs_psx_delay parameter in PSX support section */ |
66 | ||
0995174d DT |
67 | enum gc_type { |
68 | GC_NONE = 0, | |
69 | GC_SNES, | |
70 | GC_NES, | |
71 | GC_NES4, | |
72 | GC_MULTI, | |
73 | GC_MULTI2, | |
74 | GC_N64, | |
75 | GC_PSX, | |
76 | GC_DDR, | |
77 | GC_SNESMOUSE, | |
78 | GC_MAX | |
79 | }; | |
1da177e4 LT |
80 | |
81 | #define GC_REFRESH_TIME HZ/100 | |
82 | ||
0995174d DT |
83 | struct gc_pad { |
84 | struct input_dev *dev; | |
85 | enum gc_type type; | |
86 | char phys[32]; | |
87 | }; | |
88 | ||
1da177e4 LT |
89 | struct gc { |
90 | struct pardevice *pd; | |
0995174d | 91 | struct gc_pad pads[GC_MAX_DEVICES]; |
1da177e4 | 92 | struct timer_list timer; |
0995174d | 93 | int pad_count[GC_MAX]; |
1da177e4 | 94 | int used; |
72ba9f0c | 95 | struct mutex mutex; |
1da177e4 LT |
96 | }; |
97 | ||
7aa9e0e8 SM |
98 | struct gc_subdev { |
99 | unsigned int idx; | |
100 | }; | |
101 | ||
1da177e4 LT |
102 | static struct gc *gc_base[3]; |
103 | ||
af930d64 | 104 | static const int gc_status_bit[] = { 0x40, 0x80, 0x20, 0x10, 0x08 }; |
1da177e4 | 105 | |
af930d64 | 106 | static const char *gc_names[] = { |
d38fcb96 DT |
107 | NULL, "SNES pad", "NES pad", "NES FourPort", "Multisystem joystick", |
108 | "Multisystem 2-button joystick", "N64 controller", "PSX controller", | |
109 | "PSX DDR controller", "SNES mouse" | |
110 | }; | |
111 | ||
1da177e4 LT |
112 | /* |
113 | * N64 support. | |
114 | */ | |
115 | ||
af930d64 DT |
116 | static const unsigned char gc_n64_bytes[] = { 0, 1, 13, 15, 14, 12, 10, 11, 2, 3 }; |
117 | static const short gc_n64_btn[] = { | |
d38fcb96 DT |
118 | BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, |
119 | BTN_TL, BTN_TR, BTN_TRIGGER, BTN_START | |
120 | }; | |
1da177e4 LT |
121 | |
122 | #define GC_N64_LENGTH 32 /* N64 bit length, not including stop bit */ | |
7aa9e0e8 SM |
123 | #define GC_N64_STOP_LENGTH 5 /* Length of encoded stop bit */ |
124 | #define GC_N64_CMD_00 0x11111111UL | |
125 | #define GC_N64_CMD_01 0xd1111111UL | |
126 | #define GC_N64_CMD_03 0xdd111111UL | |
127 | #define GC_N64_CMD_1b 0xdd1dd111UL | |
128 | #define GC_N64_CMD_c0 0x111111ddUL | |
129 | #define GC_N64_CMD_80 0x1111111dUL | |
130 | #define GC_N64_STOP_BIT 0x1d /* Encoded stop bit */ | |
131 | #define GC_N64_REQUEST_DATA GC_N64_CMD_01 /* the request data command */ | |
1da177e4 | 132 | #define GC_N64_DELAY 133 /* delay between transmit request, and response ready (us) */ |
1da177e4 LT |
133 | #define GC_N64_DWS 3 /* delay between write segments (required for sound playback because of ISA DMA) */ |
134 | /* GC_N64_DWS > 24 is known to fail */ | |
135 | #define GC_N64_POWER_W 0xe2 /* power during write (transmit request) */ | |
136 | #define GC_N64_POWER_R 0xfd /* power during read */ | |
137 | #define GC_N64_OUT 0x1d /* output bits to the 4 pads */ | |
138 | /* Reading the main axes of any N64 pad is known to fail if the corresponding bit */ | |
139 | /* in GC_N64_OUT is pulled low on the output port (by any routine) for more */ | |
140 | /* than 123 us */ | |
141 | #define GC_N64_CLOCK 0x02 /* clock bits for read */ | |
142 | ||
7aa9e0e8 SM |
143 | /* |
144 | * Used for rumble code. | |
145 | */ | |
146 | ||
147 | /* Send encoded command */ | |
148 | static void gc_n64_send_command(struct gc *gc, unsigned long cmd, | |
149 | unsigned char target) | |
150 | { | |
151 | struct parport *port = gc->pd->port; | |
152 | int i; | |
153 | ||
154 | for (i = 0; i < GC_N64_LENGTH; i++) { | |
155 | unsigned char data = (cmd >> i) & 1 ? target : 0; | |
156 | parport_write_data(port, GC_N64_POWER_W | data); | |
157 | udelay(GC_N64_DWS); | |
158 | } | |
159 | } | |
160 | ||
161 | /* Send stop bit */ | |
162 | static void gc_n64_send_stop_bit(struct gc *gc, unsigned char target) | |
163 | { | |
164 | struct parport *port = gc->pd->port; | |
165 | int i; | |
166 | ||
167 | for (i = 0; i < GC_N64_STOP_LENGTH; i++) { | |
168 | unsigned char data = (GC_N64_STOP_BIT >> i) & 1 ? target : 0; | |
169 | parport_write_data(port, GC_N64_POWER_W | data); | |
170 | udelay(GC_N64_DWS); | |
171 | } | |
172 | } | |
173 | ||
1da177e4 LT |
174 | /* |
175 | * gc_n64_read_packet() reads an N64 packet. | |
d38fcb96 DT |
176 | * Each pad uses one bit per byte. So all pads connected to this port |
177 | * are read in parallel. | |
1da177e4 LT |
178 | */ |
179 | ||
180 | static void gc_n64_read_packet(struct gc *gc, unsigned char *data) | |
181 | { | |
182 | int i; | |
183 | unsigned long flags; | |
184 | ||
185 | /* | |
186 | * Request the pad to transmit data | |
187 | */ | |
188 | ||
189 | local_irq_save(flags); | |
7aa9e0e8 SM |
190 | gc_n64_send_command(gc, GC_N64_REQUEST_DATA, GC_N64_OUT); |
191 | gc_n64_send_stop_bit(gc, GC_N64_OUT); | |
1da177e4 LT |
192 | local_irq_restore(flags); |
193 | ||
194 | /* | |
d38fcb96 DT |
195 | * Wait for the pad response to be loaded into the 33-bit register |
196 | * of the adapter. | |
1da177e4 LT |
197 | */ |
198 | ||
199 | udelay(GC_N64_DELAY); | |
200 | ||
201 | /* | |
202 | * Grab data (ignoring the last bit, which is a stop bit) | |
203 | */ | |
204 | ||
205 | for (i = 0; i < GC_N64_LENGTH; i++) { | |
206 | parport_write_data(gc->pd->port, GC_N64_POWER_R); | |
7aa9e0e8 | 207 | udelay(2); |
1da177e4 LT |
208 | data[i] = parport_read_status(gc->pd->port); |
209 | parport_write_data(gc->pd->port, GC_N64_POWER_R | GC_N64_CLOCK); | |
210 | } | |
211 | ||
212 | /* | |
d38fcb96 DT |
213 | * We must wait 200 ms here for the controller to reinitialize before |
214 | * the next read request. No worries as long as gc_read is polled less | |
215 | * frequently than this. | |
1da177e4 LT |
216 | */ |
217 | ||
218 | } | |
219 | ||
c7fd018d DT |
220 | static void gc_n64_process_packet(struct gc *gc) |
221 | { | |
222 | unsigned char data[GC_N64_LENGTH]; | |
c7fd018d DT |
223 | struct input_dev *dev; |
224 | int i, j, s; | |
d38fcb96 | 225 | signed char x, y; |
c7fd018d DT |
226 | |
227 | gc_n64_read_packet(gc, data); | |
228 | ||
229 | for (i = 0; i < GC_MAX_DEVICES; i++) { | |
230 | ||
0995174d | 231 | if (gc->pads[i].type != GC_N64) |
c7fd018d DT |
232 | continue; |
233 | ||
0995174d | 234 | dev = gc->pads[i].dev; |
c7fd018d DT |
235 | s = gc_status_bit[i]; |
236 | ||
0995174d | 237 | if (s & ~(data[8] | data[9])) { |
c7fd018d | 238 | |
d38fcb96 | 239 | x = y = 0; |
c7fd018d DT |
240 | |
241 | for (j = 0; j < 8; j++) { | |
242 | if (data[23 - j] & s) | |
d38fcb96 | 243 | x |= 1 << j; |
c7fd018d | 244 | if (data[31 - j] & s) |
d38fcb96 | 245 | y |= 1 << j; |
c7fd018d DT |
246 | } |
247 | ||
d38fcb96 DT |
248 | input_report_abs(dev, ABS_X, x); |
249 | input_report_abs(dev, ABS_Y, -y); | |
c7fd018d | 250 | |
d38fcb96 DT |
251 | input_report_abs(dev, ABS_HAT0X, |
252 | !(s & data[6]) - !(s & data[7])); | |
253 | input_report_abs(dev, ABS_HAT0Y, | |
254 | !(s & data[4]) - !(s & data[5])); | |
c7fd018d DT |
255 | |
256 | for (j = 0; j < 10; j++) | |
d38fcb96 DT |
257 | input_report_key(dev, gc_n64_btn[j], |
258 | s & data[gc_n64_bytes[j]]); | |
c7fd018d DT |
259 | |
260 | input_sync(dev); | |
261 | } | |
262 | } | |
263 | } | |
264 | ||
7aa9e0e8 SM |
265 | static int gc_n64_play_effect(struct input_dev *dev, void *data, |
266 | struct ff_effect *effect) | |
267 | { | |
268 | int i; | |
269 | unsigned long flags; | |
270 | struct gc *gc = input_get_drvdata(dev); | |
271 | struct gc_subdev *sdev = data; | |
272 | unsigned char target = 1 << sdev->idx; /* select desired pin */ | |
273 | ||
274 | if (effect->type == FF_RUMBLE) { | |
275 | struct ff_rumble_effect *rumble = &effect->u.rumble; | |
276 | unsigned int cmd = | |
277 | rumble->strong_magnitude || rumble->weak_magnitude ? | |
278 | GC_N64_CMD_01 : GC_N64_CMD_00; | |
279 | ||
280 | local_irq_save(flags); | |
281 | ||
282 | /* Init Rumble - 0x03, 0x80, 0x01, (34)0x80 */ | |
283 | gc_n64_send_command(gc, GC_N64_CMD_03, target); | |
284 | gc_n64_send_command(gc, GC_N64_CMD_80, target); | |
285 | gc_n64_send_command(gc, GC_N64_CMD_01, target); | |
286 | for (i = 0; i < 32; i++) | |
287 | gc_n64_send_command(gc, GC_N64_CMD_80, target); | |
288 | gc_n64_send_stop_bit(gc, target); | |
289 | ||
290 | udelay(GC_N64_DELAY); | |
291 | ||
292 | /* Now start or stop it - 0x03, 0xc0, 0zx1b, (32)0x01/0x00 */ | |
293 | gc_n64_send_command(gc, GC_N64_CMD_03, target); | |
294 | gc_n64_send_command(gc, GC_N64_CMD_c0, target); | |
295 | gc_n64_send_command(gc, GC_N64_CMD_1b, target); | |
296 | for (i = 0; i < 32; i++) | |
297 | gc_n64_send_command(gc, cmd, target); | |
298 | gc_n64_send_stop_bit(gc, target); | |
299 | ||
300 | local_irq_restore(flags); | |
301 | ||
302 | } | |
303 | ||
304 | return 0; | |
305 | } | |
306 | ||
307 | static int __init gc_n64_init_ff(struct input_dev *dev, int i) | |
308 | { | |
309 | struct gc_subdev *sdev; | |
310 | int err; | |
311 | ||
312 | sdev = kmalloc(sizeof(*sdev), GFP_KERNEL); | |
313 | if (!sdev) | |
314 | return -ENOMEM; | |
315 | ||
316 | sdev->idx = i; | |
317 | ||
318 | input_set_capability(dev, EV_FF, FF_RUMBLE); | |
319 | ||
320 | err = input_ff_create_memless(dev, sdev, gc_n64_play_effect); | |
321 | if (err) { | |
322 | kfree(sdev); | |
323 | return err; | |
324 | } | |
325 | ||
326 | return 0; | |
327 | } | |
328 | ||
1da177e4 LT |
329 | /* |
330 | * NES/SNES support. | |
331 | */ | |
332 | ||
b157d55e RA |
333 | #define GC_NES_DELAY 6 /* Delay between bits - 6us */ |
334 | #define GC_NES_LENGTH 8 /* The NES pads use 8 bits of data */ | |
335 | #define GC_SNES_LENGTH 12 /* The SNES true length is 16, but the | |
336 | last 4 bits are unused */ | |
337 | #define GC_SNESMOUSE_LENGTH 32 /* The SNES mouse uses 32 bits, the first | |
338 | 16 bits are equivalent to a gamepad */ | |
1da177e4 LT |
339 | |
340 | #define GC_NES_POWER 0xfc | |
341 | #define GC_NES_CLOCK 0x01 | |
342 | #define GC_NES_LATCH 0x02 | |
343 | ||
af930d64 DT |
344 | static const unsigned char gc_nes_bytes[] = { 0, 1, 2, 3 }; |
345 | static const unsigned char gc_snes_bytes[] = { 8, 0, 2, 3, 9, 1, 10, 11 }; | |
346 | static const short gc_snes_btn[] = { | |
d38fcb96 DT |
347 | BTN_A, BTN_B, BTN_SELECT, BTN_START, BTN_X, BTN_Y, BTN_TL, BTN_TR |
348 | }; | |
1da177e4 LT |
349 | |
350 | /* | |
351 | * gc_nes_read_packet() reads a NES/SNES packet. | |
352 | * Each pad uses one bit per byte. So all pads connected to | |
353 | * this port are read in parallel. | |
354 | */ | |
355 | ||
356 | static void gc_nes_read_packet(struct gc *gc, int length, unsigned char *data) | |
357 | { | |
358 | int i; | |
359 | ||
360 | parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK | GC_NES_LATCH); | |
361 | udelay(GC_NES_DELAY * 2); | |
362 | parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK); | |
363 | ||
364 | for (i = 0; i < length; i++) { | |
365 | udelay(GC_NES_DELAY); | |
366 | parport_write_data(gc->pd->port, GC_NES_POWER); | |
367 | data[i] = parport_read_status(gc->pd->port) ^ 0x7f; | |
368 | udelay(GC_NES_DELAY); | |
369 | parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK); | |
370 | } | |
371 | } | |
372 | ||
c7fd018d DT |
373 | static void gc_nes_process_packet(struct gc *gc) |
374 | { | |
b157d55e | 375 | unsigned char data[GC_SNESMOUSE_LENGTH]; |
0995174d | 376 | struct gc_pad *pad; |
c7fd018d | 377 | struct input_dev *dev; |
b157d55e RA |
378 | int i, j, s, len; |
379 | char x_rel, y_rel; | |
380 | ||
0995174d DT |
381 | len = gc->pad_count[GC_SNESMOUSE] ? GC_SNESMOUSE_LENGTH : |
382 | (gc->pad_count[GC_SNES] ? GC_SNES_LENGTH : GC_NES_LENGTH); | |
c7fd018d | 383 | |
b157d55e | 384 | gc_nes_read_packet(gc, len, data); |
c7fd018d DT |
385 | |
386 | for (i = 0; i < GC_MAX_DEVICES; i++) { | |
387 | ||
0995174d | 388 | pad = &gc->pads[i]; |
7b5d3312 | 389 | dev = pad->dev; |
c7fd018d DT |
390 | s = gc_status_bit[i]; |
391 | ||
0995174d DT |
392 | switch (pad->type) { |
393 | ||
394 | case GC_NES: | |
395 | ||
c7fd018d DT |
396 | input_report_abs(dev, ABS_X, !(s & data[6]) - !(s & data[7])); |
397 | input_report_abs(dev, ABS_Y, !(s & data[4]) - !(s & data[5])); | |
c7fd018d | 398 | |
c7fd018d | 399 | for (j = 0; j < 4; j++) |
d38fcb96 DT |
400 | input_report_key(dev, gc_snes_btn[j], |
401 | s & data[gc_nes_bytes[j]]); | |
0995174d DT |
402 | input_sync(dev); |
403 | break; | |
404 | ||
405 | case GC_SNES: | |
406 | ||
407 | input_report_abs(dev, ABS_X, !(s & data[6]) - !(s & data[7])); | |
408 | input_report_abs(dev, ABS_Y, !(s & data[4]) - !(s & data[5])); | |
c7fd018d | 409 | |
c7fd018d | 410 | for (j = 0; j < 8; j++) |
d38fcb96 DT |
411 | input_report_key(dev, gc_snes_btn[j], |
412 | s & data[gc_snes_bytes[j]]); | |
0995174d DT |
413 | input_sync(dev); |
414 | break; | |
c7fd018d | 415 | |
0995174d | 416 | case GC_SNESMOUSE: |
b157d55e | 417 | /* |
d38fcb96 DT |
418 | * The 4 unused bits from SNES controllers appear |
419 | * to be ID bits so use them to make sure we are | |
420 | * dealing with a mouse. | |
b157d55e RA |
421 | * gamepad is connected. This is important since |
422 | * my SNES gamepad sends 1's for bits 16-31, which | |
423 | * cause the mouse pointer to quickly move to the | |
424 | * upper left corner of the screen. | |
425 | */ | |
426 | if (!(s & data[12]) && !(s & data[13]) && | |
427 | !(s & data[14]) && (s & data[15])) { | |
428 | input_report_key(dev, BTN_LEFT, s & data[9]); | |
429 | input_report_key(dev, BTN_RIGHT, s & data[8]); | |
430 | ||
431 | x_rel = y_rel = 0; | |
432 | for (j = 0; j < 7; j++) { | |
433 | x_rel <<= 1; | |
434 | if (data[25 + j] & s) | |
435 | x_rel |= 1; | |
436 | ||
437 | y_rel <<= 1; | |
438 | if (data[17 + j] & s) | |
439 | y_rel |= 1; | |
440 | } | |
441 | ||
442 | if (x_rel) { | |
443 | if (data[24] & s) | |
444 | x_rel = -x_rel; | |
445 | input_report_rel(dev, REL_X, x_rel); | |
446 | } | |
447 | ||
448 | if (y_rel) { | |
449 | if (data[16] & s) | |
450 | y_rel = -y_rel; | |
451 | input_report_rel(dev, REL_Y, y_rel); | |
452 | } | |
0995174d DT |
453 | |
454 | input_sync(dev); | |
b157d55e | 455 | } |
0995174d DT |
456 | break; |
457 | ||
458 | default: | |
459 | break; | |
b157d55e | 460 | } |
c7fd018d DT |
461 | } |
462 | } | |
463 | ||
1da177e4 LT |
464 | /* |
465 | * Multisystem joystick support | |
466 | */ | |
467 | ||
468 | #define GC_MULTI_LENGTH 5 /* Multi system joystick packet length is 5 */ | |
469 | #define GC_MULTI2_LENGTH 6 /* One more bit for one more button */ | |
470 | ||
471 | /* | |
472 | * gc_multi_read_packet() reads a Multisystem joystick packet. | |
473 | */ | |
474 | ||
475 | static void gc_multi_read_packet(struct gc *gc, int length, unsigned char *data) | |
476 | { | |
477 | int i; | |
478 | ||
479 | for (i = 0; i < length; i++) { | |
480 | parport_write_data(gc->pd->port, ~(1 << i)); | |
481 | data[i] = parport_read_status(gc->pd->port) ^ 0x7f; | |
482 | } | |
483 | } | |
484 | ||
c7fd018d DT |
485 | static void gc_multi_process_packet(struct gc *gc) |
486 | { | |
487 | unsigned char data[GC_MULTI2_LENGTH]; | |
0995174d DT |
488 | int data_len = gc->pad_count[GC_MULTI2] ? GC_MULTI2_LENGTH : GC_MULTI_LENGTH; |
489 | struct gc_pad *pad; | |
c7fd018d DT |
490 | struct input_dev *dev; |
491 | int i, s; | |
492 | ||
d38fcb96 | 493 | gc_multi_read_packet(gc, data_len, data); |
c7fd018d DT |
494 | |
495 | for (i = 0; i < GC_MAX_DEVICES; i++) { | |
0995174d DT |
496 | pad = &gc->pads[i]; |
497 | dev = pad->dev; | |
c7fd018d DT |
498 | s = gc_status_bit[i]; |
499 | ||
0995174d DT |
500 | switch (pad->type) { |
501 | case GC_MULTI2: | |
502 | input_report_key(dev, BTN_THUMB, s & data[5]); | |
503 | /* fall through */ | |
504 | ||
505 | case GC_MULTI: | |
d38fcb96 DT |
506 | input_report_abs(dev, ABS_X, |
507 | !(s & data[2]) - !(s & data[3])); | |
508 | input_report_abs(dev, ABS_Y, | |
509 | !(s & data[0]) - !(s & data[1])); | |
c7fd018d | 510 | input_report_key(dev, BTN_TRIGGER, s & data[4]); |
0995174d DT |
511 | input_sync(dev); |
512 | break; | |
c7fd018d | 513 | |
0995174d DT |
514 | default: |
515 | break; | |
516 | } | |
c7fd018d DT |
517 | } |
518 | } | |
519 | ||
1da177e4 LT |
520 | /* |
521 | * PSX support | |
522 | * | |
523 | * See documentation at: | |
631dd1a8 | 524 | * http://www.geocities.co.jp/Playtown/2004/psx/ps_eng.txt |
1da177e4 | 525 | * http://www.gamesx.com/controldata/psxcont/psxcont.htm |
1da177e4 LT |
526 | * |
527 | */ | |
528 | ||
529 | #define GC_PSX_DELAY 25 /* 25 usec */ | |
530 | #define GC_PSX_LENGTH 8 /* talk to the controller in bits */ | |
531 | #define GC_PSX_BYTES 6 /* the maximum number of bytes to read off the controller */ | |
532 | ||
533 | #define GC_PSX_MOUSE 1 /* Mouse */ | |
534 | #define GC_PSX_NEGCON 2 /* NegCon */ | |
535 | #define GC_PSX_NORMAL 4 /* Digital / Analog or Rumble in Digital mode */ | |
536 | #define GC_PSX_ANALOG 5 /* Analog in Analog mode / Rumble in Green mode */ | |
537 | #define GC_PSX_RUMBLE 7 /* Rumble in Red mode */ | |
538 | ||
539 | #define GC_PSX_CLOCK 0x04 /* Pin 4 */ | |
540 | #define GC_PSX_COMMAND 0x01 /* Pin 2 */ | |
541 | #define GC_PSX_POWER 0xf8 /* Pins 5-9 */ | |
542 | #define GC_PSX_SELECT 0x02 /* Pin 3 */ | |
543 | ||
544 | #define GC_PSX_ID(x) ((x) >> 4) /* High nibble is device type */ | |
545 | #define GC_PSX_LEN(x) (((x) & 0xf) << 1) /* Low nibble is length in bytes/2 */ | |
546 | ||
547 | static int gc_psx_delay = GC_PSX_DELAY; | |
548 | module_param_named(psx_delay, gc_psx_delay, uint, 0); | |
549 | MODULE_PARM_DESC(psx_delay, "Delay when accessing Sony PSX controller (usecs)"); | |
550 | ||
af930d64 | 551 | static const short gc_psx_abs[] = { |
d38fcb96 DT |
552 | ABS_X, ABS_Y, ABS_RX, ABS_RY, ABS_HAT0X, ABS_HAT0Y |
553 | }; | |
af930d64 | 554 | static const short gc_psx_btn[] = { |
d38fcb96 DT |
555 | BTN_TL, BTN_TR, BTN_TL2, BTN_TR2, BTN_A, BTN_B, BTN_X, BTN_Y, |
556 | BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR | |
557 | }; | |
af930d64 | 558 | static const short gc_psx_ddr_btn[] = { BTN_0, BTN_1, BTN_2, BTN_3 }; |
1da177e4 LT |
559 | |
560 | /* | |
561 | * gc_psx_command() writes 8bit command and reads 8bit data from | |
562 | * the psx pad. | |
563 | */ | |
564 | ||
d38fcb96 | 565 | static void gc_psx_command(struct gc *gc, int b, unsigned char *data) |
1da177e4 | 566 | { |
d38fcb96 | 567 | struct parport *port = gc->pd->port; |
1da177e4 | 568 | int i, j, cmd, read; |
c7fd018d | 569 | |
d38fcb96 | 570 | memset(data, 0, GC_MAX_DEVICES); |
1da177e4 LT |
571 | |
572 | for (i = 0; i < GC_PSX_LENGTH; i++, b >>= 1) { | |
573 | cmd = (b & 1) ? GC_PSX_COMMAND : 0; | |
d38fcb96 | 574 | parport_write_data(port, cmd | GC_PSX_POWER); |
1da177e4 | 575 | udelay(gc_psx_delay); |
0995174d | 576 | |
d38fcb96 | 577 | read = parport_read_status(port) ^ 0x80; |
0995174d DT |
578 | |
579 | for (j = 0; j < GC_MAX_DEVICES; j++) { | |
c25f7b76 | 580 | struct gc_pad *pad = &gc->pads[j]; |
0995174d DT |
581 | |
582 | if (pad->type == GC_PSX || pad->type == GC_DDR) | |
583 | data[j] |= (read & gc_status_bit[j]) ? (1 << i) : 0; | |
584 | } | |
585 | ||
1da177e4 LT |
586 | parport_write_data(gc->pd->port, cmd | GC_PSX_CLOCK | GC_PSX_POWER); |
587 | udelay(gc_psx_delay); | |
588 | } | |
589 | } | |
590 | ||
591 | /* | |
592 | * gc_psx_read_packet() reads a whole psx packet and returns | |
593 | * device identifier code. | |
594 | */ | |
595 | ||
0995174d DT |
596 | static void gc_psx_read_packet(struct gc *gc, |
597 | unsigned char data[GC_MAX_DEVICES][GC_PSX_BYTES], | |
c7fd018d | 598 | unsigned char id[GC_MAX_DEVICES]) |
1da177e4 LT |
599 | { |
600 | int i, j, max_len = 0; | |
601 | unsigned long flags; | |
c7fd018d | 602 | unsigned char data2[GC_MAX_DEVICES]; |
1da177e4 | 603 | |
d38fcb96 DT |
604 | /* Select pad */ |
605 | parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER); | |
1da177e4 | 606 | udelay(gc_psx_delay); |
d38fcb96 DT |
607 | /* Deselect, begin command */ |
608 | parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_POWER); | |
1da177e4 LT |
609 | udelay(gc_psx_delay); |
610 | ||
611 | local_irq_save(flags); | |
612 | ||
d38fcb96 DT |
613 | gc_psx_command(gc, 0x01, data2); /* Access pad */ |
614 | gc_psx_command(gc, 0x42, id); /* Get device ids */ | |
615 | gc_psx_command(gc, 0, data2); /* Dump status */ | |
1da177e4 | 616 | |
d38fcb96 | 617 | /* Find the longest pad */ |
0995174d DT |
618 | for (i = 0; i < GC_MAX_DEVICES; i++) { |
619 | struct gc_pad *pad = &gc->pads[i]; | |
620 | ||
621 | if ((pad->type == GC_PSX || pad->type == GC_DDR) && | |
d38fcb96 DT |
622 | GC_PSX_LEN(id[i]) > max_len && |
623 | GC_PSX_LEN(id[i]) <= GC_PSX_BYTES) { | |
1da177e4 | 624 | max_len = GC_PSX_LEN(id[i]); |
d38fcb96 | 625 | } |
0995174d | 626 | } |
1da177e4 | 627 | |
d38fcb96 DT |
628 | /* Read in all the data */ |
629 | for (i = 0; i < max_len; i++) { | |
1da177e4 | 630 | gc_psx_command(gc, 0, data2); |
c7fd018d | 631 | for (j = 0; j < GC_MAX_DEVICES; j++) |
1da177e4 LT |
632 | data[j][i] = data2[j]; |
633 | } | |
634 | ||
635 | local_irq_restore(flags); | |
636 | ||
637 | parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER); | |
638 | ||
d38fcb96 DT |
639 | /* Set id's to the real value */ |
640 | for (i = 0; i < GC_MAX_DEVICES; i++) | |
1da177e4 LT |
641 | id[i] = GC_PSX_ID(id[i]); |
642 | } | |
643 | ||
0995174d | 644 | static void gc_psx_report_one(struct gc_pad *pad, unsigned char psx_type, |
d38fcb96 | 645 | unsigned char *data) |
c7fd018d | 646 | { |
0995174d | 647 | struct input_dev *dev = pad->dev; |
d38fcb96 | 648 | int i; |
1da177e4 | 649 | |
0995174d | 650 | switch (psx_type) { |
1da177e4 | 651 | |
d38fcb96 | 652 | case GC_PSX_RUMBLE: |
1da177e4 | 653 | |
d38fcb96 DT |
654 | input_report_key(dev, BTN_THUMBL, ~data[0] & 0x04); |
655 | input_report_key(dev, BTN_THUMBR, ~data[0] & 0x02); | |
1da177e4 | 656 | |
d38fcb96 DT |
657 | case GC_PSX_NEGCON: |
658 | case GC_PSX_ANALOG: | |
1da177e4 | 659 | |
0995174d | 660 | if (pad->type == GC_DDR) { |
d38fcb96 DT |
661 | for (i = 0; i < 4; i++) |
662 | input_report_key(dev, gc_psx_ddr_btn[i], | |
663 | ~data[0] & (0x10 << i)); | |
664 | } else { | |
665 | for (i = 0; i < 4; i++) | |
666 | input_report_abs(dev, gc_psx_abs[i + 2], | |
667 | data[i + 2]); | |
1da177e4 | 668 | |
315543fd DT |
669 | input_report_abs(dev, ABS_X, |
670 | !!(data[0] & 0x80) * 128 + !(data[0] & 0x20) * 127); | |
671 | input_report_abs(dev, ABS_Y, | |
672 | !!(data[0] & 0x10) * 128 + !(data[0] & 0x40) * 127); | |
d38fcb96 | 673 | } |
1da177e4 | 674 | |
d38fcb96 DT |
675 | for (i = 0; i < 8; i++) |
676 | input_report_key(dev, gc_psx_btn[i], ~data[1] & (1 << i)); | |
1da177e4 | 677 | |
d38fcb96 DT |
678 | input_report_key(dev, BTN_START, ~data[0] & 0x08); |
679 | input_report_key(dev, BTN_SELECT, ~data[0] & 0x01); | |
1da177e4 | 680 | |
d38fcb96 | 681 | input_sync(dev); |
1da177e4 | 682 | |
d38fcb96 | 683 | break; |
c7fd018d | 684 | |
d38fcb96 | 685 | case GC_PSX_NORMAL: |
0995174d DT |
686 | |
687 | if (pad->type == GC_DDR) { | |
d38fcb96 DT |
688 | for (i = 0; i < 4; i++) |
689 | input_report_key(dev, gc_psx_ddr_btn[i], | |
690 | ~data[0] & (0x10 << i)); | |
691 | } else { | |
315543fd DT |
692 | input_report_abs(dev, ABS_X, |
693 | !!(data[0] & 0x80) * 128 + !(data[0] & 0x20) * 127); | |
694 | input_report_abs(dev, ABS_Y, | |
695 | !!(data[0] & 0x10) * 128 + !(data[0] & 0x40) * 127); | |
c7fd018d | 696 | |
d38fcb96 DT |
697 | /* |
698 | * For some reason if the extra axes are left unset | |
699 | * they drift. | |
700 | * for (i = 0; i < 4; i++) | |
701 | input_report_abs(dev, gc_psx_abs[i + 2], 128); | |
702 | * This needs to be debugged properly, | |
703 | * maybe fuzz processing needs to be done | |
704 | * in input_sync() | |
705 | * --vojtech | |
706 | */ | |
707 | } | |
c7fd018d | 708 | |
d38fcb96 DT |
709 | for (i = 0; i < 8; i++) |
710 | input_report_key(dev, gc_psx_btn[i], ~data[1] & (1 << i)); | |
c7fd018d | 711 | |
d38fcb96 DT |
712 | input_report_key(dev, BTN_START, ~data[0] & 0x08); |
713 | input_report_key(dev, BTN_SELECT, ~data[0] & 0x01); | |
c7fd018d | 714 | |
d38fcb96 | 715 | input_sync(dev); |
1da177e4 | 716 | |
d38fcb96 | 717 | break; |
1da177e4 | 718 | |
0995174d | 719 | default: /* not a pad, ignore */ |
d38fcb96 DT |
720 | break; |
721 | } | |
722 | } | |
1da177e4 | 723 | |
d38fcb96 DT |
724 | static void gc_psx_process_packet(struct gc *gc) |
725 | { | |
726 | unsigned char data[GC_MAX_DEVICES][GC_PSX_BYTES]; | |
727 | unsigned char id[GC_MAX_DEVICES]; | |
0995174d | 728 | struct gc_pad *pad; |
d38fcb96 | 729 | int i; |
1da177e4 | 730 | |
d38fcb96 | 731 | gc_psx_read_packet(gc, data, id); |
c7fd018d | 732 | |
d38fcb96 | 733 | for (i = 0; i < GC_MAX_DEVICES; i++) { |
0995174d DT |
734 | pad = &gc->pads[i]; |
735 | if (pad->type == GC_PSX || pad->type == GC_DDR) | |
736 | gc_psx_report_one(pad, id[i], data[i]); | |
1da177e4 | 737 | } |
c7fd018d | 738 | } |
1da177e4 LT |
739 | |
740 | /* | |
c7fd018d | 741 | * gc_timer() initiates reads of console pads data. |
1da177e4 LT |
742 | */ |
743 | ||
c7fd018d DT |
744 | static void gc_timer(unsigned long private) |
745 | { | |
746 | struct gc *gc = (void *) private; | |
1da177e4 | 747 | |
c7fd018d DT |
748 | /* |
749 | * N64 pads - must be read first, any read confuses them for 200 us | |
750 | */ | |
1da177e4 | 751 | |
0995174d | 752 | if (gc->pad_count[GC_N64]) |
c7fd018d | 753 | gc_n64_process_packet(gc); |
1da177e4 | 754 | |
c7fd018d | 755 | /* |
b157d55e | 756 | * NES and SNES pads or mouse |
c7fd018d | 757 | */ |
1da177e4 | 758 | |
0995174d DT |
759 | if (gc->pad_count[GC_NES] || |
760 | gc->pad_count[GC_SNES] || | |
761 | gc->pad_count[GC_SNESMOUSE]) { | |
c7fd018d | 762 | gc_nes_process_packet(gc); |
0995174d | 763 | } |
1da177e4 LT |
764 | |
765 | /* | |
766 | * Multi and Multi2 joysticks | |
767 | */ | |
768 | ||
0995174d | 769 | if (gc->pad_count[GC_MULTI] || gc->pad_count[GC_MULTI2]) |
c7fd018d | 770 | gc_multi_process_packet(gc); |
1da177e4 LT |
771 | |
772 | /* | |
773 | * PSX controllers | |
774 | */ | |
775 | ||
0995174d | 776 | if (gc->pad_count[GC_PSX] || gc->pad_count[GC_DDR]) |
c7fd018d | 777 | gc_psx_process_packet(gc); |
1da177e4 LT |
778 | |
779 | mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME); | |
780 | } | |
781 | ||
782 | static int gc_open(struct input_dev *dev) | |
783 | { | |
8715c1cf | 784 | struct gc *gc = input_get_drvdata(dev); |
8b1a198b DT |
785 | int err; |
786 | ||
72ba9f0c | 787 | err = mutex_lock_interruptible(&gc->mutex); |
8b1a198b DT |
788 | if (err) |
789 | return err; | |
790 | ||
1da177e4 LT |
791 | if (!gc->used++) { |
792 | parport_claim(gc->pd); | |
793 | parport_write_control(gc->pd->port, 0x04); | |
794 | mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME); | |
795 | } | |
8b1a198b | 796 | |
72ba9f0c | 797 | mutex_unlock(&gc->mutex); |
1da177e4 LT |
798 | return 0; |
799 | } | |
800 | ||
801 | static void gc_close(struct input_dev *dev) | |
802 | { | |
8715c1cf | 803 | struct gc *gc = input_get_drvdata(dev); |
8b1a198b | 804 | |
72ba9f0c | 805 | mutex_lock(&gc->mutex); |
1da177e4 | 806 | if (!--gc->used) { |
8b1a198b | 807 | del_timer_sync(&gc->timer); |
1da177e4 LT |
808 | parport_write_control(gc->pd->port, 0x00); |
809 | parport_release(gc->pd); | |
810 | } | |
72ba9f0c | 811 | mutex_unlock(&gc->mutex); |
1da177e4 LT |
812 | } |
813 | ||
17dd3f0f | 814 | static int __init gc_setup_pad(struct gc *gc, int idx, int pad_type) |
1da177e4 | 815 | { |
0995174d | 816 | struct gc_pad *pad = &gc->pads[idx]; |
17dd3f0f DT |
817 | struct input_dev *input_dev; |
818 | int i; | |
7aa9e0e8 | 819 | int err; |
1da177e4 | 820 | |
5bc923c5 | 821 | if (pad_type < 1 || pad_type >= GC_MAX) { |
a1e12747 | 822 | pr_err("Pad type %d unknown\n", pad_type); |
17dd3f0f | 823 | return -EINVAL; |
1da177e4 LT |
824 | } |
825 | ||
0995174d | 826 | pad->dev = input_dev = input_allocate_device(); |
17dd3f0f | 827 | if (!input_dev) { |
a1e12747 | 828 | pr_err("Not enough memory for input device\n"); |
17dd3f0f | 829 | return -ENOMEM; |
1da177e4 LT |
830 | } |
831 | ||
0995174d DT |
832 | pad->type = pad_type; |
833 | ||
834 | snprintf(pad->phys, sizeof(pad->phys), | |
835 | "%s/input%d", gc->pd->port->name, idx); | |
836 | ||
17dd3f0f | 837 | input_dev->name = gc_names[pad_type]; |
0995174d | 838 | input_dev->phys = pad->phys; |
17dd3f0f DT |
839 | input_dev->id.bustype = BUS_PARPORT; |
840 | input_dev->id.vendor = 0x0001; | |
841 | input_dev->id.product = pad_type; | |
842 | input_dev->id.version = 0x0100; | |
8715c1cf DT |
843 | |
844 | input_set_drvdata(input_dev, gc); | |
17dd3f0f DT |
845 | |
846 | input_dev->open = gc_open; | |
847 | input_dev->close = gc_close; | |
848 | ||
b157d55e | 849 | if (pad_type != GC_SNESMOUSE) { |
7b19ada2 | 850 | input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); |
17dd3f0f | 851 | |
b157d55e RA |
852 | for (i = 0; i < 2; i++) |
853 | input_set_abs_params(input_dev, ABS_X + i, -1, 1, 0, 0); | |
854 | } else | |
7b19ada2 | 855 | input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL); |
17dd3f0f | 856 | |
0995174d | 857 | gc->pad_count[pad_type]++; |
17dd3f0f DT |
858 | |
859 | switch (pad_type) { | |
860 | ||
d38fcb96 DT |
861 | case GC_N64: |
862 | for (i = 0; i < 10; i++) | |
863 | __set_bit(gc_n64_btn[i], input_dev->keybit); | |
b157d55e | 864 | |
d38fcb96 DT |
865 | for (i = 0; i < 2; i++) { |
866 | input_set_abs_params(input_dev, ABS_X + i, -127, 126, 0, 2); | |
867 | input_set_abs_params(input_dev, ABS_HAT0X + i, -1, 1, 0, 0); | |
868 | } | |
17dd3f0f | 869 | |
d38fcb96 DT |
870 | err = gc_n64_init_ff(input_dev, idx); |
871 | if (err) { | |
a1e12747 | 872 | pr_warning("Failed to initiate rumble for N64 device %d\n", idx); |
0995174d | 873 | goto err_free_dev; |
d38fcb96 | 874 | } |
17dd3f0f | 875 | |
d38fcb96 DT |
876 | break; |
877 | ||
878 | case GC_SNESMOUSE: | |
879 | __set_bit(BTN_LEFT, input_dev->keybit); | |
880 | __set_bit(BTN_RIGHT, input_dev->keybit); | |
881 | __set_bit(REL_X, input_dev->relbit); | |
882 | __set_bit(REL_Y, input_dev->relbit); | |
883 | break; | |
884 | ||
885 | case GC_SNES: | |
886 | for (i = 4; i < 8; i++) | |
887 | __set_bit(gc_snes_btn[i], input_dev->keybit); | |
888 | case GC_NES: | |
889 | for (i = 0; i < 4; i++) | |
890 | __set_bit(gc_snes_btn[i], input_dev->keybit); | |
891 | break; | |
892 | ||
893 | case GC_MULTI2: | |
894 | __set_bit(BTN_THUMB, input_dev->keybit); | |
895 | case GC_MULTI: | |
896 | __set_bit(BTN_TRIGGER, input_dev->keybit); | |
897 | break; | |
898 | ||
899 | case GC_PSX: | |
900 | for (i = 0; i < 6; i++) | |
901 | input_set_abs_params(input_dev, | |
902 | gc_psx_abs[i], 4, 252, 0, 2); | |
903 | for (i = 0; i < 12; i++) | |
904 | __set_bit(gc_psx_btn[i], input_dev->keybit); | |
905 | ||
906 | break; | |
907 | ||
908 | case GC_DDR: | |
909 | for (i = 0; i < 4; i++) | |
910 | __set_bit(gc_psx_ddr_btn[i], input_dev->keybit); | |
911 | for (i = 0; i < 12; i++) | |
912 | __set_bit(gc_psx_btn[i], input_dev->keybit); | |
913 | ||
914 | break; | |
1da177e4 | 915 | } |
8b1a198b | 916 | |
0995174d DT |
917 | err = input_register_device(pad->dev); |
918 | if (err) | |
919 | goto err_free_dev; | |
920 | ||
17dd3f0f | 921 | return 0; |
0995174d DT |
922 | |
923 | err_free_dev: | |
924 | input_free_device(pad->dev); | |
925 | pad->dev = NULL; | |
926 | return err; | |
17dd3f0f | 927 | } |
1da177e4 | 928 | |
17dd3f0f DT |
929 | static struct gc __init *gc_probe(int parport, int *pads, int n_pads) |
930 | { | |
931 | struct gc *gc; | |
932 | struct parport *pp; | |
933 | struct pardevice *pd; | |
934 | int i; | |
0995174d | 935 | int count = 0; |
17dd3f0f | 936 | int err; |
1da177e4 | 937 | |
17dd3f0f DT |
938 | pp = parport_find_number(parport); |
939 | if (!pp) { | |
a1e12747 | 940 | pr_err("no such parport %d\n", parport); |
17dd3f0f DT |
941 | err = -EINVAL; |
942 | goto err_out; | |
943 | } | |
1da177e4 | 944 | |
17dd3f0f DT |
945 | pd = parport_register_device(pp, "gamecon", NULL, NULL, NULL, PARPORT_DEV_EXCL, NULL); |
946 | if (!pd) { | |
a1e12747 | 947 | pr_err("parport busy already - lp.o loaded?\n"); |
17dd3f0f DT |
948 | err = -EBUSY; |
949 | goto err_put_pp; | |
1da177e4 LT |
950 | } |
951 | ||
17dd3f0f DT |
952 | gc = kzalloc(sizeof(struct gc), GFP_KERNEL); |
953 | if (!gc) { | |
a1e12747 | 954 | pr_err("Not enough memory\n"); |
17dd3f0f DT |
955 | err = -ENOMEM; |
956 | goto err_unreg_pardev; | |
957 | } | |
1da177e4 | 958 | |
72ba9f0c | 959 | mutex_init(&gc->mutex); |
17dd3f0f | 960 | gc->pd = pd; |
d38fcb96 | 961 | setup_timer(&gc->timer, gc_timer, (long) gc); |
1da177e4 | 962 | |
c7fd018d | 963 | for (i = 0; i < n_pads && i < GC_MAX_DEVICES; i++) { |
17dd3f0f | 964 | if (!pads[i]) |
1da177e4 LT |
965 | continue; |
966 | ||
17dd3f0f DT |
967 | err = gc_setup_pad(gc, i, pads[i]); |
968 | if (err) | |
77fc46ca | 969 | goto err_unreg_devs; |
1da177e4 | 970 | |
0995174d | 971 | count++; |
17dd3f0f | 972 | } |
1da177e4 | 973 | |
0995174d | 974 | if (count == 0) { |
a1e12747 | 975 | pr_err("No valid devices specified\n"); |
17dd3f0f DT |
976 | err = -EINVAL; |
977 | goto err_free_gc; | |
978 | } | |
1da177e4 | 979 | |
17dd3f0f DT |
980 | parport_put_port(pp); |
981 | return gc; | |
1da177e4 | 982 | |
77fc46ca | 983 | err_unreg_devs: |
17dd3f0f | 984 | while (--i >= 0) |
0995174d DT |
985 | if (gc->pads[i].dev) |
986 | input_unregister_device(gc->pads[i].dev); | |
17dd3f0f DT |
987 | err_free_gc: |
988 | kfree(gc); | |
989 | err_unreg_pardev: | |
990 | parport_unregister_device(pd); | |
991 | err_put_pp: | |
992 | parport_put_port(pp); | |
993 | err_out: | |
994 | return ERR_PTR(err); | |
995 | } | |
1da177e4 | 996 | |
77fc46ca | 997 | static void gc_remove(struct gc *gc) |
17dd3f0f DT |
998 | { |
999 | int i; | |
1da177e4 | 1000 | |
17dd3f0f | 1001 | for (i = 0; i < GC_MAX_DEVICES; i++) |
0995174d DT |
1002 | if (gc->pads[i].dev) |
1003 | input_unregister_device(gc->pads[i].dev); | |
17dd3f0f DT |
1004 | parport_unregister_device(gc->pd); |
1005 | kfree(gc); | |
1006 | } | |
1da177e4 | 1007 | |
17dd3f0f DT |
1008 | static int __init gc_init(void) |
1009 | { | |
1010 | int i; | |
1011 | int have_dev = 0; | |
1012 | int err = 0; | |
1da177e4 | 1013 | |
17dd3f0f | 1014 | for (i = 0; i < GC_MAX_PORTS; i++) { |
78167236 | 1015 | if (gc_cfg[i].nargs == 0 || gc_cfg[i].args[0] < 0) |
17dd3f0f | 1016 | continue; |
1da177e4 | 1017 | |
78167236 | 1018 | if (gc_cfg[i].nargs < 2) { |
a1e12747 | 1019 | pr_err("at least one device must be specified\n"); |
17dd3f0f DT |
1020 | err = -EINVAL; |
1021 | break; | |
1da177e4 LT |
1022 | } |
1023 | ||
78167236 DT |
1024 | gc_base[i] = gc_probe(gc_cfg[i].args[0], |
1025 | gc_cfg[i].args + 1, gc_cfg[i].nargs - 1); | |
17dd3f0f DT |
1026 | if (IS_ERR(gc_base[i])) { |
1027 | err = PTR_ERR(gc_base[i]); | |
1028 | break; | |
1029 | } | |
1da177e4 | 1030 | |
17dd3f0f | 1031 | have_dev = 1; |
1da177e4 LT |
1032 | } |
1033 | ||
17dd3f0f DT |
1034 | if (err) { |
1035 | while (--i >= 0) | |
77fc46ca DT |
1036 | if (gc_base[i]) |
1037 | gc_remove(gc_base[i]); | |
17dd3f0f | 1038 | return err; |
1da177e4 LT |
1039 | } |
1040 | ||
17dd3f0f | 1041 | return have_dev ? 0 : -ENODEV; |
1da177e4 LT |
1042 | } |
1043 | ||
1044 | static void __exit gc_exit(void) | |
1045 | { | |
17dd3f0f DT |
1046 | int i; |
1047 | ||
1048 | for (i = 0; i < GC_MAX_PORTS; i++) | |
1049 | if (gc_base[i]) | |
1050 | gc_remove(gc_base[i]); | |
1da177e4 LT |
1051 | } |
1052 | ||
1053 | module_init(gc_init); | |
1054 | module_exit(gc_exit); |