Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 65b458c4 in mainline


Ignore:
Timestamp:
2011-05-13T12:44:37Z (11 years ago)
Author:
Lubos Slovak <lubos.slovak@…>
Branches:
lfn, master
Children:
37f87fa
Parents:
97cb542
Message:

Subdriver-specific data moved to the subdriver structure.

+ DDF ops removed from hid_dev_t.

Should fix #225

Location:
uspace/drv/usbhid
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/usbhid/generic/hiddev.c

    r97cb542 r65b458c4  
    162162/*----------------------------------------------------------------------------*/
    163163
    164 int usb_generic_hid_init(usb_hid_dev_t *hid_dev)
     164int usb_generic_hid_init(usb_hid_dev_t *hid_dev, void **data)
    165165{
    166166        if (hid_dev == NULL) {
     
    173173/*----------------------------------------------------------------------------*/
    174174
    175 bool usb_generic_hid_polling_callback(usb_hid_dev_t *hid_dev,
     175bool usb_generic_hid_polling_callback(usb_hid_dev_t *hid_dev, void *data,
    176176    uint8_t *buffer, size_t buffer_size)
    177177{
  • uspace/drv/usbhid/generic/hiddev.h

    r97cb542 r65b458c4  
    4848/*----------------------------------------------------------------------------*/
    4949
    50 int usb_generic_hid_init(struct usb_hid_dev *hid_dev);
     50int usb_generic_hid_init(struct usb_hid_dev *hid_dev, void **data);
    5151
    52 bool usb_generic_hid_polling_callback(struct usb_hid_dev *hid_dev,
     52bool usb_generic_hid_polling_callback(struct usb_hid_dev *hid_dev, void *data,
    5353    uint8_t *buffer, size_t buffer_size);
    5454
  • uspace/drv/usbhid/kbd/kbddev.c

    r97cb542 r65b458c4  
    252252        sysarg_t method = IPC_GET_IMETHOD(*icall);
    253253       
    254         usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
    255        
    256         if (hid_dev == NULL || hid_dev->data == NULL) {
     254        usb_kbd_t *kbd_dev = (usb_kbd_t *)fun->driver_data;
     255        if (kbd_dev == NULL) {
    257256                usb_log_debug("default_connection_handler: "
    258257                    "Missing parameter.\n");
     
    260259                return;
    261260        }
    262        
    263         assert(hid_dev != NULL);
    264         assert(hid_dev->data != NULL);
    265         usb_kbd_t *kbd_dev = (usb_kbd_t *)hid_dev->data;
    266261
    267262        if (method == IPC_M_CONNECT_TO_ME) {
     
    663658 *     usb_hid_parse_report().
    664659 */
    665 static void usb_kbd_process_data(usb_hid_dev_t *hid_dev,
     660static void usb_kbd_process_data(usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev,
    666661                                 uint8_t *buffer, size_t actual_size)
    667662{
    668663        assert(hid_dev->report != NULL);
    669664        assert(hid_dev != NULL);
    670         assert(hid_dev->data != NULL);
    671        
    672         usb_kbd_t *kbd_dev = (usb_kbd_t *)hid_dev->data;
     665        assert(kbd_dev != NULL);
    673666
    674667        usb_log_debug("Calling usb_hid_parse_report() with "
     
    775768/*----------------------------------------------------------------------------*/
    776769
    777 static int usb_kbd_create_function(usb_hid_dev_t *hid_dev)
     770static int usb_kbd_create_function(usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev)
    778771{
    779772        assert(hid_dev != NULL);
    780773        assert(hid_dev->usb_dev != NULL);
     774        assert(kbd_dev != NULL);
    781775       
    782776        /* Create the function exposed under /dev/devices. */
     
    793787         * to the DDF function.
    794788         */
    795         fun->ops = &hid_dev->ops;
    796         fun->driver_data = hid_dev;   // TODO: maybe change to hid_dev->data
     789        fun->ops = &kbd_dev->ops;
     790        fun->driver_data = kbd_dev;
    797791
    798792        int rc = ddf_fun_bind(fun);
     
    841835 * @return Other value inherited from function usbhid_dev_init().
    842836 */
    843 int usb_kbd_init(usb_hid_dev_t *hid_dev)
     837int usb_kbd_init(usb_hid_dev_t *hid_dev, void **data)
    844838{
    845839        usb_log_debug("Initializing HID/KBD structure...\n");
     
    954948       
    955949        // save the KBD device structure into the HID device structure
    956         hid_dev->data = kbd_dev;
     950        //hid_dev->data = kbd_dev;
     951        *data = kbd_dev;
    957952       
    958953        // set handler for incoming calls
    959         hid_dev->ops.default_handler = default_connection_handler;
     954        kbd_dev->ops.default_handler = default_connection_handler;
    960955       
    961956        /*
     
    982977       
    983978        usb_log_debug("Creating KBD function...\n");
    984         int rc = usb_kbd_create_function(hid_dev);
     979        int rc = usb_kbd_create_function(hid_dev, kbd_dev);
    985980        if (rc != EOK) {
    986981                usb_kbd_free(&kbd_dev);
     
    993988/*----------------------------------------------------------------------------*/
    994989
    995 bool usb_kbd_polling_callback(usb_hid_dev_t *hid_dev, uint8_t *buffer,
    996      size_t buffer_size)
    997 {
    998         if (hid_dev == NULL || buffer == NULL) {
     990bool usb_kbd_polling_callback(usb_hid_dev_t *hid_dev, void *data,
     991     uint8_t *buffer, size_t buffer_size)
     992{
     993        if (hid_dev == NULL || buffer == NULL || data == NULL) {
    999994                // do not continue polling (???)
    1000995                return false;
    1001996        }
    1002997       
     998        usb_kbd_t *kbd_dev = (usb_kbd_t *)data;
     999        assert(kbd_dev != NULL);
     1000       
    10031001        // TODO: add return value from this function
    1004         usb_kbd_process_data(hid_dev, buffer, buffer_size);
     1002        usb_kbd_process_data(hid_dev, kbd_dev, buffer, buffer_size);
    10051003       
    10061004        return true;
     
    10651063/*----------------------------------------------------------------------------*/
    10661064
    1067 void usb_kbd_deinit(usb_hid_dev_t *hid_dev)
     1065void usb_kbd_deinit(usb_hid_dev_t *hid_dev, void *data)
    10681066{
    10691067        if (hid_dev == NULL) {
     
    10711069        }
    10721070       
    1073         if (hid_dev->data != NULL) {
    1074                 usb_kbd_t *kbd_dev = (usb_kbd_t *)hid_dev->data;
     1071        if (data != NULL) {
     1072                usb_kbd_t *kbd_dev = (usb_kbd_t *)data;
    10751073                if (usb_kbd_is_initialized(kbd_dev)) {
    10761074                        usb_kbd_mark_unusable(kbd_dev);
    10771075                } else {
    10781076                        usb_kbd_free(&kbd_dev);
    1079                         hid_dev->data = NULL;
    10801077                }
    10811078        }
  • uspace/drv/usbhid/kbd/kbddev.h

    r97cb542 r65b458c4  
    8383        int console_phone;
    8484       
     85        /** @todo What is this actually? */
     86        ddf_dev_ops_t ops;
     87       
    8588        /** Information for auto-repeat of keys. */
    8689        usb_kbd_repeat_t repeat;
     
    117120/*----------------------------------------------------------------------------*/
    118121
    119 int usb_kbd_init(struct usb_hid_dev *hid_dev);
     122int usb_kbd_init(struct usb_hid_dev *hid_dev, void **data);
    120123
    121 bool usb_kbd_polling_callback(struct usb_hid_dev *hid_dev, uint8_t *buffer,
    122     size_t buffer_size);
     124bool usb_kbd_polling_callback(struct usb_hid_dev *hid_dev, void *data,
     125                              uint8_t *buffer, size_t buffer_size);
    123126
    124127int usb_kbd_is_initialized(const usb_kbd_t *kbd_dev);
     
    131134    int type, unsigned int key);
    132135
    133 void usb_kbd_deinit(struct usb_hid_dev *hid_dev);
     136void usb_kbd_deinit(struct usb_hid_dev *hid_dev, void *data);
    134137
    135138int usb_kbd_set_boot_protocol(struct usb_hid_dev *hid_dev);
  • uspace/drv/usbhid/mouse/mousedev.c

    r97cb542 r65b458c4  
    122122        sysarg_t method = IPC_GET_IMETHOD(*icall);
    123123       
    124         usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
    125        
    126         if (hid_dev == NULL || hid_dev->data == NULL) {
     124        usb_mouse_t *mouse_dev = (usb_mouse_t *)fun->driver_data;
     125       
     126        if (mouse_dev == NULL) {
    127127                usb_log_debug("default_connection_handler: Missing "
    128128                    "parameters.\n");
     
    131131        }
    132132       
    133         assert(hid_dev != NULL);
    134         assert(hid_dev->data != NULL);
    135         usb_mouse_t *mouse_dev = (usb_mouse_t *)hid_dev->data;
    136        
    137133        int *phone = (str_cmp(fun->name, HID_MOUSE_FUN_NAME) == 0)
    138134                     ? &mouse_dev->mouse_phone : &mouse_dev->wheel_phone;
     
    145141                            "phone to mouse already set.\n");
    146142                        async_answer_0(icallid, ELIMIT);
    147                         //async_answer_0(icallid, EOK);
    148143                        return;
    149144                }
     
    224219/*----------------------------------------------------------------------------*/
    225220
    226 static bool usb_mouse_process_report(usb_hid_dev_t *hid_dev, uint8_t *buffer,
    227     size_t buffer_size)
    228 {
    229         usb_mouse_t *mouse_dev = (usb_mouse_t *)hid_dev->data;
     221static bool usb_mouse_process_report(usb_hid_dev_t *hid_dev,
     222                                     usb_mouse_t *mouse_dev, uint8_t *buffer,
     223                                     size_t buffer_size)
     224{
     225        assert(mouse_dev != NULL);
    230226       
    231227        usb_log_debug2("got buffer: %s.\n",
     
    378374/*----------------------------------------------------------------------------*/
    379375
    380 static int usb_mouse_create_function(usb_hid_dev_t *hid_dev)
    381 {
     376static int usb_mouse_create_function(usb_hid_dev_t *hid_dev, usb_mouse_t *mouse)
     377{
     378        assert(hid_dev != NULL);
     379        assert(mouse != NULL);
     380       
    382381        /* Create the function exposed under /dev/devices. */
    383382        usb_log_debug("Creating DDF function %s...\n", HID_MOUSE_FUN_NAME);
     
    389388        }
    390389       
    391         /*
    392          * Store the initialized HID device and HID ops
    393          * to the DDF function.
    394          */
    395         fun->ops = &hid_dev->ops;
    396         fun->driver_data = hid_dev;   // TODO: maybe change to hid_dev->data
     390        fun->ops = &mouse->ops;
     391        fun->driver_data = mouse;   // TODO: maybe change to hid_dev->data
    397392
    398393        int rc = ddf_fun_bind(fun);
     
    431426         * to the DDF function.
    432427         */
    433         fun->ops = &hid_dev->ops;
     428        fun->ops = &mouse->ops;
    434429        fun->driver_data = hid_dev;   // TODO: maybe change to hid_dev->data
    435430
     
    458453/*----------------------------------------------------------------------------*/
    459454
    460 int usb_mouse_init(usb_hid_dev_t *hid_dev)
     455int usb_mouse_init(usb_hid_dev_t *hid_dev, void **data)
    461456{
    462457        usb_log_debug("Initializing HID/Mouse structure...\n");
     
    485480       
    486481        // save the Mouse device structure into the HID device structure
    487         hid_dev->data = mouse_dev;
     482        *data = mouse_dev;
    488483       
    489484        // set handler for incoming calls
    490         hid_dev->ops.default_handler = default_connection_handler;
     485        // TODO: must be one for each subdriver!!
     486        mouse_dev->ops.default_handler = default_connection_handler;
    491487       
    492488        // TODO: how to know if the device supports the request???
     
    494490//          hid_dev->usb_dev->interface_no, IDLE_RATE);
    495491       
    496         int rc = usb_mouse_create_function(hid_dev);
     492        int rc = usb_mouse_create_function(hid_dev, mouse_dev);
    497493        if (rc != EOK) {
    498494                usb_mouse_free(&mouse_dev);
     
    505501/*----------------------------------------------------------------------------*/
    506502
    507 bool usb_mouse_polling_callback(usb_hid_dev_t *hid_dev, uint8_t *buffer,
    508      size_t buffer_size)
     503bool usb_mouse_polling_callback(usb_hid_dev_t *hid_dev, void *data,
     504     uint8_t *buffer, size_t buffer_size)
    509505{
    510506        usb_log_debug("usb_mouse_polling_callback()\n");
    511507        usb_debug_str_buffer(buffer, buffer_size, 0);
    512508       
    513         if (hid_dev == NULL) {
     509        if (hid_dev == NULL || data == NULL) {
    514510                usb_log_error("Missing argument to the mouse polling callback."
    515511                    "\n");
     
    517513        }
    518514       
    519         if (hid_dev->data == NULL) {
    520                 usb_log_error("Wrong argument to the mouse polling callback."
    521                     "\n");
    522                 return false;
    523         }
    524        
    525         return usb_mouse_process_report(hid_dev, buffer, buffer_size);
    526 }
    527 
    528 /*----------------------------------------------------------------------------*/
    529 
    530 void usb_mouse_deinit(usb_hid_dev_t *hid_dev)
    531 {
    532         usb_mouse_free((usb_mouse_t **)&hid_dev->data);
     515        usb_mouse_t *mouse_dev = (usb_mouse_t *)data;
     516               
     517        return usb_mouse_process_report(hid_dev, mouse_dev, buffer,
     518                                        buffer_size);
     519}
     520
     521/*----------------------------------------------------------------------------*/
     522
     523void usb_mouse_deinit(usb_hid_dev_t *hid_dev, void *data)
     524{
     525        if (data != NULL) {
     526                usb_mouse_free((usb_mouse_t **)&data);
     527        }
    533528}
    534529
  • uspace/drv/usbhid/mouse/mousedev.h

    r97cb542 r65b458c4  
    5252       
    5353        int32_t *buttons;
     54       
     55        ddf_dev_ops_t ops;
    5456} usb_mouse_t;
    5557
     
    6365/*----------------------------------------------------------------------------*/
    6466
    65 int usb_mouse_init(struct usb_hid_dev *hid_dev);
     67int usb_mouse_init(struct usb_hid_dev *hid_dev, void **data);
    6668
    67 bool usb_mouse_polling_callback(struct usb_hid_dev *hid_dev, uint8_t *buffer,
    68     size_t buffer_size);
     69bool usb_mouse_polling_callback(struct usb_hid_dev *hid_dev, void *data,
     70    uint8_t *buffer, size_t buffer_size);
    6971
    70 void usb_mouse_deinit(struct usb_hid_dev *hid_dev);
     72void usb_mouse_deinit(struct usb_hid_dev *hid_dev, void *data);
    7173
    7274int usb_mouse_set_boot_protocol(struct usb_hid_dev *hid_dev);
  • uspace/drv/usbhid/multimedia/multimedia.c

    r97cb542 r65b458c4  
    8787        sysarg_t method = IPC_GET_IMETHOD(*icall);
    8888       
    89         usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
    90        
    91         if (hid_dev == NULL || hid_dev->data == NULL) {
     89        usb_multimedia_t *multim_dev = (usb_multimedia_t *)fun->driver_data;
     90        //usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
     91       
     92        if (multim_dev == NULL) {
    9293                async_answer_0(icallid, EINVAL);
    9394                return;
    9495        }
    95        
    96         assert(hid_dev != NULL);
    97         assert(hid_dev->data != NULL);
    98         usb_multimedia_t *multim_dev = (usb_multimedia_t *)hid_dev->data;
    9996
    10097        if (method == IPC_M_CONNECT_TO_ME) {
     
    139136 * @param key Key code of the key according to HID Usage Tables.
    140137 */
    141 static void usb_multimedia_push_ev(usb_hid_dev_t *hid_dev, int type,
    142     unsigned int key)
     138static void usb_multimedia_push_ev(usb_hid_dev_t *hid_dev,
     139    usb_multimedia_t *multim_dev, int type, unsigned int key)
    143140{
    144141        assert(hid_dev != NULL);
    145         assert(hid_dev->data != NULL);
    146        
    147         usb_multimedia_t *multim_dev = (usb_multimedia_t *)hid_dev->data;
     142        assert(multim_dev != NULL);
     143       
     144//      usb_multimedia_t *multim_dev = (usb_multimedia_t *)hid_dev->data;
    148145       
    149146        console_event_t ev;
     
    190187/*----------------------------------------------------------------------------*/
    191188
    192 static int usb_multimedia_create_function(usb_hid_dev_t *hid_dev)
     189static int usb_multimedia_create_function(usb_hid_dev_t *hid_dev,
     190    usb_multimedia_t *multim_dev)
    193191{
    194192        /* Create the function exposed under /dev/devices. */
     
    200198        }
    201199       
    202         /*
    203          * Store the initialized HID device and HID ops
    204          * to the DDF function.
    205          */
    206200        fun->ops = &multimedia_ops;
    207         fun->driver_data = hid_dev;   // TODO: maybe change to hid_dev->data
     201        fun->driver_data = multim_dev;   // TODO: maybe change to hid_dev->data
    208202       
    209203        int rc = ddf_fun_bind(fun);
     
    231225/*----------------------------------------------------------------------------*/
    232226
    233 int usb_multimedia_init(struct usb_hid_dev *hid_dev)
     227int usb_multimedia_init(struct usb_hid_dev *hid_dev, void **data)
    234228{
    235229        if (hid_dev == NULL || hid_dev->usb_dev == NULL) {
     
    282276       
    283277        // save the KBD device structure into the HID device structure
    284         hid_dev->data = multim_dev;
     278        *data = multim_dev;
    285279       
    286280        usb_log_debug(NAME " HID/multimedia device structure initialized.\n");
    287281       
    288         int rc = usb_multimedia_create_function(hid_dev);
     282        int rc = usb_multimedia_create_function(hid_dev, multim_dev);
    289283        if (rc != EOK) {
    290284                usb_multimedia_free(&multim_dev);
     
    299293/*----------------------------------------------------------------------------*/
    300294
    301 void usb_multimedia_deinit(struct usb_hid_dev *hid_dev)
     295void usb_multimedia_deinit(struct usb_hid_dev *hid_dev, void *data)
    302296{
    303297        if (hid_dev == NULL) {
     
    305299        }
    306300       
    307         if (hid_dev->data != NULL) {
    308                 usb_multimedia_t *multim_dev =
    309                     (usb_multimedia_t *)hid_dev->data;
     301        if (data != NULL) {
     302                usb_multimedia_t *multim_dev = (usb_multimedia_t *)data;
    310303                usb_multimedia_free(&multim_dev);
    311                 hid_dev->data = NULL;
    312         }
    313 }
    314 
    315 /*----------------------------------------------------------------------------*/
    316 
    317 bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev,
     304        }
     305}
     306
     307/*----------------------------------------------------------------------------*/
     308
     309bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data,
    318310    uint8_t *buffer, size_t buffer_size)
    319311{
     
    322314        usb_log_debug(NAME " usb_lgtch_polling_callback(%p, %p, %zu)\n",
    323315            hid_dev, buffer, buffer_size);
     316       
     317        if (data == NULL) {
     318                return EINVAL;  // TODO: other error code?
     319        }
     320       
     321        usb_multimedia_t *multim_dev = (usb_multimedia_t *)data;
    324322
    325323        usb_log_debug(NAME " Calling usb_hid_parse_report() with "
     
    361359                            usb_multimedia_usage_to_str(field->usage);
    362360                        usb_log_info("Pressed key: %s\n", key_str);
    363                         usb_multimedia_push_ev(hid_dev, KEY_PRESS, key);
     361                        usb_multimedia_push_ev(hid_dev, multim_dev, KEY_PRESS,
     362                                               key);
    364363                }
    365364               
  • uspace/drv/usbhid/multimedia/multimedia.h

    r97cb542 r65b458c4  
    4343/*----------------------------------------------------------------------------*/
    4444
    45 int usb_multimedia_init(struct usb_hid_dev *hid_dev);
     45int usb_multimedia_init(struct usb_hid_dev *hid_dev, void **data);
    4646
    47 void usb_multimedia_deinit(struct usb_hid_dev *hid_dev);
     47void usb_multimedia_deinit(struct usb_hid_dev *hid_dev, void *data);
    4848
    49 bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev,
     49bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data,
    5050    uint8_t *buffer, size_t buffer_size);
    5151
  • uspace/drv/usbhid/subdrivers.c

    r97cb542 r65b458c4  
    9999                }
    100100        },
    101         {NULL, -1, 0, -1, -1, {NULL, NULL, NULL, NULL}}
     101        {NULL, -1, 0, -1, -1, {NULL, NULL, NULL, NULL, NULL}}
    102102};
    103103
  • uspace/drv/usbhid/usbhid.c

    r97cb542 r65b458c4  
    466466                        if (hid_dev->subdrivers[i].init != NULL) {
    467467                                usb_log_debug("Initializing subdriver %d.\n",i);
    468                                 rc = hid_dev->subdrivers[i].init(hid_dev);
     468                                rc = hid_dev->subdrivers[i].init(hid_dev,
     469                                    &hid_dev->subdrivers[i].data);
    469470                                if (rc != EOK) {
    470471                                        usb_log_warning("Failed to initialize"
     
    531532        for (i = 0; i < hid_dev->subdriver_count; ++i) {
    532533                if (hid_dev->subdrivers[i].poll != NULL
    533                     && hid_dev->subdrivers[i].poll(hid_dev, buffer,
    534                     buffer_size)) {
     534                    && hid_dev->subdrivers[i].poll(hid_dev,
     535                        hid_dev->subdrivers[i].data, buffer, buffer_size)) {
    535536                        cont = true;
    536537                }
     
    555556        for (i = 0; i < hid_dev->subdriver_count; ++i) {
    556557                if (hid_dev->subdrivers[i].poll_end != NULL) {
    557                         hid_dev->subdrivers[i].poll_end(hid_dev, reason);
     558                        hid_dev->subdrivers[i].poll_end(hid_dev,
     559                            hid_dev->subdrivers[i].data, reason);
    558560                }
    559561        }
     
    636638        for (i = 0; i < (*hid_dev)->subdriver_count; ++i) {
    637639                if ((*hid_dev)->subdrivers[i].deinit != NULL) {
    638                         (*hid_dev)->subdrivers[i].deinit(*hid_dev);
     640                        (*hid_dev)->subdrivers[i].deinit(*hid_dev,
     641                            (*hid_dev)->subdrivers[i].data);
    639642                }
    640643        }
  • uspace/drv/usbhid/usbhid.h

    r97cb542 r65b458c4  
    4848struct usb_hid_dev;
    4949
    50 typedef int (*usb_hid_driver_init_t)(struct usb_hid_dev *);
    51 typedef void (*usb_hid_driver_deinit_t)(struct usb_hid_dev *);
    52 typedef bool (*usb_hid_driver_poll)(struct usb_hid_dev *, uint8_t *, size_t);
    53 typedef int (*usb_hid_driver_poll_ended)(struct usb_hid_dev *, bool reason);
     50typedef int (*usb_hid_driver_init_t)(struct usb_hid_dev *, void **data);
     51typedef void (*usb_hid_driver_deinit_t)(struct usb_hid_dev *, void *data);
     52typedef bool (*usb_hid_driver_poll)(struct usb_hid_dev *, void *data, uint8_t *,
     53                                    size_t);
     54typedef int (*usb_hid_driver_poll_ended)(struct usb_hid_dev *, void *data,
     55                                         bool reason);
    5456
    5557// TODO: add function and class name??
     
    6365        /** Function to be called when polling ends. */
    6466        usb_hid_driver_poll_ended poll_end;
     67        /** Arbitrary data needed by the subdriver. */
     68        void *data;
    6569} usb_hid_subdriver_t;
    6670
     
    7276        /** Structure holding generic USB device information. */
    7377        usb_device_t *usb_dev;
    74        
    75         /** @todo What is this actually? */
    76         ddf_dev_ops_t ops;
    7778       
    7879        /** Index of the polling pipe in usb_hid_endpoints array. */
     
    9798       
    9899        size_t input_report_size;
    99        
    100         /** Arbitrary data (e.g. a special structure for handling keyboard). */
    101         void *data;
    102100} usb_hid_dev_t;
    103101
Note: See TracChangeset for help on using the changeset viewer.