Changeset 61257f4 in mainline

Timestamp:

2011-04-07T20:19:24Z (13 years ago)

Author:

Lubos Slovak <lubos.slovak@…>

Branches:

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

Children:

f8e8738

Parents:

fd9ba204

Message:

Initial implementation of general HID driver.

• Should handle:
  • keyboard (most of functions from usbkbd driver), more-or-less works
  • mouse (not implemented yet)
  • generic HID device (just dummy polling callback now)

Location:

uspace/drv/usbhid

Files:

• Makefile (modified) (1 diff)
• generic/hidd.c (added)
• generic/hidd.h (added)
• kbd.h (added)
• kbd/conv.c (added)
• kbd/conv.h (added)
• kbd/kbddev.c (added)
• kbd/kbddev.h (added)
• kbd/kbdrepeat.c (added)
• kbd/kbdrepeat.h (added)
• kbd/layout.h (added)
• kbd/main.c (added)
• layout.h (added)
• main.c (modified) (6 diffs)
• usbhid.c (modified) (2 diffs)
• usbhid.h (modified) (1 diff)
• usbhid.ma (modified) (1 diff)

uspace/drv/usbhid/Makefile

@@ -32 +32 @@
 BINARY = usbhid
 
+STOLEN_LAYOUT_SOURCES = \
+        kbd/layout/us_qwerty.c \
+        kbd/layout/us_dvorak.c \
+        kbd/layout/cz.c
+
 SOURCES = \
         main.c \
-        usbhid.c
+        usbhid.c \
+        kbd/conv.c \
+        kbd/kbddev.c \
+        kbd/kbdrepeat.c \
+        generic/hidd.c \
+        $(STOLEN_LAYOUT_SOURCES)
+
+EXTRA_CLEAN = $(STOLEN_LAYOUT_SOURCES)
+
+SRV_KBD = $(USPACE_PREFIX)/srv/hid/kbd
 
 include $(USPACE_PREFIX)/Makefile.common
 
+kbd/layout/%.c: $(SRV_KBD)/layout/%.c
+        ln -sfn ../../$< $@

uspace/drv/usbhid/main.c

@@ -71 +71 @@
  * @return Other error code inherited from one of functions usb_kbd_init(),
  *         ddf_fun_bind() and ddf_fun_add_to_class().
- *
- * @sa usb_kbd_fibril(), usb_kbd_repeat_fibril()
  */
 static int usb_hid_try_add_device(usb_device_t *dev)
 {
+        /* 
+         * Initialize device (get and process descriptors, get address, etc.)
+         */
+        usb_log_debug("Initializing USB/HID device...\n");
+        
+        usb_hid_dev_t *hid_dev = usb_hid_new();
+        if (hid_dev == NULL) {
+                usb_log_error("Error while creating USB/HID device "
+                    "structure.\n");
+                return ENOMEM;
+        }
+        
+        int rc = usb_hid_init(hid_dev, dev);
+        
+        if (rc != EOK) {
+                usb_log_error("Failed to initialize USB/HID device.\n");
+                usb_hid_free(&hid_dev);
+                return rc;
+        }       
+        
+        usb_log_debug("USB/HID device structure initialized.\n");
+        
         /* Create the function exposed under /dev/devices. */
         ddf_fun_t *hid_fun = ddf_fun_create(dev->ddf_dev, fun_exposed, 
-            "hid");
+            usb_hid_get_function_name(hid_dev->device_type));
         if (hid_fun == NULL) {
                 usb_log_error("Could not create DDF function node.\n");
+                usb_hid_free(&hid_dev);
                 return ENOMEM;
         }
         
-        /* 
-         * Initialize device (get and process descriptors, get address, etc.)
-         */
-        usb_log_debug("Initializing USB/HID device...\n");
-        
-//      usb_kbd_t *kbd_dev = usb_kbd_new();
-//      if (kbd_dev == NULL) {
-//              usb_log_error("Error while creating USB/HID KBD device "
-//                  "structure.\n");
-//              ddf_fun_destroy(hid_fun);
-//              return ENOMEM;  // TODO: some other code??
-//      }
-        
-//      int rc = usb_kbd_init(kbd_dev, dev);
-        
-//      if (rc != EOK) {
-//              usb_log_error("Failed to initialize USB/HID KBD device.\n");
-//              ddf_fun_destroy(hid_fun);
-//              usb_kbd_free(&kbd_dev);
-//              return rc;
-//      }       
-        
-//      usb_log_debug("USB/HID KBD device structure initialized.\n");
-        
         /*
-         * Store the initialized keyboard device and keyboard ops
+         * Store the initialized HID device and HID ops
          * to the DDF function.
          */
