Changes in uspace/drv/bus/usb/usbhid/mouse/mousedev.c [1dc4a5e:5cc9eba] in mainline

File:

• uspace/drv/bus/usb/usbhid/mouse/mousedev.c (modified) (11 diffs)

uspace/drv/bus/usb/usbhid/mouse/mousedev.c

@@ -42 +42 @@
 #include <errno.h>
 #include <async.h>
-#include <async_obsolete.h>
 #include <str_error.h>
 #include <ipc/mouseev.h>
@@ -53 +52 @@
 #include "../usbhid.h"
 
-/** Number of simulated arrow-key presses for singel wheel step. */
-#define ARROWS_PER_SINGLE_WHEEL 3
-
-// FIXME: remove this header
-#include <abi/ipc/methods.h>
-
 #define NAME "mouse"
 
 /*----------------------------------------------------------------------------*/
 
-usb_endpoint_description_t usb_hid_mouse_poll_endpoint_description = {
+const usb_endpoint_description_t usb_hid_mouse_poll_endpoint_description = {
         .transfer_type = USB_TRANSFER_INTERRUPT,
         .direction = USB_DIRECTION_IN,
@@ -73 +66 @@
 
 const char *HID_MOUSE_FUN_NAME = "mouse";
-const char *HID_MOUSE_WHEEL_FUN_NAME = "mouse-wheel";
 const char *HID_MOUSE_CATEGORY = "mouse";
-const char *HID_MOUSE_WHEEL_CATEGORY = "keyboard";
 
 /** Default idle rate for mouses. */
 static const uint8_t IDLE_RATE = 0;
-static const size_t USB_MOUSE_BUTTON_COUNT = 3;
-
-/*----------------------------------------------------------------------------*/
-
-enum {
-        USB_MOUSE_BOOT_REPORT_DESCRIPTOR_SIZE = 63
-};
-
-static const uint8_t USB_MOUSE_BOOT_REPORT_DESCRIPTOR[
-    USB_MOUSE_BOOT_REPORT_DESCRIPTOR_SIZE] = {
+
+/*----------------------------------------------------------------------------*/
+static const uint8_t USB_MOUSE_BOOT_REPORT_DESCRIPTOR[] = {
         0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
         0x09, 0x02,                    // USAGE (Mouse)
@@ -128 +112 @@
     ipc_callid_t icallid, ipc_call_t *icall)
 {
-        sysarg_t method = IPC_GET_IMETHOD(*icall);
-        
-        usb_mouse_t *mouse_dev = (usb_mouse_t *)fun->driver_data;
-        
+        usb_mouse_t *mouse_dev = fun->driver_data;
+
         if (mouse_dev == NULL) {
-                usb_log_debug("default_connection_handler: Missing "
-                    "parameters.\n");
+                usb_log_debug("%s: Missing parameters.\n", __FUNCTION__);
                 async_answer_0(icallid, EINVAL);
                 return;
         }
-        
-        usb_log_debug("default_connection_handler: fun->name: %s\n",
-                      fun->name);
-        usb_log_debug("default_connection_handler: mouse_phone: %d, wheel "
-            "phone: %d\n", mouse_dev->mouse_phone, mouse_dev->wheel_phone);
-        
-        int *phone = (str_cmp(fun->name, HID_MOUSE_FUN_NAME) == 0) 
-                     ? &mouse_dev->mouse_phone : &mouse_dev->wheel_phone;
-        
-        if (method == IPC_M_CONNECT_TO_ME) {
-                int callback = IPC_GET_ARG5(*icall);
-
-                if (*phone != -1) {
-                        usb_log_debug("default_connection_handler: Console "
-                            "phone to mouse already set.\n");
+
+        usb_log_debug("%s: fun->name: %s\n", __FUNCTION__, fun->name);
+        usb_log_debug("%s: mouse_sess: %p\n",
+            __FUNCTION__, mouse_dev->mouse_sess);
+
+        async_sess_t *sess =
+            async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
+        if (sess != NULL) {
+                if (mouse_dev->mouse_sess == NULL) {
+                        mouse_dev->mouse_sess = sess;
+                        usb_log_debug("Console session to %s set ok (%p).\n",
+                            fun->name, sess);
+                        async_answer_0(icallid, EOK);
+                } else {
+                        usb_log_error("Console session to %s already set.\n",
+                            fun->name);
                         async_answer_0(icallid, ELIMIT);
-                        return;
+                        async_hangup(sess);
                 }
-
-                *phone = callback;
-                usb_log_debug("Console phone to mouse set ok (%d).\n", *phone);
-                async_answer_0(icallid, EOK);
-                return;
-        }
-
-        usb_log_debug("default_connection_handler: Invalid function.\n");
-        async_answer_0(icallid, EINVAL);
-}
-
-/*----------------------------------------------------------------------------*/
-
-static usb_mouse_t *usb_mouse_new(void)
-{
-        usb_mouse_t *mouse = calloc(1, sizeof(usb_mouse_t));
-        if (mouse == NULL) {
-                return NULL;
-        }
-        mouse->mouse_phone = -1;
-        mouse->wheel_phone = -1;
-        
-        return mouse;
-}
-
-/*----------------------------------------------------------------------------*/
-
-static void usb_mouse_free(usb_mouse_t **mouse_dev)
-{
-        assert(mouse_dev != NULL && *mouse_dev != NULL);
-        
-        // hangup phone to the console
-        if ((*mouse_dev)->mouse_phone >= 0) {
-                async_obsolete_hangup((*mouse_dev)->mouse_phone);
-        }
-        
-        if ((*mouse_dev)->wheel_phone >= 0) {
-                async_obsolete_hangup((*mouse_dev)->wheel_phone);
-        }
-        
-        free(*mouse_dev);
-        *mouse_dev = NULL;
-}
-
-/*----------------------------------------------------------------------------*/
-
-static void usb_mouse_send_wheel(const usb_mouse_t *mouse_dev, int wheel)
-{
-        unsigned int key = (wheel > 0) ? KC_UP : KC_DOWN;
-
-        if (mouse_dev->wheel_phone < 0) {
-                usb_log_warning(
-                    "Connection to console not ready, wheel roll discarded.\n");
-                return;
-        }
-        
-        int count = ((wheel < 0) ? -wheel : wheel) * ARROWS_PER_SINGLE_WHEEL;
-        int i;
-        
-        for (i = 0; i < count; i++) {
-                /* Send arrow press and release. */
-                usb_log_debug2("Sending key %d to the console\n", key);
-                async_obsolete_msg_4(mouse_dev->wheel_phone, KBDEV_EVENT,
-                    KEY_PRESS, key, 0, 0);
-                async_obsolete_msg_4(mouse_dev->wheel_phone, KBDEV_EVENT,
-                    KEY_RELEASE, key, 0, 0);
-        }
-}
-
-/*----------------------------------------------------------------------------*/
-
+        } else {
+                usb_log_debug("%s: Invalid function.\n", __FUNCTION__);
+                async_answer_0(icallid, EINVAL);
+        }
+}
+/*----------------------------------------------------------------------------*/
 static int get_mouse_axis_move_value(uint8_t rid, usb_hid_report_t *report,
     int32_t usage)
@@ -255 +172 @@
 {
         assert(mouse_dev != NULL);
-        
-        if (mouse_dev->mouse_phone < 0) {
-                usb_log_warning(NAME " No console phone.\n");
+
+        if (mouse_dev->mouse_sess == NULL) {
+                usb_log_warning(NAME " No console session.\n");
                 return true;
         }
 
-        int shift_x = get_mouse_axis_move_value(hid_dev->report_id,
-            hid_dev->report, USB_HIDUT_USAGE_GENERIC_DESKTOP_X);
-        int shift_y = get_mouse_axis_move_value(hid_dev->report_id,
-            hid_dev->report, USB_HIDUT_USAGE_GENERIC_DESKTOP_Y);
-        int wheel = get_mouse_axis_move_value(hid_dev->report_id,
-            hid_dev->report, USB_HIDUT_USAGE_GENERIC_DESKTOP_WHEEL);
-
-        if ((shift_x != 0) || (shift_y != 0)) {
-                async_obsolete_req_2_0(mouse_dev->mouse_phone,
-                    MOUSEEV_MOVE_EVENT, shift_x, shift_y);
-        }
-
-        if (wheel != 0) {
-                usb_mouse_send_wheel(mouse_dev, wheel);
-        }
-        
-        /*
-         * Buttons
-         */
+        const int shift_x = get_mouse_axis_move_value(hid_dev->report_id,
+            &hid_dev->report, USB_HIDUT_USAGE_GENERIC_DESKTOP_X);
+        const int shift_y = get_mouse_axis_move_value(hid_dev->report_id,
+            &hid_dev->report, USB_HIDUT_USAGE_GENERIC_DESKTOP_Y);
+        const int wheel = get_mouse_axis_move_value(hid_dev->report_id,
+            &hid_dev->report, USB_HIDUT_USAGE_GENERIC_DESKTOP_WHEEL);
+
+        if (shift_x || shift_y || wheel) {
+                async_exch_t *exch =
+                    async_exchange_begin(mouse_dev->mouse_sess);
+                if (exch != NULL) {
+                        async_msg_3(exch, MOUSEEV_MOVE_EVENT,
+                            shift_x, shift_y, wheel);
+                        async_exchange_end(exch);
+                }
+        }
+
+        /* Buttons */
         usb_hid_report_path_t *path = usb_hid_report_path();
-        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_BUTTON, 0);
+        if (path == NULL) {
+                usb_log_warning("Failed to create USB HID report path.\n");
+                return true;
+        }
+        int ret =
+           usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_BUTTON, 0);
+        if (ret != EOK) {
+                usb_hid_report_path_free(path);
+                usb_log_warning("Failed to add buttons to report path.\n");
+                return true;
+        }
         usb_hid_report_path_set_report_id(path, hid_dev->report_id);
-        
+
         usb_hid_report_field_t *field = usb_hid_report_get_sibling(
-            hid_dev->report, NULL, path, USB_HID_PATH_COMPARE_END
-            | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
-            USB_HID_REPORT_TYPE_INPUT);
+            &hid_dev->report, NULL, path, USB_HID_PATH_COMPARE_END
+            | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, USB_HID_REPORT_TYPE_INPUT);
 
         while (field != NULL) {
                 usb_log_debug2(NAME " VALUE(%X) USAGE(%X)\n", field->value,
                     field->usage);
-                
-                if (mouse_dev->buttons[field->usage - field->usage_minimum] == 0
-                    && field->value != 0) {
-                        async_obsolete_req_2_0(mouse_dev->mouse_phone,
-                            MOUSEEV_BUTTON_EVENT, field->usage, 1);
-                        mouse_dev->buttons[field->usage - field->usage_minimum]
-                            = field->value;
-                } else if (mouse_dev->buttons[field->usage - field->usage_minimum] != 0
-                    && field->value == 0) {
-                        async_obsolete_req_2_0(mouse_dev->mouse_phone,
-                           MOUSEEV_BUTTON_EVENT, field->usage, 0);
-                        mouse_dev->buttons[field->usage - field->usage_minimum] =
-                           field->value;
+                assert(field->usage > field->usage_minimum);
+                const unsigned index = field->usage - field->usage_minimum;
+                assert(index < mouse_dev->buttons_count);
+
+                if (mouse_dev->buttons[index] == 0 && field->value != 0) {
+                        async_exch_t *exch =
+                            async_exchange_begin(mouse_dev->mouse_sess);
+                        if (exch != NULL) {
+                                async_req_2_0(exch, MOUSEEV_BUTTON_EVENT,
+                                    field->usage, 1);
+                                async_exchange_end(exch);
+                                mouse_dev->buttons[index] = field->value;
+                        }
+
+                } else if (mouse_dev->buttons[index] != 0 && field->value == 0) {
+                        async_exch_t *exch =
+                            async_exchange_begin(mouse_dev->mouse_sess);
+                        if (exch != NULL) {
+                                async_req_2_0(exch, MOUSEEV_BUTTON_EVENT,
+                                    field->usage, 0);
+                                async_exchange_end(exch);
+                                mouse_dev->buttons[index] = field->value;
+                        }
                 }
-                
+
                 field = usb_hid_report_get_sibling(
-                    hid_dev->report, field, path, USB_HID_PATH_COMPARE_END
-                    | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
+                    &hid_dev->report, field, path, USB_HID_PATH_COMPARE_END
+                    | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
                     USB_HID_REPORT_TYPE_INPUT);
         }
-        
+
         usb_hid_report_path_free(path);
 
         return true;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
+#define FUN_UNBIND_DESTROY(fun) \
+if (fun) { \
+        if (ddf_fun_unbind((fun)) == EOK) { \
+                (fun)->driver_data = NULL; \
+                ddf_fun_destroy((fun)); \
+        } else { \
+                usb_log_error("Could not unbind function `%s', it " \
+                    "will not be destroyed.\n", (fun)->name); \
+        } \
+} else (void)0
+/*----------------------------------------------------------------------------*/
 static int usb_mouse_create_function(usb_hid_dev_t *hid_dev, usb_mouse_t *mouse)
 {
         assert(hid_dev != NULL);
         assert(mouse != NULL);
-        
+
         /* Create the exposed function. */
         usb_log_debug("Creating DDF function %s...\n", HID_MOUSE_FUN_NAME);
-        ddf_fun_t *fun = ddf_fun_create(hid_dev->usb_dev->ddf_dev, fun_exposed, 
+        ddf_fun_t *fun = ddf_fun_create(hid_dev->usb_dev->ddf_dev, fun_exposed,
             HID_MOUSE_FUN_NAME);
         if (fun == NULL) {
-                usb_log_error("Could not create DDF function node.\n");
+                usb_log_error("Could not create DDF function node `%s'.\n",
+                    HID_MOUSE_FUN_NAME);
                 return ENOMEM;
         }
-        
+
         fun->ops = &mouse->ops;
         fun->driver_data = mouse;
@@ -339 +284 @@
         int rc = ddf_fun_bind(fun);
         if (rc != EOK) {
-                usb_log_error("Could not bind DDF function: %s.\n",
-                    str_error(rc));
+                usb_log_error("Could not bind DDF function `%s': %s.\n",
+                    fun->name, str_error(rc));
+                fun->driver_data = NULL;
                 ddf_fun_destroy(fun);
                 return rc;
         }
-        
-        usb_log_debug("Adding DDF function to category %s...\n", 
-            HID_MOUSE_CATEGORY);
+
+        usb_log_debug("Adding DDF function `%s' to category %s...\n",
+            fun->name, HID_MOUSE_CATEGORY);
         rc = ddf_fun_add_to_category(fun, HID_MOUSE_CATEGORY);
         if (rc != EOK) {
@@ -352 +298 @@
                     "Could not add DDF function to category %s: %s.\n",
                     HID_MOUSE_CATEGORY, str_error(rc));
-                ddf_fun_destroy(fun);
+                FUN_UNBIND_DESTROY(fun);
                 return rc;
         }
-        
-        /*
-         * Special function for acting as keyboard (wheel)
-         */
-        usb_log_debug("Creating DDF function %s...\n", 
-                      HID_MOUSE_WHEEL_FUN_NAME);
-        fun = ddf_fun_create(hid_dev->usb_dev->ddf_dev, fun_exposed, 
-            HID_MOUSE_WHEEL_FUN_NAME);
-        if (fun == NULL) {
-                usb_log_error("Could not create DDF function node.\n");
-                return ENOMEM;
-        }
-        
-        /*
-         * Store the initialized HID device and HID ops
-         * to the DDF function.
-         */
-        fun->ops = &mouse->ops;
-        fun->driver_data = mouse;
-
-        rc = ddf_fun_bind(fun);
-        if (rc != EOK) {
-                usb_log_error("Could not bind DDF function: %s.\n",
-                    str_error(rc));
-                ddf_fun_destroy(fun);
-                return rc;
-        }
-        
-        usb_log_debug("Adding DDF function to category %s...\n", 
-            HID_MOUSE_WHEEL_CATEGORY);
-        rc = ddf_fun_add_to_category(fun, HID_MOUSE_WHEEL_CATEGORY);
-        if (rc != EOK) {
-                usb_log_error(
-                    "Could not add DDF function to category %s: %s.\n",
-                    HID_MOUSE_WHEEL_CATEGORY, str_error(rc));
-                ddf_fun_destroy(fun);
-                return rc;
-        }
-        
+        mouse->mouse_fun = fun;
+
         return EOK;
 }
 
-/*----------------------------------------------------------------------------*/
-
+/** Get highest index of a button mentioned in given report.
+ *
+ * @param report HID report.
+ * @param report_id Report id we are interested in.
+ * @return Highest button mentioned in the report.
+ * @retval 1 No button was mentioned.
+ *
+ */
+static size_t usb_mouse_get_highest_button(usb_hid_report_t *report, uint8_t report_id)
+{
+        size_t highest_button = 0;
+
+        usb_hid_report_path_t *path = usb_hid_report_path();
+        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_BUTTON, 0);
+        usb_hid_report_path_set_report_id(path, report_id);
+
+        usb_hid_report_field_t *field = NULL;
+
+        /* Break from within. */
+        while (1) {
+                field = usb_hid_report_get_sibling(
+                    report, field, path,
+                    USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
+                    USB_HID_REPORT_TYPE_INPUT);
+                /* No more buttons? */
+                if (field == NULL) {
+                        break;
+                }
+
+                size_t current_button = field->usage - field->usage_minimum;
+                if (current_button > highest_button) {
+                        highest_button = current_button;
+                }
+        }
+
+        usb_hid_report_path_free(path);
+
+        return highest_button;
+}
+/*----------------------------------------------------------------------------*/
 int usb_mouse_init(usb_hid_dev_t *hid_dev, void **data)
 {
         usb_log_debug("Initializing HID/Mouse structure...\n");
-        
+
         if (hid_dev == NULL) {
                 usb_log_error("Failed to init keyboard structure: no structure"
@@ -408 +355 @@
                 return EINVAL;
         }
-        
-        usb_mouse_t *mouse_dev = usb_mouse_new();
+
+        usb_mouse_t *mouse_dev = calloc(1, sizeof(usb_mouse_t));
         if (mouse_dev == NULL) {
                 usb_log_error("Error while creating USB/HID Mouse device "
@@ -415 +362 @@
                 return ENOMEM;
         }
-        
-        mouse_dev->buttons = (int32_t *)calloc(USB_MOUSE_BUTTON_COUNT, 
-            sizeof(int32_t));
-        
+
+        // FIXME: This may not be optimal since stupid hardware vendor may
+        // use buttons 1, 2, 3 and 6000 and we would allocate array of
+        // 6001*4B and use only 4 items in it.
+        // Since I doubt that hardware producers would do that, I think
+        // that the current solution is good enough.
+        /* Adding 1 because we will be accessing buttons[highest]. */
+        mouse_dev->buttons_count = 1 + usb_mouse_get_highest_button(
+            &hid_dev->report, hid_dev->report_id);
+        mouse_dev->buttons = calloc(mouse_dev->buttons_count, sizeof(int32_t));
+
         if (mouse_dev->buttons == NULL) {
-                usb_log_fatal("No memory!\n");
+                usb_log_error(NAME ": out of memory, giving up on device!\n");
                 free(mouse_dev);
                 return ENOMEM;
         }
-        
-        // save the Mouse device structure into the HID device structure
-        *data = mouse_dev;
-        
+
         // set handler for incoming calls
         mouse_dev->ops.default_handler = default_connection_handler;
-        
+
         // TODO: how to know if the device supports the request???
-        usbhid_req_set_idle(&hid_dev->usb_dev->ctrl_pipe, 
+        usbhid_req_set_idle(&hid_dev->usb_dev->ctrl_pipe,
             hid_dev->usb_dev->interface_no, IDLE_RATE);
-        
+
         int rc = usb_mouse_create_function(hid_dev, mouse_dev);
         if (rc != EOK) {
-                usb_mouse_free(&mouse_dev);
+                free(mouse_dev->buttons);
+                free(mouse_dev);
                 return rc;
         }
-        
+
+        /* Save the Mouse device structure into the HID device structure. */
+        *data = mouse_dev;
+
         return EOK;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 bool usb_mouse_polling_callback(usb_hid_dev_t *hid_dev, void *data)
 {
         if (hid_dev == NULL || data == NULL) {
-                usb_log_error("Missing argument to the mouse polling callback."
-                    "\n");
+                usb_log_error(
+                    "Missing argument to the mouse polling callback.\n");
                 return false;
         }
-        
-        usb_mouse_t *mouse_dev = (usb_mouse_t *)data;
-                
+
+        usb_mouse_t *mouse_dev = data;
+
         return usb_mouse_process_report(hid_dev, mouse_dev);
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 void usb_mouse_deinit(usb_hid_dev_t *hid_dev, void *data)
 {
-        if (data != NULL) {
-                usb_mouse_free((usb_mouse_t **)&data);
-        }
-}
-
-/*----------------------------------------------------------------------------*/
-
+        if (data == NULL)
+                return;
+
+        usb_mouse_t *mouse_dev = data;
+
+        /* Hangup session to the console */
+        if (mouse_dev->mouse_sess != NULL) {
+                const int ret = async_hangup(mouse_dev->mouse_sess);
+                if (ret != EOK)
+                        usb_log_warning("Failed to hang up mouse session: "
+                            "%p, %s.\n", mouse_dev->mouse_sess, str_error(ret));
+        }
+
+        FUN_UNBIND_DESTROY(mouse_dev->mouse_fun);
+
+        free(mouse_dev->buttons);
+        free(mouse_dev);
+}
+/*----------------------------------------------------------------------------*/
 int usb_mouse_set_boot_protocol(usb_hid_dev_t *hid_dev)
 {
-        int rc = usb_hid_parse_report_descriptor(hid_dev->report, 
-            USB_MOUSE_BOOT_REPORT_DESCRIPTOR, 
-            USB_MOUSE_BOOT_REPORT_DESCRIPTOR_SIZE);
-        
+        int rc = usb_hid_parse_report_descriptor(
+            &hid_dev->report, USB_MOUSE_BOOT_REPORT_DESCRIPTOR,
+            sizeof(USB_MOUSE_BOOT_REPORT_DESCRIPTOR));
+
         if (rc != EOK) {
                 usb_log_error("Failed to parse boot report descriptor: %s\n",
@@ -481 +444 @@
                 return rc;
         }
-        
-        rc = usbhid_req_set_protocol(&hid_dev->usb_dev->ctrl_pipe, 
+
+        rc = usbhid_req_set_protocol(&hid_dev->usb_dev->ctrl_pipe,
             hid_dev->usb_dev->interface_no, USB_HID_PROTOCOL_BOOT);
-        
+
         if (rc != EOK) {
                 usb_log_warning("Failed to set boot protocol to the device: "
@@ -490 +453 @@
                 return rc;
         }
-        
+
         return EOK;
 }