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