Changeset cc29622 in mainline


Ignore:
Timestamp:
2011-10-14T12:40:31Z (12 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
e5024111
Parents:
3002434
Message:

usbhid: Remove tabs on empty lines. diff -w shows no changes.

Location:
uspace/drv/bus/usb/usbhid
Files:
11 edited

Legend:

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

    r3002434 rcc29622  
    9292        usb_log_debug2("Generic HID: Get event length (fun: %p, "
    9393            "fun->driver_data: %p.\n", fun, fun->driver_data);
    94        
     94
    9595        if (fun == NULL || fun->driver_data == NULL) {
    9696                return 0;
     
    9898
    9999        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
    100        
     100
    101101        usb_log_debug2("hid_dev: %p, Max input report size (%zu).\n",
    102102            hid_dev, hid_dev->max_input_report_size);
    103        
     103
    104104        return hid_dev->max_input_report_size;
    105105}
     
    111111{
    112112        usb_log_debug2("Generic HID: Get event.\n");
    113        
     113
    114114        if (fun == NULL || fun->driver_data == NULL || buffer == NULL
    115115            || act_size == NULL || event_nr == NULL) {
     
    119119
    120120        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
    121        
     121
    122122        if (hid_dev->input_report_size > size) {
    123123                usb_log_debug("input_report_size > size (%zu, %zu)\n",
     
    125125                return EINVAL;  // TODO: other error code
    126126        }
    127        
     127
    128128        /*! @todo This should probably be somehow atomic. */
    129129        memcpy(buffer, hid_dev->input_report,
     
    131131        *act_size = hid_dev->input_report_size;
    132132        *event_nr = usb_hid_report_number(hid_dev);
    133        
     133
    134134        usb_log_debug2("OK\n");
    135        
     135
    136136        return EOK;
    137137}
     
    142142{
    143143        usb_log_debug("Generic HID: Get report descriptor length.\n");
    144        
     144
    145145        if (fun == NULL || fun->driver_data == NULL) {
    146146                usb_log_debug("No function");
    147147                return EINVAL;
    148148        }
    149        
    150         usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
    151        
     149
     150        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
     151
    152152        usb_log_debug2("hid_dev->report_desc_size = %zu\n",
    153153            hid_dev->report_desc_size);
    154        
     154
    155155        return hid_dev->report_desc_size;
    156156}
     
    162162{
    163163        usb_log_debug2("Generic HID: Get report descriptor.\n");
    164        
     164
    165165        if (fun == NULL || fun->driver_data == NULL) {
    166166                usb_log_debug("No function");
    167167                return EINVAL;
    168168        }
    169        
    170         usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
    171        
     169
     170        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
     171
    172172        if (hid_dev->report_desc_size > size) {
    173173                return EINVAL;
    174174        }
    175        
     175
    176176        memcpy(desc, hid_dev->report_desc, hid_dev->report_desc_size);
    177177        *actual_size = hid_dev->report_desc_size;
    178        
     178
    179179        return EOK;
    180180}
     
    201201                return ENOMEM;
    202202        }
    203        
     203
    204204        fun->ops = &usb_generic_hid_ops;
    205205        fun->driver_data = hid_dev;
     
    212212                return rc;
    213213        }
    214        
     214
    215215        usb_log_debug("HID function created. Handle: %" PRIun "\n", fun->handle);
    216        
     216
    217217        return EOK;
    218218}
     
    225225                return EINVAL;
    226226        }
    227        
     227
    228228        return usb_generic_hid_create_function(hid_dev);
    229229}
  • uspace/drv/bus/usb/usbhid/kbd/conv.c

    r3002434 rcc29622  
    8787        [0x26] = KC_9,
    8888        [0x27] = KC_0,
    89        
     89
    9090        [0x28] = KC_ENTER,
    9191        [0x29] = KC_ESCAPE,
     
    109109
    110110        [0x39] = KC_CAPS_LOCK,
    111        
     111
    112112        [0x3a] = KC_F1,
    113113        [0x3b] = KC_F2,
     
    122122        [0x44] = KC_F11,
    123123        [0x45] = KC_F12,
    124        
     124
    125125        [0x46] = KC_PRTSCR,
    126126        [0x47] = KC_SCROLL_LOCK,
     
    136136        [0x51] = KC_DOWN,
    137137        [0x52] = KC_UP,
    138        
     138
    139139        //[0x64] = // some funny key
    140        
     140
    141141        [0xe0] = KC_LCTRL,
    142142        [0xe1] = KC_LSHIFT,
     
    147147        [0xe6] = KC_RALT,
    148148        //[0xe7] = KC_R // TODO: right GUI
    149        
     149
    150150        [0x53] = KC_NUM_LOCK,
    151151        [0x54] = KC_NSLASH,
     
    165165        [0x62] = KC_N0,
    166166        [0x63] = KC_NPERIOD
    167        
     167
    168168};
    169169
     
    186186
    187187        key = map[scancode];
    188        
     188
    189189        return key;
    190190}
  • uspace/drv/bus/usb/usbhid/kbd/kbddev.c

    r3002434 rcc29622  
    174174{
    175175        sysarg_t method = IPC_GET_IMETHOD(*icall);
    176        
     176
    177177        usb_kbd_t *kbd_dev = (usb_kbd_t *) fun->driver_data;
    178178        if (kbd_dev == NULL) {
     
    182182                return;
    183183        }
    184        
     184
    185185        async_sess_t *sess =
    186186            async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
     
    240240            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
    241241            USB_HID_REPORT_TYPE_OUTPUT);
    242        
     242
    243243        while (field != NULL) {
    244244               
     
    263263                        USB_HID_REPORT_TYPE_OUTPUT);
    264264        }
    265        
     265
    266266        // TODO: what about the Report ID?
    267267        int rc = usb_hid_report_output_translate(hid_dev->report, 0,
    268268            kbd_dev->output_buffer, kbd_dev->output_size);
    269        
     269
    270270        if (rc != EOK) {
    271271                usb_log_warning("Error translating LED output to output report"
     
    273273                return;
    274274        }
    275        
     275
    276276        usb_log_debug("Output report buffer: %s\n",
    277277            usb_debug_str_buffer(kbd_dev->output_buffer, kbd_dev->output_size,
    278278                0));
    279        
     279
    280280        usbhid_req_set_report(&hid_dev->usb_dev->ctrl_pipe,
    281281            hid_dev->usb_dev->interface_no, USB_HID_REPORT_TYPE_OUTPUT,
     
    300300                return;
    301301        }
    302        
     302
    303303        async_exch_t *exch = async_exchange_begin(kbd_dev->console_sess);
    304304        async_msg_2(exch, KBDEV_EVENT, type, key);
     
    347347        unsigned int key;
    348348        size_t i;
    349        
     349
    350350        /*
    351351         * First of all, check if the kbd have reported phantom state.
     
    362362                return;
    363363        }
    364        
     364
    365365        /*
    366366         * Key releases
     
    382382                }
    383383        }
    384        
     384
    385385        /*
    386386         * Key presses
     
    402402                }
    403403        }
    404        
     404
    405405        memcpy(kbd_dev->keys_old, kbd_dev->keys, kbd_dev->key_count * 4);
    406        
     406
    407407        char key_buffer[512];
    408408        ddf_dump_buffer(key_buffer, 512,
     
    435435        assert(hid_dev != NULL);
    436436        assert(kbd_dev != NULL);
    437        
     437
    438438        usb_hid_report_path_t *path = usb_hid_report_path();
    439439        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
    440440
    441441        usb_hid_report_path_set_report_id (path, hid_dev->report_id);
    442        
     442
    443443        // fill in the currently pressed keys
    444        
     444
    445445        usb_hid_report_field_t *field = usb_hid_report_get_sibling(
    446446            hid_dev->report, NULL, path,
     
    448448            USB_HID_REPORT_TYPE_INPUT);
    449449        unsigned i = 0;
    450        
     450
    451451        while (field != NULL) {
    452452                usb_log_debug2("FIELD (%p) - VALUE(%d) USAGE(%u)\n",
     
    470470                    USB_HID_REPORT_TYPE_INPUT);
    471471        }
    472        
     472
    473473        usb_hid_report_path_free(path);
    474        
     474
    475475        usb_kbd_check_key_changes(hid_dev, kbd_dev);
    476476}
     
    505505                return NULL;
    506506        }
    507        
     507
    508508        kbd_dev->console_sess = NULL;
    509509        kbd_dev->initialized = USB_KBD_STATUS_UNINITIALIZED;
    510        
     510
    511511        return kbd_dev;
    512512}
     
    519519        assert(hid_dev->usb_dev != NULL);
    520520        assert(kbd_dev != NULL);
    521        
     521
    522522        /* Create the exposed function. */
    523523        usb_log_debug("Creating DDF function %s...\n", HID_KBD_FUN_NAME);
     
    528528                return ENOMEM;
    529529        }
    530        
     530
    531531        /*
    532532         * Store the initialized HID device and HID ops
     
    543543                return rc;
    544544        }
    545        
     545
    546546        usb_log_debug("%s function created. Handle: %" PRIun "\n",
    547547            HID_KBD_FUN_NAME, fun->handle);
    548        
     548
    549549        usb_log_debug("Adding DDF function to category %s...\n",
    550550            HID_KBD_CLASS_NAME);
     
    557557                return rc;
    558558        }
    559        
     559
    560560        return EOK;
    561561}
     
    587587{
    588588        usb_log_debug("Initializing HID/KBD structure...\n");
    589        
     589
    590590        if (hid_dev == NULL) {
    591591                usb_log_error("Failed to init keyboard structure: no structure"
     
    593593                return EINVAL;
    594594        }
    595        
     595
    596596        usb_kbd_t *kbd_dev = usb_kbd_new();
    597597        if (kbd_dev == NULL) {
     
    603603        /* Store link to HID device */
    604604        kbd_dev->hid_dev = hid_dev;
    605        
     605
    606606        /*
    607607         * TODO: make more general
     
    609609        usb_hid_report_path_t *path = usb_hid_report_path();
    610610        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
    611        
     611
    612612        usb_hid_report_path_set_report_id(path, 0);
    613        
     613
    614614        kbd_dev->key_count = usb_hid_report_size(
    615615            hid_dev->report, 0, USB_HID_REPORT_TYPE_INPUT);
    616616        usb_hid_report_path_free(path);
    617        
     617
    618618        usb_log_debug("Size of the input report: %zu\n", kbd_dev->key_count);
    619        
     619
    620620        kbd_dev->keys = (int32_t *)calloc(kbd_dev->key_count, sizeof(int32_t));
    621        
     621
    622622        if (kbd_dev->keys == NULL) {
    623623                usb_log_fatal("No memory!\n");
     
    625625                return ENOMEM;
    626626        }
    627        
     627
    628628        kbd_dev->keys_old =
    629629                (int32_t *)calloc(kbd_dev->key_count, sizeof(int32_t));
    630        
     630
    631631        if (kbd_dev->keys_old == NULL) {
    632632                usb_log_fatal("No memory!\n");
     
    635635                return ENOMEM;
    636636        }
    637        
     637
    638638        /*
    639639         * Output report
     
    647647                return ENOMEM;
    648648        }
    649        
     649
    650650        usb_log_debug("Output buffer size: %zu\n", kbd_dev->output_size);
    651        
     651
    652652        kbd_dev->led_path = usb_hid_report_path();
    653653        usb_hid_report_path_append_item(
    654654            kbd_dev->led_path, USB_HIDUT_PAGE_LED, 0);
    655        
     655
    656656        kbd_dev->led_output_size = usb_hid_report_size(hid_dev->report,
    657657            0, USB_HID_REPORT_TYPE_OUTPUT);
    658        
     658
    659659        usb_log_debug("Output report size (in items): %zu\n",
    660660            kbd_dev->led_output_size);
    661        
     661
    662662        kbd_dev->led_data = (int32_t *)calloc(
    663663            kbd_dev->led_output_size, sizeof(int32_t));
    664        
     664
    665665        if (kbd_dev->led_data == NULL) {
    666666                usb_log_warning("Error creating buffer for LED output report."
     
    671671                return ENOMEM;
    672672        }
    673        
     673
    674674        /*
    675675         * Modifiers and locks
     
    678678        kbd_dev->mods = DEFAULT_ACTIVE_MODS;
    679679        kbd_dev->lock_keys = 0;
    680        
     680
    681681        /*
    682682         * Autorepeat
     
    686686        kbd_dev->repeat.delay_before = DEFAULT_DELAY_BEFORE_FIRST_REPEAT;
    687687        kbd_dev->repeat.delay_between = DEFAULT_REPEAT_DELAY;
    688        
     688
    689689        kbd_dev->repeat_mtx = (fibril_mutex_t *)(
    690690            malloc(sizeof(fibril_mutex_t)));
     
    696696                return ENOMEM;
    697697        }
    698        
     698
    699699        fibril_mutex_initialize(kbd_dev->repeat_mtx);
    700        
     700
    701701        // save the KBD device structure into the HID device structure
    702702        *data = kbd_dev;
    703        
     703
    704704        // set handler for incoming calls
    705705        kbd_dev->ops.default_handler = default_connection_handler;
    706        
     706
    707707        /*
    708708         * Set LEDs according to initial setup.
     
    710710         */
    711711        usb_kbd_set_led(hid_dev, kbd_dev);
    712        
     712
    713713        usbhid_req_set_idle(&hid_dev->usb_dev->ctrl_pipe,
    714714            hid_dev->usb_dev->interface_no, IDLE_RATE);
    715        
     715
    716716        /*
    717717         * Create new fibril for auto-repeat
     
    723723        }
    724724        fibril_add_ready(fid);
    725        
     725
    726726        kbd_dev->initialized = USB_KBD_STATUS_INITIALIZED;
    727727        usb_log_debug("HID/KBD device structure initialized.\n");
    728        
     728
    729729        usb_log_debug("Creating KBD function...\n");
    730730        int rc = usb_kbd_create_function(hid_dev, kbd_dev);
     
    733733                return rc;
    734734        }
    735        
     735
    736736        return EOK;
    737737}
     
    745745                return false;
    746746        }
    747        
     747
    748748        usb_kbd_t *kbd_dev = (usb_kbd_t *)data;
    749749        assert(kbd_dev != NULL);
    750        
     750
    751751        // TODO: add return value from this function
    752752        usb_kbd_process_data(hid_dev, kbd_dev);
    753        
     753
    754754        return true;
    755755}
     
    780780                return;
    781781        }
    782        
     782
    783783        // hangup session to the console
    784784        async_hangup(kbd_dev->console_sess);
    785        
     785
    786786        if (kbd_dev->repeat_mtx != NULL) {
    787787                //assert(!fibril_mutex_is_locked((*kbd_dev)->repeat_mtx));
     
    791791                free(kbd_dev->repeat_mtx);
    792792        }
    793        
     793
    794794        // free all buffers
    795795        if (kbd_dev->keys != NULL) {
     
    817817                return;
    818818        }
    819        
     819
    820820        if (data != NULL) {
    821821                usb_kbd_t *kbd_dev = (usb_kbd_t *)data;
     
    835835            USB_KBD_BOOT_REPORT_DESCRIPTOR,
    836836            USB_KBD_BOOT_REPORT_DESCRIPTOR_SIZE);
    837        
     837
    838838        if (rc != EOK) {
    839839                usb_log_error("Failed to parse boot report descriptor: %s\n",
     
    841841                return rc;
    842842        }
    843        
     843
    844844        rc = usbhid_req_set_protocol(&hid_dev->usb_dev->ctrl_pipe,
    845845            hid_dev->usb_dev->interface_no, USB_HID_PROTOCOL_BOOT);
    846        
     846
    847847        if (rc != EOK) {
    848848                usb_log_warning("Failed to set boot protocol to the device: "
     
    850850                return rc;
    851851        }
    852        
     852
    853853        return EOK;
    854854}
  • uspace/drv/bus/usb/usbhid/kbd/kbddev.h

    r3002434 rcc29622  
    7575        /** Currently pressed modifiers (bitmap). */
    7676        uint8_t modifiers;
    77        
     77
    7878        /** Currently active modifiers including locks. Sent to the console. */
    7979        unsigned mods;
    80        
     80
    8181        /** Currently active lock keys. */
    8282        unsigned lock_keys;
    83        
     83
    8484        /** IPC session to the console device (for sending key events). */
    8585        async_sess_t *console_sess;
    86        
     86
    8787        /** @todo What is this actually? */
    8888        ddf_dev_ops_t ops;
    89        
     89
    9090        /** Information for auto-repeat of keys. */
    9191        usb_kbd_repeat_t repeat;
    92        
     92
    9393        /** Mutex for accessing the information about auto-repeat. */
    9494        fibril_mutex_t *repeat_mtx;
    95        
     95
    9696        uint8_t *output_buffer;
    97        
     97
    9898        size_t output_size;
    99        
     99
    100100        size_t led_output_size;
    101        
     101
    102102        usb_hid_report_path_t *led_path;
    103        
     103
    104104        int32_t *led_data;
    105        
     105
    106106        /** State of the structure (for checking before use).
    107107         *
  • uspace/drv/bus/usb/usbhid/kbd/kbdrepeat.c

    r3002434 rcc29622  
    7373{
    7474        unsigned int delay = 0;
    75        
     75
    7676        usb_log_debug("Starting autorepeat loop.\n");
    7777
     
    130130{
    131131        usb_log_debug("Autorepeat fibril spawned.\n");
    132        
     132
    133133        if (arg == NULL) {
    134134                usb_log_error("No device!\n");
    135135                return EINVAL;
    136136        }
    137        
     137
    138138        usb_kbd_t *kbd = (usb_kbd_t *)arg;
    139        
     139
    140140        usb_kbd_repeat_loop(kbd);
    141        
     141
    142142        return EOK;
    143143}
  • uspace/drv/bus/usb/usbhid/main.c

    r3002434 rcc29622  
    7676{
    7777        assert(dev != NULL);
    78        
     78
    7979        /*
    8080         * Initialize device (get and process descriptors, get address, etc.)
    8181         */
    8282        usb_log_debug("Initializing USB/HID device...\n");
    83        
     83
    8484        usb_hid_dev_t *hid_dev = usb_hid_new();
    8585        if (hid_dev == NULL) {
     
    8888                return ENOMEM;
    8989        }
    90        
     90
    9191        int rc = usb_hid_init(hid_dev, dev);
    92        
     92
    9393        if (rc != EOK) {
    9494                usb_log_error("Failed to initialize USB/HID device.\n");
     
    9696                return rc;
    9797        }       
    98        
     98
    9999        usb_log_debug("USB/HID device structure initialized.\n");
    100        
     100
    101101        /*
    102102         * 1) subdriver vytvori vlastnu ddf_fun, vlastne ddf_dev_ops, ktore da
     
    109109         *    pouzit usb/classes/hid/iface.h - prvy int je telefon
    110110         */
    111        
     111
    112112        /* Start automated polling function.
    113113         * This will create a separate fibril that will query the device
     
    125125           /* Custom argument. */
    126126           hid_dev);
    127        
    128        
     127
     128
    129129        if (rc != EOK) {
    130130                usb_log_error("Failed to start polling fibril for `%s'.\n",
     
    153153{
    154154        usb_log_debug("usb_hid_device_add()\n");
    155        
     155
    156156        if (dev == NULL) {
    157157                usb_log_warning("Wrong parameter given for add_device().\n");
    158158                return EINVAL;
    159159        }
    160        
     160
    161161        if (dev->interface_no < 0) {
    162162                usb_log_warning("Device is not a supported HID device.\n");
     
    165165                return ENOTSUP;
    166166        }
    167        
     167
    168168        int rc = usb_hid_try_add_device(dev);
    169        
     169
    170170        if (rc != EOK) {
    171171                usb_log_warning("Device is not a supported HID device.\n");
     
    174174                return rc;
    175175        }
    176        
     176
    177177        usb_log_info("HID device `%s' ready to use.\n", dev->ddf_dev->name);
    178178
  • uspace/drv/bus/usb/usbhid/mouse/mousedev.c

    r3002434 rcc29622  
    124124{
    125125        usb_mouse_t *mouse_dev = (usb_mouse_t *) fun->driver_data;
    126        
     126
    127127        if (mouse_dev == NULL) {
    128128                usb_log_debug("default_connection_handler: Missing "
     
    131131                return;
    132132        }
    133        
     133
    134134        usb_log_debug("default_connection_handler: fun->name: %s\n",
    135135                      fun->name);
    136136        usb_log_debug("default_connection_handler: mouse_sess: %p, "
    137137            "wheel_sess: %p\n", mouse_dev->mouse_sess, mouse_dev->wheel_sess);
    138        
     138
    139139        async_sess_t **sess_ptr =
    140140            (str_cmp(fun->name, HID_MOUSE_FUN_NAME) == 0) ?
    141141            &mouse_dev->mouse_sess : &mouse_dev->wheel_sess;
    142        
     142
    143143        async_sess_t *sess =
    144144            async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
     
    170170        mouse->mouse_sess = NULL;
    171171        mouse->wheel_sess = NULL;
    172        
     172
    173173        return mouse;
    174174}
     
    179179{
    180180        assert(mouse_dev != NULL);
    181        
     181
    182182        // hangup session to the console
    183183        if (mouse_dev->mouse_sess != NULL)
    184184                async_hangup(mouse_dev->mouse_sess);
    185        
     185
    186186        if (mouse_dev->wheel_sess != NULL)
    187187                async_hangup(mouse_dev->wheel_sess);
     
    199199                return;
    200200        }
    201        
     201
    202202        int count = ((wheel < 0) ? -wheel : wheel) * ARROWS_PER_SINGLE_WHEEL;
    203203        int i;
    204        
     204
    205205        for (i = 0; i < count; i++) {
    206206                /* Send arrow press and release. */
     
    246246{
    247247        assert(mouse_dev != NULL);
    248        
     248
    249249        if (mouse_dev->mouse_sess == NULL) {
    250250                usb_log_warning(NAME " No console session.\n");
     
    264264                async_exchange_end(exch);
    265265        }
    266        
     266
    267267        if (wheel != 0)
    268268                usb_mouse_send_wheel(mouse_dev, wheel);
    269        
     269
    270270        /*
    271271         * Buttons
     
    274274        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_BUTTON, 0);
    275275        usb_hid_report_path_set_report_id(path, hid_dev->report_id);
    276        
     276
    277277        usb_hid_report_field_t *field = usb_hid_report_get_sibling(
    278278            hid_dev->report, NULL, path, USB_HID_PATH_COMPARE_END
     
    309309                    USB_HID_REPORT_TYPE_INPUT);
    310310        }
    311        
     311
    312312        usb_hid_report_path_free(path);
    313313
     
    321321        assert(hid_dev != NULL);
    322322        assert(mouse != NULL);
    323        
     323
    324324        /* Create the exposed function. */
    325325        usb_log_debug("Creating DDF function %s...\n", HID_MOUSE_FUN_NAME);
     
    330330                return ENOMEM;
    331331        }
    332        
     332
    333333        fun->ops = &mouse->ops;
    334334        fun->driver_data = mouse;
     
    341341                return rc;
    342342        }
    343        
     343
    344344        usb_log_debug("Adding DDF function to category %s...\n",
    345345            HID_MOUSE_CATEGORY);
     
    352352                return rc;
    353353        }
    354        
     354
    355355        /*
    356356         * Special function for acting as keyboard (wheel)
     
    364364                return ENOMEM;
    365365        }
    366        
     366
    367367        /*
    368368         * Store the initialized HID device and HID ops
     
    379379                return rc;
    380380        }
    381        
     381
    382382        usb_log_debug("Adding DDF function to category %s...\n",
    383383            HID_MOUSE_WHEEL_CATEGORY);
     
    390390                return rc;
    391391        }
    392        
     392
    393393        return EOK;
    394394}
     
    441441{
    442442        usb_log_debug("Initializing HID/Mouse structure...\n");
    443        
     443
    444444        if (hid_dev == NULL) {
    445445                usb_log_error("Failed to init keyboard structure: no structure"
     
    447447                return EINVAL;
    448448        }
    449        
     449
    450450        usb_mouse_t *mouse_dev = usb_mouse_new();
    451451        if (mouse_dev == NULL) {
     
    454454                return ENOMEM;
    455455        }
    456        
     456
    457457        // FIXME: This may not be optimal since stupid hardware vendor may
    458458        // use buttons 1, 2, 3 and 6000 and we would allocate array of
     
    464464            hid_dev->report_id) + 1;
    465465        mouse_dev->buttons = calloc(mouse_dev->buttons_count, sizeof(int32_t));
    466        
     466
    467467        if (mouse_dev->buttons == NULL) {
    468468                usb_log_error(NAME ": out of memory, giving up on device!\n");
     
    474474        // save the Mouse device structure into the HID device structure
    475475        *data = mouse_dev;
    476        
     476
    477477        // set handler for incoming calls
    478478        mouse_dev->ops.default_handler = default_connection_handler;
    479        
     479
    480480        // TODO: how to know if the device supports the request???
    481481        usbhid_req_set_idle(&hid_dev->usb_dev->ctrl_pipe,
    482482            hid_dev->usb_dev->interface_no, IDLE_RATE);
    483        
     483
    484484        int rc = usb_mouse_create_function(hid_dev, mouse_dev);
    485485        if (rc != EOK) {
     
    487487                return rc;
    488488        }
    489        
     489
    490490        return EOK;
    491491}
     
    500500                return false;
    501501        }
    502        
     502
    503503        usb_mouse_t *mouse_dev = (usb_mouse_t *)data;
    504504               
     
    522522            USB_MOUSE_BOOT_REPORT_DESCRIPTOR,
    523523            USB_MOUSE_BOOT_REPORT_DESCRIPTOR_SIZE);
    524        
     524
    525525        if (rc != EOK) {
    526526                usb_log_error("Failed to parse boot report descriptor: %s\n",
     
    528528                return rc;
    529529        }
    530        
     530
    531531        rc = usbhid_req_set_protocol(&hid_dev->usb_dev->ctrl_pipe,
    532532            hid_dev->usb_dev->interface_no, USB_HID_PROTOCOL_BOOT);
    533        
     533
    534534        if (rc != EOK) {
    535535                usb_log_warning("Failed to set boot protocol to the device: "
     
    537537                return rc;
    538538        }
    539        
     539
    540540        return EOK;
    541541}
  • uspace/drv/bus/usb/usbhid/mouse/mousedev.h

    r3002434 rcc29622  
    4949        async_sess_t *mouse_sess;
    5050        async_sess_t *wheel_sess;
    51        
     51
    5252        /* Mouse buttons statuses. */
    5353        int32_t *buttons;
    5454        size_t buttons_count;
    55        
     55
    5656        ddf_dev_ops_t ops;
    5757} usb_mouse_t;
  • uspace/drv/bus/usb/usbhid/subdrivers.h

    r3002434 rcc29622  
    6464         */
    6565        const usb_hid_subdriver_usage_t *usage_path;
    66        
     66
    6767        /** Report ID for which the path should apply. */
    6868        int report_id;
    69        
     69
    7070        /** Compare type for the Usage path. */
    7171        int compare;
    72        
     72
    7373        /** Vendor ID (set to -1 if not specified). */
    7474        int vendor_id;
    75        
     75
    7676        /** Product ID (set to -1 if not specified). */
    7777        int product_id;
    78        
     78
    7979        /** Subdriver for controlling this device. */
    8080        usb_hid_subdriver_t subdriver;
  • uspace/drv/bus/usb/usbhid/usbhid.c

    r3002434 rcc29622  
    6868{
    6969        assert(hid_dev != NULL && hid_dev->subdriver_count == 0);
    70        
     70
    7171        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(
    7272            sizeof(usb_hid_subdriver_t));
     
    7474                return ENOMEM;
    7575        }
    76        
     76
    7777        assert(hid_dev->subdriver_count >= 0);
    78        
     78
    7979        // set the init callback
    8080        hid_dev->subdrivers[hid_dev->subdriver_count].init = usb_kbd_init;
    81        
     81
    8282        // set the polling callback
    8383        hid_dev->subdrivers[hid_dev->subdriver_count].poll =
    8484            usb_kbd_polling_callback;
    85        
     85
    8686        // set the polling ended callback
    8787        hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
    88        
     88
    8989        // set the deinit callback
    9090        hid_dev->subdrivers[hid_dev->subdriver_count].deinit = usb_kbd_deinit;
    91        
     91
    9292        // set subdriver count
    9393        ++hid_dev->subdriver_count;
    94        
     94
    9595        return EOK;
    9696}
     
    101101{
    102102        assert(hid_dev != NULL && hid_dev->subdriver_count == 0);
    103        
     103
    104104        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(
    105105            sizeof(usb_hid_subdriver_t));
     
    107107                return ENOMEM;
    108108        }
    109        
     109
    110110        assert(hid_dev->subdriver_count >= 0);
    111        
     111
    112112        // set the init callback
    113113        hid_dev->subdrivers[hid_dev->subdriver_count].init = usb_mouse_init;
    114        
     114
    115115        // set the polling callback
    116116        hid_dev->subdrivers[hid_dev->subdriver_count].poll =
    117117            usb_mouse_polling_callback;
    118        
     118
    119119        // set the polling ended callback
    120120        hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
    121        
     121
    122122        // set the deinit callback
    123123        hid_dev->subdrivers[hid_dev->subdriver_count].deinit = usb_mouse_deinit;
    124        
     124
    125125        // set subdriver count
    126126        ++hid_dev->subdriver_count;
    127        
     127
    128128        return EOK;
    129129}
     
    134134{
    135135        assert(hid_dev != NULL && hid_dev->subdriver_count == 0);
    136        
     136
    137137        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(
    138138            sizeof(usb_hid_subdriver_t));
     
    140140                return ENOMEM;
    141141        }
    142        
     142
    143143        assert(hid_dev->subdriver_count >= 0);
    144        
     144
    145145        // set the init callback
    146146        hid_dev->subdrivers[hid_dev->subdriver_count].init =
    147147            usb_generic_hid_init;
    148        
     148
    149149        // set the polling callback
    150150        hid_dev->subdrivers[hid_dev->subdriver_count].poll =
    151151            usb_generic_hid_polling_callback;
    152        
     152
    153153        // set the polling ended callback
    154154        hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
    155        
     155
    156156        // set the deinit callback
    157157        hid_dev->subdrivers[hid_dev->subdriver_count].deinit = NULL;
    158        
     158
    159159        // set subdriver count
    160160        ++hid_dev->subdriver_count;
    161        
     161
    162162        return EOK;
    163163}
     
    170170        assert(hid_dev != NULL);
    171171        assert(hid_dev->usb_dev != NULL);
    172        
     172
    173173        return (hid_dev->usb_dev->descriptors.device.vendor_id
    174174            == mapping->vendor_id
     
    184184        assert(hid_dev != NULL);
    185185        assert(mapping != NULL);
    186        
     186
    187187        usb_hid_report_path_t *usage_path = usb_hid_report_path();
    188188        if (usage_path == NULL) {
     
    202202                ++i;
    203203        }
    204        
     204
    205205        assert(hid_dev->report != NULL);
    206        
     206
    207207        usb_log_debug("Compare flags: %d\n", mapping->compare);
    208        
     208
    209209        bool matches = false;
    210210        uint8_t report_id = mapping->report_id;
     
    234234                    USB_HID_REPORT_TYPE_INPUT);
    235235        } while (!matches && report_id != 0);
    236        
     236
    237237        usb_hid_report_path_free(usage_path);
    238        
     238
    239239        return matches;
    240240}
     
    246246{
    247247        int i;
    248        
     248
    249249        if (count <= 0) {
    250250                hid_dev->subdriver_count = 0;
     
    252252                return EOK;
    253253        }
    254        
     254
    255255        // add one generic HID subdriver per device
    256        
     256
    257257        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc((count + 1) *
    258258            sizeof(usb_hid_subdriver_t));
     
    260260                return ENOMEM;
    261261        }
    262        
     262
    263263        for (i = 0; i < count; ++i) {
    264264                hid_dev->subdrivers[i].init = subdrivers[i]->init;
     
    267267                hid_dev->subdrivers[i].poll_end = subdrivers[i]->poll_end;
    268268        }
    269        
     269
    270270        hid_dev->subdrivers[count].init = usb_generic_hid_init;
    271271        hid_dev->subdrivers[count].poll = usb_generic_hid_polling_callback;
    272272        hid_dev->subdrivers[count].deinit = NULL;
    273273        hid_dev->subdrivers[count].poll_end = NULL;
    274        
     274
    275275        hid_dev->subdriver_count = count + 1;
    276        
     276
    277277        return EOK;
    278278}
     
    283283{
    284284        assert(hid_dev != NULL);
    285        
     285
    286286        const usb_hid_subdriver_t *subdrivers[USB_HID_MAX_SUBDRIVERS];
    287        
     287
    288288        int i = 0, count = 0;
    289289        const usb_hid_subdriver_mapping_t *mapping = &usb_hid_subdrivers[i];
     
    291291        bool ids_matched;
    292292        bool matched;
    293        
     293
    294294        while (count < USB_HID_MAX_SUBDRIVERS &&
    295295            (mapping->usage_path != NULL
     
    339339                mapping = &usb_hid_subdrivers[++i];
    340340        }
    341        
     341
    342342        // we have all subdrivers determined, save them into the hid device
    343343        return usb_hid_save_subdrivers(hid_dev, subdrivers, count);
     
    349349{
    350350        assert(hid_dev != NULL && dev != NULL);
    351        
     351
    352352        int rc = EOK;
    353        
     353
    354354        if (dev->pipes[USB_HID_KBD_POLL_EP_NO].present) {
    355355                usb_log_debug("Found keyboard endpoint.\n");
     
    369369                rc = ENOTSUP;
    370370        }
    371        
     371
    372372        return rc;
    373373}
     
    378378{
    379379        assert(hid_dev != NULL && hid_dev->report != NULL);
    380        
     380
    381381        uint8_t report_id = 0;
    382382        size_t size;
    383        
     383
    384384        size_t max_size = 0;
    385        
     385
    386386        do {
    387387                usb_log_debug("Getting size of the report.\n");
     
    394394                    report_id, USB_HID_REPORT_TYPE_INPUT);
    395395        } while (report_id != 0);
    396        
     396
    397397        usb_log_debug("Max size of input report: %zu\n", max_size);
    398        
     398
    399399        hid_dev->max_input_report_size = max_size;
    400400        assert(hid_dev->input_report == NULL);
    401        
     401
    402402        hid_dev->input_report = malloc(max_size);
    403403        if (hid_dev->input_report == NULL) {
     
    405405        }
    406406        memset(hid_dev->input_report, 0, max_size);
    407        
     407
    408408        return EOK;
    409409}
     
    415415        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)calloc(1,
    416416            sizeof(usb_hid_dev_t));
    417        
     417
    418418        if (hid_dev == NULL) {
    419419                usb_log_fatal("No memory!\n");
    420420                return NULL;
    421421        }
    422        
     422
    423423        hid_dev->report = (usb_hid_report_t *)(malloc(sizeof(
    424424            usb_hid_report_t)));
     
    428428                return NULL;
    429429        }
    430        
     430
    431431        hid_dev->poll_pipe_index = -1;
    432        
     432
    433433        return hid_dev;
    434434}
     
    439439{
    440440        int rc, i;
    441        
     441
    442442        usb_log_debug("Initializing HID structure...\n");
    443        
     443
    444444        if (hid_dev == NULL) {
    445445                usb_log_error("Failed to init HID structure: no structure given"
     
    447447                return EINVAL;
    448448        }
    449        
     449
    450450        if (dev == NULL) {
    451451                usb_log_error("Failed to init HID structure: no USB device"
     
    453453                return EINVAL;
    454454        }
    455        
     455
    456456        /* The USB device should already be initialized, save it in structure */
    457457        hid_dev->usb_dev = dev;
    458        
     458
    459459        rc = usb_hid_check_pipes(hid_dev, dev);
    460460        if (rc != EOK) {
     
    465465        rc = usb_hid_process_report_descriptor(hid_dev->usb_dev,
    466466            hid_dev->report, &hid_dev->report_desc, &hid_dev->report_desc_size);
    467        
     467
    468468        bool fallback = false;
    469        
     469
    470470        if (rc == EOK) {
    471471                // try to find subdrivers that may want to handle this device
     
    484484                fallback = true;
    485485        }
    486        
     486
    487487        if (fallback) {
    488488                // fall back to boot protocol
     
    510510                }
    511511        }
    512        
     512
    513513        if (rc != EOK) {
    514514                usb_log_error("No subdriver for handling this device could be"
     
    542542                rc = (ok) ? EOK : -1;   // what error to report
    543543        }
    544        
    545        
     544
     545
    546546        if (rc == EOK) {
    547547                // save max input report size and allocate space for the report
     
    552552                }
    553553        }
    554        
    555        
     554
     555
    556556        return rc;
    557557}
     
    563563{
    564564        int i;
    565        
     565
    566566        if (dev == NULL || arg == NULL || buffer == NULL) {
    567567                usb_log_error("Missing arguments to polling callback.\n");
    568568                return false;
    569569        }
    570        
     570
    571571        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
    572        
     572
    573573        assert(hid_dev->input_report != NULL);
    574574        usb_log_debug("New data [%zu/%zu]: %s\n", buffer_size,
     
    582582                usb_hid_new_report(hid_dev);
    583583        }
    584        
     584
    585585        // parse the input report
    586        
     586
    587587        int rc = usb_hid_parse_report(hid_dev->report, buffer, buffer_size,
    588588            &hid_dev->report_id);
    589        
     589
    590590        if (rc != EOK) {
    591591                usb_log_warning("Error in usb_hid_parse_report():"
    592592                    "%s\n", str_error(rc));
    593593        }       
    594        
     594
    595595        bool cont = false;
    596        
     596
    597597        // continue if at least one of the subdrivers want to continue
    598598        for (i = 0; i < hid_dev->subdriver_count; ++i) {
     
    603603                }
    604604        }
    605        
     605
    606606        return cont;
    607607}
     
    613613{
    614614        int i;
    615        
     615
    616616        if (dev == NULL || arg == NULL) {
    617617                return;
    618618        }
    619        
     619
    620620        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
    621        
     621
    622622        for (i = 0; i < hid_dev->subdriver_count; ++i) {
    623623                if (hid_dev->subdrivers[i].poll_end != NULL) {
     
    626626                }
    627627        }
    628        
     628
    629629        usb_hid_destroy(hid_dev);
    630630}
     
    649649{
    650650        int i;
    651        
     651
    652652        if (hid_dev == NULL) {
    653653                return;
    654654        }
    655        
     655
    656656        usb_log_debug("Subdrivers: %p, subdriver count: %d\n",
    657657            hid_dev->subdrivers, hid_dev->subdriver_count);
    658        
     658
    659659        assert(hid_dev->subdrivers != NULL
    660660            || hid_dev->subdriver_count == 0);
    661        
     661
    662662        for (i = 0; i < hid_dev->subdriver_count; ++i) {
    663663                if (hid_dev->subdrivers[i].deinit != NULL) {
     
    666666                }
    667667        }
    668        
     668
    669669        // free the subdrivers info
    670670        if (hid_dev->subdrivers != NULL) {
  • uspace/drv/bus/usb/usbhid/usbhid.h

    r3002434 rcc29622  
    102102        /** Structure holding generic USB device information. */
    103103        usb_device_t *usb_dev;
    104        
     104
    105105        /** Index of the polling pipe in usb_hid_endpoints array. */
    106106        int poll_pipe_index;
    107        
     107
    108108        /** Subdrivers. */
    109109        usb_hid_subdriver_t *subdrivers;
    110        
     110
    111111        /** Number of subdrivers. */
    112112        int subdriver_count;
    113        
     113
    114114        /** Report descriptor. */
    115115        uint8_t *report_desc;
     
    117117        /** Report descriptor size. */
    118118        size_t report_desc_size;
    119        
     119
    120120        /** HID Report parser. */
    121121        usb_hid_report_t *report;
    122        
     122
    123123        uint8_t report_id;
    124        
     124
    125125        uint8_t *input_report;
    126        
     126
    127127        size_t input_report_size;
    128128        size_t max_input_report_size;
    129        
     129
    130130        int report_nr;
    131131};
Note: See TracChangeset for help on using the changeset viewer.