Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/bus/usb/usbhid/mouse/mousedev.c

    rf2964e45 r4093b14  
    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);
    188         int ret = ddf_fun_unbind(mouse_dev->mouse_fun);
    189         if (ret != EOK) {
    190                 usb_log_error("Failed to unbind mouse function.\n");
    191         } else {
    192                 ddf_fun_destroy(mouse_dev->mouse_fun);
    193                 /* Prevent double free */
    194                 mouse_dev->wheel_fun->driver_data = NULL;
    195         }
    196 
    197         ret = ddf_fun_unbind(mouse_dev->wheel_fun);
    198         if (ret != EOK) {
    199                 usb_log_error("Failed to unbind wheel function.\n");
    200         } else {
    201                 ddf_fun_destroy(mouse_dev->wheel_fun);
    202         }
    203188}
    204189
     
    214199                return;
    215200        }
    216 
     201       
    217202        int count = ((wheel < 0) ? -wheel : wheel) * ARROWS_PER_SINGLE_WHEEL;
    218203        int i;
    219 
     204       
    220205        for (i = 0; i < count; i++) {
    221206                /* Send arrow press and release. */
     
    261246{
    262247        assert(mouse_dev != NULL);
    263 
     248       
    264249        if (mouse_dev->mouse_sess == NULL) {
    265250                usb_log_warning(NAME " No console session.\n");
     
    279264                async_exchange_end(exch);
    280265        }
    281 
     266       
    282267        if (wheel != 0)
    283268                usb_mouse_send_wheel(mouse_dev, wheel);
    284 
     269       
    285270        /*
    286271         * Buttons
     
    289274        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_BUTTON, 0);
    290275        usb_hid_report_path_set_report_id(path, hid_dev->report_id);
    291 
     276       
    292277        usb_hid_report_field_t *field = usb_hid_report_get_sibling(
    293278            hid_dev->report, NULL, path, USB_HID_PATH_COMPARE_END
     
    324309                    USB_HID_REPORT_TYPE_INPUT);
    325310        }
    326 
     311       
    327312        usb_hid_report_path_free(path);
    328313
     
    336321        assert(hid_dev != NULL);
    337322        assert(mouse != NULL);
    338 
     323       
    339324        /* Create the exposed function. */
    340325        usb_log_debug("Creating DDF function %s...\n", HID_MOUSE_FUN_NAME);
     
    345330                return ENOMEM;
    346331        }
    347 
     332       
    348333        fun->ops = &mouse->ops;
    349334        fun->driver_data = mouse;
     
    353338                usb_log_error("Could not bind DDF function: %s.\n",
    354339                    str_error(rc));
    355                 return rc;
    356         }
    357 
     340                ddf_fun_destroy(fun);
     341                return rc;
     342        }
     343       
    358344        usb_log_debug("Adding DDF function to category %s...\n",
    359345            HID_MOUSE_CATEGORY);
     
    363349                    "Could not add DDF function to category %s: %s.\n",
    364350                    HID_MOUSE_CATEGORY, str_error(rc));
    365                 return rc;
    366         }
    367         mouse->mouse_fun = fun;
    368 
     351                ddf_fun_destroy(fun);
     352                return rc;
     353        }
     354       
    369355        /*
    370356         * Special function for acting as keyboard (wheel)
     
    378364                return ENOMEM;
    379365        }
    380 
     366       
    381367        /*
    382368         * Store the initialized HID device and HID ops
     
    390376                usb_log_error("Could not bind DDF function: %s.\n",
    391377                    str_error(rc));
    392                 return rc;
    393         }
    394 
     378                ddf_fun_destroy(fun);
     379                return rc;
     380        }
     381       
    395382        usb_log_debug("Adding DDF function to category %s...\n",
    396383            HID_MOUSE_WHEEL_CATEGORY);
     
    400387                    "Could not add DDF function to category %s: %s.\n",
    401388                    HID_MOUSE_WHEEL_CATEGORY, str_error(rc));
    402                 return rc;
    403         }
    404         mouse->wheel_fun = fun;
    405 
     389                ddf_fun_destroy(fun);
     390                return rc;
     391        }
     392       
    406393        return EOK;
    407394}
     
    454441{
    455442        usb_log_debug("Initializing HID/Mouse structure...\n");
    456 
     443       
    457444        if (hid_dev == NULL) {
    458445                usb_log_error("Failed to init keyboard structure: no structure"
     
    460447                return EINVAL;
    461448        }
    462 
     449       
    463450        usb_mouse_t *mouse_dev = usb_mouse_new();
    464451        if (mouse_dev == NULL) {
     
    467454                return ENOMEM;
    468455        }
    469 
     456       
    470457        // FIXME: This may not be optimal since stupid hardware vendor may
    471458        // use buttons 1, 2, 3 and 6000 and we would allocate array of
     
    477464            hid_dev->report_id) + 1;
    478465        mouse_dev->buttons = calloc(mouse_dev->buttons_count, sizeof(int32_t));
    479 
     466       
    480467        if (mouse_dev->buttons == NULL) {
    481468                usb_log_error(NAME ": out of memory, giving up on device!\n");
     
    487474        // save the Mouse device structure into the HID device structure
    488475        *data = mouse_dev;
    489 
     476       
    490477        // set handler for incoming calls
    491478        mouse_dev->ops.default_handler = default_connection_handler;
    492 
     479       
    493480        // TODO: how to know if the device supports the request???
    494481        usbhid_req_set_idle(&hid_dev->usb_dev->ctrl_pipe,
    495482            hid_dev->usb_dev->interface_no, IDLE_RATE);
    496 
     483       
    497484        int rc = usb_mouse_create_function(hid_dev, mouse_dev);
    498485        if (rc != EOK) {
     
    500487                return rc;
    501488        }
    502 
     489       
    503490        return EOK;
    504491}
     
    513500                return false;
    514501        }
    515 
     502       
    516503        usb_mouse_t *mouse_dev = (usb_mouse_t *)data;
    517504               
     
    524511{
    525512        if (data != NULL) {
    526                 usb_mouse_destroy(data);
     513                usb_mouse_destroy((usb_mouse_t *)data);
    527514        }
    528515}
     
    535522            USB_MOUSE_BOOT_REPORT_DESCRIPTOR,
    536523            USB_MOUSE_BOOT_REPORT_DESCRIPTOR_SIZE);
    537 
     524       
    538525        if (rc != EOK) {
    539526                usb_log_error("Failed to parse boot report descriptor: %s\n",
     
    541528                return rc;
    542529        }
    543 
     530       
    544531        rc = usbhid_req_set_protocol(&hid_dev->usb_dev->ctrl_pipe,
    545532            hid_dev->usb_dev->interface_no, USB_HID_PROTOCOL_BOOT);
    546 
     533       
    547534        if (rc != EOK) {
    548535                usb_log_warning("Failed to set boot protocol to the device: "
     
    550537                return rc;
    551538        }
    552 
     539       
    553540        return EOK;
    554541}
Note: See TracChangeset for help on using the changeset viewer.