Changes in / [b8622e2:81c508c] in mainline

Location:

uspace

Files:

• drv/usbhid/Makefile (modified) (1 diff)
• drv/usbhid/conv.c (modified) (3 diffs)
• drv/usbhid/descparser.c (deleted)
• drv/usbhid/descparser.h (deleted)
• drv/usbhid/hid.h (modified) (2 diffs)
• drv/usbhid/main.c (modified) (27 diffs)
• drv/usbhub/usbhub.c (modified) (1 diff)
• 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"
 
@@ -141 +143 @@
         //[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
+        
 };
 
@@ -189 +209 @@
 
         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;
 
 /**
@@ -68 +50 @@
 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 GUESSED_POLL_ENDPOINT 1
+#define BOOTP_REPORT_SIZE 6
+
+static unsigned DEFAULT_ACTIVE_MODS = KM_NUM_LOCK;
 
 /** Keyboard polling endpoint description for boot protocol class. */
@@ -120 +124 @@
 
 static void dump_buffer(const char *msg, const uint8_t *buffer, size_t length)
-{
+{uint8_t buffer[BUFFER_SIZE];
         printf("%s\n", msg);
         
@@ -137 +141 @@
  */
 
-/** Currently active modifiers. 
+/** Currently active modifiers (locks is probably better word).
  *
  * 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.  
@@ -147 +151 @@
  * TODO: put to device? 
  */
-static unsigned lock_keys;
+//static unsigned lock_keys;
 
 #define NUM_LAYOUTS 3
@@ -159 +163 @@
 static int active_layout = 0;
 
-static void kbd_push_ev(int type, unsigned int key)
+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)
 {
         console_event_t ev;
@@ -177 +292 @@
         if (mod_mask != 0) {
                 if (type == KEY_PRESS)
-                        mods = mods | mod_mask;
+                        kbd_dev->mods = kbd_dev->mods | mod_mask;
                 else
-                        mods = mods & ~mod_mask;
+                        kbd_dev->mods = kbd_dev->mods & ~mod_mask;
         }
 
         switch (key) {
-        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;
+        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;
         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
@@ -196 +316 @@
                          * up the lock state.
                          */
-                        mods = mods ^ (mod_mask & ~lock_keys);
-                        lock_keys = lock_keys | mod_mask;
+                        kbd_dev->mods = 
+                            kbd_dev->mods ^ (mod_mask & ~kbd_dev->lock_keys);
+                        kbd_dev->lock_keys = kbd_dev->lock_keys | mod_mask;
 
                         /* Update keyboard lock indicator lights. */
-                        // TODO
-                        //kbd_ctl_set_ind(mods);
+                        usbkbd_set_led(kbd_dev);
                 } else {
-                        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) {
+                        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) {
                 active_layout = 0;
                 layout[active_layout]->reset();
@@ -219 +337 @@
         }
 
-        if (type == KEY_PRESS && (mods & KM_LCTRL) &&
-                key == KC_F2) {
+        if (type == KEY_PRESS && (kbd_dev->mods & KM_LCTRL) && key == KC_F2) {
                 active_layout = 1;
                 layout[active_layout]->reset();
@@ -226 +343 @@
         }
 
-        if (type == KEY_PRESS && (mods & KM_LCTRL) &&
-                key == KC_F3) {
+        if (type == KEY_PRESS && (kbd_dev->mods & KM_LCTRL) && key == KC_F3) {
                 active_layout = 2;
                 layout[active_layout]->reset();
@@ -235 +351 @@
         ev.type = type;
         ev.key = key;
-        ev.mods = mods;
+        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);
 
-        printf("Sending key %d to the console\n", ev.key);
+        usb_log_debug2("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);
 }
 /*
@@ -249 +370 @@
         /*
          * 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
@@ -260 +484 @@
     uint8_t modifiers, void *arg)
 {
-        printf("Got keys: ");
+        if (arg == NULL) {
+                usb_log_warning("Missing argument in callback "
+                    "usbkbd_process_keycodes().\n");
+                return;
+        }
+
+        usb_log_debug2("Got keys from parser: ");
         unsigned i;
         for (i = 0; i < count; ++i) {
-                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");
+                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);
 }
 
@@ -284 +512 @@
  * 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);
-        }
-
+//              // 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");
+        
         return EOK;
 }
+
 static int usbkbd_process_descriptors(usb_hid_dev_kbd_t *kbd_dev)
 {
@@ -364 +680 @@
             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");
+                free(descriptors);
                 return EREFUSED;
         }
-
-
-
-
-        kbd_dev->conf = (usb_hid_configuration_t *)calloc(1, 
-            sizeof(usb_hid_configuration_t));
-        if (kbd_dev->conf == NULL) {
+        
+        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 ENOMEM;
-        }
-        
-        /*rc = usbkbd_parse_descriptors(descriptors, transferred, kbd_dev->conf);
+                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);
+        
         free(descriptors);
-        if (rc != EOK) {
-                printf("Problem with parsing standard descriptors.\n");
+        
+        if (rc != EOK) {
+                usb_log_warning("Problem with parsing REPORT descriptor.\n");
                 return rc;
         }
-
-        // 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
-         */
-
+        
+        usb_log_debug("Done parsing descriptors.\n");
+        
         return EOK;
 }
@@ -421 +734 @@
 
         if (kbd_dev == NULL) {
-                fprintf(stderr, NAME ": No memory!\n");
+                usb_log_fatal("No memory!\n");
                 return NULL;
         }
@@ -449 +762 @@
 
         /*
-         * 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
+         * 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;
 
@@ -476 +805 @@
         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);
-        printf("Calling usb_hid_boot_keyboard_input_report() with size %zu\n",
-            actual_size);
+        /*usb_log_debug2("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, 
-            NULL);
-        if (rc != EOK) {
-                printf("Error in usb_hid_boot_keyboard_input_report(): %d\n", rc);
+        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));
         }
 }
@@ -497 +828 @@
         size_t actual_size;
 
-        printf("Polling keyboard...\n");
+        usb_log_info("Polling keyboard...\n");
 
         while (true) {
@@ -504 +835 @@
                 sess_rc = usb_endpoint_pipe_start_session(&kbd_dev->poll_pipe);
                 if (sess_rc != EOK) {
-                        printf("Failed to start a session: %s.\n",
+                        usb_log_warning("Failed to start a session: %s.\n",
                             str_error(sess_rc));
                         continue;
@@ -514 +845 @@
 
                 if (rc != EOK) {
-                        printf("Error polling the keyboard: %s.\n",
+                        usb_log_warning("Error polling the keyboard: %s.\n",
                             str_error(rc));
                         continue;
@@ -520 +851 @@
 
                 if (sess_rc != EOK) {
-                        printf("Error closing session: %s.\n",
+                        usb_log_warning("Error closing session: %s.\n",
                             str_error(sess_rc));
                         continue;
@@ -530 +861 @@
                  */
                 if (actual_size == 0) {
-                        printf("Keyboard returned NAK\n");
+                        usb_log_debug("Keyboard returned NAK\n");
                         continue;
                 }
@@ -537 +868 @@
                  * TODO: Process pressed keys.
                  */
-                printf("Calling usbkbd_process_interrupt_in()\n");
+                usb_log_debug("Calling usbkbd_process_interrupt_in()\n");
                 usbkbd_process_interrupt_in(kbd_dev, buffer, actual_size);
         }
@@ -547 +878 @@
 static int usbkbd_fibril_device(void *arg)
 {
-        printf("!!! USB device fibril\n");
-
         if (arg == NULL) {
-                printf("No device!\n");
+                usb_log_error("No device!\n");
                 return -1;
         }
-
-        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;
-        }
+        
+        usb_hid_dev_kbd_t *kbd_dev = (usb_hid_dev_kbd_t *)arg;
 
         usbkbd_poll_keyboard(kbd_dev);
@@ -570 +892 @@
 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.
@@ -601 +904 @@
         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, dev);
+        fid_t fid = fibril_create(usbkbd_fibril_device, kbd_dev);
         if (fid == 0) {
-                printf("%s: failed to start fibril for HID device\n", NAME);
+                usb_log_error("Failed to start fibril for HID device\n");
                 return ENOMEM;
         }
@@ -634 +948 @@
 int main(int argc, char *argv[])
 {
-        usb_log_enable(USB_LOG_LEVEL_INFO, "usbhid");
+        usb_log_enable(USB_LOG_LEVEL_INFO, NAME);
         return ddf_driver_main(&kbd_driver);
 }

uspace/drv/usbhub/usbhub.c

@@ -253 +253 @@
         usb_endpoint_pipe_start_session(&result->endpoints.control);
         opResult = usb_request_get_descriptor(&result->endpoints.control,
-                        USB_REQUEST_TYPE_CLASS,
-                        USB_DESCTYPE_HUB, 0, 0, serialized_descriptor,
+                        USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_DEVICE,
+                        USB_DESCTYPE_HUB,
+                        0, 0, serialized_descriptor,
                         USB_HUB_MAX_DESCRIPTOR_SIZE, &received_size);
         usb_endpoint_pipe_end_session(&result->endpoints.control);

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 {
@@ -62 +73 @@
         USB_HID_PROTOCOL_KEYBOARD = 1,
         USB_HID_PROTOCOL_MOUSE = 2
-} usb_hid_protocol_t;
+} usb_hid_iface_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;
 
