hid.c File Reference

#include <IOKit/hid/IOHIDManager.h>
#include <IOKit/hid/IOHIDKeys.h>
#include <IOKit/IOKitLib.h>
#include <IOKit/usb/USBSpec.h>
#include <CoreFoundation/CoreFoundation.h>
#include <wchar.h>
#include <locale.h>
#include <pthread.h>
#include <sys/time.h>
#include <unistd.h>
#include <dlfcn.h>
#include "hidapi.h"

Include dependency graph for hid.c:

Go to the source code of this file.

Classes
struct	pthread_barrier
struct	input_report
struct	hid_device_

Macros
#define	BUF_LEN   256

Typedefs
typedef int	pthread_barrierattr_t
typedef struct pthread_barrier	pthread_barrier_t

Functions
static int	pthread_barrier_init (pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count)
static int	pthread_barrier_destroy (pthread_barrier_t *barrier)
static int	pthread_barrier_wait (pthread_barrier_t *barrier)
static int	return_data (hid_device *dev, unsigned char *data, size_t length)
static hid_device *	new_hid_device (void)
static void	free_hid_device (hid_device *dev)
static int32_t	get_int_property (IOHIDDeviceRef device, CFStringRef key)
static unsigned short	get_vendor_id (IOHIDDeviceRef device)
static unsigned short	get_product_id (IOHIDDeviceRef device)
static int32_t	get_max_report_length (IOHIDDeviceRef device)
static int	get_string_property (IOHIDDeviceRef device, CFStringRef prop, wchar_t *buf, size_t len)
static int	get_serial_number (IOHIDDeviceRef device, wchar_t *buf, size_t len)
static int	get_manufacturer_string (IOHIDDeviceRef device, wchar_t *buf, size_t len)
static int	get_product_string (IOHIDDeviceRef device, wchar_t *buf, size_t len)
static wchar_t *	dup_wcs (const wchar_t *s)
static io_service_t	hidapi_IOHIDDeviceGetService (IOHIDDeviceRef device)
static int	init_hid_manager (void)
int HID_API_EXPORT	hid_init (void)
	Initialize the HIDAPI library.
int HID_API_EXPORT	hid_exit (void)
	Finalize the HIDAPI library.
static void	process_pending_events (void)
struct hid_device_info HID_API_EXPORT *	hid_enumerate (unsigned short vendor_id, unsigned short product_id)
	Enumerate the HID Devices.
void HID_API_EXPORT	hid_free_enumeration (struct hid_device_info *devs)
	Free an enumeration Linked List.