-        //kbd_fun->driver_data = kbd_dev;
-        hid_fun->ops = &hid_ops;
-
-        int rc = ddf_fun_bind(hid_fun);
+        hid_fun->ops = &hid_dev->ops;
+        hid_fun->driver_data = hid_dev;   // TODO: maybe change to hid_dev->data
+
+        rc = ddf_fun_bind(hid_fun);
         if (rc != EOK) {
                 usb_log_error("Could not bind DDF function: %s.\n",
@@ -121 +118 @@
                 // TODO: Can / should I destroy the DDF function?
                 ddf_fun_destroy(hid_fun);
-                return rc;
-        }
-        
-        rc = ddf_fun_add_to_class(hid_fun, "hid");
+                usb_hid_free(&hid_dev);
+                return rc;
+        }
+        
+        rc = ddf_fun_add_to_class(hid_fun, 
+            usb_hid_get_class_name(hid_dev->device_type));
         if (rc != EOK) {
                 usb_log_error(
@@ -131 +130 @@
                 // TODO: Can / should I destroy the DDF function?
                 ddf_fun_destroy(hid_fun);
-                return rc;
-        }
-        
-
+                usb_hid_free(&hid_dev);
+                return rc;
+        }
+        
         /* Start automated polling function.
          * This will create a separate fibril that will query the device
@@ -141 +140 @@
        rc = usb_device_auto_poll(dev,
            /* Index of the polling pipe. */
-           USB_HID_POLL_EP_NO,
+           hid_dev->poll_pipe_index,
            /* Callback when data arrives. */
-           usb_hid_polling_callback,
+           hid_dev->poll_callback,
            /* How much data to request. */
-           dev->pipes[USB_HID_POLL_EP_NO].pipe->max_packet_size,
+           dev->pipes[hid_dev->poll_pipe_index].pipe->max_packet_size,
            /* Callback when the polling ends. */
            usb_hid_polling_ended_callback,
            /* Custom argument. */
-           NULL);
+           hid_dev);
         
         
@@ -157 +156 @@
                 return rc;
         }
