Mercurial > sdl-ios-xcode
comparison src/joystick/bsd/SDL_sysjoystick.c @ 1662:782fd950bd46 SDL-1.3
Revamp of the video system in progress - adding support for multiple displays, multiple windows, and a full video mode selection API.
WARNING: None of the video drivers have been updated for the new API yet! The API is still under design and very fluid.
The code is now run through a consistent indent format:
indent -i4 -nut -nsc -br -ce
The headers are being converted to automatically generate doxygen documentation.
author | Sam Lantinga <slouken@libsdl.org> |
---|---|
date | Sun, 28 May 2006 13:04:16 +0000 |
parents | 92947e3a18db |
children | 4da1ee79c9af |
comparison
equal
deleted
inserted
replaced
1661:281d3f4870e5 | 1662:782fd950bd46 |
---|---|
72 | 72 |
73 #define MAX_UHID_JOYS 4 | 73 #define MAX_UHID_JOYS 4 |
74 #define MAX_JOY_JOYS 2 | 74 #define MAX_JOY_JOYS 2 |
75 #define MAX_JOYS (MAX_UHID_JOYS + MAX_JOY_JOYS) | 75 #define MAX_JOYS (MAX_UHID_JOYS + MAX_JOY_JOYS) |
76 | 76 |
77 struct report { | 77 struct report |
78 struct usb_ctl_report *buf; /* Buffer */ | 78 { |
79 size_t size; /* Buffer size */ | 79 struct usb_ctl_report *buf; /* Buffer */ |
80 int rid; /* Report ID */ | 80 size_t size; /* Buffer size */ |
81 enum { | 81 int rid; /* Report ID */ |
82 SREPORT_UNINIT, | 82 enum |
83 SREPORT_CLEAN, | 83 { |
84 SREPORT_DIRTY | 84 SREPORT_UNINIT, |
85 } status; | 85 SREPORT_CLEAN, |
86 SREPORT_DIRTY | |
87 } status; | |
86 }; | 88 }; |
87 | 89 |
88 static struct { | 90 static struct |
89 int uhid_report; | 91 { |
90 hid_kind_t kind; | 92 int uhid_report; |
91 const char *name; | 93 hid_kind_t kind; |
94 const char *name; | |
92 } const repinfo[] = { | 95 } const repinfo[] = { |
93 { UHID_INPUT_REPORT, hid_input, "input" }, | 96 {UHID_INPUT_REPORT, hid_input, "input"}, |
94 { UHID_OUTPUT_REPORT, hid_output, "output" }, | 97 {UHID_OUTPUT_REPORT, hid_output, "output"}, |
95 { UHID_FEATURE_REPORT, hid_feature, "feature" } | 98 {UHID_FEATURE_REPORT, hid_feature, "feature"} |
96 }; | 99 }; |
97 | 100 |
98 enum { | 101 enum |
99 REPORT_INPUT = 0, | 102 { |
100 REPORT_OUTPUT = 1, | 103 REPORT_INPUT = 0, |
101 REPORT_FEATURE = 2 | 104 REPORT_OUTPUT = 1, |
105 REPORT_FEATURE = 2 | |
102 }; | 106 }; |
103 | 107 |
104 enum { | 108 enum |
105 JOYAXE_X, | 109 { |
106 JOYAXE_Y, | 110 JOYAXE_X, |
107 JOYAXE_Z, | 111 JOYAXE_Y, |
108 JOYAXE_SLIDER, | 112 JOYAXE_Z, |
109 JOYAXE_WHEEL, | 113 JOYAXE_SLIDER, |
110 JOYAXE_RX, | 114 JOYAXE_WHEEL, |
111 JOYAXE_RY, | 115 JOYAXE_RX, |
112 JOYAXE_RZ, | 116 JOYAXE_RY, |
113 JOYAXE_count | 117 JOYAXE_RZ, |
118 JOYAXE_count | |
114 }; | 119 }; |
115 | 120 |
116 struct joystick_hwdata { | 121 struct joystick_hwdata |
117 int fd; | 122 { |
118 char *path; | 123 int fd; |
119 enum { | 124 char *path; |
120 BSDJOY_UHID, /* uhid(4) */ | 125 enum |
121 BSDJOY_JOY /* joy(4) */ | 126 { |
122 } type; | 127 BSDJOY_UHID, /* uhid(4) */ |
123 struct report_desc *repdesc; | 128 BSDJOY_JOY /* joy(4) */ |
124 struct report inreport; | 129 } type; |
125 int axis_map[JOYAXE_count]; /* map present JOYAXE_* to 0,1,..*/ | 130 struct report_desc *repdesc; |
131 struct report inreport; | |
132 int axis_map[JOYAXE_count]; /* map present JOYAXE_* to 0,1,.. */ | |
126 }; | 133 }; |
127 | 134 |
128 static char *joynames[MAX_JOYS]; | 135 static char *joynames[MAX_JOYS]; |
129 static char *joydevnames[MAX_JOYS]; | 136 static char *joydevnames[MAX_JOYS]; |
130 | 137 |
131 static int report_alloc(struct report *, struct report_desc *, int); | 138 static int report_alloc (struct report *, struct report_desc *, int); |
132 static void report_free(struct report *); | 139 static void report_free (struct report *); |
133 | 140 |
134 #ifdef USBHID_UCR_DATA | 141 #ifdef USBHID_UCR_DATA |
135 #define REP_BUF_DATA(rep) ((rep)->buf->ucr_data) | 142 #define REP_BUF_DATA(rep) ((rep)->buf->ucr_data) |
136 #else | 143 #else |
137 #define REP_BUF_DATA(rep) ((rep)->buf->data) | 144 #define REP_BUF_DATA(rep) ((rep)->buf->data) |
138 #endif | 145 #endif |
139 | 146 |
140 int | 147 int |
141 SDL_SYS_JoystickInit(void) | 148 SDL_SYS_JoystickInit (void) |
142 { | 149 { |
143 char s[16]; | 150 char s[16]; |
144 int i, fd; | 151 int i, fd; |
145 | 152 |
146 SDL_numjoysticks = 0; | 153 SDL_numjoysticks = 0; |
147 | 154 |
148 SDL_memset(joynames, 0, sizeof(joynames)); | 155 SDL_memset (joynames, 0, sizeof (joynames)); |
149 SDL_memset(joydevnames, 0, sizeof(joydevnames)); | 156 SDL_memset (joydevnames, 0, sizeof (joydevnames)); |
150 | 157 |
151 for (i = 0; i < MAX_UHID_JOYS; i++) { | 158 for (i = 0; i < MAX_UHID_JOYS; i++) { |
152 SDL_Joystick nj; | 159 SDL_Joystick nj; |
153 | 160 |
154 SDL_snprintf(s, SDL_arraysize(s), "/dev/uhid%d", i); | 161 SDL_snprintf (s, SDL_arraysize (s), "/dev/uhid%d", i); |
155 | 162 |
156 nj.index = SDL_numjoysticks; | 163 nj.index = SDL_numjoysticks; |
157 joynames[nj.index] = strdup(s); | 164 joynames[nj.index] = strdup (s); |
158 | 165 |
159 if (SDL_SYS_JoystickOpen(&nj) == 0) { | 166 if (SDL_SYS_JoystickOpen (&nj) == 0) { |
160 SDL_SYS_JoystickClose(&nj); | 167 SDL_SYS_JoystickClose (&nj); |
161 SDL_numjoysticks++; | 168 SDL_numjoysticks++; |
162 } else { | 169 } else { |
163 SDL_free(joynames[nj.index]); | 170 SDL_free (joynames[nj.index]); |
164 joynames[nj.index] = NULL; | 171 joynames[nj.index] = NULL; |
165 } | 172 } |
166 } | 173 } |
167 for (i = 0; i < MAX_JOY_JOYS; i++) { | 174 for (i = 0; i < MAX_JOY_JOYS; i++) { |
168 SDL_snprintf(s, SDL_arraysize(s), "/dev/joy%d", i); | 175 SDL_snprintf (s, SDL_arraysize (s), "/dev/joy%d", i); |
169 fd = open(s, O_RDONLY); | 176 fd = open (s, O_RDONLY); |
170 if (fd != -1) { | 177 if (fd != -1) { |
171 joynames[SDL_numjoysticks++] = strdup(s); | 178 joynames[SDL_numjoysticks++] = strdup (s); |
172 close(fd); | 179 close (fd); |
173 } | 180 } |
174 } | 181 } |
175 | 182 |
176 /* Read the default USB HID usage table. */ | 183 /* Read the default USB HID usage table. */ |
177 hid_init(NULL); | 184 hid_init (NULL); |
178 | 185 |
179 return (SDL_numjoysticks); | 186 return (SDL_numjoysticks); |
180 } | 187 } |
181 | 188 |
182 const char * | 189 const char * |
183 SDL_SYS_JoystickName(int index) | 190 SDL_SYS_JoystickName (int index) |
184 { | 191 { |
185 if (joydevnames[index] != NULL) { | 192 if (joydevnames[index] != NULL) { |
186 return (joydevnames[index]); | 193 return (joydevnames[index]); |
187 } | 194 } |
188 return (joynames[index]); | 195 return (joynames[index]); |
189 } | 196 } |
190 | 197 |
191 static int | 198 static int |
192 usage_to_joyaxe(unsigned usage) | 199 usage_to_joyaxe (unsigned usage) |
193 { | 200 { |
194 int joyaxe; | 201 int joyaxe; |
195 switch (usage) { | 202 switch (usage) { |
196 case HUG_X: | 203 case HUG_X: |
197 joyaxe = JOYAXE_X; break; | 204 joyaxe = JOYAXE_X; |
205 break; | |
198 case HUG_Y: | 206 case HUG_Y: |
199 joyaxe = JOYAXE_Y; break; | 207 joyaxe = JOYAXE_Y; |
208 break; | |
200 case HUG_Z: | 209 case HUG_Z: |
201 joyaxe = JOYAXE_Z; break; | 210 joyaxe = JOYAXE_Z; |
211 break; | |
202 case HUG_SLIDER: | 212 case HUG_SLIDER: |
203 joyaxe = JOYAXE_SLIDER; break; | 213 joyaxe = JOYAXE_SLIDER; |
214 break; | |
204 case HUG_WHEEL: | 215 case HUG_WHEEL: |
205 joyaxe = JOYAXE_WHEEL; break; | 216 joyaxe = JOYAXE_WHEEL; |
217 break; | |
206 case HUG_RX: | 218 case HUG_RX: |
207 joyaxe = JOYAXE_RX; break; | 219 joyaxe = JOYAXE_RX; |
220 break; | |
208 case HUG_RY: | 221 case HUG_RY: |
209 joyaxe = JOYAXE_RY; break; | 222 joyaxe = JOYAXE_RY; |
223 break; | |
210 case HUG_RZ: | 224 case HUG_RZ: |
211 joyaxe = JOYAXE_RZ; break; | 225 joyaxe = JOYAXE_RZ; |
226 break; | |
212 default: | 227 default: |
213 joyaxe = -1; | 228 joyaxe = -1; |
214 } | 229 } |
215 return joyaxe; | 230 return joyaxe; |
216 } | 231 } |
217 | 232 |
218 static unsigned | 233 static unsigned |
219 hatval_to_sdl(Sint32 hatval) | 234 hatval_to_sdl (Sint32 hatval) |
220 { | 235 { |
221 static const unsigned hat_dir_map[8] = { | 236 static const unsigned hat_dir_map[8] = { |
222 SDL_HAT_UP, SDL_HAT_RIGHTUP, SDL_HAT_RIGHT, SDL_HAT_RIGHTDOWN, | 237 SDL_HAT_UP, SDL_HAT_RIGHTUP, SDL_HAT_RIGHT, SDL_HAT_RIGHTDOWN, |
223 SDL_HAT_DOWN, SDL_HAT_LEFTDOWN, SDL_HAT_LEFT, SDL_HAT_LEFTUP | 238 SDL_HAT_DOWN, SDL_HAT_LEFTDOWN, SDL_HAT_LEFT, SDL_HAT_LEFTUP |
224 }; | 239 }; |
225 unsigned result; | 240 unsigned result; |
226 if ((hatval & 7) == hatval) | 241 if ((hatval & 7) == hatval) |
227 result = hat_dir_map[hatval]; | 242 result = hat_dir_map[hatval]; |
228 else | 243 else |
229 result = SDL_HAT_CENTERED; | 244 result = SDL_HAT_CENTERED; |
230 return result; | 245 return result; |
231 } | 246 } |
232 | 247 |
233 | 248 |
234 int | 249 int |
235 SDL_SYS_JoystickOpen(SDL_Joystick *joy) | 250 SDL_SYS_JoystickOpen (SDL_Joystick * joy) |
236 { | 251 { |
237 char *path = joynames[joy->index]; | 252 char *path = joynames[joy->index]; |
238 struct joystick_hwdata *hw; | 253 struct joystick_hwdata *hw; |
239 struct hid_item hitem; | 254 struct hid_item hitem; |
240 struct hid_data *hdata; | 255 struct hid_data *hdata; |
241 struct report *rep; | 256 struct report *rep; |
242 int fd; | 257 int fd; |
243 int i; | 258 int i; |
244 | 259 |
245 fd = open(path, O_RDONLY); | 260 fd = open (path, O_RDONLY); |
246 if (fd == -1) { | 261 if (fd == -1) { |
247 SDL_SetError("%s: %s", path, strerror(errno)); | 262 SDL_SetError ("%s: %s", path, strerror (errno)); |
248 return (-1); | 263 return (-1); |
249 } | 264 } |
250 | 265 |
251 hw = (struct joystick_hwdata *)SDL_malloc(sizeof(struct joystick_hwdata)); | 266 hw = (struct joystick_hwdata *) |
252 if (hw == NULL) { | 267 SDL_malloc (sizeof (struct joystick_hwdata)); |
253 SDL_OutOfMemory(); | 268 if (hw == NULL) { |
254 close(fd); | 269 SDL_OutOfMemory (); |
255 return (-1); | 270 close (fd); |
256 } | 271 return (-1); |
257 joy->hwdata = hw; | 272 } |
258 hw->fd = fd; | 273 joy->hwdata = hw; |
259 hw->path = strdup(path); | 274 hw->fd = fd; |
260 if (! SDL_strncmp(path, "/dev/joy", 8)) { | 275 hw->path = strdup (path); |
261 hw->type = BSDJOY_JOY; | 276 if (!SDL_strncmp (path, "/dev/joy", 8)) { |
262 joy->naxes = 2; | 277 hw->type = BSDJOY_JOY; |
263 joy->nbuttons = 2; | 278 joy->naxes = 2; |
264 joy->nhats = 0; | 279 joy->nbuttons = 2; |
265 joy->nballs = 0; | 280 joy->nhats = 0; |
266 joydevnames[joy->index] = strdup("Gameport joystick"); | 281 joy->nballs = 0; |
267 goto usbend; | 282 joydevnames[joy->index] = strdup ("Gameport joystick"); |
268 } else { | 283 goto usbend; |
269 hw->type = BSDJOY_UHID; | 284 } else { |
270 } | 285 hw->type = BSDJOY_UHID; |
271 | 286 } |
272 { | 287 |
273 int ax; | 288 { |
274 for (ax = 0; ax < JOYAXE_count; ax++) | 289 int ax; |
275 hw->axis_map[ax] = -1; | 290 for (ax = 0; ax < JOYAXE_count; ax++) |
276 } | 291 hw->axis_map[ax] = -1; |
277 hw->repdesc = hid_get_report_desc(fd); | 292 } |
278 if (hw->repdesc == NULL) { | 293 hw->repdesc = hid_get_report_desc (fd); |
279 SDL_SetError("%s: USB_GET_REPORT_DESC: %s", hw->path, | 294 if (hw->repdesc == NULL) { |
280 strerror(errno)); | 295 SDL_SetError ("%s: USB_GET_REPORT_DESC: %s", hw->path, |
281 goto usberr; | 296 strerror (errno)); |
282 } | 297 goto usberr; |
283 | 298 } |
284 rep = &hw->inreport; | 299 |
285 if (ioctl(fd, USB_GET_REPORT_ID, &rep->rid) < 0) { | 300 rep = &hw->inreport; |
286 rep->rid = -1; /* XXX */ | 301 if (ioctl (fd, USB_GET_REPORT_ID, &rep->rid) < 0) { |
287 } | 302 rep->rid = -1; /* XXX */ |
288 if (report_alloc(rep, hw->repdesc, REPORT_INPUT) < 0) { | 303 } |
289 goto usberr; | 304 if (report_alloc (rep, hw->repdesc, REPORT_INPUT) < 0) { |
290 } | 305 goto usberr; |
291 if (rep->size <= 0) { | 306 } |
292 SDL_SetError("%s: Input report descriptor has invalid length", | 307 if (rep->size <= 0) { |
293 hw->path); | 308 SDL_SetError ("%s: Input report descriptor has invalid length", |
294 goto usberr; | 309 hw->path); |
295 } | 310 goto usberr; |
296 | 311 } |
297 #if defined(USBHID_NEW) || (defined(__FREEBSD__) && __FreeBSD_version >= 500111) | 312 #if defined(USBHID_NEW) || (defined(__FREEBSD__) && __FreeBSD_version >= 500111) |
298 hdata = hid_start_parse(hw->repdesc, 1 << hid_input, rep->rid); | 313 hdata = hid_start_parse (hw->repdesc, 1 << hid_input, rep->rid); |
299 #else | 314 #else |
300 hdata = hid_start_parse(hw->repdesc, 1 << hid_input); | 315 hdata = hid_start_parse (hw->repdesc, 1 << hid_input); |
301 #endif | 316 #endif |
302 if (hdata == NULL) { | 317 if (hdata == NULL) { |
303 SDL_SetError("%s: Cannot start HID parser", hw->path); | 318 SDL_SetError ("%s: Cannot start HID parser", hw->path); |
304 goto usberr; | 319 goto usberr; |
305 } | 320 } |
306 joy->naxes = 0; | 321 joy->naxes = 0; |
307 joy->nbuttons = 0; | 322 joy->nbuttons = 0; |
308 joy->nhats = 0; | 323 joy->nhats = 0; |
309 joy->nballs = 0; | 324 joy->nballs = 0; |
310 for (i=0; i<JOYAXE_count; i++) | 325 for (i = 0; i < JOYAXE_count; i++) |
311 hw->axis_map[i] = -1; | 326 hw->axis_map[i] = -1; |
312 | 327 |
313 while (hid_get_item(hdata, &hitem) > 0) { | 328 while (hid_get_item (hdata, &hitem) > 0) { |
314 char *sp; | 329 char *sp; |
315 const char *s; | 330 const char *s; |
316 | 331 |
317 switch (hitem.kind) { | 332 switch (hitem.kind) { |
318 case hid_collection: | 333 case hid_collection: |
319 switch (HID_PAGE(hitem.usage)) { | 334 switch (HID_PAGE (hitem.usage)) { |
320 case HUP_GENERIC_DESKTOP: | 335 case HUP_GENERIC_DESKTOP: |
321 switch (HID_USAGE(hitem.usage)) { | 336 switch (HID_USAGE (hitem.usage)) { |
322 case HUG_JOYSTICK: | 337 case HUG_JOYSTICK: |
323 case HUG_GAME_PAD: | 338 case HUG_GAME_PAD: |
324 s = hid_usage_in_page(hitem.usage); | 339 s = hid_usage_in_page (hitem.usage); |
325 sp = SDL_malloc(SDL_strlen(s) + 5); | 340 sp = SDL_malloc (SDL_strlen (s) + 5); |
326 SDL_snprintf(sp, SDL_strlen(s) + 5, "%s (%d)", s, | 341 SDL_snprintf (sp, SDL_strlen (s) + 5, "%s (%d)", |
327 joy->index); | 342 s, joy->index); |
328 joydevnames[joy->index] = sp; | 343 joydevnames[joy->index] = sp; |
329 } | 344 } |
330 } | 345 } |
331 break; | 346 break; |
332 case hid_input: | 347 case hid_input: |
333 switch (HID_PAGE(hitem.usage)) { | 348 switch (HID_PAGE (hitem.usage)) { |
334 case HUP_GENERIC_DESKTOP: { | 349 case HUP_GENERIC_DESKTOP: |
335 unsigned usage = HID_USAGE(hitem.usage); | 350 { |
336 int joyaxe = usage_to_joyaxe(usage); | 351 unsigned usage = HID_USAGE (hitem.usage); |
337 if (joyaxe >= 0) { | 352 int joyaxe = usage_to_joyaxe (usage); |
338 hw->axis_map[joyaxe] = 1; | 353 if (joyaxe >= 0) { |
339 } else if (usage == HUG_HAT_SWITCH) { | 354 hw->axis_map[joyaxe] = 1; |
340 joy->nhats++; | 355 } else if (usage == HUG_HAT_SWITCH) { |
341 } | 356 joy->nhats++; |
342 break; | 357 } |
343 } | 358 break; |
344 case HUP_BUTTON: | 359 } |
345 joy->nbuttons++; | 360 case HUP_BUTTON: |
346 break; | 361 joy->nbuttons++; |
347 default: | 362 break; |
348 break; | 363 default: |
349 } | 364 break; |
350 break; | 365 } |
351 default: | 366 break; |
352 break; | 367 default: |
353 } | 368 break; |
354 } | 369 } |
355 hid_end_parse(hdata); | 370 } |
356 for (i=0; i<JOYAXE_count; i++) | 371 hid_end_parse (hdata); |
357 if (hw->axis_map[i] > 0) | 372 for (i = 0; i < JOYAXE_count; i++) |
358 hw->axis_map[i] = joy->naxes++; | 373 if (hw->axis_map[i] > 0) |
359 | 374 hw->axis_map[i] = joy->naxes++; |
360 usbend: | 375 |
361 /* The poll blocks the event thread. */ | 376 usbend: |
362 fcntl(fd, F_SETFL, O_NONBLOCK); | 377 /* The poll blocks the event thread. */ |
363 | 378 fcntl (fd, F_SETFL, O_NONBLOCK); |
364 return (0); | 379 |
365 usberr: | 380 return (0); |
366 close(hw->fd); | 381 usberr: |
367 SDL_free(hw->path); | 382 close (hw->fd); |
368 SDL_free(hw); | 383 SDL_free (hw->path); |
369 return (-1); | 384 SDL_free (hw); |
385 return (-1); | |
370 } | 386 } |
371 | 387 |
372 void | 388 void |
373 SDL_SYS_JoystickUpdate(SDL_Joystick *joy) | 389 SDL_SYS_JoystickUpdate (SDL_Joystick * joy) |
374 { | 390 { |
375 struct hid_item hitem; | 391 struct hid_item hitem; |
376 struct hid_data *hdata; | 392 struct hid_data *hdata; |
377 struct report *rep; | 393 struct report *rep; |
378 int nbutton, naxe = -1; | 394 int nbutton, naxe = -1; |
379 Sint32 v; | 395 Sint32 v; |
380 | 396 |
381 #if defined(__FREEBSD__) || SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H | 397 #if defined(__FREEBSD__) || SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H |
382 struct joystick gameport; | 398 struct joystick gameport; |
383 static int x, y, xmin = 0xffff, ymin = 0xffff, xmax = 0, ymax = 0; | 399 static int x, y, xmin = 0xffff, ymin = 0xffff, xmax = 0, ymax = 0; |
384 | 400 |
385 if (joy->hwdata->type == BSDJOY_JOY) { | 401 if (joy->hwdata->type == BSDJOY_JOY) { |
386 if (read(joy->hwdata->fd, &gameport, sizeof gameport) != sizeof gameport) | 402 if (read (joy->hwdata->fd, &gameport, sizeof gameport) != |
387 return; | 403 sizeof gameport) |
388 if (abs(x - gameport.x) > 8) { | 404 return; |
389 x = gameport.x; | 405 if (abs (x - gameport.x) > 8) { |
390 if (x < xmin) { | 406 x = gameport.x; |
391 xmin = x; | 407 if (x < xmin) { |
392 } | 408 xmin = x; |
393 if (x > xmax) { | 409 } |
394 xmax = x; | 410 if (x > xmax) { |
395 } | 411 xmax = x; |
396 if (xmin == xmax) { | 412 } |
397 xmin--; | 413 if (xmin == xmax) { |
398 xmax++; | 414 xmin--; |
399 } | 415 xmax++; |
400 v = (Sint32)x; | 416 } |
401 v -= (xmax + xmin + 1)/2; | 417 v = (Sint32) x; |
402 v *= 32768/((xmax - xmin + 1)/2); | 418 v -= (xmax + xmin + 1) / 2; |
403 SDL_PrivateJoystickAxis(joy, 0, v); | 419 v *= 32768 / ((xmax - xmin + 1) / 2); |
404 } | 420 SDL_PrivateJoystickAxis (joy, 0, v); |
405 if (abs(y - gameport.y) > 8) { | 421 } |
406 y = gameport.y; | 422 if (abs (y - gameport.y) > 8) { |
407 if (y < ymin) { | 423 y = gameport.y; |
408 ymin = y; | 424 if (y < ymin) { |
409 } | 425 ymin = y; |
410 if (y > ymax) { | 426 } |
411 ymax = y; | 427 if (y > ymax) { |
412 } | 428 ymax = y; |
413 if (ymin == ymax) { | 429 } |
414 ymin--; | 430 if (ymin == ymax) { |
415 ymax++; | 431 ymin--; |
416 } | 432 ymax++; |
417 v = (Sint32)y; | 433 } |
418 v -= (ymax + ymin + 1)/2; | 434 v = (Sint32) y; |
419 v *= 32768/((ymax - ymin + 1)/2); | 435 v -= (ymax + ymin + 1) / 2; |
420 SDL_PrivateJoystickAxis(joy, 1, v); | 436 v *= 32768 / ((ymax - ymin + 1) / 2); |
421 } | 437 SDL_PrivateJoystickAxis (joy, 1, v); |
422 if (gameport.b1 != joy->buttons[0]) { | 438 } |
423 SDL_PrivateJoystickButton(joy, 0, gameport.b1); | 439 if (gameport.b1 != joy->buttons[0]) { |
424 } | 440 SDL_PrivateJoystickButton (joy, 0, gameport.b1); |
425 if (gameport.b2 != joy->buttons[1]) { | 441 } |
426 SDL_PrivateJoystickButton(joy, 1, gameport.b2); | 442 if (gameport.b2 != joy->buttons[1]) { |
427 } | 443 SDL_PrivateJoystickButton (joy, 1, gameport.b2); |
428 return; | 444 } |
429 } | 445 return; |
446 } | |
430 #endif /* defined(__FREEBSD__) || SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H */ | 447 #endif /* defined(__FREEBSD__) || SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H */ |
431 | 448 |
432 rep = &joy->hwdata->inreport; | 449 rep = &joy->hwdata->inreport; |
433 | 450 |
434 if (read(joy->hwdata->fd, REP_BUF_DATA(rep), rep->size) != rep->size) { | 451 if (read (joy->hwdata->fd, REP_BUF_DATA (rep), rep->size) != rep->size) { |
435 return; | 452 return; |
436 } | 453 } |
437 #if defined(USBHID_NEW) || (defined(__FREEBSD__) && __FreeBSD_version >= 500111) | 454 #if defined(USBHID_NEW) || (defined(__FREEBSD__) && __FreeBSD_version >= 500111) |
438 hdata = hid_start_parse(joy->hwdata->repdesc, 1 << hid_input, rep->rid); | 455 hdata = hid_start_parse (joy->hwdata->repdesc, 1 << hid_input, rep->rid); |
439 #else | 456 #else |
440 hdata = hid_start_parse(joy->hwdata->repdesc, 1 << hid_input); | 457 hdata = hid_start_parse (joy->hwdata->repdesc, 1 << hid_input); |
441 #endif | 458 #endif |
442 if (hdata == NULL) { | 459 if (hdata == NULL) { |
443 fprintf(stderr, "%s: Cannot start HID parser\n", | 460 fprintf (stderr, "%s: Cannot start HID parser\n", joy->hwdata->path); |
444 joy->hwdata->path); | 461 return; |
445 return; | 462 } |
446 } | 463 |
447 | 464 for (nbutton = 0; hid_get_item (hdata, &hitem) > 0;) { |
448 for (nbutton = 0; hid_get_item(hdata, &hitem) > 0;) { | 465 switch (hitem.kind) { |
449 switch (hitem.kind) { | 466 case hid_input: |
450 case hid_input: | 467 switch (HID_PAGE (hitem.usage)) { |
451 switch (HID_PAGE(hitem.usage)) { | 468 case HUP_GENERIC_DESKTOP: |
452 case HUP_GENERIC_DESKTOP: { | 469 { |
453 unsigned usage = HID_USAGE(hitem.usage); | 470 unsigned usage = HID_USAGE (hitem.usage); |
454 int joyaxe = usage_to_joyaxe(usage); | 471 int joyaxe = usage_to_joyaxe (usage); |
455 if (joyaxe >= 0) { | 472 if (joyaxe >= 0) { |
456 naxe = joy->hwdata->axis_map[joyaxe]; | 473 naxe = joy->hwdata->axis_map[joyaxe]; |
457 /* scaleaxe */ | 474 /* scaleaxe */ |
458 v = (Sint32)hid_get_data(REP_BUF_DATA(rep), | 475 v = (Sint32) hid_get_data (REP_BUF_DATA (rep), |
459 &hitem); | 476 &hitem); |
460 v -= (hitem.logical_maximum + hitem.logical_minimum + 1)/2; | 477 v -= (hitem.logical_maximum + |
461 v *= 32768/((hitem.logical_maximum - hitem.logical_minimum + 1)/2); | 478 hitem.logical_minimum + 1) / 2; |
462 if (v != joy->axes[naxe]) { | 479 v *= 32768 / |
463 SDL_PrivateJoystickAxis(joy, naxe, v); | 480 ((hitem.logical_maximum - |
464 } | 481 hitem.logical_minimum + 1) / 2); |
465 } else if (usage == HUG_HAT_SWITCH) { | 482 if (v != joy->axes[naxe]) { |
466 v = (Sint32)hid_get_data(REP_BUF_DATA(rep), | 483 SDL_PrivateJoystickAxis (joy, naxe, v); |
467 &hitem); | 484 } |
468 SDL_PrivateJoystickHat(joy, 0, | 485 } else if (usage == HUG_HAT_SWITCH) { |
469 hatval_to_sdl(v)-hitem.logical_minimum); | 486 v = (Sint32) hid_get_data (REP_BUF_DATA (rep), |
470 } | 487 &hitem); |
471 break; | 488 SDL_PrivateJoystickHat (joy, 0, |
472 } | 489 hatval_to_sdl (v) - |
473 case HUP_BUTTON: | 490 hitem.logical_minimum); |
474 v = (Sint32)hid_get_data(REP_BUF_DATA(rep), | 491 } |
475 &hitem); | 492 break; |
476 if (joy->buttons[nbutton] != v) { | 493 } |
477 SDL_PrivateJoystickButton(joy, | 494 case HUP_BUTTON: |
478 nbutton, v); | 495 v = (Sint32) hid_get_data (REP_BUF_DATA (rep), &hitem); |
479 } | 496 if (joy->buttons[nbutton] != v) { |
480 nbutton++; | 497 SDL_PrivateJoystickButton (joy, nbutton, v); |
481 break; | 498 } |
482 default: | 499 nbutton++; |
483 continue; | 500 break; |
484 } | 501 default: |
485 break; | 502 continue; |
486 default: | 503 } |
487 break; | 504 break; |
488 } | 505 default: |
489 } | 506 break; |
490 hid_end_parse(hdata); | 507 } |
491 | 508 } |
492 return; | 509 hid_end_parse (hdata); |
510 | |
511 return; | |
493 } | 512 } |
494 | 513 |
495 /* Function to close a joystick after use */ | 514 /* Function to close a joystick after use */ |
496 void | 515 void |
497 SDL_SYS_JoystickClose(SDL_Joystick *joy) | 516 SDL_SYS_JoystickClose (SDL_Joystick * joy) |
498 { | 517 { |
499 if (SDL_strncmp(joy->hwdata->path, "/dev/joy", 8)) { | 518 if (SDL_strncmp (joy->hwdata->path, "/dev/joy", 8)) { |
500 report_free(&joy->hwdata->inreport); | 519 report_free (&joy->hwdata->inreport); |
501 hid_dispose_report_desc(joy->hwdata->repdesc); | 520 hid_dispose_report_desc (joy->hwdata->repdesc); |
502 } | 521 } |
503 close(joy->hwdata->fd); | 522 close (joy->hwdata->fd); |
504 SDL_free(joy->hwdata->path); | 523 SDL_free (joy->hwdata->path); |
505 SDL_free(joy->hwdata); | 524 SDL_free (joy->hwdata); |
506 | 525 |
507 return; | 526 return; |
508 } | 527 } |
509 | 528 |
510 void | 529 void |
511 SDL_SYS_JoystickQuit(void) | 530 SDL_SYS_JoystickQuit (void) |
512 { | 531 { |
513 int i; | 532 int i; |
514 | 533 |
515 for (i = 0; i < MAX_JOYS; i++) { | 534 for (i = 0; i < MAX_JOYS; i++) { |
516 if (joynames[i] != NULL) | 535 if (joynames[i] != NULL) |
517 SDL_free(joynames[i]); | 536 SDL_free (joynames[i]); |
518 if (joydevnames[i] != NULL) | 537 if (joydevnames[i] != NULL) |
519 SDL_free(joydevnames[i]); | 538 SDL_free (joydevnames[i]); |
520 } | 539 } |
521 | 540 |
522 return; | 541 return; |
523 } | 542 } |
524 | 543 |
525 static int | 544 static int |
526 report_alloc(struct report *r, struct report_desc *rd, int repind) | 545 report_alloc (struct report *r, struct report_desc *rd, int repind) |
527 { | 546 { |
528 int len; | 547 int len; |
529 | 548 |
530 #ifdef __DragonFly__ | 549 #ifdef __DragonFly__ |
531 len = hid_report_size(rd, r->rid, repinfo[repind].kind); | 550 len = hid_report_size (rd, r->rid, repinfo[repind].kind); |
532 #elif __FREEBSD__ | 551 #elif __FREEBSD__ |
533 # if (__FreeBSD_version >= 460000) | 552 # if (__FreeBSD_version >= 460000) |
534 # if (__FreeBSD_version <= 500111) | 553 # if (__FreeBSD_version <= 500111) |
535 len = hid_report_size(rd, r->rid, repinfo[repind].kind); | 554 len = hid_report_size (rd, r->rid, repinfo[repind].kind); |
536 # else | 555 # else |
537 len = hid_report_size(rd, repinfo[repind].kind, r->rid); | 556 len = hid_report_size (rd, repinfo[repind].kind, r->rid); |
538 # endif | 557 # endif |
539 # else | 558 # else |
540 len = hid_report_size(rd, repinfo[repind].kind, &r->rid); | 559 len = hid_report_size (rd, repinfo[repind].kind, &r->rid); |
541 # endif | 560 # endif |
542 #else | 561 #else |
543 # ifdef USBHID_NEW | 562 # ifdef USBHID_NEW |
544 len = hid_report_size(rd, repinfo[repind].kind, r->rid); | 563 len = hid_report_size (rd, repinfo[repind].kind, r->rid); |
545 # else | 564 # else |
546 len = hid_report_size(rd, repinfo[repind].kind, &r->rid); | 565 len = hid_report_size (rd, repinfo[repind].kind, &r->rid); |
547 # endif | 566 # endif |
548 #endif | 567 #endif |
549 | 568 |
550 if (len < 0) { | 569 if (len < 0) { |
551 SDL_SetError("Negative HID report size"); | 570 SDL_SetError ("Negative HID report size"); |
552 return (-1); | 571 return (-1); |
553 } | 572 } |
554 r->size = len; | 573 r->size = len; |
555 | 574 |
556 if (r->size > 0) { | 575 if (r->size > 0) { |
557 r->buf = SDL_malloc(sizeof(*r->buf) - sizeof(REP_BUF_DATA(r)) + | 576 r->buf = SDL_malloc (sizeof (*r->buf) - sizeof (REP_BUF_DATA (r)) + |
558 r->size); | 577 r->size); |
559 if (r->buf == NULL) { | 578 if (r->buf == NULL) { |
560 SDL_OutOfMemory(); | 579 SDL_OutOfMemory (); |
561 return (-1); | 580 return (-1); |
562 } | 581 } |
563 } else { | 582 } else { |
564 r->buf = NULL; | 583 r->buf = NULL; |
565 } | 584 } |
566 | 585 |
567 r->status = SREPORT_CLEAN; | 586 r->status = SREPORT_CLEAN; |
568 return (0); | 587 return (0); |
569 } | 588 } |
570 | 589 |
571 static void | 590 static void |
572 report_free(struct report *r) | 591 report_free (struct report *r) |
573 { | 592 { |
574 if (r->buf != NULL) { | 593 if (r->buf != NULL) { |
575 SDL_free(r->buf); | 594 SDL_free (r->buf); |
576 } | 595 } |
577 r->status = SREPORT_UNINIT; | 596 r->status = SREPORT_UNINIT; |
578 } | 597 } |
579 | 598 |
580 #endif /* SDL_JOYSTICK_USBHID */ | 599 #endif /* SDL_JOYSTICK_USBHID */ |
600 /* vi: set ts=4 sw=4 expandtab: */ |