Changeset 9c0f158 in mainline for uspace/drv/usbkbd/kbddev.c


Ignore:
Timestamp:
2011-03-25T15:21:01Z (13 years ago)
Author:
Matej Klonfar <maklf@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
57d9c05e
Parents:
96bfe76 (diff), f08c560 (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 merge

File:
1 moved

Legend:

Unmodified
Added
Removed

  • uspace/drv/usbkbd/kbddev.c

    r96bfe76 r9c0f158  
    4646
    4747#include <usb/usb.h>
     48#include <usb/dp.h>
     49#include <usb/request.h>
    4850#include <usb/classes/hid.h>
    4951#include <usb/pipes.h>
    … …  
    5254#include <usb/classes/classes.h>
    5355#include <usb/classes/hidut.h>
     56#include <usb/classes/hidreq.h>
     57#include <usb/classes/hidreport.h>
     58
     59#include <usb/devdrv.h>
    5460
    5561#include "kbddev.h"
    56 #include "hiddev.h"
    57 #include "hidreq.h"
     62
    5863#include "layout.h"
    5964#include "conv.h"
    … …  
    8590static const unsigned int DEFAULT_REPEAT_DELAY = 50 * 1000;
    8691
     92/*----------------------------------------------------------------------------*/
     93
    8794/** Keyboard polling endpoint description for boot protocol class. */
    88 static usb_endpoint_description_t poll_endpoint_description = {
     95static usb_endpoint_description_t boot_poll_endpoint_description = {
    8996        .transfer_type = USB_TRANSFER_INTERRUPT,
    9097        .direction = USB_DIRECTION_IN,
    … …  
    95102};
    96103
    97 typedef enum usbhid_kbd_flags {
    98         USBHID_KBD_STATUS_UNINITIALIZED = 0,
    99         USBHID_KBD_STATUS_INITIALIZED = 1,
    100         USBHID_KBD_STATUS_TO_DESTROY = -1
    101 } usbhid_kbd_flags;
     104/* Array of endpoints expected on the device, NULL terminated. */
     105usb_endpoint_description_t
     106    *usb_kbd_endpoints[USB_KBD_POLL_EP_COUNT + 1] = {
     107        &boot_poll_endpoint_description,
     108        NULL
     109};
     110
     111/*----------------------------------------------------------------------------*/
     112
     113enum {
     114        BOOT_REPORT_DESCRIPTOR_SIZE = 63
     115};
     116
     117static const uint8_t BOOT_REPORT_DESCRIPTOR[BOOT_REPORT_DESCRIPTOR_SIZE] = {
     118        0x05, 0x01,  // Usage Page (Generic Desktop),
     119        0x09, 0x06,  // Usage (Keyboard),
     120        0xA1, 0x01,  // Collection (Application),
     121        0x75, 0x01,  //   Report Size (1),
     122        0x95, 0x08,  //   Report Count (8),       
     123        0x05, 0x07,  //   Usage Page (Key Codes);
     124        0x19, 0xE0,  //   Usage Minimum (224),
     125        0x29, 0xE7,  //   Usage Maximum (231),
     126        0x15, 0x00,  //   Logical Minimum (0),
     127        0x25, 0x01,  //   Logical Maximum (1),
     128        0x81, 0x02,  //   Input (Data, Variable, Absolute),   ; Modifier byte
     129        0x95, 0x01,  //   Report Count (1),
     130        0x75, 0x08,  //   Report Size (8),
     131        0x81, 0x01,  //   Input (Constant),                   ; Reserved byte
     132        0x95, 0x05,  //   Report Count (5),
     133        0x75, 0x01,  //   Report Size (1),
     134        0x05, 0x08,  //   Usage Page (Page# for LEDs),
     135        0x19, 0x01,  //   Usage Minimum (1),
     136        0x29, 0x05,  //   Usage Maxmimum (5),
     137        0x91, 0x02,  //   Output (Data, Variable, Absolute),  ; LED report
     138        0x95, 0x01,  //   Report Count (1),
     139        0x75, 0x03,  //   Report Size (3),
     140        0x91, 0x01,  //   Output (Constant),              ; LED report padding
     141        0x95, 0x06,  //   Report Count (6),
     142        0x75, 0x08,  //   Report Size (8),
     143        0x15, 0x00,  //   Logical Minimum (0),
     144        0x25, 0xff,  //   Logical Maximum (255),
     145        0x05, 0x07,  //   Usage Page (Key Codes),
     146        0x19, 0x00,  //   Usage Minimum (0),
     147        0x29, 0xff,  //   Usage Maximum (255),
     148        0x81, 0x00,  //   Input (Data, Array),            ; Key arrays (6 bytes)
     149        0xC0           // End Collection
     150
     151};
     152
     153/*----------------------------------------------------------------------------*/
     154
     155typedef enum usb_kbd_flags {
     156        USB_KBD_STATUS_UNINITIALIZED = 0,
     157        USB_KBD_STATUS_INITIALIZED = 1,
     158        USB_KBD_STATUS_TO_DESTROY = -1
     159} usb_kbd_flags;
    102160
    103161/*----------------------------------------------------------------------------*/
    … …  
    132190
    133191typedef enum usbhid_lock_code {
    134         USBHID_LOCK_NUM = 0x53,
    135         USBHID_LOCK_CAPS = 0x39,
    136         USBHID_LOCK_SCROLL = 0x47,
    137         USBHID_LOCK_COUNT = 3
     192        USB_KBD_LOCK_NUM = 0x53,
     193        USB_KBD_LOCK_CAPS = 0x39,
     194        USB_KBD_LOCK_SCROLL = 0x47,
     195        USB_KBD_LOCK_COUNT = 3
    138196} usbhid_lock_code;
    139197
    140 static const usbhid_lock_code usbhid_lock_codes[USBHID_LOCK_COUNT] = {
    141         USBHID_LOCK_NUM,
    142         USBHID_LOCK_CAPS,
    143         USBHID_LOCK_SCROLL
     198static const usbhid_lock_code usbhid_lock_codes[USB_KBD_LOCK_COUNT] = {
     199        USB_KBD_LOCK_NUM,
     200        USB_KBD_LOCK_CAPS,
     201        USB_KBD_LOCK_SCROLL
    144202};
    145203
    … …  
    149207
    150208static void default_connection_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *);
    151 static ddf_dev_ops_t keyboard_ops = {
     209ddf_dev_ops_t keyboard_ops = {
    152210        .default_handler = default_connection_handler
    153211};
    … …  
    169227        sysarg_t method = IPC_GET_IMETHOD(*icall);
    170228       
    171         usbhid_kbd_t *kbd_dev = (usbhid_kbd_t *)fun->driver_data;
     229        usb_kbd_t *kbd_dev = (usb_kbd_t *)fun->driver_data;
    172230        assert(kbd_dev != NULL);
    173231
    … …  
    203261 * @param kbd_dev Keyboard device structure.
    204262 */
    205 static void usbhid_kbd_set_led(usbhid_kbd_t *kbd_dev)
     263static void usb_kbd_set_led(usb_kbd_t *kbd_dev)
    206264{
    207265        uint8_t buffer[BOOTP_BUFFER_OUT_SIZE];
    … …  
    237295            usb_debug_str_buffer(buffer, BOOTP_BUFFER_OUT_SIZE, 0));
    238296       
    239         assert(kbd_dev->hid_dev != NULL);
    240         assert(kbd_dev->hid_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
    241         usbhid_req_set_report(kbd_dev->hid_dev, USB_HID_REPORT_TYPE_OUTPUT,
     297        assert(kbd_dev->usb_dev != NULL);
     298       
     299        usbhid_req_set_report(&kbd_dev->usb_dev->ctrl_pipe,
     300            kbd_dev->usb_dev->interface_no, USB_HID_REPORT_TYPE_OUTPUT,
    242301            buffer, BOOTP_BUFFER_OUT_SIZE);
    243302}
    … …  
    260319 * @param key Key code of the key according to HID Usage Tables.
    261320 */
    262 void usbhid_kbd_push_ev(usbhid_kbd_t *kbd_dev, int type, unsigned int key)
     321void usb_kbd_push_ev(usb_kbd_t *kbd_dev, int type, unsigned int key)
    263322{
    264323        console_event_t ev;
    … …  
    310369                        /* Update keyboard lock indicator lights. */
    311370                        if (kbd_dev->lock_keys != locks_old) {
    312                                 usbhid_kbd_set_led(kbd_dev);
     371                                usb_kbd_set_led(kbd_dev);
    313372                        }
    314373                } else {
    … …  
    358417
    359418/*----------------------------------------------------------------------------*/
    360 /**
    361  * Checks if modifiers were pressed or released and generates key events.
    362  *
    363  * @param kbd_dev Keyboard device structure.
    364  * @param modifiers Bitmap of modifiers.
    365  *
    366  * @sa usbhid_kbd_push_ev()
    367  */
    368 //static void usbhid_kbd_check_modifier_changes(usbhid_kbd_t *kbd_dev,
    369 //    const uint8_t *key_codes, size_t count)
    370 //{
    371 //      /*
    372 //       * TODO: why the USB keyboard has NUM_, SCROLL_ and CAPS_LOCK
    373 //       *       both as modifiers and as keyUSB_HID_LOCK_COUNTs with their own scancodes???
    374 //       *
    375 //       * modifiers should be sent as normal keys to usbhid_parse_scancode()!!
    376 //       * so maybe it would be better if I received it from report parser in
    377 //       * that way
    378 //       */
    379        
    380 //      int i;
    381 //      for (i = 0; i < count; ++i) {
    382 //              if ((modifiers & usb_hid_modifiers_consts[i]) &&
    383 //                  !(kbd_dev->modifiers & usb_hid_modifiers_consts[i])) {
    384 //                      // modifier pressed
    385 //                      if (usbhid_modifiers_keycodes[i] != 0) {
    386 //                              usbhid_kbd_push_ev(kbd_dev, KEY_PRESS,
    387 //                                  usbhid_modifiers_keycodes[i]);
    388 //                      }
    389 //              } else if (!(modifiers & usb_hid_modifiers_consts[i]) &&
    390 //                  (kbd_dev->modifiers & usb_hid_modifiers_consts[i])) {
    391 //                      // modifier released
    392 //                      if (usbhid_modifiers_keycodes[i] != 0) {
    393 //                              usbhid_kbd_push_ev(kbd_dev, KEY_RELEASE,
    394 //                                  usbhid_modifiers_keycodes[i]);
    395 //                      }
    396 //              }       // no change
    397 //      }
    398        
    399 //      kbd_dev->modifiers = modifiers;
    400 //}
    401 
    402 /*----------------------------------------------------------------------------*/
    403 
    404 static inline int usbhid_kbd_is_lock(unsigned int key_code)
     419
     420static inline int usb_kbd_is_lock(unsigned int key_code)
    405421{
    406422        return (key_code == KC_NUM_LOCK
    … …  
    414430 *
    415431 * An event is created only when key is pressed or released. Besides handling
    416  * the events (usbhid_kbd_push_ev()), the auto-repeat fibril is notified about
    417  * key presses and releases (see usbhid_kbd_repeat_start() and
    418  * usbhid_kbd_repeat_stop()).
     432 * the events (usb_kbd_push_ev()), the auto-repeat fibril is notified about
     433 * key presses and releases (see usb_kbd_repeat_start() and
     434 * usb_kbd_repeat_stop()).
    419435 *
    420436 * @param kbd_dev Keyboard device structure.
    … …  
    423439 * @param count Number of key codes in report (size of the report).
    424440 *
    425  * @sa usbhid_kbd_push_ev(), usbhid_kbd_repeat_start(), usbhid_kbd_repeat_stop()
    426  */
    427 static void usbhid_kbd_check_key_changes(usbhid_kbd_t *kbd_dev,
     441 * @sa usb_kbd_push_ev(), usb_kbd_repeat_start(), usb_kbd_repeat_stop()
     442 */
     443static void usb_kbd_check_key_changes(usb_kbd_t *kbd_dev,
    428444    const uint8_t *key_codes, size_t count)
    429445{
    … …  
    434450         * First of all, check if the kbd have reported phantom state.
    435451         *
    436          * TODO: this must be changed as we don't know which keys are modifiers
     452         * this must be changed as we don't know which keys are modifiers
    437453         *       and which are regular keys.
    438454         */
    … …  
    466482                        // not found, i.e. the key was released
    467483                        key = usbhid_parse_scancode(kbd_dev->keys[j]);
    468                         if (!usbhid_kbd_is_lock(key)) {
    469                                 usbhid_kbd_repeat_stop(kbd_dev, key);
     484                        if (!usb_kbd_is_lock(key)) {
     485                                usb_kbd_repeat_stop(kbd_dev, key);
    470486                        }
    471                         usbhid_kbd_push_ev(kbd_dev, KEY_RELEASE, key);
     487                        usb_kbd_push_ev(kbd_dev, KEY_RELEASE, key);
    472488                        usb_log_debug2("Key released: %d\n", key);
    473489                } else {
    … …  
    491507                        usb_log_debug2("Key pressed: %d (keycode: %d)\n", key,
    492508                            key_codes[i]);
    493                         usbhid_kbd_push_ev(kbd_dev, KEY_PRESS, key);
    494                         if (!usbhid_kbd_is_lock(key)) {
    495                                 usbhid_kbd_repeat_start(kbd_dev, key);
     509                        usb_kbd_push_ev(kbd_dev, KEY_PRESS, key);
     510                        if (!usb_kbd_is_lock(key)) {
     511                                usb_kbd_repeat_start(kbd_dev, key);
    496512                        }
    497513                } else {
    … …  
    523539 *            structure representing the keyboard.
    524540 *
    525  * @sa usbhid_kbd_check_key_changes(), usbhid_kbd_check_modifier_changes()
    526  */
    527 static void usbhid_kbd_process_keycodes(const uint8_t *key_codes, size_t count,
     541 * @sa usb_kbd_check_key_changes(), usb_kbd_check_modifier_changes()
     542 */
     543static void usb_kbd_process_keycodes(const uint8_t *key_codes, size_t count,
    528544    uint8_t modifiers, void *arg)
    529545{
    … …  
    534550        }
    535551       
    536         usbhid_kbd_t *kbd_dev = (usbhid_kbd_t *)arg;
     552        usb_kbd_t *kbd_dev = (usb_kbd_t *)arg;
    537553        assert(kbd_dev != NULL);
    538554
    … …  
    546562        }
    547563       
    548         ///usbhid_kbd_check_modifier_changes(kbd_dev, key_codes, count);
    549         usbhid_kbd_check_key_changes(kbd_dev, key_codes, count);
     564        ///usb_kbd_check_modifier_changes(kbd_dev, key_codes, count);
     565        usb_kbd_check_key_changes(kbd_dev, key_codes, count);
    550566}
    551567
    … …  
    558574 * This function uses the HID report parser to translate the data received from
    559575 * the device into generic USB HID key codes and into generic modifiers bitmap.
    560  * The parser then calls the given callback (usbhid_kbd_process_keycodes()).
     576 * The parser then calls the given callback (usb_kbd_process_keycodes()).
    561577 *
    562578 * @note Currently, only the boot protocol is supported.
    … …  
    566582 * @param actual_size Size of the data from keyboard (report size) in bytes.
    567583 *
    568  * @sa usbhid_kbd_process_keycodes(), usb_hid_boot_keyboard_input_report().
    569  */
    570 static void usbhid_kbd_process_data(usbhid_kbd_t *kbd_dev,
     584 * @sa usb_kbd_process_keycodes(), usb_hid_boot_keyboard_input_report(),
     585 *     usb_hid_parse_report().
     586 */
     587static void usb_kbd_process_data(usb_kbd_t *kbd_dev,
    571588                                    uint8_t *buffer, size_t actual_size)
    572589{
    573         assert(kbd_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
    574         assert(kbd_dev->hid_dev->parser != NULL);
     590        assert(kbd_dev->initialized == USB_KBD_STATUS_INITIALIZED);
     591        assert(kbd_dev->parser != NULL);
    575592       
    576593        usb_hid_report_in_callbacks_t *callbacks =
    … …  
    578595                sizeof(usb_hid_report_in_callbacks_t));
    579596       
    580         callbacks->keyboard = usbhid_kbd_process_keycodes;
     597        callbacks->keyboard = usb_kbd_process_keycodes;
    581598
    582599        usb_log_debug("Calling usb_hid_parse_report() with "
    … …  
    588605        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
    589606       
    590         int rc = usb_hid_parse_report(kbd_dev->hid_dev->parser, buffer,
     607        int rc = usb_hid_parse_report(kbd_dev->parser, buffer,
    591608            actual_size, path, USB_HID_PATH_COMPARE_STRICT, callbacks, kbd_dev);
    592609
    … …  
    602619/* HID/KBD structure manipulation                                             */
    603620/*----------------------------------------------------------------------------*/
     621
     622static void usb_kbd_mark_unusable(usb_kbd_t *kbd_dev)
     623{
     624        kbd_dev->initialized = USB_KBD_STATUS_TO_DESTROY;
     625}
     626
     627
     628/*----------------------------------------------------------------------------*/
     629/* API functions                                                              */
     630/*----------------------------------------------------------------------------*/
    604631/**
    605632 * Creates a new USB/HID keyboard structure.
    606633 *
    607634 * The structure returned by this function is not initialized. Use
    608  * usbhid_kbd_init() to initialize it prior to polling.
     635 * usb_kbd_init() to initialize it prior to polling.
    609636 *
    610637 * @return New uninitialized structure for representing a USB/HID keyboard or
    611638 *         NULL if not successful (memory error).
    612639 */
    613 static usbhid_kbd_t *usbhid_kbd_new(void)
    614 {
    615         usbhid_kbd_t *kbd_dev =
    616             (usbhid_kbd_t *)malloc(sizeof(usbhid_kbd_t));
     640usb_kbd_t *usb_kbd_new(void)
     641{
     642        usb_kbd_t *kbd_dev =
     643            (usb_kbd_t *)malloc(sizeof(usb_kbd_t));
    617644
    618645        if (kbd_dev == NULL) {
    … …  
    621648        }
    622649       
    623         memset(kbd_dev, 0, sizeof(usbhid_kbd_t));
    624        
    625         kbd_dev->hid_dev = usbhid_dev_new();
    626         if (kbd_dev->hid_dev == NULL) {
    627                 usb_log_fatal("Could not create HID device structure.\n");
     650        memset(kbd_dev, 0, sizeof(usb_kbd_t));
     651       
     652        kbd_dev->parser = (usb_hid_report_parser_t *)(malloc(sizeof(
     653            usb_hid_report_parser_t)));
     654        if (kbd_dev->parser == NULL) {
     655                usb_log_fatal("No memory!\n");
     656                free(kbd_dev);
    628657                return NULL;
    629658        }
    630659       
    631660        kbd_dev->console_phone = -1;
    632         kbd_dev->initialized = USBHID_KBD_STATUS_UNINITIALIZED;
     661        kbd_dev->initialized = USB_KBD_STATUS_UNINITIALIZED;
    633662       
    634663        return kbd_dev;
    635 }
    636 
    637 /*----------------------------------------------------------------------------*/
    638 
    639 static void usbhid_kbd_mark_unusable(usbhid_kbd_t *kbd_dev)
    640 {
    641         kbd_dev->initialized = USBHID_KBD_STATUS_TO_DESTROY;
    642664}
    643665
    … …  
    663685 * @return Other value inherited from function usbhid_dev_init().
    664686 */
    665 static int usbhid_kbd_init(usbhid_kbd_t *kbd_dev, ddf_dev_t *dev)
     687int usb_kbd_init(usb_kbd_t *kbd_dev, usb_device_t *dev)
    666688{
    667689        int rc;
    … …  
    676698       
    677699        if (dev == NULL) {
    678                 usb_log_error("Failed to init keyboard structure: no device"
     700                usb_log_error("Failed to init keyboard structure: no USB device"
    679701                    " given.\n");
    680702                return EINVAL;
    681703        }
    682704       
    683         if (kbd_dev->initialized == USBHID_KBD_STATUS_INITIALIZED) {
     705        if (kbd_dev->initialized == USB_KBD_STATUS_INITIALIZED) {
    684706                usb_log_warning("Keyboard structure already initialized.\n");
    685707                return EINVAL;
    686708        }
    687709       
    688         rc = usbhid_dev_init(kbd_dev->hid_dev, dev, &poll_endpoint_description);
    689        
     710        /* TODO: does not work! */
     711        if (!dev->pipes[USB_KBD_POLL_EP_NO].present) {
     712                usb_log_warning("Required endpoint not found - probably not "
     713                    "a supported device.\n");
     714                return ENOTSUP;
     715        }
     716       
     717        /* The USB device should already be initialized, save it in structure */
     718        kbd_dev->usb_dev = dev;
     719       
     720        /* Initialize the report parser. */
     721        rc = usb_hid_parser_init(kbd_dev->parser);
    690722        if (rc != EOK) {
    691                 usb_log_error("Failed to initialize HID device structure: %s\n",
    692                    str_error(rc));
     723                usb_log_error("Failed to initialize report parser.\n");
    693724                return rc;
    694725        }
    695726       
    696         assert(kbd_dev->hid_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
    697        
    698         // save the size of the report (boot protocol report by default)
    699 //      kbd_dev->key_count = BOOTP_REPORT_SIZE;
    700        
    701         usb_hid_report_path_t *path;
    702         path = usb_hid_report_path();
     727        /* Get the report descriptor and parse it. */
     728        rc = usb_hid_process_report_descriptor(kbd_dev->usb_dev,
     729            kbd_dev->parser);
     730        if (rc != EOK) {
     731                usb_log_warning("Could not process report descriptor, "
     732                    "falling back to boot protocol.\n");
     733                rc = usb_hid_parse_report_descriptor(kbd_dev->parser,
     734                    BOOT_REPORT_DESCRIPTOR, BOOT_REPORT_DESCRIPTOR_SIZE);
     735                if (rc != EOK) {
     736                        usb_log_error("Failed to parse boot report descriptor:"
     737                            " %s.\n", str_error(rc));
     738                        return rc;
     739                }
     740               
     741                rc = usbhid_req_set_protocol(&kbd_dev->usb_dev->ctrl_pipe,
     742                    kbd_dev->usb_dev->interface_no, USB_HID_PROTOCOL_BOOT);
     743               
     744                if (rc != EOK) {
     745                        usb_log_warning("Failed to set boot protocol to the "
     746                            "device: %s\n", str_error(rc));
     747                        return rc;
     748                }
     749        }
     750       
     751        /*
     752         * TODO: make more general
     753         */
     754        usb_hid_report_path_t *path = usb_hid_report_path();
    703755        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
    704756        kbd_dev->key_count = usb_hid_report_input_length(
    705             kbd_dev->hid_dev->parser, path, USB_HID_PATH_COMPARE_STRICT);
     757            kbd_dev->parser, path, USB_HID_PATH_COMPARE_STRICT);
    706758        usb_hid_report_path_free (path);
    707759       
    … …  
    736788       
    737789        /*
    738          * Set boot protocol.
    739790         * Set LEDs according to initial setup.
    740791         * Set Idle rate
    741792         */
    742         assert(kbd_dev->hid_dev != NULL);
    743         assert(kbd_dev->hid_dev->initialized);
    744         //usbhid_req_set_protocol(kbd_dev->hid_dev, USB_HID_PROTOCOL_BOOT);
    745        
    746         usbhid_kbd_set_led(kbd_dev);
    747        
    748         usbhid_req_set_idle(kbd_dev->hid_dev, IDLE_RATE);
    749        
    750         kbd_dev->initialized = USBHID_KBD_STATUS_INITIALIZED;
     793        usb_kbd_set_led(kbd_dev);
     794       
     795        usbhid_req_set_idle(&kbd_dev->usb_dev->ctrl_pipe,
     796            kbd_dev->usb_dev->interface_no, IDLE_RATE);
     797       
     798        kbd_dev->initialized = USB_KBD_STATUS_INITIALIZED;
    751799        usb_log_debug("HID/KBD device structure initialized.\n");
    752800       
    … …  
    755803
    756804/*----------------------------------------------------------------------------*/
    757 /* HID/KBD polling                                                            */
    758 /*----------------------------------------------------------------------------*/
    759 /**
    760  * Main keyboard polling function.
    761  *
    762  * This function uses the Interrupt In pipe of the keyboard to poll for events.
    763  * The keyboard is initialized in a way that it reports only when a key is
    764  * pressed or released, so there is no actual need for any sleeping between
    765  * polls (see usbhid_kbd_try_add_device() or usbhid_kbd_init()).
    766  *
    767  * @param kbd_dev Initialized keyboard structure representing the device to
    768  *                poll.
    769  *
    770  * @sa usbhid_kbd_process_data()
    771  */
    772 static void usbhid_kbd_poll(usbhid_kbd_t *kbd_dev)
    773 {
    774         int rc, sess_rc;
    775         uint8_t buffer[BOOTP_BUFFER_SIZE];
    776         size_t actual_size;
    777        
    778         usb_log_debug("Polling keyboard...\n");
    779        
    780         if (!kbd_dev->initialized) {
    781                 usb_log_error("HID/KBD device not initialized!\n");
    782                 return;
    783         }
    784        
    785         assert(kbd_dev->hid_dev != NULL);
    786         assert(kbd_dev->hid_dev->initialized);
    787 
    788         while (true) {
    789                 sess_rc = usb_pipe_start_session(
    790                     &kbd_dev->hid_dev->poll_pipe);
    791                 if (sess_rc != EOK) {
    792                         usb_log_warning("Failed to start a session: %s.\n",
    793                             str_error(sess_rc));
    794                         break;
    795                 }
    796 
    797                 rc = usb_pipe_read(&kbd_dev->hid_dev->poll_pipe,
    798                     buffer, BOOTP_BUFFER_SIZE, &actual_size);
    799                
    800                 sess_rc = usb_pipe_end_session(
    801                     &kbd_dev->hid_dev->poll_pipe);
    802 
    803                 if (rc != EOK) {
    804                         usb_log_warning("Error polling the keyboard: %s.\n",
    805                             str_error(rc));
    806                         break;
    807                 }
    808 
    809                 if (sess_rc != EOK) {
    810                         usb_log_warning("Error closing session: %s.\n",
    811                             str_error(sess_rc));
    812                         break;
    813                 }
    814 
    815                 /*
    816                  * If the keyboard answered with NAK, it returned no data.
    817                  * This implies that no change happened since last query.
    818                  */
    819                 if (actual_size == 0) {
    820                         usb_log_debug("Keyboard returned NAK\n");
    821                         continue;
    822                 }
    823 
    824                 /*
    825                  * TODO: Process pressed keys.
    826                  */
    827                 usb_log_debug("Calling usbhid_kbd_process_data()\n");
    828                 usbhid_kbd_process_data(kbd_dev, buffer, actual_size);
    829                
    830                 // disabled for now, no reason to sleep
    831                 //async_usleep(kbd_dev->hid_dev->poll_interval);
    832         }
    833 }
    834 
    835 /*----------------------------------------------------------------------------*/
    836 /**
    837  * Function executed by the main driver fibril.
    838  *
    839  * Just starts polling the keyboard for events.
    840  *
    841  * @param arg Initialized keyboard device structure (of type usbhid_kbd_t)
    842  *            representing the device.
    843  *
    844  * @retval EOK if the fibril finished polling the device.
    845  * @retval EINVAL if no device was given in the argument.
    846  *
    847  * @sa usbhid_kbd_poll()
    848  *
    849  * @todo Change return value - only case when the fibril finishes is in case
    850  *       of some error, so the error should probably be propagated from function
    851  *       usbhid_kbd_poll() to here and up.
    852  */
    853 static int usbhid_kbd_fibril(void *arg)
    854 {
    855         if (arg == NULL) {
    856                 usb_log_error("No device!\n");
    857                 return EINVAL;
    858         }
    859        
    860         usbhid_kbd_t *kbd_dev = (usbhid_kbd_t *)arg;
    861 
    862         usbhid_kbd_poll(kbd_dev);
    863        
    864         // as there is another fibril using this device, so we must leave the
    865         // structure to it, but mark it for destroying.
    866         usbhid_kbd_mark_unusable(kbd_dev);
    867         // at the end, properly destroy the KBD structure
    868 //      usbhid_kbd_free(&kbd_dev);
    869 //      assert(kbd_dev == NULL);
    870 
    871         return EOK;
    872 }
    873 
    874 /*----------------------------------------------------------------------------*/
    875 /* API functions                                                              */
    876 /*----------------------------------------------------------------------------*/
    877 /**
    878  * Function for adding a new device of type USB/HID/keyboard.
    879  *
    880  * This functions initializes required structures from the device's descriptors
    881  * and starts new fibril for polling the keyboard for events and another one for
    882  * handling auto-repeat of keys.
    883  *
    884  * During initialization, the keyboard is switched into boot protocol, the idle
    885  * rate is set to 0 (infinity), resulting in the keyboard only reporting event
    886  * when a key is pressed or released. Finally, the LED lights are turned on
    887  * according to the default setup of lock keys.
    888  *
    889  * @note By default, the keyboards is initialized with Num Lock turned on and
    890  *       other locks turned off.
    891  * @note Currently supports only boot-protocol keyboards.
    892  *
    893  * @param dev Device to add.
    894  *
    895  * @retval EOK if successful.
    896  * @retval ENOMEM if there
    897  * @return Other error code inherited from one of functions usbhid_kbd_init(),
    898  *         ddf_fun_bind() and ddf_fun_add_to_class().
    899  *
    900  * @sa usbhid_kbd_fibril(), usbhid_kbd_repeat_fibril()
    901  */
    902 int usbhid_kbd_try_add_device(ddf_dev_t *dev)
    903 {
    904         /*
    905          * Create default function.
    906          */
    907         ddf_fun_t *kbd_fun = ddf_fun_create(dev, fun_exposed, "keyboard");
    908         if (kbd_fun == NULL) {
    909                 usb_log_error("Could not create DDF function node.\n");
    910                 return ENOMEM;
    911         }
    912        
    913         /*
    914          * Initialize device (get and process descriptors, get address, etc.)
    915          */
    916         usb_log_debug("Initializing USB/HID KBD device...\n");
    917        
    918         usbhid_kbd_t *kbd_dev = usbhid_kbd_new();
    919         if (kbd_dev == NULL) {
    920                 usb_log_error("Error while creating USB/HID KBD device "
    921                     "structure.\n");
    922                 ddf_fun_destroy(kbd_fun);
    923                 return ENOMEM;  // TODO: some other code??
    924         }
    925        
    926         int rc = usbhid_kbd_init(kbd_dev, dev);
    927        
    928         if (rc != EOK) {
    929                 usb_log_error("Failed to initialize USB/HID KBD device.\n");
    930                 ddf_fun_destroy(kbd_fun);
    931                 usbhid_kbd_free(&kbd_dev);
    932                 return rc;
    933         }       
    934        
    935         usb_log_debug("USB/HID KBD device structure initialized.\n");
    936        
    937         /*
    938          * Store the initialized keyboard device and keyboard ops
    939          * to the DDF function.
    940          */
    941         kbd_fun->driver_data = kbd_dev;
    942         kbd_fun->ops = &keyboard_ops;
    943 
    944         rc = ddf_fun_bind(kbd_fun);
    945         if (rc != EOK) {
    946                 usb_log_error("Could not bind DDF function: %s.\n",
    947                     str_error(rc));
    948                 // TODO: Can / should I destroy the DDF function?
    949                 ddf_fun_destroy(kbd_fun);
    950                 usbhid_kbd_free(&kbd_dev);
    951                 return rc;
    952         }
    953        
    954         rc = ddf_fun_add_to_class(kbd_fun, "keyboard");
    955         if (rc != EOK) {
    956                 usb_log_error(
    957                     "Could not add DDF function to class 'keyboard': %s.\n",
    958                     str_error(rc));
    959                 // TODO: Can / should I destroy the DDF function?
    960                 ddf_fun_destroy(kbd_fun);
    961                 usbhid_kbd_free(&kbd_dev);
    962                 return rc;
    963         }
    964        
    965         /*
    966          * Create new fibril for handling this keyboard
    967          */
    968         fid_t fid = fibril_create(usbhid_kbd_fibril, kbd_dev);
    969         if (fid == 0) {
    970                 usb_log_error("Failed to start fibril for `%s' device.\n",
    971                     dev->name);
    972                 return ENOMEM;
    973         }
    974         fibril_add_ready(fid);
    975        
    976         /*
    977          * Create new fibril for auto-repeat
    978          */
    979         fid = fibril_create(usbhid_kbd_repeat_fibril, kbd_dev);
    980         if (fid == 0) {
    981                 usb_log_error("Failed to start fibril for KBD auto-repeat");
    982                 return ENOMEM;
    983         }
    984         fibril_add_ready(fid);
    985 
    986         (void)keyboard_ops;
    987 
    988         /*
    989          * Hurrah, device is initialized.
    990          */
    991         return EOK;
    992 }
    993 
    994 /*----------------------------------------------------------------------------*/
    995 
    996 int usbhid_kbd_is_usable(const usbhid_kbd_t *kbd_dev)
    997 {
    998         return (kbd_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
     805
     806bool usb_kbd_polling_callback(usb_device_t *dev, uint8_t *buffer,
     807     size_t buffer_size, void *arg)
     808{
     809        if (dev == NULL || buffer == NULL || arg == NULL) {
     810                // do not continue polling (???)
     811                return false;
     812        }
     813       
     814        usb_kbd_t *kbd_dev = (usb_kbd_t *)arg;
     815       
     816        // TODO: add return value from this function
     817        usb_kbd_process_data(kbd_dev, buffer, buffer_size);
     818       
     819        return true;
     820}
     821
     822/*----------------------------------------------------------------------------*/
     823
     824void usb_kbd_polling_ended_callback(usb_device_t *dev, bool reason,
     825     void *arg)
     826{
     827        if (dev == NULL || arg == NULL) {
     828                return;
     829        }
     830       
     831        usb_kbd_t *kbd = (usb_kbd_t *)arg;
     832       
     833        usb_kbd_mark_unusable(kbd);
     834}
     835
     836/*----------------------------------------------------------------------------*/
     837
     838int usb_kbd_is_initialized(const usb_kbd_t *kbd_dev)
     839{
     840        return (kbd_dev->initialized == USB_KBD_STATUS_INITIALIZED);
     841}
     842
     843/*----------------------------------------------------------------------------*/
     844
     845int usb_kbd_is_ready_to_destroy(const usb_kbd_t *kbd_dev)
     846{
     847        return (kbd_dev->initialized == USB_KBD_STATUS_TO_DESTROY);
    999848}
    1000849
    … …  
    1005854 * @param kbd_dev Pointer to the structure to be destroyed.
    1006855 */
    1007 void usbhid_kbd_free(usbhid_kbd_t **kbd_dev)
     856void usb_kbd_free(usb_kbd_t **kbd_dev)
    1008857{
    1009858        if (kbd_dev == NULL || *kbd_dev == NULL) {
    … …  
    1014863        async_hangup((*kbd_dev)->console_phone);
    1015864       
    1016         if ((*kbd_dev)->hid_dev != NULL) {
    1017                 usbhid_dev_free(&(*kbd_dev)->hid_dev);
    1018                 assert((*kbd_dev)->hid_dev == NULL);
    1019         }
     865//      if ((*kbd_dev)->hid_dev != NULL) {
     866//              usbhid_dev_free(&(*kbd_dev)->hid_dev);
     867//              assert((*kbd_dev)->hid_dev == NULL);
     868//      }
    1020869       
    1021870        if ((*kbd_dev)->repeat_mtx != NULL) {
    … …  
    1024873                free((*kbd_dev)->repeat_mtx);
    1025874        }
     875       
     876        // destroy the parser
     877        if ((*kbd_dev)->parser != NULL) {
     878                usb_hid_free_report_parser((*kbd_dev)->parser);
     879        }
     880       
     881        /* TODO: what about the USB device structure?? */
    1026882
    1027883        free(*kbd_dev);
Note: See TracChangeset for help on using the changeset viewer.