Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/usbkbd/main.c

    r101ef25c r0e126be7  
    2828#include <usb/usbdrv.h>
    2929#include <driver.h>
    30 #include <ipc/driver.h>
    3130#include <errno.h>
    32 #include <fibril.h>
    33 #include <usb/classes/hid.h>
    3431
    3532#define BUFFER_SIZE 32
    36 #define NAME "usbkbd"
    3733
    38 static const usb_endpoint_t CONTROL_EP = 0;
    39 
    40 static usb_hid_dev_kbd_t *usbkbd_init_device(device_t *dev)
    41 {
    42         usb_hid_dev_kbd_t *kbd_dev = (usb_hid_dev_kbd_t *)malloc(
    43                         sizeof(usb_hid_dev_kbd_t));
    44 
    45         if (kbd_dev == NULL) {
    46                 fprintf(stderr, NAME ": No memory!\n");
    47                 return NULL;
    48         }
    49 
    50         kbd_dev->device = dev;
    51 
    52         // get phone to my HC and save it as my parent's phone
    53         // TODO: maybe not a good idea if DDF will use parent_phone
    54         kbd_dev->device->parent_phone = usb_drv_hc_connect(dev, 0);
    55 
    56         kbd_dev->address = usb_drv_get_my_address(dev->parent_phone,
    57             dev);
    58 
    59         // doesn't matter now that we have no address
    60 //      if (kbd_dev->address < 0) {
    61 //              fprintf(stderr, NAME ": No device address!\n");
    62 //              free(kbd_dev);
    63 //              return NULL;
    64 //      }
    65 
    66         // default endpoint
    67         kbd_dev->default_ep = CONTROL_EP;
    68 
    69         // TODO: get descriptors
    70 
    71         // TODO: parse descriptors and save endpoints
    72 
    73         return kbd_dev;
    74 }
    75 
    76 static void usbkbd_process_interrupt_in(usb_hid_dev_kbd_t *kbd_dev,
    77                                         char *buffer, size_t actual_size)
    78 {
    79         /*
    80          * here, the parser will be called, probably with some callbacks
    81          * now only take last 6 bytes and process, i.e. send to kbd
    82          */
    83 }
    84 
    85 static void usbkbd_poll_keyboard(usb_hid_dev_kbd_t *kbd_dev)
     34/* Call this periodically to check keyboard status changes. */
     35static void poll_keyboard(device_t *dev)
    8636{
    8737        int rc;
     
    8939        char buffer[BUFFER_SIZE];
    9040        size_t actual_size;
    91         //usb_endpoint_t poll_endpoint = 1;
     41        usb_endpoint_t poll_endpoint = 1;
    9242
    93 //      usb_address_t my_address = usb_drv_get_my_address(dev->parent_phone,
    94 //          dev);
    95 //      if (my_address < 0) {
    96 //              return;
    97 //      }
     43        usb_address_t my_address = usb_drv_get_my_address(dev->parent_phone,
     44            dev);
     45        if (my_address < 0) {
     46                return;
     47        }
    9848
    9949        usb_target_t poll_target = {
    100                 .address = kbd_dev->address,
    101                 .endpoint = kbd_dev->default_ep
     50                .address = my_address,
     51                .endpoint = poll_endpoint
    10252        };
    10353
    104         while (true) {
    105                 rc = usb_drv_async_interrupt_in(kbd_dev->device->parent_phone,
    106                     poll_target, buffer, BUFFER_SIZE, &actual_size, &handle);
    107 
    108                 if (rc != EOK) {
    109                         continue;
    110                 }
    111 
    112                 rc = usb_drv_async_wait_for(handle);
    113                 if (rc != EOK) {
    114                         continue;
    115                 }
    116 
    117                 /*
    118                  * If the keyboard answered with NAK, it returned no data.
    119                  * This implies that no change happened since last query.
    120                  */
    121                 if (actual_size == 0) {
    122                         continue;
    123                 }
    124 
    125                 /*
    126                  * TODO: Process pressed keys.
    127                  */
    128                 usbkbd_process_interrupt_in(kbd_dev, buffer, actual_size);
     54        rc = usb_drv_async_interrupt_in(dev->parent_phone, poll_target,
     55            buffer, BUFFER_SIZE, &actual_size, &handle);
     56        if (rc != EOK) {
     57                return;
    12958        }
    13059
    131         // not reached
    132         assert(0);
     60        rc = usb_drv_async_wait_for(handle);
     61        if (rc != EOK) {
     62                return;
     63        }
     64
     65        /*
     66         * If the keyboard answered with NAK, it returned no data.
     67         * This implies that no change happened since last query.
     68         */
     69        if (actual_size == 0) {
     70                return;
     71        }
     72
     73        /*
     74         * Process pressed keys.
     75         */
    13376}
    13477
    135 static int usbkbd_fibril_device(void *arg)
    136 {
    137         printf("!!! USB device fibril\n");
    138 
    139         if (arg == NULL) {
    140                 printf("No device!\n");
    141                 return -1;
    142         }
    143 
    144         device_t *dev = (device_t *)arg;
    145 
    146         // initialize device (get and process descriptors, get address, etc.)
    147         usb_hid_dev_kbd_t *kbd_dev = usbkbd_init_device(dev);
    148 
    149         usbkbd_poll_keyboard(kbd_dev);
    150 
    151         return EOK;
    152 }
    153 
    154 static int usbkbd_add_device(device_t *dev)
     78static int add_kbd_device(device_t *dev)
    15579{
    15680        /* For now, fail immediately. */
    157         //return ENOTSUP;
     81        return ENOTSUP;
    15882
    15983        /*
    16084         * When everything is okay, connect to "our" HC.
    161          *
    162          * Not supported yet, skip..
    16385         */
    164 //      int phone = usb_drv_hc_connect(dev, 0);
    165 //      if (phone < 0) {
    166 //              /*
    167 //               * Connecting to HC failed, roll-back and announce
    168 //               * failure.
    169 //               */
    170 //              return phone;
    171 //      }
     86        int phone = usb_drv_hc_connect(dev, 0);
     87        if (phone < 0) {
     88                /*
     89                 * Connecting to HC failed, roll-back and announce
     90                 * failure.
     91                 */
     92                return phone;
     93        }
    17294
    173 //      dev->parent_phone = phone;
     95        dev->parent_phone = phone;
    17496
    17597        /*
    176          * Create new fibril for handling this keyboard
     98         * Just for fun ;-).
    17799         */
    178         fid_t fid = fibril_create(usbkbd_fibril_device, dev);
    179         if (fid == 0) {
    180                 printf("%s: failed to start fibril for HID device\n", NAME);
    181                 return ENOMEM;
    182         }
    183         fibril_add_ready(fid);
     100        poll_keyboard(dev);
    184101
    185102        /*
     
    190107
    191108static driver_ops_t kbd_driver_ops = {
    192         .add_device = usbkbd_add_device,
     109        .add_device = add_kbd_device,
    193110};
    194111
    195112static driver_t kbd_driver = {
    196         .name = NAME,
     113        .name = "usbkbd",
    197114        .driver_ops = &kbd_driver_ops
    198115};
Note: See TracChangeset for help on using the changeset viewer.