Changeset 0c8562c in mainline

Timestamp:

2011-03-11T11:15:44Z (14 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

3005db6

Parents:

c0964800 (diff), b3bdb68 (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:

Development branch changes

Files:

• dist/Makefile (modified) (2 diffs)
• uspace/drv/usbhid/Makefile (modified) (1 diff)
• uspace/drv/usbhid/conv.c (modified) (2 diffs)
• uspace/drv/usbhid/descdump.c (modified) (7 diffs)
• uspace/drv/usbhid/hiddev.c (modified) (7 diffs)
• uspace/drv/usbhid/hiddev.h (modified) (1 diff)
• uspace/drv/usbhid/hidreq.c (modified) (6 diffs)
• uspace/drv/usbhid/kbddev.c (modified) (33 diffs)
• uspace/drv/usbhid/kbddev.h (modified) (3 diffs)
• uspace/drv/usbhid/kbdrepeat.c (added)
• uspace/drv/usbhid/kbdrepeat.h (added)
• uspace/drv/usbhid/main.c (modified) (1 diff)
• uspace/lib/block/libblock.c (modified) (2 diffs)

dist/Makefile

@@ -43 +43 @@
 
 SUFFIX = $(suffix $(IMGFILE))
-DISTFILE = HelenOS-$(RELEASE)-$(PLATFORM)-$(MACHINE)-$(PROCESSOR)$(SUFFIX)
+
+ifdef PROFILE
+        DISTFILE = Helenos-$(shell echo $(PROFILE) | tr '/' '-')$(SUFFIX)
+else
+        DISTFILE = HelenOS-$(RELEASE)-$(PLATFORM)-$(MACHINE)-$(PROCESSOR)$(SUFFIX)
+endif
 
 .PHONY: all clean dist distfile
@@ -53 +58 @@
         cp $< $@
 
+$(IMGFILE):
+        $(MAKE) -C ..
+
 dist:
         for profile in $(PROFILES); do \

uspace/drv/usbhid/Makefile

@@ -42 +42 @@
         hidreq.c \
         kbddev.c \
+        kbdrepeat.c \
         hiddev.c \
         $(STOLEN_LAYOUT_SOURCES)

uspace/drv/usbhid/conv.c

@@ -40 +40 @@
 #include "conv.h"
 
+/**
+ * Mapping between USB HID key codes (from HID Usage Tables) and corresponding
+ * HelenOS key codes.
+ */
 static int scanmap_simple[255] = {
 
@@ -163 +167 @@
 };
 
+/**
+ * Translate USB HID key codes (from HID Usage Tables) to generic key codes
+ * recognized by HelenOS.
+ *
+ * @param scancode USB HID key code (from HID Usage Tables).
+ * 
+ * @retval HelenOS key code corresponding to the given USB HID key code.
+ */
 unsigned int usbhid_parse_scancode(int scancode)
 {

uspace/drv/usbhid/descdump.c

@@ -44 +44 @@
 #define BYTES_PER_LINE 12
 
+/**
+ * Dumps the given buffer in hexadecimal format to standard output.
+ *
+ * @param msg Message to print before the buffer.
+ * @param buffer Buffer to print.
+ * @param length Size of the buffer in bytes.
+ */
 static void dump_buffer(const char *msg, const uint8_t *buffer, size_t length)
 {
@@ -62 +69 @@
 #define INDENT "  "
 
+/**
+ * Print standard configuration descriptor to standard output.
+ *
+ * @param index Index of the descriptor.
+ * @param d Standard configuration descriptor to print.
+ */
 void dump_standard_configuration_descriptor(
     int index, const usb_standard_configuration_descriptor_t *d)
@@ -84 +97 @@
 }
 
+/**
+ * Print standard interface descriptor to standard output.
+ *
+ * @param d Standard interface descriptor to print.
+ */
 void dump_standard_interface_descriptor(
     const usb_standard_interface_descriptor_t *d)
@@ -99 +117 @@
 }
 
+/**
+ * Print standard endpoint descriptor to standard output.
+ *
+ * @param d Standard endpoint descriptor to print.
+ */
 void dump_standard_endpoint_descriptor(
     const usb_standard_endpoint_descriptor_t *d)
@@ -126 +149 @@
 }
 
+/**
+ * Print standard HID descriptor to standard output.
+ *
+ * @param d Standard HID descriptor to print.
+ */
 void dump_standard_hid_descriptor_header(
     const usb_standard_hid_descriptor_t *d)
@@ -139 +167 @@
 }
 
