Changeset f08c560 in mainline for uspace/drv

Timestamp:

2011-03-25T14:37:03Z (15 years ago)

Author:

Lubos Slovak <lubos.slovak@…>

Branches:

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

Children:

9c0f158, da3dafc, f97717d9

Parents:

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

Message:

HID→kbd, HID functions separated, ported to USB fw, better report parsing, fixes

Location:

uspace/drv

Files:

• usbhid/descdump.c (deleted)
• usbhid/hiddev.c (deleted)
• usbhid/hiddev.h (deleted)
• usbhid/main.c (deleted)
• usbkbd/Makefile (moved) (moved from uspace/drv/usbhid/Makefile ) (2 diffs)
• usbkbd/conv.c (moved) (moved from uspace/drv/usbhid/conv.c )
• usbkbd/conv.h (moved) (moved from uspace/drv/usbhid/conv.h ) (1 diff)
• usbkbd/kbd.h (moved) (moved from uspace/drv/usbhid/kbd.h )
• usbkbd/kbddev.c (moved) (moved from uspace/drv/usbhid/kbddev.c ) (33 diffs)
• usbkbd/kbddev.h (moved) (moved from uspace/drv/usbhid/kbddev.h ) (5 diffs)
• usbkbd/kbdrepeat.c (moved) (moved from uspace/drv/usbhid/kbdrepeat.c ) (8 diffs)
• usbkbd/kbdrepeat.h (moved) (moved from uspace/drv/usbhid/kbdrepeat.h ) (1 diff)
• usbkbd/layout.h (moved) (moved from uspace/drv/usbhid/layout.h ) (1 diff)
• usbkbd/main.c (added)
• usbkbd/usbkbd.ma (moved) (moved from uspace/drv/usbhid/usbhid.ma )

uspace/drv/usbkbd/Makefile

@@ -30 +30 @@
 LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBUSB_PREFIX)/libusb.a
 EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBUSB_PREFIX)/include -I.
-BINARY = usbhid
+BINARY = usbkbd
 
 STOLEN_LAYOUT_SOURCES = \
@@ -40 +40 @@
         main.c \
         conv.c \
-        hidreq.c \
         kbddev.c \
         kbdrepeat.c \
-        hiddev.c \
         $(STOLEN_LAYOUT_SOURCES)
 

uspace/drv/usbkbd/conv.h

@@ -34 +34 @@
  */
 
-#ifndef USBHID_CONV_H_
-#define USBHID_CONV_H_
+#ifndef USB_KBD_CONV_H_
+#define USB_KBD_CONV_H_
 
 unsigned int usbhid_parse_scancode(int scancode);
 
-#endif /* USBHID_CONV_H_ */
+#endif /* USB_KBD_CONV_H_ */
 
 /**

uspace/drv/usbkbd/kbddev.c

@@ -46 +46 @@
 
 #include <usb/usb.h>
+#include <usb/dp.h>
+#include <usb/request.h>
 #include <usb/classes/hid.h>
 #include <usb/pipes.h>
@@ -52 +54 @@
 #include <usb/classes/classes.h>
 #include <usb/classes/hidut.h>
+#include <usb/classes/hidreq.h>
+#include <usb/classes/hidreport.h>
+
+#include <usb/devdrv.h>
 
 #include "kbddev.h"
-#include "hiddev.h"
-#include "hidreq.h"
+
 #include "layout.h"
 #include "conv.h"
@@ -85 +90 @@
 static const unsigned int DEFAULT_REPEAT_DELAY = 50 * 1000;
 
+/*----------------------------------------------------------------------------*/
+
 /** Keyboard polling endpoint description for boot protocol class. */
