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

File:

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

uspace/drv/usbhid/kbddev.c

@@ -37 +37 @@
 #include <errno.h>
 #include <str_error.h>
-#include <stdio.h>
+#include <fibril.h>
 
 #include <io/keycode.h>
 #include <ipc/kbd.h>
 #include <async.h>
-#include <fibril.h>
-#include <fibril_synch.h>
 
 #include <usb/usb.h>
@@ -57 +55 @@
 #include "layout.h"
 #include "conv.h"
-#include "kbdrepeat.h"
-
-/*----------------------------------------------------------------------------*/
-/** Default modifiers when the keyboard is initialized. */
+
+/*----------------------------------------------------------------------------*/
+
 static const unsigned DEFAULT_ACTIVE_MODS = KM_NUM_LOCK;
-
-/** Boot protocol report size (key part). */
 static const size_t BOOTP_REPORT_SIZE = 6;
-
-/** Boot protocol total report size. */
 static const size_t BOOTP_BUFFER_SIZE = 8;
-
-/** Boot protocol output report size. */
 static const size_t BOOTP_BUFFER_OUT_SIZE = 1;
-
-/** Boot protocol error key code. */
-static const uint8_t BOOTP_ERROR_ROLLOVER = 1;
-
-/** Default idle rate for keyboards. */
-static const uint8_t IDLE_RATE = 0;
-
-/** Delay before a pressed key starts auto-repeating. */
-static const unsigned int DEFAULT_DELAY_BEFORE_FIRST_REPEAT = 500 * 1000;
-
-/** Delay between two repeats of a pressed key when auto-repeating. */
-static const unsigned int DEFAULT_REPEAT_DELAY = 50 * 1000;
 
 /** Keyboard polling endpoint description for boot protocol class. */
@@ -100 +79 @@
 #define NUM_LAYOUTS 3
 