+/**
+ * Print HID class-specific descriptor header (type and length) to standard 
+ * output.
+ * 
+ * @param d HID class-specific descriptor header to print.
+ */
 void dump_standard_hid_class_descriptor_info(
     const usb_standard_hid_class_descriptor_info_t *d)
@@ -146 +180 @@
 }
 
+/**
+ * Print HID class-specific descriptor (without the header) to standard output.
+ *
+ * @param index Index of the descriptor.
+ * @param type Type of the HID class-specific descriptor (Report or Physical).
+ * @param d HID class descriptor to print.
+ * @param size Size of the descriptor in bytes.
+ */
 void dump_hid_class_descriptor(int index, uint8_t type, 
     const uint8_t *d, size_t size )

uspace/drv/usbhid/hiddev.c

@@ -53 +53 @@
 /* Non-API functions                                                          */
 /*----------------------------------------------------------------------------*/
-
+/**
+ * Retreives HID Report descriptor from the device.
+ *
+ * This function first parses the HID descriptor from the Interface descriptor
+ * to get the size of the Report descriptor and then requests the Report 
+ * descriptor from the device.
+ *
+ * @param hid_dev HID device structure.
+ * @param config_desc Full configuration descriptor (including all nested
+ *                    descriptors).
+ * @param config_desc_size Size of the full configuration descriptor (in bytes).
+ * @param iface_desc Pointer to the interface descriptor inside the full
+ *                   configuration descriptor (@a config_desc) for the interface
+ *                   assigned with this device (@a hid_dev).
+ *
+ * @retval EOK if successful.
+ * @retval ENOENT if no HID descriptor could be found.
+ * @retval EINVAL if the HID descriptor  or HID report descriptor have different
+ *                size than expected.
+ * @retval ENOMEM if some allocation failed.
+ * @return Other value inherited from function usb_request_get_descriptor().
+ *
+ * @sa usb_request_get_descriptor()
+ */
 static int usbhid_dev_get_report_descriptor(usbhid_dev_t *hid_dev, 
     uint8_t *config_desc, size_t config_desc_size, uint8_t *iface_desc)
@@ -141 +164 @@
 
 /*----------------------------------------------------------------------------*/
-
+/**
+ * Retreives descriptors from the device, initializes pipes and stores 
+ * important information from descriptors.
+ *
+ * Initializes the polling pipe described by the given endpoint description
+ * (@a poll_ep_desc).
+ * 
+ * Information retreived from descriptors and stored in the HID device structure:
+ *    - Assigned interface number (the interface controlled by this instance of
+ *                                 the driver)
+ *    - Polling interval (from the interface descriptor)
+ *    - Report descriptor
+ *
+ * @param hid_dev HID device structure to be initialized.
+ * @param poll_ep_desc Description of the polling (Interrupt In) endpoint
+ *                     that has to be present in the device in order to
+ *                     successfuly initialize the structure.
+ *
+ * @sa usb_endpoint_pipe_initialize_from_configuration(), 
+ *     usbhid_dev_get_report_descriptor()
+ */
 static int usbhid_dev_process_descriptors(usbhid_dev_t *hid_dev, 
     usb_endpoint_description_t *poll_ep_desc) 
@@ -230 +273 @@
 /* API functions                                                              */
 /*----------------------------------------------------------------------------*/
