Changeset 960bee9 in mainline

Timestamp:

2011-03-07T16:51:59Z (13 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

97ff14d

Parents:

a6add7a (diff), d4beec3 (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 development/ changes

Files:

• boot/arch/amd64/Makefile.inc (modified) (1 diff)
• uspace/Makefile (modified) (2 diffs)
• uspace/drv/ehci-hcd/Makefile (added)
• uspace/drv/ehci-hcd/ehci-hcd (added)
• uspace/drv/ehci-hcd/ehci-hcd.ma (added)
• uspace/drv/ehci-hcd/main.c (added)
• uspace/drv/ehci-hcd/pci.c (added)
• uspace/drv/ehci-hcd/pci.h (added)
• uspace/drv/pciintel/pci.c (modified) (3 diffs)
• uspace/drv/uhci-hcd/batch.c (modified) (14 diffs)
• uspace/drv/uhci-hcd/batch.h (modified) (4 diffs)
• uspace/drv/uhci-hcd/iface.c (modified) (6 diffs)
• uspace/drv/uhci-hcd/uhci.c (modified) (3 diffs)
• uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.c (modified) (3 diffs)
• uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.h (modified) (1 diff)
• uspace/drv/uhci-hcd/utils/device_keeper.c (modified) (3 diffs)
• uspace/drv/uhci-hcd/utils/device_keeper.h (modified) (2 diffs)
• uspace/drv/usbhid/hidreq.c (modified) (3 diffs)
• uspace/drv/usbhid/hidreq.h (modified) (1 diff)
• uspace/drv/usbhid/kbddev.c (modified) (16 diffs)
• uspace/drv/usbhid/main.c (modified) (1 diff)
• uspace/lib/usb/include/usb/debug.h (modified) (1 diff)
• uspace/lib/usb/src/debug.c (modified) (1 diff)

boot/arch/amd64/Makefile.inc

@@ -43 +43 @@
         isa \
         ns8250 \
+        ehci-hcd \
         uhci-hcd \
         uhci-rhd \

uspace/Makefile

@@ -117 +117 @@
                 srv/hw/irc/apic \
                 srv/hw/irc/i8259 \
+                drv/ehci-hcd \
                 drv/uhci-hcd \
                 drv/uhci-rhd \
@@ -134 +135 @@
                 srv/hw/irc/apic \
                 srv/hw/irc/i8259 \
+                drv/ehci-hcd \
                 drv/uhci-hcd \
                 drv/uhci-rhd \

uspace/drv/pciintel/pci.c

@@ -127 +127 @@
 }
 
-static int pci_config_space_write_16(ddf_fun_t *fun, uint32_t address, uint16_t data)
+static int pci_config_space_write_32(
+    ddf_fun_t *fun, uint32_t address, uint32_t data)
+{
+        if (address > 252)
+                return EINVAL;
+        pci_conf_write_32(PCI_FUN(fun), address, data);
+        return EOK;
+}
+
+static int pci_config_space_write_16(
+    ddf_fun_t *fun, uint32_t address, uint16_t data)
 {
         if (address > 254)
@@ -135 +145 @@
 }
 
+static int pci_config_space_write_8(
+    ddf_fun_t *fun, uint32_t address, uint8_t data)
+{
+        if (address > 255)
+                return EINVAL;
+        pci_conf_write_8(PCI_FUN(fun), address, data);
+        return EOK;
+}
+
+static int pci_config_space_read_32(
+    ddf_fun_t *fun, uint32_t address, uint32_t *data)
+{
+        if (address > 252)
+                return EINVAL;
+        *data = pci_conf_read_32(PCI_FUN(fun), address);
+        return EOK;
+}
+
+static int pci_config_space_read_16(
+    ddf_fun_t *fun, uint32_t address, uint16_t *data)
+{
+        if (address > 254)
+                return EINVAL;
+        *data = pci_conf_read_16(PCI_FUN(fun), address);
+        return EOK;
+}
+
+static int pci_config_space_read_8(
+    ddf_fun_t *fun, uint32_t address, uint8_t *data)
+{
+        if (address > 255)
+                return EINVAL;
+        *data = pci_conf_read_8(PCI_FUN(fun), address);
+        return EOK;
+}
 
 static hw_res_ops_t pciintel_hw_res_ops = {
@@ -142 +187 @@
 
 static pci_dev_iface_t pci_dev_ops = {
-        .config_space_read_8 = NULL,
-        .config_space_read_16 = NULL,
-        .config_space_read_32 = NULL,
-        .config_space_write_8 = NULL,
+        .config_space_read_8 = &pci_config_space_read_8,
+        .config_space_read_16 = &pci_config_space_read_16,
+        .config_space_read_32 = &pci_config_space_read_32,
+        .config_space_write_8 = &pci_config_space_write_8,
         .config_space_write_16 = &pci_config_space_write_16,
-        .config_space_write_32 = NULL
+        .config_space_write_32 = &pci_config_space_write_32
 };
 

uspace/drv/uhci-hcd/batch.c

@@ -47 +47 @@
 static int batch_schedule(batch_t *instance);
 
-static void batch_control(
-    batch_t *instance, int data_stage, int status_stage);
+static void batch_control(batch_t *instance,
+    usb_packet_id data_stage, usb_packet_id status_stage);
+static void batch_data(batch_t *instance, usb_packet_id pid);
 static void batch_call_in(batch_t *instance);
 static void batch_call_out(batch_t *instance);
 static void batch_call_in_and_dispose(batch_t *instance);
 static void batch_call_out_and_dispose(batch_t *instance);
+static void batch_dispose(batch_t *instance);
 
 
@@ -60 +62 @@
     char* setup_buffer, size_t setup_size,
     usbhc_iface_transfer_in_callback_t func_in,
-    usbhc_iface_transfer_out_callback_t func_out, void *arg)
+    usbhc_iface_transfer_out_callback_t func_out, void *arg,
+    device_keeper_t *manager
+    )
 {
         assert(func_in == NULL || func_out == NULL);
@@ -83 +87 @@
         }
 
