Changeset 1d1bb0f in mainline

Timestamp:

2011-06-19T13:38:37Z (13 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

b72efe8

Parents:

adfdbd5 (diff), 9724d7f (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:

Merge from ​https://code.launchpad.net/~vojtech-horky/helenos/usb

Files:

• boot/arch/amd64/Makefile.inc (modified) (1 diff)
• uspace/Makefile (modified) (1 diff)
• uspace/app/mkbd/main.c (modified) (3 diffs)
• uspace/app/usbinfo/Makefile (modified) (3 diffs)
• uspace/app/usbinfo/hid.c (added)
• uspace/app/usbinfo/main.c (modified) (4 diffs)
• uspace/app/usbinfo/usbinfo.h (modified) (1 diff)
• uspace/app/vuhid/Makefile (modified) (1 diff)
• uspace/drv/ehci/Makefile (moved) (moved from uspace/drv/ehci_hcd/Makefile ) (1 diff)
• uspace/drv/ehci/ehci.h (moved) (moved from uspace/drv/ehci_hcd/ehci.h ) (1 diff)
• uspace/drv/ehci/ehci.ma (moved) (moved from uspace/drv/ehci_hcd/ehci_hcd.ma )
• uspace/drv/ehci/hc_iface.c (moved) (moved from uspace/drv/ehci_hcd/hc_iface.c ) (1 diff)
• uspace/drv/ehci/main.c (moved) (moved from uspace/drv/ehci_hcd/main.c )
• uspace/drv/ehci/pci.c (moved) (moved from uspace/drv/ehci_hcd/pci.c )
• uspace/drv/ehci/pci.h (moved) (moved from uspace/drv/ehci_hcd/pci.h )
• uspace/drv/ohci/hc.c (modified) (3 diffs)
• uspace/drv/ohci/root_hub.c (modified) (14 diffs)
• uspace/drv/uhci/Makefile (moved) (moved from uspace/drv/uhci_hcd/Makefile ) (1 diff)
• uspace/drv/uhci/batch.c (moved) (moved from uspace/drv/uhci_hcd/batch.c ) (9 diffs)
• uspace/drv/uhci/batch.h (moved) (moved from uspace/drv/uhci_hcd/batch.h )
• uspace/drv/uhci/hc.c (moved) (moved from uspace/drv/uhci_hcd/hc.c )
• uspace/drv/uhci/hc.h (moved) (moved from uspace/drv/uhci_hcd/hc.h )
• uspace/drv/uhci/hw_struct/link_pointer.h (moved) (moved from uspace/drv/uhci_hcd/hw_struct/link_pointer.h )
• uspace/drv/uhci/hw_struct/queue_head.h (moved) (moved from uspace/drv/uhci_hcd/hw_struct/queue_head.h )
• uspace/drv/uhci/hw_struct/transfer_descriptor.c (moved) (moved from uspace/drv/uhci_hcd/hw_struct/transfer_descriptor.c ) (1 diff)
• uspace/drv/uhci/hw_struct/transfer_descriptor.h (moved) (moved from uspace/drv/uhci_hcd/hw_struct/transfer_descriptor.h )
• uspace/drv/uhci/iface.c (moved) (moved from uspace/drv/uhci_hcd/iface.c ) (3 diffs)
• uspace/drv/uhci/iface.h (moved) (moved from uspace/drv/uhci_hcd/iface.h )
• uspace/drv/uhci/main.c (moved) (moved from uspace/drv/uhci_hcd/main.c ) (1 diff)
• uspace/drv/uhci/pci.c (moved) (moved from uspace/drv/uhci_hcd/pci.c )
• uspace/drv/uhci/pci.h (moved) (moved from uspace/drv/uhci_hcd/pci.h )
• uspace/drv/uhci/root_hub.c (moved) (moved from uspace/drv/uhci_hcd/root_hub.c )
• uspace/drv/uhci/root_hub.h (moved) (moved from uspace/drv/uhci_hcd/root_hub.h )
• uspace/drv/uhci/transfer_list.c (moved) (moved from uspace/drv/uhci_hcd/transfer_list.c ) (2 diffs)
• uspace/drv/uhci/transfer_list.h (moved) (moved from uspace/drv/uhci_hcd/transfer_list.h )
• uspace/drv/uhci/uhci.c (moved) (moved from uspace/drv/uhci_hcd/uhci.c )
• uspace/drv/uhci/uhci.h (moved) (moved from uspace/drv/uhci_hcd/uhci.h )
• uspace/drv/uhci/uhci.ma (moved) (moved from uspace/drv/uhci_hcd/uhci_hcd.ma )
• uspace/drv/uhci/utils/malloc32.h (moved) (moved from uspace/drv/uhci_hcd/utils/malloc32.h )
• uspace/drv/uhcirh/Makefile (moved) (moved from uspace/drv/uhci_rhd/Makefile ) (1 diff)
• uspace/drv/uhcirh/main.c (moved) (moved from uspace/drv/uhci_rhd/main.c ) (1 diff)
• uspace/drv/uhcirh/port.c (moved) (moved from uspace/drv/uhci_rhd/port.c )
• uspace/drv/uhcirh/port.h (moved) (moved from uspace/drv/uhci_rhd/port.h )
• uspace/drv/uhcirh/root_hub.c (moved) (moved from uspace/drv/uhci_rhd/root_hub.c )
• uspace/drv/uhcirh/root_hub.h (moved) (moved from uspace/drv/uhci_rhd/root_hub.h )
• uspace/drv/uhcirh/uhcirh.ma (moved) (moved from uspace/drv/uhci_rhd/uhci_rhd.ma )
• uspace/drv/usbhid/Makefile (modified) (1 diff)
• uspace/drv/usbhid/generic/hiddev.c (modified) (1 diff)
• uspace/drv/usbhid/generic/hiddev.h (modified) (1 diff)
• uspace/drv/usbhid/kbd/kbddev.c (modified) (9 diffs)
• uspace/drv/usbhid/kbd/kbddev.h (modified) (1 diff)
• uspace/drv/usbhid/kbd/kbdrepeat.c (modified) (2 diffs)
• uspace/drv/usbhid/kbd/main.c (deleted)
• uspace/drv/usbhid/mouse/mousedev.c (modified) (6 diffs)
• uspace/drv/usbhid/mouse/mousedev.h (modified) (1 diff)
• uspace/drv/usbhid/multimedia/multimedia.c (modified) (2 diffs)
• uspace/drv/usbhid/multimedia/multimedia.h (modified) (1 diff)
• uspace/drv/usbhid/subdrivers.h (modified) (1 diff)
• uspace/drv/usbhid/usbhid.c (modified) (3 diffs)
• uspace/drv/usbhid/usbhid.h (modified) (5 diffs)
• uspace/drv/usbhub/ports.c (modified) (1 diff)
• uspace/lib/c/generic/str.c (modified) (1 diff)
• uspace/lib/drv/Makefile (modified) (1 diff)
• uspace/lib/drv/generic/logbuf.c (added)
• uspace/lib/drv/include/ddf/log.h (modified) (1 diff)
• uspace/lib/usb/include/usb/usb.h (modified) (1 diff)
• uspace/lib/usb/src/debug.c (modified) (3 diffs)
• uspace/lib/usb/src/hc.c (modified) (3 diffs)
• uspace/lib/usb/src/usb.c (modified) (2 diffs)
• uspace/lib/usbdev/src/pipes.c (modified) (2 diffs)
• uspace/lib/usbhid/src/hidreq.c (modified) (12 diffs)
• uspace/lib/usbhost/include/usb/host/batch.h (modified) (1 diff)
• uspace/lib/usbhost/src/batch.c (modified) (3 diffs)

boot/arch/amd64/Makefile.inc

@@ -43 +43 @@
         isa \
         ns8250 \
-        ehci_hcd \
+        ehci\
         ohci \
-        uhci_hcd \
-        uhci_rhd \
+        uhci \
+        uhcirh \
         usbflbk \
         usbhub \

uspace/Makefile

@@ -101 +101 @@
         drv/test2 \
         drv/test3 \
-        drv/ehci_hcd \
+        drv/ehci \
         drv/ohci \
-        drv/uhci_hcd \
-        drv/uhci_rhd \
+        drv/uhci \
+        drv/uhcirh \
         drv/usbflbk \
         drv/usbhid \

uspace/app/mkbd/main.c

@@ -52 +52 @@
 #include <usb/hid/hiddescriptor.h>
 #include <usb/hid/usages/consumer.h>
+#include <io/console.h>
+#include <io/keycode.h>
 #include <assert.h>
 
@@ -166 +168 @@
         
         usb_hid_report_path_free(path);
+}
+
+static int wait_for_quit_fibril(void *arg)
+{
+        console_ctrl_t *con = console_init(stdin, stdout);
+
+        printf("Press <ESC> to quit the application.\n");
+
+        while (1) {
+                kbd_event_t ev;
+                bool ok = console_get_kbd_event(con, &ev);
+                if (!ok) {
+                        printf("Connection with console broken: %s.\n",
+                            str_error(errno));
+                        break;
+                }
+
+                if (ev.key == KC_ESCAPE) {
+                        break;
+                }
+        }
+
+        console_done(con);
+
+        exit(0);
+
+        return EOK;
 }
 
@@ -242 +271 @@
         }
         
