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: | |
524 | * http://www.dim.com/~mackys/psxmemcard/ps-eng2.txt | |
525 | * http://www.gamesx.com/controldata/psxcont/psxcont.htm | |
526 | * ftp://milano.usal.es/pablo/ | |
527 | * | |
528 | */ | |
529 | ||
530 | #define GC_PSX_DELAY 25 /* 25 usec */ | |
531 | #define GC_PSX_LENGTH 8 /* talk to the controller in bits */ | |
532 | #define GC_PSX_BYTES 6 /* the maximum number of bytes to read off the controller */ | |
533 | ||
534 | #define GC_PSX_MOUSE 1 /* Mouse */ | |
535 | #define GC_PSX_NEGCON 2 /* NegCon */ | |
536 | #define GC_PSX_NORMAL 4 /* Digital / Analog or Rumble in Digital mode */ | |
537 | #define GC_PSX_ANALOG 5 /* Analog in Analog mode / Rumble in Green mode */ | |
538 | #define GC_PSX_RUMBLE 7 /* Rumble in Red mode */ | |
539 | ||
540 | #define GC_PSX_CLOCK 0x04 /* Pin 4 */ | |
541 | #define GC_PSX_COMMAND 0x01 /* Pin 2 */ | |
542 | #define GC_PSX_POWER 0xf8 /* Pins 5-9 */ | |
543 | #define GC_PSX_SELECT 0x02 /* Pin 3 */ | |
544 | ||
545 | #define GC_PSX_ID(x) ((x) >> 4) /* High nibble is device type */ | |
546 | #define GC_PSX_LEN(x) (((x) & 0xf) << 1) /* Low nibble is length in bytes/2 */ | |
547 | ||
548 | static int gc_psx_delay = GC_PSX_DELAY; | |
549 | module_param_named(psx_delay, gc_psx_delay, uint, 0); | |
550 | MODULE_PARM_DESC(psx_delay, "Delay when accessing Sony PSX controller (usecs)"); | |
551 | ||
af930d64 | 552 | static const short gc_psx_abs[] = { |
d38fcb96 DT |
553 | ABS_X, ABS_Y, ABS_RX, ABS_RY, ABS_HAT0X, ABS_HAT0Y |
554 | }; | |
af930d64 | 555 | static const short gc_psx_btn[] = { |
d38fcb96 DT |
556 | BTN_TL, BTN_TR, BTN_TL2, BTN_TR2, BTN_A, BTN_B, BTN_X, BTN_Y, |
557 | BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR | |
558 | }; | |
af930d64 | 559 | static const short gc_psx_ddr_btn[] = { BTN_0, BTN_1, BTN_2, BTN_3 }; |
1da177e4 LT |
560 | |
561 | /* | |
562 | * gc_psx_command() writes 8bit command and reads 8bit data from | |
563 | * the psx pad. | |
564 | */ | |
565 | ||
d38fcb96 | 566 | static void gc_psx_command(struct gc *gc, int b, unsigned char *data) |
1da177e4 | 567 | { |
d38fcb96 | 568 | struct parport *port = gc->pd->port; |
1da177e4 | 569 | int i, j, cmd, read; |
c7fd018d | 570 | |
d38fcb96 | 571 | memset(data, 0, GC_MAX_DEVICES); |
1da177e4 LT |
572 | |
573 | for (i = 0; i < GC_PSX_LENGTH; i++, b >>= 1) { | |
574 | cmd = (b & 1) ? GC_PSX_COMMAND : 0; | |
d38fcb96 | 575 | parport_write_data(port, cmd | GC_PSX_POWER); |
1da177e4 | 576 | udelay(gc_psx_delay); |
0995174d | 577 | |
d38fcb96 | 578 | read = parport_read_status(port) ^ 0x80; |
0995174d DT |
579 | |
580 | for (j = 0; j < GC_MAX_DEVICES; j++) { | |
c25f7b76 | 581 | struct gc_pad *pad = &gc->pads[j]; |
0995174d DT |
582 | |
583 | if (pad->type == GC_PSX || pad->type == GC_DDR) | |
584 | data[j] |= (read & gc_status_bit[j]) ? (1 << i) : 0; | |
585 | } | |
586 | ||
1da177e4 LT |
587 | parport_write_data(gc->pd->port, cmd | GC_PSX_CLOCK | GC_PSX_POWER); |
588 | udelay(gc_psx_delay); | |
589 | } | |
590 | } | |
591 | ||
592 | /* | |
593 | * gc_psx_read_packet() reads a whole psx packet and returns | |
594 | * device identifier code. | |
595 | */ | |
596 | ||
0995174d DT |
597 | static void gc_psx_read_packet(struct gc *gc, |
598 | unsigned char data[GC_MAX_DEVICES][GC_PSX_BYTES], | |
c7fd018d | 599 | unsigned char id[GC_MAX_DEVICES]) |
1da177e4 LT |
600 | { |
601 | int i, j, max_len = 0; | |
602 | unsigned long flags; | |
c7fd018d | 603 | unsigned char data2[GC_MAX_DEVICES]; |
1da177e4 | 604 | |
d38fcb96 DT |
605 | /* Select pad */ |
606 | parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER); | |
1da177e4 | 607 | udelay(gc_psx_delay); |
d38fcb96 DT |
608 | /* Deselect, begin command */ |
609 | parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_POWER); | |
1da177e4 LT |
610 | udelay(gc_psx_delay); |
611 | ||
612 | local_irq_save(flags); | |
613 | ||
d38fcb96 DT |
614 | gc_psx_command(gc, 0x01, data2); /* Access pad */ |
615 | gc_psx_command(gc, 0x42, id); /* Get device ids */ | |
616 | gc_psx_command(gc, 0, data2); /* Dump status */ | |
1da177e4 | 617 | |
d38fcb96 | 618 | /* Find the longest pad */ |
0995174d DT |
619 | for (i = 0; i < GC_MAX_DEVICES; i++) { |
620 | struct gc_pad *pad = &gc->pads[i]; | |
621 | ||
622 | if ((pad->type == GC_PSX || pad->type == GC_DDR) && | |
d38fcb96 DT |
623 | GC_PSX_LEN(id[i]) > max_len && |
624 | GC_PSX_LEN(id[i]) <= GC_PSX_BYTES) { | |
1da177e4 | 625 | max_len = GC_PSX_LEN(id[i]); |
d38fcb96 | 626 | } |
0995174d | 627 | } |
1da177e4 | 628 | |
d38fcb96 DT |
629 | /* Read in all the data */ |
630 | for (i = 0; i < max_len; i++) { | |
1da177e4 | 631 | gc_psx_command(gc, 0, data2); |
c7fd018d | 632 | for (j = 0; j < GC_MAX_DEVICES; j++) |
1da177e4 LT |
633 | data[j][i] = data2[j]; |
634 | } | |
635 | ||
636 | local_irq_restore(flags); | |
637 | ||
638 | parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER); | |
639 | ||
d38fcb96 DT |
640 | /* Set id's to the real value */ |
641 | for (i = 0; i < GC_MAX_DEVICES; i++) | |
1da177e4 LT |
642 | id[i] = GC_PSX_ID(id[i]); |
643 | } | |
644 | ||
0995174d | 645 | static void gc_psx_report_one(struct gc_pad *pad, unsigned char psx_type, |
d38fcb96 | 646 | unsigned char *data) |
c7fd018d | 647 | { |
0995174d | 648 | struct input_dev *dev = pad->dev; |
d38fcb96 | 649 | int i; |
1da177e4 | 650 | |
0995174d | 651 | switch (psx_type) { |
1da177e4 | 652 | |
d38fcb96 | 653 | case GC_PSX_RUMBLE: |
1da177e4 | 654 | |
d38fcb96 DT |
655 | input_report_key(dev, BTN_THUMBL, ~data[0] & 0x04); |
656 | input_report_key(dev, BTN_THUMBR, ~data[0] & 0x02); | |
1da177e4 | 657 | |
d38fcb96 DT |
658 | case GC_PSX_NEGCON: |
659 | case GC_PSX_ANALOG: | |
1da177e4 | 660 | |
0995174d | 661 | if (pad->type == GC_DDR) { |
d38fcb96 DT |
662 | for (i = 0; i < 4; i++) |
663 | input_report_key(dev, gc_psx_ddr_btn[i], | |
664 | ~data[0] & (0x10 << i)); | |
665 | } else { | |
666 | for (i = 0; i < 4; i++) | |
667 | input_report_abs(dev, gc_psx_abs[i + 2], | |
668 | data[i + 2]); | |
1da177e4 | 669 | |
315543fd DT |
670 | input_report_abs(dev, ABS_X, |
671 | !!(data[0] & 0x80) * 128 + !(data[0] & 0x20) * 127); | |
672 | input_report_abs(dev, ABS_Y, | |
673 | !!(data[0] & 0x10) * 128 + !(data[0] & 0x40) * 127); | |
d38fcb96 | 674 | } |
1da177e4 | 675 | |
d38fcb96 DT |
676 | for (i = 0; i < 8; i++) |
677 | input_report_key(dev, gc_psx_btn[i], ~data[1] & (1 << i)); | |
1da177e4 | 678 | |
d38fcb96 DT |
679 | input_report_key(dev, BTN_START, ~data[0] & 0x08); |
680 | input_report_key(dev, BTN_SELECT, ~data[0] & 0x01); | |
1da177e4 | 681 | |
d38fcb96 | 682 | input_sync(dev); |
1da177e4 | 683 | |
d38fcb96 | 684 | break; |
c7fd018d | 685 | |
d38fcb96 | 686 | case GC_PSX_NORMAL: |
0995174d DT |
687 | |
688 | if (pad->type == GC_DDR) { | |
d38fcb96 DT |
689 | for (i = 0; i < 4; i++) |
690 | input_report_key(dev, gc_psx_ddr_btn[i], | |
691 | ~data[0] & (0x10 << i)); | |
692 | } else { | |
315543fd DT |
693 | input_report_abs(dev, ABS_X, |
694 | !!(data[0] & 0x80) * 128 + !(data[0] & 0x20) * 127); | |
695 | input_report_abs(dev, ABS_Y, | |
696 | !!(data[0] & 0x10) * 128 + !(data[0] & 0x40) * 127); | |
c7fd018d | 697 | |
d38fcb96 DT |
698 | /* |
699 | * For some reason if the extra axes are left unset | |
700 | * they drift. | |
701 | * for (i = 0; i < 4; i++) | |
702 | input_report_abs(dev, gc_psx_abs[i + 2], 128); | |
703 | * This needs to be debugged properly, | |
704 | * maybe fuzz processing needs to be done | |
705 | * in input_sync() | |
706 | * --vojtech | |
707 | */ | |
708 | } | |
c7fd018d | 709 | |
d38fcb96 DT |
710 | for (i = 0; i < 8; i++) |
711 | input_report_key(dev, gc_psx_btn[i], ~data[1] & (1 << i)); | |
c7fd018d | 712 | |
d38fcb96 DT |
713 | input_report_key(dev, BTN_START, ~data[0] & 0x08); |
714 | input_report_key(dev, BTN_SELECT, ~data[0] & 0x01); | |
c7fd018d | 715 | |
d38fcb96 | 716 | input_sync(dev); |
1da177e4 | 717 | |
d38fcb96 | 718 | break; |
1da177e4 | 719 | |
0995174d | 720 | default: /* not a pad, ignore */ |
d38fcb96 DT |
721 | break; |
722 | } | |
723 | } | |
1da177e4 | 724 | |
d38fcb96 DT |
725 | static void gc_psx_process_packet(struct gc *gc) |
726 | { | |
727 | unsigned char data[GC_MAX_DEVICES][GC_PSX_BYTES]; | |
728 | unsigned char id[GC_MAX_DEVICES]; | |
0995174d | 729 | struct gc_pad *pad; |
d38fcb96 | 730 | int i; |
1da177e4 | 731 | |
d38fcb96 | 732 | gc_psx_read_packet(gc, data, id); |
c7fd018d | 733 | |
d38fcb96 | 734 | for (i = 0; i < GC_MAX_DEVICES; i++) { |
0995174d DT |
735 | pad = &gc->pads[i]; |
736 | if (pad->type == GC_PSX || pad->type == GC_DDR) | |
737 | gc_psx_report_one(pad, id[i], data[i]); | |
1da177e4 | 738 | } |
c7fd018d | 739 | } |
1da177e4 LT |
740 | |
741 | /* | |
c7fd018d | 742 | * gc_timer() initiates reads of console pads data. |
1da177e4 LT |
743 | */ |
744 | ||
c7fd018d DT |
745 | static void gc_timer(unsigned long private) |
746 | { | |
747 | struct gc *gc = (void *) private; | |
1da177e4 | 748 | |
c7fd018d DT |
749 | /* |
750 | * N64 pads - must be read first, any read confuses them for 200 us | |
751 | */ | |
1da177e4 | 752 | |
0995174d | 753 | if (gc->pad_count[GC_N64]) |
c7fd018d | 754 | gc_n64_process_packet(gc); |
1da177e4 | 755 | |
c7fd018d | 756 | /* |
b157d55e | 757 | * NES and SNES pads or mouse |
c7fd018d | 758 | */ |
1da177e4 | 759 | |
0995174d DT |
760 | if (gc->pad_count[GC_NES] || |
761 | gc->pad_count[GC_SNES] || | |
762 | gc->pad_count[GC_SNESMOUSE]) { | |
c7fd018d | 763 | gc_nes_process_packet(gc); |
0995174d | 764 | } |
1da177e4 LT |
765 | |
766 | /* | |
767 | * Multi and Multi2 joysticks | |
768 | */ | |
769 | ||
0995174d | 770 | if (gc->pad_count[GC_MULTI] || gc->pad_count[GC_MULTI2]) |
c7fd018d | 771 | gc_multi_process_packet(gc); |
1da177e4 LT |
772 | |
773 | /* | |
774 | * PSX controllers | |
775 | */ | |
776 | ||
0995174d | 777 | if (gc->pad_count[GC_PSX] || gc->pad_count[GC_DDR]) |
c7fd018d | 778 | gc_psx_process_packet(gc); |
1da177e4 LT |
779 | |
780 | mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME); | |
781 | } | |
782 | ||
783 | static int gc_open(struct input_dev *dev) | |
784 | { | |
8715c1cf | 785 | struct gc *gc = input_get_drvdata(dev); |
8b1a198b DT |
786 | int err; |
787 | ||
72ba9f0c | 788 | err = mutex_lock_interruptible(&gc->mutex); |
8b1a198b DT |
789 | if (err) |
790 | return err; | |
791 | ||
1da177e4 LT |
792 | if (!gc->used++) { |
793 | parport_claim(gc->pd); | |
794 | parport_write_control(gc->pd->port, 0x04); | |
795 | mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME); | |
796 | } | |
8b1a198b | 797 | |
72ba9f0c | 798 | mutex_unlock(&gc->mutex); |
1da177e4 LT |
799 | return 0; |
800 | } | |
801 | ||
802 | static void gc_close(struct input_dev *dev) | |
803 | { | |
8715c1cf | 804 | struct gc *gc = input_get_drvdata(dev); |
8b1a198b | 805 | |
72ba9f0c | 806 | mutex_lock(&gc->mutex); |
1da177e4 | 807 | if (!--gc->used) { |
8b1a198b | 808 | del_timer_sync(&gc->timer); |
1da177e4 LT |
809 | parport_write_control(gc->pd->port, 0x00); |
810 | parport_release(gc->pd); | |
811 | } | |
72ba9f0c | 812 | mutex_unlock(&gc->mutex); |
1da177e4 LT |
813 | } |
814 | ||
17dd3f0f | 815 | static int __init gc_setup_pad(struct gc *gc, int idx, int pad_type) |
1da177e4 | 816 | { |
0995174d | 817 | struct gc_pad *pad = &gc->pads[idx]; |
17dd3f0f DT |
818 | struct input_dev *input_dev; |
819 | int i; | |
7aa9e0e8 | 820 | int err; |
1da177e4 | 821 | |
5bc923c5 | 822 | if (pad_type < 1 || pad_type >= GC_MAX) { |
a1e12747 | 823 | pr_err("Pad type %d unknown\n", pad_type); |
17dd3f0f | 824 | return -EINVAL; |
1da177e4 LT |
825 | } |
826 | ||
0995174d | 827 | pad->dev = input_dev = input_allocate_device(); |
17dd3f0f | 828 | if (!input_dev) { |
a1e12747 | 829 | pr_err("Not enough memory for input device\n"); |
17dd3f0f | 830 | return -ENOMEM; |
1da177e4 LT |
831 | } |
832 | ||
0995174d DT |
833 | pad->type = pad_type; |
834 | ||
835 | snprintf(pad->phys, sizeof(pad->phys), | |
836 | "%s/input%d", gc->pd->port->name, idx); | |
837 | ||
17dd3f0f | 838 | input_dev->name = gc_names[pad_type]; |
0995174d | 839 | input_dev->phys = pad->phys; |
17dd3f0f DT |
840 | input_dev->id.bustype = BUS_PARPORT; |
841 | input_dev->id.vendor = 0x0001; | |
842 | input_dev->id.product = pad_type; | |
843 | input_dev->id.version = 0x0100; | |
8715c1cf DT |
844 | |
845 | input_set_drvdata(input_dev, gc); | |
17dd3f0f DT |
846 | |
847 | input_dev->open = gc_open; | |
848 | input_dev->close = gc_close; | |
849 | ||
b157d55e | 850 | if (pad_type != GC_SNESMOUSE) { |
7b19ada2 | 851 | input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); |
17dd3f0f | 852 | |
b157d55e RA |
853 | for (i = 0; i < 2; i++) |
854 | input_set_abs_params(input_dev, ABS_X + i, -1, 1, 0, 0); | |
855 | } else | |
7b19ada2 | 856 | input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL); |
17dd3f0f | 857 | |
0995174d | 858 | gc->pad_count[pad_type]++; |
17dd3f0f DT |
859 | |
860 | switch (pad_type) { | |
861 | ||
d38fcb96 DT |
862 | case GC_N64: |
863 | for (i = 0; i < 10; i++) | |
864 | __set_bit(gc_n64_btn[i], input_dev->keybit); | |
b157d55e | 865 | |
d38fcb96 DT |
866 | for (i = 0; i < 2; i++) { |
867 | input_set_abs_params(input_dev, ABS_X + i, -127, 126, 0, 2); | |
868 | input_set_abs_params(input_dev, ABS_HAT0X + i, -1, 1, 0, 0); | |
869 | } | |
17dd3f0f | 870 | |
d38fcb96 DT |
871 | err = gc_n64_init_ff(input_dev, idx); |
872 | if (err) { | |
a1e12747 | 873 | pr_warning("Failed to initiate rumble for N64 device %d\n", idx); |
0995174d | 874 | goto err_free_dev; |
d38fcb96 | 875 | } |
17dd3f0f | 876 | |
d38fcb96 DT |
877 | break; |
878 | ||
879 | case GC_SNESMOUSE: | |
880 | __set_bit(BTN_LEFT, input_dev->keybit); | |
881 | __set_bit(BTN_RIGHT, input_dev->keybit); | |
882 | __set_bit(REL_X, input_dev->relbit); | |
883 | __set_bit(REL_Y, input_dev->relbit); | |
884 | break; | |
885 | ||
886 | case GC_SNES: | |
887 | for (i = 4; i < 8; i++) | |
888 | __set_bit(gc_snes_btn[i], input_dev->keybit); | |
889 | case GC_NES: | |
890 | for (i = 0; i < 4; i++) | |
891 | __set_bit(gc_snes_btn[i], input_dev->keybit); | |
892 | break; | |
893 | ||
894 | case GC_MULTI2: | |
895 | __set_bit(BTN_THUMB, input_dev->keybit); | |
896 | case GC_MULTI: | |
897 | __set_bit(BTN_TRIGGER, input_dev->keybit); | |
898 | break; | |
899 | ||
900 | case GC_PSX: | |
901 | for (i = 0; i < 6; i++) | |
902 | input_set_abs_params(input_dev, | |
903 | gc_psx_abs[i], 4, 252, 0, 2); | |
904 | for (i = 0; i < 12; i++) | |
905 | __set_bit(gc_psx_btn[i], input_dev->keybit); | |
906 | ||
907 | break; | |
908 | ||
909 | case GC_DDR: | |
910 | for (i = 0; i < 4; i++) | |
911 | __set_bit(gc_psx_ddr_btn[i], input_dev->keybit); | |
912 | for (i = 0; i < 12; i++) | |
913 | __set_bit(gc_psx_btn[i], input_dev->keybit); | |
914 | ||
915 | break; | |
1da177e4 | 916 | } |
8b1a198b | 917 | |
0995174d DT |
918 | err = input_register_device(pad->dev); |
919 | if (err) | |
920 | goto err_free_dev; | |
921 | ||
17dd3f0f | 922 | return 0; |
0995174d DT |
923 | |
924 | err_free_dev: | |
925 | input_free_device(pad->dev); | |
926 | pad->dev = NULL; | |
927 | return err; | |
17dd3f0f | 928 | } |
1da177e4 | 929 | |
17dd3f0f DT |
930 | static struct gc __init *gc_probe(int parport, int *pads, int n_pads) |
931 | { | |
932 | struct gc *gc; | |
933 | struct parport *pp; | |
934 | struct pardevice *pd; | |
935 | int i; | |
0995174d | 936 | int count = 0; |
17dd3f0f | 937 | int err; |
1da177e4 | 938 | |
17dd3f0f DT |
939 | pp = parport_find_number(parport); |
940 | if (!pp) { | |
a1e12747 | 941 | pr_err("no such parport %d\n", parport); |
17dd3f0f DT |
942 | err = -EINVAL; |
943 | goto err_out; | |
944 | } | |
1da177e4 | 945 | |
17dd3f0f DT |
946 | pd = parport_register_device(pp, "gamecon", NULL, NULL, NULL, PARPORT_DEV_EXCL, NULL); |
947 | if (!pd) { | |
a1e12747 | 948 | pr_err("parport busy already - lp.o loaded?\n"); |
17dd3f0f DT |
949 | err = -EBUSY; |
950 | goto err_put_pp; | |
1da177e4 LT |
951 | } |
952 | ||
17dd3f0f DT |
953 | gc = kzalloc(sizeof(struct gc), GFP_KERNEL); |
954 | if (!gc) { | |
a1e12747 | 955 | pr_err("Not enough memory\n"); |
17dd3f0f DT |
956 | err = -ENOMEM; |
957 | goto err_unreg_pardev; | |
958 | } | |
1da177e4 | 959 | |
72ba9f0c | 960 | mutex_init(&gc->mutex); |
17dd3f0f | 961 | gc->pd = pd; |
d38fcb96 | 962 | setup_timer(&gc->timer, gc_timer, (long) gc); |
1da177e4 | 963 | |
c7fd018d | 964 | for (i = 0; i < n_pads && i < GC_MAX_DEVICES; i++) { |
17dd3f0f | 965 | if (!pads[i]) |
1da177e4 LT |
966 | continue; |
967 | ||
17dd3f0f DT |
968 | err = gc_setup_pad(gc, i, pads[i]); |
969 | if (err) | |
77fc46ca | 970 | goto err_unreg_devs; |
1da177e4 | 971 | |
0995174d | 972 | count++; |
17dd3f0f | 973 | } |
1da177e4 | 974 | |
0995174d | 975 | if (count == 0) { |
a1e12747 | 976 | pr_err("No valid devices specified\n"); |
17dd3f0f DT |
977 | err = -EINVAL; |
978 | goto err_free_gc; | |
979 | } | |
1da177e4 | 980 | |
17dd3f0f DT |
981 | parport_put_port(pp); |
982 | return gc; | |
1da177e4 | 983 | |
77fc46ca | 984 | err_unreg_devs: |
17dd3f0f | 985 | while (--i >= 0) |
0995174d DT |
986 | if (gc->pads[i].dev) |
987 | input_unregister_device(gc->pads[i].dev); | |
17dd3f0f DT |
988 | err_free_gc: |
989 | kfree(gc); | |
990 | err_unreg_pardev: | |
991 | parport_unregister_device(pd); | |
992 | err_put_pp: | |
993 | parport_put_port(pp); | |
994 | err_out: | |
995 | return ERR_PTR(err); | |
996 | } | |
1da177e4 | 997 | |
77fc46ca | 998 | static void gc_remove(struct gc *gc) |
17dd3f0f DT |
999 | { |
1000 | int i; | |
1da177e4 | 1001 | |
17dd3f0f | 1002 | for (i = 0; i < GC_MAX_DEVICES; i++) |
0995174d DT |
1003 | if (gc->pads[i].dev) |
1004 | input_unregister_device(gc->pads[i].dev); | |
17dd3f0f DT |
1005 | parport_unregister_device(gc->pd); |
1006 | kfree(gc); | |
1007 | } | |
1da177e4 | 1008 | |
17dd3f0f DT |
1009 | static int __init gc_init(void) |
1010 | { | |
1011 | int i; | |
1012 | int have_dev = 0; | |
1013 | int err = 0; | |
1da177e4 | 1014 | |
17dd3f0f | 1015 | for (i = 0; i < GC_MAX_PORTS; i++) { |
78167236 | 1016 | if (gc_cfg[i].nargs == 0 || gc_cfg[i].args[0] < 0) |
17dd3f0f | 1017 | continue; |
1da177e4 | 1018 | |
78167236 | 1019 | if (gc_cfg[i].nargs < 2) { |
a1e12747 | 1020 | pr_err("at least one device must be specified\n"); |
17dd3f0f DT |
1021 | err = -EINVAL; |
1022 | break; | |
1da177e4 LT |
1023 | } |
1024 | ||
78167236 DT |
1025 | gc_base[i] = gc_probe(gc_cfg[i].args[0], |
1026 | gc_cfg[i].args + 1, gc_cfg[i].nargs - 1); | |
17dd3f0f DT |
1027 | if (IS_ERR(gc_base[i])) { |
1028 | err = PTR_ERR(gc_base[i]); | |
1029 | break; | |
1030 | } | |
1da177e4 | 1031 | |
17dd3f0f | 1032 | have_dev = 1; |
1da177e4 LT |
1033 | } |
1034 | ||
17dd3f0f DT |
1035 | if (err) { |
1036 | while (--i >= 0) | |
77fc46ca DT |
1037 | if (gc_base[i]) |
1038 | gc_remove(gc_base[i]); | |
17dd3f0f | 1039 | return err; |
1da177e4 LT |
1040 | } |
1041 | ||
17dd3f0f | 1042 | return have_dev ? 0 : -ENODEV; |
1da177e4 LT |
1043 | } |
1044 | ||
1045 | static void __exit gc_exit(void) | |
1046 | { | |
17dd3f0f DT |
1047 | int i; |
1048 | ||
1049 | for (i = 0; i < GC_MAX_PORTS; i++) | |
1050 | if (gc_base[i]) | |
1051 | gc_remove(gc_base[i]); | |
1da177e4 LT |
1052 | } |
1053 | ||
1054 | module_init(gc_init); | |
1055 | module_exit(gc_exit); |