-        instance->tds = malloc32(sizeof(transfer_descriptor_t) * instance->packets);
+        instance->tds = malloc32(sizeof(td_t) * instance->packets);
         if (instance->tds == NULL) {
                 usb_log_error("Failed to allocate transfer descriptors.\n");
@@ -90 +94 @@
                 return NULL;
         }
-        bzero(instance->tds, sizeof(transfer_descriptor_t) * instance->packets);
+        bzero(instance->tds, sizeof(td_t) * instance->packets);
 
         const size_t transport_size = max_packet_size * instance->packets;
@@ -136 +140 @@
         instance->arg = arg;
         instance->speed = speed;
+        instance->manager = manager;
 
         queue_head_element_td(instance->qh, addr_to_phys(instance->tds));
@@ -151 +156 @@
         size_t i = 0;
         for (;i < instance->packets; ++i) {
-                if (transfer_descriptor_is_active(&instance->tds[i])) {
+                if (td_is_active(&instance->tds[i])) {
                         return false;
                 }
-                instance->error = transfer_descriptor_status(&instance->tds[i]);
+
+                instance->error = td_status(&instance->tds[i]);
                 if (instance->error != EOK) {
+                        usb_log_debug("Batch(%p) found error TD(%d):%x.\n",
+                            instance, i, instance->tds[i].status);
+
+                        device_keeper_set_toggle(instance->manager, instance->target,
+                            td_toggle(&instance->tds[i]));
                         if (i > 0)
-                                instance->transfered_size -= instance->setup_size;
-                        usb_log_debug("Batch(%p) found error TD(%d):%x.\n",
-                          instance, i, instance->tds[i].status);
+                                goto substract_ret;
                         return true;
                 }
-                instance->transfered_size +=
-                    transfer_descriptor_actual_size(&instance->tds[i]);
-        }
+
+                instance->transfered_size += td_act_size(&instance->tds[i]);
+                if (td_is_short(&instance->tds[i]))
+                        goto substract_ret;
+        }
+substract_ret:
         instance->transfered_size -= instance->setup_size;
         return true;
@@ -192 +204 @@
 {
         assert(instance);
-
-        const bool low_speed = instance->speed == USB_SPEED_LOW;
-        int toggle = 1;
-        size_t i = 0;
-        for (;i < instance->packets; ++i) {
-                char *data =
-                    instance->transport_buffer + (i  * instance->max_packet_size);
-                transfer_descriptor_t *next = (i + 1) < instance->packets ?
-                    &instance->tds[i + 1] : NULL;
-                toggle = 1 - toggle;
-
-                transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
-                    instance->max_packet_size, toggle, false, low_speed,
-                    instance->target, USB_PID_IN, data, next);
-        }
-
-        instance->tds[i - 1].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
-
+        batch_data(instance, USB_PID_IN);
         instance->next_step = batch_call_in_and_dispose;
         usb_log_debug("Batch(%p) INTERRUPT IN initialized.\n", instance);
@@ -219 +214 @@
         assert(instance);
         memcpy(instance->transport_buffer, instance->buffer, instance->buffer_size);
-
-        const bool low_speed = instance->speed == USB_SPEED_LOW;
-        int toggle = 1;
-        size_t i = 0;
-        for (;i < instance->packets; ++i) {
-                char *data =
-                    instance->transport_buffer + (i  * instance->max_packet_size);
-                transfer_descriptor_t *next = (i + 1) < instance->packets ?
-                    &instance->tds[i + 1] : NULL;
-                toggle = 1 - toggle;
-
-                transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
-                    instance->max_packet_size, toggle++, false, low_speed,
-                    instance->target, USB_PID_OUT, data, next);
-        }
-
-        instance->tds[i - 1].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
-
+        batch_data(instance, USB_PID_OUT);
         instance->next_step = batch_call_out_and_dispose;
         usb_log_debug("Batch(%p) INTERRUPT OUT initialized.\n", instance);
@@ -242 +220 @@
 }
 /*----------------------------------------------------------------------------*/