-
-        (void)hid_ops;
 
         /*
@@ -183 +180 @@
         if (dev->interface_no < 0) {
                 usb_log_warning("Device is not a supported HID device.\n");
-                usb_log_error("Failed to add HID device: endpoint not found."
+                usb_log_error("Failed to add HID device: endpoints not found."
                     "\n");
                 return ENOTSUP;

uspace/drv/usbhid/usbhid.c

@@ -37 +37 @@
 #include <usb/debug.h>
 #include <usb/classes/classes.h>
+#include <usb/classes/hid.h>
+#include <usb/classes/hidparser.h>
+#include <usb/classes/hidreport.h>
+#include <errno.h>
 
 #include "usbhid.h"
 
-/*----------------------------------------------------------------------------*/
-
-/** HID device polling endpoint description. */
-static usb_endpoint_description_t poll_endpoint_description = {
+#include "kbd/kbddev.h"
+#include "generic/hidd.h"
+
+/*----------------------------------------------------------------------------*/
+
+/** Generic HID device polling endpoint description. */
+//static usb_endpoint_description_t usb_hid_generic_poll_endpoint_description = {
+//      .transfer_type = USB_TRANSFER_INTERRUPT,
+//      .direction = USB_DIRECTION_IN,
+//      .interface_class = USB_CLASS_HID,
+//      .flags = 0
+//};
+
+///** Keyboard polling endpoint description for boot protocol class. */
+//static usb_endpoint_description_t ush_hid_kbd_poll_endpoint_description = {
+//      .transfer_type = USB_TRANSFER_INTERRUPT,
+//      .direction = USB_DIRECTION_IN,
+//      .interface_class = USB_CLASS_HID,
+//      .interface_subclass = USB_HID_SUBCLASS_BOOT,
+//      .interface_protocol = USB_HID_PROTOCOL_KEYBOARD,
+//      .flags = 0
+//};
+
+/** Mouse polling endpoint description for boot protocol class. */
+static usb_endpoint_description_t ush_hid_mouse_poll_endpoint_description = {
         .transfer_type = USB_TRANSFER_INTERRUPT,
         .direction = USB_DIRECTION_IN,
         .interface_class = USB_CLASS_HID,
+        .interface_subclass = USB_HID_SUBCLASS_BOOT,
+        .interface_protocol = USB_HID_PROTOCOL_MOUSE,
         .flags = 0
 };
@@ -53 +80 @@
 usb_endpoint_description_t 
     *usb_hid_endpoints[USB_HID_POLL_EP_COUNT + 1] = {
-        &poll_endpoint_description,
+        &ush_hid_kbd_poll_endpoint_description,
+        &ush_hid_mouse_poll_endpoint_description,
+        &usb_hid_generic_poll_endpoint_description,
         NULL
 };
 
-/*----------------------------------------------------------------------------*/
-
-ddf_dev_ops_t hid_ops = {
-        .default_handler = NULL
-};
-
-/*----------------------------------------------------------------------------*/
-
-bool usb_hid_polling_callback(usb_device_t *dev, uint8_t *buffer,
+static const char *HID_MOUSE_FUN_NAME = "mouse";
+static const char *HID_MOUSE_CLASS_NAME = "mouse";
+
+/*----------------------------------------------------------------------------*/
+
+usb_hid_dev_t *usb_hid_new(void)
+{
+        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)calloc(1,
+            sizeof(usb_hid_dev_t));
+        
+        if (hid_dev == NULL) {
+                usb_log_fatal("No memory!\n");
+                return NULL;
+        }
+        
+        hid_dev->parser = (usb_hid_report_parser_t *)(malloc(sizeof(
+            usb_hid_report_parser_t)));
+        if (hid_dev->parser == NULL) {
+                usb_log_fatal("No memory!\n");
+                free(hid_dev);
+                return NULL;
+        }
+        
+        return hid_dev;
+}
+
+/*----------------------------------------------------------------------------*/
+
+static bool usb_dummy_polling_callback(usb_device_t *dev, uint8_t *buffer,
      size_t buffer_size, void *arg)
 {
-        usb_debug_str_buffer(buffer, buffer_size, 0);
-        return true;
-}
-
-/*----------------------------------------------------------------------------*/
-
-void usb_hid_polling_ended_callback(usb_device_t *dev, bool reason,
-     void *arg) 
-{
-        
+        return false;
+}
+
+/*----------------------------------------------------------------------------*/
+
+static int usb_hid_check_pipes(usb_hid_dev_t *hid_dev, usb_device_t *dev)
+{
+        if (dev->pipes[USB_HID_KBD_POLL_EP_NO].present) {
+                usb_log_debug("Found keyboard endpoint.\n");
+                
+                // save the pipe index and device type
+                hid_dev->poll_pipe_index = USB_HID_KBD_POLL_EP_NO;
+                hid_dev->device_type = USB_HID_PROTOCOL_KEYBOARD;
+                
+                // set the polling callback
+                hid_dev->poll_callback = usb_kbd_polling_callback;
+
+        } else if (dev->pipes[USB_HID_MOUSE_POLL_EP_NO].present) {
+                usb_log_debug("Found mouse endpoint.\n");
+                
+                // save the pipe index and device type
+                hid_dev->poll_pipe_index = USB_HID_MOUSE_POLL_EP_NO;
+                hid_dev->device_type = USB_HID_PROTOCOL_MOUSE;
+                
+                // set the polling callback
+                hid_dev->poll_callback = usb_dummy_polling_callback;
+                
+        } else if (dev->pipes[USB_HID_GENERIC_POLL_EP_NO].present) {
+                usb_log_debug("Found generic HID endpoint.\n");
+                
+                // save the pipe index and device type
+                hid_dev->poll_pipe_index = USB_HID_GENERIC_POLL_EP_NO;
+                hid_dev->device_type = USB_HID_PROTOCOL_NONE;
+                
+                // set the polling callback
+                hid_dev->poll_callback = usb_hid_polling_callback;
+                
+        } else {
+                usb_log_warning("None of supported endpoints found - probably"
+                    " not a supported device.\n");
+                return ENOTSUP;
+        }
+        
+        return EOK;
+}
+
+/*----------------------------------------------------------------------------*/
+
+static int usb_hid_init_parser(usb_hid_dev_t *hid_dev)
+{
+        /* Initialize the report parser. */
+        int rc = usb_hid_parser_init(hid_dev->parser);
+        if (rc != EOK) {
+                usb_log_error("Failed to initialize report parser.\n");
+                return rc;
+        }
+        
+        /* Get the report descriptor and parse it. */
+        rc = usb_hid_process_report_descriptor(hid_dev->usb_dev, 
+            hid_dev->parser);
+        if (rc != EOK) {
+                usb_log_warning("Could not process report descriptor.\n");
+                
+                if (hid_dev->device_type == USB_HID_PROTOCOL_KEYBOARD) {
+                        usb_log_warning("Falling back to boot protocol.\n");
+                        
+                        rc = usb_kbd_set_boot_protocol(hid_dev);
+                        
+                } else if (hid_dev->device_type == USB_HID_PROTOCOL_MOUSE) {
+                        usb_log_warning("No boot protocol for mouse yet.\n");
+                        rc = ENOTSUP;
+                }
+        }
+        
+        return rc;
+}
+
+/*----------------------------------------------------------------------------*/
+
+int usb_hid_init(usb_hid_dev_t *hid_dev, usb_device_t *dev)
+{
+        int rc;
+        
+        usb_log_debug("Initializing HID structure...\n");
+        
+        if (hid_dev == NULL) {
+                usb_log_error("Failed to init HID structure: no structure given"
+                    ".\n");
+                return EINVAL;
+        }
+        
+        if (dev == NULL) {
+                usb_log_error("Failed to init HID structure: no USB device"
+                    " given.\n");
+                return EINVAL;
+        }
+        
+        /* The USB device should already be initialized, save it in structure */
+        hid_dev->usb_dev = dev;
+        
+        rc = usb_hid_check_pipes(hid_dev, dev);
+        if (rc != EOK) {
+                return rc;
+        }
+        
+        rc = usb_hid_init_parser(hid_dev);
+        if (rc != EOK) {
+                usb_log_error("Failed to initialize HID parser.\n");
+                return rc;
+        }
+        
+        switch (hid_dev->device_type) {
+        case USB_HID_PROTOCOL_KEYBOARD:
+                // initialize the keyboard structure
+                rc = usb_kbd_init(hid_dev);
+                if (rc != EOK) {
+                        usb_log_warning("Failed to initialize KBD structure."
+                            "\n");
+                }
+                break;
+        case USB_HID_PROTOCOL_MOUSE:
+                break;
+        default:
+                break;
+        }
+        
+        return rc;
+}
+
+/*----------------------------------------------------------------------------*/
+
+void usb_hid_polling_ended_callback(usb_device_t *dev, bool reason, 
+     void *arg)
+{
+        if (dev == NULL || arg == NULL) {
+                return;
+        }
+        
+        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
+        
+        usb_hid_free(&hid_dev);
+}
+
+/*----------------------------------------------------------------------------*/
+
+const char *usb_hid_get_function_name(usb_hid_iface_protocol_t device_type)
+{
+        switch (device_type) {
+        case USB_HID_PROTOCOL_KEYBOARD:
+                return HID_KBD_FUN_NAME;
+                break;
+        case USB_HID_PROTOCOL_MOUSE:
+                return HID_MOUSE_FUN_NAME;
+                break;
+        default:
+                return HID_GENERIC_FUN_NAME;
+        }
+}
+
+/*----------------------------------------------------------------------------*/
+
+const char *usb_hid_get_class_name(usb_hid_iface_protocol_t device_type)
+{
+        switch (device_type) {
+        case USB_HID_PROTOCOL_KEYBOARD:
+                return HID_KBD_CLASS_NAME;
+                break;
+        case USB_HID_PROTOCOL_MOUSE:
+                return HID_MOUSE_CLASS_NAME;
+                break;
+        default:
+                return HID_GENERIC_CLASS_NAME;
+        }
+}
+
+/*----------------------------------------------------------------------------*/
+
+void usb_hid_free(usb_hid_dev_t **hid_dev)
+{
+        if (hid_dev == NULL || *hid_dev == NULL) {
+                return;
+        }
+        
+        switch ((*hid_dev)->device_type) {
+        case USB_HID_PROTOCOL_KEYBOARD:
+                usb_kbd_deinit(*hid_dev);
+                break;
+        case USB_HID_PROTOCOL_MOUSE:
+                break;
+        default:
+                break;
+        }
+
+        // destroy the parser
+        if ((*hid_dev)->parser != NULL) {
+                usb_hid_free_report_parser((*hid_dev)->parser);
+        }
+
+        if ((*hid_dev)->report_desc != NULL) {
+                free((*hid_dev)->report_desc);
+        }
+
+        free(*hid_dev);
+        *hid_dev = NULL;
 }
 

uspace/drv/usbhid/usbhid.h

@@ -42 +42 @@
 
 //#include <usb/classes/hid.h>
-//#include <usb/classes/hidparser.h>
+#include <usb/classes/hidparser.h>
 #include <ddf/driver.h>
 #include <usb/pipes.h>
 #include <usb/devdrv.h>
+#include <usb/classes/hid.h>
 
 /*----------------------------------------------------------------------------*/
-///**
-// * USB/HID keyboard device type.
-// *
-// * Holds a reference to generic USB/HID device structure and keyboard-specific
-// * data, such as currently pressed keys, modifiers and lock keys.
-// *
-// * Also holds a IPC phone to the console (since there is now no other way to 
-// * communicate with it).
-// *
-// * @note Storing active lock keys in this structure results in their setting
-// *       being device-specific.
-// */
-//typedef struct usb_kbd_t {
-//      /** Structure holding generic USB device information. */
-//      //usbhid_dev_t *hid_dev;
-//      usb_device_t *usb_dev;
+/**
+ * Structure for holding general HID device data.
+ */
+typedef struct usb_hid_dev_t {
+        /** Structure holding generic USB device information. */
+        usb_device_t *usb_dev;
         
-//      /** Currently pressed keys (not translated to key codes). */
-//      uint8_t *keys;
-//      /** Count of stored keys (i.e. number of keys in the report). */
-//      size_t key_count;
-//      /** Currently pressed modifiers (bitmap). */
-//      uint8_t modifiers;
+        /** @todo What is this actually? */
+        ddf_dev_ops_t ops;
         
-//      /** Currently active modifiers including locks. Sent to the console. */
-//      unsigned mods;
+        /** Index of the polling pipe in usb_hid_endpoints array. */
+        int poll_pipe_index;
         
-//      /** Currently active lock keys. */
-//      unsigned lock_keys;
+        /** Function to be called when data arrives from the device. */
+        usb_polling_callback_t poll_callback;
         
-//      /** IPC phone to the console device (for sending key events). */
-//      int console_phone;
+        /** Report descriptor. */
+        uint8_t *report_desc;
+
+        /** Report descriptor size. */
+        size_t report_desc_size;
         
-//      /** Information for auto-repeat of keys. */
-//      usb_kbd_repeat_t repeat;
+        /** HID Report parser. */
+        usb_hid_report_parser_t *parser;
         
-//      /** Mutex for accessing the information about auto-repeat. */
-//      fibril_mutex_t *repeat_mtx;
+        /** Arbitrary data (e.g. a special structure for handling keyboard). */
+        void *data;
         
-//      /** Report descriptor. */
-//      uint8_t *report_desc;
-
-//      /** Report descriptor size. */
-//      size_t report_desc_size;
-        
-//      uint8_t *output_buffer;
-        
-//      size_t output_size;
-        
-//      size_t led_output_size;
-        
-//      usb_hid_report_path_t *led_path;
-        
-//      int32_t *led_data;
-
-//      /** HID Report parser. */
-//      usb_hid_report_parser_t *parser;
-        
-//      /** State of the structure (for checking before use). 
-//       * 
-//       * 0 - not initialized
-//       * 1 - initialized
-//       * -1 - ready for destroying
-//       */
-//      int initialized;
-//} usb_kbd_t;
+        /** Type of the device (keyboard, mouse, generic HID device). */
+        usb_hid_iface_protocol_t device_type;
+} usb_hid_dev_t;
 
 /*----------------------------------------------------------------------------*/
 
 enum {
-        USB_HID_POLL_EP_NO = 0,
-        USB_HID_POLL_EP_COUNT = 1
+        USB_HID_KBD_POLL_EP_NO = 0,
+        USB_HID_MOUSE_POLL_EP_NO = 1,
+        USB_HID_GENERIC_POLL_EP_NO = 2,
+        USB_HID_POLL_EP_COUNT = 3
 };
 
 usb_endpoint_description_t *usb_hid_endpoints[USB_HID_POLL_EP_COUNT + 1];
 
-ddf_dev_ops_t hid_ops;
-
 /*----------------------------------------------------------------------------*/
 
-bool usb_hid_polling_callback(usb_device_t *dev, uint8_t *buffer,
-     size_t buffer_size, void *arg);
+usb_hid_dev_t *usb_hid_new(void);
 
-void usb_hid_polling_ended_callback(usb_device_t *dev, bool reason,
+int usb_hid_init(usb_hid_dev_t *hid_dev, usb_device_t *dev);
+
+void usb_hid_polling_ended_callback(usb_device_t *dev, bool reason, 
      void *arg);
 
-#endif /* USB_KBDDEV_H_ */
+const char *usb_hid_get_function_name(usb_hid_iface_protocol_t device_type);
+
+const char *usb_hid_get_class_name(usb_hid_iface_protocol_t device_type);
+
+/** @todo Maybe not needed in the API. */
+void usb_hid_free(usb_hid_dev_t **hid_dev);
+
+#endif /* USB_USBHID_H_ */
 
 /**

uspace/drv/usbhid/usbhid.ma

@@ -1 @@
-100 usb&interface&class=HID
+1000 usb&interface&class=HID&subclass=0x01&protocol=0x02
+1000 usb&interface&class=HID