Changeset 361e61b in mainline for uspace/drv/usbhid/kbddev.c


Ignore:
Timestamp:
2011-03-21T14:23:15Z (13 years ago)
Author:
Matej Klonfar <maklf@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
55e388a1
Parents:
c32688d (diff), 48fe0c9 (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:

merge with development

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/usbhid/kbddev.c

    rc32688d r361e61b  
    5151#include <usb/classes/hidparser.h>
    5252#include <usb/classes/classes.h>
     53#include <usb/classes/hidut.h>
    5354
    5455#include "kbddev.h"
    … …  
    9394        .flags = 0
    9495};
     96
     97typedef 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;
    95102
    96103/*----------------------------------------------------------------------------*/
    … …  
    124131};
    125132
     133typedef enum usbhid_lock_code {
     134        USBHID_LOCK_NUM = 0x53,
     135        USBHID_LOCK_CAPS = 0x39,
     136        USBHID_LOCK_SCROLL = 0x47,
     137        USBHID_LOCK_COUNT = 3
     138} usbhid_lock_code;
     139
     140static const usbhid_lock_code usbhid_lock_codes[USBHID_LOCK_COUNT] = {
     141        USBHID_LOCK_NUM,
     142        USBHID_LOCK_CAPS,
     143        USBHID_LOCK_SCROLL
     144};
     145
    126146/*----------------------------------------------------------------------------*/
    127147/* IPC method handler                                                         */
    … …  
    218238       
    219239        assert(kbd_dev->hid_dev != NULL);
    220         assert(kbd_dev->hid_dev->initialized);
     240        assert(kbd_dev->hid_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
    221241        usbhid_req_set_report(kbd_dev->hid_dev, USB_HID_REPORT_TYPE_OUTPUT,
    222242            buffer, BOOTP_BUFFER_OUT_SIZE);
    … …  
    346366 * @sa usbhid_kbd_push_ev()
    347367 */
    348 static void usbhid_kbd_check_modifier_changes(usbhid_kbd_t *kbd_dev,
    349     uint8_t modifiers)
    350 {
    351         /*
    352          * TODO: why the USB keyboard has NUM_, SCROLL_ and CAPS_LOCK
    353          *       both as modifiers and as keys with their own scancodes???
    354          *
    355          * modifiers should be sent as normal keys to usbhid_parse_scancode()!!
    356          * so maybe it would be better if I received it from report parser in
    357          * that way
    358          */
    359        
    360         int i;
    361         for (i = 0; i < USB_HID_MOD_COUNT; ++i) {
    362                 if ((modifiers & usb_hid_modifiers_consts[i]) &&
    363                     !(kbd_dev->modifiers & usb_hid_modifiers_consts[i])) {
    364                         // modifier pressed
    365                         if (usbhid_modifiers_keycodes[i] != 0) {
    366                                 usbhid_kbd_push_ev(kbd_dev, KEY_PRESS,
    367                                     usbhid_modifiers_keycodes[i]);
    368                         }
    369                 } else if (!(modifiers & usb_hid_modifiers_consts[i]) &&
    370                     (kbd_dev->modifiers & usb_hid_modifiers_consts[i])) {
    371                         // modifier released
    372                         if (usbhid_modifiers_keycodes[i] != 0) {
    373                                 usbhid_kbd_push_ev(kbd_dev, KEY_RELEASE,
    374                                     usbhid_modifiers_keycodes[i]);
    375                         }
    376                 }       // no change
    377         }
    378        
    379         kbd_dev->modifiers = modifiers;
     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
     404static inline int usbhid_kbd_is_lock(unsigned int key_code)
     405{
     406        return (key_code == KC_NUM_LOCK
     407            || key_code == KC_SCROLL_LOCK
     408            || key_code == KC_CAPS_LOCK);
    380409}
    381410
    … …  
    404433        /*
    405434         * First of all, check if the kbd have reported phantom state.
     435         *
     436         * TODO: this must be changed as we don't know which keys are modifiers
     437         *       and which are regular keys.
    406438         */
    407439        i = 0;
    … …  
    434466                        // not found, i.e. the key was released
    435467                        key = usbhid_parse_scancode(kbd_dev->keys[j]);
    436                         usbhid_kbd_repeat_stop(kbd_dev, key);
     468                        if (!usbhid_kbd_is_lock(key)) {
     469                                usbhid_kbd_repeat_stop(kbd_dev, key);
     470                        }
    437471                        usbhid_kbd_push_ev(kbd_dev, KEY_RELEASE, key);
    438472                        usb_log_debug2("Key released: %d\n", key);
    … …  
    458492                            key_codes[i]);
    459493                        usbhid_kbd_push_ev(kbd_dev, KEY_PRESS, key);
    460                         usbhid_kbd_repeat_start(kbd_dev, key);
     494                        if (!usbhid_kbd_is_lock(key)) {
     495                                usbhid_kbd_repeat_start(kbd_dev, key);
     496                        }
    461497                } else {
    462498                        // found, nothing happens
    … …  
    510546        }
    511547       
    512         usbhid_kbd_check_modifier_changes(kbd_dev, modifiers);
     548        ///usbhid_kbd_check_modifier_changes(kbd_dev, key_codes, count);
    513549        usbhid_kbd_check_key_changes(kbd_dev, key_codes, count);
    514550}
    … …  
    535571                                    uint8_t *buffer, size_t actual_size)
    536572{
    537         assert(kbd_dev->initialized);
     573        assert(kbd_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
    538574        assert(kbd_dev->hid_dev->parser != NULL);
    539575       
    … …  
    589625       
    590626        kbd_dev->console_phone = -1;
    591         kbd_dev->initialized = 0;
     627        kbd_dev->initialized = USBHID_KBD_STATUS_UNINITIALIZED;
    592628       
    593629        return kbd_dev;
    … …  
    595631
    596632/*----------------------------------------------------------------------------*/
    597 /**
    598  * Properly destroys the USB/HID keyboard structure.
    599  *
    600  * @param kbd_dev Pointer to the structure to be destroyed.
    601  */
    602 static void usbhid_kbd_free(usbhid_kbd_t **kbd_dev)
    603 {
    604         if (kbd_dev == NULL || *kbd_dev == NULL) {
    605                 return;
    606         }
    607        
    608         // hangup phone to the console
    609         async_hangup((*kbd_dev)->console_phone);
    610        
    611         if ((*kbd_dev)->hid_dev != NULL) {
    612                 usbhid_dev_free(&(*kbd_dev)->hid_dev);
    613                 assert((*kbd_dev)->hid_dev == NULL);
    614         }
    615        
    616         if ((*kbd_dev)->repeat_mtx != NULL) {
    617                 /* TODO: replace by some check and wait */
    618                 assert(!fibril_mutex_is_locked((*kbd_dev)->repeat_mtx));
    619                 free((*kbd_dev)->repeat_mtx);
    620         }
    621 
    622         free(*kbd_dev);
    623         *kbd_dev = NULL;
     633
     634static void usbhid_kbd_mark_unusable(usbhid_kbd_t *kbd_dev)
     635{
     636        kbd_dev->initialized = USBHID_KBD_STATUS_TO_DESTROY;
    624637}
    625638
    … …  
    663676        }
    664677       
    665         if (kbd_dev->initialized) {
     678        if (kbd_dev->initialized == USBHID_KBD_STATUS_INITIALIZED) {
    666679                usb_log_warning("Keyboard structure already initialized.\n");
    667680                return EINVAL;
    … …  
    676689        }
    677690       
    678         assert(kbd_dev->hid_dev->initialized);
     691        assert(kbd_dev->hid_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
    679692       
    680693        // save the size of the report (boot protocol report by default)
    681         kbd_dev->key_count = BOOTP_REPORT_SIZE;
     694//      kbd_dev->key_count = BOOTP_REPORT_SIZE;
     695       
     696        usb_hid_report_path_t path;
     697        path.usage_page = USB_HIDUT_PAGE_KEYBOARD;
     698        kbd_dev->key_count = usb_hid_report_input_length(
     699            kbd_dev->hid_dev->parser, &path);
     700       
     701        usb_log_debug("Size of the input report: %zu\n", kbd_dev->key_count);
     702       
    682703        kbd_dev->keys = (uint8_t *)calloc(
    683704            kbd_dev->key_count, sizeof(uint8_t));
    … …  
    720741        usbhid_req_set_idle(kbd_dev->hid_dev, IDLE_RATE);
    721742       
    722         kbd_dev->initialized = 1;
     743        kbd_dev->initialized = USBHID_KBD_STATUS_INITIALIZED;
    723744        usb_log_info("HID/KBD device structure initialized.\n");
    724745       
    … …  
    834855        usbhid_kbd_poll(kbd_dev);
    835856       
     857        // as there is another fibril using this device, so we must leave the
     858        // structure to it, but mark it for destroying.
     859        usbhid_kbd_mark_unusable(kbd_dev);
    836860        // at the end, properly destroy the KBD structure
    837         usbhid_kbd_free(&kbd_dev);
    838         assert(kbd_dev == NULL);
     861//      usbhid_kbd_free(&kbd_dev);
     862//      assert(kbd_dev == NULL);
    839863
    840864        return EOK;
    … …  
    958982}
    959983
     984/*----------------------------------------------------------------------------*/
     985
     986int usbhid_kbd_is_usable(const usbhid_kbd_t *kbd_dev)
     987{
     988        return (kbd_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
     989}
     990
     991/*----------------------------------------------------------------------------*/
     992/**
     993 * Properly destroys the USB/HID keyboard structure.
     994 *
     995 * @param kbd_dev Pointer to the structure to be destroyed.
     996 */
     997void usbhid_kbd_free(usbhid_kbd_t **kbd_dev)
     998{
     999        if (kbd_dev == NULL || *kbd_dev == NULL) {
     1000                return;
     1001        }
     1002       
     1003        // hangup phone to the console
     1004        async_hangup((*kbd_dev)->console_phone);
     1005       
     1006        if ((*kbd_dev)->hid_dev != NULL) {
     1007                usbhid_dev_free(&(*kbd_dev)->hid_dev);
     1008                assert((*kbd_dev)->hid_dev == NULL);
     1009        }
     1010       
     1011        if ((*kbd_dev)->repeat_mtx != NULL) {
     1012                /* TODO: replace by some check and wait */
     1013                assert(!fibril_mutex_is_locked((*kbd_dev)->repeat_mtx));
     1014                free((*kbd_dev)->repeat_mtx);
     1015        }
     1016
     1017        free(*kbd_dev);
     1018        *kbd_dev = NULL;
     1019}
     1020
    9601021/**
    9611022 * @}
Note: See TracChangeset for help on using the changeset viewer.