-/** Keyboard layout map. */
 static layout_op_t *layout[NUM_LAYOUTS] = {
         &us_qwerty_op,
@@ -112 +90 @@
 /* Modifier constants                                                         */
 /*----------------------------------------------------------------------------*/
-/** Mapping of USB modifier key codes to generic modifier key codes. */
+
 static const keycode_t usbhid_modifiers_keycodes[USB_HID_MOD_COUNT] = {
         KC_LCTRL,         /* USB_HID_MOD_LCTRL */
@@ -133 +111 @@
 };
 
-/** 
- * Default handler for IPC methods not handled by DDF.
+/** Default handler for IPC methods not handled by DDF.
  *
- * Currently recognizes only one method (IPC_M_CONNECT_TO_ME), in which case it
- * assumes the caller is the console and thus it stores IPC phone to it for 
- * later use by the driver to notify about key events.
- *
- * @param fun Device function handling the call.
+ * @param dev Device handling the call.
  * @param icallid Call id.
  * @param icall Call data.
@@ -171 +144 @@
 /* Key processing functions                                                   */
 /*----------------------------------------------------------------------------*/
-/**
- * Handles turning of LED lights on and off.
- *
- * In case of USB keyboards, the LEDs are handled in the driver, not in the 
- * device. When there should be a change (lock key was pressed), the driver
- * uses a Set_Report request sent to the device to set the state of the LEDs.
- *
- * This functions sets the LED lights according to current settings of modifiers
- * kept in the keyboard device structure.
- *
- * @param kbd_dev Keyboard device structure.
- */
+
 static void usbhid_kbd_set_led(usbhid_kbd_t *kbd_dev) 
 {
         uint8_t buffer[BOOTP_BUFFER_OUT_SIZE];
         int rc= 0;
+        unsigned i;
         
         memset(buffer, 0, BOOTP_BUFFER_OUT_SIZE);
@@ -214 +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);
-}
-
-/*----------------------------------------------------------------------------*/
-/**
- * Processes key events.
- *
- * @note This function was copied from AT keyboard driver and modified to suit
- *       USB keyboard.
- *
- * @note Lock keys are not sent to the console, as they are completely handled
- *       in the driver. It may, however, be required later that the driver
- *       sends also these keys to application (otherwise it cannot use those
- *       keys at all).
- * 
- * @param kbd_dev Keyboard device structure.
- * @param type Type of the event (press / release). Recognized values: 
- *             KEY_PRESS, KEY_RELEASE
- * @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)
+        usbhid_req_set_report(kbd_dev->hid_dev, value, buffer, 
+            BOOTP_BUFFER_OUT_SIZE);
+}
+
+/*----------------------------------------------------------------------------*/
+
+static void usbhid_kbd_push_ev(usbhid_kbd_t *kbd_dev, int type, 
+    unsigned int key)
 {
         console_event_t ev;
         unsigned mod_mask;
 
-        /*
-         * These parts are copy-pasted from the AT keyboard driver.
-         *
-         * They definitely require some refactoring, but will keep it for later
-         * when the console and keyboard system is changed in HelenOS.
-         */
+        // TODO: replace by our own parsing?? or are the key codes identical??
         switch (key) {
         case KC_LCTRL: mod_mask = KM_LCTRL; break;
@@ -276 +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
@@ -282 +240 @@
                          * up the lock state.
                          */
-                        unsigned int locks_old = kbd_dev->lock_keys;
-                        
                         kbd_dev->mods = 
                             kbd_dev->mods ^ (mod_mask & ~kbd_dev->lock_keys);
@@ -289 +245 @@
 
                         /* Update keyboard lock indicator lights. */
-                        if (kbd_dev->lock_keys != locks_old) {
-                                usbhid_kbd_set_led(kbd_dev);
-                        }
+                        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
@@ -323 +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, 
@@ -338 +296 @@
 
 /*----------------------------------------------------------------------------*/
-/**
- * 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,
     uint8_t modifiers)
@@ -381 +332 @@
 
 /*----------------------------------------------------------------------------*/
-/**
- * Checks if some keys were pressed or released and generates key events.
- *
- * 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()).
- *
- * @param kbd_dev Keyboard device structure.
- * @param key_codes Parsed keyboard report - codes of currently pressed keys 
- *                  according to HID Usage Tables.
- * @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, 
-    const uint8_t *key_codes, size_t count)
-{
+    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 < count &&
-            key_codes[i] == BOOTP_ERROR_ROLLOVER) {
-                ++i;
-        }
-        if (i == count) {
-                usb_log_debug("Phantom state occured.\n");
-                // phantom state, do nothing
-                return;
-        }
-        
-        /* TODO: quite dummy right now, think of better implementation */
-        assert(count == kbd_dev->key_count);
+        // TODO: quite dummy right now, think of better implementation
         
         /*
          * 1) Key releases
          */
-        for (j = 0; j < count; ++j) {
+        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->key_count
-                    && key_codes[i] != kbd_dev->keys[j]) {
+                while (i < kbd_dev->keycode_count
+                    && key_codes[i] != kbd_dev->keycodes[j]) {
                         ++i;
                 }
                 
-                if (i == count) {
+                if (i == kbd_dev->keycode_count) {
                         // not found, i.e. the key was released
-                        key = usbhid_parse_scancode(kbd_dev->keys[j]);
-                        usbhid_kbd_repeat_stop(kbd_dev, key);
+                        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
@@ -445 +367 @@
          * 1) Key presses
          */
-        for (i = 0; i < kbd_dev->key_count; ++i) {
+        for (i = 0; i < kbd_dev->keycode_count; ++i) {
                 // try to find the new key in the old key list
                 j = 0;
-                while (j < count && kbd_dev->keys[j] != key_codes[i]) { 
+                while (j < kbd_dev->keycode_count 
+                    && kbd_dev->keycodes[j] != key_codes[i]) { 
                         ++j;
                 }
                 
-                if (j == count) {
+                if (j == kbd_dev->keycode_count) {
                         // 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);
-                        usbhid_kbd_repeat_start(kbd_dev, key);
                 } else {
                         // found, nothing happens
@@ -464 +386 @@
         }
         
-        memcpy(kbd_dev->keys, key_codes, count);
-
-        usb_log_debug("New stored keycodes: %s\n", 
-            usb_debug_str_buffer(kbd_dev->keys, kbd_dev->key_count, 0));
+        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]);
+        }
 }
 
@@ -473 +397 @@
 /* Callbacks for parser                                                       */
 /*----------------------------------------------------------------------------*/
-/**
- * Callback function for the HID report parser.
- *
- * This function is called by the HID report parser with the parsed report.
- * The parsed report is used to check if any events occured (key was pressed or
- * released, modifier was pressed or released).
- *
- * @param key_codes Parsed keyboard report - codes of currently pressed keys 
- *                  according to HID Usage Tables.
- * @param count Number of key codes in report (size of the report).
- * @param modifiers Bitmap of modifiers (Ctrl, Alt, Shift, GUI).
- * @param arg User-specified argument. Expects pointer to the keyboard device
- *            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,
     uint8_t modifiers, void *arg)
@@ -497 +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, count, 0));
-        
-        if (count != kbd_dev->key_count) {
+        
+        if (count != kbd_dev->keycode_count) {
                 usb_log_warning("Number of received keycodes (%d) differs from"
-                    " expected number (%d).\n", count, kbd_dev->key_count);
+                    " expected number (%d).\n", count, kbd_dev->keycode_count);
                 return;
         }
         
         usbhid_kbd_check_modifier_changes(kbd_dev, modifiers);
-        usbhid_kbd_check_key_changes(kbd_dev, key_codes, count);
+        usbhid_kbd_check_key_changes(kbd_dev, key_codes);
 }
 
@@ -517 +430 @@
 /* General kbd functions                                                      */
 /*----------------------------------------------------------------------------*/
-/**
- * Processes data received from the device in form of report.
- *
- * 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()).
- *
- * @note Currently, only the boot protocol is supported.
- *
- * @param kbd_dev Keyboard device structure (must be initialized).
- * @param buffer Data from the keyboard (i.e. the report).
- * @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,
                                     uint8_t *buffer, size_t actual_size)
 {
-        assert(kbd_dev->initialized);
-        assert(kbd_dev->hid_dev->parser != NULL);
-        
         usb_hid_report_in_callbacks_t *callbacks =
             (usb_hid_report_in_callbacks_t *)malloc(
@@ -544 +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) {
@@ -561 +458 @@
 /* HID/KBD structure manipulation                                             */
 /*----------------------------------------------------------------------------*/
-/**
- * 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.
- *
- * @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)
 {
@@ -595 +484 @@
 
 /*----------------------------------------------------------------------------*/
-/**
- * Properly destroys the USB/HID keyboard structure.
- *
- * @param kbd_dev Pointer to the structure to be destroyed.
- */
+
 static void usbhid_kbd_free(usbhid_kbd_t **kbd_dev)
 {
@@ -614 +499 @@
         }
         
-        if ((*kbd_dev)->repeat_mtx != NULL) {
-                /* TODO: replace by some check and wait */
-                assert(!fibril_mutex_is_locked((*kbd_dev)->repeat_mtx));
-                free((*kbd_dev)->repeat_mtx);
-        }
-
         free(*kbd_dev);
         *kbd_dev = NULL;
@@ -625 +504 @@
 
 /*----------------------------------------------------------------------------*/
-/**
- * Initialization of the USB/HID keyboard structure.
- *
- * This functions initializes required structures from the device's descriptors.
- *
- * 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.
- *
- * @param kbd_dev Keyboard device structure to be initialized.
- * @param dev DDF device structure of the keyboard.
- *
- * @retval EOK if successful.
- * @retval EINVAL if some parameter is not given.
- * @return Other value inherited from function usbhid_dev_init().
- */
+
 static int usbhid_kbd_init(usbhid_kbd_t *kbd_dev, ddf_dev_t *dev)
 {
@@ -679 +539 @@
         
         // save the size of the report (boot protocol report by default)
-        kbd_dev->key_count = BOOTP_REPORT_SIZE;
-        kbd_dev->keys = (uint8_t *)calloc(
-            kbd_dev->key_count, sizeof(uint8_t));
-        
-        if (kbd_dev->keys == NULL) {
+        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");
-                return ENOMEM;
+                return rc;
         }
         
@@ -692 +552 @@
         kbd_dev->lock_keys = 0;
         
-        kbd_dev->repeat.key_new = 0;
-        kbd_dev->repeat.key_repeated = 0;
-        kbd_dev->repeat.delay_before = DEFAULT_DELAY_BEFORE_FIRST_REPEAT;
-        kbd_dev->repeat.delay_between = DEFAULT_REPEAT_DELAY;
-        
-        kbd_dev->repeat_mtx = (fibril_mutex_t *)(
-            malloc(sizeof(fibril_mutex_t)));
-        if (kbd_dev->repeat_mtx == NULL) {
-                usb_log_fatal("No memory!\n");
-                free(kbd_dev->keys);
-                return ENOMEM;
-        }
-        
-        fibril_mutex_initialize(kbd_dev->repeat_mtx);
-        
         /*
          * 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;
@@ -729 +571 @@
 /* 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)
 {
@@ -759 +589 @@
 
         while (true) {
+                async_usleep(1000 * 10);
+
                 sess_rc = usb_endpoint_pipe_start_session(
                     &kbd_dev->hid_dev->poll_pipe);
@@ -764 +596 @@
                         usb_log_warning("Failed to start a session: %s.\n",
                             str_error(sess_rc));
-                        break;
+                        continue;
                 }
 
@@ -776 +608 @@
                         usb_log_warning("Error polling the keyboard: %s.\n",
                             str_error(rc));
-                        break;
+                        continue;
                 }
 
@@ -782 +614 @@
                         usb_log_warning("Error closing session: %s.\n",
                             str_error(sess_rc));
-                        break;
+                        continue;
                 }
 
@@ -799 +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);
-        }
-}
-
-/*----------------------------------------------------------------------------*/
-/**
- * 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.
- */
+        }
+
+        // not reached
+        assert(0);
+}
+
+/*----------------------------------------------------------------------------*/
+
 static int usbhid_kbd_fibril(void *arg)
 {
@@ -844 +660 @@
 /* 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)
 {
@@ -890 +682 @@
                     "structure.\n");
                 ddf_fun_destroy(kbd_fun);
-                return ENOMEM;  // TODO: some other code??
+                return EINVAL;  // TODO: some other code??
         }
         
@@ -939 +731 @@
         }
         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;