]>
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 | |
1da177e4 LT |
10 | */ |
11 | ||
12 | /* | |
13 | * This program is free software; you can redistribute it and/or modify | |
14 | * it under the terms of the GNU General Public License as published by | |
15 | * the Free Software Foundation; either version 2 of the License, or | |
16 | * (at your option) any later version. | |
17 | * | |
18 | * This program is distributed in the hope that it will be useful, | |
19 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
21 | * GNU General Public License for more details. | |
22 | * | |
23 | * You should have received a copy of the GNU General Public License | |
24 | * along with this program; if not, write to the Free Software | |
25 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
26 | * | |
27 | * Should you need to contact me, the author, you can do so either by | |
28 | * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail: | |
29 | * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic | |
30 | */ | |
31 | ||
32 | #include <linux/kernel.h> | |
33 | #include <linux/delay.h> | |
34 | #include <linux/module.h> | |
35 | #include <linux/moduleparam.h> | |
36 | #include <linux/init.h> | |
37 | #include <linux/parport.h> | |
38 | #include <linux/input.h> | |
39 | ||
40 | MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>"); | |
41 | MODULE_DESCRIPTION("NES, SNES, N64, MultiSystem, PSX gamepad driver"); | |
42 | MODULE_LICENSE("GPL"); | |
43 | ||
44 | static int gc[] __initdata = { -1, 0, 0, 0, 0, 0 }; | |
45 | static int gc_nargs __initdata = 0; | |
46 | module_param_array_named(map, gc, int, &gc_nargs, 0); | |
47 | MODULE_PARM_DESC(map, "Describers first set of devices (<parport#>,<pad1>,<pad2>,..<pad5>)"); | |
48 | ||
49 | static int gc_2[] __initdata = { -1, 0, 0, 0, 0, 0 }; | |
50 | static int gc_nargs_2 __initdata = 0; | |
51 | module_param_array_named(map2, gc_2, int, &gc_nargs_2, 0); | |
52 | MODULE_PARM_DESC(map2, "Describers second set of devices"); | |
53 | ||
54 | static int gc_3[] __initdata = { -1, 0, 0, 0, 0, 0 }; | |
55 | static int gc_nargs_3 __initdata = 0; | |
56 | module_param_array_named(map3, gc_3, int, &gc_nargs_3, 0); | |
57 | MODULE_PARM_DESC(map3, "Describers third set of devices"); | |
58 | ||
59 | __obsolete_setup("gc="); | |
60 | __obsolete_setup("gc_2="); | |
61 | __obsolete_setup("gc_3="); | |
62 | ||
63 | /* see also gs_psx_delay parameter in PSX support section */ | |
64 | ||
65 | #define GC_SNES 1 | |
66 | #define GC_NES 2 | |
67 | #define GC_NES4 3 | |
68 | #define GC_MULTI 4 | |
69 | #define GC_MULTI2 5 | |
70 | #define GC_N64 6 | |
71 | #define GC_PSX 7 | |
72 | #define GC_DDR 8 | |
73 | ||
74 | #define GC_MAX 8 | |
75 | ||
76 | #define GC_REFRESH_TIME HZ/100 | |
77 | ||
78 | struct gc { | |
79 | struct pardevice *pd; | |
80 | struct input_dev dev[5]; | |
81 | struct timer_list timer; | |
82 | unsigned char pads[GC_MAX + 1]; | |
83 | int used; | |
84 | char phys[5][32]; | |
85 | }; | |
86 | ||
87 | static struct gc *gc_base[3]; | |
88 | ||
89 | static int gc_status_bit[] = { 0x40, 0x80, 0x20, 0x10, 0x08 }; | |
90 | ||
91 | static char *gc_names[] = { NULL, "SNES pad", "NES pad", "NES FourPort", "Multisystem joystick", | |
92 | "Multisystem 2-button joystick", "N64 controller", "PSX controller", | |
93 | "PSX DDR controller" }; | |
94 | /* | |
95 | * N64 support. | |
96 | */ | |
97 | ||
98 | static unsigned char gc_n64_bytes[] = { 0, 1, 13, 15, 14, 12, 10, 11, 2, 3 }; | |
99 | static short gc_n64_btn[] = { BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, BTN_TL, BTN_TR, BTN_TRIGGER, BTN_START }; | |
100 | ||
101 | #define GC_N64_LENGTH 32 /* N64 bit length, not including stop bit */ | |
102 | #define GC_N64_REQUEST_LENGTH 37 /* transmit request sequence is 9 bits long */ | |
103 | #define GC_N64_DELAY 133 /* delay between transmit request, and response ready (us) */ | |
104 | #define GC_N64_REQUEST 0x1dd1111111ULL /* the request data command (encoded for 000000011) */ | |
105 | #define GC_N64_DWS 3 /* delay between write segments (required for sound playback because of ISA DMA) */ | |
106 | /* GC_N64_DWS > 24 is known to fail */ | |
107 | #define GC_N64_POWER_W 0xe2 /* power during write (transmit request) */ | |
108 | #define GC_N64_POWER_R 0xfd /* power during read */ | |
109 | #define GC_N64_OUT 0x1d /* output bits to the 4 pads */ | |
110 | /* Reading the main axes of any N64 pad is known to fail if the corresponding bit */ | |
111 | /* in GC_N64_OUT is pulled low on the output port (by any routine) for more */ | |
112 | /* than 123 us */ | |
113 | #define GC_N64_CLOCK 0x02 /* clock bits for read */ | |
114 | ||
115 | /* | |
116 | * gc_n64_read_packet() reads an N64 packet. | |
117 | * Each pad uses one bit per byte. So all pads connected to this port are read in parallel. | |
118 | */ | |
119 | ||
120 | static void gc_n64_read_packet(struct gc *gc, unsigned char *data) | |
121 | { | |
122 | int i; | |
123 | unsigned long flags; | |
124 | ||
125 | /* | |
126 | * Request the pad to transmit data | |
127 | */ | |
128 | ||
129 | local_irq_save(flags); | |
130 | for (i = 0; i < GC_N64_REQUEST_LENGTH; i++) { | |
131 | parport_write_data(gc->pd->port, GC_N64_POWER_W | ((GC_N64_REQUEST >> i) & 1 ? GC_N64_OUT : 0)); | |
132 | udelay(GC_N64_DWS); | |
133 | } | |
134 | local_irq_restore(flags); | |
135 | ||
136 | /* | |
137 | * Wait for the pad response to be loaded into the 33-bit register of the adapter | |
138 | */ | |
139 | ||
140 | udelay(GC_N64_DELAY); | |
141 | ||
142 | /* | |
143 | * Grab data (ignoring the last bit, which is a stop bit) | |
144 | */ | |
145 | ||
146 | for (i = 0; i < GC_N64_LENGTH; i++) { | |
147 | parport_write_data(gc->pd->port, GC_N64_POWER_R); | |
148 | data[i] = parport_read_status(gc->pd->port); | |
149 | parport_write_data(gc->pd->port, GC_N64_POWER_R | GC_N64_CLOCK); | |
150 | } | |
151 | ||
152 | /* | |
153 | * We must wait 200 ms here for the controller to reinitialize before the next read request. | |
154 | * No worries as long as gc_read is polled less frequently than this. | |
155 | */ | |
156 | ||
157 | } | |
158 | ||
159 | /* | |
160 | * NES/SNES support. | |
161 | */ | |
162 | ||
163 | #define GC_NES_DELAY 6 /* Delay between bits - 6us */ | |
164 | #define GC_NES_LENGTH 8 /* The NES pads use 8 bits of data */ | |
165 | #define GC_SNES_LENGTH 12 /* The SNES true length is 16, but the last 4 bits are unused */ | |
166 | ||
167 | #define GC_NES_POWER 0xfc | |
168 | #define GC_NES_CLOCK 0x01 | |
169 | #define GC_NES_LATCH 0x02 | |
170 | ||
171 | static unsigned char gc_nes_bytes[] = { 0, 1, 2, 3 }; | |
172 | static unsigned char gc_snes_bytes[] = { 8, 0, 2, 3, 9, 1, 10, 11 }; | |
173 | static short gc_snes_btn[] = { BTN_A, BTN_B, BTN_SELECT, BTN_START, BTN_X, BTN_Y, BTN_TL, BTN_TR }; | |
174 | ||
175 | /* | |
176 | * gc_nes_read_packet() reads a NES/SNES packet. | |
177 | * Each pad uses one bit per byte. So all pads connected to | |
178 | * this port are read in parallel. | |
179 | */ | |
180 | ||
181 | static void gc_nes_read_packet(struct gc *gc, int length, unsigned char *data) | |
182 | { | |
183 | int i; | |
184 | ||
185 | parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK | GC_NES_LATCH); | |
186 | udelay(GC_NES_DELAY * 2); | |
187 | parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK); | |
188 | ||
189 | for (i = 0; i < length; i++) { | |
190 | udelay(GC_NES_DELAY); | |
191 | parport_write_data(gc->pd->port, GC_NES_POWER); | |
192 | data[i] = parport_read_status(gc->pd->port) ^ 0x7f; | |
193 | udelay(GC_NES_DELAY); | |
194 | parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK); | |
195 | } | |
196 | } | |
197 | ||
198 | /* | |
199 | * Multisystem joystick support | |
200 | */ | |
201 | ||
202 | #define GC_MULTI_LENGTH 5 /* Multi system joystick packet length is 5 */ | |
203 | #define GC_MULTI2_LENGTH 6 /* One more bit for one more button */ | |
204 | ||
205 | /* | |
206 | * gc_multi_read_packet() reads a Multisystem joystick packet. | |
207 | */ | |
208 | ||
209 | static void gc_multi_read_packet(struct gc *gc, int length, unsigned char *data) | |
210 | { | |
211 | int i; | |
212 | ||
213 | for (i = 0; i < length; i++) { | |
214 | parport_write_data(gc->pd->port, ~(1 << i)); | |
215 | data[i] = parport_read_status(gc->pd->port) ^ 0x7f; | |
216 | } | |
217 | } | |
218 | ||
219 | /* | |
220 | * PSX support | |
221 | * | |
222 | * See documentation at: | |
223 | * http://www.dim.com/~mackys/psxmemcard/ps-eng2.txt | |
224 | * http://www.gamesx.com/controldata/psxcont/psxcont.htm | |
225 | * ftp://milano.usal.es/pablo/ | |
226 | * | |
227 | */ | |
228 | ||
229 | #define GC_PSX_DELAY 25 /* 25 usec */ | |
230 | #define GC_PSX_LENGTH 8 /* talk to the controller in bits */ | |
231 | #define GC_PSX_BYTES 6 /* the maximum number of bytes to read off the controller */ | |
232 | ||
233 | #define GC_PSX_MOUSE 1 /* Mouse */ | |
234 | #define GC_PSX_NEGCON 2 /* NegCon */ | |
235 | #define GC_PSX_NORMAL 4 /* Digital / Analog or Rumble in Digital mode */ | |
236 | #define GC_PSX_ANALOG 5 /* Analog in Analog mode / Rumble in Green mode */ | |
237 | #define GC_PSX_RUMBLE 7 /* Rumble in Red mode */ | |
238 | ||
239 | #define GC_PSX_CLOCK 0x04 /* Pin 4 */ | |
240 | #define GC_PSX_COMMAND 0x01 /* Pin 2 */ | |
241 | #define GC_PSX_POWER 0xf8 /* Pins 5-9 */ | |
242 | #define GC_PSX_SELECT 0x02 /* Pin 3 */ | |
243 | ||
244 | #define GC_PSX_ID(x) ((x) >> 4) /* High nibble is device type */ | |
245 | #define GC_PSX_LEN(x) (((x) & 0xf) << 1) /* Low nibble is length in bytes/2 */ | |
246 | ||
247 | static int gc_psx_delay = GC_PSX_DELAY; | |
248 | module_param_named(psx_delay, gc_psx_delay, uint, 0); | |
249 | MODULE_PARM_DESC(psx_delay, "Delay when accessing Sony PSX controller (usecs)"); | |
250 | ||
251 | __obsolete_setup("gc_psx_delay="); | |
252 | ||
253 | static short gc_psx_abs[] = { ABS_X, ABS_Y, ABS_RX, ABS_RY, ABS_HAT0X, ABS_HAT0Y }; | |
254 | static short gc_psx_btn[] = { BTN_TL, BTN_TR, BTN_TL2, BTN_TR2, BTN_A, BTN_B, BTN_X, BTN_Y, | |
255 | BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR }; | |
256 | static short gc_psx_ddr_btn[] = { BTN_0, BTN_1, BTN_2, BTN_3 }; | |
257 | ||
258 | /* | |
259 | * gc_psx_command() writes 8bit command and reads 8bit data from | |
260 | * the psx pad. | |
261 | */ | |
262 | ||
263 | static void gc_psx_command(struct gc *gc, int b, unsigned char data[5]) | |
264 | { | |
265 | int i, j, cmd, read; | |
266 | for (i = 0; i < 5; i++) | |
267 | data[i] = 0; | |
268 | ||
269 | for (i = 0; i < GC_PSX_LENGTH; i++, b >>= 1) { | |
270 | cmd = (b & 1) ? GC_PSX_COMMAND : 0; | |
271 | parport_write_data(gc->pd->port, cmd | GC_PSX_POWER); | |
272 | udelay(gc_psx_delay); | |
273 | read = parport_read_status(gc->pd->port) ^ 0x80; | |
274 | for (j = 0; j < 5; j++) | |
275 | data[j] |= (read & gc_status_bit[j] & (gc->pads[GC_PSX] | gc->pads[GC_DDR])) ? (1 << i) : 0; | |
276 | parport_write_data(gc->pd->port, cmd | GC_PSX_CLOCK | GC_PSX_POWER); | |
277 | udelay(gc_psx_delay); | |
278 | } | |
279 | } | |
280 | ||
281 | /* | |
282 | * gc_psx_read_packet() reads a whole psx packet and returns | |
283 | * device identifier code. | |
284 | */ | |
285 | ||
286 | static void gc_psx_read_packet(struct gc *gc, unsigned char data[5][GC_PSX_BYTES], unsigned char id[5]) | |
287 | { | |
288 | int i, j, max_len = 0; | |
289 | unsigned long flags; | |
290 | unsigned char data2[5]; | |
291 | ||
292 | parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER); /* Select pad */ | |
293 | udelay(gc_psx_delay); | |
294 | parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_POWER); /* Deselect, begin command */ | |
295 | udelay(gc_psx_delay); | |
296 | ||
297 | local_irq_save(flags); | |
298 | ||
299 | gc_psx_command(gc, 0x01, data2); /* Access pad */ | |
300 | gc_psx_command(gc, 0x42, id); /* Get device ids */ | |
301 | gc_psx_command(gc, 0, data2); /* Dump status */ | |
302 | ||
303 | for (i =0; i < 5; i++) /* Find the longest pad */ | |
304 | if((gc_status_bit[i] & (gc->pads[GC_PSX] | gc->pads[GC_DDR])) | |
305 | && (GC_PSX_LEN(id[i]) > max_len) | |
306 | && (GC_PSX_LEN(id[i]) <= GC_PSX_BYTES)) | |
307 | max_len = GC_PSX_LEN(id[i]); | |
308 | ||
309 | for (i = 0; i < max_len; i++) { /* Read in all the data */ | |
310 | gc_psx_command(gc, 0, data2); | |
311 | for (j = 0; j < 5; j++) | |
312 | data[j][i] = data2[j]; | |
313 | } | |
314 | ||
315 | local_irq_restore(flags); | |
316 | ||
317 | parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER); | |
318 | ||
319 | for(i = 0; i < 5; i++) /* Set id's to the real value */ | |
320 | id[i] = GC_PSX_ID(id[i]); | |
321 | } | |
322 | ||
323 | /* | |
324 | * gc_timer() reads and analyzes console pads data. | |
325 | */ | |
326 | ||
327 | #define GC_MAX_LENGTH GC_N64_LENGTH | |
328 | ||
329 | static void gc_timer(unsigned long private) | |
330 | { | |
331 | struct gc *gc = (void *) private; | |
332 | struct input_dev *dev = gc->dev; | |
333 | unsigned char data[GC_MAX_LENGTH]; | |
334 | unsigned char data_psx[5][GC_PSX_BYTES]; | |
335 | int i, j, s; | |
336 | ||
337 | /* | |
338 | * N64 pads - must be read first, any read confuses them for 200 us | |
339 | */ | |
340 | ||
341 | if (gc->pads[GC_N64]) { | |
342 | ||
343 | gc_n64_read_packet(gc, data); | |
344 | ||
345 | for (i = 0; i < 5; i++) { | |
346 | ||
347 | s = gc_status_bit[i]; | |
348 | ||
349 | if (s & gc->pads[GC_N64] & ~(data[8] | data[9])) { | |
350 | ||
351 | signed char axes[2]; | |
352 | axes[0] = axes[1] = 0; | |
353 | ||
354 | for (j = 0; j < 8; j++) { | |
355 | if (data[23 - j] & s) axes[0] |= 1 << j; | |
356 | if (data[31 - j] & s) axes[1] |= 1 << j; | |
357 | } | |
358 | ||
359 | input_report_abs(dev + i, ABS_X, axes[0]); | |
360 | input_report_abs(dev + i, ABS_Y, -axes[1]); | |
361 | ||
362 | input_report_abs(dev + i, ABS_HAT0X, !(s & data[6]) - !(s & data[7])); | |
363 | input_report_abs(dev + i, ABS_HAT0Y, !(s & data[4]) - !(s & data[5])); | |
364 | ||
365 | for (j = 0; j < 10; j++) | |
366 | input_report_key(dev + i, gc_n64_btn[j], s & data[gc_n64_bytes[j]]); | |
367 | ||
368 | input_sync(dev + i); | |
369 | } | |
370 | } | |
371 | } | |
372 | ||
373 | /* | |
374 | * NES and SNES pads | |
375 | */ | |
376 | ||
377 | if (gc->pads[GC_NES] || gc->pads[GC_SNES]) { | |
378 | ||
379 | gc_nes_read_packet(gc, gc->pads[GC_SNES] ? GC_SNES_LENGTH : GC_NES_LENGTH, data); | |
380 | ||
381 | for (i = 0; i < 5; i++) { | |
382 | ||
383 | s = gc_status_bit[i]; | |
384 | ||
385 | if (s & (gc->pads[GC_NES] | gc->pads[GC_SNES])) { | |
386 | input_report_abs(dev + i, ABS_X, !(s & data[6]) - !(s & data[7])); | |
387 | input_report_abs(dev + i, ABS_Y, !(s & data[4]) - !(s & data[5])); | |
388 | } | |
389 | ||
390 | if (s & gc->pads[GC_NES]) | |
391 | for (j = 0; j < 4; j++) | |
392 | input_report_key(dev + i, gc_snes_btn[j], s & data[gc_nes_bytes[j]]); | |
393 | ||
394 | if (s & gc->pads[GC_SNES]) | |
395 | for (j = 0; j < 8; j++) | |
396 | input_report_key(dev + i, gc_snes_btn[j], s & data[gc_snes_bytes[j]]); | |
397 | ||
398 | input_sync(dev + i); | |
399 | } | |
400 | } | |
401 | ||
402 | /* | |
403 | * Multi and Multi2 joysticks | |
404 | */ | |
405 | ||
406 | if (gc->pads[GC_MULTI] || gc->pads[GC_MULTI2]) { | |
407 | ||
408 | gc_multi_read_packet(gc, gc->pads[GC_MULTI2] ? GC_MULTI2_LENGTH : GC_MULTI_LENGTH, data); | |
409 | ||
410 | for (i = 0; i < 5; i++) { | |
411 | ||
412 | s = gc_status_bit[i]; | |
413 | ||
414 | if (s & (gc->pads[GC_MULTI] | gc->pads[GC_MULTI2])) { | |
415 | input_report_abs(dev + i, ABS_X, !(s & data[2]) - !(s & data[3])); | |
416 | input_report_abs(dev + i, ABS_Y, !(s & data[0]) - !(s & data[1])); | |
417 | input_report_key(dev + i, BTN_TRIGGER, s & data[4]); | |
418 | } | |
419 | ||
420 | if (s & gc->pads[GC_MULTI2]) | |
421 | input_report_key(dev + i, BTN_THUMB, s & data[5]); | |
422 | ||
423 | input_sync(dev + i); | |
424 | } | |
425 | } | |
426 | ||
427 | /* | |
428 | * PSX controllers | |
429 | */ | |
430 | ||
431 | if (gc->pads[GC_PSX] || gc->pads[GC_DDR]) { | |
432 | ||
433 | gc_psx_read_packet(gc, data_psx, data); | |
434 | ||
435 | for (i = 0; i < 5; i++) { | |
ab0c3443 | 436 | switch (data[i]) { |
1da177e4 LT |
437 | |
438 | case GC_PSX_RUMBLE: | |
439 | ||
440 | input_report_key(dev + i, BTN_THUMBL, ~data_psx[i][0] & 0x04); | |
441 | input_report_key(dev + i, BTN_THUMBR, ~data_psx[i][0] & 0x02); | |
442 | ||
443 | case GC_PSX_NEGCON: | |
444 | case GC_PSX_ANALOG: | |
445 | ||
446 | if(gc->pads[GC_DDR] & gc_status_bit[i]) { | |
447 | for(j = 0; j < 4; j++) | |
448 | input_report_key(dev + i, gc_psx_ddr_btn[j], ~data_psx[i][0] & (0x10 << j)); | |
449 | } else { | |
450 | for (j = 0; j < 4; j++) | |
451 | input_report_abs(dev + i, gc_psx_abs[j+2], data_psx[i][j + 2]); | |
452 | ||
453 | input_report_abs(dev + i, ABS_X, 128 + !(data_psx[i][0] & 0x20) * 127 - !(data_psx[i][0] & 0x80) * 128); | |
454 | input_report_abs(dev + i, ABS_Y, 128 + !(data_psx[i][0] & 0x40) * 127 - !(data_psx[i][0] & 0x10) * 128); | |
455 | } | |
456 | ||
457 | for (j = 0; j < 8; j++) | |
458 | input_report_key(dev + i, gc_psx_btn[j], ~data_psx[i][1] & (1 << j)); | |
459 | ||
460 | input_report_key(dev + i, BTN_START, ~data_psx[i][0] & 0x08); | |
461 | input_report_key(dev + i, BTN_SELECT, ~data_psx[i][0] & 0x01); | |
462 | ||
463 | input_sync(dev + i); | |
464 | ||
465 | break; | |
466 | ||
467 | case GC_PSX_NORMAL: | |
468 | if(gc->pads[GC_DDR] & gc_status_bit[i]) { | |
469 | for(j = 0; j < 4; j++) | |
470 | input_report_key(dev + i, gc_psx_ddr_btn[j], ~data_psx[i][0] & (0x10 << j)); | |
471 | } else { | |
472 | input_report_abs(dev + i, ABS_X, 128 + !(data_psx[i][0] & 0x20) * 127 - !(data_psx[i][0] & 0x80) * 128); | |
473 | input_report_abs(dev + i, ABS_Y, 128 + !(data_psx[i][0] & 0x40) * 127 - !(data_psx[i][0] & 0x10) * 128); | |
474 | ||
475 | /* for some reason if the extra axes are left unset they drift */ | |
476 | /* for (j = 0; j < 4; j++) | |
477 | input_report_abs(dev + i, gc_psx_abs[j+2], 128); | |
478 | * This needs to be debugged properly, | |
479 | * maybe fuzz processing needs to be done in input_sync() | |
480 | * --vojtech | |
481 | */ | |
482 | } | |
483 | ||
484 | for (j = 0; j < 8; j++) | |
485 | input_report_key(dev + i, gc_psx_btn[j], ~data_psx[i][1] & (1 << j)); | |
486 | ||
487 | input_report_key(dev + i, BTN_START, ~data_psx[i][0] & 0x08); | |
488 | input_report_key(dev + i, BTN_SELECT, ~data_psx[i][0] & 0x01); | |
489 | ||
490 | input_sync(dev + i); | |
491 | ||
492 | break; | |
493 | ||
494 | case 0: /* not a pad, ignore */ | |
495 | break; | |
496 | } | |
497 | } | |
498 | } | |
499 | ||
500 | mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME); | |
501 | } | |
502 | ||
503 | static int gc_open(struct input_dev *dev) | |
504 | { | |
505 | struct gc *gc = dev->private; | |
506 | if (!gc->used++) { | |
507 | parport_claim(gc->pd); | |
508 | parport_write_control(gc->pd->port, 0x04); | |
509 | mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME); | |
510 | } | |
511 | return 0; | |
512 | } | |
513 | ||
514 | static void gc_close(struct input_dev *dev) | |
515 | { | |
516 | struct gc *gc = dev->private; | |
517 | if (!--gc->used) { | |
518 | del_timer(&gc->timer); | |
519 | parport_write_control(gc->pd->port, 0x00); | |
520 | parport_release(gc->pd); | |
521 | } | |
522 | } | |
523 | ||
524 | static struct gc __init *gc_probe(int *config, int nargs) | |
525 | { | |
526 | struct gc *gc; | |
527 | struct parport *pp; | |
528 | int i, j; | |
529 | ||
530 | if (config[0] < 0) | |
531 | return NULL; | |
532 | ||
533 | if (nargs < 2) { | |
534 | printk(KERN_ERR "gamecon.c: at least one device must be specified\n"); | |
535 | return NULL; | |
536 | } | |
537 | ||
538 | pp = parport_find_number(config[0]); | |
539 | ||
540 | if (!pp) { | |
541 | printk(KERN_ERR "gamecon.c: no such parport\n"); | |
542 | return NULL; | |
543 | } | |
544 | ||
545 | if (!(gc = kmalloc(sizeof(struct gc), GFP_KERNEL))) { | |
546 | parport_put_port(pp); | |
547 | return NULL; | |
548 | } | |
549 | memset(gc, 0, sizeof(struct gc)); | |
550 | ||
551 | gc->pd = parport_register_device(pp, "gamecon", NULL, NULL, NULL, PARPORT_DEV_EXCL, NULL); | |
552 | ||
553 | parport_put_port(pp); | |
554 | ||
555 | if (!gc->pd) { | |
556 | printk(KERN_ERR "gamecon.c: parport busy already - lp.o loaded?\n"); | |
557 | kfree(gc); | |
558 | return NULL; | |
559 | } | |
560 | ||
561 | parport_claim(gc->pd); | |
562 | ||
563 | init_timer(&gc->timer); | |
564 | gc->timer.data = (long) gc; | |
565 | gc->timer.function = gc_timer; | |
566 | ||
567 | for (i = 0; i < nargs - 1; i++) { | |
568 | ||
569 | if (!config[i + 1]) | |
570 | continue; | |
571 | ||
572 | if (config[i + 1] < 1 || config[i + 1] > GC_MAX) { | |
573 | printk(KERN_WARNING "gamecon.c: Pad type %d unknown\n", config[i + 1]); | |
574 | continue; | |
575 | } | |
576 | ||
577 | gc->dev[i].private = gc; | |
578 | gc->dev[i].open = gc_open; | |
579 | gc->dev[i].close = gc_close; | |
580 | ||
581 | gc->dev[i].evbit[0] = BIT(EV_KEY) | BIT(EV_ABS); | |
582 | ||
583 | for (j = 0; j < 2; j++) { | |
584 | set_bit(ABS_X + j, gc->dev[i].absbit); | |
585 | gc->dev[i].absmin[ABS_X + j] = -1; | |
586 | gc->dev[i].absmax[ABS_X + j] = 1; | |
587 | } | |
588 | ||
589 | gc->pads[0] |= gc_status_bit[i]; | |
590 | gc->pads[config[i + 1]] |= gc_status_bit[i]; | |
591 | ||
592 | switch(config[i + 1]) { | |
593 | ||
594 | case GC_N64: | |
595 | for (j = 0; j < 10; j++) | |
596 | set_bit(gc_n64_btn[j], gc->dev[i].keybit); | |
597 | ||
598 | for (j = 0; j < 2; j++) { | |
599 | set_bit(ABS_X + j, gc->dev[i].absbit); | |
600 | gc->dev[i].absmin[ABS_X + j] = -127; | |
601 | gc->dev[i].absmax[ABS_X + j] = 126; | |
602 | gc->dev[i].absflat[ABS_X + j] = 2; | |
603 | set_bit(ABS_HAT0X + j, gc->dev[i].absbit); | |
604 | gc->dev[i].absmin[ABS_HAT0X + j] = -1; | |
605 | gc->dev[i].absmax[ABS_HAT0X + j] = 1; | |
606 | } | |
607 | ||
608 | break; | |
609 | ||
610 | case GC_SNES: | |
611 | for (j = 4; j < 8; j++) | |
612 | set_bit(gc_snes_btn[j], gc->dev[i].keybit); | |
613 | case GC_NES: | |
614 | for (j = 0; j < 4; j++) | |
615 | set_bit(gc_snes_btn[j], gc->dev[i].keybit); | |
616 | break; | |
617 | ||
618 | case GC_MULTI2: | |
619 | set_bit(BTN_THUMB, gc->dev[i].keybit); | |
620 | case GC_MULTI: | |
621 | set_bit(BTN_TRIGGER, gc->dev[i].keybit); | |
622 | break; | |
623 | ||
624 | case GC_PSX: | |
625 | case GC_DDR: | |
626 | if(config[i + 1] == GC_DDR) { | |
627 | for (j = 0; j < 4; j++) | |
628 | set_bit(gc_psx_ddr_btn[j], gc->dev[i].keybit); | |
629 | } else { | |
630 | for (j = 0; j < 6; j++) { | |
631 | set_bit(gc_psx_abs[j], gc->dev[i].absbit); | |
632 | gc->dev[i].absmin[gc_psx_abs[j]] = 4; | |
633 | gc->dev[i].absmax[gc_psx_abs[j]] = 252; | |
634 | gc->dev[i].absflat[gc_psx_abs[j]] = 2; | |
635 | } | |
636 | } | |
637 | ||
638 | for (j = 0; j < 12; j++) | |
639 | set_bit(gc_psx_btn[j], gc->dev[i].keybit); | |
640 | ||
641 | break; | |
642 | } | |
643 | ||
644 | sprintf(gc->phys[i], "%s/input%d", gc->pd->port->name, i); | |
645 | ||
646 | gc->dev[i].name = gc_names[config[i + 1]]; | |
647 | gc->dev[i].phys = gc->phys[i]; | |
648 | gc->dev[i].id.bustype = BUS_PARPORT; | |
649 | gc->dev[i].id.vendor = 0x0001; | |
650 | gc->dev[i].id.product = config[i + 1]; | |
651 | gc->dev[i].id.version = 0x0100; | |
652 | } | |
653 | ||
654 | parport_release(gc->pd); | |
655 | ||
656 | if (!gc->pads[0]) { | |
657 | parport_unregister_device(gc->pd); | |
658 | kfree(gc); | |
659 | return NULL; | |
660 | } | |
661 | ||
662 | for (i = 0; i < 5; i++) | |
663 | if (gc->pads[0] & gc_status_bit[i]) { | |
664 | input_register_device(gc->dev + i); | |
665 | printk(KERN_INFO "input: %s on %s\n", gc->dev[i].name, gc->pd->port->name); | |
666 | } | |
667 | ||
668 | return gc; | |
669 | } | |
670 | ||
671 | static int __init gc_init(void) | |
672 | { | |
673 | gc_base[0] = gc_probe(gc, gc_nargs); | |
674 | gc_base[1] = gc_probe(gc_2, gc_nargs_2); | |
675 | gc_base[2] = gc_probe(gc_3, gc_nargs_3); | |
676 | ||
677 | if (gc_base[0] || gc_base[1] || gc_base[2]) | |
678 | return 0; | |
679 | ||
680 | return -ENODEV; | |
681 | } | |
682 | ||
683 | static void __exit gc_exit(void) | |
684 | { | |
685 | int i, j; | |
686 | ||
687 | for (i = 0; i < 3; i++) | |
688 | if (gc_base[i]) { | |
689 | for (j = 0; j < 5; j++) | |
690 | if (gc_base[i]->pads[0] & gc_status_bit[j]) | |
691 | input_unregister_device(gc_base[i]->dev + j); | |
692 | parport_unregister_device(gc_base[i]->pd); | |
693 | } | |
694 | } | |
695 | ||
696 | module_init(gc_init); | |
697 | module_exit(gc_exit); |