Changes in / [299d53e:8e1eb4d0] in mainline

Location:

uspace

Files:

• drv/usbhid/Makefile (modified) (1 diff)
• drv/usbhid/conv.c (modified) (3 diffs)
• drv/usbhid/descparser.c (added)
• drv/usbhid/descparser.h (added)
• drv/usbhid/hid.h (modified) (2 diffs)
• drv/usbhid/main.c (modified) (27 diffs)
• drv/usbhub/main.c (modified) (2 diffs)
• drv/usbhub/port_status.h (modified) (1 diff)
• drv/usbhub/usbhub.c (modified) (21 diffs)
• drv/usbhub/usbhub.h (modified) (2 diffs)
• lib/usb/include/usb/classes/hid.h (modified) (2 diffs)
• lib/usb/include/usb/classes/hidparser.h (modified) (1 diff)
• lib/usb/include/usb/request.h (modified) (1 diff)
• lib/usb/src/hidparser.c (modified) (1 diff)
• lib/usb/src/request.c (modified) (11 diffs)

uspace/drv/usbhid/Makefile

@@ -39 +39 @@
 SOURCES = \
         main.c \
+        descparser.c \
+        descdump.c \
         conv.c \
         $(STOLEN_LAYOUT_SOURCES)

uspace/drv/usbhid/conv.c

@@ -36 +36 @@
 #include <io/keycode.h>
 #include <stdint.h>
-#include <stdio.h>
-#include <usb/debug.h>
 #include "conv.h"
 
@@ -143 +141 @@
         //[0xe7] = KC_R // TODO: right GUI
         
-        [0x53] = KC_NUM_LOCK,
-        [0x54] = KC_NSLASH,
-        [0x55] = KC_NTIMES,
-        [0x56] = KC_NMINUS,
-        [0x57] = KC_NPLUS,
-        [0x58] = KC_NENTER,
-        [0x59] = KC_N1,
-        [0x5a] = KC_N2,
-        [0x5b] = KC_N3,
-        [0x5c] = KC_N4,
-        [0x5d] = KC_N5,
-        [0x5e] = KC_N6,
-        [0x5f] = KC_N7,
-        [0x60] = KC_N8,
-        [0x61] = KC_N9,
-        [0x62] = KC_N0,
-        [0x63] = KC_NPERIOD
-        
 };
 
@@ -209 +189 @@
 
         key = map[scancode];
-        
-        if (scancode == 0x53) {
-                usb_log_debug("\n\nWe have a NUM LOCK!, sending key %u\n\n", key);
-        }
-        
-        if (scancode == 0x47) {
-                usb_log_debug("\n\nWe have a SCROLL LOCK!, sending key %u\n\n", key);
-        }
-        
-        if (scancode == 0x39) {
-                usb_log_debug("\n\nWe have a CAPS LOCK!, sending key %u\n\n", key);
-        }
-        
 //      if (key != 0)
 //              kbd_push_ev(type, key);

uspace/drv/usbhid/hid.h

@@ -37 +37 @@
 #define USBHID_HID_H_
 
-#include <stdint.h>
-
 #include <usb/classes/hid.h>
 #include <ddf/driver.h>
 #include <usb/pipes.h>
+
+/**
+ *
+ */
+typedef struct {
+        usb_standard_interface_descriptor_t iface_desc;
+        usb_standard_endpoint_descriptor_t *endpoints;
+        usb_standard_hid_descriptor_t hid_desc;
+        uint8_t *report_desc;
+        //usb_standard_hid_class_descriptor_info_t *class_desc_info;
+        //uint8_t **class_descs;
+} usb_hid_iface_t;
+
+/**
+ *
+ */
+typedef struct {
+        usb_standard_configuration_descriptor_t config_descriptor;
+        usb_hid_iface_t *interfaces;
+} usb_hid_configuration_t;
 
 /**
@@ -50 +68 @@
 typedef struct {
         ddf_dev_t *device;
+        usb_hid_configuration_t *conf;
+        usb_hid_report_parser_t *parser;
 
         usb_device_connection_t wire;
         usb_endpoint_pipe_t ctrl_pipe;
         usb_endpoint_pipe_t poll_pipe;
-        
-        uint16_t iface;
-        
-        uint8_t *report_desc;
-        usb_hid_report_parser_t *parser;
-        
-        uint8_t *keycodes;
-        size_t keycode_count;
-        uint8_t modifiers;
-        
-        unsigned mods;
-        unsigned lock_keys;
 } usb_hid_dev_kbd_t;
 
+// TODO: more configurations!
+
 #endif

uspace/drv/usbhid/main.c

@@ -51 +51 @@
 #include <usb/descriptor.h>
 #include <io/console.h>
-#include <stdint.h>
-#include <usb/dp.h>
 #include "hid.h"
+#include "descparser.h"
+#include "descdump.h"
 #include "conv.h"
 #include "layout.h"
 
 #define BUFFER_SIZE 8
-#define BUFFER_OUT_SIZE 1
 #define NAME "usbhid"
 
-//#define GUESSED_POLL_ENDPOINT 1
-#define BOOTP_REPORT_SIZE 6
-
-static unsigned DEFAULT_ACTIVE_MODS = KM_NUM_LOCK;
+#define GUESSED_POLL_ENDPOINT 1
 
 /** Keyboard polling endpoint description for boot protocol class. */
@@ -124 +120 @@
 
 static void dump_buffer(const char *msg, const uint8_t *buffer, size_t length)