-static void batch_control(
-    batch_t *instance, int data_stage, int status_stage)
+void batch_bulk_in(batch_t *instance)
+{
+        assert(instance);
+        batch_data(instance, USB_PID_IN);
+        instance->next_step = batch_call_in_and_dispose;
+        usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
+        batch_schedule(instance);
+}
+/*----------------------------------------------------------------------------*/
+void batch_bulk_out(batch_t *instance)
+{
+        assert(instance);
+        memcpy(instance->transport_buffer, instance->buffer, instance->buffer_size);
+        batch_data(instance, USB_PID_OUT);
+        instance->next_step = batch_call_out_and_dispose;
+        usb_log_debug("Batch(%p) BULK OUT initialized.\n", instance);
+        batch_schedule(instance);
+}
+/*----------------------------------------------------------------------------*/
+void batch_data(batch_t *instance, usb_packet_id pid)
+{
+        assert(instance);
+        const bool low_speed = instance->speed == USB_SPEED_LOW;
+        int toggle = device_keeper_get_toggle(instance->manager, instance->target);
+        assert(toggle == 0 || toggle == 1);
+
+        size_t packet = 0;
+        size_t remain_size = instance->buffer_size;
+        while (remain_size > 0) {
+                char *data =
+                    instance->transport_buffer + instance->buffer_size
+                    - remain_size;
+
+
+                const size_t packet_size =
+                    (instance->max_packet_size > remain_size) ?
+                    remain_size : instance->max_packet_size;
+
+                td_init(&instance->tds[packet],
+                    DEFAULT_ERROR_COUNT, packet_size, toggle, false, low_speed,
+                    instance->target, pid, data,
+                    &instance->tds[packet + 1]);
+
+                toggle = 1 - toggle;
+                ++packet;
+                assert(packet <= instance->packets);
+                assert(packet_size <= remain_size);
+                remain_size -= packet_size;
+        }
+        device_keeper_set_toggle(instance->manager, instance->target, toggle);
+
+        instance->tds[packet - 1].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
+        instance->tds[packet - 1].next = 0 | LINK_POINTER_TERMINATE_FLAG;
+}
+/*----------------------------------------------------------------------------*/
+void batch_control(batch_t *instance,
+   usb_packet_id data_stage, usb_packet_id status_stage)
 {
         assert(instance);
@@ -250 +283 @@
         int toggle = 0;
         /* setup stage */
-        transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
+        td_init(instance->tds, DEFAULT_ERROR_COUNT,
             instance->setup_size, toggle, false, low_speed, instance->target,
             USB_PID_SETUP, instance->setup_buffer, &instance->tds[1]);
@@ -268 +301 @@
                     remain_size : instance->max_packet_size;
 
-                transfer_descriptor_init(&instance->tds[packet],
+                td_init(&instance->tds[packet],
                     DEFAULT_ERROR_COUNT, packet_size, toggle, false, low_speed,
                     instance->target, data_stage, data,
@@ -281 +314 @@
         /* status stage */
         assert(packet == instance->packets - 1);
-        transfer_descriptor_init(&instance->tds[packet], DEFAULT_ERROR_COUNT,
+        td_init(&instance->tds[packet], DEFAULT_ERROR_COUNT,
             0, 1, false, low_speed, instance->target, status_stage, NULL, NULL);
 
@@ -323 +356 @@
         assert(instance);
         batch_call_in(instance);
+        batch_dispose(instance);
+}
+/*----------------------------------------------------------------------------*/
+void batch_call_out_and_dispose(batch_t *instance)
+{
+        assert(instance);
+        batch_call_out(instance);
+        batch_dispose(instance);
+}
+/*----------------------------------------------------------------------------*/
+void batch_dispose(batch_t *instance)
+{
+        assert(instance);
         usb_log_debug("Batch(%p) disposing.\n", instance);
         free32(instance->tds);
@@ -331 +377 @@
 }
 /*----------------------------------------------------------------------------*/
-void batch_call_out_and_dispose(batch_t *instance)
-{
-        assert(instance);
-        batch_call_out(instance);
-        usb_log_debug("Batch(%p) disposing.\n", instance);
-        free32(instance->tds);
-        free32(instance->qh);
-        free32(instance->setup_buffer);
-        free32(instance->transport_buffer);
-        free(instance);
-}
-/*----------------------------------------------------------------------------*/
 int batch_schedule(batch_t *instance)
 {

uspace/drv/uhci-hcd/batch.h

@@ -42 +42 @@
 #include "uhci_struct/transfer_descriptor.h"
 #include "uhci_struct/queue_head.h"
+#include "utils/device_keeper.h"
 
 typedef struct batch
@@ -65 +66 @@
         ddf_fun_t *fun;
         queue_head_t *qh;
-        transfer_descriptor_t *tds;
+        td_t *tds;
         void (*next_step)(struct batch*);
+        device_keeper_t *manager;
 } batch_t;
 
@@ -74 +76 @@
                 char *setup_buffer, size_t setup_size,
     usbhc_iface_transfer_in_callback_t func_in,
-    usbhc_iface_transfer_out_callback_t func_out, void *arg);
+    usbhc_iface_transfer_out_callback_t func_out, void *arg,
+                device_keeper_t *manager
+                );
 
 bool batch_is_complete(batch_t *instance);
@@ -86 +90 @@
 void batch_interrupt_out(batch_t *instance);
 
-/* DEPRECATED FUNCTIONS NEEDED BY THE OLD API */
-void batch_control_setup_old(batch_t *instance);
+void batch_bulk_in(batch_t *instance);
 
-void batch_control_write_data_old(batch_t *instance);
-
-void batch_control_read_data_old(batch_t *instance);
-
-void batch_control_write_status_old(batch_t *instance);
-
-void batch_control_read_status_old(batch_t *instance);
+void batch_bulk_out(batch_t *instance);
 #endif
 /**

uspace/drv/uhci-hcd/iface.c

@@ -114 +114 @@
 
         batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
-            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg);
+            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
+            &hc->device_manager);
         if (!batch)
                 return ENOMEM;
@@ -133 +134 @@
 
         batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
-            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg);
+            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
+                        &hc->device_manager);
         if (!batch)
                 return ENOMEM;
         batch_interrupt_in(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static int bulk_out(ddf_fun_t *fun, usb_target_t target,
+    size_t max_packet_size, void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        assert(fun);
+        uhci_t *hc = fun_to_uhci(fun);
+        assert(hc);
+        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
+
+        usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
+            target.address, target.endpoint, size, max_packet_size);
+
+        batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
+            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
+            &hc->device_manager);
+        if (!batch)
+                return ENOMEM;
+        batch_bulk_out(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static int bulk_in(ddf_fun_t *fun, usb_target_t target,
+    size_t max_packet_size, void *data, size_t size,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+        assert(fun);
+        uhci_t *hc = fun_to_uhci(fun);
+        assert(hc);
+        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
+        usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
+            target.address, target.endpoint, size, max_packet_size);
+
+        batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
+            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
+            &hc->device_manager);
+        if (!batch)
+                return ENOMEM;
+        batch_bulk_in(batch);
         return EOK;
 }
@@ -152 +195 @@
             target.address, target.endpoint, size, max_packet_size);
 
+        if (setup_size != 8)
+                return EINVAL;
+
         batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
             max_packet_size, speed, data, size, setup_data, setup_size,
-            NULL, callback, arg);
-        if (!batch)
-                return ENOMEM;
+            NULL, callback, arg, &hc->device_manager);
+        if (!batch)
+                return ENOMEM;
+        device_keeper_reset_if_need(&hc->device_manager, target, setup_data);
         batch_control_write(batch);
         return EOK;
@@ -175 +222 @@
         batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
             max_packet_size, speed, data, size, setup_data, setup_size, callback,
-            NULL, arg);
+            NULL, arg, &hc->device_manager);
         if (!batch)
                 return ENOMEM;
@@ -181 +228 @@
         return EOK;
 }
-
-
 /*----------------------------------------------------------------------------*/
 usbhc_iface_t uhci_iface = {
@@ -194 +239 @@
         .interrupt_in = interrupt_in,
 
+        .bulk_in = bulk_in,
+        .bulk_out = bulk_out,
+
         .control_read = control_read,
         .control_write = control_write,

uspace/drv/uhci-hcd/uhci.c

@@ -167 +167 @@
         /* reset hc, all states and counters */
         pio_write_16(&instance->registers->usbcmd, UHCI_CMD_HCRESET);
-        while ((pio_read_16(&instance->registers->usbcmd) & UHCI_CMD_HCRESET) != 0)
-                { async_usleep(10); }
+        do { async_usleep(10); }
+        while ((pio_read_16(&instance->registers->usbcmd) & UHCI_CMD_HCRESET) != 0);
 
         /* set framelist pointer */
@@ -175 +175 @@
 
         /* enable all interrupts, but resume interrupt */
-        pio_write_16(&instance->registers->usbintr,
-            UHCI_INTR_CRC | UHCI_INTR_COMPLETE | UHCI_INTR_SHORT_PACKET);
-
+//      pio_write_16(&instance->registers->usbintr,
+//          UHCI_INTR_CRC | UHCI_INTR_COMPLETE | UHCI_INTR_SHORT_PACKET);
+
+        uint16_t status = pio_read_16(&instance->registers->usbcmd);
+        usb_log_warning("Previous command value: %x.\n", status);
         /* Start the hc with large(64B) packet FSBR */
         pio_write_16(&instance->registers->usbcmd,
@@ -336 +338 @@
                 uhci_interrupt(instance, status);
                 pio_write_16(&instance->registers->usbsts, 0x1f);
-                async_usleep(UHCI_CLEANER_TIMEOUT * 5);
+                async_usleep(UHCI_CLEANER_TIMEOUT);
         }
         return EOK;

uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.c

@@ -38 +38 @@
 #include "utils/malloc32.h"
 
-void transfer_descriptor_init(transfer_descriptor_t *instance,
-    int error_count, size_t size, bool toggle, bool isochronous, bool low_speed,
-    usb_target_t target, int pid, void *buffer, transfer_descriptor_t *next)
+void td_init(td_t *instance, int err_count, size_t size, bool toggle, bool iso,
+    bool low_speed, usb_target_t target, usb_packet_id pid, void *buffer, td_t *next)
 {
         assert(instance);
+        assert(size < 1024);
+        assert((pid == USB_PID_SETUP) || (pid == USB_PID_IN) || (pid == USB_PID_OUT));
 
         instance->next = 0
@@ -49 +50 @@
 
         instance->status = 0
-          | ((error_count & TD_STATUS_ERROR_COUNT_MASK) << TD_STATUS_ERROR_COUNT_POS)
-                | (low_speed ? TD_STATUS_LOW_SPEED_FLAG : 0)
-          | TD_STATUS_ERROR_ACTIVE;
+            | ((err_count & TD_STATUS_ERROR_COUNT_MASK) << TD_STATUS_ERROR_COUNT_POS)
+            | (low_speed ? TD_STATUS_LOW_SPEED_FLAG : 0)
+            | (iso ? TD_STATUS_ISOCHRONOUS_FLAG : 0)
+            | TD_STATUS_ERROR_ACTIVE;
 
-        assert(size < 1024);
+        if (pid == USB_PID_IN && !iso) {
+                instance->status |= TD_STATUS_SPD_FLAG;
+        }
+
         instance->device = 0
-                | (((size - 1) & TD_DEVICE_MAXLEN_MASK) << TD_DEVICE_MAXLEN_POS)
-                | (toggle ? TD_DEVICE_DATA_TOGGLE_ONE_FLAG : 0)
-                | ((target.address & TD_DEVICE_ADDRESS_MASK) << TD_DEVICE_ADDRESS_POS)
-                | ((target.endpoint & TD_DEVICE_ENDPOINT_MASK) << TD_DEVICE_ENDPOINT_POS)
-                | ((pid & TD_DEVICE_PID_MASK) << TD_DEVICE_PID_POS);
+            | (((size - 1) & TD_DEVICE_MAXLEN_MASK) << TD_DEVICE_MAXLEN_POS)
+            | (toggle ? TD_DEVICE_DATA_TOGGLE_ONE_FLAG : 0)
+            | ((target.address & TD_DEVICE_ADDRESS_MASK) << TD_DEVICE_ADDRESS_POS)
+            | ((target.endpoint & TD_DEVICE_ENDPOINT_MASK) << TD_DEVICE_ENDPOINT_POS)
+            | ((pid & TD_DEVICE_PID_MASK) << TD_DEVICE_PID_POS);
 
         instance->buffer_ptr = 0;
@@ -68 +73 @@
 
         usb_log_debug2("Created TD: %X:%X:%X:%X(%p).\n",
-                instance->next, instance->status, instance->device,
-          instance->buffer_ptr, buffer);
+            instance->next, instance->status, instance->device,
+            instance->buffer_ptr, buffer);
+        if (pid == USB_PID_SETUP) {
+                usb_log_debug("SETUP BUFFER: %s\n",
+                        usb_debug_str_buffer(buffer, 8, 8));
+        }
 }
 /*----------------------------------------------------------------------------*/
-int transfer_descriptor_status(transfer_descriptor_t *instance)
+int td_status(td_t *instance)
 {
         assert(instance);

uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.h

@@ -88 +88 @@
          * we don't use it anyway
          */
-} __attribute__((packed)) transfer_descriptor_t;
+} __attribute__((packed)) td_t;
 
 
-void transfer_descriptor_init(transfer_descriptor_t *instance,
-    int error_count, size_t size, bool toggle, bool isochronous, bool low_speed,
-    usb_target_t target, int pid, void *buffer, transfer_descriptor_t * next);
+void td_init(td_t *instance, int error_count, size_t size, bool toggle, bool iso,
+    bool low_speed, usb_target_t target, usb_packet_id pid, void *buffer,
+    td_t *next);
 
