lang/LangPrimSource/HID_Utilities_10_4/HID_Queue_Utilities.c

   1 /*
   2         File:           HID_Queue_Utilities.c
   3
   4         Contains:       Implementation of the HID queue functions for the HID utilites.
   5
   6         DRI: George Warner
   7
   8         Copyright:      Copyright © 2002 Apple Computer, Inc., All Rights Reserved
   9
  10         Disclaimer:     IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc.
  11                                 ("Apple") in consideration of your agreement to the following terms, and your
  12                                 use, installation, modification or redistribution of this Apple software
  13                                 constitutes acceptance of these terms.  If you do not agree with these terms,
  14                                 please do not use, install, modify or redistribute this Apple software.
  15
  16                                 In consideration of your agreement to abide by the following terms, and subject
  17                                 to these terms, Apple grants you a personal, non-exclusive license, under AppleÕs
  18                                 copyrights in this original Apple software (the "Apple Software"), to use,
  19                                 reproduce, modify and redistribute the Apple Software, with or without
  20                                 modifications, in source and/or binary forms; provided that if you redistribute
  21                                 the Apple Software in its entirety and without modifications, you must retain
  22                                 this notice and the following text and disclaimers in all such redistributions of
  23                                 the Apple Software.  Neither the name, trademarks, service marks or logos of
  24                                 Apple Computer, Inc. may be used to endorse or promote products derived from the
  25                                 Apple Software without specific prior written permission from Apple.  Except as
  26                                 expressly stated in this notice, no other rights or licenses, express or implied,
  27                                 are granted by Apple herein, including but not limited to any patent rights that
  28                                 may be infringed by your derivative works or by other works in which the Apple
  29                                 Software may be incorporated.
  30
  31                                 The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO
  32                                 WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
  33                                 WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  34                                 PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
  35                                 COMBINATION WITH YOUR PRODUCTS.
  36
  37                                 IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
  38                                 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  39                                 GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  40                                 ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION
  41                                 OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT
  42                                 (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN
  43                                 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  44 */
  45
  46 //#include <IOKit/hid/IOHIDDevice.h>
  47 #ifdef SC_DARWIN
  48 #include "HID_Utilities_Internal.h"
  49 #include "HID_Utilities_External.h"
  50
  51 // ==================================
  52 // compiler directives
  53 // ==================================
  54 #define USE_ASYNC_EVENTS TRUE
  55 #define REPORT_ERRORS FALSE
  56 // ==================================
  57 #if REPORT_ERRORS
  58 #define HIDREPORTERRORNUM(s,n) HIDReportErrorNum(s,n)
  59 #define HIDREPORTERROR(s)               HIDReportError(s)
  60 #else
  61 #define HIDREPORTERRORNUM(s,n)  do {} while (false)
  62 #define HIDREPORTERROR(s)               do {} while (false)
  63 #endif
  64 // ==================================
  65 // private functions
  66 // ==================================
  67
  68 // creates a queue for a device
  69
  70 static IOReturn hid_CreateQueue (pRecDevice pDevice)
  71 {
  72     IOReturn result = kIOReturnError;   // assume failure (pessimist!)
  73
  74         if (HIDIsValidDevice(pDevice))
  75         {
  76                 if (NULL == pDevice->queue) // do we already have a queue
  77                 {
  78                         if (NULL != pDevice->interface)
  79                         {
  80                                 pDevice->queue = (void *) (*(IOHIDDeviceInterface**) pDevice->interface)->allocQueue (pDevice->interface); // alloc queue
  81                                 if (pDevice->queue)
  82                                 {
  83                                         result = (*(IOHIDQueueInterface**) pDevice->queue)->create (pDevice->queue, 0, kDeviceQueueSize); // create actual queue
  84                                         if (kIOReturnSuccess != result)
  85                                                 HIDREPORTERRORNUM ("hid_CreateQueue - Failed to create queue via create", result);
  86                                 }
  87                                 else
  88                                 {
  89                                         HIDREPORTERROR ("hid_CreateQueue - Failed to alloc IOHIDQueueInterface ** via allocQueue");
  90                                         result = kIOReturnError; // synthesis error
  91                                 }
  92                         }
  93                         else
  94                                 HIDREPORTERRORNUM ("hid_CreateQueue - Device inteface does not exist for queue creation", result);
  95                 }
  96         }
  97         else
  98                 HIDREPORTERRORNUM ("hid_CreateQueue - Invalid Device", result);
  99     return result;
 100 }
 101
 102 // ---------------------------------
 103 // returns true if queue is empty false otherwise
 104 // error if no device, empty if no queue
 105
 106 static unsigned char hid_IsDeviceQueueEmpty (pRecDevice pDevice)
 107 {
 108         if (HIDIsValidDevice(pDevice))  // need valid device
 109         {
 110                 if (pDevice->queue) // and queue
 111                 {
 112                         pRecElement pElement = HIDGetFirstDeviceElement (pDevice, kHIDElementTypeIO);
 113                         while (pElement)
 114                         {
 115                                 if ((*(IOHIDQueueInterface**) pDevice->queue)->hasElement (pDevice->queue, pElement->cookie))
 116                                         return false;
 117                                 pElement = HIDGetNextDeviceElement (pElement, kHIDElementTypeIO);
 118                         }
 119                 }
 120                 else
 121                         HIDREPORTERROR ("hid_IsDeviceQueueEmpty - no queue.");
 122         }
 123         else
 124                 HIDREPORTERROR ("hid_IsDeviceQueueEmpty - Invalid device.");
 125         return true;
 126 }
 127
 128 // ---------------------------------
 129 // disposes and releases queue, sets queue to NULL,.
 130 // Note: will have no effect if device or queue do not exist
 131
 132 static IOReturn hid_DisposeReleaseQueue (pRecDevice pDevice)
 133 {
 134     IOReturn result = kIOReturnError;   // assume failure (pessimist!)
 135
 136         if (HIDIsValidDevice(pDevice))  // need valid device
 137         {
 138                 if (pDevice->queue) // and queue
 139                 {
 140                         // stop queue
 141                         result = (*(IOHIDQueueInterface**) pDevice->queue)->stop (pDevice->queue);
 142                         if (kIOReturnSuccess != result)
 143                                 HIDREPORTERRORNUM ("hid_DisposeReleaseQueue - Failed to stop queue.", result);
 144                         // dispose of queue
 145                         result = (*(IOHIDQueueInterface**) pDevice->queue)->dispose (pDevice->queue);
 146                         if (kIOReturnSuccess != result)
 147                                 HIDREPORTERRORNUM ("hid_DisposeReleaseQueue - Failed to dipose queue.", result);
 148                         // release the queue
 149                         result = (*(IOHIDQueueInterface**) pDevice->queue)->Release (pDevice->queue);
 150                         if (kIOReturnSuccess != result)
 151                                 HIDREPORTERRORNUM ("hid_DisposeReleaseQueue - Failed to release queue.", result);
 152
 153                         pDevice->queue = NULL;
 154                 }
 155                 else
 156                         HIDREPORTERROR ("hid_DisposeReleaseQueue - no queue.");
 157         }
 158         else
 159                 HIDREPORTERROR ("hid_DisposeReleaseQueue - Invalid device.");
 160     return result;
 161 }
 162
 163 // ==================================
 164 // public functions
 165
 166 // ---------------------------------
 167 // queues specific element, performing any device queue set up required
 168 // queue is started and ready to return events on exit from this function
 169
 170 unsigned long  HIDQueueElement (pRecDevice pDevice, pRecElement pElement)
 171 {
 172     IOReturn result = kIOReturnError;   // assume failure (pessimist!)
 173
 174         if (HIDIsValidElement(pDevice,pElement))
 175         {
 176                 if (NULL == pDevice->interface) // must have interface
 177                 {
 178                         HIDREPORTERROR ("HIDQueueElement - Device does not have interface.");
 179                         return kIOReturnError;
 180                 }
 181                 if (NULL == pDevice->queue) // if no queue create queue
 182                         result = hid_CreateQueue (pDevice);
 183                 if ((kIOReturnSuccess != result) || (NULL == pDevice->queue))
 184                 {
 185                         HIDREPORTERRORNUM ("HIDQueueElement - problem creating queue.", result);
 186                         if (kIOReturnSuccess != result)
 187                                 return result;
 188                         else
 189                                 return kIOReturnError;
 190                 }
 191
 192                 // stop queue
 193                 result = (*(IOHIDQueueInterface**) pDevice->queue)->stop (pDevice->queue);
 194                 if (kIOReturnSuccess != result)
 195                         HIDREPORTERROR ("HIDQueueElement - Failed to stop queue.");
 196
 197                 // queue element
 198                 if (!(*(IOHIDQueueInterface**) pDevice->queue)->hasElement (pDevice->queue, pElement->cookie))
 199                 {
 200                         result = (*(IOHIDQueueInterface**) pDevice->queue)->addElement (pDevice->queue, pElement->cookie, 0);
 201                         if (kIOReturnSuccess != result)
 202                                 HIDREPORTERROR ("HIDQueueElement - Failed to add Element to queue.");
 203                 }
 204
 205                 // restart queue
 206                 result = (*(IOHIDQueueInterface**) pDevice->queue)->start (pDevice->queue);
 207                 if (kIOReturnSuccess != result)
 208                         HIDREPORTERROR ("HIDQueueElement - Failed to start queue.");
 209         }
 210         else
 211         {
 212                 HIDREPORTERROR ("HIDQueueElement - Invalid Device and/or element.");
 213         return kIOReturnBadArgument;
 214         }
 215
 216    return result;
 217 }
 218
 219 // ---------------------------------
 220 // adds all elements to queue, performing any device queue set up required
 221 // queue is started and ready to return events on exit from this function
 222
 223 unsigned long  HIDQueueDevice (pRecDevice pDevice)
 224 {
 225     IOReturn result = kIOReturnError;   // assume failure (pessimist!)
 226     pRecElement pElement;
 227
 228         if (HIDIsValidDevice(pDevice))
 229         {
 230                 // error checking
 231                 if (NULL == pDevice)
 232                 {
 233                         HIDREPORTERROR ("HIDQueueDevice - Device does not exist.");
 234                         return kIOReturnBadArgument;
 235                 }
 236                 if (NULL == pDevice->interface) // must have interface
 237                 {
 238                         HIDREPORTERROR ("HIDQueueDevice - Device does not have interface.");
 239                         return kIOReturnError;
 240                 }
 241                 if (NULL == pDevice->queue) // if no queue create queue
 242                         result = hid_CreateQueue (pDevice);
 243                 if ((kIOReturnSuccess != result) || (NULL == pDevice->queue))
 244                 {
 245                         HIDREPORTERRORNUM ("HIDQueueDevice - problem creating queue.", result);
 246                         if (kIOReturnSuccess != result)
 247                                 return result;
 248                         else
 249                                 return kIOReturnError;
 250                 }
 251
 252                 // stop queue
 253                 result = (*(IOHIDQueueInterface**) pDevice->queue)->stop (pDevice->queue);
 254                 if (kIOReturnSuccess != result)
 255                         HIDREPORTERRORNUM ("HIDQueueDevice - Failed to stop queue.", result);
 256
 257                 // queue element
 258   //¥ pElement = HIDGetFirstDeviceElement (pDevice, kHIDElementTypeIO);
 259                 pElement = HIDGetFirstDeviceElement (pDevice, kHIDElementTypeInput | kHIDElementTypeFeature);
 260
 261                 while (pElement)
 262                 {
 263                         if (!(*(IOHIDQueueInterface**) pDevice->queue)->hasElement (pDevice->queue, pElement->cookie))
 264                         {
 265                                 result = (*(IOHIDQueueInterface**) pDevice->queue)->addElement (pDevice->queue, pElement->cookie, 0);
 266                                 if (kIOReturnSuccess != result)
 267                                         HIDREPORTERRORNUM ("HIDQueueDevice - Failed to add element to queue.", result);
 268                         }
 269                         //¥ pElement = HIDGetNextDeviceElement (pElement, kHIDElementTypeIO);
 270                         pElement = HIDGetNextDeviceElement (pElement, kHIDElementTypeInput | kHIDElementTypeFeature);
 271                 }
 272
 273                 // start queue
 274                 result = (*(IOHIDQueueInterface**) pDevice->queue)->start (pDevice->queue);
 275                 if (kIOReturnSuccess != result)
 276                         HIDREPORTERRORNUM ("HIDQueueDevice - Failed to start queue.", result);
 277
 278         }
 279         else
 280                 HIDREPORTERROR ("HIDQueueDevice - Invalid device.");
 281
 282     return result;
 283 }
 284
 285 // ---------------------------------
 286 // removes element for queue, if last element in queue will release queue and closes device interface
 287
 288 unsigned long  HIDDequeueElement (pRecDevice pDevice, pRecElement pElement)
 289 {
 290     IOReturn result = kIOReturnError;   // assume failure (pessimist!)
 291
 292         if (HIDIsValidElement(pDevice,pElement))
 293         {
 294                 if (!pDevice || !pElement)
 295                         result = kIOReturnBadArgument;
 296                 else
 297                 {
 298                         if ((pDevice->interface) && (pDevice->queue))
 299                         {
 300                                 // stop queue
 301                                 result = (*(IOHIDQueueInterface**) pDevice->queue)->stop (pDevice->queue);
 302                                 if (kIOReturnSuccess != result)
 303                                         HIDREPORTERRORNUM ("HIDDequeueElement - Failed to stop queue.", result);
 304
 305                                 if ((*(IOHIDQueueInterface**) pDevice->queue)->hasElement (pDevice->queue, pElement->cookie)) // if has element then remove
 306                                 {
 307                                         result = (*(IOHIDQueueInterface**) pDevice->queue)->removeElement (pDevice->queue, pElement->cookie);
 308                                         if (kIOReturnSuccess != result)
 309                                                 HIDREPORTERRORNUM ("HIDDequeueElement - Failed to add element to queue", result);
 310                                 }
 311
 312                                 if (hid_IsDeviceQueueEmpty (pDevice)) // release device queue and close interface if queue empty
 313                                 {
 314                                         result = hid_DisposeReleaseQueue (pDevice);
 315                                         if (kIOReturnSuccess != result)
 316                                                 HIDREPORTERRORNUM ("HIDDequeueElement - Failed to dispose and release queue.", result);
 317                                 }
 318                                 else // not empty so restart queue
 319                                 {
 320                                         result = (*(IOHIDQueueInterface**) pDevice->queue)->start (pDevice->queue);
 321                                         if (kIOReturnSuccess != result)
 322                                                 HIDREPORTERRORNUM ("HIDDequeueElement - Failed to start queue.", result);
 323                                 }
 324                         }
 325                         else
 326                         {
 327                                 HIDREPORTERROR ("HIDDequeueElement - No device inteface or queue.");
 328                                 return kIOReturnError;
 329                         }
 330                 }
 331         }
 332         else
 333                 HIDREPORTERROR ("HIDDequeueElement - Invalid device.");
 334
 335     return result;
 336 }
 337
 338 // ---------------------------------
 339 // completely removes all elements from queue and releases queue and closes device interface
 340 // does not release device interfaces, application must call HIDReleaseDeviceList on exit
 341
 342 unsigned long  HIDDequeueDevice (pRecDevice pDevice)
 343 {
 344     IOReturn result = kIOReturnSuccess;
 345
 346     if (HIDIsValidDevice(pDevice))
 347         {
 348                 if ((pDevice->interface) && (pDevice->queue))
 349                 {
 350                         // iterate through elements and if queued, remove
 351                         pRecElement pElement = HIDGetFirstDeviceElement (pDevice, kHIDElementTypeIO);
 352                         while (pElement)
 353                         {
 354                                 if ((*(IOHIDQueueInterface**) pDevice->queue)->hasElement (pDevice->queue, pElement->cookie))
 355                                 {
 356                                         result = (*(IOHIDQueueInterface**) pDevice->queue)->removeElement (pDevice->queue, pElement->cookie);
 357                                         if (kIOReturnSuccess != result)
 358                                                 HIDREPORTERRORNUM ("HIDDequeueDevice - Failed to remove element from queue.", result);
 359                                 }
 360                                 pElement = HIDGetNextDeviceElement (pElement, kHIDElementTypeIO);
 361                         }
 362                 }
 363                 // ensure queue is disposed and released
 364                 // interface will be closed and released on call to HIDReleaseDeviceList
 365                 result = hid_DisposeReleaseQueue (pDevice);
 366                 if (kIOReturnSuccess != result)
 367                         HIDREPORTERRORNUM ("removeElement - Failed to dispose and release queue.", result);
 368 #if USE_ASYNC_EVENTS
 369                 else if (NULL != pDevice->queueRunLoopSource)
 370                 {
 371                         if (CFRunLoopContainsSource(CFRunLoopGetCurrent(), pDevice->queueRunLoopSource, kCFRunLoopDefaultMode))
 372                                 CFRunLoopRemoveSource(CFRunLoopGetCurrent(), pDevice->queueRunLoopSource, kCFRunLoopDefaultMode);
 373                         CFRelease(pDevice->queueRunLoopSource);
 374                         pDevice->queueRunLoopSource = NULL;
 375                 }
 376 #endif USE_ASYNC_EVENTS
 377         }
 378         else
 379         {
 380                 HIDREPORTERROR ("HIDDequeueDevice - Invalid device.");
 381                 result = kIOReturnBadArgument;
 382         }
 383     return result;
 384 }
 385
 386 // ---------------------------------
 387 // releases all device queues for quit or rebuild (must be called)
 388 // does not release device interfaces, application must call HIDReleaseDeviceList on exit
 389
 390 unsigned long HIDReleaseAllDeviceQueues (void)
 391 {
 392     IOReturn result = kIOReturnBadArgument;
 393     pRecDevice pDevice = HIDGetFirstDevice ();
 394
 395     while (pDevice)
 396     {
 397         result = HIDDequeueDevice (pDevice);
 398         if (kIOReturnSuccess != result)
 399             HIDREPORTERRORNUM ("HIDReleaseAllDeviceQueues - Could not dequeue device.", result);
 400         pDevice = HIDGetNextDevice (pDevice);
 401     }
 402     return result;
 403 }
 404
 405 // ---------------------------------
 406 // Closes and releases interface to device, should be done prior to exting application
 407 // Note: will have no affect if device or interface do not exist
 408 // application will "own" the device if interface is not closed
 409 // (device may have to be plug and re-plugged in different location to get it working again without a restart)
 410
 411 unsigned long HIDCloseReleaseInterface (pRecDevice pDevice)
 412 {
 413         IOReturn result = kIOReturnSuccess;
 414
 415         if (HIDIsValidDevice(pDevice) && (NULL != pDevice->interface))
 416         {
 417                 // close the interface
 418                 result = (*(IOHIDDeviceInterface**) pDevice->interface)->close (pDevice->interface);
 419                 if (kIOReturnNotOpen == result)
 420                 {
 421                         //  do nothing as device was not opened, thus can't be closed
 422                 }
 423                 else if (kIOReturnSuccess != result)
 424                         HIDREPORTERRORNUM ("HIDCloseReleaseInterface - Failed to close IOHIDDeviceInterface.", result);
 425                 //release the interface
 426                 result = (*(IOHIDDeviceInterface**) pDevice->interface)->Release (pDevice->interface);
 427                 if (kIOReturnSuccess != result)
 428                         HIDREPORTERRORNUM ("HIDCloseReleaseInterface - Failed to release interface.", result);
 429                 pDevice->interface = NULL;
 430         }
 431         return result;
 432 }
 433
 434 // ---------------------------------
 435 // Get the next event in the queue for a device
 436 // elements or entire device should be queued prior to calling this with HIDQueueElement or HIDQueueDevice
 437 // returns true if an event is avialable for the element and fills out *pHIDEvent structure, returns false otherwise
 438 // Note: kIOReturnUnderrun returned from getNextEvent indicates an empty queue not an error condition
 439 // Note: application should pass in a pointer to a IOHIDEventStruct cast to a void (for CFM compatibility)
 440
 441 unsigned char HIDGetEvent (pRecDevice pDevice, void * pHIDEvent)
 442 {
 443     IOReturn result = kIOReturnBadArgument;
 444     AbsoluteTime zeroTime = {0,0};
 445
 446     if (HIDIsValidDevice(pDevice))
 447         {
 448                 if (pDevice->queue)
 449                 {
 450                         result = (*(IOHIDQueueInterface**) pDevice->queue)->getNextEvent (pDevice->queue, (IOHIDEventStruct *)pHIDEvent, zeroTime, 0);
 451                         if (kIOReturnUnderrun == result)
 452                                 return false;  // no events in queue not an error per say
 453                         else if (kIOReturnSuccess != result) // actual error versus just an empty queue
 454                                 HIDREPORTERRORNUM ("HIDGetEvent - Could not get HID event via getNextEvent.", result);
 455                         else
 456                                 return true;
 457                 }
 458                 else
 459                         HIDREPORTERROR ("HIDGetEvent - queue does not exist.");
 460         }
 461         else
 462                 HIDREPORTERROR ("HIDGetEvent - invalid device.");
 463
 464     return false; // did not get event
 465 }
 466
 467 // ---------------------------------
 468 // returns current value for element, polling element
 469 // will return 0 on error conditions which should be accounted for by application
 470
 471 long HIDGetElementValue (pRecDevice pDevice, pRecElement pElement)
 472 {
 473     IOReturn result = kIOReturnBadArgument;
 474     IOHIDEventStruct hidEvent;
 475
 476         hidEvent.value = 0;
 477     hidEvent.longValueSize = 0;
 478         hidEvent.longValue = nil;
 479
 480         if (HIDIsValidElement(pDevice, pElement))
 481         {
 482                 if (NULL != pDevice->interface)
 483                 {
 484                         // ++ NOTE: If the element type is feature then use queryElementValue instead of getElementValue
 485                         if (kIOHIDElementTypeFeature == pElement->type)
 486                         {
 487                                 result = (*(IOHIDDeviceInterface**) pDevice->interface)->queryElementValue (pDevice->interface, pElement->cookie, &hidEvent,0,NULL,NULL,NULL);
 488                                 if (kIOReturnUnsupported == result)     // unless it's unsuported.
 489                                         goto try_getElementValue;
 490                                 else if (kIOReturnSuccess != result)
 491                                         HIDREPORTERRORNUM ("HIDGetElementValue - Could not get HID element value via queryElementValue.", result);
 492                         }
 493                         else if (pElement->type <= kIOHIDElementTypeInput_ScanCodes)
 494                         {
 495 try_getElementValue:
 496                                 result = (*(IOHIDDeviceInterface**) pDevice->interface)->getElementValue (pDevice->interface, pElement->cookie, &hidEvent);
 497                                 if (kIOReturnSuccess != result)
 498                                         HIDREPORTERRORNUM ("HIDGetElementValue - Could not get HID element value via getElementValue.", result);
 499                         }
 500                         // on 10.0.x this returns the incorrect result for negative ranges, so fix it!!!
 501    // this is not required on Mac OS X 10.1+
 502                         if ((pElement->min < 0) && (hidEvent.value > pElement->max)) // assume range problem
 503                                 hidEvent.value = hidEvent.value + pElement->min - pElement->max - 1;
 504                 }
 505                 else
 506                         HIDREPORTERROR ("HIDGetElementValue - no interface for device.");
 507         }
 508         else
 509                 HIDREPORTERROR ("HIDGetElementValue - invalid device and/or element.");
 510
 511     // record min and max for auto scale and auto ...
 512     if (hidEvent.value < pElement->calMin)
 513         pElement->calMin = hidEvent.value;
 514     if (hidEvent.value > pElement->calMax)
 515         pElement->calMax = hidEvent.value;
 516
 517     // auto user scale
 518     return hidEvent.value;
 519 }
 520
 521 // ---------------------------------
 522 // Set an elements value
 523 // NOTE: This should only be used when a single element of a report needs to be sent.
 524 // If multiple elements are to be send then transactions should be used.
 525
 526 long HIDSetElementValue (pRecDevice pDevice, pRecElement pElement,void* pIOHIDEvent)
 527 {
 528         IOHIDEventStruct* pMyIOHIDEvent = (IOHIDEventStruct*) pIOHIDEvent;
 529     IOReturn result = kIOReturnError;   // assume failure (pessimist!)
 530
 531         if (HIDIsValidElement(pDevice, pElement))
 532         {
 533                 if (NULL != pDevice->interface)
 534                 {
 535                         result = (*(IOHIDDeviceInterface**) pDevice->interface)->setElementValue (pDevice->interface, pElement->cookie, pMyIOHIDEvent, -1, nil, nil, nil);
 536                         if (kIOReturnSuccess != result)
 537                                 HIDREPORTERRORNUM ("HIDSetElementValue - Could not set HID element value via setElementValue.", result);
 538                 }
 539                 else
 540                         HIDREPORTERROR ("HIDSetElementValue - no interface for device.");
 541         }
 542         else
 543                 HIDREPORTERROR ("HIDSetElementValue - invalid device and/or element.");
 544
 545     return result;
 546 }
 547
 548 // ---------------------------------
 549 // Set a callback to be called when a queue goes from empty to non-empty
 550 long HIDSetQueueCallback (pRecDevice pDevice, IOHIDCallbackFunction callback)
 551 {
 552     IOReturn result = kIOReturnError;   // assume failure (pessimist!)
 553
 554         if (HIDIsValidDevice(pDevice))
 555         {
 556 #if USE_ASYNC_EVENTS
 557                 // if we don't have a queue runloop sourceÉ
 558                 if (NULL == pDevice->queueRunLoopSource)
 559                 {
 560                         // then create one
 561                         result = (*(IOHIDQueueInterface**) pDevice->queue)->createAsyncEventSource((void *) pDevice->queue,
 562                                 (CFRunLoopSourceRef*) &pDevice->queueRunLoopSource);
 563                         if (kIOReturnSuccess != result)
 564                                 HIDREPORTERRORNUM ("HIDSetQueueCallback - Failed to createAsyncEventSource error: ", result);
 565                 }
 566                 // if we have one nowÉ
 567                 if (NULL != pDevice->queueRunLoopSource)
 568                 {
 569                         // and it's not already attached to our runloopÉ
 570                         if (!CFRunLoopContainsSource(CFRunLoopGetCurrent(), pDevice->queueRunLoopSource, kCFRunLoopDefaultMode))
 571                                 // then attach it now.
 572                                 CFRunLoopAddSource(CFRunLoopGetCurrent(), pDevice->queueRunLoopSource, kCFRunLoopDefaultMode);
 573                 }
 574
 575                 // now install our callback
 576                 result = (*(IOHIDQueueInterface**) pDevice->queue)->setEventCallout(pDevice->queue, callback, pDevice, pDevice);
 577                 if (kIOReturnSuccess != result)
 578                         HIDREPORTERRORNUM ("HIDSetQueueCallback - Could not set HID queue callback via setEventCallout.", result);
 579 #endif USE_ASYNC_EVENTS
 580         }
 581         else
 582                 HIDREPORTERROR ("HIDSetQueueCallback - invalid device and/or element.");
 583     return result;
 584 }
 585
 586 #if 1
 587 // ---------------------------------
 588 // Get a report from a device
 589 long HIDGetReport (pRecDevice pDevice,const IOHIDReportType reportType, const UInt32 reportID, void* reportBuffer, UInt32* reportBufferSize)
 590 {
 591     IOReturn result = kIOReturnError;   // assume failure (pessimist!)
 592
 593     if (HIDIsValidDevice(pDevice))
 594     {
 595                 if (NULL != pDevice->interface)
 596                 {
 597                         result = (*(IOHIDDeviceInterface**) pDevice->interface)->getReport (pDevice->interface, reportType, reportID, reportBuffer, reportBufferSize, -1, nil, nil, nil);
 598                         if (kIOReturnSuccess != result)
 599                                 HIDREPORTERRORNUM ("HIDGetReport - Could not getReport, error: ", result);
 600                 }
 601                 else
 602                         HIDREPORTERROR ("HIDGetReport - no interface for device.");
 603     }
 604     else
 605         HIDREPORTERROR ("HIDGetReport - invalid device.");
 606
 607     return result;
 608 }
 609
 610 // ---------------------------------
 611 // Send a report to a device
 612 long HIDSetReport (pRecDevice pDevice,const IOHIDReportType reportType, const UInt32 reportID, void* reportBuffer, const UInt32 reportBufferSize)
 613 {
 614     IOReturn result = kIOReturnError;   // assume failure (pessimist!)
 615
 616     if (HIDIsValidDevice(pDevice))
 617     {
 618                 if (NULL != pDevice->interface)
 619                 {
 620                         result = (*(IOHIDDeviceInterface**) pDevice->interface)->setReport (pDevice->interface, reportType, reportID, reportBuffer, reportBufferSize, -1, nil, nil, nil);
 621                         if (kIOReturnSuccess != result)
 622                                 HIDREPORTERRORNUM ("HIDGetReport - Could not setReport; error: ", result);
 623                 }
 624                 else
 625                         HIDREPORTERROR ("HIDGetReport - no interface for device.");
 626     }
 627     else
 628         HIDREPORTERROR ("HIDGetReport - invalid device.");
 629
 630     return result;
 631 }
 632 #endif
 633 #endif //SC_DARWIN