hid_device *HID_API_EXPORT	hid_open (unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
	Open a HID device using a Vendor ID (VID), Product ID (PID) and optionally a serial number.
static void	hid_device_removal_callback (void *context, IOReturn result, void *sender)
static void	hid_report_callback (void *context, IOReturn result, void *sender, IOHIDReportType report_type, uint32_t report_id, uint8_t *report, CFIndex report_length)
static void	perform_signal_callback (void *context)
static void *	read_thread (void *param)
hid_device *HID_API_EXPORT	hid_open_path (const char *path)
	Open a HID device by its path name.
static int	set_report (hid_device *dev, IOHIDReportType type, const unsigned char *data, size_t length)
int HID_API_EXPORT	hid_write (hid_device *dev, const unsigned char *data, size_t length)
	Write an Output report to a HID device.
static int	cond_wait (const hid_device *dev, pthread_cond_t *cond, pthread_mutex_t *mutex)
static int	cond_timedwait (const hid_device *dev, pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
int HID_API_EXPORT	hid_read_timeout (hid_device *dev, unsigned char *data, size_t length, int milliseconds)
	Read an Input report from a HID device with timeout.
int HID_API_EXPORT	hid_read (hid_device *dev, unsigned char *data, size_t length)
	Read an Input report from a HID device.
int HID_API_EXPORT	hid_set_nonblocking (hid_device *dev, int nonblock)
	Set the device handle to be non-blocking.
int HID_API_EXPORT	hid_send_feature_report (hid_device *dev, const unsigned char *data, size_t length)
	Send a Feature report to the device.
int HID_API_EXPORT	hid_get_feature_report (hid_device *dev, unsigned char *data, size_t length)
	Get a feature report from a HID device.
void HID_API_EXPORT	hid_close (hid_device *dev)
	Close a HID device.
int HID_API_EXPORT_CALL	hid_get_manufacturer_string (hid_device *dev, wchar_t *string, size_t maxlen)
	Get The Manufacturer String from a HID device.
int HID_API_EXPORT_CALL	hid_get_product_string (hid_device *dev, wchar_t *string, size_t maxlen)
	Get The Product String from a HID device.
int HID_API_EXPORT_CALL	hid_get_serial_number_string (hid_device *dev, wchar_t *string, size_t maxlen)
	Get The Serial Number String from a HID device.
int HID_API_EXPORT_CALL	hid_get_indexed_string (hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
	Get a string from a HID device, based on its string index.
HID_API_EXPORT const wchar_t *HID_API_CALL	hid_error (hid_device *dev)
	Get a string describing the last error which occurred.

Variables
static IOHIDManagerRef	hid_mgr = 0x0

---

Class Documentation

pthread_barrier

struct pthread_barrier

Class Members
pthread_cond_t	cond
int	count
pthread_mutex_t	mutex
int	trip_count

input_report

struct input_report

Collaboration diagram for input_report:

Class Members
uint8_t *	data
size_t	len
struct input_report *	next

hid_device_

struct hid_device_

Collaboration diagram for hid_device_:

Class Members
pthread_barrier_t	barrier
int	blocking
BOOL	blocking
pthread_cond_t	condition
int	device_handle
IOHIDDeviceRef	device_handle
HANDLE	device_handle
int	disconnected
uint8_t *	input_report_buf
size_t	input_report_length
struct input_report *	input_reports
DWORD	last_error_num
void *	last_error_str
CFIndex	max_input_report_len
pthread_mutex_t	mutex
OVERLAPPED	ol
USHORT	output_report_length
char *	read_buf
BOOL	read_pending
CFRunLoopRef	run_loop
CFStringRef	run_loop_mode
pthread_barrier_t	shutdown_barrier
int	shutdown_thread
CFRunLoopSourceRef	source
pthread_t	thread
int	uses_numbered_reports

Macro Definition Documentation

BUF_LEN

#define BUF_LEN   256

Typedef Documentation

pthread_barrier_t

typedef struct pthread_barrier pthread_barrier_t

pthread_barrierattr_t

typedef int pthread_barrierattr_t

Function Documentation

cond_timedwait()

static int cond_timedwait ( const hid_device *  dev, pthread_cond_t *  cond, pthread_mutex_t *  mutex, const struct timespec *  abstime  )

static

{
  while (!dev->input_reports) {
    int res = pthread_cond_timedwait(cond, mutex, abstime);
    if (res != 0)
      return res;
 
    /* A res of 0 means we may have been signaled or it may
       be a spurious wakeup. Check to see that there's acutally
       data in the queue before returning, and if not, go back
       to sleep. See the pthread_cond_timedwait() man page for
       details. */
 
    if (dev->shutdown_thread || dev->disconnected)
      return -1;
  }
 
  return 0;
 
}

References hid_device_::disconnected, hid_device_::input_reports, and hid_device_::shutdown_thread.

Referenced by hid_read_timeout().

Here is the caller graph for this function:

cond_wait()

static int cond_wait ( const hid_device *  dev, pthread_cond_t *  cond, pthread_mutex_t *  mutex  )

static

{
  while (!dev->input_reports) {
    int res = pthread_cond_wait(cond, mutex);
    if (res != 0)
      return res;
 
    /* A res of 0 means we may have been signaled or it may
       be a spurious wakeup. Check to see that there's acutally
       data in the queue before returning, and if not, go back
       to sleep. See the pthread_cond_timedwait() man page for
       details. */
 
    if (dev->shutdown_thread || dev->disconnected)
      return -1;
  }
 
  return 0;
}

References hid_device_::disconnected, hid_device_::input_reports, and hid_device_::shutdown_thread.

Referenced by hid_read_timeout().

Here is the caller graph for this function:

dup_wcs()

static wchar_t * dup_wcs ( const wchar_t *  s )

static

{
  size_t len = wcslen(s);
  wchar_t *ret = malloc((len+1)*sizeof(wchar_t));
  wcscpy(ret, s);
 
  return ret;
}

References input_report::len, and malloc().

Referenced by hid_enumerate().

Here is the call graph for this function:

Here is the caller graph for this function:

free_hid_device()

static void free_hid_device ( hid_device *  dev )

static

{
  if (!dev)
    return;
 
  /* Delete any input reports still left over. */
  struct input_report *rpt = dev->input_reports;
  while (rpt) {
    struct input_report *next = rpt->next;
    free(rpt->data);
    free(rpt);
    rpt = next;
  }
 
  /* Free the string and the report buffer. The check for NULL
     is necessary here as CFRelease() doesn't handle NULL like
     free() and others do. */
  if (dev->run_loop_mode)
    CFRelease(dev->run_loop_mode);
  if (dev->source)
    CFRelease(dev->source);
  free(dev->input_report_buf);
 
  /* Clean up the thread objects */
  pthread_barrier_destroy(&dev->shutdown_barrier);
  pthread_barrier_destroy(&dev->barrier);
  pthread_cond_destroy(&dev->condition);
  pthread_mutex_destroy(&dev->mutex);
 
  /* Free the structure itself. */
  free(dev);
}

References hid_device_::barrier, hid_device_::condition, input_report::data, free(), hid_device_::input_report_buf, hid_device_::input_reports, hid_device_::mutex, input_report::next, pthread_barrier_destroy(), hid_device_::run_loop_mode, hid_device_::shutdown_barrier, and hid_device_::source.

Here is the call graph for this function:

get_int_property()

static int32_t get_int_property ( IOHIDDeviceRef  device, CFStringRef  key  )

static

{
  CFTypeRef ref;
  int32_t value;
 
  ref = IOHIDDeviceGetProperty(device, key);
  if (ref) {
    if (CFGetTypeID(ref) == CFNumberGetTypeID()) {
      CFNumberGetValue((CFNumberRef) ref, kCFNumberSInt32Type, &value);
      return value;
    }
  }
  return 0;
}

Referenced by get_max_report_length(), get_product_id(), get_vendor_id(), and hid_enumerate().

Here is the caller graph for this function:

get_manufacturer_string()

static int get_manufacturer_string ( IOHIDDeviceRef  device, wchar_t *  buf, size_t  len  )

static

{
  return get_string_property(device, CFSTR(kIOHIDManufacturerKey), buf, len);
}

References get_string_property(), and input_report::len.

Referenced by hid_enumerate(), and hid_get_manufacturer_string().

Here is the call graph for this function:

Here is the caller graph for this function:

get_max_report_length()

static int32_t get_max_report_length ( IOHIDDeviceRef  device )

static

{
  return get_int_property(device, CFSTR(kIOHIDMaxInputReportSizeKey));
}

References get_int_property().

Referenced by hid_open_path().

Here is the call graph for this function:

Here is the caller graph for this function:

get_product_id()

static unsigned short get_product_id ( IOHIDDeviceRef  device )

static

{
  return get_int_property(device, CFSTR(kIOHIDProductIDKey));
}

References get_int_property().

Referenced by hid_enumerate().

Here is the call graph for this function:

Here is the caller graph for this function:

get_product_string()

static int get_product_string ( IOHIDDeviceRef  device, wchar_t *  buf, size_t  len  )

static

{
  return get_string_property(device, CFSTR(kIOHIDProductKey), buf, len);
}

References get_string_property(), and input_report::len.

Referenced by hid_enumerate(), and hid_get_product_string().

Here is the call graph for this function:

Here is the caller graph for this function:

get_serial_number()

static int get_serial_number ( IOHIDDeviceRef  device, wchar_t *  buf, size_t  len  )

static

{
  return get_string_property(device, CFSTR(kIOHIDSerialNumberKey), buf, len);
}

References get_string_property(), and input_report::len.

Referenced by hid_enumerate(), and hid_get_serial_number_string().

Here is the call graph for this function:

Here is the caller graph for this function:

get_string_property()

static int get_string_property ( IOHIDDeviceRef  device, CFStringRef  prop, wchar_t *  buf, size_t  len  )

static

{
  CFStringRef str;
 
  if (!len)
    return 0;
 
  str = IOHIDDeviceGetProperty(device, prop);
 
  buf[0] = 0;
 
  if (str) {
    CFIndex str_len = CFStringGetLength(str);
    CFRange range;
    CFIndex used_buf_len;
    CFIndex chars_copied;
 
    len --;
 
    range.location = 0;
    range.length = ((size_t)str_len > len)? len: (size_t)str_len;
    chars_copied = CFStringGetBytes(str,
      range,
      kCFStringEncodingUTF32LE,
      (char)'?',
      FALSE,
      (UInt8*)buf,
      len * sizeof(wchar_t),
      &used_buf_len);
 
    if (chars_copied == len)
      buf[len] = 0; /* len is decremented above */
    else
      buf[chars_copied] = 0;
 
    return 0;
  }
  else
    return -1;
 
}

References FALSE, and input_report::len.

Referenced by get_manufacturer_string(), get_product_string(), and get_serial_number().

Here is the caller graph for this function:

get_vendor_id()

static unsigned short get_vendor_id ( IOHIDDeviceRef  device )

static

{
  return get_int_property(device, CFSTR(kIOHIDVendorIDKey));
}

References get_int_property().

Referenced by hid_enumerate().

Here is the call graph for this function:

Here is the caller graph for this function:

hid_device_removal_callback()

static void hid_device_removal_callback ( void *  context, IOReturn  result, void *  sender  )

static

{
  /* Stop the Run Loop for this device. */
  hid_device *d = context;
 
  d->disconnected = 1;
  CFRunLoopStop(d->run_loop);
}

Referenced by hid_open_path().

Here is the caller graph for this function:

hid_report_callback()

static void hid_report_callback ( void *  context, IOReturn  result, void *  sender, IOHIDReportType  report_type, uint32_t  report_id, uint8_t *  report, CFIndex  report_length  )

static

{
  struct input_report *rpt;
  hid_device *dev = context;
 
  /* Make a new Input Report object */
  rpt = calloc(1, sizeof(struct input_report));
  rpt->data = calloc(1, report_length);
  memcpy(rpt->data, report, report_length);
  rpt->len = report_length;
  rpt->next = NULL;
 
  /* Lock this section */
  pthread_mutex_lock(&dev->mutex);
 
  /* Attach the new report object to the end of the list. */
  if (dev->input_reports == NULL) {
    /* The list is empty. Put it at the root. */
    dev->input_reports = rpt;
  }
  else {
    /* Find the end of the list and attach. */
    struct input_report *cur = dev->input_reports;
    int num_queued = 0;
    while (cur->next != NULL) {
      cur = cur->next;
      num_queued++;
    }
    cur->next = rpt;
 
    /* Pop one off if we've reached 30 in the queue. This
       way we don't grow forever if the user never reads
       anything from the device. */
    if (num_queued > 30) {
      return_data(dev, NULL, 0);
    }
  }
 
  /* Signal a waiting thread that there is data. */
  pthread_cond_signal(&dev->condition);
 
  /* Unlock */
  pthread_mutex_unlock(&dev->mutex);
 
}

References hid_device_::condition, input_report::data, hid_device_::input_reports, input_report::len, hid_device_::mutex, input_report::next, and return_data().

Referenced by hid_open_path().

Here is the call graph for this function:

Here is the caller graph for this function:

hidapi_IOHIDDeviceGetService()

static io_service_t hidapi_IOHIDDeviceGetService ( IOHIDDeviceRef  device )

static

{
  static void *iokit_framework = NULL;
  static io_service_t (*dynamic_IOHIDDeviceGetService)(IOHIDDeviceRef device) = NULL;
 
  /* Use dlopen()/dlsym() to get a pointer to IOHIDDeviceGetService() if it exists.
   * If any of these steps fail, dynamic_IOHIDDeviceGetService will be left NULL
   * and the fallback method will be used.
   */
  if (iokit_framework == NULL) {
    iokit_framework = dlopen("/System/Library/IOKit.framework/IOKit", RTLD_LAZY);
 
    if (iokit_framework != NULL)
      dynamic_IOHIDDeviceGetService = dlsym(iokit_framework, "IOHIDDeviceGetService");
  }
 
  if (dynamic_IOHIDDeviceGetService != NULL) {
    /* Running on OS X 10.6 and above: IOHIDDeviceGetService() exists */
    return dynamic_IOHIDDeviceGetService(device);
  }
  else
  {
    /* Running on OS X 10.5: IOHIDDeviceGetService() doesn't exist.
     *
     * Be naughty and pull the service out of the IOHIDDevice.
     * IOHIDDevice is an opaque struct not exposed to applications, but its
     * layout is stable through all available versions of OS X.
     * Tested and working on OS X 10.5.8 i386, x86_64, and ppc.
     */
    struct IOHIDDevice_internal {
      /* The first field of the IOHIDDevice struct is a
       * CFRuntimeBase (which is a private CF struct).
       *
       * a, b, and c are the 3 fields that make up a CFRuntimeBase.
       * See http://opensource.apple.com/source/CF/CF-476.18/CFRuntime.h
       *
       * The second field of the IOHIDDevice is the io_service_t we're looking for.
       */
      uintptr_t a;
      uint8_t b[4];
#if __LP64__
      uint32_t c;
#endif
      io_service_t service;
    };
    struct IOHIDDevice_internal *tmp = (struct IOHIDDevice_internal *)device;
 
    return tmp->service;
  }
}

Referenced by hid_enumerate().

Here is the caller graph for this function:

init_hid_manager()

static int init_hid_manager ( void  )

static

{
  /* Initialize all the HID Manager Objects */
  hid_mgr = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
  if (hid_mgr) {
    IOHIDManagerSetDeviceMatching(hid_mgr, NULL);
    IOHIDManagerScheduleWithRunLoop(hid_mgr, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
    return 0;
  }
 
  return -1;
}

References hid_mgr.

Referenced by hid_init().

Here is the caller graph for this function:

new_hid_device()

static hid_device * new_hid_device ( void  )

static

{
  hid_device *dev = calloc(1, sizeof(hid_device));
  dev->device_handle = NULL;
  dev->blocking = 1;
  dev->uses_numbered_reports = 0;
  dev->disconnected = 0;
  dev->run_loop_mode = NULL;
  dev->run_loop = NULL;
  dev->source = NULL;
  dev->input_report_buf = NULL;
  dev->input_reports = NULL;
  dev->shutdown_thread = 0;
 
  /* Thread objects */
  pthread_mutex_init(&dev->mutex, NULL);
  pthread_cond_init(&dev->condition, NULL);
  pthread_barrier_init(&dev->barrier, NULL, 2);
  pthread_barrier_init(&dev->shutdown_barrier, NULL, 2);
 
  return dev;
}

References hid_device_::barrier, hid_device_::blocking, hid_device_::condition, hid_device_::device_handle, hid_device_::disconnected, hid_device_::input_report_buf, hid_device_::input_reports, hid_device_::mutex, pthread_barrier_init(), hid_device_::run_loop, hid_device_::run_loop_mode, hid_device_::shutdown_barrier, hid_device_::shutdown_thread, hid_device_::source, and hid_device_::uses_numbered_reports.

Here is the call graph for this function:

perform_signal_callback()

static void perform_signal_callback ( void *  context )

static

{
  hid_device *dev = context;
  CFRunLoopStop(dev->run_loop); /*TODO: CFRunLoopGetCurrent()*/
}

References hid_device_::run_loop.

Referenced by read_thread().

Here is the caller graph for this function:

process_pending_events()

static void process_pending_events ( void  )

static

                                         {
  SInt32 res;
  do {
    res = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.001, FALSE);
  } while(res != kCFRunLoopRunFinished && res != kCFRunLoopRunTimedOut);
}

References FALSE.

Referenced by hid_enumerate().

Here is the caller graph for this function:

pthread_barrier_destroy()

static int pthread_barrier_destroy ( pthread_barrier_t *  barrier )

static

{
  pthread_cond_destroy(&barrier->cond);
  pthread_mutex_destroy(&barrier->mutex);
  return 0;
}

References pthread_barrier::cond, and pthread_barrier::mutex.

Referenced by free_hid_device().

Here is the caller graph for this function:

pthread_barrier_init()

static int pthread_barrier_init ( pthread_barrier_t *  barrier, const pthread_barrierattr_t *  attr, unsigned int  count  )

static

{
  if(count == 0) {
    errno = EINVAL;
    return -1;
  }
 
  if(pthread_mutex_init(&barrier->mutex, 0) < 0) {
    return -1;
  }
  if(pthread_cond_init(&barrier->cond, 0) < 0) {
    pthread_mutex_destroy(&barrier->mutex);
    return -1;
  }
  barrier->trip_count = count;
  barrier->count = 0;
 
  return 0;
}

References pthread_barrier::cond, pthread_barrier::count, pthread_barrier::mutex, and pthread_barrier::trip_count.

Referenced by new_hid_device().

Here is the caller graph for this function:

pthread_barrier_wait()

static int pthread_barrier_wait ( pthread_barrier_t *  barrier )

static

{
  pthread_mutex_lock(&barrier->mutex);
  ++(barrier->count);
  if(barrier->count >= barrier->trip_count)
  {
    barrier->count = 0;
    pthread_cond_broadcast(&barrier->cond);
    pthread_mutex_unlock(&barrier->mutex);
    return 1;
  }
  else
  {
    pthread_cond_wait(&barrier->cond, &(barrier->mutex));
    pthread_mutex_unlock(&barrier->mutex);
    return 0;
  }
}

References pthread_barrier::cond, pthread_barrier::count, pthread_barrier::mutex, and pthread_barrier::trip_count.

Referenced by hid_close(), hid_open_path(), and read_thread().

Here is the caller graph for this function:

read_thread()

static void * read_thread ( void *  param )

static

{
  hid_device *dev = param;
  SInt32 code;
 
  /* Move the device's run loop to this thread. */
  IOHIDDeviceScheduleWithRunLoop(dev->device_handle, CFRunLoopGetCurrent(), dev->run_loop_mode);
 
  /* Create the RunLoopSource which is used to signal the
     event loop to stop when hid_close() is called. */
  CFRunLoopSourceContext ctx;
  memset(&ctx, 0, sizeof(ctx));
  ctx.version = 0;
  ctx.info = dev;
  ctx.perform = &perform_signal_callback;
  dev->source = CFRunLoopSourceCreate(kCFAllocatorDefault, 0/*order*/, &ctx);
  CFRunLoopAddSource(CFRunLoopGetCurrent(), dev->source, dev->run_loop_mode);
 
  /* Store off the Run Loop so it can be stopped from hid_close()
     and on device disconnection. */
  dev->run_loop = CFRunLoopGetCurrent();
 
  /* Notify the main thread that the read thread is up and running. */
  pthread_barrier_wait(&dev->barrier);
 
  /* Run the Event Loop. CFRunLoopRunInMode() will dispatch HID input
     reports into the hid_report_callback(). */
  while (!dev->shutdown_thread && !dev->disconnected) {
    code = CFRunLoopRunInMode(dev->run_loop_mode, 1000/*sec*/, FALSE);
    /* Return if the device has been disconnected */
    if (code == kCFRunLoopRunFinished) {
      dev->disconnected = 1;
      break;
    }
 
 
    /* Break if The Run Loop returns Finished or Stopped. */
    if (code != kCFRunLoopRunTimedOut &&
        code != kCFRunLoopRunHandledSource) {
      /* There was some kind of error. Setting
         shutdown seems to make sense, but
         there may be something else more appropriate */
      dev->shutdown_thread = 1;
      break;
    }
  }
 
  /* Now that the read thread is stopping, Wake any threads which are
     waiting on data (in hid_read_timeout()). Do this under a mutex to
     make sure that a thread which is about to go to sleep waiting on
     the condition actually will go to sleep before the condition is
     signaled. */
  pthread_mutex_lock(&dev->mutex);
  pthread_cond_broadcast(&dev->condition);
  pthread_mutex_unlock(&dev->mutex);
 
  /* Wait here until hid_close() is called and makes it past
     the call to CFRunLoopWakeUp(). This thread still needs to
     be valid when that function is called on the other thread. */
  pthread_barrier_wait(&dev->shutdown_barrier);
 
  return NULL;
}

References hid_device_::barrier, hid_device_::condition, hid_device_::device_handle, hid_device_::disconnected, FALSE, hid_device_::mutex, perform_signal_callback(), pthread_barrier_wait(), hid_device_::run_loop, hid_device_::run_loop_mode, hid_device_::shutdown_barrier, hid_device_::shutdown_thread, and hid_device_::source.

Referenced by hid_open_path().

Here is the call graph for this function:

Here is the caller graph for this function:

return_data()

static int return_data ( hid_device *  dev, unsigned char *  data, size_t  length  )

static

{
  /* Copy the data out of the linked list item (rpt) into the
     return buffer (data), and delete the liked list item. */
  struct input_report *rpt = dev->input_reports;
  size_t len = (length < rpt->len)? length: rpt->len;
  memcpy(data, rpt->data, len);
  dev->input_reports = rpt->next;
  free(rpt->data);
  free(rpt);
  return len;
}

References input_report::data, free(), hid_device_::input_reports, input_report::len, and input_report::next.

Referenced by hid_close(), hid_read_timeout(), and hid_report_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

set_report()

static int set_report ( hid_device *  dev, IOHIDReportType  type, const unsigned char *  data, size_t  length  )

static

{
  const unsigned char *data_to_send;
  size_t length_to_send;
  IOReturn res;
 
  /* Return if the device has been disconnected. */
  if (dev->disconnected)
    return -1;
 
  if (data[0] == 0x0) {
    /* Not using numbered Reports.
       Don't send the report number. */
    data_to_send = data+1;
    length_to_send = length-1;
  }
  else {
    /* Using numbered Reports.
       Send the Report Number */
    data_to_send = data;
    length_to_send = length;
  }
 
  if (!dev->disconnected) {
    res = IOHIDDeviceSetReport(dev->device_handle,
             type,
             data[0], /* Report ID*/
             data_to_send, length_to_send);
 
    if (res == kIOReturnSuccess) {
      return length;
    }
    else
      return -1;
  }
 
  return -1;
}

References input_report::data, hid_device_::device_handle, and hid_device_::disconnected.

Referenced by hid_send_feature_report(), and hid_write().

Here is the caller graph for this function:

Variable Documentation

hid_mgr

IOHIDManagerRef hid_mgr = 0x0

static

Referenced by hid_enumerate(), hid_exit(), hid_init(), and init_hid_manager().