-int transfer_descriptor_status(transfer_descriptor_t *instance);
+int td_status(td_t *instance);
 
-static inline size_t transfer_descriptor_actual_size(
-    transfer_descriptor_t *instance)
+static inline size_t td_act_size(td_t *instance)
 {
         assert(instance);
         return
-            ((instance->status >> TD_STATUS_ACTLEN_POS) + 1) & TD_STATUS_ACTLEN_MASK;
+            ((instance->status >> TD_STATUS_ACTLEN_POS) + 1)
+            & TD_STATUS_ACTLEN_MASK;
 }
 
-static inline bool transfer_descriptor_is_active(
-    transfer_descriptor_t *instance)
+static inline bool td_is_short(td_t *instance)
+{
+        const size_t act_size = td_act_size(instance);
+        const size_t max_size =
+            ((instance->device >> TD_DEVICE_MAXLEN_POS) + 1)
+            & TD_DEVICE_MAXLEN_MASK;
+        return
+            (instance->status | TD_STATUS_SPD_FLAG) && act_size < max_size;
+}
+
+static inline int td_toggle(td_t *instance)
+{
+        assert(instance);
+        return ((instance->device & TD_DEVICE_DATA_TOGGLE_ONE_FLAG) != 0)
+            ? 1 : 0;
+}
+
+static inline bool td_is_active(td_t *instance)
 {
         assert(instance);

uspace/drv/uhci-hcd/utils/device_keeper.c

@@ -49 +49 @@
                 instance->devices[i].occupied = false;
                 instance->devices[i].handle = 0;
+                instance->devices[i].toggle_status = 0;
         }
 }
