Changes in / [1879a7d:ea991e84] in mainline


Ignore:
Location:
uspace
Files:
4 deleted
3 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/usbkbd/Makefile

    r1879a7d rea991e84  
    2929USPACE_PREFIX = ../..
    3030LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBUSB_PREFIX)/libusb.a
    31 EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBUSB_PREFIX)/include -I.
     31EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBUSB_PREFIX)/include
    3232BINARY = usbkbd
    33 SRV_KBD = $(USPACE_PREFIX)/srv/hid/kbd
    3433
    3534SOURCES = \
    3635        main.c \
    3736        descparser.c \
    38         descdump.c \
    39         conv.c \
    40         us_qwerty.c \
    41         us_dvorak.c \
    42         cz.c
     37        descdump.c
    4338
    4439include $(USPACE_PREFIX)/Makefile.common
    45 
    46 us_qwerty.c:
    47         ln -snf $(SRV_KBD)/layout/$@ $@
    48 
    49 us_dvorak.c:
    50         ln -snf $(SRV_KBD)/layout/$@ $@
    51 
    52 cz.c:
    53         ln -snf $(SRV_KBD)/layout/$@ $@
    54 
    55 
  • uspace/drv/usbkbd/main.c

    r1879a7d rea991e84  
    4141#include <usb/devreq.h>
    4242#include <usb/descriptor.h>
    43 #include <io/console.h>
    4443#include "descparser.h"
    4544#include "descdump.h"
    46 #include "conv.h"
    47 #include "layout.h"
    4845
    4946#define BUFFER_SIZE 32
     
    9491
    9592/*
    96  * TODO: Move somewhere else
    97  */
    98 /*
    99 #define BYTES_PER_LINE 12
    100 
    101 static void dump_buffer(const char *msg, const uint8_t *buffer, size_t length)
    102 {
    103         printf("%s\n", msg);
    104        
    105         size_t i;
    106         for (i = 0; i < length; i++) {
    107                 printf("  0x%02X", buffer[i]);
    108                 if (((i > 0) && (((i+1) % BYTES_PER_LINE) == 0))
    109                     || (i + 1 == length)) {
    110                         printf("\n");
    111                 }
    112         }
    113 }
    114 */
    115 /*
    116  * Copy-paste from srv/hid/kbd/generic/kbd.c
    117  */
    118 
    119 /** Currently active modifiers.
    120  *
    121  * TODO: put to device?
    122  */
    123 static unsigned mods = KM_NUM_LOCK;
    124 
    125 /** Currently pressed lock keys. We track these to tackle autorepeat. 
    126  *
    127  * TODO: put to device?
    128  */
    129 static unsigned lock_keys;
    130 
    131 #define NUM_LAYOUTS 3
    132 
    133 static layout_op_t *layout[NUM_LAYOUTS] = {
    134         &us_qwerty_op,
    135         &us_dvorak_op,
    136         &cz_op
    137 };
    138 
    139 static int active_layout = 0;
    140 
    141 static void kbd_push_ev(int type, unsigned int key)
    142 {
    143         console_event_t ev;
    144         unsigned mod_mask;
    145 
    146         // TODO: replace by our own parsing?? or are the key codes identical??
    147         switch (key) {
    148         case KC_LCTRL: mod_mask = KM_LCTRL; break;
    149         case KC_RCTRL: mod_mask = KM_RCTRL; break;
    150         case KC_LSHIFT: mod_mask = KM_LSHIFT; break;
    151         case KC_RSHIFT: mod_mask = KM_RSHIFT; break;
    152         case KC_LALT: mod_mask = KM_LALT; break;
    153         case KC_RALT: mod_mask = KM_RALT; break;
    154         default: mod_mask = 0; break;
    155         }
    156 
    157         if (mod_mask != 0) {
    158                 if (type == KEY_PRESS)
    159                         mods = mods | mod_mask;
    160                 else
    161                         mods = mods & ~mod_mask;
    162         }
    163 
    164         switch (key) {
    165         case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; break;
    166         case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; break;
    167         case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; break;
    168         default: mod_mask = 0; break;
    169         }
    170 
    171         if (mod_mask != 0) {
    172                 if (type == KEY_PRESS) {
    173                         /*
    174                          * Only change lock state on transition from released
    175                          * to pressed. This prevents autorepeat from messing
    176                          * up the lock state.
    177                          */
    178                         mods = mods ^ (mod_mask & ~lock_keys);
    179                         lock_keys = lock_keys | mod_mask;
    180 
    181                         /* Update keyboard lock indicator lights. */
    182                         // TODO
    183                         //kbd_ctl_set_ind(mods);
    184                 } else {
    185                         lock_keys = lock_keys & ~mod_mask;
    186                 }
    187         }
    188 /*
    189         printf("type: %d\n", type);
    190         printf("mods: 0x%x\n", mods);
    191         printf("keycode: %u\n", key);
    192 */
    193        
    194         if (type == KEY_PRESS && (mods & KM_LCTRL) &&
    195                 key == KC_F1) {
    196                 active_layout = 0;
    197                 layout[active_layout]->reset();
    198                 return;
    199         }
    200 
    201         if (type == KEY_PRESS && (mods & KM_LCTRL) &&
    202                 key == KC_F2) {
    203                 active_layout = 1;
    204                 layout[active_layout]->reset();
    205                 return;
    206         }
    207 
    208         if (type == KEY_PRESS && (mods & KM_LCTRL) &&
    209                 key == KC_F3) {
    210                 active_layout = 2;
    211                 layout[active_layout]->reset();
    212                 return;
    213         }
    214        
    215         ev.type = type;
    216         ev.key = key;
    217         ev.mods = mods;
    218 
    219         ev.c = layout[active_layout]->parse_ev(&ev);
    220 
    221         printf("Sending key %d to the console\n", ev.key);
    222         assert(console_callback_phone != -1);
    223         async_msg_4(console_callback_phone, KBD_EVENT, ev.type, ev.key, ev.mods, ev.c);
    224 }
    225 /*
    226  * End of copy-paste
    227  */
    228 
    229         /*
    230          * TODO:
    231          * 1) key press / key release - how does the keyboard notify about release?
    232          * 2) layouts (use the already defined), not important now
    233          * 3)
    234          */
    235 
    236 /*
    23793 * Callbacks for parser
    23894 */
    23995static void usbkbd_process_keycodes(const uint8_t *key_codes, size_t count,
    240     uint8_t modifiers, void *arg)
     96                                    uint8_t modifiers, void *arg)
    24197{
    24298        printf("Got keys: ");
     
    244100        for (i = 0; i < count; ++i) {
    245101                printf("%d ", key_codes[i]);
    246                 // TODO: Key press / release
    247 
    248                 // TODO: NOT WORKING
    249                 unsigned int key = usbkbd_parse_scancode(key_codes[i]);
    250                 kbd_push_ev(KEY_PRESS, key);
    251102        }
    252103        printf("\n");
     
    416267        //usb_hid_parse_report(kbd_dev->parser, buffer, actual_size, callbacks,
    417268        //    NULL);
    418         printf("Calling usb_hid_boot_keyboard_input_report() with size %zu\n",
    419             actual_size);
    420         //dump_buffer("bufffer: ", buffer, actual_size);
    421         int rc = usb_hid_boot_keyboard_input_report(buffer, actual_size, callbacks,
    422             NULL);
    423         if (rc != EOK) {
    424                 printf("Error in usb_hid_boot_keyboard_input_report(): %d\n", rc);
    425         }
     269        printf("Calling usb_hid_boot_keyboard_input_report()...\n)");
     270        usb_hid_boot_keyboard_input_report(buffer, actual_size, callbacks, NULL);
    426271}
    427272
    428273static void usbkbd_poll_keyboard(usb_hid_dev_kbd_t *kbd_dev)
    429274{
     275        return;
     276       
    430277        int rc;
    431278        usb_handle_t handle;
     
    445292        };
    446293
    447         printf("Polling keyboard...\n");
    448 
    449294        while (true) {
    450                 async_usleep(1000 * 1000 * 2);
     295                async_usleep(1000 * 1000);
    451296                rc = usb_drv_async_interrupt_in(kbd_dev->device->parent_phone,
    452297                    poll_target, buffer, BUFFER_SIZE, &actual_size, &handle);
    453298
    454299                if (rc != EOK) {
    455                         printf("Error in usb_drv_async_interrupt_in(): %d\n", rc);
    456300                        continue;
    457301                }
     
    459303                rc = usb_drv_async_wait_for(handle);
    460304                if (rc != EOK) {
    461                         printf("Error in usb_drv_async_wait_for(): %d\n", rc);
    462305                        continue;
    463306                }
     
    468311                 */
    469312                if (actual_size == 0) {
    470                         printf("Keyboard returned NAK\n");
    471313                        continue;
    472314                }
     
    475317                 * TODO: Process pressed keys.
    476318                 */
    477                 printf("Calling usbkbd_process_interrupt_in()\n");
    478319                usbkbd_process_interrupt_in(kbd_dev, buffer, actual_size);
    479320        }
     
    496337        // initialize device (get and process descriptors, get address, etc.)
    497338        usb_hid_dev_kbd_t *kbd_dev = usbkbd_init_device(dev);
    498         if (kbd_dev == NULL) {
    499                 printf("Error while initializing device.\n");
    500                 return -1;
    501         }
    502339
    503340        usbkbd_poll_keyboard(kbd_dev);
  • uspace/lib/usb/src/hidparser.c

    r1879a7d rea991e84  
    3535#include <usb/classes/hidparser.h>
    3636#include <errno.h>
    37 #include <stdio.h>
    3837
    3938/** Parse HID report descriptor.
     
    121120        item.logical_max = 255;
    122121
    123         if (size != 8) {
    124                 return ERANGE;
     122        if(size != 8){
     123                return -1;
    125124        }
    126125
    127126        uint8_t keys[6];
    128         for (i = 0; i < item.count; i++) {
    129                 keys[i] = data[i + item.offset];
     127        for(i=item.offset; i<item.count; i++) {
     128                keys[i-2] = data[i];
    130129        }
    131130
Note: See TracChangeset for help on using the changeset viewer.