-static usb_endpoint_description_t poll_endpoint_description = {
+static usb_endpoint_description_t boot_poll_endpoint_description = {
         .transfer_type = USB_TRANSFER_INTERRUPT,
         .direction = USB_DIRECTION_IN,
@@ -95 +102 @@
 };
 
-typedef enum usbhid_kbd_flags {
-        USBHID_KBD_STATUS_UNINITIALIZED = 0,
-        USBHID_KBD_STATUS_INITIALIZED = 1,
-        USBHID_KBD_STATUS_TO_DESTROY = -1
-} usbhid_kbd_flags;
+/* Array of endpoints expected on the device, NULL terminated. */
+usb_endpoint_description_t 
+    *usb_kbd_endpoints[USB_KBD_POLL_EP_COUNT + 1] = {
+        &boot_poll_endpoint_description,
+        NULL
+};
+
+/*----------------------------------------------------------------------------*/
+
+enum {
+        BOOT_REPORT_DESCRIPTOR_SIZE = 63
+};
+
+static const uint8_t BOOT_REPORT_DESCRIPTOR[BOOT_REPORT_DESCRIPTOR_SIZE] = {
+        0x05, 0x01,  // Usage Page (Generic Desktop),
+        0x09, 0x06,  // Usage (Keyboard),
+        0xA1, 0x01,  // Collection (Application),
+        0x75, 0x01,  //   Report Size (1),
+        0x95, 0x08,  //   Report Count (8),       
+        0x05, 0x07,  //   Usage Page (Key Codes);
+        0x19, 0xE0,  //   Usage Minimum (224),
+        0x29, 0xE7,  //   Usage Maximum (231),
+        0x15, 0x00,  //   Logical Minimum (0),
+        0x25, 0x01,  //   Logical Maximum (1),
+        0x81, 0x02,  //   Input (Data, Variable, Absolute),   ; Modifier byte
+        0x95, 0x01,  //   Report Count (1),
+        0x75, 0x08,  //   Report Size (8),
+        0x81, 0x01,  //   Input (Constant),                   ; Reserved byte
+        0x95, 0x05,  //   Report Count (5),
+        0x75, 0x01,  //   Report Size (1),
+        0x05, 0x08,  //   Usage Page (Page# for LEDs),
+        0x19, 0x01,  //   Usage Minimum (1),
+        0x29, 0x05,  //   Usage Maxmimum (5),
+        0x91, 0x02,  //   Output (Data, Variable, Absolute),  ; LED report
+        0x95, 0x01,  //   Report Count (1),
+        0x75, 0x03,  //   Report Size (3),
+        0x91, 0x01,  //   Output (Constant),              ; LED report padding
+        0x95, 0x06,  //   Report Count (6),
+        0x75, 0x08,  //   Report Size (8),
+        0x15, 0x00,  //   Logical Minimum (0),
+        0x25, 0xff,  //   Logical Maximum (255),
+        0x05, 0x07,  //   Usage Page (Key Codes),
+        0x19, 0x00,  //   Usage Minimum (0),
+        0x29, 0xff,  //   Usage Maximum (255),
+        0x81, 0x00,  //   Input (Data, Array),            ; Key arrays (6 bytes)
+        0xC0           // End Collection
+
+};
+
+/*----------------------------------------------------------------------------*/
+
+typedef enum usb_kbd_flags {
+        USB_KBD_STATUS_UNINITIALIZED = 0,
+        USB_KBD_STATUS_INITIALIZED = 1,
+        USB_KBD_STATUS_TO_DESTROY = -1
+} usb_kbd_flags;
 
 /*----------------------------------------------------------------------------*/
@@ -132 +190 @@
 
 typedef enum usbhid_lock_code {
-        USBHID_LOCK_NUM = 0x53,
-        USBHID_LOCK_CAPS = 0x39,
-        USBHID_LOCK_SCROLL = 0x47,
-        USBHID_LOCK_COUNT = 3
+        USB_KBD_LOCK_NUM = 0x53,
+        USB_KBD_LOCK_CAPS = 0x39,
+        USB_KBD_LOCK_SCROLL = 0x47,
+        USB_KBD_LOCK_COUNT = 3
 } usbhid_lock_code;
 
-static const usbhid_lock_code usbhid_lock_codes[USBHID_LOCK_COUNT] = {
-        USBHID_LOCK_NUM,
-        USBHID_LOCK_CAPS,
-        USBHID_LOCK_SCROLL
+static const usbhid_lock_code usbhid_lock_codes[USB_KBD_LOCK_COUNT] = {
+        USB_KBD_LOCK_NUM,
+        USB_KBD_LOCK_CAPS,
+        USB_KBD_LOCK_SCROLL
 };
 
@@ -149 +207 @@
 
 static void default_connection_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *);
-static ddf_dev_ops_t keyboard_ops = {
+ddf_dev_ops_t keyboard_ops = {
         .default_handler = default_connection_handler
 };
@@ -169 +227 @@
         sysarg_t method = IPC_GET_IMETHOD(*icall);
         
-        usbhid_kbd_t *kbd_dev = (usbhid_kbd_t *)fun->driver_data;
+        usb_kbd_t *kbd_dev = (usb_kbd_t *)fun->driver_data;
         assert(kbd_dev != NULL);
 
@@ -203 +261 @@
  * @param kbd_dev Keyboard device structure.
  */
-static void usbhid_kbd_set_led(usbhid_kbd_t *kbd_dev) 
+static void usb_kbd_set_led(usb_kbd_t *kbd_dev) 
 {
         uint8_t buffer[BOOTP_BUFFER_OUT_SIZE];
@@ -237 +295 @@
             usb_debug_str_buffer(buffer, BOOTP_BUFFER_OUT_SIZE, 0));
         
-        assert(kbd_dev->hid_dev != NULL);
-        assert(kbd_dev->hid_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
-        usbhid_req_set_report(kbd_dev->hid_dev, USB_HID_REPORT_TYPE_OUTPUT, 
+        assert(kbd_dev->usb_dev != NULL);
+        
+        usbhid_req_set_report(&kbd_dev->usb_dev->ctrl_pipe, 
+            kbd_dev->usb_dev->interface_no, USB_HID_REPORT_TYPE_OUTPUT, 
             buffer, BOOTP_BUFFER_OUT_SIZE);
 }
@@ -260 +319 @@
  * @param key Key code of the key according to HID Usage Tables.
  */
-void usbhid_kbd_push_ev(usbhid_kbd_t *kbd_dev, int type, unsigned int key)
+void usb_kbd_push_ev(usb_kbd_t *kbd_dev, int type, unsigned int key)
 {
         console_event_t ev;
@@ -310 +369 @@
                         /* Update keyboard lock indicator lights. */
                         if (kbd_dev->lock_keys != locks_old) {
-                                usbhid_kbd_set_led(kbd_dev);
+                                usb_kbd_set_led(kbd_dev);
                         }
                 } else {
@@ -358 +417 @@
 
 /*----------------------------------------------------------------------------*/
-/**
- * Checks if modifiers were pressed or released and generates key events.
- *
- * @param kbd_dev Keyboard device structure.
- * @param modifiers Bitmap of modifiers.
- *
- * @sa usbhid_kbd_push_ev()
- */
-//static void usbhid_kbd_check_modifier_changes(usbhid_kbd_t *kbd_dev, 
-//    const uint8_t *key_codes, size_t count)
-//{
-//      /*
-//       * TODO: why the USB keyboard has NUM_, SCROLL_ and CAPS_LOCK
-//       *       both as modifiers and as keyUSB_HID_LOCK_COUNTs with their own scancodes???
-//       *
-//       * modifiers should be sent as normal keys to usbhid_parse_scancode()!!
-//       * so maybe it would be better if I received it from report parser in 
-//       * that way
-//       */
-        
-//      int i;
-//      for (i = 0; i < count; ++i) {
-//              if ((modifiers & usb_hid_modifiers_consts[i]) &&
-//                  !(kbd_dev->modifiers & usb_hid_modifiers_consts[i])) {
-//                      // modifier pressed
-//                      if (usbhid_modifiers_keycodes[i] != 0) {
-//                              usbhid_kbd_push_ev(kbd_dev, KEY_PRESS, 
-//                                  usbhid_modifiers_keycodes[i]);
-//                      }
-//              } else if (!(modifiers & usb_hid_modifiers_consts[i]) &&
-//                  (kbd_dev->modifiers & usb_hid_modifiers_consts[i])) {
-//                      // modifier released
-//                      if (usbhid_modifiers_keycodes[i] != 0) {
-//                              usbhid_kbd_push_ev(kbd_dev, KEY_RELEASE, 
-//                                  usbhid_modifiers_keycodes[i]);
-//                      }
-//              }       // no change
-//      }
-        
-//      kbd_dev->modifiers = modifiers;
-//}
-
-/*----------------------------------------------------------------------------*/
-
-static inline int usbhid_kbd_is_lock(unsigned int key_code) 
+
+static inline int usb_kbd_is_lock(unsigned int key_code) 
 {
         return (key_code == KC_NUM_LOCK
@@ -414 +430 @@
  *
  * An event is created only when key is pressed or released. Besides handling
- * the events (usbhid_kbd_push_ev()), the auto-repeat fibril is notified about
- * key presses and releases (see usbhid_kbd_repeat_start() and 
- * usbhid_kbd_repeat_stop()).
+ * the events (usb_kbd_push_ev()), the auto-repeat fibril is notified about
+ * key presses and releases (see usb_kbd_repeat_start() and 
+ * usb_kbd_repeat_stop()).
  *
  * @param kbd_dev Keyboard device structure.
@@ -423 +439 @@
  * @param count Number of key codes in report (size of the report).
  *
- * @sa usbhid_kbd_push_ev(), usbhid_kbd_repeat_start(), usbhid_kbd_repeat_stop()
- */
-static void usbhid_kbd_check_key_changes(usbhid_kbd_t *kbd_dev, 
+ * @sa usb_kbd_push_ev(), usb_kbd_repeat_start(), usb_kbd_repeat_stop()
+ */
+static void usb_kbd_check_key_changes(usb_kbd_t *kbd_dev, 
     const uint8_t *key_codes, size_t count)
 {
@@ -434 +450 @@
          * First of all, check if the kbd have reported phantom state.
          *
-         * TODO: this must be changed as we don't know which keys are modifiers
+         *  this must be changed as we don't know which keys are modifiers
          *       and which are regular keys.
          */
@@ -466 +482 @@
                         // not found, i.e. the key was released
                         key = usbhid_parse_scancode(kbd_dev->keys[j]);
-                        if (!usbhid_kbd_is_lock(key)) {
-                                usbhid_kbd_repeat_stop(kbd_dev, key);
+                        if (!usb_kbd_is_lock(key)) {
+                                usb_kbd_repeat_stop(kbd_dev, key);
                         }
-                        usbhid_kbd_push_ev(kbd_dev, KEY_RELEASE, key);
+                        usb_kbd_push_ev(kbd_dev, KEY_RELEASE, key);
                         usb_log_debug2("Key released: %d\n", key);
                 } else {
@@ -491 +507 @@
                         usb_log_debug2("Key pressed: %d (keycode: %d)\n", key,
                             key_codes[i]);
-                        usbhid_kbd_push_ev(kbd_dev, KEY_PRESS, key);
-                        if (!usbhid_kbd_is_lock(key)) {
-                                usbhid_kbd_repeat_start(kbd_dev, key);
+                        usb_kbd_push_ev(kbd_dev, KEY_PRESS, key);
+                        if (!usb_kbd_is_lock(key)) {
+                                usb_kbd_repeat_start(kbd_dev, key);
                         }
                 } else {
@@ -523 +539 @@
  *            structure representing the keyboard.
  *
- * @sa usbhid_kbd_check_key_changes(), usbhid_kbd_check_modifier_changes()
- */
-static void usbhid_kbd_process_keycodes(const uint8_t *key_codes, size_t count,
+ * @sa usb_kbd_check_key_changes(), usb_kbd_check_modifier_changes()
+ */
+static void usb_kbd_process_keycodes(const uint8_t *key_codes, size_t count,
     uint8_t modifiers, void *arg)
 {
@@ -534 +550 @@
         }
         
-        usbhid_kbd_t *kbd_dev = (usbhid_kbd_t *)arg;
+        usb_kbd_t *kbd_dev = (usb_kbd_t *)arg;
         assert(kbd_dev != NULL);
 
@@ -546 +562 @@
         }
         
-        ///usbhid_kbd_check_modifier_changes(kbd_dev, key_codes, count);
-        usbhid_kbd_check_key_changes(kbd_dev, key_codes, count);
+        ///usb_kbd_check_modifier_changes(kbd_dev, key_codes, count);
+        usb_kbd_check_key_changes(kbd_dev, key_codes, count);
 }
 
@@ -558 +574 @@
  * This function uses the HID report parser to translate the data received from
  * the device into generic USB HID key codes and into generic modifiers bitmap.
- * The parser then calls the given callback (usbhid_kbd_process_keycodes()).
+ * The parser then calls the given callback (usb_kbd_process_keycodes()).
  *
  * @note Currently, only the boot protocol is supported.
@@ -566 +582 @@
  * @param actual_size Size of the data from keyboard (report size) in bytes.
  *
- * @sa usbhid_kbd_process_keycodes(), usb_hid_boot_keyboard_input_report().
- */
-static void usbhid_kbd_process_data(usbhid_kbd_t *kbd_dev,
+ * @sa usb_kbd_process_keycodes(), usb_hid_boot_keyboard_input_report(),
+ *     usb_hid_parse_report().
+ */
+static void usb_kbd_process_data(usb_kbd_t *kbd_dev,
                                     uint8_t *buffer, size_t actual_size)
 {
-        assert(kbd_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
-        assert(kbd_dev->hid_dev->parser != NULL);
+        assert(kbd_dev->initialized == USB_KBD_STATUS_INITIALIZED);
+        assert(kbd_dev->parser != NULL);
         
         usb_hid_report_in_callbacks_t *callbacks =
@@ -578 +595 @@
                 sizeof(usb_hid_report_in_callbacks_t));
         
-        callbacks->keyboard = usbhid_kbd_process_keycodes;
+        callbacks->keyboard = usb_kbd_process_keycodes;
 
         usb_log_debug("Calling usb_hid_parse_report() with "
@@ -585 +602 @@
 //      int rc = usb_hid_boot_keyboard_input_report(buffer, actual_size,
 //          callbacks, kbd_dev);
-        int rc = usb_hid_parse_report(kbd_dev->hid_dev->parser, buffer,
-            actual_size, callbacks, kbd_dev);
+        usb_hid_report_path_t *path = usb_hid_report_path();
+        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
+        
+        int rc = usb_hid_parse_report(kbd_dev->parser, buffer,
+            actual_size, path, USB_HID_PATH_COMPARE_STRICT, callbacks, kbd_dev);
+
+        usb_hid_report_path_free (path);
         
         if (rc != EOK) {
@@ -597 +619 @@
 /* HID/KBD structure manipulation                                             */
 /*----------------------------------------------------------------------------*/
+
+static void usb_kbd_mark_unusable(usb_kbd_t *kbd_dev)
+{
+        kbd_dev->initialized = USB_KBD_STATUS_TO_DESTROY;
+}
+
+
+/*----------------------------------------------------------------------------*/
+/* API functions                                                              */
+/*----------------------------------------------------------------------------*/
 /**
  * Creates a new USB/HID keyboard structure.
  *
  * The structure returned by this function is not initialized. Use 
- * usbhid_kbd_init() to initialize it prior to polling.
+ * usb_kbd_init() to initialize it prior to polling.
  *
  * @return New uninitialized structure for representing a USB/HID keyboard or
  *         NULL if not successful (memory error).
  */
-static usbhid_kbd_t *usbhid_kbd_new(void)
-{
-        usbhid_kbd_t *kbd_dev = 
-            (usbhid_kbd_t *)malloc(sizeof(usbhid_kbd_t));
+usb_kbd_t *usb_kbd_new(void)
+{
+        usb_kbd_t *kbd_dev = 
+            (usb_kbd_t *)malloc(sizeof(usb_kbd_t));
 
         if (kbd_dev == NULL) {
@@ -616 +648 @@
         }
         
-        memset(kbd_dev, 0, sizeof(usbhid_kbd_t));
-        
-        kbd_dev->hid_dev = usbhid_dev_new();
-        if (kbd_dev->hid_dev == NULL) {
-                usb_log_fatal("Could not create HID device structure.\n");
+        memset(kbd_dev, 0, sizeof(usb_kbd_t));
+        
+        kbd_dev->parser = (usb_hid_report_parser_t *)(malloc(sizeof(
+            usb_hid_report_parser_t)));
+        if (kbd_dev->parser == NULL) {
+                usb_log_fatal("No memory!\n");
+                free(kbd_dev);
                 return NULL;
         }
         
         kbd_dev->console_phone = -1;
-        kbd_dev->initialized = USBHID_KBD_STATUS_UNINITIALIZED;
+        kbd_dev->initialized = USB_KBD_STATUS_UNINITIALIZED;
         
         return kbd_dev;
-}
-
-/*----------------------------------------------------------------------------*/
-
-static void usbhid_kbd_mark_unusable(usbhid_kbd_t *kbd_dev)
-{
-        kbd_dev->initialized = USBHID_KBD_STATUS_TO_DESTROY;
 }
 
@@ -658 +685 @@
  * @return Other value inherited from function usbhid_dev_init().
  */
-static int usbhid_kbd_init(usbhid_kbd_t *kbd_dev, ddf_dev_t *dev)
+int usb_kbd_init(usb_kbd_t *kbd_dev, usb_device_t *dev)
 {
         int rc;
@@ -671 +698 @@
         
         if (dev == NULL) {
-                usb_log_error("Failed to init keyboard structure: no device"
+                usb_log_error("Failed to init keyboard structure: no USB device"
                     " given.\n");
                 return EINVAL;
         }
         
-        if (kbd_dev->initialized == USBHID_KBD_STATUS_INITIALIZED) {
+        if (kbd_dev->initialized == USB_KBD_STATUS_INITIALIZED) {
                 usb_log_warning("Keyboard structure already initialized.\n");
                 return EINVAL;
         }
         
-        rc = usbhid_dev_init(kbd_dev->hid_dev, dev, &poll_endpoint_description);
-        
+        /* TODO: does not work! */
+        if (!dev->pipes[USB_KBD_POLL_EP_NO].present) {
+                usb_log_warning("Required endpoint not found - probably not "
+                    "a supported device.\n");
+                return ENOTSUP;
+        }
+        
+        /* The USB device should already be initialized, save it in structure */
+        kbd_dev->usb_dev = dev;
+        
+        /* Initialize the report parser. */
+        rc = usb_hid_parser_init(kbd_dev->parser);
         if (rc != EOK) {
-                usb_log_error("Failed to initialize HID device structure: %s\n",
-                   str_error(rc));
+                usb_log_error("Failed to initialize report parser.\n");
                 return rc;
         }
         
-        assert(kbd_dev->hid_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
-        
-        // save the size of the report (boot protocol report by default)
-//      kbd_dev->key_count = BOOTP_REPORT_SIZE;
-        
-        usb_hid_report_path_t path;
-        path.usage_page = USB_HIDUT_PAGE_KEYBOARD;
+        /* Get the report descriptor and parse it. */
+        rc = usb_hid_process_report_descriptor(kbd_dev->usb_dev, 
+            kbd_dev->parser);
+        if (rc != EOK) {
+                usb_log_warning("Could not process report descriptor, "
+                    "falling back to boot protocol.\n");
+                rc = usb_hid_parse_report_descriptor(kbd_dev->parser, 
+                    BOOT_REPORT_DESCRIPTOR, BOOT_REPORT_DESCRIPTOR_SIZE);
+                if (rc != EOK) {
+                        usb_log_error("Failed to parse boot report descriptor:"
+                            " %s.\n", str_error(rc));
+                        return rc;
+                }
+                
+                rc = usbhid_req_set_protocol(&kbd_dev->usb_dev->ctrl_pipe, 
+                    kbd_dev->usb_dev->interface_no, USB_HID_PROTOCOL_BOOT);
+                
+                if (rc != EOK) {
+                        usb_log_warning("Failed to set boot protocol to the "
+                            "device: %s\n", str_error(rc));
+                        return rc;
+                }
+        }
+        
+        /*
+         * TODO: make more general
+         */
+        usb_hid_report_path_t *path = usb_hid_report_path();
+        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
         kbd_dev->key_count = usb_hid_report_input_length(
-            kbd_dev->hid_dev->parser, &path);
+            kbd_dev->parser, path, USB_HID_PATH_COMPARE_STRICT);
+        usb_hid_report_path_free (path);
         
         usb_log_debug("Size of the input report: %zu\n", kbd_dev->key_count);
@@ -729 +788 @@
         
         /*
-         * Set boot protocol.
          * Set LEDs according to initial setup.
          * Set Idle rate
          */
-        assert(kbd_dev->hid_dev != NULL);
-        assert(kbd_dev->hid_dev->initialized);
-        //usbhid_req_set_protocol(kbd_dev->hid_dev, USB_HID_PROTOCOL_BOOT);
-        
-        usbhid_kbd_set_led(kbd_dev);
-        
-        usbhid_req_set_idle(kbd_dev->hid_dev, IDLE_RATE);
-        
-        kbd_dev->initialized = USBHID_KBD_STATUS_INITIALIZED;
+        usb_kbd_set_led(kbd_dev);
+        
+        usbhid_req_set_idle(&kbd_dev->usb_dev->ctrl_pipe, 
+            kbd_dev->usb_dev->interface_no, IDLE_RATE);
+        
+        kbd_dev->initialized = USB_KBD_STATUS_INITIALIZED;
         usb_log_debug("HID/KBD device structure initialized.\n");
         
@@ -748 +803 @@
 
 /*----------------------------------------------------------------------------*/
-/* HID/KBD polling                                                            */
-/*----------------------------------------------------------------------------*/
-/**
- * Main keyboard polling function.
- *
- * This function uses the Interrupt In pipe of the keyboard to poll for events.
- * The keyboard is initialized in a way that it reports only when a key is 
- * pressed or released, so there is no actual need for any sleeping between
- * polls (see usbhid_kbd_try_add_device() or usbhid_kbd_init()).
- *
- * @param kbd_dev Initialized keyboard structure representing the device to 
- *                poll.
- *
- * @sa usbhid_kbd_process_data()
- */
-static void usbhid_kbd_poll(usbhid_kbd_t *kbd_dev)
-{
-        int rc, sess_rc;
-        uint8_t buffer[BOOTP_BUFFER_SIZE];
-        size_t actual_size;
-        
-        usb_log_debug("Polling keyboard...\n");
-        
-        if (!kbd_dev->initialized) {
-                usb_log_error("HID/KBD device not initialized!\n");
-                return;
-        }
-        
-        assert(kbd_dev->hid_dev != NULL);
-        assert(kbd_dev->hid_dev->initialized);
-
-        while (true) {
-                sess_rc = usb_pipe_start_session(
-                    &kbd_dev->hid_dev->poll_pipe);
-                if (sess_rc != EOK) {
-                        usb_log_warning("Failed to start a session: %s.\n",
-                            str_error(sess_rc));
-                        break;
-                }
-
-                rc = usb_pipe_read(&kbd_dev->hid_dev->poll_pipe, 
-                    buffer, BOOTP_BUFFER_SIZE, &actual_size);
-                
-                sess_rc = usb_pipe_end_session(
-                    &kbd_dev->hid_dev->poll_pipe);
-
-                if (rc != EOK) {
-                        usb_log_warning("Error polling the keyboard: %s.\n",
-                            str_error(rc));
-                        break;
-                }
-
-                if (sess_rc != EOK) {
-                        usb_log_warning("Error closing session: %s.\n",
-                            str_error(sess_rc));
-                        break;
-                }
-
-                /*
-                 * If the keyboard answered with NAK, it returned no data.
-                 * This implies that no change happened since last query.
-                 */
-                if (actual_size == 0) {
-                        usb_log_debug("Keyboard returned NAK\n");
-                        continue;
-                }
-
-                /*
-                 * TODO: Process pressed keys.
-                 */
-                usb_log_debug("Calling usbhid_kbd_process_data()\n");
-                usbhid_kbd_process_data(kbd_dev, buffer, actual_size);
-                
-                // disabled for now, no reason to sleep
-                //async_usleep(kbd_dev->hid_dev->poll_interval);
-        }
-}
-
-/*----------------------------------------------------------------------------*/
-/**
- * Function executed by the main driver fibril.
- *
- * Just starts polling the keyboard for events.
- * 
- * @param arg Initialized keyboard device structure (of type usbhid_kbd_t) 
- *            representing the device.
- *
- * @retval EOK if the fibril finished polling the device.
- * @retval EINVAL if no device was given in the argument.
- *
- * @sa usbhid_kbd_poll()
- *
- * @todo Change return value - only case when the fibril finishes is in case
- *       of some error, so the error should probably be propagated from function
- *       usbhid_kbd_poll() to here and up.
- */
-static int usbhid_kbd_fibril(void *arg)
-{
-        if (arg == NULL) {
-                usb_log_error("No device!\n");
-                return EINVAL;
-        }
-        
-        usbhid_kbd_t *kbd_dev = (usbhid_kbd_t *)arg;
-
-        usbhid_kbd_poll(kbd_dev);
-        
-        // as there is another fibril using this device, so we must leave the
-        // structure to it, but mark it for destroying.
-        usbhid_kbd_mark_unusable(kbd_dev);
-        // at the end, properly destroy the KBD structure
-//      usbhid_kbd_free(&kbd_dev);
-//      assert(kbd_dev == NULL);
-
-        return EOK;
-}
-
-/*----------------------------------------------------------------------------*/
-/* API functions                                                              */
-/*----------------------------------------------------------------------------*/
-/**
- * Function for adding a new device of type USB/HID/keyboard.
- *
- * This functions initializes required structures from the device's descriptors
- * and starts new fibril for polling the keyboard for events and another one for
- * handling auto-repeat of keys.
- *
- * During initialization, the keyboard is switched into boot protocol, the idle
- * rate is set to 0 (infinity), resulting in the keyboard only reporting event
- * when a key is pressed or released. Finally, the LED lights are turned on 
- * according to the default setup of lock keys.
- *
- * @note By default, the keyboards is initialized with Num Lock turned on and 
- *       other locks turned off.
- * @note Currently supports only boot-protocol keyboards.
- *
- * @param dev Device to add.
- *
- * @retval EOK if successful.
- * @retval ENOMEM if there
- * @return Other error code inherited from one of functions usbhid_kbd_init(),
- *         ddf_fun_bind() and ddf_fun_add_to_class().
- *
- * @sa usbhid_kbd_fibril(), usbhid_kbd_repeat_fibril()
- */
-int usbhid_kbd_try_add_device(ddf_dev_t *dev)
-{
-        /*
-         * Create default function.
-         */
-        ddf_fun_t *kbd_fun = ddf_fun_create(dev, fun_exposed, "keyboard");
-        if (kbd_fun == NULL) {
-                usb_log_error("Could not create DDF function node.\n");
-                return ENOMEM;
-        }
-        
-        /* 
-         * Initialize device (get and process descriptors, get address, etc.)
-         */
-        usb_log_debug("Initializing USB/HID KBD device...\n");
-        
-        usbhid_kbd_t *kbd_dev = usbhid_kbd_new();
-        if (kbd_dev == NULL) {
-                usb_log_error("Error while creating USB/HID KBD device "
-                    "structure.\n");
-                ddf_fun_destroy(kbd_fun);
-                return ENOMEM;  // TODO: some other code??
-        }
-        
-        int rc = usbhid_kbd_init(kbd_dev, dev);
-        
-        if (rc != EOK) {
-                usb_log_error("Failed to initialize USB/HID KBD device.\n");
-                ddf_fun_destroy(kbd_fun);
-                usbhid_kbd_free(&kbd_dev);
-                return rc;
-        }       
-        
-        usb_log_debug("USB/HID KBD device structure initialized.\n");
-        
-        /*
-         * Store the initialized keyboard device and keyboard ops
-         * to the DDF function.
-         */
-        kbd_fun->driver_data = kbd_dev;
-        kbd_fun->ops = &keyboard_ops;
-
-        rc = ddf_fun_bind(kbd_fun);
-        if (rc != EOK) {
-                usb_log_error("Could not bind DDF function: %s.\n",
-                    str_error(rc));
-                // TODO: Can / should I destroy the DDF function?
-                ddf_fun_destroy(kbd_fun);
-                usbhid_kbd_free(&kbd_dev);
-                return rc;
-        }
-        
-        rc = ddf_fun_add_to_class(kbd_fun, "keyboard");
-        if (rc != EOK) {
-                usb_log_error(
-                    "Could not add DDF function to class 'keyboard': %s.\n",
-                    str_error(rc));
-                // TODO: Can / should I destroy the DDF function?
-                ddf_fun_destroy(kbd_fun);
-                usbhid_kbd_free(&kbd_dev);
-                return rc;
-        }
-        
-        /*
-         * Create new fibril for handling this keyboard
-         */
-        fid_t fid = fibril_create(usbhid_kbd_fibril, kbd_dev);
-        if (fid == 0) {
-                usb_log_error("Failed to start fibril for `%s' device.\n",
-                    dev->name);
-                return ENOMEM;
-        }
-        fibril_add_ready(fid);
-        
-        /*
-         * Create new fibril for auto-repeat
-         */
-        fid = fibril_create(usbhid_kbd_repeat_fibril, kbd_dev);
-        if (fid == 0) {
-                usb_log_error("Failed to start fibril for KBD auto-repeat");
-                return ENOMEM;
-        }
-        fibril_add_ready(fid);
-
-        (void)keyboard_ops;
-
-        /*
-         * Hurrah, device is initialized.
-         */
-        return EOK;
-}
-
-/*----------------------------------------------------------------------------*/
-
-int usbhid_kbd_is_usable(const usbhid_kbd_t *kbd_dev)
-{
-        return (kbd_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
+
+bool usb_kbd_polling_callback(usb_device_t *dev, uint8_t *buffer,
+     size_t buffer_size, void *arg)
+{
+        if (dev == NULL || buffer == NULL || arg == NULL) {
+                // do not continue polling (???)
+                return false;
+        }
+        
+        usb_kbd_t *kbd_dev = (usb_kbd_t *)arg;
+        
+        // TODO: add return value from this function
+        usb_kbd_process_data(kbd_dev, buffer, buffer_size);
+        
+        return true;
+}
+
+/*----------------------------------------------------------------------------*/
+
+void usb_kbd_polling_ended_callback(usb_device_t *dev, bool reason, 
+     void *arg)
+{
+        if (dev == NULL || arg == NULL) {
+                return;
+        }
+        
+        usb_kbd_t *kbd = (usb_kbd_t *)arg;
+        
+        usb_kbd_mark_unusable(kbd);
+}
+
+/*----------------------------------------------------------------------------*/
+
+int usb_kbd_is_initialized(const usb_kbd_t *kbd_dev)
+{
+        return (kbd_dev->initialized == USB_KBD_STATUS_INITIALIZED);
+}
+
+/*----------------------------------------------------------------------------*/
+
+int usb_kbd_is_ready_to_destroy(const usb_kbd_t *kbd_dev)
+{
+        return (kbd_dev->initialized == USB_KBD_STATUS_TO_DESTROY);
 }
 
@@ -998 +854 @@
  * @param kbd_dev Pointer to the structure to be destroyed.
  */
-void usbhid_kbd_free(usbhid_kbd_t **kbd_dev)
+void usb_kbd_free(usb_kbd_t **kbd_dev)
 {
         if (kbd_dev == NULL || *kbd_dev == NULL) {
@@ -1007 +863 @@
         async_hangup((*kbd_dev)->console_phone);
         
-        if ((*kbd_dev)->hid_dev != NULL) {
-                usbhid_dev_free(&(*kbd_dev)->hid_dev);
-                assert((*kbd_dev)->hid_dev == NULL);
-        }
+//      if ((*kbd_dev)->hid_dev != NULL) {
+//              usbhid_dev_free(&(*kbd_dev)->hid_dev);
+//              assert((*kbd_dev)->hid_dev == NULL);
+//      }
         
         if ((*kbd_dev)->repeat_mtx != NULL) {
@@ -1017 +873 @@
                 free((*kbd_dev)->repeat_mtx);
         }
+        
+        // destroy the parser
+        if ((*kbd_dev)->parser != NULL) {
+                usb_hid_free_report_parser((*kbd_dev)->parser);
+        }
+        
+        /* TODO: what about the USB device structure?? */
 
         free(*kbd_dev);

uspace/drv/usbkbd/kbddev.h

@@ -34 +34 @@
  */
 
-#ifndef USBHID_KBDDEV_H_
-#define USBHID_KBDDEV_H_
+#ifndef USB_KBDDEV_H_
+#define USB_KBDDEV_H_
 
 #include <stdint.h>
@@ -45 +45 @@
 #include <ddf/driver.h>
 #include <usb/pipes.h>
+#include <usb/devdrv.h>
 
-#include "hiddev.h"
+#include "kbdrepeat.h"
 
 /*----------------------------------------------------------------------------*/
-/**
- * Structure for keeping information needed for auto-repeat of keys.
- */
-typedef struct {
-        /** Last pressed key. */
-        unsigned int key_new;
-        /** Key to be repeated. */
-        unsigned int key_repeated;
-        /** Delay before first repeat in microseconds. */
-        unsigned int delay_before;
-        /** Delay between repeats in microseconds. */
-        unsigned int delay_between;
-} usbhid_kbd_repeat_t;
-
 /**
  * USB/HID keyboard device type.
@@ -75 +62 @@
  *       being device-specific.
  */
-typedef struct {
-        /** Structure holding generic USB/HID device information. */
-        usbhid_dev_t *hid_dev;
+typedef struct usb_kbd_t {
+        /** Structure holding generic USB device information. */
+        //usbhid_dev_t *hid_dev;
+        usb_device_t *usb_dev;
         
         /** Currently pressed keys (not translated to key codes). */
@@ -96 +84 @@
         
         /** Information for auto-repeat of keys. */
-        usbhid_kbd_repeat_t repeat;
+        usb_kbd_repeat_t repeat;
         
         /** Mutex for accessing the information about auto-repeat. */
         fibril_mutex_t *repeat_mtx;
+        
+        /** Report descriptor. */
+        uint8_t *report_desc;
+
+        /** Report descriptor size. */
+        size_t report_desc_size;
+
+        /** HID Report parser. */
+        usb_hid_report_parser_t *parser;
         
         /** State of the structure (for checking before use). 
@@ -108 +105 @@
          */
         int initialized;
-} usbhid_kbd_t;
+} usb_kbd_t;
 
 /*----------------------------------------------------------------------------*/
 
-int usbhid_kbd_try_add_device(ddf_dev_t *dev);
+enum {
+        USB_KBD_POLL_EP_NO = 0,
+        USB_KBD_POLL_EP_COUNT = 1
+};
 
-int usbhid_kbd_is_usable(const usbhid_kbd_t *kbd_dev);
+usb_endpoint_description_t *usb_kbd_endpoints[USB_KBD_POLL_EP_COUNT + 1];
 
-void usbhid_kbd_free(usbhid_kbd_t **kbd_dev);
+ddf_dev_ops_t keyboard_ops;
 
-void usbhid_kbd_push_ev(usbhid_kbd_t *kbd_dev, int type, unsigned int key);
+/*----------------------------------------------------------------------------*/
 
-#endif /* USBHID_KBDDEV_H_ */
+usb_kbd_t *usb_kbd_new(void);
+
+int usb_kbd_init(usb_kbd_t *kbd_dev, usb_device_t *dev);
+
+bool usb_kbd_polling_callback(usb_device_t *dev, uint8_t *buffer,
+     size_t buffer_size, void *arg);
+
+void usb_kbd_polling_ended_callback(usb_device_t *dev, bool reason, 
+     void *arg);
+
+int usb_kbd_is_initialized(const usb_kbd_t *kbd_dev);
+
+int usb_kbd_is_ready_to_destroy(const usb_kbd_t *kbd_dev);
+
+void usb_kbd_free(usb_kbd_t **kbd_dev);
+
+void usb_kbd_push_ev(usb_kbd_t *kbd_dev, int type, unsigned int key);
+
+#endif /* USB_KBDDEV_H_ */
 
 /**

uspace/drv/usbkbd/kbdrepeat.c

@@ -62 +62 @@
  * 
  * If the currently repeated key is not pressed any more (
- * usbhid_kbd_repeat_stop() was called), it stops repeating it and starts 
+ * usb_kbd_repeat_stop() was called), it stops repeating it and starts 
  * checking again.
  *
@@ -70 +70 @@
  * @param kbd Keyboard device structure.
  */
-static void usbhid_kbd_repeat_loop(usbhid_kbd_t *kbd)
+static void usb_kbd_repeat_loop(usb_kbd_t *kbd)
 {
         unsigned int delay = 0;
@@ -78 +78 @@
         while (true) {
                 // check if the kbd structure is usable
-                if (!usbhid_kbd_is_usable(kbd)) {
-                        usbhid_kbd_free(&kbd);
-                        assert(kbd == NULL);
+                if (!usb_kbd_is_initialized(kbd)) {
+                        if (usb_kbd_is_ready_to_destroy(kbd)) {
+                                usb_kbd_free(&kbd);
+                                assert(kbd == NULL);
+                        }
                         return;
                 }
@@ -90 +92 @@
                                 usb_log_debug2("Repeating key: %u.\n", 
                                     kbd->repeat.key_repeated);
-                                usbhid_kbd_push_ev(kbd, KEY_PRESS, 
+                                usb_kbd_push_ev(kbd, KEY_PRESS, 
                                     kbd->repeat.key_repeated);
                                 delay = kbd->repeat.delay_between;
@@ -125 +127 @@
  * @retval EINVAL if no argument is supplied.
  */
-int usbhid_kbd_repeat_fibril(void *arg)
+int usb_kbd_repeat_fibril(void *arg)
 {
         usb_log_debug("Autorepeat fibril spawned.\n");
@@ -134 +136 @@
         }
         
-        usbhid_kbd_t *kbd = (usbhid_kbd_t *)arg;
+        usb_kbd_t *kbd = (usb_kbd_t *)arg;
         
-        usbhid_kbd_repeat_loop(kbd);
+        usb_kbd_repeat_loop(kbd);
         
         return EOK;
@@ -152 +154 @@
  * @param key Key to start repeating.
  */
-void usbhid_kbd_repeat_start(usbhid_kbd_t *kbd, unsigned int key)
+void usb_kbd_repeat_start(usb_kbd_t *kbd, unsigned int key)
 {
         fibril_mutex_lock(kbd->repeat_mtx);
@@ -170 +172 @@
  * @param key Key to stop repeating.
  */
-void usbhid_kbd_repeat_stop(usbhid_kbd_t *kbd, unsigned int key)
+void usb_kbd_repeat_stop(usb_kbd_t *kbd, unsigned int key)
 {
         fibril_mutex_lock(kbd->repeat_mtx);

uspace/drv/usbkbd/kbdrepeat.h

@@ -34 +34 @@
  */
 
-#ifndef USBHID_KBDREPEAT_H_
-#define USBHID_KBDREPEAT_H_
+#ifndef USB_KBDREPEAT_H_
+#define USB_KBDREPEAT_H_
 
-#include "kbddev.h"
+struct usb_kbd_t;
+
+/*----------------------------------------------------------------------------*/
+/**
+ * Structure for keeping information needed for auto-repeat of keys.
+ */
+typedef struct {
+        /** Last pressed key. */
+        unsigned int key_new;
+        /** Key to be repeated. */
+        unsigned int key_repeated;
+        /** Delay before first repeat in microseconds. */
+        unsigned int delay_before;
+        /** Delay between repeats in microseconds. */
+        unsigned int delay_between;
+} usb_kbd_repeat_t;
 
 /*----------------------------------------------------------------------------*/
 
-int usbhid_kbd_repeat_fibril(void *arg);
+int usb_kbd_repeat_fibril(void *arg);
 
-void usbhid_kbd_repeat_start(usbhid_kbd_t *kbd, unsigned int key);
+void usb_kbd_repeat_start(struct usb_kbd_t *kbd, unsigned int key);
 
-void usbhid_kbd_repeat_stop(usbhid_kbd_t *kbd, unsigned int key);
+void usb_kbd_repeat_stop(struct usb_kbd_t *kbd, unsigned int key);
 
-#endif /* USBHID_KBDREPEAT_H_ */
+#endif /* USB_KBDREPEAT_H_ */
 
 /**

uspace/drv/usbkbd/layout.h

@@ -36 +36 @@
  */
 
-#ifndef USBHID_LAYOUT_H_
-#define USBHID_LAYOUT_H_
+#ifndef USB_KBD_LAYOUT_H_
+#define USB_KBD_LAYOUT_H_
 
 #include <sys/types.h>