@@ -73 +74 @@
         fibril_mutex_unlock(&instance->guard);
         fibril_condvar_signal(&instance->default_address_occupied);
+}
+/*----------------------------------------------------------------------------*/
+void device_keeper_reset_if_need(
+    device_keeper_t *instance, usb_target_t target, const unsigned char *data)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        if (target.endpoint > 15 || target.endpoint < 0
+            || target.address >= USB_ADDRESS_COUNT || target.address < 0
+            || !instance->devices[target.address].occupied) {
+                goto the_end;
+        }
+
+        switch (data[1])
+        {
+        case 0x01: /*clear feature*/
+                /* recipient is enpoint, value is zero (ENDPOINT_STALL) */
+                if (((data[0] & 0xf) == 1) && ((data[2] | data[3]) == 0)) {
+                        /* enpoint number is < 16, thus first byte is enough */
+                        instance->devices[target.address].toggle_status &= ~(1 << data[4]);
+                }
+        break;
+
+        case 0x9: /* set configuration */
+        case 0x11: /* set interface */
+                instance->devices[target.address].toggle_status = 0;
+        break;
+        }
+the_end:
+        fibril_mutex_unlock(&instance->guard);
+}
+/*----------------------------------------------------------------------------*/
+int device_keeper_get_toggle(device_keeper_t *instance, usb_target_t target)
+{
+        assert(instance);
+        int ret;
+        fibril_mutex_lock(&instance->guard);
+        if (target.endpoint > 15 || target.endpoint < 0
+            || target.address >= USB_ADDRESS_COUNT || target.address < 0
+            || !instance->devices[target.address].occupied) {
+                ret = EINVAL;
+        } else {
+                ret = (instance->devices[target.address].toggle_status >> target.endpoint) & 1;
+        }
+        fibril_mutex_unlock(&instance->guard);
+        return ret;
+}
+/*----------------------------------------------------------------------------*/
+int device_keeper_set_toggle(
+    device_keeper_t *instance, usb_target_t target, bool toggle)
+{
+        assert(instance);
+        int ret;
+        fibril_mutex_lock(&instance->guard);
+        if (target.endpoint > 15 || target.endpoint < 0
+            || target.address >= USB_ADDRESS_COUNT || target.address < 0
+            || !instance->devices[target.address].occupied) {
+                ret = EINVAL;
+        } else {
+                if (toggle) {
+                        instance->devices[target.address].toggle_status |= (1 << target.endpoint);
+                } else {
+                        instance->devices[target.address].toggle_status &= ~(1 << target.endpoint);
+                }
+                ret = EOK;
+        }
+        fibril_mutex_unlock(&instance->guard);
+        return ret;
 }
 /*----------------------------------------------------------------------------*/
@@ -96 +165 @@
         instance->devices[new_address].occupied = true;
         instance->devices[new_address].speed = speed;
+        instance->devices[new_address].toggle_status = 0;
         instance->last_address = new_address;
         fibril_mutex_unlock(&instance->guard);

uspace/drv/uhci-hcd/utils/device_keeper.h

@@ -44 +44 @@
         usb_speed_t speed;
         bool occupied;
+        uint16_t toggle_status;
         devman_handle_t handle;
 };
@@ -55 +56 @@
 
 void device_keeper_init(device_keeper_t *instance);
+
 void device_keeper_reserve_default(
     device_keeper_t *instance, usb_speed_t speed);
+
 void device_keeper_release_default(device_keeper_t *instance);
+
+void device_keeper_reset_if_need(
+    device_keeper_t *instance, usb_target_t target, const unsigned char *setup_data);
+
+int device_keeper_get_toggle(device_keeper_t *instance, usb_target_t target);
+
+int device_keeper_set_toggle(
+    device_keeper_t *instance, usb_target_t target, bool toggle);
 
 usb_address_t device_keeper_request(
     device_keeper_t *instance, usb_speed_t speed);