-
+/**
+ * Creates new uninitialized HID device structure.
+ *
+ * @return Pointer to the new HID device structure, or NULL if an error occured.
+ */
 usbhid_dev_t *usbhid_dev_new(void)
 {
@@ -249 +296 @@
 
 /*----------------------------------------------------------------------------*/
-
+/**
+ * Properly destroys the HID device structure.
+ *
+ * @note Currently does not clean-up the used pipes, as there are no functions
+ *       offering such functionality.
+ * 
+ * @param hid_dev Pointer to the structure to be destroyed.
+ */
 void usbhid_dev_free(usbhid_dev_t **hid_dev)
 {
@@ -272 +326 @@
 
 /*----------------------------------------------------------------------------*/
-
+/**
+ * Initializes HID device structure.
+ *
+ * @param hid_dev HID device structure to be initialized.
+ * @param dev DDF device representing the HID device.
+ * @param poll_ep_desc Description of the polling (Interrupt In) endpoint
+ *                     that has to be present in the device in order to
+ *                     successfuly initialize the structure.
+ *
+ * @retval EOK if successful.
+ * @retval EINVAL if some argument is missing.
+ * @return Other value inherited from one of functions 
+ *         usb_device_connection_initialize_from_device(),
+ *         usb_endpoint_pipe_initialize_default_control(),
+ *         usb_endpoint_pipe_start_session(), usb_endpoint_pipe_end_session(),
+ *         usbhid_dev_process_descriptors().
+ *
+ * @sa usbhid_dev_process_descriptors()
+ */
 int usbhid_dev_init(usbhid_dev_t *hid_dev, ddf_dev_t *dev, 
     usb_endpoint_description_t *poll_ep_desc)
@@ -323 +395 @@
          * Get descriptors, parse descriptors and save endpoints.
          */
-        usb_endpoint_pipe_start_session(&hid_dev->ctrl_pipe);
+        rc = usb_endpoint_pipe_start_session(&hid_dev->ctrl_pipe);
+        if (rc != EOK) {
+                usb_log_error("Failed to start session on the control pipe: %s"
+                    ".\n", str_error(rc));
+                return rc;
+        }
         
         rc = usbhid_dev_process_descriptors(hid_dev, poll_ep_desc);
-        
-        usb_endpoint_pipe_end_session(&hid_dev->ctrl_pipe);
-        if (rc != EOK) {
+        if (rc != EOK) {
+                /* TODO: end session?? */
                 usb_log_error("Failed to process descriptors: %s.\n",
                     str_error(rc));
@@ -334 +410 @@
         }
         
+        rc = usb_endpoint_pipe_end_session(&hid_dev->ctrl_pipe);
+        if (rc != EOK) {
+                usb_log_warning("Failed to start session on the control pipe: "
+                    "%s.\n", str_error(rc));
+                return rc;
+        }
+        
         hid_dev->initialized = 1;
         usb_log_info("HID device structure initialized.\n");

uspace/drv/usbhid/hiddev.h

@@ -48 +48 @@
 
 /**
- * @brief USB/HID device type.
+ * USB/HID device type.
+ *
+ * Holds a reference to DDF device structure, and HID-specific data, such 
+ * as information about used pipes (one Control pipe and one Interrupt In pipe),
+ * polling interval, assigned interface number, Report descriptor and a
+ * reference to the Report parser used to parse incoming reports and composing
+ * outgoing reports.
  */
 typedef struct {
+        /** DDF device representing the controlled HID device. */
         ddf_dev_t *device;
 
+        /** Physical connection to the device. */
         usb_device_connection_t wire;
+        /** USB pipe corresponding to the default Control endpoint. */
         usb_endpoint_pipe_t ctrl_pipe;
+        /** USB pipe corresponding to the Interrupt In (polling) pipe. */
         usb_endpoint_pipe_t poll_pipe;
         
+        /** Polling interval retreived from the Interface descriptor. */
         short poll_interval;
         
+        /** Interface number assigned to this device. */
         uint16_t iface;
         
+        /** Report descriptor. */
         uint8_t *report_desc;
+        /** HID Report parser. */
         usb_hid_report_parser_t *parser;
         
+        /** State of the structure (for checking before use). */
         int initialized;
 } usbhid_dev_t;

uspace/drv/usbhid/hidreq.c

@@ -46 +46 @@
 
 /*----------------------------------------------------------------------------*/
-
+/**
+ * Send Set Report request to the HID device.
+ *
+ * @param hid_dev HID device to send the request to.
+ * @param type Type of the report.
+ * @param buffer Report data.
+ * @param buf_size Report data size (in bytes).
+ *
+ * @retval EOK if successful.
+ * @retval EINVAL if no HID device is given.
+ * @return Other value inherited from one of functions 
+ *         usb_endpoint_pipe_start_session(), usb_endpoint_pipe_end_session(),
+ *         usb_control_request_set().
+ */
 int usbhid_req_set_report(usbhid_dev_t *hid_dev,
     usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size)
@@ -97 +110 @@
 
 /*----------------------------------------------------------------------------*/
-
+/**
+ * Send Set Protocol request to the HID device.
+ *
+ * @param hid_dev HID device to send the request to.
+ * @param protocol Protocol to set.
+ *
+ * @retval EOK if successful.
+ * @retval EINVAL if no HID device is given.
+ * @return Other value inherited from one of functions 
+ *         usb_endpoint_pipe_start_session(), usb_endpoint_pipe_end_session(),
+ *         usb_control_request_set().
+ */
 int usbhid_req_set_protocol(usbhid_dev_t *hid_dev, usb_hid_protocol_t protocol)
 {
@@ -145 +169 @@
 
 /*----------------------------------------------------------------------------*/
-
+/**
+ * Send Set Idle request to the HID device.
+ *
+ * @param hid_dev HID device to send the request to.
+ * @param duration Duration value (is multiplicated by 4 by the device to
+ *                 get real duration in miliseconds).
+ *
+ * @retval EOK if successful.
+ * @retval EINVAL if no HID device is given.
+ * @return Other value inherited from one of functions 
+ *         usb_endpoint_pipe_start_session(), usb_endpoint_pipe_end_session(),
+ *         usb_control_request_set().
+ */
 int usbhid_req_set_idle(usbhid_dev_t *hid_dev, uint8_t duration)
 {
@@ -195 +231 @@
 
 /*----------------------------------------------------------------------------*/
-
+/**
+ * Send Get Report request to the HID device.
+ *
+ * @param[in] hid_dev HID device to send the request to.
+ * @param[in] type Type of the report.
+ * @param[in][out] buffer Buffer for the report data.
+ * @param[in] buf_size Size of the buffer (in bytes).
+ * @param[out] actual_size Actual size of report received from the device 
+ *                         (in bytes).
+ *
+ * @retval EOK if successful.
+ * @retval EINVAL if no HID device is given.
+ * @return Other value inherited from one of functions 
+ *         usb_endpoint_pipe_start_session(), usb_endpoint_pipe_end_session(),
+ *         usb_control_request_set().
+ */
 int usbhid_req_get_report(usbhid_dev_t *hid_dev, usb_hid_report_type_t type, 
     uint8_t *buffer, size_t buf_size, size_t *actual_size)
@@ -246 +297 @@
 }
 
+/*----------------------------------------------------------------------------*/
+/**
+ * Send Get Protocol request to the HID device.
+ *
+ * @param[in] hid_dev HID device to send the request to.
+ * @param[out] protocol Current protocol of the device.
+ *
+ * @retval EOK if successful.
+ * @retval EINVAL if no HID device is given.
+ * @return Other value inherited from one of functions 
+ *         usb_endpoint_pipe_start_session(), usb_endpoint_pipe_end_session(),
+ *         usb_control_request_set().
+ */
 int usbhid_req_get_protocol(usbhid_dev_t *hid_dev, usb_hid_protocol_t *protocol)
 {
@@ -303 +367 @@
 }
 
+/*----------------------------------------------------------------------------*/
+/**
+ * Send Get Idle request to the HID device.
+ *
+ * @param[in] hid_dev HID device to send the request to.
+ * @param[out] duration Duration value (multiplicate by 4 to get real duration
+ *                      in miliseconds).
+ *
+ * @retval EOK if successful.
+ * @retval EINVAL if no HID device is given.
+ * @return Other value inherited from one of functions 
+ *         usb_endpoint_pipe_start_session(), usb_endpoint_pipe_end_session(),
+ *         usb_control_request_set().
+ */
 int usbhid_req_get_idle(usbhid_dev_t *hid_dev, uint8_t *duration)
 {

uspace/drv/usbhid/kbddev.c

@@ -37 +37 @@
 #include <errno.h>
 #include <str_error.h>
-#include <fibril.h>
 #include <stdio.h>
 
@@ -43 +42 @@
 #include <ipc/kbd.h>
 #include <async.h>
+#include <fibril.h>
+#include <fibril_synch.h>
 
 #include <usb/usb.h>
@@ -56 +57 @@
 #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. */
@@ -82 +100 @@
 #define NUM_LAYOUTS 3
 
+/** Keyboard layout map. */
 static layout_op_t *layout[NUM_LAYOUTS] = {
         &us_qwerty_op,
@@ -93 +112 @@
 /* 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 */
@@ -114 +133 @@
 };
 
-/** Default handler for IPC methods not handled by DDF.
- *
- * @param dev Device handling the call.
+/** 
+ * 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 icallid Call id.
  * @param icall Call data.
@@ -147 +171 @@
 /* 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) 
 {
@@ -189 +224 @@
 
 /*----------------------------------------------------------------------------*/
-
-static void usbhid_kbd_push_ev(usbhid_kbd_t *kbd_dev, int type, 
-    unsigned int key)
+/**
+ * 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)
 {
         console_event_t ev;
         unsigned mod_mask;
 
-        // TODO: replace by our own parsing?? or are the key codes identical??
+        /*
+         * 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.
+         */
         switch (key) {
         case KC_LCTRL: mod_mask = KM_LCTRL; break;
@@ -228 +282 @@
                          * up the lock state.
                          */
+                        unsigned int locks_old = kbd_dev->lock_keys;
+                        
                         kbd_dev->mods = 
                             kbd_dev->mods ^ (mod_mask & ~kbd_dev->lock_keys);
@@ -233 +289 @@
 
                         /* Update keyboard lock indicator lights. */
-                        usbhid_kbd_set_led(kbd_dev);
+                        if (kbd_dev->lock_keys != locks_old) {
+                                usbhid_kbd_set_led(kbd_dev);
+                        }
                 } else {
                         kbd_dev->lock_keys = kbd_dev->lock_keys & ~mod_mask;
@@ -280 +338 @@
 
 /*----------------------------------------------------------------------------*/
-
+/**
+ * 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)
@@ -316 +381 @@
 
 /*----------------------------------------------------------------------------*/
-
+/**
+ * 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)
+    const uint8_t *key_codes, size_t count)
 {
         unsigned int key;
@@ -328 +407 @@
         i = 0;
         // all fields should report Error Rollover
-        while (i < kbd_dev->keycode_count &&
+        while (i < count &&
             key_codes[i] == BOOTP_ERROR_ROLLOVER) {
                 ++i;
         }
-        if (i == kbd_dev->keycode_count) {
+        if (i == count) {
                 usb_log_debug("Phantom state occured.\n");
                 // phantom state, do nothing
@@ -338 +417 @@
         }
         
-        // TODO: quite dummy right now, think of better implementation
+        /* TODO: quite dummy right now, think of better implementation */
+        assert(count == kbd_dev->key_count);
         
         /*
          * 1) Key releases
          */
-        for (j = 0; j < kbd_dev->keycode_count; ++j) {
+        for (j = 0; j < 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]) {
+                while (i < kbd_dev->key_count
+                    && key_codes[i] != kbd_dev->keys[j]) {
                         ++i;
                 }
                 
-                if (i == kbd_dev->keycode_count) {
+                if (i == count) {
                         // not found, i.e. the key was released
-                        key = usbhid_parse_scancode(kbd_dev->keycodes[j]);
+                        key = usbhid_parse_scancode(kbd_dev->keys[j]);
+                        usbhid_kbd_repeat_stop(kbd_dev, key);
                         usbhid_kbd_push_ev(kbd_dev, KEY_RELEASE, key);
                         usb_log_debug2("Key released: %d\n", key);
@@ -364 +445 @@
          * 1) Key presses
          */
-        for (i = 0; i < kbd_dev->keycode_count; ++i) {
+        for (i = 0; i < kbd_dev->key_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]) { 
+                while (j < count && kbd_dev->keys[j] != key_codes[i]) { 
                         ++j;
                 }
                 
-                if (j == kbd_dev->keycode_count) {
+                if (j == count) {
                         // not found, i.e. new key pressed
                         key = usbhid_parse_scancode(key_codes[i]);
@@ -378 +458 @@
                             key_codes[i]);
                         usbhid_kbd_push_ev(kbd_dev, KEY_PRESS, key);
+                        usbhid_kbd_repeat_start(kbd_dev, key);
                 } else {
                         // found, nothing happens
                 }
         }
-//      // 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);
+        
+        memcpy(kbd_dev->keys, key_codes, count);
 
         usb_log_debug("New stored keycodes: %s\n", 
-            usb_debug_str_buffer(kbd_dev->keycodes, kbd_dev->keycode_count, 0));
+            usb_debug_str_buffer(kbd_dev->keys, kbd_dev->key_count, 0));
 }
 
@@ -401 +473 @@
 /* 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)
@@ -415 +502 @@
 
         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) {
+            usb_debug_str_buffer(key_codes, kbd_dev->key_count, 0));
+        
+        if (count != kbd_dev->key_count) {
                 usb_log_warning("Number of received keycodes (%d) differs from"
-                    " expected number (%d).\n", count, kbd_dev->keycode_count);
+                    " expected number (%d).\n", count, kbd_dev->key_count);
                 return;
         }
         
         usbhid_kbd_check_modifier_changes(kbd_dev, modifiers);
-        usbhid_kbd_check_key_changes(kbd_dev, key_codes);
+        usbhid_kbd_check_key_changes(kbd_dev, key_codes, count);
 }
 
@@ -430 +517 @@
 /* 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)
@@ -455 +556 @@
 /* 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)
 {
@@ -481 +590 @@
 
 /*----------------------------------------------------------------------------*/
-
+/**
+ * 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)
 {
@@ -496 +609 @@
         }
         
+        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;
@@ -501 +620 @@
 
 /*----------------------------------------------------------------------------*/
-
+/**
+ * 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)
 {
@@ -536 +674 @@
         
         // save the size of the report (boot protocol report by default)
-        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) {
+        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) {
                 usb_log_fatal("No memory!\n");
-                return rc;
+                return ENOMEM;
         }
         
@@ -549 +687 @@
         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.
@@ -571 +724 @@
 /* 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)
 {
@@ -594 +759 @@
                         usb_log_warning("Failed to start a session: %s.\n",
                             str_error(sess_rc));
-                        continue;
+                        break;
                 }
 
@@ -606 +771 @@
                         usb_log_warning("Error polling the keyboard: %s.\n",
                             str_error(rc));
-                        continue;
+                        break;
                 }
 
@@ -612 +777 @@
                         usb_log_warning("Error closing session: %s.\n",
                             str_error(sess_rc));
-                        continue;
+                        break;
                 }
 
@@ -633 +798 @@
                 //async_usleep(kbd_dev->hid_dev->poll_interval);
         }
-
-        // not reached
-        assert(0);
-}
-
-/*----------------------------------------------------------------------------*/
-
+}
+
+/*----------------------------------------------------------------------------*/
+/**
+ * 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)
 {
@@ -661 +839 @@
 /* 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)
 {
@@ -683 +885 @@
                     "structure.\n");
                 ddf_fun_destroy(kbd_fun);
-                return EINVAL;  // TODO: some other code??
+                return ENOMEM;  // TODO: some other code??
         }
         
@@ -732 +934 @@
         }
         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;

uspace/drv/usbhid/kbddev.h

@@ -39 +39 @@
 #include <stdint.h>
 
+#include <fibril_synch.h>
+
 #include <usb/classes/hid.h>
 #include <ddf/driver.h>
@@ -46 +48 @@
 
 /*----------------------------------------------------------------------------*/
+/**
+ * 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;
 
 /**
- * @brief USB/HID keyboard device type.
+ * 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 {
+        /** Structure holding generic USB/HID device information. */
         usbhid_dev_t *hid_dev;
         
-        uint8_t *keycodes;
-        size_t keycode_count;
+        /** 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;
         
+        /** Currently active modifiers including locks. Sent to the console. */
         unsigned mods;
+        
+        /** Currently active lock keys. */
         unsigned lock_keys;
         
+        /** IPC phone to the console device (for sending key events). */
         int console_phone;
         
+        /** Information for auto-repeat of keys. */
+        usbhid_kbd_repeat_t repeat;
+        
+        /** Mutex for accessing the information about auto-repeat. */
+        fibril_mutex_t *repeat_mtx;
+        
+        /** State of the structure (for checking before use). */
         int initialized;
 } usbhid_kbd_t;
@@ -69 +108 @@
 int usbhid_kbd_try_add_device(ddf_dev_t *dev);
 
+void usbhid_kbd_push_ev(usbhid_kbd_t *kbd_dev, int type, unsigned int key);
+
 #endif /* USBHID_KBDDEV_H_ */
 

uspace/drv/usbhid/main.c

@@ -47 +47 @@
 
 /*----------------------------------------------------------------------------*/
-
+/**
+ * Callback for passing a new device to the driver.
+ *
+ * @note Currently, only boot-protocol keyboards are supported by this driver.
+ *
+ * @param dev Structure representing the new device.
+ *
+ * @retval EOK if successful. 
+ * @retval EREFUSED if the device is not supported.
+ */
 static int usbhid_add_device(ddf_dev_t *dev)
 {

uspace/lib/block/libblock.c

@@ -411 +411 @@
         l = hash_table_find(&cache->block_hash, &key);
         if (l) {
+found:
                 /*
                  * We found the block in the cache.
@@ -493 +494 @@
                                         fibril_mutex_unlock(&b->lock);
                                         goto retry;
+                                }
+                                l = hash_table_find(&cache->block_hash, &key);
+                                if (l) {
+                                        /*
+                                         * Someone else must have already
+                                         * instantiated the block while we were
+                                         * not holding the cache lock.
+                                         * Leave the recycled block on the
+                                         * freelist and continue as if we
+                                         * found the block of interest during
+                                         * the first try.
+                                         */
+                                        fibril_mutex_unlock(&b->lock);
+                                        goto found;
                                 }