Changeset 0f191a2 in mainline


Ignore:
Timestamp:
2011-01-07T09:20:13Z (13 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
2b0db98, 2c98e78, 43c3937
Parents:
ae1f70e (diff), 8f8a0cd6 (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 vojtechhorky/ - connecting to HC

Fixed ticket #6:
Currently, all USB device drivers connect to the virtual host
controller. The usb_drv_hc_connect() function must connect
the caller to the host controller driver the device is
physically attached to.

Location:
uspace
Files:
3 added
15 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/uhci/main.c

    rae1f70e r0f191a2  
    2727 */
    2828#include <usb/hcdhubd.h>
     29#include <usb_iface.h>
    2930#include <usb/debug.h>
    3031#include <errno.h>
    … …  
    3233#include "uhci.h"
    3334
     35static int usb_iface_get_hc_handle(device_t *dev, devman_handle_t *handle)
     36{
     37        /* This shall be called only for the UHCI itself. */
     38        assert(dev->parent == NULL);
     39
     40        *handle = dev->handle;
     41        return EOK;
     42}
     43
     44static usb_iface_t hc_usb_iface = {
     45        .get_hc_handle = usb_iface_get_hc_handle
     46};
     47
    3448static device_ops_t uhci_ops = {
    35         .interfaces[USBHC_DEV_IFACE] = &uhci_iface,
     49        .interfaces[USB_DEV_IFACE] = &hc_usb_iface,
     50        .interfaces[USBHC_DEV_IFACE] = &uhci_iface
    3651};
    3752

  • uspace/drv/usbhub/usbhub.c

    rae1f70e r0f191a2  
    3737#include <errno.h>
    3838
    39 #include <usbhc_iface.h>
     39#include <usb_iface.h>
    4040#include <usb/usbdrv.h>
    4141#include <usb/descriptor.h>
    … …  
    4646#include "usbhub_private.h"
    4747#include "port_status.h"
     48
     49static usb_iface_t hub_usb_iface = {
     50        .get_hc_handle = usb_drv_find_hc
     51};
     52
     53static device_ops_t hub_device_ops = {
     54        .interfaces[USB_DEV_IFACE] = &hub_usb_iface
     55};
    4856
    4957//*********************************************
    … …  
    135143         * connected devices.
    136144         */
     145        dev->ops = &hub_device_ops;
    137146
    138147        //create the hub structure
    139148        //get hc connection
    140         int hc = usb_drv_hc_connect(dev, 0);
     149        int hc = usb_drv_hc_connect_auto(dev, 0);
     150        if (hc < 0) {
     151                return hc;
     152        }
    141153
    142154        usb_hub_info_t * hub_info = usb_create_hub_info(dev, hc);
    … …  
    464476                 * Connect to respective HC.
    465477                 */
    466                 int hc = usb_drv_hc_connect(hub_info->device, 0);
     478                int hc = usb_drv_hc_connect_auto(hub_info->device, 0);
    467479                if (hc < 0) {
    468480                        continue;

  • uspace/drv/usbkbd/main.c

    rae1f70e r0f191a2  
    190190        // get phone to my HC and save it as my parent's phone
    191191        // TODO: maybe not a good idea if DDF will use parent_phone
    192         kbd_dev->device->parent_phone = usb_drv_hc_connect(dev, 0);
     192        kbd_dev->device->parent_phone = usb_drv_hc_connect_auto(dev, 0);
    193193
    194194        kbd_dev->address = usb_drv_get_my_address(dev->parent_phone,
    … …  
    325325         * Not supported yet, skip..
    326326         */
    327 //      int phone = usb_drv_hc_connect(dev, 0);
     327//      int phone = usb_drv_hc_connect_auto(dev, 0);
    328328//      if (phone < 0) {
    329329//              /*

  • uspace/drv/vhc/hcd.c

    rae1f70e r0f191a2  
    4646
    4747#include <usb/usb.h>
     48#include <usb_iface.h>
    4849#include "vhcd.h"
    4950#include "hc.h"
    … …  
    5253#include "conn.h"
    5354
     55static int usb_iface_get_hc_handle(device_t *dev, devman_handle_t *handle)
     56{
     57        /* This shall be called only for VHC device. */
     58        assert(dev->parent == NULL);
     59
     60        *handle = dev->handle;
     61        return EOK;
     62}
     63
     64static usb_iface_t hc_usb_iface = {
     65        .get_hc_handle = usb_iface_get_hc_handle
     66};
     67
    5468static device_ops_t vhc_ops = {
    5569        .interfaces[USBHC_DEV_IFACE] = &vhc_iface,
     70        .interfaces[USB_DEV_IFACE] = &hc_usb_iface,
    5671        .default_handler = default_connection_handler
    5772};

  • uspace/drv/vhc/hub.c

    rae1f70e r0f191a2  
    7979        device_t *hc_dev = (device_t *) arg;
    8080
    81         int hc = usb_drv_hc_connect(hc_dev, IPC_FLAG_BLOCKING);
     81        int hc = usb_drv_hc_connect(hc_dev, hc_dev->handle, IPC_FLAG_BLOCKING);
    8282        if (hc < 0) {
    8383                printf(NAME ": failed to register root hub\n");

  • uspace/lib/c/include/ipc/dev_iface.h

    rae1f70e r0f191a2  
    3939        CHAR_DEV_IFACE,
    4040
     41        /** Interface provided by any USB device. */
     42        USB_DEV_IFACE,
    4143        /** Interface provided by USB host controller. */
    4244        USBHC_DEV_IFACE,

  • uspace/lib/drv/Makefile

    rae1f70e r0f191a2  
    3636        generic/dev_iface.c \
    3737        generic/remote_res.c \
     38        generic/remote_usb.c \
    3839        generic/remote_usbhc.c \
    3940        generic/remote_char.c

  • uspace/lib/drv/generic/dev_iface.c

    rae1f70e r0f191a2  
    3939#include "remote_res.h"
    4040#include "remote_char.h"
     41#include "remote_usb.h"
    4142#include "remote_usbhc.h"
    4243
    … …  
    4546                &remote_res_iface,
    4647                &remote_char_iface,
     48                &remote_usb_iface,
    4749                &remote_usbhc_iface
    4850        }

  • uspace/lib/drv/generic/remote_usbhc.c

    rae1f70e r0f191a2  
    5959//static void remote_usbhc(device_t *, void *, ipc_callid_t, ipc_call_t *);
    6060
    61 /** Remote USB interface operations. */
     61/** Remote USB host controller interface operations. */
    6262static remote_iface_func_ptr_t remote_usbhc_iface_ops [] = {
    6363        remote_usbhc_get_address,
    … …  
    8484};
    8585
    86 /** Remote USB interface structure.
     86/** Remote USB host controller interface structure.
    8787 */
    8888remote_iface_t remote_usbhc_iface = {

  • uspace/lib/drv/include/usbhc_iface.h

    rae1f70e r0f191a2  
    3131 */
    3232/** @file
    33  * @brief USB interface definition.
     33 * @brief USB host controller interface definition.
    3434 */
    3535
    … …  
    226226    usbhc_iface_transfer_in_callback_t, void *);
    227227
    228 /** USB devices communication interface. */
     228/** USB host controller communication interface. */
    229229typedef struct {
    230230        int (*tell_address)(device_t *, devman_handle_t, usb_address_t *);

  • uspace/lib/usb/include/usb/usbdrv.h

    rae1f70e r0f191a2  
    4141#include <usb/descriptor.h>
    4242
    43 int usb_drv_hc_connect(device_t *, unsigned int);
     43int usb_drv_find_hc(device_t *, devman_handle_t *);
     44int usb_drv_hc_connect(device_t *, devman_handle_t, unsigned int);
     45int usb_drv_hc_connect_auto(device_t *, unsigned int);
    4446
    4547int usb_drv_reserve_default_address(int);

  • uspace/lib/usb/src/hcdhubd.c

    rae1f70e r0f191a2  
    3636#include <usb/devreq.h>
    3737#include <usbhc_iface.h>
     38#include <usb_iface.h>
    3839#include <usb/descriptor.h>
    3940#include <driver.h>
    … …  
    4546#include "hcdhubd_private.h"
    4647
     48
     49static int usb_iface_get_hc_handle(device_t *dev, devman_handle_t *handle)
     50{
     51        assert(dev);
     52        assert(dev->parent != NULL);
     53
     54        device_t *parent = dev->parent;
     55
     56        if (parent->ops && parent->ops->interfaces[USB_DEV_IFACE]) {
     57                usb_iface_t *usb_iface
     58                    = (usb_iface_t *) parent->ops->interfaces[USB_DEV_IFACE];
     59                assert(usb_iface != NULL);
     60                if (usb_iface->get_hc_handle) {
     61                        int rc = usb_iface->get_hc_handle(parent, handle);
     62                        return rc;
     63                }
     64        }
     65
     66        return ENOTSUP;
     67}
     68
     69static usb_iface_t usb_iface = {
     70        .get_hc_handle = usb_iface_get_hc_handle
     71};
     72
     73static device_ops_t child_ops = {
     74        .interfaces[USB_DEV_IFACE] = &usb_iface
     75};
     76
    4777/** Callback when new device is detected and must be handled by this driver.
    4878 *
    … …  
    129159        }
    130160        child->name = child_info->name;
     161        child->parent = child_info->parent;
     162        child->ops = &child_ops;
    131163
    132164        match_id = create_match_id();

  • uspace/lib/usb/src/recognise.c

    rae1f70e r0f191a2  
    3333 * @brief Functions for recognising kind of attached devices.
    3434 */
     35#include <usb_iface.h>
    3536#include <usb/usbdrv.h>
    3637#include <usb/classes/classes.h>
    … …  
    3839#include <errno.h>
    3940
     41static int usb_iface_get_hc_handle(device_t *dev, devman_handle_t *handle)
     42{
     43        assert(dev);
     44        assert(dev->parent != NULL);
     45
     46        device_t *parent = dev->parent;
     47
     48        if (parent->ops && parent->ops->interfaces[USB_DEV_IFACE]) {
     49                usb_iface_t *usb_iface
     50                    = (usb_iface_t *) parent->ops->interfaces[USB_DEV_IFACE];
     51                assert(usb_iface != NULL);
     52                if (usb_iface->get_hc_handle) {
     53                        int rc = usb_iface->get_hc_handle(parent, handle);
     54                        return rc;
     55                }
     56        }
     57
     58        return ENOTSUP;
     59}
     60
     61static usb_iface_t usb_iface = {
     62        .get_hc_handle = usb_iface_get_hc_handle
     63};
     64
     65static device_ops_t child_ops = {
     66        .interfaces[USB_DEV_IFACE] = &usb_iface
     67};
    4068
    4169#define BCD_INT(a) (((unsigned int)(a)) / 256)
    … …  
    285313                goto failure;
    286314        }
     315        child->parent = parent;
    287316        child->name = child_name;
     317        child->ops = &child_ops;
    288318       
    289319        rc = usb_drv_create_device_match_ids(hc, &child->match_ids, address);

  • uspace/lib/usb/src/usbdrv.c

    rae1f70e r0f191a2  
    3535#include <usb/usbdrv.h>
    3636#include <usbhc_iface.h>
     37#include <usb_iface.h>
    3738#include <errno.h>
    3839#include <str_error.h>
    … …  
    5455} transfer_info_t;
    5556
     57/** Find handle of host controller the device is physically attached to.
     58 *
     59 * @param[in] dev Device looking for its host controller.
     60 * @param[out] handle Host controller devman handle.
     61 * @return Error code.
     62 */
     63int usb_drv_find_hc(device_t *dev, devman_handle_t *handle)
     64{
     65        if (dev == NULL) {
     66                return EBADMEM;
     67        }
     68        if (handle == NULL) {
     69                return EBADMEM;
     70        }
     71
     72        int parent_phone = devman_parent_device_connect(dev->handle,
     73            IPC_FLAG_BLOCKING);
     74        if (parent_phone < 0) {
     75                return parent_phone;
     76        }
     77
     78        devman_handle_t h;
     79        int rc = async_req_1_1(parent_phone, DEV_IFACE_ID(USB_DEV_IFACE),
     80            IPC_M_USB_GET_HOST_CONTROLLER_HANDLE, &h);
     81
     82        ipc_hangup(parent_phone);
     83
     84        if (rc != EOK) {
     85                return rc;
     86        }
     87
     88        *handle = h;
     89
     90        return EOK;
     91}
     92
     93/** Connect to host controller the device is physically attached to.
     94 *
     95 * @param dev Device asking for connection.
     96 * @param hc_handle Devman handle of the host controller.
     97 * @param flags Connection flags (blocking connection).
     98 * @return Phone to the HC or error code.
     99 */
     100int usb_drv_hc_connect(device_t *dev, devman_handle_t hc_handle,
     101    unsigned int flags)
     102{
     103        return devman_device_connect(hc_handle, flags);
     104}
     105
    56106/** Connect to host controller the device is physically attached to.
    57107 *
    … …  
    60110 * @return Phone to corresponding HC or error code.
    61111 */
    62 int usb_drv_hc_connect(device_t *dev, unsigned int flags)
    63 {
     112int usb_drv_hc_connect_auto(device_t *dev, unsigned int flags)
     113{
     114        int rc;
     115        devman_handle_t hc_handle;
     116
    64117        /*
    65118         * Call parent hub to obtain device handle of respective HC.
    66119         */
    67 
    68         /*
    69          * FIXME: currently we connect always to virtual host controller.
    70          */
    71         int rc;
    72         devman_handle_t handle;
    73 
    74         rc = devman_device_get_handle("/virt/usbhc", &handle, flags);
     120        rc = usb_drv_find_hc(dev, &hc_handle);
    75121        if (rc != EOK) {
    76122                return rc;
    77123        }
    78124       
    79         int phone = devman_device_connect(handle, flags);
    80 
    81         return phone;
     125        return usb_drv_hc_connect(dev, hc_handle, flags);
    82126}
    83127

  • uspace/srv/devman/main.c

    rae1f70e r0f191a2  
    458458       
    459459        if (driver == NULL) {
    460                 printf(NAME ": devman_forward error - the device is not in %" PRIun
    461                     " usable state.\n", handle);
     460                printf(NAME ": devman_forward error - the device %" PRIun \
     461                    " (%s) is not in usable state.\n",
     462                    handle, dev->pathname);
    462463                ipc_answer_0(iid, ENOENT);
    463464                return;
Note: See TracChangeset for help on using the changeset viewer.