+
 void device_keeper_bind(
     device_keeper_t *instance, usb_address_t address, devman_handle_t handle);
+
 void device_keeper_release(device_keeper_t *instance, usb_address_t address);
+
 usb_address_t device_keeper_find(
     device_keeper_t *instance, devman_handle_t handle);

uspace/drv/usbhid/hidreq.c

@@ -69 +69 @@
                 return sess_rc;
         }
+        
+        uint16_t value = 0;
+        value |= (type << 8);
 
         usb_log_debug("Sending Set_Report request to the device.\n");
@@ -74 +77 @@
         rc = usb_control_request_set(&hid_dev->ctrl_pipe, 
             USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
-            USB_HIDREQ_SET_REPORT, type, hid_dev->iface, buffer, buf_size);
+            USB_HIDREQ_SET_REPORT, value, hid_dev->iface, buffer, buf_size);
 
         sess_rc = usb_endpoint_pipe_end_session(&hid_dev->ctrl_pipe);
@@ -137 +140 @@
                 return sess_rc;
         }
+        
+        return EOK;
+}
+
+/*----------------------------------------------------------------------------*/
+
+int usbhid_req_set_idle(usbhid_dev_t *hid_dev, uint8_t duration)
+{
+        if (hid_dev == NULL) {
+                usb_log_error("usbhid_req_set_idle(): no HID device "
+                    "structure given.\n");
+                return EINVAL;
+        }
+        
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+        
+        int rc, sess_rc;
+        
+        sess_rc = usb_endpoint_pipe_start_session(&hid_dev->ctrl_pipe);
+        if (sess_rc != EOK) {
+                usb_log_warning("Failed to start a session: %s.\n",
+                    str_error(sess_rc));
+                return sess_rc;
+        }
+
+        usb_log_debug("Sending Set_Idle request to the device ("
+            "duration: %u, iface: %d).\n", duration, hid_dev->iface);
+        
+        uint16_t value = duration << 8;
+        
+        rc = usb_control_request_set(&hid_dev->ctrl_pipe, 
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
+            USB_HIDREQ_SET_IDLE, value, hid_dev->iface, NULL, 0);
+
+        sess_rc = usb_endpoint_pipe_end_session(&hid_dev->ctrl_pipe);
+
+        if (rc != EOK) {
+                usb_log_warning("Error sending output report to the keyboard: "
+                    "%s.\n", str_error(rc));
+                return rc;
+        }
+
+        if (sess_rc != EOK) {
+                usb_log_warning("Error closing session: %s.\n",
+                    str_error(sess_rc));
+                return sess_rc;
+        }
+        
+        return EOK;
+}
+
+/*----------------------------------------------------------------------------*/
+
+int usbhid_req_get_report(usbhid_dev_t *hid_dev, usb_hid_report_type_t type, 
+    uint8_t *buffer, size_t buf_size, size_t *actual_size)
+{
+        if (hid_dev == NULL) {
+                usb_log_error("usbhid_req_set_report(): no HID device structure"
+                    " given.\n");
+                return EINVAL;
+        }
+        
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+        
+        int rc, sess_rc;
+        
+        sess_rc = usb_endpoint_pipe_start_session(&hid_dev->ctrl_pipe);
+        if (sess_rc != EOK) {
+                usb_log_warning("Failed to start a session: %s.\n",
+                    str_error(sess_rc));
+                return sess_rc;
+        }
+
+        uint16_t value = 0;
+        value |= (type << 8);
+        
+        usb_log_debug("Sending Get_Report request to the device.\n");
+        
+        rc = usb_control_request_get(&hid_dev->ctrl_pipe, 
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
+            USB_HIDREQ_GET_REPORT, value, hid_dev->iface, buffer, buf_size,
+            actual_size);
+
+        sess_rc = usb_endpoint_pipe_end_session(&hid_dev->ctrl_pipe);
+
+        if (rc != EOK) {
+                usb_log_warning("Error sending output report to the keyboard: "
+                    "%s.\n", str_error(rc));
+                return rc;
+        }
+
+        if (sess_rc != EOK) {
+                usb_log_warning("Error closing session: %s.\n",
+                    str_error(sess_rc));
+                return sess_rc;
+        }
+        
+        return EOK;
+}
+
+int usbhid_req_get_protocol(usbhid_dev_t *hid_dev, usb_hid_protocol_t *protocol)
+{
+        if (hid_dev == NULL) {
+                usb_log_error("usbhid_req_set_protocol(): no HID device "
+                    "structure given.\n");
+                return EINVAL;
+        }
+        
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+        
+        int rc, sess_rc;
+        
+        sess_rc = usb_endpoint_pipe_start_session(&hid_dev->ctrl_pipe);
+        if (sess_rc != EOK) {
+                usb_log_warning("Failed to start a session: %s.\n",
+                    str_error(sess_rc));
+                return sess_rc;
+        }
+
+        usb_log_debug("Sending Get_Protocol request to the device ("
+            "iface: %d).\n", hid_dev->iface);
+        
+        uint8_t buffer[1];
+        size_t actual_size = 0;
+        
+        rc = usb_control_request_get(&hid_dev->ctrl_pipe, 
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
+            USB_HIDREQ_GET_PROTOCOL, 0, hid_dev->iface, buffer, 1, &actual_size);
+
+        sess_rc = usb_endpoint_pipe_end_session(&hid_dev->ctrl_pipe);
+
+        if (rc != EOK) {
+                usb_log_warning("Error sending output report to the keyboard: "
+                    "%s.\n", str_error(rc));
+                return rc;
+        }
+
+        if (sess_rc != EOK) {
+                usb_log_warning("Error closing session: %s.\n",
+                    str_error(sess_rc));
+                return sess_rc;
+        }
+        
+        if (actual_size != 1) {
+                usb_log_warning("Wrong data size: %zu, expected: 1.\n",
+                        actual_size);
+                return ELIMIT;
+        }
+        
+        *protocol = buffer[0];
+        
+        return EOK;
+}
+
+int usbhid_req_get_idle(usbhid_dev_t *hid_dev, uint8_t *duration)
+{
+        if (hid_dev == NULL) {
+                usb_log_error("usbhid_req_set_idle(): no HID device "
+                    "structure given.\n");
+                return EINVAL;
+        }
+        
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+        
+        int rc, sess_rc;
+        
+        sess_rc = usb_endpoint_pipe_start_session(&hid_dev->ctrl_pipe);
+        if (sess_rc != EOK) {
+                usb_log_warning("Failed to start a session: %s.\n",
+                    str_error(sess_rc));
+                return sess_rc;
+        }
+
+        usb_log_debug("Sending Get_Idle request to the device ("
+            "iface: %d).\n", hid_dev->iface);
+        
+        uint16_t value = 0;
+        uint8_t buffer[1];
+        size_t actual_size = 0;
+        
+        rc = usb_control_request_get(&hid_dev->ctrl_pipe, 
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
+            USB_HIDREQ_GET_IDLE, value, hid_dev->iface, buffer, 1, 
+            &actual_size);
+
+        sess_rc = usb_endpoint_pipe_end_session(&hid_dev->ctrl_pipe);
+
+        if (rc != EOK) {
+                usb_log_warning("Error sending output report to the keyboard: "
+                    "%s.\n", str_error(rc));
+                return rc;
+        }
+
+        if (sess_rc != EOK) {
+                usb_log_warning("Error closing session: %s.\n",
+                    str_error(sess_rc));
+                return sess_rc;
+        }
+        
+        if (actual_size != 1) {
+                usb_log_warning("Wrong data size: %zu, expected: 1.\n",
+                        actual_size);
+                return ELIMIT;
+        }
+        
+        *duration = buffer[0];
         
         return EOK;

uspace/drv/usbhid/hidreq.h

@@ -50 +50 @@
 int usbhid_req_set_protocol(usbhid_dev_t *hid_dev, usb_hid_protocol_t protocol);
 
+int usbhid_req_set_idle(usbhid_dev_t *hid_dev, uint8_t duration);
+
+int usbhid_req_get_report(usbhid_dev_t *hid_dev, usb_hid_report_type_t type, 
+    uint8_t *buffer, size_t buf_size, size_t *actual_size);
+
+int usbhid_req_get_protocol(usbhid_dev_t *hid_dev, usb_hid_protocol_t *protocol);
+
+int usbhid_req_get_idle(usbhid_dev_t *hid_dev, uint8_t *duration);
+
 /*----------------------------------------------------------------------------*/
 

uspace/drv/usbhid/kbddev.c

@@ -38 +38 @@
 #include <str_error.h>
 #include <fibril.h>
+#include <stdio.h>
 
 #include <io/keycode.h>
@@ -62 +63 @@
 static const size_t BOOTP_BUFFER_SIZE = 8;
 static const size_t BOOTP_BUFFER_OUT_SIZE = 1;
+static const uint8_t BOOTP_ERROR_ROLLOVER = 1;
+static const uint8_t IDLE_RATE = 0;
 
 /** Keyboard polling endpoint description for boot protocol class. */
@@ -149 +152 @@
         uint8_t buffer[BOOTP_BUFFER_OUT_SIZE];
         int rc= 0;
-        unsigned i;
         
         memset(buffer, 0, BOOTP_BUFFER_OUT_SIZE);
@@ -177 +179 @@
         }
         