-#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
+
+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
 
 /*

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,
-    uint8_t, uint8_t, uint16_t, void *, size_t, size_t *);
+    usb_request_recipient_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,
-    uint8_t, uint8_t, uint16_t, void **, size_t *);
+    usb_request_recipient_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;
         }
 
-        /* used only first five bits, others are only padding*/
-        *data = leds;
+        data[0] = 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))
@@ -209 +210 @@
  */
 int usb_request_get_descriptor(usb_endpoint_pipe_t *pipe,
-    usb_request_type_t request_type,
+    usb_request_type_t request_type, usb_request_recipient_t recipient,
     uint8_t descriptor_type, uint8_t descriptor_index,
     uint16_t language,
@@ -224 +225 @@
 
         return usb_control_request_get(pipe,
-            request_type, USB_REQUEST_RECIPIENT_DEVICE,
+            request_type, recipient,
             USB_DEVREQ_GET_DESCRIPTOR,
             wValue, language,
@@ -242 +243 @@
  */
 int usb_request_get_descriptor_alloc(usb_endpoint_pipe_t * pipe,
-    usb_request_type_t request_type,
+    usb_request_type_t request_type, usb_request_recipient_t recipient,
     uint8_t descriptor_type, uint8_t descriptor_index,
     uint16_t language,
@@ -258 +259 @@
         uint8_t tmp_buffer[1];
         size_t bytes_transfered;
-        rc = usb_request_get_descriptor(pipe, request_type,
+        rc = usb_request_get_descriptor(pipe, request_type, recipient,
             descriptor_type, descriptor_index, language,
             &tmp_buffer, 1, &bytes_transfered);
@@ -283 +284 @@
         }
 
-        rc = usb_request_get_descriptor(pipe, request_type,
+        rc = usb_request_get_descriptor(pipe, request_type, recipient,
             descriptor_type, descriptor_index, language,
             buffer, size, &bytes_transfered);
@@ -320 +321 @@
         usb_standard_device_descriptor_t descriptor_tmp;
         int rc = usb_request_get_descriptor(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_DEVICE,
-            0, 0,
+            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE, 
+            USB_DESCTYPE_DEVICE, 0, 0,
             &descriptor_tmp, sizeof(descriptor_tmp),
             &actually_transferred);
@@ -366 +367 @@
         usb_standard_configuration_descriptor_t descriptor_tmp;
         int rc = usb_request_get_descriptor(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_CONFIGURATION,
-            index, 0,
+            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
+            USB_DESCTYPE_CONFIGURATION, index, 0,
             &descriptor_tmp, sizeof(descriptor_tmp),
             &actually_transferred);
@@ -406 +407 @@
 
         return usb_request_get_descriptor(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_CONFIGURATION,
-            index, 0,
+            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
+            USB_DESCTYPE_CONFIGURATION, index, 0,
             descriptor, descriptor_size, actual_size);
 }
@@ -452 +453 @@
         size_t string_descriptor_size = 0;
         rc = usb_request_get_descriptor_alloc(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_STRING, 0, 0,
+            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
+            USB_DESCTYPE_STRING, 0, 0,
             (void **) &string_descriptor, &string_descriptor_size);
         if (rc != EOK) {
@@ -531 +533 @@
         size_t string_size;
         rc = usb_request_get_descriptor_alloc(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_STRING,
-            index, uint16_host2usb(lang),
+            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
+            USB_DESCTYPE_STRING, index, uint16_host2usb(lang),
             (void **) &string, &string_size);
         if (rc != EOK) {