diff options
Diffstat (limited to 'apps/plugins/sdl/src/joystick/mint')
-rw-r--r-- | apps/plugins/sdl/src/joystick/mint/SDL_sysjoystick.c | 826 |
1 files changed, 0 insertions, 826 deletions
diff --git a/apps/plugins/sdl/src/joystick/mint/SDL_sysjoystick.c b/apps/plugins/sdl/src/joystick/mint/SDL_sysjoystick.c deleted file mode 100644 index 9a36152927..0000000000 --- a/apps/plugins/sdl/src/joystick/mint/SDL_sysjoystick.c +++ /dev/null | |||
@@ -1,826 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | #ifdef SDL_JOYSTICK_MINT | ||
25 | |||
26 | /* | ||
27 | * Atari Joystick/Joypad drivers | ||
28 | * | ||
29 | * Patrice Mandin | ||
30 | */ | ||
31 | |||
32 | #include <mint/cookie.h> | ||
33 | #include <mint/osbind.h> | ||
34 | |||
35 | #include "SDL_events.h" | ||
36 | #include "../SDL_sysjoystick.h" | ||
37 | #include "../SDL_joystick_c.h" | ||
38 | |||
39 | #include "../../video/ataricommon/SDL_ikbdinterrupt_s.h" | ||
40 | #include "../../video/ataricommon/SDL_xbiosevents_c.h" | ||
41 | #include "../../video/ataricommon/SDL_xbiosinterrupt_s.h" | ||
42 | |||
43 | /*--- Const ---*/ | ||
44 | |||
45 | /* We can have: | ||
46 | 1 joystick on IKBD port 1, read via hardware I/O | ||
47 | or same joystick on IKBD port 1, read via xbios | ||
48 | 1 joypad on port A (up to 4 with teamtap) | ||
49 | or 2 joysticks on joypad port A | ||
50 | or 1 analog paddle on joypad port A | ||
51 | or 1 lightpen on joypad port A | ||
52 | 1 joypad on port B (up to 4 with teamtap) | ||
53 | or 2 joysticks on joypad port B | ||
54 | or 1 analog paddle on joypad port B | ||
55 | 2 joysticks on parallel port | ||
56 | */ | ||
57 | |||
58 | enum { | ||
59 | IKBD_JOY1=0, | ||
60 | XBIOS_JOY1, | ||
61 | PORTA_PAD0, | ||
62 | PORTA_PAD1, | ||
63 | PORTA_PAD2, | ||
64 | PORTA_PAD3, | ||
65 | PORTB_PAD0, | ||
66 | PORTB_PAD1, | ||
67 | PORTB_PAD2, | ||
68 | PORTB_PAD3, | ||
69 | PORTA_JOY0, | ||
70 | PORTA_JOY1, | ||
71 | PORTB_JOY0, | ||
72 | PORTB_JOY1, | ||
73 | PORTA_LP, | ||
74 | PORTA_ANPAD, | ||
75 | PORTB_ANPAD, | ||
76 | #if 0 | ||
77 | PARA_JOY0, | ||
78 | PARA_JOY1, | ||
79 | #endif | ||
80 | MAX_JOYSTICKS | ||
81 | }; | ||
82 | |||
83 | enum { | ||
84 | MCH_ST=0, | ||
85 | MCH_STE, | ||
86 | MCH_TT, | ||
87 | MCH_F30, | ||
88 | MCH_CLONE, | ||
89 | MCH_ARANYM | ||
90 | }; | ||
91 | |||
92 | /* Joypad buttons | ||
93 | * Procontroller note: | ||
94 | * L,R are connected to 4,6 | ||
95 | * X,Y,Z are connected to 7,8,9 | ||
96 | */ | ||
97 | |||
98 | enum { | ||
99 | JP_UP=0, JP_DOWN, JP_LEFT, JP_RIGHT, | ||
100 | JP_KPMULT, JP_KP7, JP_KP4, JP_KP1, | ||
101 | JP_KP0, JP_KP8, JP_KP5, JP_KP2, | ||
102 | JP_KPNUM, JP_KP9, JP_KP6, JP_KP3, | ||
103 | JP_PAUSE, JP_FIRE0, JP_UNDEF0, JP_FIRE1, | ||
104 | JP_UNDEF1, JP_FIRE2, JP_UNDEF2, JP_OPTION | ||
105 | }; | ||
106 | |||
107 | #define JP_NUM_BUTTONS 17 | ||
108 | |||
109 | #define PORT_JS_RIGHT (1<<0) | ||
110 | #define PORT_JS_LEFT (1<<1) | ||
111 | #define PORT_JS_DOWN (1<<2) | ||
112 | #define PORT_JS_UP (1<<3) | ||
113 | #define PORT_JS_FIRE (1<<4) | ||
114 | |||
115 | enum { | ||
116 | TEAMTAP_MAYBE=0, | ||
117 | TEAMTAP_YES, | ||
118 | TEAMTAP_NO | ||
119 | }; | ||
120 | |||
121 | /* Teamtap detection values */ | ||
122 | static const Uint32 teamtap_ghosts[20][4]={ | ||
123 | {1<<JP_UP, /* for this event on joypad 0, port X */ | ||
124 | (1<<JP_UP)|(1<<JP_KP0), /* we get this on joypad 1 */ | ||
125 | (1<<JP_UP)|(1<<JP_KPNUM)|(1<<JP_KP0), /* this on joypad 2 */ | ||
126 | (1<<JP_KPMULT)|(1<<JP_KP0)}, /* this on joypad 3 */ | ||
127 | {1<<JP_DOWN, | ||
128 | (1<<JP_DOWN)|(1<<JP_KP8), | ||
129 | (1<<JP_DOWN)|(1<<JP_KP9)|(1<<JP_KP8), | ||
130 | (1<<JP_KP7)|(1<<JP_KP8)}, | ||
131 | {1<<JP_LEFT, | ||
132 | (1<<JP_LEFT)|(1<<JP_KP5), | ||
133 | (1<<JP_LEFT)|(1<<JP_KP6)|(1<<JP_KP5), | ||
134 | (1<<JP_KP4)|(1<<JP_KP5)}, | ||
135 | {1<<JP_RIGHT, | ||
136 | (1<<JP_RIGHT)|(1<<JP_KP2), | ||
137 | (1<<JP_RIGHT)|(1<<JP_KP3)|(1<<JP_KP2), | ||
138 | (1<<JP_KP1)|(1<<JP_KP2)}, | ||
139 | {1<<JP_OPTION, | ||
140 | (1<<JP_OPTION)|(1<<JP_FIRE1)|(1<<JP_FIRE2), | ||
141 | (1<<JP_FIRE0)|(1<<JP_FIRE1)|(1<<JP_FIRE2), | ||
142 | 0}, | ||
143 | {1<<JP_FIRE0, | ||
144 | (1<<JP_FIRE2)|(1<<JP_FIRE0), | ||
145 | (1<<JP_FIRE0)|(1<<JP_OPTION)|(1<<JP_FIRE2), | ||
146 | (1<<JP_FIRE1)|(1<<JP_FIRE2)}, | ||
147 | {1<<JP_FIRE1, | ||
148 | (1<<JP_FIRE0), | ||
149 | (1<<JP_OPTION)|(1<<JP_FIRE0)|(1<<JP_FIRE1), | ||
150 | (1<<JP_FIRE0)|(1<<JP_FIRE2)}, | ||
151 | {1<<JP_FIRE2, | ||
152 | (1<<JP_OPTION)|(1<<JP_FIRE0)|(1<<JP_FIRE1)|(1<<JP_FIRE2), | ||
153 | (1<<JP_OPTION), | ||
154 | (1<<JP_FIRE0)|(1<<JP_FIRE1)}, | ||
155 | {1<<JP_KP1, | ||
156 | (1<<JP_RIGHT)|(1<<JP_KP1), | ||
157 | (1<<JP_RIGHT)|(1<<JP_KP1)|(1<<JP_KP3), | ||
158 | (1<<JP_RIGHT)|(1<<JP_KP2)}, | ||
159 | {1<<JP_KP2, | ||
160 | (1<<JP_RIGHT)|(1<<JP_KP1)|(1<<JP_KP2)|(1<<JP_KP3), | ||
161 | (1<<JP_KP3), | ||
162 | (1<<JP_RIGHT)|(1<<JP_KP1)}, | ||
163 | {1<<JP_KP3, | ||
164 | (1<<JP_RIGHT)|(1<<JP_KP1)|(1<<JP_KP2)|(1<<JP_KP3), | ||
165 | (1<<JP_RIGHT)|(1<<JP_KP1)|(1<<JP_KP2), | ||
166 | 0}, | ||
167 | {1<<JP_KP4, | ||
168 | (1<<JP_LEFT)|(1<<JP_KP4), | ||
169 | (1<<JP_LEFT)|(1<<JP_KP4)|(1<<JP_KP6), | ||
170 | (1<<JP_LEFT)|(1<<JP_KP5)}, | ||
171 | {1<<JP_KP5, | ||
172 | (1<<JP_LEFT)|(1<<JP_KP4)|(1<<JP_KP5)|(1<<JP_KP6), | ||
173 | (1<<JP_KP6), | ||
174 | (1<<JP_LEFT)|(1<<JP_KP4)}, | ||
175 | {1<<JP_KP6, | ||
176 | (1<<JP_LEFT)|(1<<JP_KP4)|(1<<JP_KP5)|(1<<JP_KP6), | ||
177 | (1<<JP_LEFT)|(1<<JP_KP4)|(1<<JP_KP5), | ||
178 | 0}, | ||
179 | {1<<JP_KP7, | ||
180 | (1<<JP_DOWN)|(1<<JP_KP7), | ||
181 | (1<<JP_DOWN)|(1<<JP_KP7)|(1<<JP_KP9), | ||
182 | (1<<JP_DOWN)|(1<<JP_KP8)}, | ||
183 | {1<<JP_KP8, | ||
184 | (1<<JP_DOWN)|(1<<JP_KP7)|(1<<JP_KP8)|(1<<JP_KP9), | ||
185 | (1<<JP_KP9), | ||
186 | (1<<JP_DOWN)|(1<<JP_KP7)}, | ||
187 | {1<<JP_KP9, | ||
188 | (1<<JP_DOWN)|(1<<JP_KP7)|(1<<JP_KP8)|(1<<JP_KP9), | ||
189 | (1<<JP_DOWN)|(1<<JP_KP7)|(1<<JP_KP8), | ||
190 | 0}, | ||
191 | {1<<JP_KPMULT, | ||
192 | (1<<JP_UP)|(1<<JP_KPMULT), | ||
193 | (1<<JP_UP)|(1<<JP_KPNUM), | ||
194 | (1<<JP_UP)|(1<<JP_KP0)}, | ||
195 | {1<<JP_KP0, | ||
196 | (1<<JP_UP)|(1<<JP_KPNUM)|(1<<JP_KPMULT)|(1<<JP_KP0), | ||
197 | 1<<JP_KPNUM, | ||
198 | (1<<JP_UP)|(1<<JP_KPMULT)}, | ||
199 | {1<<JP_KPNUM, | ||
200 | (1<<JP_UP)|(1<<JP_KPNUM)|(1<<JP_KPMULT)|(1<<JP_KP0), | ||
201 | (1<<JP_UP)|(1<<JP_KPMULT)|(1<<JP_KP0), | ||
202 | 0}, | ||
203 | }; | ||
204 | |||
205 | /*--- Types ---*/ | ||
206 | |||
207 | typedef struct { | ||
208 | SDL_bool enabled; | ||
209 | char *name; | ||
210 | Uint32 prevstate; | ||
211 | } atarijoy_t; | ||
212 | |||
213 | /*--- Variables ---*/ | ||
214 | |||
215 | static atarijoy_t atarijoysticks[MAX_JOYSTICKS]={ | ||
216 | {SDL_FALSE,"IKBD joystick port 1",0}, | ||
217 | {SDL_FALSE,"Xbios joystick port 1",0}, | ||
218 | {SDL_FALSE,"Joypad 0 port A",0}, | ||
219 | {SDL_FALSE,"Joypad 1 port A",0}, | ||
220 | {SDL_FALSE,"Joypad 2 port A",0}, | ||
221 | {SDL_FALSE,"Joypad 3 port A",0}, | ||
222 | {SDL_FALSE,"Joypad 0 port B",0}, | ||
223 | {SDL_FALSE,"Joypad 1 port B",0}, | ||
224 | {SDL_FALSE,"Joypad 2 port B",0}, | ||
225 | {SDL_FALSE,"Joypad 3 port B",0}, | ||
226 | {SDL_FALSE,"Joystick 0 port A",0}, | ||
227 | {SDL_FALSE,"Joystick 1 port A",0}, | ||
228 | {SDL_FALSE,"Joystick 0 port B",0}, | ||
229 | {SDL_FALSE,"Joystick 1 port B",0}, | ||
230 | {SDL_FALSE,"Lightpen port A",0}, | ||
231 | {SDL_FALSE,"Analog paddle port A",0}, | ||
232 | {SDL_FALSE,"Analog paddle port B",0} | ||
233 | #if 0 | ||
234 | ,{SDL_FALSE,"Joystick 0 parallel port",0}, | ||
235 | {SDL_FALSE,"Joystick 1 parallel port",0} | ||
236 | #endif | ||
237 | }; | ||
238 | |||
239 | static const int jp_buttons[JP_NUM_BUTTONS]={ | ||
240 | JP_FIRE0, JP_FIRE1, JP_FIRE2, JP_PAUSE, | ||
241 | JP_OPTION, JP_KPMULT, JP_KPNUM, JP_KP0, | ||
242 | JP_KP1, JP_KP2, JP_KP3, JP_KP4, | ||
243 | JP_KP5, JP_KP6, JP_KP7, JP_KP8, | ||
244 | JP_KP9 | ||
245 | }; | ||
246 | |||
247 | static SDL_bool joypad_ports_enabled=SDL_FALSE; | ||
248 | static int has_teamtap[2]={TEAMTAP_MAYBE,TEAMTAP_MAYBE}; | ||
249 | |||
250 | /* Updated joypad ports */ | ||
251 | static Uint16 jp_paddles[4]; | ||
252 | static Uint16 jp_lightpens[2]; | ||
253 | static Uint16 jp_directions; | ||
254 | static Uint16 jp_fires; | ||
255 | static Uint32 jp_joypads[8]; | ||
256 | |||
257 | /*--- Functions prototypes ---*/ | ||
258 | |||
259 | static int GetEnabledAtariJoystick(int index); | ||
260 | static void UpdateJoypads(void); | ||
261 | |||
262 | /*--- Functions ---*/ | ||
263 | |||
264 | int SDL_SYS_JoystickInit(void) | ||
265 | { | ||
266 | int i; | ||
267 | long cookie_mch; | ||
268 | const char *envr=SDL_getenv("SDL_JOYSTICK_ATARI"); | ||
269 | |||
270 | #define TEST_JOY_ENABLED(env,idstring,num) \ | ||
271 | if (SDL_strstr(env,idstring"-off")) { \ | ||
272 | atarijoysticks[num].enabled=SDL_FALSE; \ | ||
273 | } \ | ||
274 | if (SDL_strstr(env,idstring"-on")) { \ | ||
275 | atarijoysticks[num].enabled=SDL_TRUE; \ | ||
276 | } | ||
277 | |||
278 | /* Cookie _MCH present ? if not, assume ST machine */ | ||
279 | if (Getcookie(C__MCH, &cookie_mch) != C_FOUND) { | ||
280 | cookie_mch = MCH_ST << 16; | ||
281 | } | ||
282 | |||
283 | /* Enable some default joysticks */ | ||
284 | if ((cookie_mch == MCH_ST<<16) || ((cookie_mch>>16) == MCH_STE) || | ||
285 | (cookie_mch == MCH_TT<<16) || (cookie_mch == MCH_F30<<16) || | ||
286 | (cookie_mch == MCH_ARANYM<<16)) | ||
287 | { | ||
288 | atarijoysticks[IKBD_JOY1].enabled=(SDL_AtariIkbd_enabled!=0); | ||
289 | } | ||
290 | if ((cookie_mch == MCH_STE<<16) || (cookie_mch == MCH_F30<<16) || | ||
291 | (cookie_mch == MCH_ARANYM<<16)) | ||
292 | { | ||
293 | atarijoysticks[PORTA_PAD0].enabled = | ||
294 | atarijoysticks[PORTA_PAD1].enabled = | ||
295 | atarijoysticks[PORTA_PAD2].enabled = | ||
296 | atarijoysticks[PORTA_PAD3].enabled = | ||
297 | atarijoysticks[PORTB_PAD0].enabled = | ||
298 | atarijoysticks[PORTB_PAD1].enabled = | ||
299 | atarijoysticks[PORTB_PAD2].enabled = | ||
300 | atarijoysticks[PORTB_PAD3].enabled = SDL_TRUE; | ||
301 | } | ||
302 | if (!atarijoysticks[IKBD_JOY1].enabled) { | ||
303 | atarijoysticks[XBIOS_JOY1].enabled=(SDL_AtariXbios_enabled!=0); | ||
304 | } | ||
305 | |||
306 | /* Read environment for joysticks to enable */ | ||
307 | if (envr) { | ||
308 | /* IKBD on any Atari, maybe clones */ | ||
309 | if ((cookie_mch == MCH_ST<<16) || ((cookie_mch>>16) == MCH_STE) || | ||
310 | (cookie_mch == MCH_TT<<16) || (cookie_mch == MCH_F30<<16) || | ||
311 | (cookie_mch == MCH_ARANYM<<16)) { | ||
312 | if (SDL_AtariIkbd_enabled!=0) { | ||
313 | TEST_JOY_ENABLED(envr, "ikbd-joy1", IKBD_JOY1); | ||
314 | } | ||
315 | } | ||
316 | /* Joypads ports on STE, Falcon and maybe others */ | ||
317 | if ((cookie_mch == MCH_STE<<16) || (cookie_mch == MCH_F30<<16) || | ||
318 | (cookie_mch == MCH_ARANYM<<16)) { | ||
319 | TEST_JOY_ENABLED(envr, "porta-pad", PORTA_PAD0); | ||
320 | if (!atarijoysticks[PORTA_PAD0].enabled) { | ||
321 | TEST_JOY_ENABLED(envr, "porta-joy0", PORTA_JOY0); | ||
322 | TEST_JOY_ENABLED(envr, "porta-joy1", PORTA_JOY1); | ||
323 | if (!(atarijoysticks[PORTA_JOY0].enabled) && !(atarijoysticks[PORTA_JOY1].enabled)) { | ||
324 | TEST_JOY_ENABLED(envr, "porta-lp", PORTA_LP); | ||
325 | if (!atarijoysticks[PORTA_LP].enabled) { | ||
326 | TEST_JOY_ENABLED(envr, "porta-anpad", PORTA_ANPAD); | ||
327 | } | ||
328 | } | ||
329 | } | ||
330 | |||
331 | TEST_JOY_ENABLED(envr, "portb-pad", PORTB_PAD0); | ||
332 | if (!atarijoysticks[PORTB_PAD0].enabled) { | ||
333 | TEST_JOY_ENABLED(envr, "portb-joy0", PORTB_JOY0); | ||
334 | TEST_JOY_ENABLED(envr, "portb-joy1", PORTB_JOY1); | ||
335 | if (!(atarijoysticks[PORTB_JOY0].enabled) && !(atarijoysticks[PORTB_JOY1].enabled)) { | ||
336 | TEST_JOY_ENABLED(envr, "portb-anpad", PORTB_ANPAD); | ||
337 | } | ||
338 | } | ||
339 | } | ||
340 | |||
341 | if (!atarijoysticks[IKBD_JOY1].enabled) { | ||
342 | if (SDL_AtariXbios_enabled!=0) { | ||
343 | TEST_JOY_ENABLED(envr, "xbios-joy1", XBIOS_JOY1); | ||
344 | } | ||
345 | } | ||
346 | #if 0 | ||
347 | /* Parallel port on any Atari, maybe clones */ | ||
348 | if ((cookie_mch == MCH_ST<<16) || ((cookie_mch>>16) == MCH_STE) || | ||
349 | (cookie_mch == MCH_TT<<16) || (cookie_mch == MCH_F30<<16)) { | ||
350 | TEST_JOY_ENABLED(envr, "para-joy0", PARA_JOY0); | ||
351 | TEST_JOY_ENABLED(envr, "para-joy1", PARA_JOY1); | ||
352 | } | ||
353 | #endif | ||
354 | } | ||
355 | |||
356 | /* Need to update joypad ports ? */ | ||
357 | joypad_ports_enabled=SDL_FALSE; | ||
358 | for (i=PORTA_PAD0;i<=PORTB_ANPAD;i++) { | ||
359 | if (atarijoysticks[i].enabled) { | ||
360 | joypad_ports_enabled=SDL_TRUE; | ||
361 | break; | ||
362 | } | ||
363 | } | ||
364 | |||
365 | SDL_numjoysticks = 0; | ||
366 | for (i=0;i<MAX_JOYSTICKS;i++) { | ||
367 | if (atarijoysticks[i].enabled) { | ||
368 | ++SDL_numjoysticks; | ||
369 | } | ||
370 | } | ||
371 | |||
372 | return(SDL_numjoysticks); | ||
373 | } | ||
374 | |||
375 | static int GetEnabledAtariJoystick(int index) | ||
376 | { | ||
377 | int i,j; | ||
378 | |||
379 | /* Return the nth'index' enabled atari joystick */ | ||
380 | j=0; | ||
381 | for (i=0;i<MAX_JOYSTICKS;i++) { | ||
382 | if (!atarijoysticks[i].enabled) { | ||
383 | continue; | ||
384 | } | ||
385 | |||
386 | if (j==index) { | ||
387 | break; | ||
388 | } | ||
389 | |||
390 | ++j; | ||
391 | } | ||
392 | if (i==MAX_JOYSTICKS) | ||
393 | return -1; | ||
394 | |||
395 | return i; | ||
396 | } | ||
397 | |||
398 | const char *SDL_SYS_JoystickName(int index) | ||
399 | { | ||
400 | int numjoystick; | ||
401 | |||
402 | numjoystick=GetEnabledAtariJoystick(index); | ||
403 | if (numjoystick==-1) | ||
404 | return NULL; | ||
405 | |||
406 | return(atarijoysticks[numjoystick].name); | ||
407 | } | ||
408 | |||
409 | int SDL_SYS_JoystickOpen(SDL_Joystick *joystick) | ||
410 | { | ||
411 | int numjoystick; | ||
412 | |||
413 | numjoystick=GetEnabledAtariJoystick(joystick->index); | ||
414 | if (numjoystick==-1) | ||
415 | return -1; | ||
416 | |||
417 | joystick->naxes=0; | ||
418 | joystick->nhats=0; | ||
419 | joystick->nballs=0; | ||
420 | |||
421 | switch(numjoystick) { | ||
422 | case PORTA_PAD0: | ||
423 | case PORTA_PAD1: | ||
424 | case PORTA_PAD2: | ||
425 | case PORTA_PAD3: | ||
426 | case PORTB_PAD0: | ||
427 | case PORTB_PAD1: | ||
428 | case PORTB_PAD2: | ||
429 | case PORTB_PAD3: | ||
430 | joystick->nhats=1; | ||
431 | joystick->nbuttons=JP_NUM_BUTTONS; | ||
432 | break; | ||
433 | case PORTA_LP: | ||
434 | case PORTA_ANPAD: | ||
435 | case PORTB_ANPAD: | ||
436 | joystick->naxes=2; | ||
437 | joystick->nbuttons=2; | ||
438 | break; | ||
439 | default: | ||
440 | joystick->nhats=1; | ||
441 | joystick->nbuttons=1; | ||
442 | break; | ||
443 | } | ||
444 | |||
445 | return(0); | ||
446 | } | ||
447 | |||
448 | /* Detect Teamtap using ghost events */ | ||
449 | static void detect_teamtap(int num_port) | ||
450 | { | ||
451 | int i,j; | ||
452 | |||
453 | /* Check if joypad 1,2,3 triggered but not 0 */ | ||
454 | for (i=1; i<4; i++) { | ||
455 | if (jp_joypads[num_port*4+i] && (jp_joypads[num_port*4]==0)) { | ||
456 | has_teamtap[num_port] = TEAMTAP_YES; | ||
457 | return; | ||
458 | } | ||
459 | } | ||
460 | |||
461 | /* Check if joypad 0 on a given port triggered ghost events for | ||
462 | * other joypads | ||
463 | */ | ||
464 | for (i=0; i<20; i++) { | ||
465 | int with_teamtap=1; | ||
466 | |||
467 | if (jp_joypads[num_port*4]!=teamtap_ghosts[i][0]) | ||
468 | continue; | ||
469 | |||
470 | /* If any button on first joypad pressed, check other pads */ | ||
471 | for (j=1; j<4; j++) { | ||
472 | if ((jp_joypads[num_port*4+j] & teamtap_ghosts[i][j]) | ||
473 | ==teamtap_ghosts[i][j]) | ||
474 | { | ||
475 | with_teamtap = 0; | ||
476 | } | ||
477 | } | ||
478 | |||
479 | has_teamtap[num_port] = (with_teamtap ? TEAMTAP_YES : TEAMTAP_NO); | ||
480 | break; | ||
481 | } | ||
482 | } | ||
483 | |||
484 | void SDL_SYS_JoystickUpdate(SDL_Joystick *joystick) | ||
485 | { | ||
486 | int numjoystick; | ||
487 | Uint8 hatstate; | ||
488 | Uint32 curstate,prevstate; | ||
489 | |||
490 | numjoystick=GetEnabledAtariJoystick(joystick->index); | ||
491 | if (numjoystick==-1) | ||
492 | return; | ||
493 | |||
494 | prevstate = atarijoysticks[numjoystick].prevstate; | ||
495 | |||
496 | if (joypad_ports_enabled) { | ||
497 | Supexec(UpdateJoypads); | ||
498 | } | ||
499 | |||
500 | switch (numjoystick) { | ||
501 | case IKBD_JOY1: | ||
502 | case XBIOS_JOY1: | ||
503 | { | ||
504 | curstate = 0; | ||
505 | |||
506 | if (numjoystick==IKBD_JOY1) { | ||
507 | curstate = SDL_AtariIkbd_joystick & 0xff; | ||
508 | } | ||
509 | if (numjoystick==XBIOS_JOY1) { | ||
510 | curstate = SDL_AtariXbios_joystick & 0xff; | ||
511 | } | ||
512 | |||
513 | if (curstate != prevstate) { | ||
514 | hatstate = SDL_HAT_CENTERED; | ||
515 | if (curstate & IKBD_JOY_LEFT) { | ||
516 | hatstate |= SDL_HAT_LEFT; | ||
517 | } | ||
518 | if (curstate & IKBD_JOY_RIGHT) { | ||
519 | hatstate |= SDL_HAT_RIGHT; | ||
520 | } | ||
521 | if (curstate & IKBD_JOY_UP) { | ||
522 | hatstate |= SDL_HAT_UP; | ||
523 | } | ||
524 | if (curstate & IKBD_JOY_DOWN) { | ||
525 | hatstate |= SDL_HAT_DOWN; | ||
526 | } | ||
527 | SDL_PrivateJoystickHat(joystick, 0, hatstate); | ||
528 | |||
529 | /* Button */ | ||
530 | if ((curstate & IKBD_JOY_FIRE) && !(prevstate & IKBD_JOY_FIRE)) { | ||
531 | SDL_PrivateJoystickButton(joystick,0,SDL_PRESSED); | ||
532 | } | ||
533 | if (!(curstate & IKBD_JOY_FIRE) && (prevstate & IKBD_JOY_FIRE)) { | ||
534 | SDL_PrivateJoystickButton(joystick,0,SDL_RELEASED); | ||
535 | } | ||
536 | } | ||
537 | atarijoysticks[numjoystick].prevstate = curstate; | ||
538 | } | ||
539 | break; | ||
540 | case PORTA_PAD0: | ||
541 | case PORTA_PAD1: | ||
542 | case PORTA_PAD2: | ||
543 | case PORTA_PAD3: | ||
544 | case PORTB_PAD0: | ||
545 | case PORTB_PAD1: | ||
546 | case PORTB_PAD2: | ||
547 | case PORTB_PAD3: | ||
548 | { | ||
549 | int numjoypad,i,numport; | ||
550 | |||
551 | numjoypad = numport = 0; | ||
552 | switch(numjoystick) { | ||
553 | case PORTA_PAD0: | ||
554 | numjoypad = 0; break; | ||
555 | case PORTA_PAD1: | ||
556 | numjoypad = 1; break; | ||
557 | case PORTA_PAD2: | ||
558 | numjoypad = 2; break; | ||
559 | case PORTA_PAD3: | ||
560 | numjoypad = 3; break; | ||
561 | case PORTB_PAD0: | ||
562 | numjoypad = 4; numport = 1; break; | ||
563 | case PORTB_PAD1: | ||
564 | numjoypad = 5; numport = 1; break; | ||
565 | case PORTB_PAD2: | ||
566 | numjoypad = 6; numport = 1; break; | ||
567 | case PORTB_PAD3: | ||
568 | numjoypad = 7; numport = 1; break; | ||
569 | } | ||
570 | |||
571 | jp_joypads[numjoypad] &= 0xabffff; | ||
572 | |||
573 | if (has_teamtap[numport]==TEAMTAP_MAYBE) { | ||
574 | detect_teamtap(numport); | ||
575 | } | ||
576 | /* No events for PORTX_PAD[1,2,3] if no teamtap detected */ | ||
577 | if (has_teamtap[numport] == TEAMTAP_NO) { | ||
578 | if ((numjoypad & 3)!=0) { | ||
579 | return; | ||
580 | } | ||
581 | } | ||
582 | |||
583 | curstate=jp_joypads[numjoypad]; | ||
584 | if (curstate!=prevstate) { | ||
585 | hatstate = SDL_HAT_CENTERED; | ||
586 | if (curstate & (1<<JP_LEFT)) { | ||
587 | hatstate |= SDL_HAT_LEFT; | ||
588 | } | ||
589 | if (curstate & (1<<JP_RIGHT)) { | ||
590 | hatstate |= SDL_HAT_RIGHT; | ||
591 | } | ||
592 | if (curstate & (1<<JP_UP)) { | ||
593 | hatstate |= SDL_HAT_UP; | ||
594 | } | ||
595 | if (curstate & (1<<JP_DOWN)) { | ||
596 | hatstate |= SDL_HAT_DOWN; | ||
597 | } | ||
598 | SDL_PrivateJoystickHat(joystick, 0, hatstate); | ||
599 | |||
600 | /* Buttons */ | ||
601 | for (i=0;i<JP_NUM_BUTTONS;i++) { | ||
602 | int button; | ||
603 | |||
604 | button=1<<jp_buttons[i]; | ||
605 | |||
606 | if ((curstate & button) && !(prevstate & button)) { | ||
607 | SDL_PrivateJoystickButton(joystick,i,SDL_PRESSED); | ||
608 | } | ||
609 | if (!(curstate & button) && (prevstate & button)) { | ||
610 | SDL_PrivateJoystickButton(joystick,i,SDL_RELEASED); | ||
611 | } | ||
612 | } | ||
613 | } | ||
614 | atarijoysticks[numjoystick].prevstate = curstate; | ||
615 | } | ||
616 | break; | ||
617 | case PORTA_JOY0: | ||
618 | case PORTA_JOY1: | ||
619 | case PORTB_JOY0: | ||
620 | case PORTB_JOY1: | ||
621 | { | ||
622 | int fire_shift=0,dir_shift=0; | ||
623 | |||
624 | if (numjoystick==PORTA_JOY0) { fire_shift=0; dir_shift=0; } | ||
625 | if (numjoystick==PORTA_JOY1) { fire_shift=1; dir_shift=4; } | ||
626 | if (numjoystick==PORTB_JOY0) { fire_shift=2; dir_shift=8; } | ||
627 | if (numjoystick==PORTB_JOY1) { fire_shift=3; dir_shift=12; } | ||
628 | |||
629 | curstate = (jp_directions>>dir_shift) & 15; | ||
630 | curstate |= ((jp_fires>>fire_shift) & 1)<<4; | ||
631 | |||
632 | if (curstate != prevstate) { | ||
633 | hatstate = SDL_HAT_CENTERED; | ||
634 | if (curstate & PORT_JS_LEFT) { | ||
635 | hatstate |= SDL_HAT_LEFT; | ||
636 | } | ||
637 | if (curstate & PORT_JS_RIGHT) { | ||
638 | hatstate |= SDL_HAT_RIGHT; | ||
639 | } | ||
640 | if (curstate & PORT_JS_UP) { | ||
641 | hatstate |= SDL_HAT_UP; | ||
642 | } | ||
643 | if (curstate & PORT_JS_DOWN) { | ||
644 | hatstate |= SDL_HAT_DOWN; | ||
645 | } | ||
646 | SDL_PrivateJoystickHat(joystick, 0, hatstate); | ||
647 | |||
648 | /* Button */ | ||
649 | if ((curstate & PORT_JS_FIRE) && !(prevstate & PORT_JS_FIRE)) { | ||
650 | SDL_PrivateJoystickButton(joystick,0,SDL_PRESSED); | ||
651 | } | ||
652 | if (!(curstate & PORT_JS_FIRE) && (prevstate & PORT_JS_FIRE)) { | ||
653 | SDL_PrivateJoystickButton(joystick,0,SDL_RELEASED); | ||
654 | } | ||
655 | } | ||
656 | atarijoysticks[numjoystick].prevstate = curstate; | ||
657 | } | ||
658 | break; | ||
659 | case PORTA_LP: | ||
660 | { | ||
661 | int i; | ||
662 | |||
663 | curstate = jp_lightpens[0]>>1; | ||
664 | curstate |= (jp_lightpens[1]>>1)<<15; | ||
665 | curstate |= (jp_fires & 3)<<30; | ||
666 | |||
667 | if (curstate != prevstate) { | ||
668 | /* X axis */ | ||
669 | SDL_PrivateJoystickAxis(joystick,0,jp_lightpens[0] ^ 0x8000); | ||
670 | /* Y axis */ | ||
671 | SDL_PrivateJoystickAxis(joystick,1,jp_lightpens[1] ^ 0x8000); | ||
672 | /* Buttons */ | ||
673 | for (i=0;i<2;i++) { | ||
674 | int button; | ||
675 | |||
676 | button=1<<(30+i); | ||
677 | |||
678 | if ((curstate & button) && !(prevstate & button)) { | ||
679 | SDL_PrivateJoystickButton(joystick,i,SDL_PRESSED); | ||
680 | } | ||
681 | if (!(curstate & button) && (prevstate & button)) { | ||
682 | SDL_PrivateJoystickButton(joystick,i,SDL_RELEASED); | ||
683 | } | ||
684 | } | ||
685 | } | ||
686 | atarijoysticks[numjoystick].prevstate = curstate; | ||
687 | } | ||
688 | break; | ||
689 | case PORTA_ANPAD: | ||
690 | case PORTB_ANPAD: | ||
691 | { | ||
692 | int numpaddle, i; | ||
693 | |||
694 | numpaddle=0<<1; | ||
695 | if (numjoystick==PORTB_ANPAD) numpaddle=1<<1; | ||
696 | |||
697 | curstate = jp_paddles[numpaddle]>>1; | ||
698 | curstate |= (jp_paddles[numpaddle+1]>>1)<<15; | ||
699 | curstate |= ((jp_fires>>numpaddle) & 3)<<30; | ||
700 | |||
701 | if (curstate != prevstate) { | ||
702 | /* X axis */ | ||
703 | SDL_PrivateJoystickAxis(joystick,0,jp_paddles[numpaddle] ^ 0x8000); | ||
704 | /* Y axis */ | ||
705 | SDL_PrivateJoystickAxis(joystick,1,jp_paddles[numpaddle+1] ^ 0x8000); | ||
706 | /* Buttons */ | ||
707 | for (i=0;i<2;i++) { | ||
708 | int button; | ||
709 | |||
710 | button=1<<(30+i); | ||
711 | |||
712 | if ((curstate & button) && !(prevstate & button)) { | ||
713 | SDL_PrivateJoystickButton(joystick,i,SDL_PRESSED); | ||
714 | } | ||
715 | if (!(curstate & button) && (prevstate & button)) { | ||
716 | SDL_PrivateJoystickButton(joystick,i,SDL_RELEASED); | ||
717 | } | ||
718 | } | ||
719 | } | ||
720 | atarijoysticks[numjoystick].prevstate = curstate; | ||
721 | } | ||
722 | break; | ||
723 | #if 0 | ||
724 | case PARA_JOY0: | ||
725 | case PARA_JOY1: | ||
726 | break; | ||
727 | #endif | ||
728 | }; | ||
729 | |||
730 | return; | ||
731 | } | ||
732 | |||
733 | void SDL_SYS_JoystickClose(SDL_Joystick *joystick) | ||
734 | { | ||
735 | return; | ||
736 | } | ||
737 | |||
738 | void SDL_SYS_JoystickQuit(void) | ||
739 | { | ||
740 | SDL_numjoysticks=0; | ||
741 | return; | ||
742 | } | ||
743 | |||
744 | /*--- Joypad I/O read/write interface ---*/ | ||
745 | |||
746 | #define JOYPAD_IO_BASE (0xffff9200) | ||
747 | struct JOYPAD_IO_S { | ||
748 | Uint16 fires; | ||
749 | Uint16 directions; | ||
750 | Uint16 dummy1[6]; | ||
751 | Uint16 paddles[4]; | ||
752 | Uint16 dummy2[4]; | ||
753 | Uint16 lightpens[2]; | ||
754 | }; | ||
755 | #define JOYPAD_IO ((*(volatile struct JOYPAD_IO_S *)JOYPAD_IO_BASE)) | ||
756 | |||
757 | static const Uint16 joypad_masks[8*4]={ | ||
758 | 0xfffe, 0xfffd, 0xfffb, 0xfff7, | ||
759 | 0xfff0, 0xfff1, 0xfff2, 0xfff3, | ||
760 | 0xfff4, 0xfff5, 0xfff6, 0xfff8, | ||
761 | 0xfff9, 0xfffa, 0xfffc, 0xffff, | ||
762 | 0xffef, 0xffdf, 0xffbf, 0xff7f, | ||
763 | 0xff0f, 0xff1f, 0xff2f, 0xff3f, | ||
764 | 0xff4f, 0xff5f, 0xff6f, 0xff8f, | ||
765 | 0xff9f, 0xffaf, 0xffcf, 0xffff | ||
766 | }; | ||
767 | |||
768 | static void UpdateJoypads(void) | ||
769 | { | ||
770 | Uint16 tmp, i, j; | ||
771 | Uint32 cur_fire, cur_dir; | ||
772 | |||
773 | /*--- This function is called in supervisor mode ---*/ | ||
774 | |||
775 | /* Update joysticks */ | ||
776 | jp_fires = (~(JOYPAD_IO.fires)) & 15; | ||
777 | jp_directions = (~(JOYPAD_IO.directions)); | ||
778 | |||
779 | /* Update lightpen */ | ||
780 | tmp = JOYPAD_IO.lightpens[0] & 1023; | ||
781 | jp_lightpens[0] = (tmp<<6) | (tmp>>4); | ||
782 | tmp = JOYPAD_IO.lightpens[1] & 1023; | ||
783 | jp_lightpens[1] = (tmp<<6) | (tmp>>4); | ||
784 | |||
785 | /* Update paddles */ | ||
786 | tmp = (JOYPAD_IO.paddles[0] & 255); | ||
787 | jp_paddles[0] = (tmp<<8) | tmp; | ||
788 | tmp = (JOYPAD_IO.paddles[1] & 255); | ||
789 | jp_paddles[1] = (tmp<<8) | tmp; | ||
790 | tmp = (JOYPAD_IO.paddles[2] & 255); | ||
791 | jp_paddles[2] = (tmp<<8) | tmp; | ||
792 | tmp = (JOYPAD_IO.paddles[3] & 255); | ||
793 | jp_paddles[3] = (tmp<<8) | tmp; | ||
794 | |||
795 | /* Update joypads on teamtap port A */ | ||
796 | for (i=0; i<4; i++) { | ||
797 | jp_joypads[i] = 0; | ||
798 | for (j=0; j<4; j++) { | ||
799 | JOYPAD_IO.directions = joypad_masks[(i*4)+j]; | ||
800 | |||
801 | cur_fire = (~(JOYPAD_IO.fires) & 3)<<16; | ||
802 | cur_dir = (~(JOYPAD_IO.directions)>>8) & 15; | ||
803 | |||
804 | jp_joypads[i] |= cur_fire<<(j*2); | ||
805 | jp_joypads[i] |= cur_dir<<(j*4); | ||
806 | } | ||
807 | } | ||
808 | |||
809 | /* Update joypads on teamtap port B */ | ||
810 | for (i=4; i<8; i++) { | ||
811 | jp_joypads[i] = 0; | ||
812 | for (j=0; j<4; j++) { | ||
813 | JOYPAD_IO.directions = joypad_masks[(i*4)+j]; | ||
814 | |||
815 | cur_fire = (~(JOYPAD_IO.fires) & 0xc)<<14; | ||
816 | cur_dir = (~(JOYPAD_IO.directions)>>12) & 15; | ||
817 | |||
818 | jp_joypads[i] |= cur_fire<<(j*2); | ||
819 | jp_joypads[i] |= cur_dir<<(j*4); | ||
820 | } | ||
821 | } | ||
822 | |||
823 | JOYPAD_IO.directions=0xffff; | ||
824 | } | ||
825 | |||
826 | #endif /* SDL_JOYSTICK_MINT */ | ||