Changeset 92574f4 in mainline for uspace/drv/usbhid/main.c

Timestamp:

2011-02-24T12:03:27Z (13 years ago)

Author:

Lubos Slovak <lubos.slovak@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

e7b7ebd5

Parents:

4837092 (diff), a80849c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merged development (changes in DDF, etc.).

Conflicts in uspace/drv/usbkbd/main.c

File:

• uspace/drv/usbhid/main.c (modified) (20 diffs)

uspace/drv/usbhid/main.c

@@ -36 +36 @@
  */
 
-#include <usb/usbdrv.h>
-#include <driver.h>
+#include <ddf/driver.h>
 #include <ipc/driver.h>
 #include <ipc/kbd.h>
@@ -45 +44 @@
 #include <str_error.h>
 #include <fibril.h>
+#include <usb/debug.h>
+#include <usb/classes/classes.h>
 #include <usb/classes/hid.h>
 #include <usb/classes/hidparser.h>
-#include <usb/devreq.h>
+#include <usb/request.h>
 #include <usb/descriptor.h>
-#include <usb/debug.h>
 #include <io/console.h>
 #include <stdint.h>
@@ -58 +58 @@
 #include "layout.h"
 
-#define BUFFER_SIZE 32
+#define BUFFER_SIZE 8
 #define NAME "usbhid"
 
@@ -64 +64 @@
 #define BOOTP_REPORT_SIZE 6
 
-static void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *);
-static device_ops_t keyboard_ops = {
+/** Keyboard polling endpoint description for boot protocol class. */
+static usb_endpoint_description_t poll_endpoint_description = {
+        .transfer_type = USB_TRANSFER_INTERRUPT,
+        .direction = USB_DIRECTION_IN,
+        .interface_class = USB_CLASS_HID,
+        .interface_subclass = USB_HID_SUBCLASS_BOOT,
+        .interface_protocol = USB_HID_PROTOCOL_KEYBOARD,
+        .flags = 0
+};
+
+static void default_connection_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *);
+static ddf_dev_ops_t keyboard_ops = {
         .default_handler = default_connection_handler
 };
@@ -77 +87 @@
  * @param icall Call data.
  */
-void default_connection_handler(device_t *dev,
+void default_connection_handler(ddf_fun_t *fun,
     ipc_callid_t icallid, ipc_call_t *icall)
 {
@@ -86 +96 @@
 
                 if (console_callback_phone != -1) {
-                        ipc_answer_0(icallid, ELIMIT);
+                        async_answer_0(icallid, ELIMIT);
                         return;
                 }
 
                 console_callback_phone = callback;
-                ipc_answer_0(icallid, EOK);
+                async_answer_0(icallid, EOK);
                 return;
         }
 
-        ipc_answer_0(icallid, EINVAL);
+        async_answer_0(icallid, EINVAL);
 }
 
@@ -387 +397 @@
                 
                 // get the descriptor from the device
