dlls/winejoystick.drv/joystick_osx.c

   1 /*
   2  * WinMM joystick driver OS X implementation
   3  *
   4  * Copyright 1997 Andreas Mohr
   5  * Copyright 1998 Marcus Meissner
   6  * Copyright 1998,1999 Lionel Ulmer
   7  * Copyright 2000 Wolfgang Schwotzer
   8  * Copyright 2000-2001 TransGaming Technologies Inc.
   9  * Copyright 2002 David Hagood
  10  * Copyright 2009 CodeWeavers, Aric Stewart
  11  * Copyright 2015 Ken Thomases for CodeWeavers Inc.
  12  *
  13  * This library is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU Lesser General Public
  15  * License as published by the Free Software Foundation; either
  16  * version 2.1 of the License, or (at your option) any later version.
  17  *
  18  * This library 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 GNU
  21  * Lesser General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public
  24  * License along with this library; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  26  */
  27
  28 #include "config.h"
  29
  30 #if defined(HAVE_IOKIT_HID_IOHIDLIB_H)
  31
  32 #define DWORD UInt32
  33 #define LPDWORD UInt32*
  34 #define LONG SInt32
  35 #define LPLONG SInt32*
  36 #define E_PENDING __carbon_E_PENDING
  37 #define ULONG __carbon_ULONG
  38 #define E_INVALIDARG __carbon_E_INVALIDARG
  39 #define E_OUTOFMEMORY __carbon_E_OUTOFMEMORY
  40 #define E_HANDLE __carbon_E_HANDLE
  41 #define E_ACCESSDENIED __carbon_E_ACCESSDENIED
  42 #define E_UNEXPECTED __carbon_E_UNEXPECTED
  43 #define E_FAIL __carbon_E_FAIL
  44 #define E_ABORT __carbon_E_ABORT
  45 #define E_POINTER __carbon_E_POINTER
  46 #define E_NOINTERFACE __carbon_E_NOINTERFACE
  47 #define E_NOTIMPL __carbon_E_NOTIMPL
  48 #define S_FALSE __carbon_S_FALSE
  49 #define S_OK __carbon_S_OK
  50 #define HRESULT_FACILITY __carbon_HRESULT_FACILITY
  51 #define IS_ERROR __carbon_IS_ERROR
  52 #define FAILED __carbon_FAILED
  53 #define SUCCEEDED __carbon_SUCCEEDED
  54 #define MAKE_HRESULT __carbon_MAKE_HRESULT
  55 #define HRESULT __carbon_HRESULT
  56 #define STDMETHODCALLTYPE __carbon_STDMETHODCALLTYPE
  57 #include <IOKit/IOKitLib.h>
  58 #include <IOKit/hid/IOHIDLib.h>
  59 #undef ULONG
  60 #undef E_INVALIDARG
  61 #undef E_OUTOFMEMORY
  62 #undef E_HANDLE
  63 #undef E_ACCESSDENIED
  64 #undef E_UNEXPECTED
  65 #undef E_FAIL
  66 #undef E_ABORT
  67 #undef E_POINTER
  68 #undef E_NOINTERFACE
  69 #undef E_NOTIMPL
  70 #undef S_FALSE
  71 #undef S_OK
  72 #undef HRESULT_FACILITY
  73 #undef IS_ERROR
  74 #undef FAILED
  75 #undef SUCCEEDED
  76 #undef MAKE_HRESULT
  77 #undef HRESULT
  78 #undef STDMETHODCALLTYPE
  79 #undef DWORD
  80 #undef LPDWORD
  81 #undef LONG
  82 #undef LPLONG
  83 #undef E_PENDING
  84
  85 #include "joystick.h"
  86
  87 #include "wine/debug.h"
  88
  89
  90 WINE_DEFAULT_DEBUG_CHANNEL(joystick);
  91
  92
  93 #define MAXJOYSTICK (JOYSTICKID2 + 30)
  94
  95
  96 enum {
  97     AXIS_X,
  98     AXIS_Y,
  99     AXIS_Z,
 100     AXIS_RX,
 101     AXIS_RY,
 102     AXIS_RZ,
 103     NUM_AXES
 104 };
 105
 106 struct axis {
 107     IOHIDElementRef element;
 108     CFIndex min_value, max_value;
 109 };
 110
 111 typedef struct {
 112     BOOL                in_use;
 113     IOHIDElementRef     element;
 114     struct axis         axes[NUM_AXES];
 115     CFMutableArrayRef   buttons;
 116     IOHIDElementRef     hatswitch;
 117 } joystick_t;
 118
 119
 120 static joystick_t joysticks[MAXJOYSTICK];
 121 static CFMutableArrayRef device_main_elements = NULL;
 122
 123
 124 static const char* debugstr_cf(CFTypeRef t)
 125 {
 126     CFStringRef s;
 127     const char* ret;
 128
 129     if (!t) return "(null)";
 130
 131     if (CFGetTypeID(t) == CFStringGetTypeID())
 132         s = t;
 133     else
 134         s = CFCopyDescription(t);
 135     ret = CFStringGetCStringPtr(s, kCFStringEncodingUTF8);
 136     if (ret) ret = debugstr_a(ret);
 137     if (!ret)
 138     {
 139         const UniChar* u = CFStringGetCharactersPtr(s);
 140         if (u)
 141             ret = debugstr_wn((const WCHAR*)u, CFStringGetLength(s));
 142     }
 143     if (!ret)
 144     {
 145         UniChar buf[200];
 146         int len = min(CFStringGetLength(s), sizeof(buf)/sizeof(buf[0]));
 147         CFStringGetCharacters(s, CFRangeMake(0, len), buf);
 148         ret = debugstr_wn(buf, len);
 149     }
 150     if (s != t) CFRelease(s);
 151     return ret;
 152 }
 153
 154 static const char* debugstr_device(IOHIDDeviceRef device)
 155 {
 156     return wine_dbg_sprintf("<IOHIDDevice %p product %s>", device,
 157                             debugstr_cf(IOHIDDeviceGetProperty(device, CFSTR(kIOHIDProductKey))));
 158 }
 159
 160 static const char* debugstr_element(IOHIDElementRef element)
 161 {
 162     return wine_dbg_sprintf("<IOHIDElement %p type %d usage %u/%u device %p>", element,
 163                             IOHIDElementGetType(element), IOHIDElementGetUsagePage(element),
 164                             IOHIDElementGetUsage(element), IOHIDElementGetDevice(element));
 165 }
 166
 167
 168 static int axis_for_usage(int usage)
 169 {
 170     switch (usage)
 171     {
 172         case kHIDUsage_GD_X: return AXIS_X;
 173         case kHIDUsage_GD_Y: return AXIS_Y;
 174         case kHIDUsage_GD_Z: return AXIS_Z;
 175         case kHIDUsage_GD_Rx: return AXIS_RX;
 176         case kHIDUsage_GD_Ry: return AXIS_RY;
 177         case kHIDUsage_GD_Rz: return AXIS_RZ;
 178     }
 179
 180     return -1;
 181 }
 182
 183
 184 /**************************************************************************
 185  *                              joystick_from_id
 186  */
 187 static joystick_t* joystick_from_id(DWORD_PTR device_id)
 188 {
 189     int index;
 190
 191     if ((device_id - (DWORD_PTR)joysticks) % sizeof(joysticks[0]) != 0)
 192         return NULL;
 193     index = (device_id - (DWORD_PTR)joysticks) / sizeof(joysticks[0]);
 194     if (index < 0 || index >= MAXJOYSTICK || !((joystick_t*)device_id)->in_use)
 195         return NULL;
 196
 197     return (joystick_t*)device_id;
 198 }
 199
 200 /**************************************************************************
 201  *                              create_osx_device_match
 202  */
 203 static CFDictionaryRef create_osx_device_match(int usage)
 204 {
 205     CFDictionaryRef result = NULL;
 206     int number;
 207     CFStringRef keys[] = { CFSTR(kIOHIDDeviceUsagePageKey), CFSTR(kIOHIDDeviceUsageKey) };
 208     CFNumberRef values[2];
 209     int i;
 210
 211     TRACE("usage %d\n", usage);
 212
 213     number = kHIDPage_GenericDesktop;
 214     values[0] = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &number);
 215     values[1] = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &usage);
 216
 217     if (values[0] && values[1])
 218     {
 219         result = CFDictionaryCreate(NULL, (const void**)keys, (const void**)values, sizeof(values) / sizeof(values[0]),
 220                                     &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 221
 222         if (!result)
 223             ERR("CFDictionaryCreate failed.\n");
 224     }
 225     else
 226         ERR("CFNumberCreate failed.\n");
 227
 228     for (i = 0; i < sizeof(values) / sizeof(values[0]); i++)
 229         if (values[i]) CFRelease(values[i]);
 230
 231     return result;
 232 }
 233
 234 /**************************************************************************
 235  *                              find_top_level
 236  */
 237 static CFIndex find_top_level(IOHIDDeviceRef hid_device, CFMutableArrayRef main_elements)
 238 {
 239     CFArrayRef      elements;
 240     CFIndex         total = 0;
 241
 242     TRACE("hid_device %s\n", debugstr_device(hid_device));
 243
 244     if (!hid_device)
 245         return 0;
 246
 247     elements = IOHIDDeviceCopyMatchingElements(hid_device, NULL, 0);
 248
 249     if (elements)
 250     {
 251         CFIndex i, count = CFArrayGetCount(elements);
 252         for (i = 0; i < count; i++)
 253         {
 254             IOHIDElementRef element = (IOHIDElementRef)CFArrayGetValueAtIndex(elements, i);
 255             int type = IOHIDElementGetType(element);
 256
 257             TRACE("element %s\n", debugstr_element(element));
 258
 259             /* Check for top-level gaming device collections */
 260             if (type == kIOHIDElementTypeCollection && IOHIDElementGetParent(element) == 0)
 261             {
 262                 int usage_page = IOHIDElementGetUsagePage(element);
 263                 int usage = IOHIDElementGetUsage(element);
 264
 265                 if (usage_page == kHIDPage_GenericDesktop &&
 266                     (usage == kHIDUsage_GD_Joystick || usage == kHIDUsage_GD_GamePad))
 267                 {
 268                     CFArrayAppendValue(main_elements, element);
 269                     total++;
 270                 }
 271             }
 272         }
 273         CFRelease(elements);
 274     }
 275
 276     TRACE("-> total %d\n", (int)total);
 277     return total;
 278 }
 279
 280 /**************************************************************************
 281  *                              find_osx_devices
 282  */
 283 static int find_osx_devices(void)
 284 {
 285     IOHIDManagerRef hid_manager;
 286     int usages[] = { kHIDUsage_GD_Joystick, kHIDUsage_GD_GamePad };
 287     int i;
 288     CFDictionaryRef matching_dicts[sizeof(usages) / sizeof(usages[0])];
 289     CFArrayRef matching;
 290     CFSetRef devset;
 291
 292     TRACE("()\n");
 293
 294     hid_manager = IOHIDManagerCreate(kCFAllocatorDefault, 0L);
 295     if (IOHIDManagerOpen(hid_manager, 0) != kIOReturnSuccess)
 296     {
 297         ERR("Couldn't open IOHIDManager.\n");
 298         CFRelease(hid_manager);
 299         return 0;
 300     }
 301
 302     for (i = 0; i < sizeof(matching_dicts) / sizeof(matching_dicts[0]); i++)
 303     {
 304         matching_dicts[i] = create_osx_device_match(usages[i]);
 305         if (!matching_dicts[i])
 306         {
 307             while (i > 0)
 308                 CFRelease(matching_dicts[--i]);
 309             goto fail;
 310         }
 311     }
 312
 313     matching = CFArrayCreate(NULL, (const void**)matching_dicts, sizeof(matching_dicts) / sizeof(matching_dicts[0]),
 314                              &kCFTypeArrayCallBacks);
 315
 316     for (i = 0; i < sizeof(matching_dicts) / sizeof(matching_dicts[0]); i++)
 317         CFRelease(matching_dicts[i]);
 318
 319     IOHIDManagerSetDeviceMatchingMultiple(hid_manager, matching);
 320     CFRelease(matching);
 321     devset = IOHIDManagerCopyDevices(hid_manager);
 322     if (devset)
 323     {
 324         CFIndex num_devices, num_main_elements;
 325         const void** refs;
 326         CFArrayRef devices;
 327
 328         num_devices = CFSetGetCount(devset);
 329         refs = HeapAlloc(GetProcessHeap(), 0, num_devices * sizeof(*refs));
 330         if (!refs)
 331         {
 332             CFRelease(devset);
 333             goto fail;
 334         }
 335
 336         CFSetGetValues(devset, refs);
 337         devices = CFArrayCreate(NULL, refs, num_devices, &kCFTypeArrayCallBacks);
 338         HeapFree(GetProcessHeap(), 0, refs);
 339         CFRelease(devset);
 340         if (!devices)
 341             goto fail;
 342
 343         device_main_elements = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
 344         if (!device_main_elements)
 345         {
 346             CFRelease(devices);
 347             goto fail;
 348         }
 349
 350         num_main_elements = 0;
 351         for (i = 0; i < num_devices; i++)
 352         {
 353             IOHIDDeviceRef hid_device = (IOHIDDeviceRef)CFArrayGetValueAtIndex(devices, i);
 354             TRACE("hid_device %s\n", debugstr_device(hid_device));
 355             num_main_elements += find_top_level(hid_device, device_main_elements);
 356         }
 357
 358         CFRelease(devices);
 359
 360         TRACE("found %i device(s), %i collection(s)\n",(int)num_devices,(int)num_main_elements);
 361         return (int)num_main_elements;
 362     }
 363
 364 fail:
 365     IOHIDManagerClose(hid_manager, 0);
 366     CFRelease(hid_manager);
 367     return 0;
 368 }
 369
 370 /**************************************************************************
 371  *                              collect_joystick_elements
 372  */
 373 static void collect_joystick_elements(joystick_t* joystick, IOHIDElementRef collection)
 374 {
 375     CFIndex    i, count;
 376     CFArrayRef children = IOHIDElementGetChildren(collection);
 377
 378     TRACE("collection %s\n", debugstr_element(collection));
 379
 380     count = CFArrayGetCount(children);
 381     for (i = 0; i < count; i++)
 382     {
 383         IOHIDElementRef child;
 384         int type;
 385
 386         child = (IOHIDElementRef)CFArrayGetValueAtIndex(children, i);
 387         TRACE("child %s\n", debugstr_element(child));
 388         type = IOHIDElementGetType(child);
 389         switch (type)
 390         {
 391             case kIOHIDElementTypeCollection:
 392                 collect_joystick_elements(joystick, child);
 393                 break;
 394             case kIOHIDElementTypeInput_Button:
 395             {
 396                 int usage_page = IOHIDElementGetUsagePage(child);
 397
 398                 TRACE("kIOHIDElementTypeInput_Button usage_page %d\n", usage_page);
 399
 400                 /* avoid strange elements found on the 360 controller */
 401                 if (usage_page == kHIDPage_Button)
 402                     CFArrayAppendValue(joystick->buttons, child);
 403                 break;
 404             }
 405             case kIOHIDElementTypeInput_Axis:
 406             {
 407                 TRACE("kIOHIDElementTypeInput_Axis; ignoring\n");
 408                 break;
 409             }
 410             case kIOHIDElementTypeInput_Misc:
 411             {
 412                 uint32_t usage = IOHIDElementGetUsage( child );
 413                 switch(usage)
 414                 {
 415                     case kHIDUsage_GD_Hatswitch:
 416                     {
 417                         TRACE("kIOHIDElementTypeInput_Misc / kHIDUsage_GD_Hatswitch\n");
 418                         if (joystick->hatswitch)
 419                             TRACE("    ignoring additional hatswitch\n");
 420                         else
 421                             joystick->hatswitch = (IOHIDElementRef)CFRetain(child);
 422                         break;
 423                     }
 424                     case kHIDUsage_GD_X:
 425                     case kHIDUsage_GD_Y:
 426                     case kHIDUsage_GD_Z:
 427                     case kHIDUsage_GD_Rx:
 428                     case kHIDUsage_GD_Ry:
 429                     case kHIDUsage_GD_Rz:
 430                     {
 431                         int axis = axis_for_usage(usage);
 432                         TRACE("kIOHIDElementTypeInput_Misc / kHIDUsage_GD_<axis> (%d) axis %d\n", usage, axis);
 433                         if (axis < 0 || joystick->axes[axis].element)
 434                             TRACE("    ignoring\n");
 435                         else
 436                         {
 437                             joystick->axes[axis].element = (IOHIDElementRef)CFRetain(child);
 438                             joystick->axes[axis].min_value = IOHIDElementGetLogicalMin(child);
 439                             joystick->axes[axis].max_value = IOHIDElementGetLogicalMax(child);
 440                         }
 441                         break;
 442                     }
 443                     case kHIDUsage_GD_Slider:
 444                         TRACE("kIOHIDElementTypeInput_Misc / kHIDUsage_GD_Slider; ignoring\n");
 445                         break;
 446                     default:
 447                         FIXME("kIOHIDElementTypeInput_Misc / Unhandled usage %d\n", usage);
 448                         break;
 449                 }
 450                 break;
 451             }
 452             default:
 453                 FIXME("Unhandled type %i\n",type);
 454                 break;
 455         }
 456     }
 457 }
 458
 459 /**************************************************************************
 460  *                              button_usage_comparator
 461  */
 462 static CFComparisonResult button_usage_comparator(const void *val1, const void *val2, void *context)
 463 {
 464     IOHIDElementRef element1 = (IOHIDElementRef)val1, element2 = (IOHIDElementRef)val2;
 465     int usage1 = IOHIDElementGetUsage(element1), usage2 = IOHIDElementGetUsage(element2);
 466
 467     if (usage1 < usage2)
 468         return kCFCompareLessThan;
 469     if (usage1 > usage2)
 470         return kCFCompareGreaterThan;
 471     return kCFCompareEqualTo;
 472 }
 473
 474 /**************************************************************************
 475  *                              driver_open
 476  */
 477 LRESULT driver_open(LPSTR str, DWORD index)
 478 {
 479     if (index >= MAXJOYSTICK || joysticks[index].in_use)
 480         return 0;
 481
 482     joysticks[index].in_use = TRUE;
 483     return (LRESULT)&joysticks[index];
 484 }
 485
 486 /**************************************************************************
 487  *                              driver_close
 488  */
 489 LRESULT driver_close(DWORD_PTR device_id)
 490 {
 491     joystick_t* joystick = joystick_from_id(device_id);
 492     int i;
 493
 494     if (joystick == NULL)
 495         return 0;
 496
 497     CFRelease(joystick->element);
 498     for (i = 0; i < NUM_AXES; i++)
 499     {
 500         if (joystick->axes[i].element)
 501             CFRelease(joystick->axes[i].element);
 502     }
 503     if (joystick->buttons)
 504         CFRelease(joystick->buttons);
 505     if (joystick->hatswitch)
 506         CFRelease(joystick->hatswitch);
 507
 508     memset(joystick, 0, sizeof(*joystick));
 509     return 1;
 510 }
 511
 512 /**************************************************************************
 513  *                              open_joystick
 514  */
 515 static BOOL open_joystick(joystick_t* joystick)
 516 {
 517     CFIndex index;
 518     CFRange range;
 519
 520     if (joystick->element)
 521         return TRUE;
 522
 523     if (!device_main_elements)
 524     {
 525         find_osx_devices();
 526         if (!device_main_elements)
 527             return FALSE;
 528     }
 529
 530     index = joystick - joysticks;
 531     if (index >= CFArrayGetCount(device_main_elements))
 532         return FALSE;
 533
 534     joystick->element = (IOHIDElementRef)CFArrayGetValueAtIndex(device_main_elements, index);
 535     joystick->buttons = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
 536     collect_joystick_elements(joystick, joystick->element);
 537
 538     /* Sort buttons into correct order */
 539     range.location = 0;
 540     range.length = CFArrayGetCount(joystick->buttons);
 541     CFArraySortValues(joystick->buttons, range, button_usage_comparator, NULL);
 542     if (range.length > 32)
 543     {
 544         /* Delete any buttons beyond the first 32 */
 545         range.location = 32;
 546         range.length -= 32;
 547         CFArrayReplaceValues(joystick->buttons, range, NULL, 0);
 548     }
 549
 550     return TRUE;
 551 }
 552
 553
 554 /**************************************************************************
 555  *                              driver_joyGetDevCaps
 556  */
 557 LRESULT driver_joyGetDevCaps(DWORD_PTR device_id, JOYCAPSW* caps, DWORD size)
 558 {
 559     joystick_t* joystick;
 560     IOHIDDeviceRef device;
 561
 562     if ((joystick = joystick_from_id(device_id)) == NULL)
 563         return MMSYSERR_NODRIVER;
 564
 565     if (!open_joystick(joystick))
 566         return JOYERR_PARMS;
 567
 568     caps->szPname[0] = 0;
 569
 570     device = IOHIDElementGetDevice(joystick->element);
 571     if (device)
 572     {
 573         CFStringRef product_name = IOHIDDeviceGetProperty(device, CFSTR(kIOHIDProductKey));
 574         if (product_name)
 575         {
 576             CFRange range;
 577
 578             range.location = 0;
 579             range.length = min(MAXPNAMELEN - 1, CFStringGetLength(product_name));
 580             CFStringGetCharacters(product_name, range, (UniChar*)caps->szPname);
 581             caps->szPname[range.length] = 0;
 582         }
 583     }
 584
 585     caps->wMid = MM_MICROSOFT;
 586     caps->wPid = MM_PC_JOYSTICK;
 587     caps->wXmin = 0;
 588     caps->wXmax = 0xFFFF;
 589     caps->wYmin = 0;
 590     caps->wYmax = 0xFFFF;
 591     caps->wZmin = 0;
 592     caps->wZmax = joystick->axes[AXIS_Z].element ? 0xFFFF : 0;
 593     caps->wNumButtons = CFArrayGetCount(joystick->buttons);
 594     if (size == sizeof(JOYCAPSW))
 595     {
 596         int i;
 597
 598         /* complete 95 structure */
 599         caps->wRmin = 0;
 600         caps->wRmax = 0xFFFF;
 601         caps->wUmin = 0;
 602         caps->wUmax = 0xFFFF;
 603         caps->wVmin = 0;
 604         caps->wVmax = 0xFFFF;
 605         caps->wMaxAxes = 6; /* same as MS Joystick Driver */
 606         caps->wNumAxes = 0;
 607         caps->wMaxButtons = 32; /* same as MS Joystick Driver */
 608         caps->szRegKey[0] = 0;
 609         caps->szOEMVxD[0] = 0;
 610         caps->wCaps = 0;
 611
 612         for (i = 0; i < NUM_AXES; i++)
 613         {
 614             if (joystick->axes[i].element)
 615             {
 616                 caps->wNumAxes++;
 617                 switch (i)
 618                 {
 619                     case AXIS_Z:  caps->wCaps |= JOYCAPS_HASZ; break;
 620                     case AXIS_RX: caps->wCaps |= JOYCAPS_HASU; break;
 621                     case AXIS_RY: caps->wCaps |= JOYCAPS_HASV; break;
 622                     case AXIS_RZ: caps->wCaps |= JOYCAPS_HASR; break;
 623                 }
 624             }
 625         }
 626
 627         if (joystick->hatswitch)
 628             caps->wCaps |= JOYCAPS_HASPOV | JOYCAPS_POV4DIR;
 629     }
 630
 631     TRACE("name %s buttons %u axes %d caps 0x%08x\n", debugstr_w(caps->szPname), caps->wNumButtons, caps->wNumAxes, caps->wCaps);
 632
 633     return JOYERR_NOERROR;
 634 }
 635
 636 /**************************************************************************
 637  *                              driver_joyGetPosEx
 638  */
 639 LRESULT driver_joyGetPosEx(DWORD_PTR device_id, JOYINFOEX* info)
 640 {
 641     static const struct {
 642         DWORD flag;
 643         off_t offset;
 644     } axis_map[NUM_AXES] = {
 645         { JOY_RETURNX, FIELD_OFFSET(JOYINFOEX, dwXpos) },
 646         { JOY_RETURNY, FIELD_OFFSET(JOYINFOEX, dwYpos) },
 647         { JOY_RETURNZ, FIELD_OFFSET(JOYINFOEX, dwZpos) },
 648         { JOY_RETURNU, FIELD_OFFSET(JOYINFOEX, dwUpos) },
 649         { JOY_RETURNV, FIELD_OFFSET(JOYINFOEX, dwVpos) },
 650         { JOY_RETURNR, FIELD_OFFSET(JOYINFOEX, dwRpos) },
 651     };
 652
 653     joystick_t* joystick;
 654     IOHIDDeviceRef device;
 655     CFIndex i, count;
 656     IOHIDValueRef valueRef;
 657     long value;
 658
 659     if ((joystick = joystick_from_id(device_id)) == NULL)
 660         return MMSYSERR_NODRIVER;
 661
 662     if (!open_joystick(joystick))
 663         return JOYERR_PARMS;
 664
 665     device = IOHIDElementGetDevice(joystick->element);
 666
 667     if (info->dwFlags & JOY_RETURNBUTTONS)
 668     {
 669         info->dwButtons = 0;
 670         info->dwButtonNumber = 0;
 671
 672         count = CFArrayGetCount(joystick->buttons);
 673         for (i = 0; i < count; i++)
 674         {
 675             IOHIDElementRef button = (IOHIDElementRef)CFArrayGetValueAtIndex(joystick->buttons, i);
 676             IOHIDDeviceGetValue(device, button, &valueRef);
 677             value = IOHIDValueGetIntegerValue(valueRef);
 678             if (value)
 679             {
 680                 info->dwButtons |= 1 << i;
 681                 info->dwButtonNumber++;
 682             }
 683         }
 684     }
 685
 686     for (i = 0; i < NUM_AXES; i++)
 687     {
 688         if (info->dwFlags & axis_map[i].flag)
 689         {
 690             DWORD* field = (DWORD*)((char*)info + axis_map[i].offset);
 691             if (joystick->axes[i].element)
 692             {
 693                 IOHIDDeviceGetValue(device, joystick->axes[i].element, &valueRef);
 694                 value = IOHIDValueGetIntegerValue(valueRef) - joystick->axes[i].min_value;
 695                 *field = MulDiv(value, 0xFFFF, joystick->axes[i].max_value - joystick->axes[i].min_value);
 696             }
 697             else
 698             {
 699                 *field = 0;
 700                 info->dwFlags &= ~axis_map[i].flag;
 701             }
 702         }
 703     }
 704
 705     if (info->dwFlags & JOY_RETURNPOV)
 706     {
 707         if (joystick->hatswitch)
 708         {
 709             IOHIDDeviceGetValue(device, joystick->hatswitch, &valueRef);
 710             value = IOHIDValueGetIntegerValue(valueRef);
 711             if (value >= 8)
 712                 info->dwPOV = JOY_POVCENTERED;
 713             else
 714                 info->dwPOV = value * 4500;
 715         }
 716         else
 717         {
 718             info->dwPOV = 0;
 719             info->dwFlags &= ~JOY_RETURNPOV;
 720         }
 721     }
 722
 723     TRACE("x: %d, y: %d, z: %d, r: %d, u: %d, v: %d, buttons: 0x%04x, pov %d, flags: 0x%04x\n",
 724           info->dwXpos, info->dwYpos, info->dwZpos, info->dwRpos, info->dwUpos, info->dwVpos, info->dwButtons, info->dwPOV, info->dwFlags);
 725
 726     return JOYERR_NOERROR;
 727 }
 728
 729 /**************************************************************************
 730  *                              driver_joyGetPos
 731  */
 732 LRESULT driver_joyGetPos(DWORD_PTR device_id, JOYINFO* info)
 733 {
 734     JOYINFOEX ji;
 735     LONG ret;
 736
 737     memset(&ji, 0, sizeof(ji));
 738
 739     ji.dwSize = sizeof(ji);
 740     ji.dwFlags = JOY_RETURNX | JOY_RETURNY | JOY_RETURNZ | JOY_RETURNBUTTONS;
 741     ret = driver_joyGetPosEx(device_id, &ji);
 742     if (ret == JOYERR_NOERROR)
 743     {
 744         info->wXpos    = ji.dwXpos;
 745         info->wYpos    = ji.dwYpos;
 746         info->wZpos    = ji.dwZpos;
 747         info->wButtons = ji.dwButtons;
 748     }
 749
 750     return ret;
 751 }
 752
 753 #endif /* HAVE_IOKIT_HID_IOHIDLIB_H */