Index: uspace/drv/usbhid/generic/hiddev.c =================================================================== --- uspace/drv/usbhid/generic/hiddev.c (revision a49e17176a379a47b42277c9a627431062cf002e) +++ uspace/drv/usbhid/generic/hiddev.c (revision 60c0573469b97a8a312f0304101cbd58ad38e764) @@ -39,4 +39,5 @@ #include "hiddev.h" +#include "usbhid.h" /*----------------------------------------------------------------------------*/ @@ -54,9 +55,9 @@ /*----------------------------------------------------------------------------*/ -bool usb_hid_polling_callback(usb_device_t *dev, uint8_t *buffer, - size_t buffer_size, void *arg) +bool usb_generic_hid_polling_callback(usb_hid_dev_t *hid_dev, + uint8_t *buffer, size_t buffer_size) { - usb_log_debug("usb_hid_polling_callback(%p, %p, %zu, %p)\n", - dev, buffer, buffer_size, arg); + usb_log_debug("usb_hid_polling_callback(%p, %p, %zu)\n", + hid_dev, buffer, buffer_size); usb_debug_str_buffer(buffer, buffer_size, 0); return true; Index: uspace/drv/usbhid/generic/hiddev.h =================================================================== --- uspace/drv/usbhid/generic/hiddev.h (revision a49e17176a379a47b42277c9a627431062cf002e) +++ uspace/drv/usbhid/generic/hiddev.h (revision 60c0573469b97a8a312f0304101cbd58ad38e764) @@ -39,4 +39,6 @@ #include +struct usb_hid_dev; + usb_endpoint_description_t usb_hid_generic_poll_endpoint_description; @@ -44,6 +46,6 @@ const char *HID_GENERIC_CLASS_NAME; -bool usb_hid_polling_callback(usb_device_t *dev, uint8_t *buffer, - size_t buffer_size, void *arg); +bool usb_generic_hid_polling_callback(struct usb_hid_dev *hid_dev, + uint8_t *buffer, size_t buffer_size); #endif // USB_HIDDDEV_H_ Index: uspace/drv/usbhid/kbd/kbddev.c =================================================================== --- uspace/drv/usbhid/kbd/kbddev.c (revision a49e17176a379a47b42277c9a627431062cf002e) +++ uspace/drv/usbhid/kbd/kbddev.c (revision 60c0573469b97a8a312f0304101cbd58ad38e764) @@ -856,13 +856,11 @@ /*----------------------------------------------------------------------------*/ -bool usb_kbd_polling_callback(usb_device_t *dev, uint8_t *buffer, - size_t buffer_size, void *arg) -{ - if (dev == NULL || buffer == NULL || arg == NULL) { +bool usb_kbd_polling_callback(usb_hid_dev_t *hid_dev, uint8_t *buffer, + size_t buffer_size) +{ + if (hid_dev == NULL || buffer == NULL) { // do not continue polling (???) return false; } - - usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg; // TODO: add return value from this function @@ -916,5 +914,5 @@ /*----------------------------------------------------------------------------*/ -void usb_kbd_deinit(struct usb_hid_dev_t *hid_dev) +void usb_kbd_deinit(usb_hid_dev_t *hid_dev) { if (hid_dev == NULL) { Index: uspace/drv/usbhid/kbd/kbddev.h =================================================================== --- uspace/drv/usbhid/kbd/kbddev.h (revision a49e17176a379a47b42277c9a627431062cf002e) +++ uspace/drv/usbhid/kbd/kbddev.h (revision 60c0573469b97a8a312f0304101cbd58ad38e764) @@ -49,5 +49,5 @@ #include "kbdrepeat.h" -struct usb_hid_dev_t; +struct usb_hid_dev; /*----------------------------------------------------------------------------*/ @@ -115,8 +115,8 @@ /*----------------------------------------------------------------------------*/ -int usb_kbd_init(struct usb_hid_dev_t *hid_dev); +int usb_kbd_init(struct usb_hid_dev *hid_dev); -bool usb_kbd_polling_callback(usb_device_t *dev, uint8_t *buffer, - size_t buffer_size, void *arg); +bool usb_kbd_polling_callback(struct usb_hid_dev *hid_dev, uint8_t *buffer, + size_t buffer_size); int usb_kbd_is_initialized(const usb_kbd_t *kbd_dev); @@ -126,10 +126,10 @@ void usb_kbd_free(usb_kbd_t **kbd_dev); -void usb_kbd_push_ev(struct usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev, +void usb_kbd_push_ev(struct usb_hid_dev *hid_dev, usb_kbd_t *kbd_dev, int type, unsigned int key); -void usb_kbd_deinit(struct usb_hid_dev_t *hid_dev); +void usb_kbd_deinit(struct usb_hid_dev *hid_dev); -int usb_kbd_set_boot_protocol(struct usb_hid_dev_t *hid_dev); +int usb_kbd_set_boot_protocol(struct usb_hid_dev *hid_dev); #endif /* USB_KBDDEV_H_ */ Index: uspace/drv/usbhid/main.c =================================================================== --- uspace/drv/usbhid/main.c (revision a49e17176a379a47b42277c9a627431062cf002e) +++ uspace/drv/usbhid/main.c (revision 60c0573469b97a8a312f0304101cbd58ad38e764) @@ -98,5 +98,5 @@ /* Create the function exposed under /dev/devices. */ ddf_fun_t *hid_fun = ddf_fun_create(dev->ddf_dev, fun_exposed, - usb_hid_get_function_name(hid_dev->device_type)); + usb_hid_get_function_name(hid_dev)); if (hid_fun == NULL) { usb_log_error("Could not create DDF function node.\n"); @@ -122,6 +122,5 @@ } - rc = ddf_fun_add_to_class(hid_fun, - usb_hid_get_class_name(hid_dev->device_type)); + rc = ddf_fun_add_to_class(hid_fun, usb_hid_get_class_name(hid_dev)); if (rc != EOK) { usb_log_error( @@ -142,5 +141,5 @@ hid_dev->poll_pipe_index, /* Callback when data arrives. */ - hid_dev->poll_callback, + usb_hid_polling_callback, /* How much data to request. */ dev->pipes[hid_dev->poll_pipe_index].pipe->max_packet_size, Index: uspace/drv/usbhid/mouse/mousedev.c =================================================================== --- uspace/drv/usbhid/mouse/mousedev.c (revision a49e17176a379a47b42277c9a627431062cf002e) +++ uspace/drv/usbhid/mouse/mousedev.c (revision 60c0573469b97a8a312f0304101cbd58ad38e764) @@ -231,5 +231,5 @@ /*----------------------------------------------------------------------------*/ -int usb_mouse_init(struct usb_hid_dev_t *hid_dev) +int usb_mouse_init(usb_hid_dev_t *hid_dev) { usb_log_debug("Initializing HID/Mouse structure...\n"); @@ -252,11 +252,9 @@ // set handler for incoming calls - // TODO: now does this behave when we have more such handlers in - // one actual driver?? hid_dev->ops.default_handler = default_connection_handler; // TODO: how to know if the device supports the request??? -// usbhid_req_set_idle(&hid_dev->usb_dev->ctrl_pipe, -// hid_dev->usb_dev->interface_no, IDLE_RATE); + usbhid_req_set_idle(&hid_dev->usb_dev->ctrl_pipe, + hid_dev->usb_dev->interface_no, IDLE_RATE); return EOK; @@ -265,11 +263,11 @@ /*----------------------------------------------------------------------------*/ -bool usb_mouse_polling_callback(usb_device_t *dev, uint8_t *buffer, - size_t buffer_size, void *arg) +bool usb_mouse_polling_callback(usb_hid_dev_t *hid_dev, uint8_t *buffer, + size_t buffer_size) { usb_log_debug("usb_mouse_polling_callback()\n"); usb_debug_str_buffer(buffer, buffer_size, 0); - if (arg == NULL) { + if (hid_dev == NULL) { usb_log_error("Missing argument to the mouse polling callback." "\n"); @@ -277,5 +275,4 @@ } - usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg; if (hid_dev->data == NULL) { usb_log_error("Wrong argument to the mouse polling callback." @@ -290,5 +287,5 @@ /*----------------------------------------------------------------------------*/ -void usb_mouse_deinit(struct usb_hid_dev_t *hid_dev) +void usb_mouse_deinit(usb_hid_dev_t *hid_dev) { usb_mouse_free((usb_mouse_t **)&hid_dev->data); @@ -297,5 +294,5 @@ /*----------------------------------------------------------------------------*/ -int usb_mouse_set_boot_protocol(struct usb_hid_dev_t *hid_dev) +int usb_mouse_set_boot_protocol(usb_hid_dev_t *hid_dev) { int rc = usb_hid_parse_report_descriptor(hid_dev->parser, Index: uspace/drv/usbhid/mouse/mousedev.h =================================================================== --- uspace/drv/usbhid/mouse/mousedev.h (revision a49e17176a379a47b42277c9a627431062cf002e) +++ uspace/drv/usbhid/mouse/mousedev.h (revision 60c0573469b97a8a312f0304101cbd58ad38e764) @@ -39,5 +39,5 @@ #include -struct usb_hid_dev_t; +struct usb_hid_dev; /*----------------------------------------------------------------------------*/ @@ -60,12 +60,12 @@ /*----------------------------------------------------------------------------*/ -int usb_mouse_init(struct usb_hid_dev_t *hid_dev); +int usb_mouse_init(struct usb_hid_dev *hid_dev); -bool usb_mouse_polling_callback(usb_device_t *dev, uint8_t *buffer, - size_t buffer_size, void *arg); +bool usb_mouse_polling_callback(struct usb_hid_dev *hid_dev, uint8_t *buffer, + size_t buffer_size); -void usb_mouse_deinit(struct usb_hid_dev_t *hid_dev); +void usb_mouse_deinit(struct usb_hid_dev *hid_dev); -int usb_mouse_set_boot_protocol(struct usb_hid_dev_t *hid_dev); +int usb_mouse_set_boot_protocol(struct usb_hid_dev *hid_dev); /*----------------------------------------------------------------------------*/ Index: uspace/drv/usbhid/usbhid.c =================================================================== --- uspace/drv/usbhid/usbhid.c (revision a49e17176a379a47b42277c9a627431062cf002e) +++ uspace/drv/usbhid/usbhid.c (revision 60c0573469b97a8a312f0304101cbd58ad38e764) @@ -51,4 +51,12 @@ /*----------------------------------------------------------------------------*/ +typedef struct usb_hid_callback_mapping { + usb_hid_report_path_t *path; + char *vendor_id; + char *product_id; +} usb_hid_callback_mapping; + +/*----------------------------------------------------------------------------*/ + /* Array of endpoints expected on the device, NULL terminated. */ usb_endpoint_description_t *usb_hid_endpoints[USB_HID_POLL_EP_COUNT + 1] = { @@ -61,4 +69,179 @@ /*----------------------------------------------------------------------------*/ +static int usb_hid_set_boot_kbd_subdriver(usb_hid_dev_t *hid_dev) +{ + assert(hid_dev->subdriver_count == 0); + + hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc( + sizeof(usb_hid_subdriver_t)); + if (hid_dev->subdrivers == NULL) { + return ENOMEM; + } + + // set the init callback + hid_dev->subdrivers[0].init = usb_kbd_init; + + // set the polling callback + hid_dev->subdrivers[0].poll = usb_kbd_polling_callback; + + // set the polling ended callback + hid_dev->subdrivers[0].poll_end = NULL; + + // set the deinit callback + hid_dev->subdrivers[0].deinit = usb_kbd_deinit; + + // set subdriver count + hid_dev->subdriver_count = 1; + + return EOK; +} + +/*----------------------------------------------------------------------------*/ + +static int usb_hid_set_boot_mouse_subdriver(usb_hid_dev_t *hid_dev) +{ + assert(hid_dev->subdriver_count == 0); + + hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc( + sizeof(usb_hid_subdriver_t)); + if (hid_dev->subdrivers == NULL) { + return ENOMEM; + } + + // set the init callback + hid_dev->subdrivers[0].init = usb_mouse_init; + + // set the polling callback + hid_dev->subdrivers[0].poll = usb_mouse_polling_callback; + + // set the polling ended callback + hid_dev->subdrivers[0].poll_end = NULL; + + // set the deinit callback + hid_dev->subdrivers[0].deinit = usb_mouse_deinit; + + // set subdriver count + hid_dev->subdriver_count = 1; + + return EOK; +} + +/*----------------------------------------------------------------------------*/ + +static int usb_hid_set_generic_hid_subdriver(usb_hid_dev_t *hid_dev) +{ + assert(hid_dev->subdriver_count == 0); + + hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc( + sizeof(usb_hid_subdriver_t)); + if (hid_dev->subdrivers == NULL) { + return ENOMEM; + } + + // set the init callback + hid_dev->subdrivers[0].init = NULL; + + // set the polling callback + hid_dev->subdrivers[0].poll = usb_generic_hid_polling_callback; + + // set the polling ended callback + hid_dev->subdrivers[0].poll_end = NULL; + + // set the deinit callback + hid_dev->subdrivers[0].deinit = NULL; + + return EOK; +} + +/*----------------------------------------------------------------------------*/ + +static int usb_hid_find_subdrivers(usb_hid_dev_t *hid_dev) +{ + return EOK; +} + +/*----------------------------------------------------------------------------*/ + +static int usb_hid_check_pipes(usb_hid_dev_t *hid_dev, usb_device_t *dev) +{ + // first try to find subdrivers that may want to handle this device + int rc = usb_hid_find_subdrivers(hid_dev); + + if (dev->pipes[USB_HID_KBD_POLL_EP_NO].present) { + usb_log_debug("Found keyboard endpoint.\n"); + + // save the pipe index + hid_dev->poll_pipe_index = USB_HID_KBD_POLL_EP_NO; + + // if no subdrivers registered, use the boot kbd subdriver + if (hid_dev->subdriver_count == 0) { + rc = usb_hid_set_boot_kbd_subdriver(hid_dev); + } + } else if (dev->pipes[USB_HID_MOUSE_POLL_EP_NO].present) { + usb_log_debug("Found mouse endpoint.\n"); + + // save the pipe index + hid_dev->poll_pipe_index = USB_HID_MOUSE_POLL_EP_NO; + //hid_dev->device_type = USB_HID_PROTOCOL_MOUSE; + + // if no subdrivers registered, use the boot kbd subdriver + if (hid_dev->subdriver_count == 0) { + rc = usb_hid_set_boot_mouse_subdriver(hid_dev); + } + } else if (dev->pipes[USB_HID_GENERIC_POLL_EP_NO].present) { + usb_log_debug("Found generic HID endpoint.\n"); + + // save the pipe index + hid_dev->poll_pipe_index = USB_HID_GENERIC_POLL_EP_NO; + + if (hid_dev->subdriver_count == 0) { + usb_log_warning("Found no subdriver for handling this" + " HID device. Setting generic HID subdriver.\n"); + usb_hid_set_generic_hid_subdriver(hid_dev); + return EOK; + } + } else { + usb_log_error("None of supported endpoints found - probably" + " not a supported device.\n"); + rc = ENOTSUP; + } + + return rc; +} + +/*----------------------------------------------------------------------------*/ + +static int usb_hid_init_parser(usb_hid_dev_t *hid_dev) +{ + /* Initialize the report parser. */ + int rc = usb_hid_parser_init(hid_dev->parser); + if (rc != EOK) { + usb_log_error("Failed to initialize report parser.\n"); + return rc; + } + + /* Get the report descriptor and parse it. */ + rc = usb_hid_process_report_descriptor(hid_dev->usb_dev, + hid_dev->parser); + + // TODO: remove the hack + if (rc != EOK || hid_dev->poll_pipe_index == USB_HID_MOUSE_POLL_EP_NO) { + usb_log_warning("Could not process report descriptor.\n"); + + if (hid_dev->poll_pipe_index == USB_HID_KBD_POLL_EP_NO) { + usb_log_warning("Falling back to boot protocol.\n"); + rc = usb_kbd_set_boot_protocol(hid_dev); + } else if (hid_dev->poll_pipe_index + == USB_HID_MOUSE_POLL_EP_NO) { + usb_log_warning("Falling back to boot protocol.\n"); + rc = usb_mouse_set_boot_protocol(hid_dev); + } + } + + return rc; +} + +/*----------------------------------------------------------------------------*/ + usb_hid_dev_t *usb_hid_new(void) { @@ -84,80 +267,7 @@ /*----------------------------------------------------------------------------*/ -static int usb_hid_check_pipes(usb_hid_dev_t *hid_dev, usb_device_t *dev) -{ - if (dev->pipes[USB_HID_KBD_POLL_EP_NO].present) { - usb_log_debug("Found keyboard endpoint.\n"); - - // save the pipe index and device type - hid_dev->poll_pipe_index = USB_HID_KBD_POLL_EP_NO; - hid_dev->device_type = USB_HID_PROTOCOL_KEYBOARD; - - // set the polling callback - hid_dev->poll_callback = usb_kbd_polling_callback; - - } else if (dev->pipes[USB_HID_MOUSE_POLL_EP_NO].present) { - usb_log_debug("Found mouse endpoint.\n"); - - // save the pipe index and device type - hid_dev->poll_pipe_index = USB_HID_MOUSE_POLL_EP_NO; - hid_dev->device_type = USB_HID_PROTOCOL_MOUSE; - - // set the polling callback - hid_dev->poll_callback = usb_mouse_polling_callback; - - } else if (dev->pipes[USB_HID_GENERIC_POLL_EP_NO].present) { - usb_log_debug("Found generic HID endpoint.\n"); - - // save the pipe index and device type - hid_dev->poll_pipe_index = USB_HID_GENERIC_POLL_EP_NO; - hid_dev->device_type = USB_HID_PROTOCOL_NONE; - - // set the polling callback - hid_dev->poll_callback = usb_hid_polling_callback; - - } else { - usb_log_warning("None of supported endpoints found - probably" - " not a supported device.\n"); - return ENOTSUP; - } - - return EOK; -} - -/*----------------------------------------------------------------------------*/ - -static int usb_hid_init_parser(usb_hid_dev_t *hid_dev) -{ - /* Initialize the report parser. */ - int rc = usb_hid_parser_init(hid_dev->parser); - if (rc != EOK) { - usb_log_error("Failed to initialize report parser.\n"); - return rc; - } - - /* Get the report descriptor and parse it. */ - rc = usb_hid_process_report_descriptor(hid_dev->usb_dev, - hid_dev->parser); - - if (rc != EOK || hid_dev->device_type == USB_HID_PROTOCOL_MOUSE) { - usb_log_warning("Could not process report descriptor.\n"); - - if (hid_dev->device_type == USB_HID_PROTOCOL_KEYBOARD) { - usb_log_warning("Falling back to boot protocol.\n"); - rc = usb_kbd_set_boot_protocol(hid_dev); - } else if (hid_dev->device_type == USB_HID_PROTOCOL_MOUSE) { - usb_log_warning("Falling back to boot protocol.\n"); - rc = usb_mouse_set_boot_protocol(hid_dev); - } - } - - return rc; -} - -/*----------------------------------------------------------------------------*/ - int usb_hid_init(usb_hid_dev_t *hid_dev, usb_device_t *dev) { - int rc; + int rc, i; usb_log_debug("Initializing HID structure...\n"); @@ -189,25 +299,43 @@ } - switch (hid_dev->device_type) { - case USB_HID_PROTOCOL_KEYBOARD: - // initialize the keyboard structure - rc = usb_kbd_init(hid_dev); - if (rc != EOK) { - usb_log_warning("Failed to initialize KBD structure." - "\n"); - } - break; - case USB_HID_PROTOCOL_MOUSE: - rc = usb_mouse_init(hid_dev); - if (rc != EOK) { - usb_log_warning("Failed to initialize Mouse structure." - "\n"); - } - break; - default: - break; + for (i = 0; i < hid_dev->subdriver_count; ++i) { + if (hid_dev->subdrivers[i].init != NULL) { + rc = hid_dev->subdrivers[i].init(hid_dev); + if (rc != EOK) { + usb_log_warning("Failed to initialize HID" + " subdriver structure.\n"); + } + } } return rc; +} + +/*----------------------------------------------------------------------------*/ + +bool usb_hid_polling_callback(usb_device_t *dev, uint8_t *buffer, + size_t buffer_size, void *arg) +{ + int i; + + if (dev == NULL || arg == NULL || buffer == NULL) { + usb_log_error("Missing arguments to polling callback.\n"); + return false; + } + + usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg; + + bool cont = false; + + // continue if at least one of the subdrivers want to continue + for (i = 0; i < hid_dev->subdriver_count; ++i) { + if (hid_dev->subdrivers[i].poll != NULL + && hid_dev->subdrivers[i].poll(hid_dev, buffer, + buffer_size)) { + cont = true; + } + } + + return cont; } @@ -217,4 +345,6 @@ void *arg) { + int i; + if (dev == NULL || arg == NULL) { return; @@ -223,4 +353,10 @@ usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg; + for (i = 0; i < hid_dev->subdriver_count; ++i) { + if (hid_dev->subdrivers[i].poll_end != NULL) { + hid_dev->subdrivers[i].poll_end(hid_dev, reason); + } + } + usb_hid_free(&hid_dev); } @@ -228,11 +364,11 @@ /*----------------------------------------------------------------------------*/ -const char *usb_hid_get_function_name(usb_hid_iface_protocol_t device_type) -{ - switch (device_type) { - case USB_HID_PROTOCOL_KEYBOARD: +const char *usb_hid_get_function_name(const usb_hid_dev_t *hid_dev) +{ + switch (hid_dev->poll_pipe_index) { + case USB_HID_KBD_POLL_EP_NO: return HID_KBD_FUN_NAME; break; - case USB_HID_PROTOCOL_MOUSE: + case USB_HID_MOUSE_POLL_EP_NO: return HID_MOUSE_FUN_NAME; break; @@ -244,11 +380,14 @@ /*----------------------------------------------------------------------------*/ -const char *usb_hid_get_class_name(usb_hid_iface_protocol_t device_type) -{ - switch (device_type) { - case USB_HID_PROTOCOL_KEYBOARD: +const char *usb_hid_get_class_name(const usb_hid_dev_t *hid_dev) +{ + // this means that only boot protocol keyboards will be connected + // to the console; there is probably no better way to do this + + switch (hid_dev->poll_pipe_index) { + case USB_HID_KBD_POLL_EP_NO: return HID_KBD_CLASS_NAME; break; - case USB_HID_PROTOCOL_MOUSE: + case USB_HID_MOUSE_POLL_EP_NO: return HID_MOUSE_CLASS_NAME; break; @@ -262,17 +401,14 @@ void usb_hid_free(usb_hid_dev_t **hid_dev) { + int i; + if (hid_dev == NULL || *hid_dev == NULL) { return; } - switch ((*hid_dev)->device_type) { - case USB_HID_PROTOCOL_KEYBOARD: - usb_kbd_deinit(*hid_dev); - break; - case USB_HID_PROTOCOL_MOUSE: - usb_mouse_deinit(*hid_dev); - break; - default: - break; + for (i = 0; i < (*hid_dev)->subdriver_count; ++i) { + if ((*hid_dev)->subdrivers[i].deinit != NULL) { + (*hid_dev)->subdrivers[i].deinit(*hid_dev); + } } Index: uspace/drv/usbhid/usbhid.h =================================================================== --- uspace/drv/usbhid/usbhid.h (revision a49e17176a379a47b42277c9a627431062cf002e) +++ uspace/drv/usbhid/usbhid.h (revision 60c0573469b97a8a312f0304101cbd58ad38e764) @@ -45,9 +45,28 @@ #include +struct usb_hid_dev; + +typedef int (*usb_hid_driver_init_t)(struct usb_hid_dev *); +typedef void (*usb_hid_driver_deinit_t)(struct usb_hid_dev *); +typedef bool (*usb_hid_driver_poll)(struct usb_hid_dev *, uint8_t *, size_t); +typedef int (*usb_hid_driver_poll_ended)(struct usb_hid_dev *, bool reason); + +// TODO: add function and class name?? +typedef struct usb_hid_subdriver { + /** Function to be called when initializing HID device. */ + usb_hid_driver_init_t init; + /** Function to be called when destroying the HID device structure. */ + usb_hid_driver_deinit_t deinit; + /** Function to be called when data arrives from the device. */ + usb_hid_driver_poll poll; + /** Function to be called when polling ends. */ + usb_hid_driver_poll_ended poll_end; +} usb_hid_subdriver_t; + /*----------------------------------------------------------------------------*/ /** * Structure for holding general HID device data. */ -typedef struct usb_hid_dev_t { +typedef struct usb_hid_dev { /** Structure holding generic USB device information. */ usb_device_t *usb_dev; @@ -59,6 +78,9 @@ int poll_pipe_index; - /** Function to be called when data arrives from the device. */ - usb_polling_callback_t poll_callback; + /** Subdrivers. */ + usb_hid_subdriver_t *subdrivers; + + /** Number of subdrivers. */ + int subdriver_count; /** Report descriptor. */ @@ -73,7 +95,4 @@ /** Arbitrary data (e.g. a special structure for handling keyboard). */ void *data; - - /** Type of the device (keyboard, mouse, generic HID device). */ - usb_hid_iface_protocol_t device_type; } usb_hid_dev_t; @@ -95,10 +114,13 @@ int usb_hid_init(usb_hid_dev_t *hid_dev, usb_device_t *dev); +bool usb_hid_polling_callback(usb_device_t *dev, uint8_t *buffer, + size_t buffer_size, void *arg); + void usb_hid_polling_ended_callback(usb_device_t *dev, bool reason, void *arg); -const char *usb_hid_get_function_name(usb_hid_iface_protocol_t device_type); +const char *usb_hid_get_function_name(const usb_hid_dev_t *hid_dev); -const char *usb_hid_get_class_name(usb_hid_iface_protocol_t device_type); +const char *usb_hid_get_class_name(const usb_hid_dev_t *hid_dev); void usb_hid_free(usb_hid_dev_t **hid_dev);