This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_sysjoystick.c
881 lines (768 loc) · 31.8 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2004 Sam Lantinga
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Sam Lantinga
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
23
24
25
#ifdef SDL_JOYSTICK_IOKIT
26
/* SDL joystick driver for Darwin / Mac OS X, based on the IOKit HID API */
27
28
29
30
31
32
33
34
35
/* Written 2001 by Max Horn */
#include <unistd.h>
#include <ctype.h>
#include <sysexits.h>
#include <mach/mach.h>
#include <mach/mach_error.h>
#include <IOKit/IOKitLib.h>
#include <IOKit/IOCFPlugIn.h>
36
37
38
#ifdef MACOS_10_0_4
#include <IOKit/hidsystem/IOHIDUsageTables.h>
#else
39
/* The header was moved here in Mac OS X 10.1 */
40
#include <Kernel/IOKit/hidsystem/IOHIDUsageTables.h>
41
#endif
42
43
44
#include <IOKit/hid/IOHIDLib.h>
#include <IOKit/hid/IOHIDKeys.h>
#include <CoreFoundation/CoreFoundation.h>
45
#include <Carbon/Carbon.h> /* for NewPtrClear, DisposePtr */
46
47
#include "SDL_joystick.h"
48
49
#include "../SDL_sysjoystick.h"
#include "../SDL_joystick_c.h"
50
51
52
struct recElement
{
53
54
55
IOHIDElementCookie cookie; /* unique value which identifies element, will NOT change */
long min; /* reported min value possible */
long max; /* reported max value possible */
56
#if 0
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
/* TODO: maybe should handle the following stuff somehow? */
long scaledMin; /* reported scaled min value possible */
long scaledMax; /* reported scaled max value possible */
long size; /* size in bits of data return from element */
Boolean relative; /* are reports relative to last report (deltas) */
Boolean wrapping; /* does element wrap around (one value higher than max is min) */
Boolean nonLinear; /* are the values reported non-linear relative to element movement */
Boolean preferredState; /* does element have a preferred state (such as a button) */
Boolean nullState; /* does element have null state */
#endif /* 0 */
/* runtime variables used for auto-calibration */
long minReport; /* min returned value */
long maxReport; /* max returned value */
struct recElement *pNext; /* next element in list */
74
75
76
77
78
};
typedef struct recElement recElement;
struct joystick_hwdata
{
79
IOHIDDeviceInterface **interface; /* interface to device, NULL = no interface */
80
81
82
83
char product[256]; /* name of product */
long usage; /* usage page from IOUSBHID Parser.h which defines general usage */
long usagePage; /* usage within above page from IOUSBHID Parser.h which defines specific usage */
84
85
86
87
88
long axes; /* number of axis (calculated, not reported by device) */
long buttons; /* number of buttons (calculated, not reported by device) */
long hats; /* number of hat switches (calculated, not reported by device) */
long elements; /* number of total elements (shouldbe total of above) (calculated, not reported by device) */
89
90
91
92
recElement *firstAxis;
recElement *firstButton;
recElement *firstHat;
93
94
95
int removed;
int uncentered;
96
97
struct joystick_hwdata *pNext; /* next device */
98
99
100
101
102
103
104
105
};
typedef struct joystick_hwdata recDevice;
/* Linked list of all available devices */
static recDevice *gpDeviceList = NULL;
106
static void
107
HIDReportErrorNum(char *strError, long numError)
108
{
109
SDL_SetError(strError);
110
111
}
112
113
static void HIDGetCollectionElements(CFMutableDictionaryRef deviceProperties,
recDevice * pDevice);
114
115
116
117
118
/* returns current value for element, polling element
* will return 0 on error conditions which should be accounted for by application
*/
119
static SInt32
120
HIDGetElementValue(recDevice * pDevice, recElement * pElement)
121
{
122
123
124
125
126
127
IOReturn result = kIOReturnSuccess;
IOHIDEventStruct hidEvent;
hidEvent.value = 0;
if (NULL != pDevice && NULL != pElement && NULL != pDevice->interface) {
result =
128
129
130
(*(pDevice->interface))->getElementValue(pDevice->interface,
pElement->cookie,
&hidEvent);
131
132
133
134
135
136
137
138
139
140
141
if (kIOReturnSuccess == result) {
/* record min and max for auto calibration */
if (hidEvent.value < pElement->minReport)
pElement->minReport = hidEvent.value;
if (hidEvent.value > pElement->maxReport)
pElement->maxReport = hidEvent.value;
}
}
/* auto user scale */
return hidEvent.value;
142
143
}
144
static SInt32
145
146
HIDScaledCalibratedValue(recDevice * pDevice, recElement * pElement,
long min, long max)
147
{
148
149
float deviceScale = max - min;
float readScale = pElement->maxReport - pElement->minReport;
150
SInt32 value = HIDGetElementValue(pDevice, pElement);
151
152
153
154
155
if (readScale == 0)
return value; /* no scaling at all */
else
return ((value - pElement->minReport) * deviceScale / readScale) +
min;
156
157
}
158
159
static void
160
HIDRemovalCallback(void *target, IOReturn result, void *refcon, void *sender)
161
{
162
163
164
recDevice *device = (recDevice *) refcon;
device->removed = 1;
device->uncentered = 1;
165
166
167
168
}
169
170
171
172
/* Create and open an interface to device, required prior to extracting values or building queues.
* Note: appliction now owns the device and must close and release it prior to exiting
*/
173
static IOReturn
174
HIDCreateOpenDeviceInterface(io_object_t hidDevice, recDevice * pDevice)
175
{
176
177
178
179
180
181
182
IOReturn result = kIOReturnSuccess;
HRESULT plugInResult = S_OK;
SInt32 score = 0;
IOCFPlugInInterface **ppPlugInInterface = NULL;
if (NULL == pDevice->interface) {
result =
183
184
185
186
IOCreatePlugInInterfaceForService(hidDevice,
kIOHIDDeviceUserClientTypeID,
kIOCFPlugInInterfaceID,
&ppPlugInInterface, &score);
187
188
189
if (kIOReturnSuccess == result) {
/* Call a method of the intermediate plug-in to create the device interface */
plugInResult =
190
191
192
193
194
(*ppPlugInInterface)->QueryInterface(ppPlugInInterface,
CFUUIDGetUUIDBytes
(kIOHIDDeviceInterfaceID),
(void *) &(pDevice->
interface));
195
196
197
198
if (S_OK != plugInResult)
HIDReportErrorNum
("CouldnÕt query HID class device interface from plugInInterface",
plugInResult);
199
(*ppPlugInInterface)->Release(ppPlugInInterface);
200
201
202
203
204
205
} else
HIDReportErrorNum
("Failed to create **plugInInterface via IOCreatePlugInInterfaceForService.",
result);
}
if (NULL != pDevice->interface) {
206
result = (*(pDevice->interface))->open(pDevice->interface, 0);
207
208
209
210
if (kIOReturnSuccess != result)
HIDReportErrorNum
("Failed to open pDevice->interface via open.", result);
else
211
212
213
(*(pDevice->interface))->setRemovalCallback(pDevice->interface,
HIDRemovalCallback,
pDevice, pDevice);
214
215
216
}
return result;
217
218
219
220
221
222
223
224
}
/* Closes and releases interface to device, should be done prior to exting application
* Note: will have no affect if device or interface do not exist
* application will "own" the device if interface is not closed
* (device may have to be plug and re-plugged in different location to get it working again without a restart)
*/
225
static IOReturn
226
HIDCloseReleaseInterface(recDevice * pDevice)
227
{
228
229
230
231
IOReturn result = kIOReturnSuccess;
if ((NULL != pDevice) && (NULL != pDevice->interface)) {
/* close the interface */
232
result = (*(pDevice->interface))->close(pDevice->interface);
233
234
235
if (kIOReturnNotOpen == result) {
/* do nothing as device was not opened, thus can't be closed */
} else if (kIOReturnSuccess != result)
236
237
HIDReportErrorNum("Failed to close IOHIDDeviceInterface.",
result);
238
/* release the interface */
239
result = (*(pDevice->interface))->Release(pDevice->interface);
240
if (kIOReturnSuccess != result)
241
242
HIDReportErrorNum("Failed to release IOHIDDeviceInterface.",
result);
243
244
245
pDevice->interface = NULL;
}
return result;
246
247
248
249
}
/* extracts actual specific element information from each element CF dictionary entry */
250
static void
251
HIDGetElementInfo(CFTypeRef refElement, recElement * pElement)
252
{
253
254
255
long number;
CFTypeRef refType;
256
257
refType = CFDictionaryGetValue(refElement, CFSTR(kIOHIDElementCookieKey));
if (refType && CFNumberGetValue(refType, kCFNumberLongType, &number))
258
pElement->cookie = (IOHIDElementCookie) number;
259
260
refType = CFDictionaryGetValue(refElement, CFSTR(kIOHIDElementMinKey));
if (refType && CFNumberGetValue(refType, kCFNumberLongType, &number))
261
262
pElement->min = number;
pElement->maxReport = pElement->min;
263
264
refType = CFDictionaryGetValue(refElement, CFSTR(kIOHIDElementMaxKey));
if (refType && CFNumberGetValue(refType, kCFNumberLongType, &number))
265
266
pElement->max = number;
pElement->minReport = pElement->max;
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
/*
TODO: maybe should handle the following stuff somehow?
refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementScaledMinKey));
if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
pElement->scaledMin = number;
refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementScaledMaxKey));
if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
pElement->scaledMax = number;
refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementSizeKey));
if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
pElement->size = number;
refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementIsRelativeKey));
if (refType)
pElement->relative = CFBooleanGetValue (refType);
refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementIsWrappingKey));
if (refType)
pElement->wrapping = CFBooleanGetValue (refType);
refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementIsNonLinearKey));
if (refType)
pElement->nonLinear = CFBooleanGetValue (refType);
refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementHasPreferedStateKey));
if (refType)
pElement->preferredState = CFBooleanGetValue (refType);
refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementHasNullStateKey));
if (refType)
pElement->nullState = CFBooleanGetValue (refType);
*/
295
}
296
297
298
299
300
301
/* examines CF dictionary vlaue in device element hierarchy to determine if it is element of interest or a collection of more elements
* if element of interest allocate storage, add to list and retrieve element specific info
* if collection then pass on to deconstruction collection into additional individual elements
*/
302
static void
303
HIDAddElement(CFTypeRef refElement, recDevice * pDevice)
304
{
305
306
307
308
recElement *element = NULL;
recElement **headElement = NULL;
long elementType, usagePage, usage;
CFTypeRef refElementType =
309
CFDictionaryGetValue(refElement, CFSTR(kIOHIDElementTypeKey));
310
CFTypeRef refUsagePage =
311
CFDictionaryGetValue(refElement, CFSTR(kIOHIDElementUsagePageKey));
312
CFTypeRef refUsage =
313
CFDictionaryGetValue(refElement, CFSTR(kIOHIDElementUsageKey));
314
315
316
317
if ((refElementType)
&&
318
(CFNumberGetValue(refElementType, kCFNumberLongType, &elementType))) {
319
320
321
322
323
/* look at types of interest */
if ((elementType == kIOHIDElementTypeInput_Misc)
|| (elementType == kIOHIDElementTypeInput_Button)
|| (elementType == kIOHIDElementTypeInput_Axis)) {
if (refUsagePage
324
325
326
&& CFNumberGetValue(refUsagePage, kCFNumberLongType,
&usagePage) && refUsage
&& CFNumberGetValue(refUsage, kCFNumberLongType, &usage)) {
327
328
329
330
331
332
333
334
335
336
337
338
339
340
switch (usagePage) { /* only interested in kHIDPage_GenericDesktop and kHIDPage_Button */
case kHIDPage_GenericDesktop:
{
switch (usage) { /* look at usage to determine function */
case kHIDUsage_GD_X:
case kHIDUsage_GD_Y:
case kHIDUsage_GD_Z:
case kHIDUsage_GD_Rx:
case kHIDUsage_GD_Ry:
case kHIDUsage_GD_Rz:
case kHIDUsage_GD_Slider:
case kHIDUsage_GD_Dial:
case kHIDUsage_GD_Wheel:
element = (recElement *)
341
NewPtrClear(sizeof(recElement));
342
343
344
345
346
347
348
if (element) {
pDevice->axes++;
headElement = &(pDevice->firstAxis);
}
break;
case kHIDUsage_GD_Hatswitch:
element = (recElement *)
349
NewPtrClear(sizeof(recElement));
350
351
352
353
354
355
356
357
358
359
if (element) {
pDevice->hats++;
headElement = &(pDevice->firstHat);
}
break;
}
}
break;
case kHIDPage_Button:
element = (recElement *)
360
NewPtrClear(sizeof(recElement));
361
362
363
364
365
366
367
368
369
370
if (element) {
pDevice->buttons++;
headElement = &(pDevice->firstButton);
}
break;
default:
break;
}
}
} else if (kIOHIDElementTypeCollection == elementType)
371
372
HIDGetCollectionElements((CFMutableDictionaryRef) refElement,
pDevice);
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
}
if (element && headElement) { /* add to list */
pDevice->elements++;
if (NULL == *headElement)
*headElement = element;
else {
recElement *elementPrevious, *elementCurrent;
elementCurrent = *headElement;
while (elementCurrent) {
elementPrevious = elementCurrent;
elementCurrent = elementPrevious->pNext;
}
elementPrevious->pNext = element;
}
element->pNext = NULL;
389
HIDGetElementInfo(refElement, element);
390
}
391
392
393
394
}
/* collects information from each array member in device element list (each array memeber = element) */
395
static void
396
HIDGetElementsCFArrayHandler(const void *value, void *parameter)
397
{
398
399
if (CFGetTypeID(value) == CFDictionaryGetTypeID())
HIDAddElement((CFTypeRef) value, (recDevice *) parameter);
400
401
402
403
}
/* handles retrieval of element information from arrays of elements in device IO registry information */
404
static void
405
HIDGetElements(CFTypeRef refElementCurrent, recDevice * pDevice)
406
{
407
408
409
CFTypeID type = CFGetTypeID(refElementCurrent);
if (type == CFArrayGetTypeID()) { /* if element is an array */
CFRange range = { 0, CFArrayGetCount(refElementCurrent) };
410
/* CountElementsCFArrayHandler called for each array member */
411
412
CFArrayApplyFunction(refElementCurrent, range,
HIDGetElementsCFArrayHandler, pDevice);
413
414
}
}
415
416
417
418
419
/* handles extracting element information from element collection CF types
* used from top level element decoding and hierarchy deconstruction to flatten device element list
*/
420
static void
421
422
HIDGetCollectionElements(CFMutableDictionaryRef deviceProperties,
recDevice * pDevice)
423
{
424
CFTypeRef refElementTop =
425
CFDictionaryGetValue(deviceProperties, CFSTR(kIOHIDElementKey));
426
if (refElementTop)
427
HIDGetElements(refElementTop, pDevice);
428
429
430
431
}
/* use top level element usage page and usage to discern device usage page and usage setting appropriate vlaues in device record */
432
static void
433
HIDTopLevelElementHandler(const void *value, void *parameter)
434
{
435
CFTypeRef refCF = 0;
436
if (CFGetTypeID(value) != CFDictionaryGetTypeID())
437
return;
438
refCF = CFDictionaryGetValue(value, CFSTR(kIOHIDElementUsagePageKey));
439
440
if (!CFNumberGetValue
(refCF, kCFNumberLongType, &((recDevice *) parameter)->usagePage))
441
442
SDL_SetError("CFNumberGetValue error retrieving pDevice->usagePage.");
refCF = CFDictionaryGetValue(value, CFSTR(kIOHIDElementUsageKey));
443
444
if (!CFNumberGetValue
(refCF, kCFNumberLongType, &((recDevice *) parameter)->usage))
445
SDL_SetError("CFNumberGetValue error retrieving pDevice->usage.");
446
447
448
449
}
/* extracts device info from CF dictionary records in IO registry */
450
static void
451
452
HIDGetDeviceInfo(io_object_t hidDevice, CFMutableDictionaryRef hidProperties,
recDevice * pDevice)
453
{
454
455
456
457
458
459
460
CFMutableDictionaryRef usbProperties = 0;
io_registry_entry_t parent1, parent2;
/* Mac OS X currently is not mirroring all USB properties to HID page so need to look at USB device page also
* get dictionary for usb properties: step up two levels and get CF dictionary for USB properties
*/
if ((KERN_SUCCESS ==
461
IORegistryEntryGetParentEntry(hidDevice, kIOServicePlane, &parent1))
462
&& (KERN_SUCCESS ==
463
IORegistryEntryGetParentEntry(parent1, kIOServicePlane, &parent2))
464
&& (KERN_SUCCESS ==
465
466
467
IORegistryEntryCreateCFProperties(parent2, &usbProperties,
kCFAllocatorDefault,
kNilOptions))) {
468
469
470
471
472
473
474
475
476
if (usbProperties) {
CFTypeRef refCF = 0;
/* get device info
* try hid dictionary first, if fail then go to usb dictionary
*/
/* get product name */
refCF =
477
CFDictionaryGetValue(hidProperties, CFSTR(kIOHIDProductKey));
478
479
if (!refCF)
refCF =
480
481
CFDictionaryGetValue(usbProperties,
CFSTR("USB Product Name"));
482
483
484
if (refCF) {
if (!CFStringGetCString
(refCF, pDevice->product, 256,
485
CFStringGetSystemEncoding()))
486
487
488
489
490
491
SDL_SetError
("CFStringGetCString error retrieving pDevice->product.");
}
/* get usage page and usage */
refCF =
492
493
CFDictionaryGetValue(hidProperties,
CFSTR(kIOHIDPrimaryUsagePageKey));
494
495
496
497
498
499
if (refCF) {
if (!CFNumberGetValue
(refCF, kCFNumberLongType, &pDevice->usagePage))
SDL_SetError
("CFNumberGetValue error retrieving pDevice->usagePage.");
refCF =
500
501
CFDictionaryGetValue(hidProperties,
CFSTR(kIOHIDPrimaryUsageKey));
502
503
504
505
506
507
508
509
510
511
512
if (refCF)
if (!CFNumberGetValue
(refCF, kCFNumberLongType, &pDevice->usage))
SDL_SetError
("CFNumberGetValue error retrieving pDevice->usage.");
}
if (NULL == refCF) { /* get top level element HID usage page or usage */
/* use top level element instead */
CFTypeRef refCFTopElement = 0;
refCFTopElement =
513
514
CFDictionaryGetValue(hidProperties,
CFSTR(kIOHIDElementKey));
515
516
{
/* refCFTopElement points to an array of element dictionaries */
517
518
519
CFRange range = { 0, CFArrayGetCount(refCFTopElement) };
CFArrayApplyFunction(refCFTopElement, range,
HIDTopLevelElementHandler, pDevice);
520
521
522
}
}
523
CFRelease(usbProperties);
524
525
526
527
} else
SDL_SetError
("IORegistryEntryCreateCFProperties failed to create usbProperties.");
528
529
530
531
if (kIOReturnSuccess != IOObjectRelease(parent2))
SDL_SetError("IOObjectRelease error with parent2.");
if (kIOReturnSuccess != IOObjectRelease(parent1))
SDL_SetError("IOObjectRelease error with parent1.");
532
}
533
534
535
}
536
static recDevice *
537
HIDBuildDevice(io_object_t hidDevice)
538
{
539
recDevice *pDevice = (recDevice *) NewPtrClear(sizeof(recDevice));
540
541
542
543
if (pDevice) {
/* get dictionary for HID properties */
CFMutableDictionaryRef hidProperties = 0;
kern_return_t result =
544
545
546
IORegistryEntryCreateCFProperties(hidDevice, &hidProperties,
kCFAllocatorDefault,
kNilOptions);
547
548
if ((result == KERN_SUCCESS) && hidProperties) {
/* create device interface */
549
result = HIDCreateOpenDeviceInterface(hidDevice, pDevice);
550
if (kIOReturnSuccess == result) {
551
552
HIDGetDeviceInfo(hidDevice, hidProperties, pDevice); /* hidDevice used to find parents in registry tree */
HIDGetCollectionElements(hidProperties, pDevice);
553
} else {
554
DisposePtr((Ptr) pDevice);
555
556
pDevice = NULL;
}
557
CFRelease(hidProperties);
558
} else {
559
DisposePtr((Ptr) pDevice);
560
561
562
563
pDevice = NULL;
}
}
return pDevice;
564
565
566
567
568
}
/* disposes of the element list associated with a device and the memory associated with the list
*/
569
static void
570
HIDDisposeElementList(recElement ** elementList)
571
{
572
573
574
recElement *pElement = *elementList;
while (pElement) {
recElement *pElementNext = pElement->pNext;
575
DisposePtr((Ptr) pElement);
576
577
578
pElement = pElementNext;
}
*elementList = NULL;
579
580
581
582
583
584
}
/* disposes of a single device, closing and releaseing interface, freeing memory fro device and elements, setting device pointer to NULL
* all your device no longer belong to us... (i.e., you do not 'own' the device anymore)
*/
585
static recDevice *
586
HIDDisposeDevice(recDevice ** ppDevice)
587
{
588
589
590
591
592
593
594
kern_return_t result = KERN_SUCCESS;
recDevice *pDeviceNext = NULL;
if (*ppDevice) {
/* save next device prior to disposing of this device */
pDeviceNext = (*ppDevice)->pNext;
/* free element lists */
595
596
597
HIDDisposeElementList(&(*ppDevice)->firstAxis);
HIDDisposeElementList(&(*ppDevice)->firstButton);
HIDDisposeElementList(&(*ppDevice)->firstHat);
598
599
result = HIDCloseReleaseInterface(*ppDevice); /* function sanity checks interface value (now application does not own device) */
600
601
602
603
if (kIOReturnSuccess != result)
HIDReportErrorNum
("HIDCloseReleaseInterface failed when trying to dipose device.",
result);
604
DisposePtr((Ptr) * ppDevice);
605
606
607
*ppDevice = NULL;
}
return pDeviceNext;
608
609
610
611
612
613
614
615
}
/* Function to scan the system for joysticks.
* Joystick 0 should be the system default joystick.
* This function should return the number of available joysticks, or -1
* on an unrecoverable fatal error.
*/
616
int
617
SDL_SYS_JoystickInit(void)
618
{
619
620
621
622
623
624
625
626
627
628
IOReturn result = kIOReturnSuccess;
mach_port_t masterPort = 0;
io_iterator_t hidObjectIterator = 0;
CFMutableDictionaryRef hidMatchDictionary = NULL;
recDevice *device, *lastDevice;
io_object_t ioHIDDeviceObject = 0;
SDL_numjoysticks = 0;
if (gpDeviceList) {
629
SDL_SetError("Joystick: Device list already inited.");
630
631
632
return -1;
}
633
result = IOMasterPort(bootstrap_port, &masterPort);
634
if (kIOReturnSuccess != result) {
635
SDL_SetError("Joystick: IOMasterPort error with bootstrap_port.");
636
637
638
639
return -1;
}
/* Set up a matching dictionary to search I/O Registry by class name for all HID class devices. */
640
hidMatchDictionary = IOServiceMatching(kIOHIDDeviceKey);
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
if (hidMatchDictionary) {
/* Add key for device type (joystick, in this case) to refine the matching dictionary. */
/* NOTE: we now perform this filtering later
UInt32 usagePage = kHIDPage_GenericDesktop;
UInt32 usage = kHIDUsage_GD_Joystick;
CFNumberRef refUsage = NULL, refUsagePage = NULL;
refUsage = CFNumberCreate (kCFAllocatorDefault, kCFNumberIntType, &usage);
CFDictionarySetValue (hidMatchDictionary, CFSTR (kIOHIDPrimaryUsageKey), refUsage);
refUsagePage = CFNumberCreate (kCFAllocatorDefault, kCFNumberIntType, &usagePage);
CFDictionarySetValue (hidMatchDictionary, CFSTR (kIOHIDPrimaryUsagePageKey), refUsagePage);
*/
} else {
SDL_SetError
("Joystick: Failed to get HID CFMutableDictionaryRef via IOServiceMatching.");
return -1;
}
/*/ Now search I/O Registry for matching devices. */
result =
662
663
IOServiceGetMatchingServices(masterPort, hidMatchDictionary,
&hidObjectIterator);
664
665
/* Check for errors */
if (kIOReturnSuccess != result) {
666
SDL_SetError("Joystick: Couldn't create a HID object iterator.");
667
668
669
670
671
672
673
674
675
676
677
678
679
return -1;
}
if (!hidObjectIterator) { /* there are no joysticks */
gpDeviceList = NULL;
SDL_numjoysticks = 0;
return 0;
}
/* IOServiceGetMatchingServices consumes a reference to the dictionary, so we don't need to release the dictionary ref. */
/* build flat linked list of devices from device iterator */
gpDeviceList = lastDevice = NULL;
680
while ((ioHIDDeviceObject = IOIteratorNext(hidObjectIterator))) {
681
/* build a device record */
682
device = HIDBuildDevice(ioHIDDeviceObject);
683
684
685
686
if (!device)
continue;
/* dump device object, it is no longer needed */
687
result = IOObjectRelease(ioHIDDeviceObject);
688
689
690
/* if (KERN_SUCCESS != result)
HIDReportErrorNum ("IOObjectRelease error with ioHIDDeviceObject.", result);
*/
691
692
693
694
695
696
697
/* Filter device list to non-keyboard/mouse stuff */
if ((device->usagePage != kHIDPage_GenericDesktop) ||
((device->usage != kHIDUsage_GD_Joystick &&
device->usage != kHIDUsage_GD_GamePad))) {
/* release memory for the device */
698
699
HIDDisposeDevice(&device);
DisposePtr((Ptr) device);
700
701
702
703
704
705
706
707
708
709
continue;
}
/* Add device to the end of the list */
if (lastDevice)
lastDevice->pNext = device;
else
gpDeviceList = device;
lastDevice = device;
}
710
result = IOObjectRelease(hidObjectIterator); /* release the iterator */
711
712
713
714
715
716
717
718
719
/* Count the total number of devices we found */
device = gpDeviceList;
while (device) {
SDL_numjoysticks++;
device = device->pNext;
}
return SDL_numjoysticks;
720
721
722
}
/* Function to get the device-dependent name of a joystick */
723
const char *
724
SDL_SYS_JoystickName(int index)
725
{
726
recDevice *device = gpDeviceList;
727
728
729
730
731
for (; index > 0; index--)
device = device->pNext;
return device->product;
732
733
734
735
736
737
738
}
/* Function to open a joystick for use.
* The joystick to open is specified by the index field of the joystick.
* This should fill the nbuttons and naxes fields of the joystick structure.
* It returns 0, or -1 if there is an error.
*/
739
int
740
SDL_SYS_JoystickOpen(SDL_Joystick * joystick)
741
{
742
743
744
745
746
recDevice *device = gpDeviceList;
int index;
for (index = joystick->index; index > 0; index--)
device = device->pNext;
747
748
749
joystick->hwdata = device;
joystick->name = device->product;
750
751
752
753
754
joystick->naxes = device->axes;
joystick->nhats = device->hats;
joystick->nballs = 0;
joystick->nbuttons = device->buttons;
755
756
return 0;
757
758
759
760
761
762
763
}
/* Function to update the state of a joystick - called as a device poll.
* This function shouldn't update the joystick structure directly,
* but instead should call SDL_PrivateJoystick*() to deliver events
* and update joystick device state.
*/
764
void
765
SDL_SYS_JoystickUpdate(SDL_Joystick * joystick)
766
{
767
768
769
770
771
772
773
774
775
776
777
recDevice *device = joystick->hwdata;
recElement *element;
SInt32 value;
int i;
if (device->removed) { /* device was unplugged; ignore it. */
if (device->uncentered) {
device->uncentered = 0;
/* Tell the app that everything is centered/unpressed... */
for (i = 0; i < device->axes; i++)
778
SDL_PrivateJoystickAxis(joystick, i, 0);
779
780
for (i = 0; i < device->buttons; i++)
781
SDL_PrivateJoystickButton(joystick, i, 0);
782
783
for (i = 0; i < device->hats; i++)
784
SDL_PrivateJoystickHat(joystick, i, SDL_HAT_CENTERED);
785
786
787
788
789
790
791
792
}
return;
}
element = device->firstAxis;
i = 0;
while (element) {
793
value = HIDScaledCalibratedValue(device, element, -32768, 32767);
794
if (value != joystick->axes[i])
795
SDL_PrivateJoystickAxis(joystick, i, value);
796
797
798
799
800
801
802
element = element->pNext;
++i;
}
element = device->firstButton;
i = 0;
while (element) {
803
value = HIDGetElementValue(device, element);
804
if (value > 1) /* handle pressure-sensitive buttons */
805
value = 1;
806
if (value != joystick->buttons[i])
807
SDL_PrivateJoystickButton(joystick, i, value);
808
809
810
811
812
813
814
815
816
element = element->pNext;
++i;
}
element = device->firstHat;
i = 0;
while (element) {
Uint8 pos = 0;
817
value = HIDGetElementValue(device, element);
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
if (element->max == 3) /* 4 position hatswitch - scale up value */
value *= 2;
else if (element->max != 7) /* Neither a 4 nor 8 positions - fall back to default position (centered) */
value = -1;
switch (value) {
case 0:
pos = SDL_HAT_UP;
break;
case 1:
pos = SDL_HAT_RIGHTUP;
break;
case 2:
pos = SDL_HAT_RIGHT;
break;
case 3:
pos = SDL_HAT_RIGHTDOWN;
break;
case 4:
pos = SDL_HAT_DOWN;
break;
case 5:
pos = SDL_HAT_LEFTDOWN;
break;
case 6:
pos = SDL_HAT_LEFT;
break;
case 7:
pos = SDL_HAT_LEFTUP;
break;
default:
/* Every other value is mapped to center. We do that because some
* joysticks use 8 and some 15 for this value, and apparently
* there are even more variants out there - so we try to be generous.
*/
pos = SDL_HAT_CENTERED;
break;
}
if (pos != joystick->hats[i])
856
SDL_PrivateJoystickHat(joystick, i, pos);
857
858
859
860
861
element = element->pNext;
++i;
}
return;
862
863
864
}
/* Function to close a joystick after use */
865
void
866
SDL_SYS_JoystickClose(SDL_Joystick * joystick)
867
{
868
869
/* Should we do anything here? */
return;
870
871
872
}
/* Function to perform any system-specific joystick related cleanup */
873
void
874
SDL_SYS_JoystickQuit(void)
875
{
876
while (NULL != gpDeviceList)
877
gpDeviceList = HIDDisposeDevice(&gpDeviceList);
878
}
879
880
#endif /* SDL_JOYSTICK_IOKIT */
881
/* vi: set ts=4 sw=4 expandtab: */