-{uint8_t buffer[BUFFER_SIZE];
+{
         printf("%s\n", msg);
         
@@ -141 +137 @@
  */
 
-/** Currently active modifiers (locks is probably better word).
+/** Currently active modifiers. 
  *
  * TODO: put to device?
  */
-//static unsigned mods = KM_NUM_LOCK;
+static unsigned mods = KM_NUM_LOCK;
 
 /** Currently pressed lock keys. We track these to tackle autorepeat.  
@@ -151 +147 @@
  * TODO: put to device? 
  */
-//static unsigned lock_keys;
+static unsigned lock_keys;
 
 #define NUM_LAYOUTS 3
@@ -163 +159 @@
 static int active_layout = 0;
 
-static void usbkbd_req_set_report(usb_hid_dev_kbd_t *kbd_dev, uint16_t iface,
-    usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size)
-{
-        int rc, sess_rc;
-        
-        sess_rc = usb_endpoint_pipe_start_session(&kbd_dev->ctrl_pipe);
-        if (sess_rc != EOK) {
-                usb_log_warning("Failed to start a session: %s.\n",
-                    str_error(sess_rc));
-                return;
-        }
-
-        usb_log_debug("Sending Set_Report request to the device.\n");
-        
-        rc = usb_control_request_set(&kbd_dev->ctrl_pipe, 
-            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
-            USB_HIDREQ_SET_REPORT, type, iface, buffer, buf_size);
-
-        sess_rc = usb_endpoint_pipe_end_session(&kbd_dev->ctrl_pipe);
-
-        if (rc != EOK) {
-                usb_log_warning("Error sending output report to the keyboard: "
-                    "%s.\n", str_error(rc));
-                return;
-        }
-
-        if (sess_rc != EOK) {
-                usb_log_warning("Error closing session: %s.\n",
-                    str_error(sess_rc));
-                return;
-        }
-}
-
-static void usbkbd_req_set_protocol(usb_hid_dev_kbd_t *kbd_dev,
-    usb_hid_protocol_t protocol)
-{
-        int rc, sess_rc;
-        
-        sess_rc = usb_endpoint_pipe_start_session(&kbd_dev->ctrl_pipe);
-        if (sess_rc != EOK) {
-                usb_log_warning("Failed to start a session: %s.\n",
-                    str_error(sess_rc));
-                return;
-        }
-
-        usb_log_debug("Sending Set_Protocol request to the device ("
-            "protocol: %d, iface: %d).\n", protocol, kbd_dev->iface);
-        
-        rc = usb_control_request_set(&kbd_dev->ctrl_pipe, 
-            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
-            USB_HIDREQ_SET_PROTOCOL, protocol, kbd_dev->iface, NULL, 0);
-
-        sess_rc = usb_endpoint_pipe_end_session(&kbd_dev->ctrl_pipe);
-
-        if (rc != EOK) {
-                usb_log_warning("Error sending output report to the keyboard: "
-                    "%s.\n", str_error(rc));
-                return;
-        }
-
-        if (sess_rc != EOK) {
-                usb_log_warning("Error closing session: %s.\n",
-                    str_error(sess_rc));
-                return;
-        }
-}
-
-static void usbkbd_set_led(usb_hid_dev_kbd_t *kbd_dev) 
-{
-        uint8_t buffer[BUFFER_OUT_SIZE];
-        int rc= 0, i;
-        
-        memset(buffer, 0, BUFFER_OUT_SIZE);
-        uint8_t leds = 0;
-
-        if (kbd_dev->mods & KM_NUM_LOCK) {
-                leds |= USB_HID_LED_NUM_LOCK;
-        }
-        
-        if (kbd_dev->mods & KM_CAPS_LOCK) {
-                leds |= USB_HID_LED_CAPS_LOCK;
-        }
-        
-        if (kbd_dev->mods & KM_SCROLL_LOCK) {
-                leds |= USB_HID_LED_SCROLL_LOCK;
-        }
-
-        // TODO: COMPOSE and KANA
-        
-        usb_log_debug("Creating output report.\n");
-        usb_log_debug("Leds: 0x%x\n", leds);
-        if ((rc = usb_hid_boot_keyboard_output_report(
-            leds, buffer, BUFFER_OUT_SIZE)) != EOK) {
-                usb_log_warning("Error composing output report to the keyboard:"
-                    "%s.\n", str_error(rc));
-                return;
-        }
-        
-        usb_log_debug("Output report buffer: ");
-        for (i = 0; i < 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);
-
-        usbkbd_req_set_report(kbd_dev, kbd_dev->iface, value, buffer, 
-            BUFFER_OUT_SIZE);
-}
-
-static void kbd_push_ev(int type, unsigned int key, usb_hid_dev_kbd_t *kbd_dev)
+static void kbd_push_ev(int type, unsigned int key)
 {
         console_event_t ev;
@@ -292 +177 @@
         if (mod_mask != 0) {
                 if (type == KEY_PRESS)
-                        kbd_dev->mods = kbd_dev->mods | mod_mask;
+                        mods = mods | mod_mask;
                 else
-                        kbd_dev->mods = kbd_dev->mods & ~mod_mask;
+                        mods = mods & ~mod_mask;
         }
 
         switch (key) {
-        case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; usb_log_debug2("\n\nPushing CAPS LOCK! (mask: %u)\n\n", mod_mask); break;
-        case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; usb_log_debug2("\n\nPushing NUM LOCK! (mask: %u)\n\n", mod_mask); break;
-        case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; usb_log_debug2("\n\nPushing SCROLL LOCK! (mask: %u)\n\n", mod_mask); break;
+        case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; break;
+        case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; break;
+        case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; break;
         default: mod_mask = 0; break;
         }
 
         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
@@ -316 +196 @@
                          * up the lock state.
                          */
-                        kbd_dev->mods = 
-                            kbd_dev->mods ^ (mod_mask & ~kbd_dev->lock_keys);
-                        kbd_dev->lock_keys = kbd_dev->lock_keys | mod_mask;
+                        mods = mods ^ (mod_mask & ~lock_keys);
+                        lock_keys = lock_keys | mod_mask;
 
                         /* Update keyboard lock indicator lights. */
-                        usbkbd_set_led(kbd_dev);
+                        // TODO
+                        //kbd_ctl_set_ind(mods);
                 } 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 (type == KEY_PRESS && (kbd_dev->mods & KM_LCTRL) && key == KC_F1) {
+                        lock_keys = lock_keys & ~mod_mask;
+                }
+        }
+/*
+        printf("type: %d\n", type);
+        printf("mods: 0x%x\n", mods);
+        printf("keycode: %u\n", key);
+*/
+        
+        if (type == KEY_PRESS && (mods & KM_LCTRL) &&
+                key == KC_F1) {
                 active_layout = 0;
                 layout[active_layout]->reset();
@@ -337 +219 @@
         }
 
-        if (type == KEY_PRESS && (kbd_dev->mods & KM_LCTRL) && key == KC_F2) {
+        if (type == KEY_PRESS && (mods & KM_LCTRL) &&
+                key == KC_F2) {
                 active_layout = 1;
                 layout[active_layout]->reset();
@@ -343 +226 @@
         }
 
-        if (type == KEY_PRESS && (kbd_dev->mods & KM_LCTRL) && key == KC_F3) {
+        if (type == KEY_PRESS && (mods & KM_LCTRL) &&
+                key == KC_F3) {
                 active_layout = 2;
                 layout[active_layout]->reset();
@@ -351 +235 @@
         ev.type = type;
         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.mods = mods;
 
         ev.c = layout[active_layout]->parse_ev(&ev);
 
-        usb_log_debug2("Sending key %d to the console\n", ev.key);
+        printf("Sending key %d to the console\n", ev.key);
         assert(console_callback_phone != -1);
-        async_msg_4(console_callback_phone, KBD_EVENT, ev.type, ev.key, 
-            ev.mods, ev.c);
+        async_msg_4(console_callback_phone, KBD_EVENT, ev.type, ev.key, ev.mods, ev.c);
 }
 /*
@@ -370 +249 @@
         /*
          * TODO:
-         * 1) key press / key release - how does the keyboard notify about 
-         *    release?
+         * 1) key press / key release - how does the keyboard notify about release?
          * 2) layouts (use the already defined), not important now
          * 3) 
          */
 
-static const keycode_t usb_hid_modifiers_keycodes[USB_HID_MOD_COUNT] = {
-        KC_LCTRL,         /* USB_HID_MOD_LCTRL */
-        KC_LSHIFT,        /* USB_HID_MOD_LSHIFT */
-        KC_LALT,          /* USB_HID_MOD_LALT */
-        0,                /* USB_HID_MOD_LGUI */
-        KC_RCTRL,         /* USB_HID_MOD_RCTRL */
-        KC_RSHIFT,        /* USB_HID_MOD_RSHIFT */
-        KC_RALT,          /* USB_HID_MOD_RALT */
-        0,                /* USB_HID_MOD_RGUI */
-};
-
-static void usbkbd_check_modifier_changes(usb_hid_dev_kbd_t *kbd_dev,
-    uint8_t modifiers)
-{
-        /*
-         * TODO: why the USB keyboard has NUM_, SCROLL_ and CAPS_LOCK
-         *       both as modifiers and as keys with their own scancodes???
-         *
-         * modifiers should be sent as normal keys to usbkbd_parse_scancode()!!
-         * so maybe it would be better if I received it from report parser in 
-         * that way
-         */
-        
-        int i;
-        for (i = 0; i < USB_HID_MOD_COUNT; ++i) {
-                if ((modifiers & usb_hid_modifiers_consts[i]) &&
-                    !(kbd_dev->modifiers & usb_hid_modifiers_consts[i])) {
-                        // modifier pressed
-                        if (usb_hid_modifiers_keycodes[i] != 0) {
-                                kbd_push_ev(KEY_PRESS, 
-                                    usb_hid_modifiers_keycodes[i], kbd_dev);
-                        }
-                } else if (!(modifiers & usb_hid_modifiers_consts[i]) &&
-                    (kbd_dev->modifiers & usb_hid_modifiers_consts[i])) {
-                        // modifier released
-                        if (usb_hid_modifiers_keycodes[i] != 0) {
-                                kbd_push_ev(KEY_RELEASE, 
-                                    usb_hid_modifiers_keycodes[i], kbd_dev);
-                        }
-                }       // no change
-        }
-        
-        kbd_dev->modifiers = modifiers;
-}
-
-static void usbkbd_check_key_changes(usb_hid_dev_kbd_t *kbd_dev, 
-    const uint8_t *key_codes)
-{
-        // TODO: phantom state!!
-        
-        unsigned int key;
-        unsigned int i, j;
-        
-        // TODO: quite dummy right now, think of better implementation
-        
-        // key releases
-        for (j = 0; j < kbd_dev->keycode_count; ++j) {
-                // try to find the old key in the new key list
-                i = 0;
-                while (i < kbd_dev->keycode_count
-                    && key_codes[i] != kbd_dev->keycodes[j]) {
-                        ++i;
-                }
-                
-                if (i == kbd_dev->keycode_count) {
-                        // not found, i.e. the key was released
-                        key = usbkbd_parse_scancode(kbd_dev->keycodes[j]);
-                        kbd_push_ev(KEY_RELEASE, key, kbd_dev);
-                        usb_log_debug2("\nKey released: %d\n", key);
-                } else {
-                        // found, nothing happens
-                }
-        }
-        
-        // key presses
-        for (i = 0; i < kbd_dev->keycode_count; ++i) {
-                // try to find the new key in the old key list
-                j = 0;
-                while (j < kbd_dev->keycode_count 
-                    && kbd_dev->keycodes[j] != key_codes[i]) { 
-                        ++j;
-                }
-                
-                if (j == kbd_dev->keycode_count) {
-                        // not found, i.e. new key pressed
-                        key = usbkbd_parse_scancode(key_codes[i]);
-                        usb_log_debug2("\nKey pressed: %d (keycode: %d)\n", key,
-                            key_codes[i]);
-                        kbd_push_ev(KEY_PRESS, key, kbd_dev);
-                } else {
-                        // found, nothing happens
-                }
-        }
-        
-        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]);
-        }
-}
-
 /*
  * Callbacks for parser
@@ -484 +260 @@
     uint8_t modifiers, void *arg)
 {
-        if (arg == NULL) {
-                usb_log_warning("Missing argument in callback "
-                    "usbkbd_process_keycodes().\n");
-                return;
-        }
-
-        usb_log_debug2("Got keys from parser: ");
+        printf("Got keys: ");
         unsigned i;
         for (i = 0; i < count; ++i) {
-                usb_log_debug2("%d ", key_codes[i]);
-        }
-        usb_log_debug2("\n");
-        
-        usb_hid_dev_kbd_t *kbd_dev = (usb_hid_dev_kbd_t *)arg;
-        
-        if (count != kbd_dev->keycode_count) {
-                usb_log_warning("Number of received keycodes (%d) differs from"
-                    " expected number (%d).\n", count, kbd_dev->keycode_count);
-                return;
-        }
-        
-        usbkbd_check_modifier_changes(kbd_dev, modifiers);
-        usbkbd_check_key_changes(kbd_dev, key_codes);
+                printf("%d ", key_codes[i]);
+        }
+        printf("\n");
+
+        for (i = 0; i < count; ++i) {
+                // TODO: Key press / release
+
+                // TODO: NOT WORKING
+                unsigned int key = usbkbd_parse_scancode(key_codes[i]);
+
+                if (key == 0) {
+                        continue;
+                }
+                kbd_push_ev(KEY_PRESS, key);
+        }
+        printf("\n");
 }
 
@@ -512 +284 @@
  * Kbd functions
  */
