Changeset c7b5826 in mainline for uspace/drv

Timestamp:

2011-05-18T09:34:56Z (14 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

33d19a7

Parents:

d736fe38 (diff), b2995c3 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Development branch changes

Location:

uspace/drv

Files:

• ohci/root_hub.c (modified) (1 diff)
• ohci/root_hub.h (modified) (1 diff)
• uhci-rhd/port.c (modified) (1 diff)
• uhci-rhd/port.h (modified) (1 diff)
• usbflbk/main.c (modified) (1 diff)
• usbhid/Makefile (modified) (1 diff)
• usbhid/generic/hiddev.c (modified) (2 diffs)
• usbhid/generic/hiddev.h (modified) (2 diffs)
• usbhid/kbd/kbddev.c (modified) (16 diffs)
• usbhid/kbd/kbddev.h (modified) (4 diffs)
• usbhid/kbd/main.c (modified) (1 diff)
• usbhid/lgtch-ultrax/keymap.c (deleted)
• usbhid/main.c (modified) (1 diff)
• usbhid/mouse/mousedev.c (modified) (13 diffs)
• usbhid/mouse/mousedev.h (modified) (3 diffs)
• usbhid/multimedia/keymap.c (added)
• usbhid/multimedia/keymap.h (moved) (moved from uspace/drv/usbhid/lgtch-ultrax/keymap.h ) (1 diff)
• usbhid/multimedia/multimedia.c (moved) (moved from uspace/drv/usbhid/lgtch-ultrax/lgtch-ultrax.c ) (21 diffs)
• usbhid/multimedia/multimedia.h (moved) (moved from uspace/drv/usbhid/lgtch-ultrax/lgtch-ultrax.h ) (2 diffs)
• usbhid/subdrivers.c (modified) (4 diffs)
• usbhid/usbhid.c (modified) (6 diffs)
• usbhid/usbhid.h (modified) (4 diffs)
• usbhub/main.c (modified) (1 diff)
• usbhub/port_status.h (modified) (1 diff)
• usbhub/ports.h (modified) (1 diff)
• usbhub/usbhub.c (modified) (2 diffs)
• usbhub/usbhub.h (modified) (1 diff)
• usbhub/usbhub_private.h (modified) (1 diff)
• usbkbd/conv.c (deleted)
• usbkbd/conv.h (deleted)
• usbkbd/kbd.h (deleted)
• usbkbd/kbddev.c (deleted)
• usbkbd/kbddev.h (deleted)
• usbkbd/kbdrepeat.c (deleted)
• usbkbd/kbdrepeat.h (deleted)
• usbkbd/layout.h (deleted)
• usbkbd/main.c (deleted)
• usbkbd/usbkbd.ma (deleted)
• usbmast/inquiry.c (modified) (1 diff)
• usbmast/main.c (modified) (1 diff)
• usbmast/mast.c (modified) (1 diff)
• usbmast/mast.h (modified) (1 diff)
• usbmid/dump.c (modified) (1 diff)
• usbmid/explore.c (modified) (1 diff)
• usbmid/main.c (modified) (1 diff)
• usbmid/usbmid.c (modified) (1 diff)
• usbmid/usbmid.h (modified) (1 diff)
• usbmouse/init.c (modified) (1 diff)
• usbmouse/main.c (modified) (1 diff)
• usbmouse/mouse.h (modified) (1 diff)
• vhc/connhost.c (modified) (1 diff)
• vhc/hub.c (modified) (1 diff)

uspace/drv/ohci/root_hub.c

@@ -39 +39 @@
 
 #include "root_hub.h"
-#include "usb/classes/classes.h"
-#include "usb/devdrv.h"
+#include <usb/classes/classes.h>
+#include <usb/dev/driver.h>
 #include "ohci_regs.h"
 
-#include <usb/request.h>
+#include <usb/dev/request.h>
 #include <usb/classes/hub.h>
 

uspace/drv/ohci/root_hub.h

@@ -36 +36 @@
 
 #include <usb/usb.h>
-#include <usb/devdrv.h>
+#include <usb/dev/driver.h>
 
 #include "ohci_regs.h"

uspace/drv/uhci-rhd/port.c

@@ -40 +40 @@
 
 #include <usb/usb.h>    /* usb_address_t */
-#include <usb/hub.h>    /* usb_hc_new_device_wrapper */
+#include <usb/dev/hub.h>    /* usb_hc_new_device_wrapper */
 #include <usb/debug.h>
 

uspace/drv/uhci-rhd/port.h

@@ -38 +38 @@
 #include <fibril.h>
 #include <ddf/driver.h>
-#include <usb/usbdevice.h> /* usb_hc_connection_t */
+#include <usb/dev/hc.h> /* usb_hc_connection_t */
 
 typedef uint16_t port_status_t;

uspace/drv/usbflbk/main.c

@@ -34 +34 @@
  * Main routines of USB fallback driver.
  */
-#include <usb/devdrv.h>
+#include <usb/dev/driver.h>
 #include <usb/debug.h>
 #include <errno.h>

uspace/drv/usbhid/Makefile

@@ -57 +57 @@
         generic/hiddev.c \
         mouse/mousedev.c \
-        lgtch-ultrax/lgtch-ultrax.c \
-        lgtch-ultrax/keymap.c \
+        multimedia/multimedia.c \
+        multimedia/keymap.c \
         $(STOLEN_LAYOUT_SOURCES)
 

uspace/drv/usbhid/generic/hiddev.c

@@ -162 +162 @@
 /*----------------------------------------------------------------------------*/
 
-int usb_generic_hid_init(usb_hid_dev_t *hid_dev)
+int usb_generic_hid_init(usb_hid_dev_t *hid_dev, void **data)
 {
         if (hid_dev == NULL) {
@@ -173 +173 @@
 /*----------------------------------------------------------------------------*/
 
-bool usb_generic_hid_polling_callback(usb_hid_dev_t *hid_dev, 
+bool usb_generic_hid_polling_callback(usb_hid_dev_t *hid_dev, void *data, 
     uint8_t *buffer, size_t buffer_size)
 {

uspace/drv/usbhid/generic/hiddev.h

@@ -37 +37 @@
 #define USB_HID_HIDDDEV_H_
 
-#include <usb/devdrv.h>
+#include <usb/dev/driver.h>
 
 struct usb_hid_dev;
@@ -48 +48 @@
 /*----------------------------------------------------------------------------*/
 
-int usb_generic_hid_init(struct usb_hid_dev *hid_dev);
+int usb_generic_hid_init(struct usb_hid_dev *hid_dev, void **data);
 
-bool usb_generic_hid_polling_callback(struct usb_hid_dev *hid_dev,
+bool usb_generic_hid_polling_callback(struct usb_hid_dev *hid_dev, void *data,
     uint8_t *buffer, size_t buffer_size);
 

uspace/drv/usbhid/kbd/kbddev.c

@@ -46 +46 @@
 
 #include <usb/usb.h>
-#include <usb/dp.h>
-#include <usb/request.h>
-#include <usb/classes/hid.h>
-#include <usb/pipes.h>
+#include <usb/dev/dp.h>
+#include <usb/dev/request.h>
+#include <usb/hid/hid.h>
+#include <usb/dev/pipes.h>
 #include <usb/debug.h>
-#include <usb/classes/hidparser.h>
+#include <usb/hid/hidparser.h>
 #include <usb/classes/classes.h>
-#include <usb/classes/hidut.h>
-#include <usb/classes/hidreq.h>
-#include <usb/classes/hidreport.h>
-#include <usb/classes/hid/utled.h>
-
-#include <usb/devdrv.h>
+#include <usb/hid/usages/core.h>
+#include <usb/hid/request.h>
+#include <usb/hid/hidreport.h>
+#include <usb/hid/usages/led.h>
+
+#include <usb/dev/driver.h>
 
 #include "kbddev.h"
@@ -252 +252 @@
         sysarg_t method = IPC_GET_IMETHOD(*icall);
         
-        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
-        
-        if (hid_dev == NULL || hid_dev->data == NULL) {
+        usb_kbd_t *kbd_dev = (usb_kbd_t *)fun->driver_data;
+        if (kbd_dev == NULL) {
                 usb_log_debug("default_connection_handler: "
                     "Missing parameter.\n");
@@ -260 +259 @@
                 return;
         }
-        
-        assert(hid_dev != NULL);
-        assert(hid_dev->data != NULL);
-        usb_kbd_t *kbd_dev = (usb_kbd_t *)hid_dev->data;
 
         if (method == IPC_M_CONNECT_TO_ME) {
@@ -313 +308 @@
         usb_hid_report_field_t *field = usb_hid_report_get_sibling(
             hid_dev->report, NULL, kbd_dev->led_path, 
-            USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY | USB_HID_PATH_COMPARE_END,
+            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
             USB_HID_REPORT_TYPE_OUTPUT);
         
-        while (field != NULL) {
-
+        while (field != NULL) {         
+                
                 if ((field->usage == USB_HID_LED_NUM_LOCK) 
                     && (kbd_dev->mods & KM_NUM_LOCK)){
@@ -334 +329 @@
                 
                 field = usb_hid_report_get_sibling(hid_dev->report, field,
-                    kbd_dev->led_path, USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY 
-                    | USB_HID_PATH_COMPARE_END, USB_HID_REPORT_TYPE_OUTPUT);
+                    kbd_dev->led_path,  
+                USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
+                        USB_HID_REPORT_TYPE_OUTPUT);
         }
         
@@ -662 +658 @@
  *     usb_hid_parse_report().
  */
-static void usb_kbd_process_data(usb_hid_dev_t *hid_dev,
+static void usb_kbd_process_data(usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev,
                                  uint8_t *buffer, size_t actual_size)
 {
         assert(hid_dev->report != NULL);
         assert(hid_dev != NULL);
-        assert(hid_dev->data != NULL);
-        
-        usb_kbd_t *kbd_dev = (usb_kbd_t *)hid_dev->data;
+        assert(kbd_dev != NULL);
 
         usb_log_debug("Calling usb_hid_parse_report() with "
@@ -774 +768 @@
 /*----------------------------------------------------------------------------*/
 
-static int usb_kbd_create_function(usb_hid_dev_t *hid_dev)
+static int usb_kbd_create_function(usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev)
 {
         assert(hid_dev != NULL);
         assert(hid_dev->usb_dev != NULL);
+        assert(kbd_dev != NULL);
         
         /* Create the function exposed under /dev/devices. */
@@ -792 +787 @@
          * to the DDF function.
          */
-        fun->ops = &hid_dev->ops;
-        fun->driver_data = hid_dev;   // TODO: maybe change to hid_dev->data
+        fun->ops = &kbd_dev->ops;
+        fun->driver_data = kbd_dev;
 
         int rc = ddf_fun_bind(fun);
@@ -840 +835 @@
  * @return Other value inherited from function usbhid_dev_init().
  */
-int usb_kbd_init(usb_hid_dev_t *hid_dev)
+int usb_kbd_init(usb_hid_dev_t *hid_dev, void **data)
 {
         usb_log_debug("Initializing HID/KBD structure...\n");
@@ -865 +860 @@
         usb_hid_report_path_set_report_id(path, 0);
         
-        kbd_dev->key_count = usb_hid_report_input_length(
-            hid_dev->report, path, 
-            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
+        kbd_dev->key_count = usb_hid_report_size(
+            hid_dev->report, 0, USB_HID_REPORT_TYPE_INPUT); 
         usb_hid_report_path_free(path);
         
@@ -908 +902 @@
             kbd_dev->led_path, USB_HIDUT_PAGE_LED, 0);
         
-        kbd_dev->led_output_size = usb_hid_report_output_size(hid_dev->report, 
-            kbd_dev->led_path, 
-            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
+        kbd_dev->led_output_size = usb_hid_report_size(hid_dev->report, 
+            0, USB_HID_REPORT_TYPE_OUTPUT);
         
         usb_log_debug("Output report size (in items): %zu\n", 
@@ -955 +948 @@
         
         // save the KBD device structure into the HID device structure
-        hid_dev->data = kbd_dev;
+        //hid_dev->data = kbd_dev;
+        *data = kbd_dev;
         
         // set handler for incoming calls
-        hid_dev->ops.default_handler = default_connection_handler;
+        kbd_dev->ops.default_handler = default_connection_handler;
         
         /*
@@ -983 +977 @@
         
         usb_log_debug("Creating KBD function...\n");
-        int rc = usb_kbd_create_function(hid_dev);
+        int rc = usb_kbd_create_function(hid_dev, kbd_dev);
         if (rc != EOK) {
                 usb_kbd_free(&kbd_dev);
@@ -994 +988 @@
 /*----------------------------------------------------------------------------*/
 
-bool usb_kbd_polling_callback(usb_hid_dev_t *hid_dev, uint8_t *buffer,
-     size_t buffer_size)
-{
-        if (hid_dev == NULL || buffer == NULL) {
+bool usb_kbd_polling_callback(usb_hid_dev_t *hid_dev, void *data, 
+     uint8_t *buffer, size_t buffer_size)
+{
+        if (hid_dev == NULL || buffer == NULL || data == NULL) {
                 // do not continue polling (???)
                 return false;
         }
         
+        usb_kbd_t *kbd_dev = (usb_kbd_t *)data;
+        assert(kbd_dev != NULL);
+        
         // TODO: add return value from this function
-        usb_kbd_process_data(hid_dev, buffer, buffer_size);
+        usb_kbd_process_data(hid_dev, kbd_dev, buffer, buffer_size);
         
         return true;
@@ -1066 +1063 @@
 /*----------------------------------------------------------------------------*/
 
-void usb_kbd_deinit(usb_hid_dev_t *hid_dev)
+void usb_kbd_deinit(usb_hid_dev_t *hid_dev, void *data)
 {
         if (hid_dev == NULL) {
@@ -1072 +1069 @@
         }
         
-        if (hid_dev->data != NULL) {
-                usb_kbd_t *kbd_dev = (usb_kbd_t *)hid_dev->data;
+        if (data != NULL) {
+                usb_kbd_t *kbd_dev = (usb_kbd_t *)data;
                 if (usb_kbd_is_initialized(kbd_dev)) {
                         usb_kbd_mark_unusable(kbd_dev);
                 } else {
                         usb_kbd_free(&kbd_dev);
-                        hid_dev->data = NULL;
                 }
         }

uspace/drv/usbhid/kbd/kbddev.h

@@ -41 +41 @@
 #include <fibril_synch.h>
 
-#include <usb/classes/hid.h>
-#include <usb/classes/hidparser.h>
+#include <usb/hid/hid.h>
+#include <usb/hid/hidparser.h>
 #include <ddf/driver.h>
-#include <usb/pipes.h>
-#include <usb/devdrv.h>
+#include <usb/dev/pipes.h>
+#include <usb/dev/driver.h>
 
 #include "kbdrepeat.h"
@@ -83 +83 @@
         int console_phone;
         
+        /** @todo What is this actually? */
+        ddf_dev_ops_t ops;
+        
         /** Information for auto-repeat of keys. */
         usb_kbd_repeat_t repeat;
@@ -117 +120 @@
 /*----------------------------------------------------------------------------*/
 
-int usb_kbd_init(struct usb_hid_dev *hid_dev);
+int usb_kbd_init(struct usb_hid_dev *hid_dev, void **data);
 
-bool usb_kbd_polling_callback(struct usb_hid_dev *hid_dev, uint8_t *buffer,
-    size_t buffer_size);
+bool usb_kbd_polling_callback(struct usb_hid_dev *hid_dev, void *data, 
+                              uint8_t *buffer, size_t buffer_size);
 
 int usb_kbd_is_initialized(const usb_kbd_t *kbd_dev);
@@ -131 +134 @@
     int type, unsigned int key);
 
-void usb_kbd_deinit(struct usb_hid_dev *hid_dev);
+void usb_kbd_deinit(struct usb_hid_dev *hid_dev, void *data);
 
 int usb_kbd_set_boot_protocol(struct usb_hid_dev *hid_dev);

uspace/drv/usbhid/kbd/main.c

@@ -41 +41 @@
 #include <str_error.h>
 
-#include <usb/devdrv.h>
+#include <usb/dev/driver.h>
 
 #include "kbddev.h"

uspace/drv/usbhid/main.c

@@ -41 +41 @@
 #include <str_error.h>
 
-#include <usb/devdrv.h>
-#include <usb/devpoll.h>
+#include <usb/dev/driver.h>
+#include <usb/dev/poll.h>
 
 #include "usbhid.h"

uspace/drv/usbhid/mouse/mousedev.c

@@ -37 +37 @@
 #include <usb/debug.h>
 #include <usb/classes/classes.h>
-#include <usb/classes/hid.h>
-#include <usb/classes/hidreq.h>
-#include <usb/classes/hidut.h>
+#include <usb/hid/hid.h>
+#include <usb/hid/request.h>
+#include <usb/hid/usages/core.h>
 #include <errno.h>
 #include <str_error.h>
@@ -122 +122 @@
         sysarg_t method = IPC_GET_IMETHOD(*icall);
         
-        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
-        
-        if (hid_dev == NULL || hid_dev->data == NULL) {
+        usb_mouse_t *mouse_dev = (usb_mouse_t *)fun->driver_data;
+        
+        if (mouse_dev == NULL) {
                 usb_log_debug("default_connection_handler: Missing "
                     "parameters.\n");
@@ -131 +131 @@
         }
         
-        assert(hid_dev != NULL);
-        assert(hid_dev->data != NULL);
-        usb_mouse_t *mouse_dev = (usb_mouse_t *)hid_dev->data;
+        usb_log_debug("default_connection_handler: fun->name: %s\n",
+                      fun->name);
+        usb_log_debug("default_connection_handler: mouse_phone: %d, wheel "
+            "phone: %d\n", mouse_dev->mouse_phone, mouse_dev->wheel_phone);
         
         int *phone = (str_cmp(fun->name, HID_MOUSE_FUN_NAME) == 0) 
@@ -145 +146 @@
                             "phone to mouse already set.\n");
                         async_answer_0(icallid, ELIMIT);
-                        //async_answer_0(icallid, EOK);
                         return;
                 }
 
                 *phone = callback;
-                usb_log_debug("Console phone to mouse set ok (%d).\n", callback);
+                usb_log_debug("Console phone to mouse set ok (%d).\n", *phone);
                 async_answer_0(icallid, EOK);
                 return;
@@ -224 +224 @@
 /*----------------------------------------------------------------------------*/
 
-static bool usb_mouse_process_report(usb_hid_dev_t *hid_dev, uint8_t *buffer,
-    size_t buffer_size)
-{
-        usb_mouse_t *mouse_dev = (usb_mouse_t *)hid_dev->data;
+static bool usb_mouse_process_report(usb_hid_dev_t *hid_dev, 
+                                     usb_mouse_t *mouse_dev, uint8_t *buffer,
+                                     size_t buffer_size)
+{
+        assert(mouse_dev != NULL);
         
         usb_log_debug2("got buffer: %s.\n",
@@ -378 +379 @@
 /*----------------------------------------------------------------------------*/
 
-static int usb_mouse_create_function(usb_hid_dev_t *hid_dev)
-{
+static int usb_mouse_create_function(usb_hid_dev_t *hid_dev, usb_mouse_t *mouse)
+{
+        assert(hid_dev != NULL);
+        assert(mouse != NULL);
+        
         /* Create the function exposed under /dev/devices. */
         usb_log_debug("Creating DDF function %s...\n", HID_MOUSE_FUN_NAME);
@@ -389 +393 @@
         }
         
-        /*
-         * Store the initialized HID device and HID ops
-         * to the DDF function.
-         */
-        fun->ops = &hid_dev->ops;
-        fun->driver_data = hid_dev;   // TODO: maybe change to hid_dev->data
+        fun->ops = &mouse->ops;
+        fun->driver_data = mouse;   // TODO: maybe change to hid_dev->data
 
         int rc = ddf_fun_bind(fun);
@@ -431 +431 @@
          * to the DDF function.
          */
-        fun->ops = &hid_dev->ops;
-        fun->driver_data = hid_dev;   // TODO: maybe change to hid_dev->data
+        fun->ops = &mouse->ops;
+        fun->driver_data = mouse;   // TODO: maybe change to hid_dev->data
 
         rc = ddf_fun_bind(fun);
@@ -458 +458 @@
 /*----------------------------------------------------------------------------*/
 
-int usb_mouse_init(usb_hid_dev_t *hid_dev)
+int usb_mouse_init(usb_hid_dev_t *hid_dev, void **data)
 {
         usb_log_debug("Initializing HID/Mouse structure...\n");
@@ -485 +485 @@
         
         // save the Mouse device structure into the HID device structure
-        hid_dev->data = mouse_dev;
+        *data = mouse_dev;
         
         // set handler for incoming calls
-        hid_dev->ops.default_handler = default_connection_handler;
+        // TODO: must be one for each subdriver!!
+        mouse_dev->ops.default_handler = default_connection_handler;
         
         // TODO: how to know if the device supports the request???
@@ -494 +495 @@
 //          hid_dev->usb_dev->interface_no, IDLE_RATE);
         
-        int rc = usb_mouse_create_function(hid_dev);
+        int rc = usb_mouse_create_function(hid_dev, mouse_dev);
         if (rc != EOK) {
                 usb_mouse_free(&mouse_dev);
@@ -505 +506 @@
 /*----------------------------------------------------------------------------*/
 
-bool usb_mouse_polling_callback(usb_hid_dev_t *hid_dev, uint8_t *buffer,
-     size_t buffer_size)
+bool usb_mouse_polling_callback(usb_hid_dev_t *hid_dev, void *data, 
+     uint8_t *buffer, size_t buffer_size)
 {
         usb_log_debug("usb_mouse_polling_callback()\n");
         usb_debug_str_buffer(buffer, buffer_size, 0);
         
-        if (hid_dev == NULL) {
+        if (hid_dev == NULL || data == NULL) {
                 usb_log_error("Missing argument to the mouse polling callback."
                     "\n");
@@ -517 +518 @@
         }
         
-        if (hid_dev->data == NULL) {
-                usb_log_error("Wrong argument to the mouse polling callback."
-                    "\n");
-                return false;
-        }
-        
-        return usb_mouse_process_report(hid_dev, buffer, buffer_size);
-}
-
-/*----------------------------------------------------------------------------*/
-
-void usb_mouse_deinit(usb_hid_dev_t *hid_dev)
-{
-        usb_mouse_free((usb_mouse_t **)&hid_dev->data);
+        usb_mouse_t *mouse_dev = (usb_mouse_t *)data;
+                
+        return usb_mouse_process_report(hid_dev, mouse_dev, buffer, 
+                                        buffer_size);
+}
+
+/*----------------------------------------------------------------------------*/
+
+void usb_mouse_deinit(usb_hid_dev_t *hid_dev, void *data)
+{
+        if (data != NULL) {
+                usb_mouse_free((usb_mouse_t **)&data);
+        }
 }
 

uspace/drv/usbhid/mouse/mousedev.h

@@ -37 +37 @@
 #define USB_HID_MOUSEDEV_H_
 
-#include <usb/devdrv.h>
+#include <usb/dev/driver.h>
 
 struct usb_hid_dev;
@@ -52 +52 @@
         
         int32_t *buttons;
+        
+        ddf_dev_ops_t ops;
 } usb_mouse_t;
 
@@ -63 +65 @@
 /*----------------------------------------------------------------------------*/
 
-int usb_mouse_init(struct usb_hid_dev *hid_dev);
+int usb_mouse_init(struct usb_hid_dev *hid_dev, void **data);
 
-bool usb_mouse_polling_callback(struct usb_hid_dev *hid_dev, uint8_t *buffer,
-    size_t buffer_size);
+bool usb_mouse_polling_callback(struct usb_hid_dev *hid_dev, void *data, 
+    uint8_t *buffer, size_t buffer_size);
 
-void usb_mouse_deinit(struct usb_hid_dev *hid_dev);
+void usb_mouse_deinit(struct usb_hid_dev *hid_dev, void *data);
 
 int usb_mouse_set_boot_protocol(struct usb_hid_dev *hid_dev);

uspace/drv/usbhid/multimedia/keymap.h

@@ -34 +34 @@
  */
 
-#ifndef USB_HID_LGTCH_ULTRAX_KEYMAP_H_
-#define USB_HID_LGTCH_ULTRAX_KEYMAP_H_
+#ifndef USB_HID_MULTIMEDIA_KEYMAP_H_
+#define USB_HID_MULTIMEDIA_KEYMAP_H_
 
-unsigned int usb_lgtch_map_usage(int usage);
+unsigned int usb_multimedia_map_usage(int usage);
 
-#endif /* USB_HID_LGTCH_ULTRAX_KEYMAP_H_ */
+const char *usb_multimedia_usage_to_str(int usage);
+
+#endif /* USB_HID_MULTIMEDIA_KEYMAP_H_ */
 
 /**

uspace/drv/usbhid/multimedia/multimedia.c

@@ -32 +32 @@
 /**
  * @file
- * USB Logitech UltraX Keyboard sample driver.
- */
-
-
-#include "lgtch-ultrax.h"
+ * USB Keyboard multimedia keys subdriver.
+ */
+
+
+#include "multimedia.h"
 #include "../usbhid.h"
 #include "keymap.h"
 
-#include <usb/classes/hidparser.h>
+#include <usb/hid/hidparser.h>
 #include <usb/debug.h>
-#include <usb/classes/hidut.h>
+#include <usb/hid/usages/core.h>
 
 #include <errno.h>
@@ -50 +50 @@
 #include <io/console.h>
 
-#define NAME "lgtch-ultrax"
-
-typedef enum usb_lgtch_flags {
-        USB_LGTCH_STATUS_UNINITIALIZED = 0,
-        USB_LGTCH_STATUS_INITIALIZED = 1,
-        USB_LGTCH_STATUS_TO_DESTROY = -1
-} usb_lgtch_flags;
+#define NAME "multimedia-keys"
 
 /*----------------------------------------------------------------------------*/
@@ -62 +56 @@
  * Logitech UltraX device type.
  */
-typedef struct usb_lgtch_ultrax_t {
+typedef struct usb_multimedia_t {
         /** Previously pressed keys (not translated to key codes). */
         int32_t *keys_old;
@@ -68 +62 @@
         int32_t *keys;
         /** Count of stored keys (i.e. number of keys in the report). */
-        size_t key_count;
-        
+        size_t key_count;       
         /** IPC phone to the console device (for sending key events). */
         int console_phone;
-
-        /** Information for auto-repeat of keys. */
-//      usb_kbd_repeat_t repeat;
-        
-        /** Mutex for accessing the information about auto-repeat. */
-//      fibril_mutex_t *repeat_mtx;
-
-        /** State of the structure (for checking before use). 
-         * 
-         * 0 - not initialized
-         * 1 - initialized
-         * -1 - ready for destroying
-         */
-        int initialized;
-} usb_lgtch_ultrax_t;
+} usb_multimedia_t;
 
 
@@ -108 +87 @@
         sysarg_t method = IPC_GET_IMETHOD(*icall);
         
-        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
-        
-        if (hid_dev == NULL || hid_dev->data == NULL) {
+        usb_multimedia_t *multim_dev = (usb_multimedia_t *)fun->driver_data;
+        //usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
+        
+        if (multim_dev == NULL) {
                 async_answer_0(icallid, EINVAL);
                 return;
         }
-        
-        assert(hid_dev != NULL);
-        assert(hid_dev->data != NULL);
-        usb_lgtch_ultrax_t *lgtch_dev = (usb_lgtch_ultrax_t *)hid_dev->data;
 
         if (method == IPC_M_CONNECT_TO_ME) {
                 int callback = IPC_GET_ARG5(*icall);
 
-                if (lgtch_dev->console_phone != -1) {
+                if (multim_dev->console_phone != -1) {
                         async_answer_0(icallid, ELIMIT);
                         return;
                 }
 
-                lgtch_dev->console_phone = callback;
+                multim_dev->console_phone = callback;
                 usb_log_debug(NAME " Saved phone to console: %d\n", callback);
                 async_answer_0(icallid, EOK);
@@ -138 +114 @@
 /*----------------------------------------------------------------------------*/
 
-static ddf_dev_ops_t lgtch_ultrax_ops = {
+static ddf_dev_ops_t multimedia_ops = {
         .default_handler = default_connection_handler
 };
-
-/*----------------------------------------------------------------------------*/
-
-//static void usb_lgtch_process_keycodes(const uint8_t *key_codes, size_t count,
-//    uint8_t report_id, void *arg);
-
-//static const usb_hid_report_in_callbacks_t usb_lgtch_parser_callbacks = {
-//      .keyboard = usb_lgtch_process_keycodes
-//};
-
-///*----------------------------------------------------------------------------*/
-
-//static void usb_lgtch_process_keycodes(const uint8_t *key_codes, size_t count,
-//    uint8_t report_id, void *arg)
-//{
-//      // TODO: checks
-        
-//      usb_log_debug(NAME " Got keys from parser (report id: %u): %s\n", 
-//          report_id, usb_debug_str_buffer(key_codes, count, 0));
-//}
 
 /*----------------------------------------------------------------------------*/
@@ -180 +136 @@
  * @param key Key code of the key according to HID Usage Tables.
  */
-static void usb_lgtch_push_ev(usb_hid_dev_t *hid_dev, int type, 
-    unsigned int key)
+static void usb_multimedia_push_ev(usb_hid_dev_t *hid_dev, 
+    usb_multimedia_t *multim_dev, int type, unsigned int key)
 {
         assert(hid_dev != NULL);
-        assert(hid_dev->data != NULL);
-        
-        usb_lgtch_ultrax_t *lgtch_dev = (usb_lgtch_ultrax_t *)hid_dev->data;
+        assert(multim_dev != NULL);
+        
+//      usb_multimedia_t *multim_dev = (usb_multimedia_t *)hid_dev->data;
         
         console_event_t ev;
@@ -193 +149 @@
         ev.key = key;
         ev.mods = 0;
-
         ev.c = 0;
 
         usb_log_debug2(NAME " Sending key %d to the console\n", ev.key);
-        if (lgtch_dev->console_phone < 0) {
+        if (multim_dev->console_phone < 0) {
                 usb_log_warning(
                     "Connection to console not ready, key discarded.\n");
@@ -203 +158 @@
         }
         
-        async_msg_4(lgtch_dev->console_phone, KBD_EVENT, ev.type, ev.key, 
+        async_msg_4(multim_dev->console_phone, KBD_EVENT, ev.type, ev.key, 
             ev.mods, ev.c);
 }
@@ -209 +164 @@
 /*----------------------------------------------------------------------------*/
 
-static void usb_lgtch_free(usb_lgtch_ultrax_t **lgtch_dev)
-{
-        if (lgtch_dev == NULL || *lgtch_dev == NULL) {
+static void usb_multimedia_free(usb_multimedia_t **multim_dev)
+{
+        if (multim_dev == NULL || *multim_dev == NULL) {
                 return;
         }
         
         // hangup phone to the console
-        async_hangup((*lgtch_dev)->console_phone);
-        
-//      if ((*lgtch_dev)->repeat_mtx != NULL) {
-//              /* TODO: replace by some check and wait */
-//              assert(!fibril_mutex_is_locked((*lgtch_dev)->repeat_mtx));
-//              free((*lgtch_dev)->repeat_mtx);
-//      }
+        async_hangup((*multim_dev)->console_phone);
         
         // free all buffers
-        if ((*lgtch_dev)->keys != NULL) {
-                free((*lgtch_dev)->keys);
-        }
-        if ((*lgtch_dev)->keys_old != NULL) {
-                free((*lgtch_dev)->keys_old);
-        }
-
-        free(*lgtch_dev);
-        *lgtch_dev = NULL;
-}
-
-/*----------------------------------------------------------------------------*/
-
-static int usb_lgtch_create_function(usb_hid_dev_t *hid_dev)
+        if ((*multim_dev)->keys != NULL) {
+                free((*multim_dev)->keys);
+        }
+        if ((*multim_dev)->keys_old != NULL) {
+                free((*multim_dev)->keys_old);
+        }
+
+        free(*multim_dev);
+        *multim_dev = NULL;
+}
+
+/*----------------------------------------------------------------------------*/
+
+static int usb_multimedia_create_function(usb_hid_dev_t *hid_dev, 
+    usb_multimedia_t *multim_dev)
 {
         /* Create the function exposed under /dev/devices. */
@@ -248 +198 @@
         }
         
-        /*
-         * Store the initialized HID device and HID ops
-         * to the DDF function.
-         */
-        fun->ops = &lgtch_ultrax_ops;
-        fun->driver_data = hid_dev;   // TODO: maybe change to hid_dev->data
+        fun->ops = &multimedia_ops;
+        fun->driver_data = multim_dev;   // TODO: maybe change to hid_dev->data
         
         int rc = ddf_fun_bind(fun);
@@ -279 +225 @@
 /*----------------------------------------------------------------------------*/
 
-int usb_lgtch_init(struct usb_hid_dev *hid_dev)
+int usb_multimedia_init(struct usb_hid_dev *hid_dev, void **data)
 {
         if (hid_dev == NULL || hid_dev->usb_dev == NULL) {
@@ -285 +231 @@
         }
         
-        usb_log_debug(NAME " Initializing HID/lgtch_ultrax structure...\n");
-        
-        usb_lgtch_ultrax_t *lgtch_dev = (usb_lgtch_ultrax_t *)malloc(
-            sizeof(usb_lgtch_ultrax_t));
-        if (lgtch_dev == NULL) {
+        usb_log_debug(NAME " Initializing HID/multimedia structure...\n");
+        
+        usb_multimedia_t *multim_dev = (usb_multimedia_t *)malloc(
+            sizeof(usb_multimedia_t));
+        if (multim_dev == NULL) {
                 return ENOMEM;
         }
         
-        lgtch_dev->console_phone = -1;
+        multim_dev->console_phone = -1;
         
         usb_hid_report_path_t *path = usb_hid_report_path();
@@ -300 +246 @@
         usb_hid_report_path_set_report_id(path, 1);
         
-        lgtch_dev->key_count = usb_hid_report_input_length(
-            hid_dev->report, path, 
-            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
+        multim_dev->key_count = usb_hid_report_size(
+            hid_dev->report, 0, USB_HID_REPORT_TYPE_INPUT);
+
         usb_hid_report_path_free(path);
         
         usb_log_debug(NAME " Size of the input report: %zu\n", 
-            lgtch_dev->key_count);
-        
-        lgtch_dev->keys = (int32_t *)calloc(lgtch_dev->key_count, 
+            multim_dev->key_count);
+        
+        multim_dev->keys = (int32_t *)calloc(multim_dev->key_count, 
             sizeof(int32_t));
         
-        if (lgtch_dev->keys == NULL) {
+        if (multim_dev->keys == NULL) {
                 usb_log_fatal("No memory!\n");
-                free(lgtch_dev);
+                free(multim_dev);
                 return ENOMEM;
         }
         
-        lgtch_dev->keys_old = 
-                (int32_t *)calloc(lgtch_dev->key_count, sizeof(int32_t));
-        
-        if (lgtch_dev->keys_old == NULL) {
+        multim_dev->keys_old = 
+                (int32_t *)calloc(multim_dev->key_count, sizeof(int32_t));
+        
+        if (multim_dev->keys_old == NULL) {
                 usb_log_fatal("No memory!\n");
-                free(lgtch_dev->keys);
-                free(lgtch_dev);
+                free(multim_dev->keys);
+                free(multim_dev);
                 return ENOMEM;
         }
@@ -330 +276 @@
         
         // save the KBD device structure into the HID device structure
-        hid_dev->data = lgtch_dev;
-        
-        lgtch_dev->initialized = USB_LGTCH_STATUS_INITIALIZED;
-        usb_log_debug(NAME " HID/lgtch_ultrax device structure initialized.\n");
-        
-        int rc = usb_lgtch_create_function(hid_dev);
+        *data = multim_dev;
+        
+        usb_log_debug(NAME " HID/multimedia device structure initialized.\n");
+        
+        int rc = usb_multimedia_create_function(hid_dev, multim_dev);
         if (rc != EOK) {
-                usb_lgtch_free(&lgtch_dev);
+                usb_multimedia_free(&multim_dev);
                 return rc;
         }
         
-        usb_log_debug(NAME " HID/lgtch_ultrax structure initialized.\n");
+        usb_log_debug(NAME " HID/multimedia structure initialized.\n");
         
         return EOK;
@@ -348 +293 @@
 /*----------------------------------------------------------------------------*/
 
-void usb_lgtch_deinit(struct usb_hid_dev *hid_dev)
+void usb_multimedia_deinit(struct usb_hid_dev *hid_dev, void *data)
 {
         if (hid_dev == NULL) {
@@ -354 +299 @@
         }
         
-        if (hid_dev->data != NULL) {
-                usb_lgtch_ultrax_t *lgtch_dev = 
-                    (usb_lgtch_ultrax_t *)hid_dev->data;
-//              if (usb_kbd_is_initialized(kbd_dev)) {
-//                      usb_kbd_mark_unusable(kbd_dev);
-//              } else {
-                        usb_lgtch_free(&lgtch_dev);
-                        hid_dev->data = NULL;
-//              }
-        }
-}
-
-/*----------------------------------------------------------------------------*/
-
-bool usb_lgtch_polling_callback(struct usb_hid_dev *hid_dev, 
+        if (data != NULL) {
+                usb_multimedia_t *multim_dev = (usb_multimedia_t *)data;
+                usb_multimedia_free(&multim_dev);
+        }
+}
+
+/*----------------------------------------------------------------------------*/
+
+bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data, 
     uint8_t *buffer, size_t buffer_size)
 {
@@ -375 +314 @@
         usb_log_debug(NAME " usb_lgtch_polling_callback(%p, %p, %zu)\n",
             hid_dev, buffer, buffer_size);
+        
+        if (data == NULL) {
+                return EINVAL;  // TODO: other error code?
+        }
+        
+        usb_multimedia_t *multim_dev = (usb_multimedia_t *)data;
 
         usb_log_debug(NAME " Calling usb_hid_parse_report() with "
@@ -380 +325 @@
         
         usb_hid_report_path_t *path = usb_hid_report_path();
-        usb_hid_report_path_append_item(path, 0xc, 0);
+        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_CONSUMER, 0);
 
         uint8_t report_id;
@@ -400 +345 @@
             USB_HID_REPORT_TYPE_INPUT);
         
-        unsigned int key;
+//      unsigned int key;
         
         /*! @todo Is this iterating OK if done multiple times? 
@@ -406 +351 @@
          */
         while (field != NULL) {
-                usb_log_debug(NAME " KEY VALUE(%X) USAGE(%X)\n", field->value, 
-                    field->usage);
-                
-                key = usb_lgtch_map_usage(field->usage);
-                usb_lgtch_push_ev(hid_dev, KEY_PRESS, key);
+                if(field->value != 0) {
+                        usb_log_debug(NAME " KEY VALUE(%X) USAGE(%X)\n", 
+                            field->value, field->usage);
+                        unsigned int key = 
+                            usb_multimedia_map_usage(field->usage);
+                        const char *key_str = 
+                            usb_multimedia_usage_to_str(field->usage);
+                        usb_log_info("Pressed key: %s\n", key_str);
+                        usb_multimedia_push_ev(hid_dev, multim_dev, KEY_PRESS, 
+                                               key);
+                }
                 
                 field = usb_hid_report_get_sibling(

uspace/drv/usbhid/multimedia/multimedia.h

@@ -31 +31 @@
  */
 /** @file
- * USB Logitech UltraX Keyboard sample driver.
+ * USB Keyboard multimedia keys subdriver.
  */
 
-#ifndef USB_HID_LGTCH_ULTRAX_H_
-#define USB_HID_LGTCH_ULTRAX_H_
+#ifndef USB_HID_MULTIMEDIA_H_
+#define USB_HID_MULTIMEDIA_H_
 
-#include <usb/devdrv.h>
+#include <usb/dev/driver.h>
 
 struct usb_hid_dev;
@@ -43 +43 @@
 /*----------------------------------------------------------------------------*/
 
-int usb_lgtch_init(struct usb_hid_dev *hid_dev);
+int usb_multimedia_init(struct usb_hid_dev *hid_dev, void **data);
 
-void usb_lgtch_deinit(struct usb_hid_dev *hid_dev);
+void usb_multimedia_deinit(struct usb_hid_dev *hid_dev, void *data);
 
-bool usb_lgtch_polling_callback(struct usb_hid_dev *hid_dev, uint8_t *buffer,
-    size_t buffer_size);
+bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data,
+    uint8_t *buffer, size_t buffer_size);
 
 /*----------------------------------------------------------------------------*/
 
-#endif // USB_HID_LGTCH_ULTRAX_H_
+#endif // USB_HID_MULTIMEDIA_H_
 
 /**

uspace/drv/usbhid/subdrivers.c

@@ -35 +35 @@
 
 #include "subdrivers.h"
-#include "usb/classes/hidut.h"
-#include "usb/classes/hidpath.h"
+#include <usb/hid/usages/core.h>
+#include <usb/hid/hidpath.h>
 
-#include "lgtch-ultrax/lgtch-ultrax.h"
+//#include "lgtch-ultrax/lgtch-ultrax.h"
+#include "multimedia/multimedia.h"
 #include "mouse/mousedev.h"
 
 static usb_hid_subdriver_usage_t path_kbd[] = {
-        {USB_HIDUT_PAGE_KEYBOARD, 0}, 
+        {USB_HIDUT_PAGE_GENERIC_DESKTOP, 
+         USB_HIDUT_USAGE_GENERIC_DESKTOP_KEYBOARD}, 
         {0, 0}
 };
 
-static usb_hid_subdriver_usage_t path_mouse2[] = {
-        {USB_HIDUT_PAGE_GENERIC_DESKTOP, USB_HIDUT_USAGE_GENERIC_DESKTOP_X},
+static usb_hid_subdriver_usage_t path_mouse[] = {
+        {USB_HIDUT_PAGE_GENERIC_DESKTOP, USB_HIDUT_USAGE_GENERIC_DESKTOP_MOUSE},
         {0, 0}
 };
 
-static usb_hid_subdriver_usage_t lgtch_path[] = {
-        {0xc, 0},
+static usb_hid_subdriver_usage_t multim_key_path[] = {
+        {USB_HIDUT_PAGE_CONSUMER, USB_HIDUT_USAGE_CONSUMER_CONSUMER_CONTROL},
         {0, 0}
 };
@@ -60 +62 @@
                 path_kbd,
                 -1,
-                USB_HID_PATH_COMPARE_END 
-                | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
+                USB_HID_PATH_COMPARE_BEGIN,
                 -1,
                 -1,
@@ -73 +74 @@
         },
         {
-                lgtch_path,
+                multim_key_path,
                 1,
-                USB_HID_PATH_COMPARE_END 
-                | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
-                0x046d,
-                0xc30e,
+                USB_HID_PATH_COMPARE_BEGIN,
+                -1,
+                -1,
                 {
-                        .init = usb_lgtch_init,
-                        .deinit = usb_lgtch_deinit,
-                        .poll = usb_lgtch_polling_callback,
+                        .init = usb_multimedia_init,
+                        .deinit = usb_multimedia_deinit,
+                        .poll = usb_multimedia_polling_callback,
                         .poll_end = NULL
                 }
         },
         {
-                path_mouse2,
+                path_mouse,
                 -1,
-                USB_HID_PATH_COMPARE_END 
-                | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
+                USB_HID_PATH_COMPARE_BEGIN,
                 -1,
                 -1,
@@ -100 +99 @@
                 }
         },
-        {NULL, -1, 0, -1, -1, {NULL, NULL, NULL, NULL}}
+        {NULL, -1, 0, -1, -1, {NULL, NULL, NULL, NULL, NULL}}
 };
 

uspace/drv/usbhid/usbhid.c

@@ -37 +37 @@
 #include <usb/debug.h>
 #include <usb/classes/classes.h>
-#include <usb/classes/hid.h>
-#include <usb/classes/hidparser.h>
-#include <usb/classes/hidreport.h>
-#include <usb/classes/hidreq.h>
+#include <usb/hid/hid.h>
+#include <usb/hid/hidparser.h>
+#include <usb/hid/hidreport.h>
+#include <usb/hid/request.h>
 #include <errno.h>
 #include <str_error.h>
@@ -203 +203 @@
         
         usb_log_debug("Compare flags: %d\n", mapping->compare);
-        size_t size = usb_hid_report_input_length(hid_dev->report, usage_path, 
-            mapping->compare);
+//      size_t size = usb_hid_report_size(hid_dev->report, 0, 
+//          USB_HID_REPORT_TYPE_INPUT);
+        size_t size = 0;
+        usb_hid_report_field_t *field = usb_hid_report_get_sibling (hid_dev->report,
+                NULL, usage_path, mapping->compare, USB_HID_REPORT_TYPE_INPUT);
+        while(field != NULL) {
+                size++;
+                field = usb_hid_report_get_sibling (hid_dev->report,
+                                        field, usage_path, mapping->compare, 
+                            USB_HID_REPORT_TYPE_INPUT);
+        }
+        
         usb_log_debug("Size of the input report: %zuB\n", size);
-        
         usb_hid_report_path_free(usage_path);
         
@@ -457 +466 @@
                         if (hid_dev->subdrivers[i].init != NULL) {
                                 usb_log_debug("Initializing subdriver %d.\n",i);
-                                rc = hid_dev->subdrivers[i].init(hid_dev);
+                                rc = hid_dev->subdrivers[i].init(hid_dev,
+                                    &hid_dev->subdrivers[i].data);
                                 if (rc != EOK) {
                                         usb_log_warning("Failed to initialize"
@@ -522 +532 @@
         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)) {
+                    && hid_dev->subdrivers[i].poll(hid_dev, 
+                        hid_dev->subdrivers[i].data, buffer, buffer_size)) {
                         cont = true;
                 }
@@ -546 +556 @@
         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);
+                        hid_dev->subdrivers[i].poll_end(hid_dev,
+                            hid_dev->subdrivers[i].data, reason);
                 }
         }
@@ -627 +638 @@
         for (i = 0; i < (*hid_dev)->subdriver_count; ++i) {
                 if ((*hid_dev)->subdrivers[i].deinit != NULL) {
-                        (*hid_dev)->subdrivers[i].deinit(*hid_dev);
+                        (*hid_dev)->subdrivers[i].deinit(*hid_dev,
+                            (*hid_dev)->subdrivers[i].data);
                 }
         }

uspace/drv/usbhid/usbhid.h

@@ -39 +39 @@
 #include <stdint.h>
 
-#include <usb/classes/hidparser.h>
+#include <usb/hid/hidparser.h>
 #include <ddf/driver.h>
-#include <usb/pipes.h>
-#include <usb/devdrv.h>
-#include <usb/classes/hid.h>
+#include <usb/dev/pipes.h>
+#include <usb/dev/driver.h>
+#include <usb/hid/hid.h>
 #include <bool.h>
 
 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);
+typedef int (*usb_hid_driver_init_t)(struct usb_hid_dev *, void **data);
+typedef void (*usb_hid_driver_deinit_t)(struct usb_hid_dev *, void *data);
+typedef bool (*usb_hid_driver_poll)(struct usb_hid_dev *, void *data, uint8_t *,
+                                    size_t);
+typedef int (*usb_hid_driver_poll_ended)(struct usb_hid_dev *, void *data, 
+                                         bool reason);
 
 // TODO: add function and class name??
@@ -63 +65 @@
         /** Function to be called when polling ends. */
         usb_hid_driver_poll_ended poll_end;
+        /** Arbitrary data needed by the subdriver. */
+        void *data;
 } usb_hid_subdriver_t;
 
@@ -72 +76 @@
         /** Structure holding generic USB device information. */
         usb_device_t *usb_dev;
-        
-        /** @todo What is this actually? */
-        ddf_dev_ops_t ops;
         
         /** Index of the polling pipe in usb_hid_endpoints array. */
@@ -97 +98 @@
         
         size_t input_report_size;
-        
-        /** Arbitrary data (e.g. a special structure for handling keyboard). */
-        void *data;
 } usb_hid_dev_t;
 

uspace/drv/usbhub/main.c

@@ -36 +36 @@
 #include <stdio.h>
 
-#include <usb/devdrv.h>
+#include <usb/dev/driver.h>
 #include <usb/classes/classes.h>
 

uspace/drv/usbhub/port_status.h

@@ -35 +35 @@
 #include <bool.h>
 #include <sys/types.h>
-#include <usb/request.h>
+#include <usb/dev/request.h>
 #include "usbhub_private.h"
 

uspace/drv/usbhub/ports.h

@@ -36 +36 @@
 #define DRV_USBHUB_PORTS_H
 
-#include <usb/devdrv.h>
-#include <usb/hub.h>
+#include <usb/dev/driver.h>
+#include <usb/dev/hub.h>
 
 typedef struct usb_hub_info_t usb_hub_info_t;

uspace/drv/usbhub/usbhub.c

@@ -42 +42 @@
 #include <usb/ddfiface.h>
 #include <usb/descriptor.h>
-#include <usb/recognise.h>
-#include <usb/request.h>
+#include <usb/dev/recognise.h>
+#include <usb/dev/request.h>
 #include <usb/classes/hub.h>
-#include <usb/devpoll.h>
+#include <usb/dev/poll.h>
 #include <stdio.h>
 
@@ -51 +51 @@
 #include "usbhub_private.h"
 #include "port_status.h"
-#include "usb/usb.h"
-#include "usb/pipes.h"
-#include "usb/classes/classes.h"
+#include <usb/usb.h>
+#include <usb/dev/pipes.h>
+#include <usb/classes/classes.h>
 
 

uspace/drv/usbhub/usbhub.h

@@ -39 +39 @@
 #include <ddf/driver.h>
 
-#include <usb/hub.h>
+#include <usb/dev/hub.h>
 #include <usb/classes/hub.h>
 
-#include <usb/pipes.h>
-#include <usb/devdrv.h>
+#include <usb/dev/pipes.h>
+#include <usb/dev/driver.h>
 
 #include <fibril_synch.h>

uspace/drv/usbhub/usbhub_private.h

@@ -47 +47 @@
 #include <usb/usb.h>
 #include <usb/debug.h>
-#include <usb/request.h>
+#include <usb/dev/request.h>
 
 //************

uspace/drv/usbmast/inquiry.c

@@ -34 +34 @@
  * Main routines of USB mass storage driver.
  */
-#include <usb/devdrv.h>
+#include <usb/dev/driver.h>
 #include <usb/debug.h>
 #include <usb/classes/classes.h>

uspace/drv/usbmast/main.c

@@ -34 +34 @@
  * Main routines of USB mass storage driver.
  */
-#include <usb/devdrv.h>
+#include <usb/dev/driver.h>
 #include <usb/debug.h>
 #include <usb/classes/classes.h>

uspace/drv/usbmast/mast.c

@@ -40 +40 @@
 #include <str_error.h>
 #include <usb/debug.h>
-#include <usb/request.h>
+#include <usb/dev/request.h>
 
 bool usb_mast_verbose = true;

uspace/drv/usbmast/mast.h

@@ -39 +39 @@
 #include <sys/types.h>
 #include <usb/usb.h>
-#include <usb/pipes.h>
-#include <usb/devdrv.h>
+#include <usb/dev/pipes.h>
+#include <usb/dev/driver.h>
 
 /** Result of SCSI INQUIRY command.

uspace/drv/usbmid/dump.c

@@ -37 +37 @@
 #include <str_error.h>
 #include <stdlib.h>
-#include <usb/pipes.h>
-#include <usb/dp.h>
+#include <usb/dev/pipes.h>
+#include <usb/dev/dp.h>
 #include <usb/classes/classes.h>
 #include "usbmid.h"

uspace/drv/usbmid/explore.c

@@ -38 +38 @@
 #include <stdlib.h>
 #include <usb/classes/classes.h>
-#include <usb/request.h>
-#include <usb/dp.h>
+#include <usb/dev/request.h>
+#include <usb/dev/dp.h>
 #include <usb/ddfiface.h>
 #include "usbmid.h"

uspace/drv/usbmid/main.c

@@ -38 +38 @@
 #include <usb/debug.h>
 #include <usb/classes/classes.h>
-#include <usb/request.h>
+#include <usb/dev/request.h>
 #include <usb/descriptor.h>
-#include <usb/pipes.h>
+#include <usb/dev/pipes.h>
 
 #include "usbmid.h"

uspace/drv/usbmid/usbmid.c

@@ -39 +39 @@
 #include <usb_iface.h>
 #include <usb/ddfiface.h>
-#include <usb/pipes.h>
+#include <usb/dev/pipes.h>
 #include <usb/classes/classes.h>
-#include <usb/recognise.h>
+#include <usb/dev/recognise.h>
 #include "usbmid.h"
 

uspace/drv/usbmid/usbmid.h

@@ -40 +40 @@
 #include <ddf/driver.h>
 #include <usb/usb.h>
-#include <usb/pipes.h>
+#include <usb/dev/pipes.h>
 #include <usb/debug.h>
-#include <usb/devdrv.h>
+#include <usb/dev/driver.h>
 
 #define NAME "usbmid"

uspace/drv/usbmouse/init.c

@@ -37 +37 @@
 #include <usb/debug.h>
 #include <usb/classes/classes.h>
-#include <usb/classes/hid.h>
-#include <usb/request.h>
+#include <usb/hid/hid.h>
+#include <usb/dev/request.h>
 #include <errno.h>
 

uspace/drv/usbmouse/main.c

@@ -36 +36 @@
 #include "mouse.h"
 #include <usb/debug.h>
-#include <usb/devpoll.h>
+#include <usb/dev/poll.h>
 #include <errno.h>
 #include <str_error.h>

uspace/drv/usbmouse/mouse.h

@@ -37 +37 @@
 #define USBMOUSE_MOUSE_H_
 
-#include <usb/devdrv.h>
-#include <usb/pipes.h>
+#include <usb/dev/driver.h>
+#include <usb/dev/pipes.h>
 #include <time.h>
 

uspace/drv/vhc/connhost.c

@@ -36 +36 @@
 #include <errno.h>
 #include <usb/usb.h>
-#include <usb/addrkeep.h>
 #include <usb/ddfiface.h>
 #include <usb/debug.h>

uspace/drv/vhc/hub.c

@@ -40 +40 @@
 #include <ddf/driver.h>
 #include <devman.h>
-#include <usb/hub.h>
-#include <usb/recognise.h>
+#include <usb/dev/hub.h>
+#include <usb/dev/recognise.h>
 
 #include "hub.h"