Changeset e27595b in mainline

Timestamp:

2010-11-20T13:04:15Z (13 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

0e126be7

Parents:

7034be15

Message:

Virtual USB devices can connect to VHC

Fixed and bypassed problems introduced by using DDF.

Location:

uspace

Files:

• app/virtusbkbd/virtusbkbd.c (modified) (2 diffs)
• drv/vhc/conn.h (modified) (1 diff)
• drv/vhc/conndev.c (modified) (1 diff)
• drv/vhc/devices.h (modified) (1 diff)
• drv/vhc/hcd.c (modified) (4 diffs)
• lib/usb/hcdhubd.c (modified) (2 diffs)
• lib/usbvirt/hub.h (modified) (1 diff)
• lib/usbvirt/main.c (modified) (5 diffs)

uspace/app/virtusbkbd/virtusbkbd.c

@@ -58 +58 @@
 #define NAME "virt-usb-kbd"
 
-#define DEV_HCD_NAME "hcd-virt-dev"
 
 #define __QUOTEME(x) #x
@@ -216 +215 @@
         
         
-        int rc = usbvirt_connect(&keyboard_dev, DEV_HCD_NAME);
+        int rc = usbvirt_connect(&keyboard_dev);
         if (rc != EOK) {
-                printf("%s: Unable to start comunication with VHCD at usb://%s (%s).\n",
-                    NAME, DEV_HCD_NAME, str_error(rc));
+                printf("%s: Unable to start communication with VHCD (%s).\n",
+                    NAME, str_error(rc));
                 return rc;
         }

uspace/drv/vhc/conn.h

@@ -42 +42 @@
 
 void connection_handler_host(ipcarg_t);
-void connection_handler_device(ipcarg_t, virtdev_connection_t *);
+
 usb_hcd_transfer_ops_t vhc_transfer_ops;
+
+void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *);
+
 
 #endif

uspace/drv/vhc/conndev.c

@@ -74 +74 @@
 }
 
-/** Connection handler for communcation with virtual device.
+/** Default handler for IPC methods not handled by DDF.
  *
- * This function also takes care of proper phone hung-up.
- *
- * @param phone_hash Incoming phone hash.
- * @param dev Virtual device handle.
+ * @param dev Device handling the call.
+ * @param icallid Call id.
+ * @param icall Call data.
  */