+        fid_t quit_fibril = fibril_create(wait_for_quit_fibril, NULL);
+        if (quit_fibril == 0) {
+                printf("Failed to start extra fibril.\n");
+                return -1;
+        }
+        fibril_add_ready(quit_fibril);
+
         size_t actual_size;
         int event_nr;
-        
+
         while (true) {
                 /** @todo Try blocking call. */

uspace/app/usbinfo/Makefile

@@ -31 +31 @@
 
 LIBS = \
+        $(LIBUSBHID_PREFIX)/libusbhid.a \
         $(LIBUSBDEV_PREFIX)/libusbdev.a \
         $(LIBUSB_PREFIX)/libusb.a \
@@ -37 +38 @@
         -I$(LIBUSB_PREFIX)/include \
         -I$(LIBUSBDEV_PREFIX)/include \
+        -I$(LIBUSBHID_PREFIX)/include \
         -I$(LIBDRV_PREFIX)/include
 
@@ -43 +45 @@
         dev.c \
         dump.c \
+        hid.c \
         info.c \
         main.c

uspace/app/usbinfo/main.c

@@ -56 +56 @@
         printf("Usage: %s [options] device [device [device [ ... ]]]\n",
             app_name);
-        printf(_INDENT "The device is a devman path to the device.\n");
+        printf(_INDENT "The device can be specified in two ways.\n");
+        printf(_INDENT "  o Using its devman path, e.g. /hw/pci0/.../usb00_a1.\n");
+        printf(_INDENT "  o Or using BUS.ADDR numbers as printed by lsusb.\n");
 
         _OPTION("-h --help", "Print this help and exit.");
@@ -65 +67 @@
         _OPTION("-s --strings", "Try to print all string descriptors.");
         _OPTION("-S --status", "Get status of the device.");
+        _OPTION("-r --hid-report", "Dump HID report descriptor.");
+        _OPTION("-r --hid-report-usages", "Dump usages of HID report.");
 
         printf("\n");
@@ -82 +86 @@
         {"strings", no_argument, NULL, 's'},
         {"status", no_argument, NULL, 'S'},
+        {"hid-report", no_argument, NULL, 'r'},
+        {"hid-report-usages", no_argument, NULL, 'R'},
         {0, 0, NULL, 0}
 };
-static const char *short_options = "himtTsS";
+static const char *short_options = "himtTsSrR";
 
 static usbinfo_action_t actions[] = {
@@ -115 +121 @@
                 .opt = 'S',
                 .action = dump_status,
+                .active = false
+        },
+        {
+                .opt = 'r',
+                .action = dump_hidreport_raw,
+                .active = false
+        },
+        {
+                .opt = 'R',
+                .action = dump_hidreport_usages,
                 .active = false
         },

uspace/app/usbinfo/usbinfo.h

@@ -85 +85 @@
 void dump_strings(usbinfo_device_t *);
 void dump_status(usbinfo_device_t *);
+void dump_hidreport_raw(usbinfo_device_t *);
+void dump_hidreport_usages(usbinfo_device_t *);
 
 

uspace/app/vuhid/Makefile

@@ -36 +36 @@
         $(LIBUSBHID_PREFIX)/libusbhid.a \
         $(LIBUSBDEV_PREFIX)/libusbdev.a \
-        $(LIBUSB_PREFIX)/libusb.a
+        $(LIBUSB_PREFIX)/libusb.a \
+        $(LIBDRV_PREFIX)/libdrv.a
 EXTRA_CFLAGS = \
         -I$(LIBUSB_PREFIX)/include \

uspace/drv/ehci/Makefile

@@ -38 +38 @@
         -I$(LIBDRV_PREFIX)/include
 
-BINARY = ehci_hcd
+BINARY = ehci
 
 SOURCES = \

uspace/drv/ehci/ehci.h

@@ -38 +38 @@
 #include <usbhc_iface.h>
 
-#define NAME "ehci_hcd"
+#define NAME "ehci"
 
 extern usbhc_iface_t ehci_hc_iface;

uspace/drv/ehci/hc_iface.c

@@ -45 +45 @@
 
 #define UNSUPPORTED(methodname) \
-        usb_log_warning("Unsupported interface method `%s()' in %s:%d.\n", \
+        usb_log_debug("Client called unsupported interface method " \
+            "`%s()' in %s:%d.\n", \
             methodname, __FILE__, __LINE__)
 

uspace/drv/ohci/hc.c

@@ -65 +65 @@
             device_keeper_get_free_address(&instance->manager, USB_SPEED_FULL);
         if (hub_address <= 0) {
-                usb_log_error("Failed(%d) to get OHCI root hub address.\n",
-                    hub_address);
+                usb_log_error("Failed to get OHCI root hub address: %s\n",
+                    str_error(hub_address));
                 return hub_address;
         }
@@ -445 +445 @@
         /* HC is in reset (hw startup) => no other driver
          * maintain reset for at least the time specified in USB spec (50 ms)*/
-        usb_log_info("HC found in reset.\n");
+        usb_log_debug("Host controller found in reset state.\n");
         async_usleep(50000);
 }
@@ -516 +516 @@
 
         instance->registers->control &= (C_HCFS_OPERATIONAL << C_HCFS_SHIFT);
-        usb_log_info("OHCI HC up and running(%x).\n",
+        usb_log_debug("OHCI HC up and running (ctl_reg=0x%x).\n",
             instance->registers->control);
 }

uspace/drv/ohci/root_hub.c

@@ -232 +232 @@
                 return ENOMEM;
 