-//static int usbkbd_get_report_descriptor(usb_hid_dev_kbd_t *kbd_dev)
-//{
-//      // iterate over all configurations and interfaces
-//      // TODO: more configurations!!
-//      unsigned i;
-//      for (i = 0; i < kbd_dev->conf->config_descriptor.interface_count; ++i) {
-//              // TODO: endianness
-//              uint16_t length =  kbd_dev->conf->interfaces[i].hid_desc.
-//                  report_desc_info.length;
-//              size_t actual_size = 0;
-
-//              // allocate space for the report descriptor
-//              kbd_dev->conf->interfaces[i].report_desc = 
-//                  (uint8_t *)malloc(length);
+static int usbkbd_get_report_descriptor(usb_hid_dev_kbd_t *kbd_dev)
+{
+        // iterate over all configurations and interfaces
+        // TODO: more configurations!!
+        unsigned i;
+        for (i = 0; i < kbd_dev->conf->config_descriptor.interface_count; ++i) {
+                // TODO: endianness
+                uint16_t length = 
+                    kbd_dev->conf->interfaces[i].hid_desc.report_desc_info.length;
+                size_t actual_size = 0;
+
+                // allocate space for the report descriptor
+                kbd_dev->conf->interfaces[i].report_desc = (uint8_t *)malloc(length);
                 
-//              // get the descriptor from the device
-//              int rc = usb_request_get_descriptor(&kbd_dev->ctrl_pipe,
-//                  USB_REQUEST_TYPE_CLASS, USB_DESCTYPE_HID_REPORT,
-//                  i, 0,
-//                  kbd_dev->conf->interfaces[i].report_desc, length,
-//                  &actual_size);
-
-//              if (rc != EOK) {
-//                      return rc;
-//              }
-
-//              assert(actual_size == length);
-
-//              //dump_hid_class_descriptor(0, USB_DESCTYPE_HID_REPORT, 
-//              //    kbd_dev->conf->interfaces[i].report_desc, length);
-//      }
-
-//      return EOK;
-//}
-
-static int usbkbd_get_report_descriptor(usb_hid_dev_kbd_t *kbd_dev, 
-    uint8_t *config_desc, size_t config_desc_size, uint8_t *iface_desc)
-{
-        assert(kbd_dev != NULL);
-        assert(config_desc != NULL);
-        assert(config_desc_size != 0);
-        assert(iface_desc != NULL);
-        
-        usb_dp_parser_t parser =  {
-                .nesting = usb_dp_standard_descriptor_nesting
-        };
-        
-        usb_dp_parser_data_t parser_data = {
-                .data = config_desc,
-                .size = config_desc_size,
-                .arg = NULL
-        };
-        
-        /*
-         * First nested descriptor of interface descriptor.
-         */
-        uint8_t *d = 
-            usb_dp_get_nested_descriptor(&parser, &parser_data, iface_desc);
-        
-        /*
-         * Search through siblings until the HID descriptor is found.
-         */
-        while (d != NULL && *(d + 1) != USB_DESCTYPE_HID) {
-                d = usb_dp_get_sibling_descriptor(&parser, &parser_data, 
-                    iface_desc, d);
-        }
-        
-        if (d == NULL) {
-                usb_log_fatal("No HID descriptor found!\n");
-                return ENOENT;
-        }
-        
-        if (*d != sizeof(usb_standard_hid_descriptor_t)) {
-                usb_log_fatal("HID descriptor hass wrong size (%u, expected %u"
-                    ")\n", *d, sizeof(usb_standard_hid_descriptor_t));
-                return EINVAL;
-        }
-        
-        usb_standard_hid_descriptor_t *hid_desc = 
-            (usb_standard_hid_descriptor_t *)d;
-        
-        uint16_t length =  hid_desc->report_desc_info.length;
-        size_t actual_size = 0;
-
-        /*
-         * Allocate space for the report descriptor.
-         */
-        kbd_dev->report_desc = (uint8_t *)malloc(length);
-        if (kbd_dev->report_desc == NULL) {
-                usb_log_fatal("Failed to allocate space for Report descriptor."
-                    "\n");
-                return ENOMEM;
-        }
-        
-        usb_log_debug("Getting Report descriptor, expected size: %u\n", length);
-        
-        /*
-         * Get the descriptor from the device.
-         */
-        int rc = usb_request_get_descriptor(&kbd_dev->ctrl_pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE,
-            USB_DESCTYPE_HID_REPORT, 0,
-            kbd_dev->iface, kbd_dev->report_desc, length, &actual_size);
-
-        if (rc != EOK) {
-                return rc;
-        }
-
-        if (actual_size != length) {
-                free(kbd_dev->report_desc);
-                kbd_dev->report_desc = NULL;
-                usb_log_fatal("Report descriptor has wrong size (%u, expected "
-                    "%u)\n", actual_size, length);
-                return EINVAL;
-        }
-        
-        usb_log_debug("Done.\n");
-        
+                // get the descriptor from the device
+                int rc = usb_request_get_descriptor(&kbd_dev->ctrl_pipe,
+                    USB_REQUEST_TYPE_CLASS, USB_DESCTYPE_HID_REPORT,
+                    i, 0,
+                    kbd_dev->conf->interfaces[i].report_desc, length,
+                    &actual_size);
+
+                if (rc != EOK) {
+                        return rc;
+                }
+
+                assert(actual_size == length);
+
+                //dump_hid_class_descriptor(0, USB_DESCTYPE_HID_REPORT, 
+                //    kbd_dev->conf->interfaces[i].report_desc, length);
+        }
+
         return EOK;
 }
-
 static int usbkbd_process_descriptors(usb_hid_dev_kbd_t *kbd_dev)
 {
@@ -680 +364 @@
             descriptors, config_desc.total_length,
             &kbd_dev->wire);
-        
         if (rc != EOK) {
                 usb_log_error("Failed to initialize poll pipe: %s.\n",
                     str_error(rc));
-                free(descriptors);
                 return rc;
         }
-        
         if (!endpoint_mapping[0].present) {
                 usb_log_warning("Not accepting device, " \
                     "not boot-protocol keyboard.\n");
+                return EREFUSED;
+        }
+
+
+
+
+        kbd_dev->conf = (usb_hid_configuration_t *)calloc(1, 
+            sizeof(usb_hid_configuration_t));
+        if (kbd_dev->conf == NULL) {
                 free(descriptors);
-                return EREFUSED;
-        }
-        
-        usb_log_debug("Accepted device. Saving interface, and getting Report"
-            " descriptor.\n");
-        
-        /*
-         * Save assigned interface number.
-         */
-        if (endpoint_mapping[0].interface_no < 0) {
-                usb_log_error("Bad interface number.\n");
-                free(descriptors);
-                return EINVAL;
-        }
-        
-        kbd_dev->iface = endpoint_mapping[0].interface_no;
-        
-        assert(endpoint_mapping[0].interface != NULL);
-        
-        rc = usbkbd_get_report_descriptor(kbd_dev, descriptors, transferred,
-            (uint8_t *)endpoint_mapping[0].interface);
-        
+                return ENOMEM;
+        }
+        
+        /*rc = usbkbd_parse_descriptors(descriptors, transferred, kbd_dev->conf);
         free(descriptors);
-        
-        if (rc != EOK) {
-                usb_log_warning("Problem with parsing REPORT descriptor.\n");
+        if (rc != EOK) {
+                printf("Problem with parsing standard descriptors.\n");
                 return rc;
         }
-        
-        usb_log_debug("Done parsing descriptors.\n");
-        
+
+        // get and report descriptors*/
+        rc = usbkbd_get_report_descriptor(kbd_dev);
+        if (rc != EOK) {
+                printf("Problem with parsing HID REPORT descriptor.\n");
+                return rc;
+        }
+        
+        //usbkbd_print_config(kbd_dev->conf);
+
+        /*
+         * TODO: 
+         * 1) select one configuration (lets say the first)
+         * 2) how many interfaces?? how to select one??
+     *    ("The default setting for an interface is always alternate setting zero.")
+         * 3) find endpoint which is IN and INTERRUPT (parse), save its number
+     *    as the endpoint for polling
+         */
+
         return EOK;
 }