-                int rc = usb_drv_req_get_descriptor(
-                    kbd_dev->device->parent_phone, kbd_dev->address, 
-                    USB_REQUEST_TYPE_CLASS, USB_DESCTYPE_HID_REPORT, 
-                    0, i, kbd_dev->conf->interfaces[i].report_desc, length, 
+                int rc = usb_request_get_descriptor(&kbd_dev->ctrl_pipe,
+                    USB_REQUEST_TYPE_CLASS, USB_DESCTYPE_HID_REPORT,
+                    i, 0,
+                    kbd_dev->conf->interfaces[i].report_desc, length,
                     &actual_size);
 
@@ -411 +421 @@
         usb_standard_configuration_descriptor_t config_desc;
         
-        int rc = usb_drv_req_get_bare_configuration_descriptor(
-            kbd_dev->device->parent_phone, kbd_dev->address, 0, &config_desc);
+        int rc;
+        rc = usb_request_get_bare_configuration_descriptor(&kbd_dev->ctrl_pipe,
+            0, &config_desc);
         
         if (rc != EOK) {
@@ -426 +437 @@
         size_t transferred = 0;
         // get full configuration descriptor
-        rc = usb_drv_req_get_full_configuration_descriptor(
-            kbd_dev->device->parent_phone, kbd_dev->address, 0, descriptors,
+        rc = usb_request_get_full_configuration_descriptor(&kbd_dev->ctrl_pipe,
+            0, descriptors,
             config_desc.total_length, &transferred);
         
@@ -437 +448 @@
         }
         
+        /*
+         * Initialize the interrupt in endpoint.
+         */
+        usb_endpoint_mapping_t endpoint_mapping[1] = {
+                {
+                        .pipe = &kbd_dev->poll_pipe,
+                        .description = &poll_endpoint_description,
+                        .interface_no =
+                            usb_device_get_assigned_interface(kbd_dev->device)
+                }
+        };
+        rc = usb_endpoint_pipe_initialize_from_configuration(
+            endpoint_mapping, 1,
+            descriptors, config_desc.total_length,
+            &kbd_dev->wire);
+        if (rc != EOK) {
+                usb_log_error("Failed to initialize poll pipe: %s.\n",
+                    str_error(rc));
+                return rc;
+        }
+        if (!endpoint_mapping[0].present) {
+                usb_log_warning("Not accepting device, " \
+                    "not boot-protocol keyboard.\n");
+                return EREFUSED;
+        }
+
+
+
+
         kbd_dev->conf = (usb_hid_configuration_t *)calloc(1, 
             sizeof(usb_hid_configuration_t));
@@ -444 +484 @@
         }
         
-        rc = usbkbd_parse_descriptors(descriptors, transferred, kbd_dev->conf);
+        /*rc = usbkbd_parse_descriptors(descriptors, transferred, kbd_dev->conf);
         free(descriptors);
         if (rc != EOK) {
@@ -451 +491 @@
         }
 
-        // get and report descriptors
+        // get and report descriptors*/
         rc = usbkbd_get_report_descriptor(kbd_dev);
         if (rc != EOK) {
@@ -469 +509 @@
          *    as the endpoint for polling
          */
-        
+
         return EOK;
 }
 
-static usb_hid_dev_kbd_t *usbkbd_init_device(device_t *dev)
-{
+static usb_hid_dev_kbd_t *usbkbd_init_device(ddf_dev_t *dev)
+{
+        int rc;
+
         usb_hid_dev_kbd_t *kbd_dev = (usb_hid_dev_kbd_t *)calloc(1, 
             sizeof(usb_hid_dev_kbd_t));
@@ -485 +527 @@
         kbd_dev->device = dev;
 
-        // get phone to my HC and save it as my parent's phone
-        // TODO: maybe not a good idea if DDF will use parent_phone
-        int rc = kbd_dev->device->parent_phone = usb_drv_hc_connect_auto(dev, 0);
-        if (rc < 0) {
-                usb_log_error("Problem setting phone to HC.\n");
+        /*
+         * Initialize the backing connection to the host controller.
+         */
+        rc = usb_device_connection_initialize_from_device(&kbd_dev->wire, dev);
+        if (rc != EOK) {
+                printf("Problem initializing connection to device: %s.\n",
+                    str_error(rc));
                 goto error_leave;
         }
 
-        rc = kbd_dev->address = usb_drv_get_my_address(dev->parent_phone, dev);
-        if (rc < 0) {
-                usb_log_error("Problem getting address of the device.\n");
+        /*
+         * Initialize device pipes.
+         */
+        rc = usb_endpoint_pipe_initialize_default_control(&kbd_dev->ctrl_pipe,
+            &kbd_dev->wire);
+        if (rc != EOK) {
+                printf("Failed to initialize default control pipe: %s.\n",
+                    str_error(rc));
                 goto error_leave;
         }
 
-        // doesn't matter now that we have no address
-//      if (kbd_dev->address < 0) {
-//              usb_log_error("No device address!\n");
-//              free(kbd_dev);
-//              return NULL;
-//      }
-
         /*
          * will need all descriptors:
-         * 1) choose one configuration from configuration descriptors 
+         * 1) choose one configuration from configuration descriptors
          *    (set it to the device)
          * 2) set endpoints from endpoint descriptors
          */
 
-        usbkbd_process_descriptors(kbd_dev);
-        
-        // save the size of the report
-        kbd_dev->keycode_count = BOOTP_REPORT_SIZE;
-        kbd_dev->keycodes = (uint8_t *)calloc(
-            kbd_dev->keycode_count, sizeof(uint8_t));
-        
-        if (kbd_dev->keycodes == NULL) {
-                usb_log_fatal("No memory!\n");
+        // TODO: get descriptors, parse descriptors and save endpoints
+        usb_endpoint_pipe_start_session(&kbd_dev->ctrl_pipe);
+        //usb_request_set_configuration(&kbd_dev->ctrl_pipe, 1);
+        rc = usbkbd_process_descriptors(kbd_dev);
+        usb_endpoint_pipe_end_session(&kbd_dev->ctrl_pipe);
+        if (rc != EOK) {
                 goto error_leave;
         }
-        
-        // set configuration to the first one
-        // TODO: handle case with no configurations
-        usb_drv_req_set_configuration(kbd_dev->device->parent_phone,
-            kbd_dev->address, 
-            kbd_dev->conf->config_descriptor.configuration_number);
-        
-        /*
-         * Initialize the backing connection to the host controller.
-         */
-        rc = usb_device_connection_initialize_from_device(&kbd_dev->wire, dev);
-        if (rc != EOK) {
-                usb_log_error("Problem initializing connection to device: %s."
-                    "\n", str_error(rc));
-                goto error_leave;
-        }
-
-        /*
-         * Initialize device pipes.
-         */
-        rc = usb_endpoint_pipe_initialize(&kbd_dev->poll_pipe, &kbd_dev->wire,
-            GUESSED_POLL_ENDPOINT, USB_TRANSFER_INTERRUPT, USB_DIRECTION_IN);
-        if (rc != EOK) {
-                usb_log_error("Failed to initialize interrupt in pipe: %s.\n",
-                    str_error(rc));
-                goto error_leave;
-        }
-
 
         return kbd_dev;
@@ -591 +602 @@
 
         while (true) {
-                async_usleep(1000 * 1000 * 2);
+                async_usleep(1000 * 10);
 
                 sess_rc = usb_endpoint_pipe_start_session(&kbd_dev->poll_pipe);
@@ -643 +654 @@
         }
 
-        device_t *dev = (device_t *)arg;
+        ddf_dev_t *dev = (ddf_dev_t *)arg;
 
         // initialize device (get and process descriptors, get address, etc.)
@@ -657 +668 @@
 }
 
-static int usbkbd_add_device(device_t *dev)
+static int usbkbd_add_device(ddf_dev_t *dev)
 {
         /* For now, fail immediately. */
@@ -679 +690 @@
 
         /*
+         * Create default function.
+         */
+        // FIXME - check for errors
+        ddf_fun_t *kbd_fun = ddf_fun_create(dev, fun_exposed, "keyboard");
+        assert(kbd_fun != NULL);
+        kbd_fun->ops = &keyboard_ops;
+
+        int rc = ddf_fun_bind(kbd_fun);
+        assert(rc == EOK);
+        rc = ddf_fun_add_to_class(kbd_fun, "keyboard");
+        assert(rc == EOK);
+
+        /*
          * Create new fibril for handling this keyboard
          */
@@ -688 +712 @@
         fibril_add_ready(fid);
 
-        dev->ops = &keyboard_ops;
-
-        add_device_to_class(dev, "keyboard");
+        //dev->ops = &keyboard_ops;
+        (void)keyboard_ops;
+
+        //add_device_to_class(dev, "keyboard");
 
         /*
@@ -710 +735 @@
 {
         usb_log_enable(USB_LOG_LEVEL_MAX, NAME);
-        return driver_main(&kbd_driver);
+        return ddf_driver_main(&kbd_driver);
 }