-        usb_log_info("OHCI root hub with %zu ports initialized.\n",
+        usb_log_info("Root hub (%zu ports) initialized.\n",
             instance->port_count);
 
@@ -251 +251 @@
         int opResult;
         if (request->ep->transfer_type == USB_TRANSFER_CONTROL) {
-                usb_log_info("Root hub got CONTROL packet\n");
+                usb_log_debug("Root hub got CONTROL packet\n");
                 opResult = process_ctrl_request(instance, request);
                 usb_transfer_batch_finish_error(request, opResult);
         } else if (request->ep->transfer_type == USB_TRANSFER_INTERRUPT) {
-                usb_log_info("Root hub got INTERRUPT packet\n");
+                usb_log_debug("Root hub got INTERRUPT packet\n");
                 create_interrupt_mask_in_instance(instance);
                 if (is_zeros(instance->interrupt_buffer,
@@ -521 +521 @@
                 case USB_DESCTYPE_HUB:
                 {
-                        usb_log_debug("USB_DESCTYPE_HUB\n");
+                        usb_log_debug2("USB_DESCTYPE_HUB\n");
                         result_descriptor = instance->hub_descriptor;
                         size = instance->descriptor_size;
@@ -528 +528 @@
                 case USB_DESCTYPE_DEVICE:
                 {
-                        usb_log_debug("USB_DESCTYPE_DEVICE\n");
+                        usb_log_debug2("USB_DESCTYPE_DEVICE\n");
                         result_descriptor = &ohci_rh_device_descriptor;
                         size = sizeof (ohci_rh_device_descriptor);
@@ -535 +535 @@
                 case USB_DESCTYPE_CONFIGURATION:
                 {
-                        usb_log_debug("USB_DESCTYPE_CONFIGURATION\n");
+                        usb_log_debug2("USB_DESCTYPE_CONFIGURATION\n");
                         result_descriptor = instance->descriptors.configuration;
                         size = instance->descriptors.configuration_size;
@@ -542 +542 @@
                 case USB_DESCTYPE_INTERFACE:
                 {
-                        usb_log_debug("USB_DESCTYPE_INTERFACE\n");
+                        usb_log_debug2("USB_DESCTYPE_INTERFACE\n");
                         result_descriptor = &ohci_rh_iface_descriptor;
                         size = sizeof (ohci_rh_iface_descriptor);
@@ -549 +549 @@
                 case USB_DESCTYPE_ENDPOINT:
                 {
-                        usb_log_debug("USB_DESCTYPE_ENDPOINT\n");
+                        usb_log_debug2("USB_DESCTYPE_ENDPOINT\n");
                         result_descriptor = &ohci_rh_ep_descriptor;
                         size = sizeof (ohci_rh_ep_descriptor);
@@ -556 +556 @@
                 default:
                 {
-                        usb_log_debug("USB_DESCTYPE_EINVAL %d \n",
+                        usb_log_debug2("USB_DESCTYPE_EINVAL %d \n",
                             setup_request->value);
-                        usb_log_debug("\ttype %d\n\trequest %d\n\tvalue "
+                        usb_log_debug2("\ttype %d\n\trequest %d\n\tvalue "
                             "%d\n\tindex %d\n\tlen %d\n ",
                             setup_request->request_type,
@@ -789 +789 @@
                 }
                 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE) {
-                        usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
+                        usb_log_debug2("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
                         return process_port_feature_clear_request(instance,
                             setup_request->value,
@@ -854 +854 @@
                 return EINVAL;
         }
-        usb_log_info("CTRL packet: %s.\n",
+        usb_log_debug("CTRL packet: %s.\n",
             usb_debug_str_buffer(
             (const uint8_t *) request->setup_buffer, 8, 8));
@@ -864 +864 @@
                 case USB_DEVREQ_GET_DESCRIPTOR:
                 case USB_DEVREQ_GET_CONFIGURATION:
-                        usb_log_debug("Processing request with output\n");
+                        usb_log_debug2("Processing request with output\n");
                         opResult = process_request_with_output(
                             instance, request);
@@ -871 +871 @@
                 case USB_DEVREQ_SET_FEATURE:
                 case USB_DEVREQ_SET_ADDRESS:
-                        usb_log_debug("Processing request without "
+                        usb_log_debug2("Processing request without "
                             "additional data\n");
                         opResult = process_request_without_data(
@@ -878 +878 @@
                 case USB_DEVREQ_SET_DESCRIPTOR:
                 case USB_DEVREQ_SET_CONFIGURATION:
-                        usb_log_debug("Processing request with "
-                            "input\n");
+                        usb_log_debug2("Processing request with input\n");
                         opResult = process_request_with_input(
                             instance, request);
@@ -885 +884 @@
                         break;
                 default:
-                        usb_log_warning("Received unsuported request: "
-                            "%d\n",
-                            setup_request->request
-                            );
+                        usb_log_warning("Received unsupported request: %d.\n",
+                            setup_request->request);
                         opResult = ENOTSUP;
         }

uspace/drv/uhci/Makefile

@@ -38 +38 @@
         -I$(LIBDRV_PREFIX)/include
 
-BINARY = uhci_hcd
+BINARY = uhci
 
 SOURCES = \

uspace/drv/uhci/batch.c

@@ -147 +147 @@
             + sizeof(qh_t);
         void *data_buffer = setup + setup_size;
-        usb_target_t target =
-            { .address = ep->address, .endpoint = ep->endpoint };
         usb_transfer_batch_init(instance, ep, buffer, data_buffer, buffer_size,
             setup, setup_size, func_in, func_out, arg, fun,
@@ -154 +152 @@
 
         memcpy(instance->setup_buffer, setup_buffer, setup_size);
-        usb_log_debug("Batch(%p) %d:%d memory structures ready.\n",
-            instance, target.address, target.endpoint);
+        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT
+            " memory structures ready.\n", instance,
+            USB_TRANSFER_BATCH_ARGS(*instance));
         return instance;
 }
@@ -205 +204 @@
         return true;
 }
+
+#define LOG_BATCH_INITIALIZED(batch, name) \
+        usb_log_debug2("Batch %p %s " USB_TRANSFER_BATCH_FMT " initialized.\n", \
+            (batch), (name), USB_TRANSFER_BATCH_ARGS(*(batch)))
+
 /*----------------------------------------------------------------------------*/
 /** Prepares control write transfer.
@@ -219 +223 @@
         batch_control(instance, USB_PID_OUT, USB_PID_IN);
         instance->next_step = usb_transfer_batch_call_out_and_dispose;
-        usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
+        LOG_BATCH_INITIALIZED(instance, "control write");
 }
 /*----------------------------------------------------------------------------*/
@@ -233 +237 @@
         batch_control(instance, USB_PID_IN, USB_PID_OUT);
         instance->next_step = usb_transfer_batch_call_in_and_dispose;
-        usb_log_debug("Batch(%p) CONTROL READ initialized.\n", instance);
+        LOG_BATCH_INITIALIZED(instance, "control read");
 }
 /*----------------------------------------------------------------------------*/
@@ -247 +251 @@
         batch_data(instance, USB_PID_IN);
         instance->next_step = usb_transfer_batch_call_in_and_dispose;
-        usb_log_debug("Batch(%p) INTERRUPT IN initialized.\n", instance);
+        LOG_BATCH_INITIALIZED(instance, "interrupt in");
 }
 /*----------------------------------------------------------------------------*/
@@ -263 +267 @@
         batch_data(instance, USB_PID_OUT);
         instance->next_step = usb_transfer_batch_call_out_and_dispose;
-        usb_log_debug("Batch(%p) INTERRUPT OUT initialized.\n", instance);
+        LOG_BATCH_INITIALIZED(instance, "interrupt out");
 }
 /*----------------------------------------------------------------------------*/
@@ -277 +281 @@
         batch_data(instance, USB_PID_IN);
         instance->next_step = usb_transfer_batch_call_in_and_dispose;
-        usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
+        LOG_BATCH_INITIALIZED(instance, "bulk in");
 }
 /*----------------------------------------------------------------------------*/
@@ -293 +297 @@
         batch_data(instance, USB_PID_OUT);
         instance->next_step = usb_transfer_batch_call_out_and_dispose;
-        usb_log_debug("Batch(%p) BULK OUT initialized.\n", instance);
+        LOG_BATCH_INITIALIZED(instance, "bulk out");
 }
 /*----------------------------------------------------------------------------*/

uspace/drv/uhci/hw_struct/transfer_descriptor.c

@@ -103 +103 @@
         td_print_status(instance);
         if (pid == USB_PID_SETUP) {
-                usb_log_debug("SETUP BUFFER: %s\n",
+                usb_log_debug2("SETUP BUFFER: %s\n",
                     usb_debug_str_buffer(buffer, 8, 8));
         }

uspace/drv/uhci/iface.c

@@ -64 +64 @@
         }
 
-        usb_log_debug("%s %d:%d %zu(%zu).\n",
+        usb_log_debug2("%s %d:%d %zu(%zu).\n",
             name, target.address, target.endpoint, size, ep->max_packet_size);
 
@@ -172 +172 @@
                 speed = ep_speed;
         }
-        usb_log_debug("Register endpoint %d:%d %s %s(%d) %zu(%zu) %u.\n",
+        usb_log_debug("Register endpoint %d:%d %s-%s %s %zuB %ums.\n",
             address, endpoint, usb_str_transfer_type(transfer_type),
-            usb_str_speed(speed), direction, size, max_packet_size, interval);
+            usb_str_direction(direction), usb_str_speed(speed),
+            max_packet_size, interval);
 
         return usb_endpoint_manager_add_ep(&hc->ep_manager, address, endpoint,
@@ -187 +188 @@
         hc_t *hc = fun_to_hc(fun);
         assert(hc);
-        usb_log_debug("Unregister endpoint %d:%d %d.\n",
-            address, endpoint, direction);
+        usb_log_debug("Unregister endpoint %d:%d %s.\n",
+            address, endpoint, usb_str_direction(direction));
         return usb_endpoint_manager_unregister_ep(&hc->ep_manager, address,
             endpoint, direction);

uspace/drv/uhci/main.c

@@ -41 +41 @@
 #include "uhci.h"
 
-#define NAME "uhci_hcd"
+#define NAME "uhci"
 
 static int uhci_add_device(ddf_dev_t *device);

uspace/drv/uhci/transfer_list.c

@@ -141 +141 @@
         list_append(&batch->link, &instance->batch_list);
 
-        usb_transfer_batch_t *first = list_get_instance(
-            instance->batch_list.next, usb_transfer_batch_t, link);
-        usb_log_debug("Batch(%p) added to queue %s, first is %p.\n",
-                batch, instance->name, first);
+        usb_log_debug("Batch %p " USB_TRANSFER_BATCH_FMT " scheduled in queue %s.\n",
+            batch, USB_TRANSFER_BATCH_ARGS(*batch), instance->name);
         fibril_mutex_unlock(&instance->guard);
 }
@@ -234 +232 @@
         /* Remove from the batch list */
         list_remove(&batch->link);
-        usb_log_debug("Batch(%p) removed (%s) from %s, next: %x.\n",
-            batch, qpos, instance->name, batch_qh(batch)->next);
+        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " removed (%s) "
+            "from %s, next: %x.\n",
+            batch, USB_TRANSFER_BATCH_ARGS(*batch),
+            qpos, instance->name, batch_qh(batch)->next);
 }
 /**

uspace/drv/uhcirh/Makefile

@@ -38 +38 @@
         -I$(LIBDRV_PREFIX)/include
 
-BINARY = uhci_rhd
+BINARY = uhcirh
 
 SOURCES = \

uspace/drv/uhcirh/main.c

@@ -46 +46 @@
 #include "root_hub.h"
 
-#define NAME "uhci_rhd"
+#define NAME "uhcirh"
 
 static int hc_get_my_registers(const ddf_dev_t *dev,

uspace/drv/usbhid/Makefile

@@ -43 +43 @@
 BINARY = usbhid
 
+SUBDRIVER_SOURCES = \
+        kbd/conv.c \
+        kbd/kbddev.c \
+        kbd/kbdrepeat.c \
+        mouse/mousedev.c \
+        multimedia/multimedia.c \
+        multimedia/keymap.c
+
 SOURCES = \
         main.c \
         usbhid.c \
         subdrivers.c \
-        kbd/conv.c \
-        kbd/kbddev.c \
-        kbd/kbdrepeat.c \
         generic/hiddev.c \
-        mouse/mousedev.c \
-        multimedia/multimedia.c \
-        multimedia/keymap.c \
-        $(STOLEN_LAYOUT_SOURCES)
+        $(SUBDRIVER_SOURCES)
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/drv/usbhid/generic/hiddev.c

@@ -231 +231 @@
 /*----------------------------------------------------------------------------*/
 
-bool usb_generic_hid_polling_callback(usb_hid_dev_t *hid_dev, void *data, 
-    uint8_t *buffer, size_t buffer_size)
-{
-        usb_log_debug2("usb_hid_polling_callback(%p, %p, %zu)\n",
-            hid_dev, buffer, buffer_size);
-        usb_debug_str_buffer(buffer, buffer_size, 0);
+bool usb_generic_hid_polling_callback(usb_hid_dev_t *hid_dev, void *data)
+{
         return true;
 }

uspace/drv/usbhid/generic/hiddev.h

@@ -50 +50 @@
 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, void *data,
-    uint8_t *buffer, size_t buffer_size);
+bool usb_generic_hid_polling_callback(struct usb_hid_dev *hid_dev, void *data);
 
 #endif // USB_HID_HIDDDEV_H_

uspace/drv/usbhid/kbd/kbddev.c

@@ -46 +46 @@
 #include <fibril.h>
 #include <fibril_synch.h>
+
+#include <ddf/log.h>
 
 #include <usb/usb.h>
@@ -317 +319 @@
 }
 
+static size_t find_in_array_int32(int32_t val, int32_t *arr, size_t arr_size)
+{
+        for (size_t i = 0; i < arr_size; i++) {
+                if (arr[i] == val) {
+                        return i;
+                }
+        }
+
+        return (size_t) -1;
+}
+
 /*----------------------------------------------------------------------------*/
 /**
@@ -337 +350 @@
 {
         unsigned int key;
-        unsigned int i, j;
+        size_t i;
         
         /*
@@ -347 +360 @@
          * whole input report.
          */
-        i = 0;
-        while (i < kbd_dev->key_count && kbd_dev->keys[i] != ERROR_ROLLOVER) {
-                ++i;
-        }
-        if (i != kbd_dev->key_count) {
-                usb_log_debug("Phantom state occured.\n");
-                // phantom state, do nothing
+        i = find_in_array_int32(ERROR_ROLLOVER, kbd_dev->keys,
+            kbd_dev->key_count);
+        if (i != (size_t) -1) {
+                usb_log_debug("Detected phantom state.\n");
                 return;
         }
         
         /*
-         * 1) Key releases
-         */
-        for (j = 0; j < kbd_dev->key_count; ++j) {
-                // try to find the old key in the new key list
-                i = 0;
-                while (i < kbd_dev->key_count
-                    && kbd_dev->keys[i] != kbd_dev->keys_old[j]) {
-                        ++i;
-                }
-                
-                if (i == kbd_dev->key_count) {
-                        // not found, i.e. the key was released
-                        key = usbhid_parse_scancode(kbd_dev->keys_old[j]);
+         * Key releases
+         */
+        for (i = 0; i < kbd_dev->key_count; i++) {
+                int32_t old_key = kbd_dev->keys_old[i];
+                /* Find the old key among currently pressed keys. */
+                size_t pos = find_in_array_int32(old_key, kbd_dev->keys,
+                    kbd_dev->key_count);
+                /* If the key was not found, we need to signal release. */
+                if (pos == (size_t) -1) {
+                        key = usbhid_parse_scancode(old_key);
                         if (!usb_kbd_is_lock(key)) {
                                 usb_kbd_repeat_stop(kbd_dev, key);
                         }
                         usb_kbd_push_ev(hid_dev, kbd_dev, KEY_RELEASE, key);
-                        usb_log_debug2("Key released: %d\n", key);
-                } else {
-                        // found, nothing happens
-                }
-        }
-        
-        /*
-         * 1) Key presses
+                        usb_log_debug2("Key released: %u "
+                            "(USB code %" PRIu32 ")\n", key, old_key);
+                }
+        }
+        
+        /*
+         * Key presses
          */
         for (i = 0; i < kbd_dev->key_count; ++i) {
-                // try to find the new key in the old key list
-                j = 0;
-                while (j < kbd_dev->key_count 
-                    && kbd_dev->keys_old[j] != kbd_dev->keys[i]) { 
-                        ++j;
-                }
-                
-                if (j == kbd_dev->key_count) {
-                        // not found, i.e. new key pressed
+                int32_t new_key = kbd_dev->keys[i];
+                /* Find the new key among already pressed keys. */
+                size_t pos = find_in_array_int32(new_key, kbd_dev->keys_old,
+                    kbd_dev->key_count);
+                /* If the key was not found, we need to signal press. */
+                if (pos == (size_t) -1) {
                         key = usbhid_parse_scancode(kbd_dev->keys[i]);
-                        usb_log_debug2("Key pressed: %d (keycode: %d)\n", key,
-                            kbd_dev->keys[i]);
                         if (!usb_kbd_is_lock(key)) {
                                 usb_kbd_repeat_start(kbd_dev, key);
                         }
                         usb_kbd_push_ev(hid_dev, kbd_dev, KEY_PRESS, key);
-                } else {
-                        // found, nothing happens
+                        usb_log_debug2("Key pressed: %u "
+                            "(USB code %" PRIu32 ")\n", key, new_key);
                 }
         }
@@ -408 +409 @@
         memcpy(kbd_dev->keys_old, kbd_dev->keys, kbd_dev->key_count * 4);
         
-        usb_log_debug2("New stored keys: ");
-        for (i = 0; i < kbd_dev->key_count; ++i) {
-                usb_log_debug2("%d ", kbd_dev->keys_old[i]);
-        }
-        usb_log_debug2("\n");
+        char key_buffer[512];
+        ddf_dump_buffer(key_buffer, 512,
+            kbd_dev->keys_old, 4, kbd_dev->key_count, 0);
+        usb_log_debug2("Stored keys %s.\n", key_buffer);
 }
 
@@ -434 +434 @@
  *     usb_hid_parse_report().
  */
-static void usb_kbd_process_data(usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev,
-                                 uint8_t *buffer, size_t actual_size)
+static void usb_kbd_process_data(usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev)
 {
         assert(hid_dev->report != NULL);
         assert(hid_dev != NULL);
         assert(kbd_dev != NULL);
-
-        usb_log_debug("Calling usb_hid_parse_report() with "
-            "buffer %s\n", usb_debug_str_buffer(buffer, actual_size, 0));
         
         usb_hid_report_path_t *path = usb_hid_report_path();
         usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
 
-        uint8_t report_id;
-        int rc = usb_hid_parse_report(hid_dev->report, buffer, actual_size, 
-            &report_id);
-        
-        if (rc != EOK) {
-                usb_log_warning("Error in usb_hid_parse_report():"
-                    "%s\n", str_error(rc));
-        }
-        
-        usb_hid_report_path_set_report_id (path, report_id);
+        usb_hid_report_path_set_report_id (path, hid_dev->report_id);
         
         // fill in the currently pressed keys
@@ -756 +743 @@
 /*----------------------------------------------------------------------------*/
 
-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) {
+bool usb_kbd_polling_callback(usb_hid_dev_t *hid_dev, void *data)
+{
+        if (hid_dev == NULL/* || buffer == NULL*/ || data == NULL) {
                 // do not continue polling (???)
                 return false;
@@ -768 +754 @@
         
         // TODO: add return value from this function
-        usb_kbd_process_data(hid_dev, kbd_dev, buffer, buffer_size);
+        usb_kbd_process_data(hid_dev, kbd_dev);
         
         return true;
@@ -804 +790 @@
         if ((*kbd_dev)->repeat_mtx != NULL) {
                 //assert(!fibril_mutex_is_locked((*kbd_dev)->repeat_mtx));
+                // FIXME - the fibril_mutex_is_locked may not cause
+                // fibril scheduling
                 while (fibril_mutex_is_locked((*kbd_dev)->repeat_mtx)) {}
                 free((*kbd_dev)->repeat_mtx);

uspace/drv/usbhid/kbd/kbddev.h

@@ -125 +125 @@
 int usb_kbd_init(struct usb_hid_dev *hid_dev, void **data);
 
-bool usb_kbd_polling_callback(struct usb_hid_dev *hid_dev, void *data, 
-                              uint8_t *buffer, size_t buffer_size);
+bool usb_kbd_polling_callback(struct usb_hid_dev *hid_dev, void *data);
 
 int usb_kbd_is_initialized(const usb_kbd_t *kbd_dev);

uspace/drv/usbhid/kbd/kbdrepeat.c

@@ -97 +97 @@
                                 delay = kbd->repeat.delay_between;
                         } else {
-                                usb_log_debug("New key to repeat: %u.\n", 
+                                usb_log_debug2("New key to repeat: %u.\n",
                                     kbd->repeat.key_new);
                                 kbd->repeat.key_repeated = kbd->repeat.key_new;
@@ -104 +104 @@
                 } else {
                         if (kbd->repeat.key_repeated > 0) {
-                                usb_log_debug("Stopping to repeat key: %u.\n", 
+                                usb_log_debug2("Stopping to repeat key: %u.\n",
                                     kbd->repeat.key_repeated);
                                 kbd->repeat.key_repeated = 0;

uspace/drv/usbhid/mouse/mousedev.c

@@ -52 +52 @@
 #include "mousedev.h"
 #include "../usbhid.h"
+
+/** Number of simulated arrow-key presses for singel wheel step. */
+#define ARROWS_PER_SINGLE_WHEEL 3
 
 // FIXME: remove this header
@@ -201 +204 @@
 static void usb_mouse_send_wheel(const usb_mouse_t *mouse_dev, int wheel)
 {
-        kbd_event_t ev;
-        
-        ev.type = KEY_PRESS;
-        ev.key = (wheel > 0) ? KC_UP : (wheel < 0) ? KC_DOWN : 0;
-        ev.mods = 0;
-        ev.c = 0;
+        unsigned int key = (wheel > 0) ? KC_UP : KC_DOWN;
 
         if (mouse_dev->wheel_phone < 0) {
                 usb_log_warning(
-                    "Connection to console not ready, key discarded.\n");
+                    "Connection to console not ready, wheel roll discarded.\n");
                 return;
         }
         
-        int count = (wheel < 0) ? -wheel : wheel;
+        int count = ((wheel < 0) ? -wheel : wheel) * ARROWS_PER_SINGLE_WHEEL;
         int i;
         
-        for (i = 0; i < count * 3; ++i) {
-                usb_log_debug2("Sending key %d to the console\n", ev.key);
-                async_obsolete_msg_4(mouse_dev->wheel_phone, KBDEV_EVENT, ev.type, 
-                    ev.key, ev.mods, ev.c);
-                // send key release right away
-                async_obsolete_msg_4(mouse_dev->wheel_phone, KBDEV_EVENT, KEY_RELEASE, 
-                    ev.key, ev.mods, ev.c);
-        }
-}
-
-/*----------------------------------------------------------------------------*/
-
-static bool usb_mouse_process_report(usb_hid_dev_t *hid_dev, 
-                                     usb_mouse_t *mouse_dev, uint8_t *buffer,
-                                     size_t buffer_size)
+        for (i = 0; i < count; i++) {
+                /* Send arrow press and release. */
+                usb_log_debug2("Sending key %d to the console\n", key);
+                async_obsolete_msg_4(mouse_dev->wheel_phone, KBDEV_EVENT,
+                    KEY_PRESS, key, 0, 0);
+                async_obsolete_msg_4(mouse_dev->wheel_phone, KBDEV_EVENT,
+                    KEY_RELEASE, key, 0, 0);
+        }
+}
+
+/*----------------------------------------------------------------------------*/
+
+static int get_mouse_axis_move_value(uint8_t rid, usb_hid_report_t *report,
+    int32_t usage)
+{
+        int result = 0;
+
+        usb_hid_report_path_t *path = usb_hid_report_path();
+        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_GENERIC_DESKTOP,
+            usage);
+
+        usb_hid_report_path_set_report_id(path, rid);
+
+        usb_hid_report_field_t *field = usb_hid_report_get_sibling(
+            report, NULL, path, USB_HID_PATH_COMPARE_END,
+            USB_HID_REPORT_TYPE_INPUT);
+
+        if (field != NULL) {
+                result = field->value;
+        }
+
+        usb_hid_report_path_free(path);
+
+        return result;
+}
+
+static bool usb_mouse_process_report(usb_hid_dev_t *hid_dev,
+    usb_mouse_t *mouse_dev)
 {
         assert(mouse_dev != NULL);
-        
-        usb_log_debug2("got buffer: %s.\n",
-            usb_debug_str_buffer(buffer, buffer_size, 0));
         
         if (mouse_dev->mouse_phone < 0) {
@@ -243 +261 @@
         }
 
-        /*
-         * parse the input report
-         */
-        
-        usb_log_debug(NAME " Calling usb_hid_parse_report() with "
-            "buffer %s\n", usb_debug_str_buffer(buffer, buffer_size, 0));
-        
-        uint8_t report_id;
-        
-        int rc = usb_hid_parse_report(hid_dev->report, buffer, buffer_size, 
-            &report_id);
-        
-        if (rc != EOK) {
-                usb_log_warning(NAME "Error in usb_hid_parse_report(): %s\n", 
-                    str_error(rc));
-                return true;
-        }
-        
-        /*
-         * X
-         */
-        int shift_x = 0;
-        
-        usb_hid_report_path_t *path = usb_hid_report_path();
-        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_GENERIC_DESKTOP, 
-            USB_HIDUT_USAGE_GENERIC_DESKTOP_X);
-
-        usb_hid_report_path_set_report_id(path, report_id);
-
-        usb_hid_report_field_t *field = usb_hid_report_get_sibling(
-            hid_dev->report, NULL, path, USB_HID_PATH_COMPARE_END, 
-            USB_HID_REPORT_TYPE_INPUT);
-
-        if (field != NULL) {
-                usb_log_debug(NAME " VALUE(%X) USAGE(%X)\n", field->value, 
-                    field->usage);
-                shift_x = field->value;
-        }
-
-        usb_hid_report_path_free(path);
-        
-        /*
-         * Y
-         */
-        int shift_y = 0;
-        
-        path = usb_hid_report_path();
-        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_GENERIC_DESKTOP, 
-            USB_HIDUT_USAGE_GENERIC_DESKTOP_Y);
-
-        usb_hid_report_path_set_report_id(path, report_id);
-
-        field = usb_hid_report_get_sibling(
-            hid_dev->report, NULL, path, USB_HID_PATH_COMPARE_END, 
-            USB_HID_REPORT_TYPE_INPUT);
-
-        if (field != NULL) {
-                usb_log_debug(NAME " VALUE(%X) USAGE(%X)\n", field->value, 
-                    field->usage);
-                shift_y = field->value;
-        }
-
-        usb_hid_report_path_free(path);
-        
+        int shift_x = get_mouse_axis_move_value(hid_dev->report_id,
+            hid_dev->report, USB_HIDUT_USAGE_GENERIC_DESKTOP_X);
+        int shift_y = get_mouse_axis_move_value(hid_dev->report_id,
+            hid_dev->report, USB_HIDUT_USAGE_GENERIC_DESKTOP_Y);
+        int wheel = get_mouse_axis_move_value(hid_dev->report_id,
+            hid_dev->report, USB_HIDUT_USAGE_GENERIC_DESKTOP_WHEEL);
+
         if ((shift_x != 0) || (shift_y != 0)) {
                 async_obsolete_req_2_0(mouse_dev->mouse_phone,
                     MEVENT_MOVE, shift_x, shift_y);
         }
-        
-        /*
-         * Wheel
-         */
-        int wheel = 0;
-        
-        path = usb_hid_report_path();
-        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_GENERIC_DESKTOP, 
-            USB_HIDUT_USAGE_GENERIC_DESKTOP_WHEEL);
-
-        usb_hid_report_path_set_report_id(path, report_id);
-        
-        field = usb_hid_report_get_sibling(
-            hid_dev->report, NULL, path, USB_HID_PATH_COMPARE_END, 
-            USB_HID_REPORT_TYPE_INPUT);
-
-        if (field != NULL) {
-                usb_log_debug(NAME " VALUE(%X) USAGE(%X)\n", field->value, 
-                    field->usage);
-                wheel = field->value;
-        }
-
-        usb_hid_report_path_free(path);
-        
-        // send arrow up for positive direction and arrow down for negative
-        // direction; three arrows for difference of 1
-        usb_mouse_send_wheel(mouse_dev, wheel);
-        
+
+        if (wheel != 0) {
+                usb_mouse_send_wheel(mouse_dev, wheel);
+        }
         
         /*
          * Buttons
          */
-        path = usb_hid_report_path();
+        usb_hid_report_path_t *path = usb_hid_report_path();
         usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_BUTTON, 0);
-        usb_hid_report_path_set_report_id(path, report_id);
-        
-        field = usb_hid_report_get_sibling(
+        usb_hid_report_path_set_report_id(path, hid_dev->report_id);
+        
+        usb_hid_report_field_t *field = usb_hid_report_get_sibling(
             hid_dev->report, NULL, path, USB_HID_PATH_COMPARE_END
             | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
@@ -353 +290 @@
 
         while (field != NULL) {
-                usb_log_debug(NAME " VALUE(%X) USAGE(%X)\n", field->value, 
+                usb_log_debug2(NAME " VALUE(%X) USAGE(%X)\n", field->value,
                     field->usage);
                 
@@ -510 +447 @@
 /*----------------------------------------------------------------------------*/
 
-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);
-        
+bool usb_mouse_polling_callback(usb_hid_dev_t *hid_dev, void *data)
+{
         if (hid_dev == NULL || data == NULL) {
                 usb_log_error("Missing argument to the mouse polling callback."
@@ -524 +457 @@
         usb_mouse_t *mouse_dev = (usb_mouse_t *)data;
                 
-        return usb_mouse_process_report(hid_dev, mouse_dev, buffer, 
-                                        buffer_size);
+        return usb_mouse_process_report(hid_dev, mouse_dev);
 }
 

uspace/drv/usbhid/mouse/mousedev.h

@@ -65 +65 @@
 int usb_mouse_init(struct usb_hid_dev *hid_dev, void **data);
 
-bool usb_mouse_polling_callback(struct usb_hid_dev *hid_dev, void *data, 
-    uint8_t *buffer, size_t buffer_size);
+bool usb_mouse_polling_callback(struct usb_hid_dev *hid_dev, void *data);
 
 void usb_mouse_deinit(struct usb_hid_dev *hid_dev, void *data);

uspace/drv/usbhid/multimedia/multimedia.c

@@ -94 +94 @@
         
         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) {
@@ -274 +273 @@
 /*----------------------------------------------------------------------------*/
 
-bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data, 
-    uint8_t *buffer, size_t buffer_size)
+bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data)
 {
         // TODO: checks
-        if (hid_dev == NULL || data == NULL || buffer == NULL) {
+        if (hid_dev == NULL || data == NULL) {
                 return false;
         }
-        
-        usb_log_debug(NAME " usb_lgtch_polling_callback(%p, %p, %zu)\n",
-            hid_dev, buffer, buffer_size);
-        
+
         usb_multimedia_t *multim_dev = (usb_multimedia_t *)data;
-
-        usb_log_debug(NAME " Calling usb_hid_parse_report() with "
-            "buffer %s\n", usb_debug_str_buffer(buffer, buffer_size, 0));
         
         usb_hid_report_path_t *path = usb_hid_report_path();
         usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_CONSUMER, 0);
 
-        uint8_t report_id;
-        
-        int rc = usb_hid_parse_report(hid_dev->report, buffer, buffer_size, 
-            &report_id);
-        
-        if (rc != EOK) {
-                usb_log_warning(NAME "Error in usb_hid_parse_report(): %s\n", 
-                    str_error(rc));
-                return true;
-        }
-        
-        usb_hid_report_path_set_report_id(path, report_id);
+        usb_hid_report_path_set_report_id(path, hid_dev->report_id);
 
         usb_hid_report_field_t *field = usb_hid_report_get_sibling(

uspace/drv/usbhid/multimedia/multimedia.h

@@ -47 +47 @@
 void usb_multimedia_deinit(struct usb_hid_dev *hid_dev, void *data);
 
-bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data,
-    uint8_t *buffer, size_t buffer_size);
+bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data);
 
 /*----------------------------------------------------------------------------*/

uspace/drv/usbhid/subdrivers.h

@@ -49 +49 @@
 /*----------------------------------------------------------------------------*/
 
-/* TODO: This mapping must contain some other information to get the proper
- *       interface.
+/** Structure representing the mapping between device requirements and the 
+ *  subdriver supposed to handle this device.
+ *
+ * By filling in this structure and adding it to the usb_hid_subdrivers array,
+ * a new subdriver mapping will be created and used by the HID driver when it
+ * searches for appropriate subdrivers for a device.
  */
 typedef struct usb_hid_subdriver_mapping {
+        /** Usage path that the device's Input reports must contain. 
+         *
+         * It is an array of pairs <usage_page, usage>, terminated by a <0, 0>
+         * pair. If you do not wish to specify the device in this way, set this
+         * to NULL.
+         */
         const usb_hid_subdriver_usage_t *usage_path;
+        
+        /** Report ID for which the path should apply. */
         int report_id;
+        
+        /** Compare type for the Usage path. */
         int compare;
+        
+        /** Vendor ID (set to -1 if not specified). */
         int vendor_id;
+        
+        /** Product ID (set to -1 if not specified). */
         int product_id;
+        
+        /** Subdriver for controlling this device. */
         usb_hid_subdriver_t subdriver;
 } usb_hid_subdriver_mapping_t;

uspace/drv/usbhid/usbhid.c

@@ -572 +572 @@
         
         assert(hid_dev->input_report != NULL);
-        usb_log_debug("Max input report size: %zu, buffer size: %zu\n",
-            hid_dev->max_input_report_size, buffer_size);
+        usb_log_debug("New data [%zu/%zu]: %s\n", buffer_size,
+            hid_dev->max_input_report_size,
+            usb_debug_str_buffer(buffer, buffer_size, 0));
 
         if (hid_dev->max_input_report_size >= buffer_size) {
@@ -582 +583 @@
         }
         
+        // parse the input report
+        
+        int rc = usb_hid_parse_report(hid_dev->report, buffer, buffer_size, 
+            &hid_dev->report_id);
+        
+        if (rc != EOK) {
+                usb_log_warning("Error in usb_hid_parse_report():"
+                    "%s\n", str_error(rc));
+        }       
+        
         bool cont = false;
         
@@ -588 +599 @@
                 if (hid_dev->subdrivers[i].poll != NULL
                     && hid_dev->subdrivers[i].poll(hid_dev, 
-                        hid_dev->subdrivers[i].data, buffer, buffer_size)) {
+                        hid_dev->subdrivers[i].data)) {
                         cont = true;
                 }

uspace/drv/usbhid/usbhid.h

@@ -46 +46 @@
 #include <bool.h>
 
-struct usb_hid_dev;
+typedef struct usb_hid_dev usb_hid_dev_t;
+typedef struct usb_hid_subdriver usb_hid_subdriver_t;
 
-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);
+/** Subdriver initialization callback.
+ *
+ * @param dev Backing USB HID device.
+ * @param data Custom subdriver data (pointer where to store them).
+ * @return Error code.
+ */
+typedef int (*usb_hid_driver_init_t)(usb_hid_dev_t *dev, void **data);
 
-typedef struct usb_hid_subdriver {      
+/** Subdriver deinitialization callback.
+ *
+ * @param dev Backing USB HID device.
+ * @param data Custom subdriver data.
+ */
+typedef void (*usb_hid_driver_deinit_t)(usb_hid_dev_t *dev, void *data);
+
+/** Subdriver callback on data from device.
+ *
+ * @param dev Backing USB HID device.
+ * @param data Custom subdriver data.
+ * @return Whether to continue polling (typically true always).
+ */
+typedef bool (*usb_hid_driver_poll_t)(usb_hid_dev_t *dev, void *data);
+
+/** Subdriver callback after communication with the device ceased.
+ *
+ * @param dev Backing USB HID device.
+ * @param data Custom subdriver data.
+ * @param ended_due_to_errors Whether communication ended due to errors in
+ *      communication (true) or deliberately by driver (false).
+ */
+typedef void (*usb_hid_driver_poll_ended_t)(usb_hid_dev_t *dev, void *data,
+    bool ended_due_to_errors);
+
+struct usb_hid_subdriver {
         /** Function to be called when initializing HID device. */
         usb_hid_driver_init_t init;
@@ -61 +88 @@
         usb_hid_driver_deinit_t deinit;
         /** Function to be called when data arrives from the device. */
-        usb_hid_driver_poll poll;
+        usb_hid_driver_poll_t poll;
         /** Function to be called when polling ends. */
-        usb_hid_driver_poll_ended poll_end;
+        usb_hid_driver_poll_ended_t poll_end;
         /** Arbitrary data needed by the subdriver. */
         void *data;
-} usb_hid_subdriver_t;
+};
 
 /*----------------------------------------------------------------------------*/
@@ -72 +99 @@
  * Structure for holding general HID device data.
  */
-typedef struct usb_hid_dev {
+struct usb_hid_dev {
         /** Structure holding generic USB device information. */
         usb_device_t *usb_dev;
@@ -94 +121 @@
         usb_hid_report_t *report;
         
+        uint8_t report_id;
+        
         uint8_t *input_report;
         
@@ -100 +129 @@
         
         int report_nr;
-} usb_hid_dev_t;
+};
 
 /*----------------------------------------------------------------------------*/

uspace/drv/usbhub/ports.c

@@ -140 +140 @@
                 usb_hub_port_reset_completed(hub, port, status);
         }
-        usb_log_debug("Status x%x : %d\n ", status, status);
+        usb_log_debug("Port %d status 0x%08" PRIx32 "\n", (int) port, status);
 
         usb_port_status_set_bit(

uspace/lib/c/generic/str.c

@@ -540 +540 @@
 
         dstr_size = str_size(dest);
+        if (dstr_size >= size) {
+                return;
+        }
         str_cpy(dest + dstr_size, size - dstr_size, src);
 }

uspace/lib/drv/Makefile

@@ -36 +36 @@
         generic/dev_iface.c \
         generic/log.c \
+        generic/logbuf.c \
         generic/remote_hw_res.c \
         generic/remote_char_dev.c \

uspace/lib/drv/include/ddf/log.h

@@ -39 +39 @@
 extern void ddf_msg(log_level_t, const char *, ...);
 
+extern void ddf_dump_buffer(char *, size_t, const void *, size_t, size_t,
+    size_t);
+
 #endif
 

uspace/lib/usb/include/usb/usb.h

@@ -69 +69 @@
         USB_DIRECTION_BOTH
 } usb_direction_t;
+
+const char *usb_str_direction(usb_direction_t);
 
 /** USB speeds. */

uspace/lib/usb/src/debug.c

@@ -38 +38 @@
 #include <stdlib.h>
 #include <stdio.h>
+#include <ddf/log.h>
 #include <usb/debug.h>
 
@@ -67 +68 @@
                 if (rc > 0) {
                         log_stream = fopen(fname, "w");
+                        if (log_stream != NULL) {
+                                setvbuf(log_stream, NULL, _IOFBF, BUFSIZ);
+                        }
                         free(fname);
                 }
@@ -193 +197 @@
         bzero(buffer_dump[buffer_dump_index], BUFFER_DUMP_LEN);
 
-        if (buffer == NULL) {
-                return "(null)";
-        }
-        if (size == 0) {
-                return "(empty)";
-        }
-        if ((dumped_size == 0) || (dumped_size > size)) {
-                dumped_size = size;
-        }
-
-        /* How many bytes are available in the output buffer. */
-        size_t buffer_remaining_size = BUFFER_DUMP_LEN - 1 - REMAINDER_STR_LEN;
-        char *it = buffer_dump[buffer_dump_index];
-
-        size_t index = 0;
-
-        while (index < size) {
-                /* Determine space before the number. */
-                const char *space_before;
-                if (index == 0) {
-                        space_before = "";
-                } else if ((index % BUFFER_DUMP_GROUP_SIZE) == 0) {
-                        space_before = "  ";
-                } else {
-                        space_before = " ";
-                }
-
-                /*
-                 * Add the byte as a hexadecimal number plus the space.
-                 * We do it into temporary buffer to ensure that always
-                 * the whole byte is printed.
-                 */
-                int val = buffer[index];
-                char current_byte[16];
-                int printed = snprintf(current_byte, 16,
-                    "%s%02x", space_before, val);
-                if (printed < 0) {
-                        break;
-                }
-
-                if ((size_t) printed > buffer_remaining_size) {
-                        break;
-                }
-
-                /* We can safely add 1, because space for end 0 is reserved. */
-                str_append(it, buffer_remaining_size + 1, current_byte);
-
-                buffer_remaining_size -= printed;
-                /* Point at the terminator 0. */
-                it += printed;
-                index++;
-
-                if (index >= dumped_size) {
-                        break;
-                }
-        }
-
-        /* Add how many bytes were not printed. */
-        if (index < size) {
-                snprintf(it, REMAINDER_STR_LEN,
-                    REMAINDER_STR_FMT, size - index);
-        }
+        /* Do the actual dump. */
+        ddf_dump_buffer(buffer_dump[buffer_dump_index], BUFFER_DUMP_LEN,
+            buffer, 1, size, dumped_size);
 
         /* Next time, use the other buffer. */

uspace/lib/usb/src/hc.c

@@ -98 +98 @@
                 return EBUSY;
         
-        async_sess_t *sess = devman_device_connect(EXCHANGE_SERIALIZE,
+        async_sess_t *sess = devman_device_connect(EXCHANGE_ATOMIC,
             connection->hc_handle, 0);
         if (!sess)
@@ -177 +177 @@
 {
         async_sess_t *parent_sess =
-            devman_parent_device_connect(EXCHANGE_SERIALIZE, dev_handle,
+            devman_parent_device_connect(EXCHANGE_ATOMIC, dev_handle,
             IPC_FLAG_BLOCKING);
         if (!parent_sess)
@@ -241 +241 @@
 {
         async_sess_t *parent_sess =
-            devman_parent_device_connect(EXCHANGE_SERIALIZE, device_handle,
+            devman_parent_device_connect(EXCHANGE_ATOMIC, device_handle,
             IPC_FLAG_BLOCKING);
         if (!parent_sess)

uspace/lib/usb/src/usb.c

@@ -58 +58 @@
 };
 
+static const char *str_direction[] = {
+        "in",
+        "out",
+        "both"
+};
+
 /** String representation for USB transfer type.
  *
@@ -84 +90 @@
 }
 
+/** String representation of USB direction.
+ *
+ * @param d The direction.
+ * @return Direction as a string (in English).
+ */
+const char *usb_str_direction(usb_direction_t d)
+{
+        if (d >= ARR_SIZE(str_direction)) {
+                return "invalid";
+        }
+        return str_direction[d];
+}
+
 /** String representation of USB speed.
  *

uspace/lib/usbdev/src/pipes.c

@@ -81 +81 @@
 {
         async_sess_t *parent_sess =
-            devman_parent_device_connect(EXCHANGE_SERIALIZE, device->handle,
+            devman_parent_device_connect(EXCHANGE_ATOMIC, device->handle,
             IPC_FLAG_BLOCKING);
         if (!parent_sess)
@@ -122 +122 @@
         
         async_sess_t *parent_sess =
-            devman_parent_device_connect(EXCHANGE_SERIALIZE, dev->handle,
+            devman_parent_device_connect(EXCHANGE_ATOMIC, dev->handle,
             IPC_FLAG_BLOCKING);
         if (!parent_sess)

uspace/lib/usbhid/src/hidreq.c

@@ -82 +82 @@
         value |= (type << 8);
 
-        usb_log_debug("Sending Set_Report request to the device.\n");
+        usb_log_debug("Sending Set Report request to the device.\n");
         
         rc = usb_control_request_set(ctrl_pipe, 
@@ -89 +89 @@
 
         if (rc != EOK) {
-                usb_log_warning("Error sending output report to the keyboard: "
-                    "%s.\n", str_error(rc));
+                usb_log_warning("Error sending Set Report request to the "
+                    "device: %s.\n", str_error(rc));
                 return rc;
         }
@@ -129 +129 @@
         int rc;
 
-        usb_log_debug("Sending Set_Protocol request to the device ("
+        usb_log_debug("Sending Set Protocol request to the device ("
             "protocol: %d, iface: %d).\n", protocol, iface_no);
         
@@ -137 +137 @@
 
         if (rc != EOK) {
-                usb_log_warning("Error sending output report to the keyboard: "
-                    "%s.\n", str_error(rc));
+                usb_log_warning("Error sending Set Protocol request to the "
+                    "device: %s.\n", str_error(rc));
                 return rc;
         }
@@ -177 +177 @@
         int rc;
 
-        usb_log_debug("Sending Set_Idle request to the device ("
+        usb_log_debug("Sending Set Idle request to the device ("
             "duration: %u, iface: %d).\n", duration, iface_no);
         
@@ -187 +187 @@
 
         if (rc != EOK) {
-                usb_log_warning("Error sending output report to the keyboard: "
+                usb_log_warning("Error sending Set Idle request to the device: "
                     "%s.\n", str_error(rc));
                 return rc;
@@ -235 +235 @@
         value |= (type << 8);
         
-        usb_log_debug("Sending Get_Report request to the device.\n");
+        usb_log_debug("Sending Get Report request to the device.\n");
         
         rc = usb_control_request_get(ctrl_pipe, 
@@ -243 +243 @@
 
         if (rc != EOK) {
-                usb_log_warning("Error sending output report to the keyboard: "
+                usb_log_warning("Error sending Get Report request to the device: "
                     "%s.\n", str_error(rc));
                 return rc;
@@ -283 +283 @@
         int rc; 
 
-        usb_log_debug("Sending Get_Protocol request to the device ("
+        usb_log_debug("Sending Get Protocol request to the device ("
             "iface: %d).\n", iface_no);
         
@@ -294 +294 @@
 
         if (rc != EOK) {
-                usb_log_warning("Error sending output report to the keyboard: "
-                    "%s.\n", str_error(rc));
+                usb_log_warning("Error sending Get Protocol request to the "
+                    "device: %s.\n", str_error(rc));
                 return rc;
         }
@@ -344 +344 @@
         int rc;
 
-        usb_log_debug("Sending Get_Idle request to the device ("
+        usb_log_debug("Sending Get Idle request to the device ("
             "iface: %d).\n", iface_no);
         
@@ -357 +357 @@
 
         if (rc != EOK) {
-                usb_log_warning("Error sending output report to the keyboard: "
+                usb_log_warning("Error sending Get Idle request to the device: "
                     "%s.\n", str_error(rc));
                 return rc;

uspace/lib/usbhost/include/usb/host/batch.h

@@ -61 +61 @@
 };
 
+/** Printf formatting string for dumping usb_transfer_batch_t. */
+#define USB_TRANSFER_BATCH_FMT "[%d:%d %s %s-%s %zuB/%zu]"
+
+/** Printf arguments for dumping usb_transfer_batch_t.
+ * @param batch USB transfer batch to be dumped.
+ */
+#define USB_TRANSFER_BATCH_ARGS(batch) \
+        (batch).ep->address, (batch).ep->endpoint, \
+        usb_str_speed((batch).ep->speed), \
+        usb_str_transfer_type_short((batch).ep->transfer_type), \
+        usb_str_direction((batch).ep->direction), \
+        (batch).buffer_size, (batch).ep->max_packet_size
+
+
 void usb_transfer_batch_init(
     usb_transfer_batch_t *instance,

uspace/lib/usbhost/src/batch.c

@@ -128 +128 @@
         memcpy(instance->buffer, instance->data_buffer, instance->buffer_size);
 
-        usb_log_debug("Batch(%p) done (T%d.%d, %s %s in, %zuB): %s (%d).\n",
-            instance, instance->ep->address, instance->ep->endpoint,
-            usb_str_speed(instance->ep->speed),
-            usb_str_transfer_type_short(instance->ep->transfer_type),
-            instance->transfered_size, str_error(instance->error),
-            instance->error);
+        usb_log_debug("Batch %p " USB_TRANSFER_BATCH_FMT " completed (%zuB): %s.\n",
+            instance, USB_TRANSFER_BATCH_ARGS(*instance),
+            instance->transfered_size, str_error(instance->error));
 
         instance->callback_in(instance->fun, instance->error,
@@ -148 +145 @@
         assert(instance->callback_out);
 
-        usb_log_debug("Batch(%p) done (T%d.%d, %s %s out): %s (%d).\n",
-            instance, instance->ep->address, instance->ep->endpoint,
-            usb_str_speed(instance->ep->speed),
-            usb_str_transfer_type_short(instance->ep->transfer_type),
-            str_error(instance->error), instance->error);
+        usb_log_debug("Batch %p " USB_TRANSFER_BATCH_FMT " completed: %s.\n",
+            instance, USB_TRANSFER_BATCH_ARGS(*instance),
+            str_error(instance->error));
 
         instance->callback_out(instance->fun,
@@ -165 +160 @@
 {
         assert(instance);
-        usb_log_debug("Batch(%p) disposing.\n", instance);
+        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " disposing.\n",
+            instance, USB_TRANSFER_BATCH_ARGS(*instance));
         if (instance->private_data) {
                 assert(instance->private_data_dtor);