@@ -734 +421 @@
 
         if (kbd_dev == NULL) {
-                usb_log_fatal("No memory!\n");
+                fprintf(stderr, NAME ": No memory!\n");
                 return NULL;
         }
@@ -762 +449 @@
 
         /*
-         * Get descriptors, parse descriptors and save endpoints.
-         */
+         * will need all descriptors:
+         * 1) choose one configuration from configuration descriptors
+         *    (set it to the device)
+         * 2) set endpoints from endpoint descriptors
+         */
+
+        // TODO: get descriptors, parse descriptors and save endpoints
         usb_endpoint_pipe_start_session(&kbd_dev->ctrl_pipe);
-        
+        //usb_request_set_configuration(&kbd_dev->ctrl_pipe, 1);
         rc = usbkbd_process_descriptors(kbd_dev);
-        
         usb_endpoint_pipe_end_session(&kbd_dev->ctrl_pipe);
         if (rc != EOK) {
                 goto error_leave;
         }
-        
-        // save the size of the report (boot protocol report by default)
-        kbd_dev->keycode_count = BOOTP_REPORT_SIZE;
-        kbd_dev->keycodes = (uint8_t *)calloc(
-            kbd_dev->keycode_count, sizeof(uint8_t));
-        
-        if (kbd_dev->keycodes == NULL) {
-                usb_log_fatal("No memory!\n");
-                goto error_leave;
-        }
-        
-        kbd_dev->modifiers = 0;
-        kbd_dev->mods = DEFAULT_ACTIVE_MODS;
-        kbd_dev->lock_keys = 0;
-        
-        // set boot protocol
-        usbkbd_req_set_protocol(kbd_dev, USB_HID_PROTOCOL_BOOT);
-        
-        // set LEDs according to internal setup (NUM LOCK enabled)
-        usbkbd_set_led(kbd_dev);
-        
+
         return kbd_dev;
 
@@ -805 +476 @@
         usb_hid_report_in_callbacks_t *callbacks =
             (usb_hid_report_in_callbacks_t *)malloc(
-                sizeof(usb_hid_report_in_callbacks_t));
+                sizeof(usb_hid_report_in_callbacks_t));
         callbacks->keyboard = usbkbd_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);*/
+        printf("Calling usb_hid_boot_keyboard_input_report() with size %zu\n",
+            actual_size);
         //dump_buffer("bufffer: ", buffer, actual_size);
-        int rc = usb_hid_boot_keyboard_input_report(buffer, actual_size,
-            callbacks, kbd_dev);
-        
-        if (rc != EOK) {
-                usb_log_warning("Error in usb_hid_boot_keyboard_input_report():"
-                    "%s\n", str_error(rc));
+        int rc = usb_hid_boot_keyboard_input_report(buffer, actual_size, callbacks, 
+            NULL);
+        if (rc != EOK) {
+                printf("Error in usb_hid_boot_keyboard_input_report(): %d\n", rc);
         }
 }