-        // TODO: REFACTOR!!!
-        
-        usb_log_debug("Output report buffer: ");
-        for (i = 0; i < BOOTP_BUFFER_OUT_SIZE; ++i) {
-                usb_log_debug("0x%x ", buffer[i]);
-        }
-        usb_log_debug("\n");
-        
-        uint16_t value = 0;
-        value |= (USB_HID_REPORT_TYPE_OUTPUT << 8);
-
+        usb_log_debug("Output report buffer: %s\n", 
+            usb_debug_str_buffer(buffer, BOOTP_BUFFER_OUT_SIZE, 0));
+        
         assert(kbd_dev->hid_dev != NULL);
         assert(kbd_dev->hid_dev->initialized);
-        usbhid_req_set_report(kbd_dev->hid_dev, value, buffer, 
-            BOOTP_BUFFER_OUT_SIZE);
+        usbhid_req_set_report(kbd_dev->hid_dev, USB_HID_REPORT_TYPE_OUTPUT, 
+            buffer, BOOTP_BUFFER_OUT_SIZE);
 }
 
@@ -228 +222 @@
 
         if (mod_mask != 0) {
-                usb_log_debug2("\n\nChanging mods and lock keys\n");
-                usb_log_debug2("\nmods before: 0x%x\n", kbd_dev->mods);
-                usb_log_debug2("\nLock keys before:0x%x\n\n", 
-                    kbd_dev->lock_keys);
-                
                 if (type == KEY_PRESS) {
-                        usb_log_debug2("\nKey pressed.\n");
                         /*
                          * Only change lock state on transition from released
@@ -247 +235 @@
                         usbhid_kbd_set_led(kbd_dev);
                 } else {
-                        usb_log_debug2("\nKey released.\n");
                         kbd_dev->lock_keys = kbd_dev->lock_keys & ~mod_mask;
                 }
         }
 
-        usb_log_debug2("\n\nmods after: 0x%x\n", kbd_dev->mods);
-        usb_log_debug2("\nLock keys after: 0x%x\n\n", kbd_dev->lock_keys);
-        
         if (key == KC_CAPS_LOCK || key == KC_NUM_LOCK || key == KC_SCROLL_LOCK) {
                 // do not send anything to the console, this is our business
@@ -281 +265 @@
         ev.key = key;
         ev.mods = kbd_dev->mods;
-        
-        if (ev.mods & KM_NUM_LOCK) {
-                usb_log_debug("\n\nNum Lock turned on.\n\n");
-        }
 
         ev.c = layout[active_layout]->parse_ev(&ev);
@@ -340 +320 @@
     const uint8_t *key_codes)
 {
-        // TODO: phantom state!!
-        
         unsigned int key;
         unsigned int i, j;
+        
+        /*
+         * First of all, check if the kbd have reported phantom state.
+         */
+        i = 0;
+        // all fields should report Error Rollover
+        while (i < kbd_dev->keycode_count &&
+            key_codes[i] == BOOTP_ERROR_ROLLOVER) {
+                ++i;
+        }
+        if (i == kbd_dev->keycode_count) {
+                usb_log_debug("Phantom state occured.\n");
+                // phantom state, do nothing
+                return;
+        }
         
         // TODO: quite dummy right now, think of better implementation
@@ -362 +355 @@
                         key = usbhid_parse_scancode(kbd_dev->keycodes[j]);
                         usbhid_kbd_push_ev(kbd_dev, KEY_RELEASE, key);
-                        usb_log_debug2("\nKey released: %d\n", key);
+                        usb_log_debug2("Key released: %d\n", key);
                 } else {
                         // found, nothing happens
@@ -382 +375 @@
                         // not found, i.e. new key pressed
                         key = usbhid_parse_scancode(key_codes[i]);
-                        usb_log_debug2("\nKey pressed: %d (keycode: %d)\n", key,
+                        usb_log_debug2("Key pressed: %d (keycode: %d)\n", key,
                             key_codes[i]);
                         usbhid_kbd_push_ev(kbd_dev, KEY_PRESS, key);
@@ -389 +382 @@
                 }
         }
+//      // report all currently pressed keys
+//      for (i = 0; i < kbd_dev->keycode_count; ++i) {
+//              if (key_codes[i] != 0) {
+//                      key = usbhid_parse_scancode(key_codes[i]);
+//                      usb_log_debug2("Key pressed: %d (keycode: %d)\n", key,
+//                          key_codes[i]);
+//                      usbhid_kbd_push_ev(kbd_dev, KEY_PRESS, key);
+//              }
+//      }
         
         memcpy(kbd_dev->keycodes, key_codes, kbd_dev->keycode_count);
-        
-        usb_log_debug2("\nNew stored keycodes: ");
-        for (i = 0; i < kbd_dev->keycode_count; ++i) {
-                usb_log_debug2("%d ", kbd_dev->keycodes[i]);
-        }
+
+        usb_log_debug("New stored keycodes: %s\n", 
+            usb_debug_str_buffer(kbd_dev->keycodes, kbd_dev->keycode_count, 0));
 }
 
