Changes in uspace/drv/usbhid/kbddev.c [2f593872:ac8285d] in mainline

File:

• uspace/drv/usbhid/kbddev.c (modified) (17 diffs)

uspace/drv/usbhid/kbddev.c

@@ -38 +38 @@
 #include <str_error.h>
 #include <fibril.h>
-#include <stdio.h>
 
 #include <io/keycode.h>
@@ -63 +62 @@
 static const size_t BOOTP_BUFFER_SIZE = 8;
 static const size_t BOOTP_BUFFER_OUT_SIZE = 1;
-static const uint8_t BOOTP_ERROR_ROLLOVER = 1;
-static const uint8_t IDLE_RATE = 0;
 
 /** Keyboard polling endpoint description for boot protocol class. */
@@ -152 +149 @@
         uint8_t buffer[BOOTP_BUFFER_OUT_SIZE];
         int rc= 0;
+        unsigned i;
         
         memset(buffer, 0, BOOTP_BUFFER_OUT_SIZE);
@@ -179 +177 @@
         }
         
-        usb_log_debug("Output report buffer: %s\n", 
-            usb_debug_str_buffer(buffer, BOOTP_BUFFER_OUT_SIZE, 0));
-        
+        // TODO: REFACTOR!!!
+        
+        usb_log_debug("Output report buffer: ");
+        for (i = 0; i < BOOTP_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);
+
         assert(kbd_dev->hid_dev != NULL);
         assert(kbd_dev->hid_dev->initialized);
-        usbhid_req_set_report(kbd_dev->hid_dev, USB_HID_REPORT_TYPE_OUTPUT, 
-            buffer, BOOTP_BUFFER_OUT_SIZE);
+        usbhid_req_set_report(kbd_dev->hid_dev, value, buffer, 
+            BOOTP_BUFFER_OUT_SIZE);
 }
 
@@ -222 +228 @@
 
         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
@@ -235 +247 @@
                         usbhid_kbd_set_led(kbd_dev);
                 } else {
+                        usb_log_debug2("\nKey released.\n");
                         kbd_dev->lock_keys = kbd_dev->lock_keys & ~mod_mask;
                 }
         }
 
+        usb_log_debug2("\n\nmods after: 0x%x\n", kbd_dev->mods);
+        usb_log_debug2("\nLock keys after: 0x%x\n\n", kbd_dev->lock_keys);
+        
         if (key == KC_CAPS_LOCK || key == KC_NUM_LOCK || key == KC_SCROLL_LOCK) {
                 // do not send anything to the console, this is our business
@@ -265 +281 @@
         ev.key = key;
         ev.mods = kbd_dev->mods;
+        
+        if (ev.mods & KM_NUM_LOCK) {
+                usb_log_debug("\n\nNum Lock turned on.\n\n");
+        }
 
         ev.c = layout[active_layout]->parse_ev(&ev);
 
         usb_log_debug2("Sending key %d to the console\n", ev.key);
-        if (kbd_dev->console_phone < 0) {
-                usb_log_warning(
-                    "Connection to console not ready, key discarded.\n");
-                return;
-        }
+        assert(kbd_dev->console_phone != -1);
         
         async_msg_4(kbd_dev->console_phone, KBD_EVENT, ev.type, ev.key, 
@@ -320 +336 @@
     const uint8_t *key_codes)
 {
+        // TODO: phantom state!!
+        
         unsigned int key;
         unsigned int i, j;
-        
-        /*
-         * First of all, check if the kbd have reported phantom state.
-         */
-        i = 0;
-        // all fields should report Error Rollover
-        while (i < kbd_dev->keycode_count &&
-            key_codes[i] == BOOTP_ERROR_ROLLOVER) {
-                ++i;
-        }
-        if (i == kbd_dev->keycode_count) {
-                usb_log_debug("Phantom state occured.\n");
-                // phantom state, do nothing
-                return;
-        }
         
         // TODO: quite dummy right now, think of better implementation
@@ -355 +358 @@
                         key = usbhid_parse_scancode(kbd_dev->keycodes[j]);
                         usbhid_kbd_push_ev(kbd_dev, KEY_RELEASE, key);
-                        usb_log_debug2("Key released: %d\n", key);
+                        usb_log_debug2("\nKey released: %d\n", key);
                 } else {
                         // found, nothing happens
@@ -375 +378 @@
                         // not found, i.e. new key pressed
                         key = usbhid_parse_scancode(key_codes[i]);
-                        usb_log_debug2("Key pressed: %d (keycode: %d)\n", key,
+                        usb_log_debug2("\nKey pressed: %d (keycode: %d)\n", key,
                             key_codes[i]);
                         usbhid_kbd_push_ev(kbd_dev, KEY_PRESS, key);
@@ -382 +385 @@
                 }
         }
-//      // report all currently pressed keys
-//      for (i = 0; i < kbd_dev->keycode_count; ++i) {
-//              if (key_codes[i] != 0) {
-//                      key = usbhid_parse_scancode(key_codes[i]);
-//                      usb_log_debug2("Key pressed: %d (keycode: %d)\n", key,
-//                          key_codes[i]);
-//                      usbhid_kbd_push_ev(kbd_dev, KEY_PRESS, key);
-//              }
-//      }
         
         memcpy(kbd_dev->keycodes, key_codes, kbd_dev->keycode_count);
-
-        usb_log_debug("New stored keycodes: %s\n", 
-            usb_debug_str_buffer(kbd_dev->keycodes, kbd_dev->keycode_count, 0));
+        
+        usb_log_debug2("\nNew stored keycodes: ");
+        for (i = 0; i < kbd_dev->keycode_count; ++i) {
+                usb_log_debug2("%d ", kbd_dev->keycodes[i]);
+        }
 }
 
@@ -410 +406 @@
                 return;
         }
+
+        usb_log_debug2("Got keys from parser: ");
+        unsigned i;
+        for (i = 0; i < count; ++i) {
+                usb_log_debug2("%d ", key_codes[i]);
+        }
+        usb_log_debug2("\n");
         
         usbhid_kbd_t *kbd_dev = (usbhid_kbd_t *)arg;
         assert(kbd_dev != NULL);
-
-        usb_log_debug("Got keys from parser: %s\n", 
-            usb_debug_str_buffer(key_codes, kbd_dev->keycode_count, 0));
         
         if (count != kbd_dev->keycode_count) {
@@ -440 +440 @@
         callbacks->keyboard = usbhid_kbd_process_keycodes;
 
-        usb_log_debug("Calling usb_hid_parse_report() with "
-            "buffer %s\n", usb_debug_str_buffer(buffer, actual_size, 0));
-        
-//      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_parse_report(kbd_dev->parser, buffer, actual_size, callbacks, 
+        //    NULL);
+        /*usb_log_debug2("Calling usb_hid_boot_keyboard_input_report() with size"
+            " %zu\n", actual_size);*/
+        //dump_buffer("bufffer: ", buffer, actual_size);
+        
+        int rc = usb_hid_boot_keyboard_input_report(buffer, actual_size,
+            callbacks, kbd_dev);
         
         if (rc != EOK) {
@@ -498 +499 @@
         }
         
-        usb_hid_free_report_parser((*kbd_dev)->parser);
-        
         free(*kbd_dev);
         *kbd_dev = NULL;
@@ -556 +555 @@
          * 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_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 = 1;
@@ -593 +589 @@
 
         while (true) {
+                async_usleep(1000 * 10);
+
                 sess_rc = usb_endpoint_pipe_start_session(
                     &kbd_dev->hid_dev->poll_pipe);
@@ -633 +631 @@
                 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);
         }