@@ -828 +497 @@
         size_t actual_size;
 
-        usb_log_info("Polling keyboard...\n");
+        printf("Polling keyboard...\n");
 
         while (true) {
@@ -835 +504 @@
                 sess_rc = usb_endpoint_pipe_start_session(&kbd_dev->poll_pipe);
                 if (sess_rc != EOK) {
-                        usb_log_warning("Failed to start a session: %s.\n",
+                        printf("Failed to start a session: %s.\n",
                             str_error(sess_rc));
                         continue;
@@ -845 +514 @@
 
                 if (rc != EOK) {
-                        usb_log_warning("Error polling the keyboard: %s.\n",
+                        printf("Error polling the keyboard: %s.\n",
                             str_error(rc));
                         continue;
@@ -851 +520 @@
 
                 if (sess_rc != EOK) {
-                        usb_log_warning("Error closing session: %s.\n",
+                        printf("Error closing session: %s.\n",
                             str_error(sess_rc));
                         continue;
@@ -861 +530 @@
                  */
                 if (actual_size == 0) {
-                        usb_log_debug("Keyboard returned NAK\n");
+                        printf("Keyboard returned NAK\n");
                         continue;
                 }
@@ -868 +537 @@
                  * TODO: Process pressed keys.
                  */
-                usb_log_debug("Calling usbkbd_process_interrupt_in()\n");
+                printf("Calling usbkbd_process_interrupt_in()\n");
                 usbkbd_process_interrupt_in(kbd_dev, buffer, actual_size);
         }
@@ -878 +547 @@
 static int usbkbd_fibril_device(void *arg)
 {
+        printf("!!! USB device fibril\n");
+
         if (arg == NULL) {
-                usb_log_error("No device!\n");
+                printf("No device!\n");
                 return -1;
         }
-        
-        usb_hid_dev_kbd_t *kbd_dev = (usb_hid_dev_kbd_t *)arg;
+
+        ddf_dev_t *dev = (ddf_dev_t *)arg;
+
+        // initialize device (get and process descriptors, get address, etc.)
+        usb_hid_dev_kbd_t *kbd_dev = usbkbd_init_device(dev);
+        if (kbd_dev == NULL) {
+                printf("Error while initializing device.\n");
+                return -1;
+        }
 
         usbkbd_poll_keyboard(kbd_dev);
@@ -892 +570 @@
 static int usbkbd_add_device(ddf_dev_t *dev)
 {
+        /* For now, fail immediately. */
+        //return ENOTSUP;
+
+        /*
+         * When everything is okay, connect to "our" HC.
+         *
+         * Not supported yet, skip..
+         */
+//      int phone = usb_drv_hc_connect_auto(dev, 0);
+//      if (phone < 0) {
+//              /*
+//               * Connecting to HC failed, roll-back and announce
+//               * failure.
+//               */
+//              return phone;
+//      }
+
+//      dev->parent_phone = phone;
+
         /*
          * Create default function.
@@ -904 +601 @@
         rc = ddf_fun_add_to_class(kbd_fun, "keyboard");
         assert(rc == EOK);
-        
-        /* 
-         * Initialize device (get and process descriptors, get address, etc.)
-         */
-        usb_hid_dev_kbd_t *kbd_dev = usbkbd_init_device(dev);
-        if (kbd_dev == NULL) {
-                usb_log_error("Error while initializing device.\n");
-                return -1;
-        }
-
-        usb_log_info("Device initialized.\n");
-        
+
         /*
          * Create new fibril for handling this keyboard
          */
-        fid_t fid = fibril_create(usbkbd_fibril_device, kbd_dev);
+        fid_t fid = fibril_create(usbkbd_fibril_device, dev);
         if (fid == 0) {
-                usb_log_error("Failed to start fibril for HID device\n");
+                printf("%s: failed to start fibril for HID device\n", NAME);
                 return ENOMEM;
         }
@@ -948 +634 @@
 int main(int argc, char *argv[])
 {
-        usb_log_enable(USB_LOG_LEVEL_INFO, NAME);
+        usb_log_enable(USB_LOG_LEVEL_INFO, "usbhid");
         return ddf_driver_main(&kbd_driver);
 }

uspace/drv/usbhub/main.c

@@ -34 +34 @@
 #include <errno.h>
 #include <async.h>
-#include <stdio.h>
 
 #include "usbhub.h"
@@ -52 +51 @@
 };
 
+int usb_hub_control_loop(void * noparam){
+        while(true){
+                usb_hub_check_hub_changes();
+                async_usleep(1000 * 1000 );/// \TODO proper number once
+        }
+        return 0;
+}
+
+
 int main(int argc, char *argv[])
 {
         usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
-        dprintf(USB_LOG_LEVEL_INFO, "starting hub driver");
-
-        //this is probably not needed anymore
+        
         fibril_mutex_initialize(&usb_hub_list_lock);
         fibril_mutex_lock(&usb_hub_list_lock);
         usb_lst_init(&usb_hub_list);
         fibril_mutex_unlock(&usb_hub_list_lock);
-        
+
+        fid_t fid = fibril_create(usb_hub_control_loop, NULL);
+        if (fid == 0) {
+                fprintf(stderr, NAME ": failed to start monitoring fibril," \
+                    " driver aborting.\n");
+                return ENOMEM;
+        }
+        fibril_add_ready(fid);
+
         return ddf_driver_main(&hub_driver);
 }

uspace/drv/usbhub/port_status.h

@@ -177 +177 @@
 }
 
-/**
- * set the device request to be a port disable request
- * @param request
- * @param port
- */
-static inline void usb_hub_unset_power_port_request(
-usb_device_request_setup_packet_t * request, uint16_t port
-){
-        request->index = port;
-        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
-        request->request = USB_HUB_REQUEST_CLEAR_FEATURE;
-        request->value = USB_HUB_FEATURE_PORT_POWER;
-        request->length = 0;
-}
-
 /** get i`th bit of port status */
 static inline bool usb_port_get_bit(usb_port_status_t * status, int idx)

uspace/drv/usbhub/usbhub.c

@@ -44 +44 @@
 #include <usb/request.h>
 #include <usb/classes/hub.h>
-#include <stdio.h>
 
 #include "usbhub.h"
@@ -57 +56 @@
 };
 
-/** Hub status-change endpoint description
- *
- * For more see usb hub specification in 11.15.1 of
- */
+/** Hub status-change endpoint description */
 static usb_endpoint_description_t status_change_endpoint_description = {
         .transfer_type = USB_TRANSFER_INTERRUPT,
         .direction = USB_DIRECTION_IN,
         .interface_class = USB_CLASS_HUB,
-        .interface_subclass = 0,
-        .interface_protocol = 0,
         .flags = 0
 };
-
-int usb_hub_control_loop(void * hub_info_param){
-        usb_hub_info_t * hub_info = (usb_hub_info_t*)hub_info_param;
-        while(true){
-                usb_hub_check_hub_changes(hub_info);
-                async_usleep(1000 * 1000 );/// \TODO proper number once
-        }
-        return 0;
-}
 
 
@@ -150 +135 @@
 
         //configuration descriptor
-        /// \TODO check other configurations?
+        /// \TODO check other configurations
         usb_standard_configuration_descriptor_t config_descriptor;
         opResult = usb_request_get_bare_configuration_descriptor(
@@ -194 +179 @@
         }
 
+        /**
+         * Initialize the interrupt in endpoint.
+         * \TODO this code should be checked...
+         */
         usb_endpoint_mapping_t endpoint_mapping[1] = {
                 {
@@ -221 +210 @@
         return EOK;
         
+
+        // Initialize the interrupt(=status change) endpoint.
+        /*usb_endpoint_pipe_initialize(
+                &result->endpoints->status_change,
+                &result->device_connection, );USB_TRANSFER_INTERRUPT
+        USB_DIRECTION_IN*/
+
 }
 
@@ -253 +249 @@
         usb_endpoint_pipe_start_session(&result->endpoints.control);
         opResult = usb_request_get_descriptor(&result->endpoints.control,
-                        USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_DEVICE,
-                        USB_DESCTYPE_HUB,
-                        0, 0, serialized_descriptor,
+                        USB_REQUEST_TYPE_CLASS,
+                        USB_DESCTYPE_HUB, 0, 0, serialized_descriptor,
                         USB_HUB_MAX_DESCRIPTOR_SIZE, &received_size);
         usb_endpoint_pipe_end_session(&result->endpoints.control);
@@ -272 +267 @@
         }
 
+        
         dprintf(USB_LOG_LEVEL_INFO, "setting port count to %d",descriptor->ports_count);
         result->port_count = descriptor->ports_count;
@@ -333 +329 @@
 
         //add the hub to list
-        //is this needed now?
         fibril_mutex_lock(&usb_hub_list_lock);
         usb_lst_append(&usb_hub_list, hub_info);
         fibril_mutex_unlock(&usb_hub_list_lock);
+
         dprintf(USB_LOG_LEVEL_DEBUG, "hub info added to list");
-
-        dprintf(USB_LOG_LEVEL_DEBUG, "adding to ddf");
-        ddf_fun_t *hub_fun = ddf_fun_create(dev, fun_exposed, "hub");
-        assert(hub_fun != NULL);
-        hub_fun->ops = NULL;
-
-        int rc = ddf_fun_bind(hub_fun);
-        assert(rc == EOK);
-        rc = ddf_fun_add_to_class(hub_fun, "hub");
-        assert(rc == EOK);
-
-        fid_t fid = fibril_create(usb_hub_control_loop, hub_info);
-        if (fid == 0) {
-                dprintf(USB_LOG_LEVEL_ERROR, 
-                                ": failed to start monitoring fibril for new hub");
-                return ENOMEM;
-        }
-        fibril_add_ready(fid);
-
-        dprintf(USB_LOG_LEVEL_DEBUG, "hub fibril created");
         //(void)hub_info;
-        //usb_hub_check_hub_changes();
+        usb_hub_check_hub_changes();
         
         dprintf(USB_LOG_LEVEL_INFO, "hub dev added");
@@ -392 +368 @@
         //opResult = usb_drv_reserve_default_address(hc);
         opResult = usb_hc_reserve_default_address(&hub->connection, USB_SPEED_LOW);
-        
-        if (opResult != EOK) {
-                dprintf(USB_LOG_LEVEL_WARNING, 
-                                "cannot assign default address, it is probably used %d",opResult);
+
+        if (opResult != EOK) {
+                dprintf(USB_LOG_LEVEL_WARNING, "cannot assign default address, it is probably used");
                 return;
         }
@@ -406 +381 @@
                         );
         if (opResult != EOK) {
-                dprintf(USB_LOG_LEVEL_ERROR, 
-                                "something went wrong when reseting a port %d",opResult);
+                dprintf(USB_LOG_LEVEL_ERROR, "something went wrong when reseting a port");
                 //usb_hub_release_default_address(hc);
                 usb_hc_release_default_address(&hub->connection);
@@ -420 +394 @@
  */
 static void usb_hub_finalize_add_device( usb_hub_info_t * hub,
-                uint16_t port, bool isLowSpeed) {
+                uint16_t port) {
 
         int opResult;
@@ -443 +417 @@
                         &new_device_connection);
         /// \TODO get highspeed info
-        usb_speed_t speed = isLowSpeed?USB_SPEED_LOW:USB_SPEED_FULL;
+
+
+
 
 
@@ -449 +425 @@
         usb_address_t new_device_address = usb_hc_request_address(
                         &hub->connection,
-                        speed/// \TODO fullspeed??
+                        USB_SPEED_LOW/// \TODO fullspeed??
                         );
         if (new_device_address < 0) {
@@ -460 +436 @@
         //opResult = usb_drv_req_set_address(hc, USB_ADDRESS_DEFAULT,
         //    new_device_address);
-        usb_endpoint_pipe_start_session(&new_device_pipe);
         opResult = usb_request_set_address(&new_device_pipe,new_device_address);
-        usb_endpoint_pipe_end_session(&new_device_pipe);
-        if (opResult != EOK) {
-                dprintf(USB_LOG_LEVEL_ERROR, 
-                                "could not set address for new device %d",opResult);
+
+        if (opResult != EOK) {
+                dprintf(USB_LOG_LEVEL_ERROR, "could not set address for new device");
                 usb_hc_release_default_address(&hub->connection);
                 return;
@@ -484 +458 @@
 
         if (opResult != EOK) {
-                dprintf(USB_LOG_LEVEL_ERROR, 
-                                "could not start driver for new device %d",opResult);
+                dprintf(USB_LOG_LEVEL_ERROR, "could not start driver for new device");
                 return;
         }
@@ -496 +469 @@
                         &hub->attached_devs[port]);
         if (opResult != EOK) {
-                dprintf(USB_LOG_LEVEL_ERROR, 
-                                "could not assign address of device in hcd %d",opResult);
+                dprintf(USB_LOG_LEVEL_ERROR, "could not assign address of device in hcd");
                 return;
         }
@@ -539 +511 @@
 }
 
-
-/**
- *Process over current condition on port.
- * 
- * Turn off the power on the port.
- *
- * @param hub
- * @param port
- */
-static void usb_hub_over_current( usb_hub_info_t * hub,
-                uint16_t port){
-        int opResult;
-        opResult = usb_hub_clear_port_feature(&hub->endpoints.control,
-            port, USB_HUB_FEATURE_PORT_POWER);
-        if(opResult!=EOK){
-                dprintf(USB_LOG_LEVEL_ERROR, "cannot power off port %d;  %d",
-                                port, opResult);
-        }
-}
-
 /**
  * Process interrupts on given hub port
@@ -570 +522 @@
         //determine type of change
         usb_endpoint_pipe_t *pipe = &hub->endpoints.control;
+        int opResult = usb_endpoint_pipe_start_session(pipe);
         
-        int opResult;
+        if(opResult != EOK){
+                dprintf(USB_LOG_LEVEL_ERROR, "cannot open pipe %d", opResult);
+        }
+
+        /*
+        usb_target_t target;
+        target.address=address;
+        target.endpoint=0;
+        */
 
         usb_port_status_t status;
@@ -586 +547 @@
                         );
         if (opResult != EOK) {
-                dprintf(USB_LOG_LEVEL_ERROR, "could not get port status");
+                dprintf(USB_LOG_LEVEL_ERROR, "ERROR: could not get port status");
                 return;
         }
         if (rcvd_size != sizeof (usb_port_status_t)) {
-                dprintf(USB_LOG_LEVEL_ERROR, "received status has incorrect size");
+                dprintf(USB_LOG_LEVEL_ERROR, "ERROR: received status has incorrect size");
                 return;
         }
@@ -605 +566 @@
                 }
         }
-        //over current
-        if (usb_port_overcurrent_change(&status)) {
-                //check if it was not auto-resolved
-                if(usb_port_over_current(&status)){
-                        usb_hub_over_current(hub,port);
-                }else{
-                        dprintf(USB_LOG_LEVEL_INFO,
-                                "over current condition was auto-resolved on port %d",port);
-                }
-        }
         //port reset
         if (usb_port_reset_completed(&status)) {
                 dprintf(USB_LOG_LEVEL_INFO, "port reset complete");
                 if (usb_port_enabled(&status)) {
-                        usb_hub_finalize_add_device(hub, port, usb_port_low_speed(&status));
+                        usb_hub_finalize_add_device(hub, port);
                 } else {
-                        dprintf(USB_LOG_LEVEL_WARNING, "port reset, but port still not enabled");
+                        dprintf(USB_LOG_LEVEL_WARNING, "ERROR: port reset, but port still not enabled");
                 }
         }
@@ -634 +585 @@
         }
         /// \TODO handle other changes
-}
-
-/**
- * Check changes on particular hub
- * @param hub_info_param
- */
-void usb_hub_check_hub_changes(usb_hub_info_t * hub_info){
-        int opResult;
-        opResult = usb_endpoint_pipe_start_session(&hub_info->endpoints.status_change);
-        if(opResult != EOK){
-                dprintf(USB_LOG_LEVEL_ERROR,
-                                "could not initialize communication for hub; %d", opResult);
-                return;
-        }
-
-        size_t port_count = hub_info->port_count;
-
-        /// FIXME: count properly
-        size_t byte_length = ((port_count+1) / 8) + 1;
+        /// \TODO debug log for various situations
+        usb_endpoint_pipe_end_session(pipe);
+
+
+}
+
+/**
+ * Check changes on all known hubs.
+ */
+void usb_hub_check_hub_changes(void) {
+        /*
+         * Iterate through all hubs.
+         */
+        usb_general_list_t * lst_item;
+        fibril_mutex_lock(&usb_hub_list_lock);
+        for (lst_item = usb_hub_list.next;
+                        lst_item != &usb_hub_list;
+                        lst_item = lst_item->next) {
+                fibril_mutex_unlock(&usb_hub_list_lock);
+                usb_hub_info_t * hub_info = ((usb_hub_info_t*)lst_item->data);
+                int opResult;
+
+                opResult = usb_endpoint_pipe_start_session(&hub_info->endpoints.status_change);
+                if(opResult != EOK){
+                        continue;
+                }
+                /*
+                 * Check status change pipe of this hub.
+                 */
+                /*
+                usb_target_t target;
+                target.address = hub_info->address;
+                target.endpoint = 1;/// \TODO get from endpoint descriptor
+                dprintf(USB_LOG_LEVEL_INFO, "checking changes for hub at addr %d",
+                    target.address);
+                */
+                size_t port_count = hub_info->port_count;
+
+                /*
+                 * Connect to respective HC.
+                 *
+                int hc = usb_drv_hc_connect_auto(hub_info->device, 0);
+                if (hc < 0) {
+                        continue;
+                }*/
+
+                /// FIXME: count properly
+                size_t byte_length = ((port_count+1) / 8) + 1;
+
                 void *change_bitmap = malloc(byte_length);
-        size_t actual_size;
-
-        /*
-         * Send the request.
-         */
-        opResult = usb_endpoint_pipe_read(
-                        &hub_info->endpoints.status_change,
-                        change_bitmap, byte_length, &actual_size
-                        );
-
-        if (opResult != EOK) {
+                size_t actual_size;
+                //usb_handle_t handle;
+
+                /*
+                 * Send the request.
+                 */
+                opResult = usb_endpoint_pipe_read(
+                                &hub_info->endpoints.status_change,
+                                change_bitmap, byte_length, &actual_size
+                                );
+
+                //usb_drv_async_wait_for(handle);
+
+                if (opResult != EOK) {
+                        free(change_bitmap);
+                        dprintf(USB_LOG_LEVEL_WARNING, "something went wrong while getting status of hub");
+                        continue;
+                }
+                unsigned int port;
+                for (port = 1; port < port_count+1; ++port) {
+                        bool interrupt =
+                                        (((uint8_t*) change_bitmap)[port / 8] >> (port % 8)) % 2;
+                        if (interrupt) {
+                                usb_hub_process_interrupt(
+                                        hub_info, port);
+                        }
+                }
+                usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
                 free(change_bitmap);
-                dprintf(USB_LOG_LEVEL_WARNING, "something went wrong while getting status of hub");
-                usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
-                return;
-        }
-        unsigned int port;
-        opResult = usb_endpoint_pipe_start_session(&hub_info->endpoints.control);
-        if(opResult!=EOK){
-                dprintf(USB_LOG_LEVEL_ERROR, "could not start control pipe session %d",
-                                opResult);
-                usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
-                return;
-        }
-        opResult = usb_hc_connection_open(&hub_info->connection);
-        if(opResult!=EOK){
-                dprintf(USB_LOG_LEVEL_ERROR, "could not start host controller session %d",
-                                opResult);
-                usb_endpoint_pipe_end_session(&hub_info->endpoints.control);
-                usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
-                return;
-        }
-
-        ///todo, opresult check, pre obe konekce
-        for (port = 1; port < port_count+1; ++port) {
-                bool interrupt =
-                                (((uint8_t*) change_bitmap)[port / 8] >> (port % 8)) % 2;
-                if (interrupt) {
-                        usb_hub_process_interrupt(
-                                hub_info, port);
-                }
-        }
-        usb_hc_connection_close(&hub_info->connection);
-        usb_endpoint_pipe_end_session(&hub_info->endpoints.control);
-        usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
-        free(change_bitmap);
-}
+                
+
+                //async_hangup(hc);
+                fibril_mutex_lock(&usb_hub_list_lock);
+        }
+        fibril_mutex_unlock(&usb_hub_list_lock);
+}
+
+
 
 

uspace/drv/usbhub/usbhub.h

@@ -75 +75 @@
 /**
  * function running the hub-controlling loop.
- * @param hub_info_param hub info pointer
+ * @param noparam fundtion does not need any parameters
  */
-int usb_hub_control_loop(void * hub_info_param);
+int usb_hub_control_loop(void * noparam);
 
 /** Callback when new hub device is detected.
@@ -87 +87 @@
 
 /**
- * check changes on specified hub
- * @param hub_info_param pointer to usb_hub_info_t structure
+ * check changes on all registered hubs
  */
-void usb_hub_check_hub_changes(usb_hub_info_t * hub_info_param);
+void usb_hub_check_hub_changes(void);
 
 
+//int usb_add_hub_device(device_t *);
 
 

uspace/lib/usb/include/usb/classes/hid.h

@@ -51 +51 @@
 } usb_hid_request_t;
 