@@ -410 +410 @@
                 return;
         }
-
-        usb_log_debug2("Got keys from parser: ");
-        unsigned i;
-        for (i = 0; i < count; ++i) {
-                usb_log_debug2("%d ", key_codes[i]);
-        }
-        usb_log_debug2("\n");
         
         usbhid_kbd_t *kbd_dev = (usbhid_kbd_t *)arg;
         assert(kbd_dev != NULL);
+
+        usb_log_debug("Got keys from parser: %s\n", 
+            usb_debug_str_buffer(key_codes, kbd_dev->keycode_count, 0));
         
         if (count != kbd_dev->keycode_count) {
@@ -444 +440 @@
         callbacks->keyboard = usbhid_kbd_process_keycodes;
 
-        //usb_hid_parse_report(kbd_dev->parser, buffer, actual_size, callbacks, 
-        //    NULL);
-        /*usb_log_debug2("Calling usb_hid_boot_keyboard_input_report() with size"
-            " %zu\n", actual_size);*/
-        //dump_buffer("bufffer: ", buffer, actual_size);
+        usb_log_debug("Calling usb_hid_boot_keyboard_input_report() with "
+            "buffer %s\n", usb_debug_str_buffer(buffer, actual_size, 0));
         
         int rc = usb_hid_boot_keyboard_input_report(buffer, actual_size,
@@ -559 +552 @@
          * Set boot protocol.
          * Set LEDs according to initial setup.
+         * Set Idle rate
          */
         assert(kbd_dev->hid_dev != NULL);
@@ -565 +559 @@
         
         usbhid_kbd_set_led(kbd_dev);
+        
+        usbhid_req_set_idle(kbd_dev->hid_dev, IDLE_RATE);
         
         kbd_dev->initialized = 1;
@@ -634 +630 @@
                 usbhid_kbd_process_data(kbd_dev, buffer, actual_size);
                 
-                async_usleep(kbd_dev->hid_dev->poll_interval);
+                // disabled for now, no reason to sleep
+                //async_usleep(kbd_dev->hid_dev->poll_interval);
         }
 

uspace/drv/usbhid/main.c

@@ -80 +80 @@
 int main(int argc, char *argv[])
 {
-        usb_log_enable(USB_LOG_LEVEL_INFO, NAME);
+        usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
         return ddf_driver_main(&kbd_driver);
 }

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

@@ -108 +108 @@
         usb_log_printf(USB_LOG_LEVEL_DEBUG2, format, ##__VA_ARGS__)
 
-const char *usb_debug_str_buffer(uint8_t *, size_t, size_t);
+const char *usb_debug_str_buffer(const uint8_t *, size_t, size_t);
 
 

uspace/lib/usb/src/debug.c

@@ -181 +181 @@
  * @return Dumped buffer as a static (but fibril local) string.
  */
-const char *usb_debug_str_buffer(uint8_t *buffer, size_t size,
+const char *usb_debug_str_buffer(const uint8_t *buffer, size_t size,
     size_t dumped_size)
 {