Changes in / [a80849c:92574f4] in mainline

Location:

uspace

Files:

• drv/usbhid/hid.h (modified) (2 diffs)
• drv/usbhid/main.c (modified) (23 diffs)
• lib/usb/include/usb/classes/hidparser.h (modified) (1 diff)

uspace/drv/usbhid/hid.h

@@ -37 +37 @@
 #define USBHID_HID_H_
 
+#include <stdint.h>
+
 #include <usb/classes/hid.h>
 #include <ddf/driver.h>
@@ -74 +76 @@
         usb_endpoint_pipe_t ctrl_pipe;
         usb_endpoint_pipe_t poll_pipe;
+        
+        uint8_t *keycodes;
+        size_t keycode_count;
+        uint8_t modifiers;
 } usb_hid_dev_kbd_t;
 

uspace/drv/usbhid/main.c

@@ -51 +51 @@
 #include <usb/descriptor.h>
 #include <io/console.h>
+#include <stdint.h>
 #include "hid.h"
 #include "descparser.h"
@@ -61 +62 @@
 
 #define GUESSED_POLL_ENDPOINT 1
+#define BOOTP_REPORT_SIZE 6
 
 /** Keyboard polling endpoint description for boot protocol class. */
@@ -207 +209 @@
         }
 /*
-        printf("type: %d\n", type);
-        printf("mods: 0x%x\n", mods);
-        printf("keycode: %u\n", key);
+        usb_log_debug2("type: %d\n", type);
+        usb_log_debug2("mods: 0x%x\n", mods);
+        usb_log_debug2("keycode: %u\n", key);
 */
         
@@ -239 +241 @@
         ev.c = layout[active_layout]->parse_ev(&ev);
 
-        printf("Sending key %d to the console\n", ev.key);
+        usb_log_debug("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 +252 @@
         /*
          * 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_boot_keycodes[5] = {
+        KC_NUM_LOCK,      /* USB_HID_MOD_BOOT_NUM_LOCK */
+        KC_CAPS_LOCK,     /* USB_HID_MOD_BOOT_CAPS_LOCK */
+        KC_SCROLL_LOCK,   /* USB_HID_MOD_BOOT_SCROLL_LOCK */
+        0,                /* USB_HID_MOD_BOOT_COMPOSE */
+        0                 /* USB_HID_MOD_BOOT_KANA */
+};
+
+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_BOOT_COUNT; ++i) {
+                if ((modifiers & usb_hid_modifiers_boot_consts[i]) &&
+                    !(kbd_dev->modifiers & usb_hid_modifiers_boot_consts[i])) {
+                        // modifier pressed
+                        if (usb_hid_modifiers_boot_keycodes[i] != 0) {
+                                kbd_push_ev(KEY_PRESS, 
+                                    usb_hid_modifiers_boot_keycodes[i]);
+                        }
+                } else if (!(modifiers & usb_hid_modifiers_boot_consts[i]) &&
+                    (kbd_dev->modifiers & usb_hid_modifiers_boot_consts[i])) {
+                        // modifier released
+                        if (usb_hid_modifiers_boot_keycodes[i] != 0) {
+                                kbd_push_ev(KEY_RELEASE, 
+                                    usb_hid_modifiers_boot_keycodes[i]);
+                        }
+                }       // no change
+        }
+}
+
+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]) {
+                        ++j;
+                }
+                
+                if (j == 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);
+                } 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;
+                }
+                
+                assert(kbd_dev->keycode_count <= kbd_dev->keycode_count);
+                
+                if (j == kbd_dev->keycode_count) {
+                        // not found, i.e. new key pressed
+                        key = usbkbd_parse_scancode(key_codes[i]);
+                        kbd_push_ev(KEY_PRESS, key);
+                } else {
+                        // found, nothing happens
+                }
+        }
+}
+
 /*
  * Callbacks for parser
@@ -260 +353 @@
     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);
 }
 
@@ -291 +388 @@
         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;
+                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);
+                kbd_dev->conf->interfaces[i].report_desc = 
+                    (uint8_t *)malloc(length);
                 
                 // get the descriptor from the device
@@ -317 +415 @@
         return EOK;
 }
+
 static int usbkbd_process_descriptors(usb_hid_dev_kbd_t *kbd_dev)
 {
@@ -388 +487 @@
         free(descriptors);
         if (rc != EOK) {
-                printf("Problem with parsing standard descriptors.\n");
+                usb_log_warning("Problem with parsing standard descriptors.\n");
                 return rc;
         }
@@ -395 +494 @@
         rc = usbkbd_get_report_descriptor(kbd_dev);
         if (rc != EOK) {
-                printf("Problem with parsing HID REPORT descriptor.\n");
+                usb_log_warning("Problem with parsing REPORT descriptor.\n");
                 return rc;
         }
@@ -405 +504 @@
          * 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.")
+         *    ("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
+         *    as the endpoint for polling
          */
 
@@ -421 +521 @@
 
         if (kbd_dev == NULL) {
-                fprintf(stderr, NAME ": No memory!\n");
+                usb_log_fatal("No memory!\n");
                 return NULL;
         }
@@ -476 +576 @@
         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 +599 @@
         size_t actual_size;
 
-        printf("Polling keyboard...\n");
+        usb_log_info("Polling keyboard...\n");
 
         while (true) {
@@ -504 +606 @@
                 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 +616 @@
 
                 if (rc != EOK) {
-                        printf("Error polling the keyboard: %s.\n",
+                        usb_log_warning("Error polling the keyboard: %s.\n",
                             str_error(rc));
                         continue;
@@ -520 +622 @@
 
                 if (sess_rc != EOK) {
-                        printf("Error closing session: %s.\n",
+                        usb_log_warning("Error closing session: %s.\n",
                             str_error(sess_rc));
                         continue;
@@ -530 +632 @@
                  */
                 if (actual_size == 0) {
-                        printf("Keyboard returned NAK\n");
+                        usb_log_debug("Keyboard returned NAK\n");
                         continue;
                 }
@@ -537 +639 @@
                  * 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 +649 @@
 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;
         }
@@ -559 +659 @@
         usb_hid_dev_kbd_t *kbd_dev = usbkbd_init_device(dev);
         if (kbd_dev == NULL) {
-                printf("Error while initializing device.\n");
+                usb_log_error("Error while initializing device.\n");
                 return -1;
         }
@@ -607 +707 @@
         fid_t fid = fibril_create(usbkbd_fibril_device, 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 +734 @@
 int main(int argc, char *argv[])
 {
-        usb_log_enable(USB_LOG_LEVEL_INFO, "usbhid");
+        usb_log_enable(USB_LOG_LEVEL_MAX, NAME);
         return ddf_driver_main(&kbd_driver);
 }

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_BOOT_NUM_LOCK = 0x01,
+        USB_HID_MOD_BOOT_CAPS_LOCK = 0x02,
+        USB_HID_MOD_BOOT_SCROLL_LOCK = 0x04,
+        USB_HID_MOD_BOOT_COMPOSE = 0x08,
+        USB_HID_MOD_BOOT_KANA = 0x10,
+        USB_HID_MOD_BOOT_COUNT = 5
+} usb_hid_modifiers_boot_t;
+
+static const usb_hid_modifiers_boot_t usb_hid_modifiers_boot_consts[5] = {
+        USB_HID_MOD_BOOT_NUM_LOCK,
+        USB_HID_MOD_BOOT_CAPS_LOCK,
+        USB_HID_MOD_BOOT_SCROLL_LOCK,
+        USB_HID_MOD_BOOT_COMPOSE,
+        USB_HID_MOD_BOOT_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
 
 /*