-typedef enum {
-        USB_HID_REPORT_TYPE_INPUT = 1,
-        USB_HID_REPORT_TYPE_OUTPUT = 2,
-        USB_HID_REPORT_TYPE_FEATURE = 3
-} usb_hid_report_type_t;
-
-typedef enum {
-        USB_HID_PROTOCOL_BOOT = 0,
-        USB_HID_PROTOCOL_REPORT = 1
-} usb_hid_protocol_t;
-
 /** USB/HID subclass constants. */
 typedef enum {
@@ -73 +62 @@
         USB_HID_PROTOCOL_KEYBOARD = 1,
         USB_HID_PROTOCOL_MOUSE = 2
-} usb_hid_iface_protocol_t;
+} usb_hid_protocol_t;
 
 /** Part of standard USB HID descriptor specifying one class descriptor.

uspace/lib/usb/include/usb/classes/hidparser.h

@@ -70 +70 @@
 } usb_hid_report_in_callbacks_t;
 
-
-typedef enum {
-        USB_HID_MOD_LCTRL = 0x01,
-        USB_HID_MOD_LSHIFT = 0x02,
-        USB_HID_MOD_LALT = 0x04,
-        USB_HID_MOD_LGUI = 0x08,
-        USB_HID_MOD_RCTRL = 0x10,
-        USB_HID_MOD_RSHIFT = 0x20,
-        USB_HID_MOD_RALT = 0x40,
-        USB_HID_MOD_RGUI = 0x80,
-        USB_HID_MOD_COUNT = 8
-} usb_hid_modifiers_t;
-
-typedef enum {
-        USB_HID_LED_NUM_LOCK = 0x1,
-        USB_HID_LED_CAPS_LOCK = 0x2,
-        USB_HID_LED_SCROLL_LOCK = 0x4,
-        USB_HID_LED_COMPOSE = 0x8,
-        USB_HID_LED_KANA = 0x10,
-        USB_HID_LED_COUNT = 5
-} usb_hid_led_t;
-
-static const usb_hid_modifiers_t 
-    usb_hid_modifiers_consts[USB_HID_MOD_COUNT] = {
-        USB_HID_MOD_LCTRL,
-        USB_HID_MOD_LSHIFT,
-        USB_HID_MOD_LALT,
-        USB_HID_MOD_LGUI,
-        USB_HID_MOD_RCTRL,
-        USB_HID_MOD_RSHIFT,
-        USB_HID_MOD_RALT,
-        USB_HID_MOD_RGUI
-};
-
-//static const usb_hid_led_t usb_hid_led_consts[USB_HID_LED_COUNT] = {
-//      USB_HID_LED_NUM_LOCK,
-//      USB_HID_LED_CAPS_LOCK,
-//      USB_HID_LED_SCROLL_LOCK,
-//      USB_HID_LED_COMPOSE,
-//      USB_HID_LED_KANA
-//};
-
-//#define USB_HID_BOOT_KEYBOARD_NUM_LOCK                0x01
-//#define USB_HID_BOOT_KEYBOARD_CAPS_LOCK               0x02
-//#define USB_HID_BOOT_KEYBOARD_SCROLL_LOCK     0x04
-//#define USB_HID_BOOT_KEYBOARD_COMPOSE         0x08
-//#define USB_HID_BOOT_KEYBOARD_KANA                    0x10
+#define USB_HID_BOOT_KEYBOARD_NUM_LOCK          0x01
+#define USB_HID_BOOT_KEYBOARD_CAPS_LOCK         0x02
+#define USB_HID_BOOT_KEYBOARD_SCROLL_LOCK       0x04
+#define USB_HID_BOOT_KEYBOARD_COMPOSE           0x08
+#define USB_HID_BOOT_KEYBOARD_KANA                      0x10
 
 /*

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

@@ -96 +96 @@
 int usb_request_set_address(usb_endpoint_pipe_t *, usb_address_t);
 int usb_request_get_descriptor(usb_endpoint_pipe_t *, usb_request_type_t,
-    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void *, size_t, 
-    size_t *);
+    uint8_t, uint8_t, uint16_t, void *, size_t, size_t *);
 int usb_request_get_descriptor_alloc(usb_endpoint_pipe_t *, usb_request_type_t,
-    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void **, size_t *);
+    uint8_t, uint8_t, uint16_t, void **, size_t *);
 int usb_request_get_device_descriptor(usb_endpoint_pipe_t *,
     usb_standard_device_descriptor_t *);

uspace/lib/usb/src/hidparser.c

@@ -144 +144 @@
 int usb_hid_boot_keyboard_output_report(uint8_t leds, uint8_t *data, size_t size)
 {
-        if (size < 1){
+        if(size != 1){
                 return -1;
         }
 
-        data[0] = leds;
+        /* used only first five bits, others are only padding*/
+        *data = leds;
         return EOK;
 }