-void connection_handler_device(ipcarg_t phone_hash, virtdev_connection_t *dev)
+void default_connection_handler(device_t *dev,
+    ipc_callid_t icallid, ipc_call_t *icall)
 {
-        assert(dev != NULL);
-        
-        char devname[DEVICE_NAME_MAXLENGTH + 1];
-        int rc = get_device_name(dev->phone, devname, DEVICE_NAME_MAXLENGTH);
-        
-        dprintf(0, "virtual device connected (phone: %#x, name: %s)",
-            phone_hash, rc == EOK ? devname : "<unknown>");
-        
-        
-        while (true) {
-                ipc_callid_t callid; 
-                ipc_call_t call; 
-                
-                callid = async_get_call(&call);
-                
-                switch (IPC_GET_METHOD(call)) {
-                        case IPC_M_PHONE_HUNGUP:
-                                ipc_hangup(dev->phone);
-                                ipc_answer_0(callid, EOK);
-                                dprintf(0, "phone%#x: device hung-up",
-                                    phone_hash);
-                                return;
-                        
-                        case IPC_M_CONNECT_TO_ME:
-                                ipc_answer_0(callid, ELIMIT);
-                                break;
-                        
-                        default:
-                                dprintf_inval_call(2, call, phone_hash);
-                                ipc_answer_0(callid, EINVAL);
-                                break;
+        ipcarg_t method = IPC_GET_METHOD(*icall);
+
+        if (method == IPC_M_CONNECT_TO_ME) {
+                int callback = IPC_GET_ARG5(*icall);
+                virtdev_connection_t *dev
+                    = virtdev_add_device(callback);
+                if (!dev) {
+                        ipc_answer_0(icallid, EEXISTS);
+                        ipc_hangup(callback);
+                        return;
                 }
+                ipc_answer_0(icallid, EOK);
+
+                char devname[DEVICE_NAME_MAXLENGTH + 1];
+                int rc = get_device_name(callback, devname, DEVICE_NAME_MAXLENGTH);
+
+                dprintf(0, "virtual device connected (name: %s)",
+                    rc == EOK ? devname : "<unknown>");
+
+                /* FIXME: destroy the device when the client disconnects. */
+
+                return;
         }
+
+        ipc_answer_0(icallid, EINVAL);
 }
+
 
 /**

uspace/drv/vhc/devices.h

@@ -50 +50 @@
 
 virtdev_connection_t *virtdev_add_device(int);
+virtdev_connection_t *virtdev_get_mine(void);
 void virtdev_destroy_device(virtdev_connection_t *);
 usb_transaction_outcome_t virtdev_send_to_all(transaction_t *);

uspace/drv/vhc/hcd.c

@@ -52 +52 @@
 #include "conn.h"
 
+
 static int vhc_count = 0;
 static int vhc_add_device(usb_hc_device_t *dev)
 {
-        printf("%s: new device registered.\n", NAME);
         /*
          * Currently, we know how to simulate only single HC.
@@ -66 +66 @@
 
         dev->transfer_ops = &vhc_transfer_ops;
+        dev->generic->ops->default_handler = default_connection_handler;
 
         /*
@@ -71 +72 @@
          */
         usb_hcd_add_root_hub(dev);
+
+        printf("%s: virtual USB host controller ready.\n", NAME);
 
         return EOK;
@@ -84 +87 @@
         printf("%s: virtual USB host controller driver.\n", NAME);
 
+        debug_level = 5;
+
         return usb_hcd_main(&vhc_driver);
 }

uspace/lib/usb/hcdhubd.c

@@ -76 +76 @@
 
                 hc_dev->generic = dev;
+                dev->ops = &usb_device_ops;
+                hc_dev->generic->driver_data = hc_dev;
+
                 int rc = hc_driver->add_hc(hc_dev);
                 if (rc != EOK) {
@@ -81 +84 @@
                         return rc;
                 }
-
-                /*
-                 * Finish initialization of dev and hc_dev structures.
-                 */
-                hc_dev->generic->driver_data = hc_dev;
-                dev->ops = &usb_device_ops;
 
                 /*

uspace/lib/usbvirt/hub.h

@@ -59 +59 @@
 } usbvirt_device_method_t;
 
-int usbvirt_connect(usbvirt_device_t *, const char *);
+int usbvirt_connect(usbvirt_device_t *);
 int usbvirt_connect_local(usbvirt_device_t *);
 int usbvirt_disconnect(usbvirt_device_t *dev);

uspace/lib/usbvirt/main.c

@@ -33 +33 @@
  * @brief Device registration with virtual USB framework.
  */
-#include <devmap.h>
-#include <fcntl.h>
-#include <vfs/vfs.h>
+#include <devman.h>
 #include <errno.h>
 #include <stdlib.h>
@@ -181 +179 @@
                 return;
         }
-        
+
         device_callback_connection(dev->device, iid, icall);
 }
@@ -187 +185 @@
 /** Create necessary phones for comunication with virtual HCD.
  * This function wraps following calls:
- * -# open <code>/dev/usb/<i>hcd_path</i></code> for reading
+ * -# open <code>/dev/devices/\\vhc for reading
  * -# access phone of file opened in previous step
  * -# create callback through just opened phone
@@ -202 +200 @@
  * @return EOK on success or error code from errno.h.
  */
-int usbvirt_connect(usbvirt_device_t *dev, const char *hcd_path)
+int usbvirt_connect(usbvirt_device_t *dev)
 {
         virtual_device_t *virtual_device = find_device(dev);
@@ -209 +207 @@
         }
         
-        char dev_path[DEVMAP_NAME_MAXLEN + 1];
-        snprintf(dev_path, DEVMAP_NAME_MAXLEN,
-            "/dev/%s/%s", NAMESPACE, hcd_path);
-        
-        int fd = open(dev_path, O_RDONLY);
-        if (fd < 0) {
-                return fd;
-        }
-        
-        int hcd_phone = fd_phone(fd);
+        const char *vhc_path = "/vhc";
+        int rc;
+        devman_handle_t handle;
+
+        rc = devman_device_get_handle(vhc_path, &handle, 0);
+        if (rc != EOK) {
+                printf("devman_device_get_handle() failed\n");
+                return rc;
+        }
+        
+        int hcd_phone = devman_device_connect(handle, 0);
         
         if (hcd_phone < 0) {
+                printf("devman_device_connect() failed\n");
                 return hcd_phone;
         }
         
         ipcarg_t phonehash;
-        int rc = ipc_connect_to_me(hcd_phone, 0, 0, 0, &phonehash);
+        rc = ipc_connect_to_me(hcd_phone, 0, 0, 0, &phonehash);
         if (rc != EOK) {
+                printf("ipc_connect_to_me() failed\n");
                 return rc;
         }