uspace/lib/usb/src/request.c

@@ -36 +36 @@
 #include <errno.h>
 #include <assert.h>
-#include <usb/debug.h>
 
 #define MAX_DATA_LENGTH ((size_t)(0xFFFF))
@@ -210 +209 @@
  */
 int usb_request_get_descriptor(usb_endpoint_pipe_t *pipe,
-    usb_request_type_t request_type, usb_request_recipient_t recipient,
+    usb_request_type_t request_type,
     uint8_t descriptor_type, uint8_t descriptor_index,
     uint16_t language,
@@ -225 +224 @@
 
         return usb_control_request_get(pipe,
-            request_type, recipient,
+            request_type, USB_REQUEST_RECIPIENT_DEVICE,
             USB_DEVREQ_GET_DESCRIPTOR,
             wValue, language,
@@ -243 +242 @@
  */
 int usb_request_get_descriptor_alloc(usb_endpoint_pipe_t * pipe,
-    usb_request_type_t request_type, usb_request_recipient_t recipient,
+    usb_request_type_t request_type,
     uint8_t descriptor_type, uint8_t descriptor_index,
     uint16_t language,
@@ -259 +258 @@
         uint8_t tmp_buffer[1];
         size_t bytes_transfered;
-        rc = usb_request_get_descriptor(pipe, request_type, recipient,
+        rc = usb_request_get_descriptor(pipe, request_type,
             descriptor_type, descriptor_index, language,
             &tmp_buffer, 1, &bytes_transfered);
@@ -284 +283 @@
         }
 
-        rc = usb_request_get_descriptor(pipe, request_type, recipient,
+        rc = usb_request_get_descriptor(pipe, request_type,
             descriptor_type, descriptor_index, language,
             buffer, size, &bytes_transfered);
@@ -321 +320 @@
         usb_standard_device_descriptor_t descriptor_tmp;
         int rc = usb_request_get_descriptor(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE, 
-            USB_DESCTYPE_DEVICE, 0, 0,
+            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_DEVICE,
+            0, 0,
             &descriptor_tmp, sizeof(descriptor_tmp),
             &actually_transferred);
@@ -367 +366 @@
         usb_standard_configuration_descriptor_t descriptor_tmp;
         int rc = usb_request_get_descriptor(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
-            USB_DESCTYPE_CONFIGURATION, index, 0,
+            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_CONFIGURATION,
+            index, 0,
             &descriptor_tmp, sizeof(descriptor_tmp),
             &actually_transferred);
@@ -407 +406 @@
 
         return usb_request_get_descriptor(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
-            USB_DESCTYPE_CONFIGURATION, index, 0,
+            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_CONFIGURATION,
+            index, 0,
             descriptor, descriptor_size, actual_size);
 }
@@ -453 +452 @@
         size_t string_descriptor_size = 0;
         rc = usb_request_get_descriptor_alloc(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
-            USB_DESCTYPE_STRING, 0, 0,
+            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_STRING, 0, 0,
             (void **) &string_descriptor, &string_descriptor_size);
         if (rc != EOK) {
@@ -533 +531 @@
         size_t string_size;
         rc = usb_request_get_descriptor_alloc(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
-            USB_DESCTYPE_STRING, index, uint16_host2usb(lang),
+            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_STRING,
+            index, uint16_host2usb(lang),
             (void **) &string, &string_size);
         if (rc != EOK) {