Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset f50f722 in mainline


Ignore:
Timestamp:
2011-05-08T16:04:05Z (11 years ago)
Author:
Matej Klonfar <maklf@…>
Branches:
lfn, master
Children:
1989cdf
Parents:
68b614e (diff), 7b6f116 (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

Location:
uspace
Files:
27 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/lsusb/main.c

    r68b614e rf50f722  
    4444#include <devman.h>
    4545#include <devmap.h>
     46#include <usb/hub.h>
    4647#include <usb/host.h>
    4748
    4849#define NAME "lsusb"
    4950
    50 #define MAX_FAILED_ATTEMPTS 4
     51#define MAX_FAILED_ATTEMPTS 10
    5152#define MAX_PATH_LENGTH 1024
     53
     54static void print_found_hc(size_t class_index, const char *path)
     55{
     56        // printf(NAME ": host controller %zu is `%s'.\n", class_index, path);
     57        printf("Bus %02zu: %s\n", class_index, path);
     58}
     59static void print_found_dev(usb_address_t addr, const char *path)
     60{
     61        // printf(NAME ":     device with address %d is `%s'.\n", addr, path);
     62        printf("  Device %02d: %s\n", addr, path);
     63}
     64
     65static void print_hc_devices(devman_handle_t hc_handle)
     66{
     67        int rc;
     68        usb_hc_connection_t conn;
     69
     70        usb_hc_connection_initialize(&conn, hc_handle);
     71        rc = usb_hc_connection_open(&conn);
     72        if (rc != EOK) {
     73                printf(NAME ": failed to connect to HC: %s.\n",
     74                    str_error(rc));
     75                return;
     76        }
     77        usb_address_t addr;
     78        for (addr = 1; addr < 5; addr++) {
     79                devman_handle_t dev_handle;
     80                rc = usb_hc_get_handle_by_address(&conn, addr, &dev_handle);
     81                if (rc != EOK) {
     82                        continue;
     83                }
     84                char path[MAX_PATH_LENGTH];
     85                rc = devman_get_device_path(dev_handle, path, MAX_PATH_LENGTH);
     86                if (rc != EOK) {
     87                        continue;
     88                }
     89                print_found_dev(addr, path);
     90        }
     91        usb_hc_connection_close(&conn);
     92}
    5293
    5394int main(int argc, char *argv[])
     
    69110                        continue;
    70111                }
    71                 printf(NAME ": host controller %zu is `%s'.\n",
    72                     class_index, path);
     112                print_found_hc(class_index, path);
     113                print_hc_devices(hc_handle);
    73114        }
    74115
  • uspace/app/usbinfo/dev.c

    r68b614e rf50f722  
    4040#include "usbinfo.h"
    4141
    42 usbinfo_device_t *prepare_device(devman_handle_t hc_handle,
    43     usb_address_t dev_addr)
     42usbinfo_device_t *prepare_device(const char *name,
     43    devman_handle_t hc_handle, usb_address_t dev_addr)
    4444{
    4545        usbinfo_device_t *dev = malloc(sizeof(usbinfo_device_t));
     
    5555        if (rc != EOK) {
    5656                fprintf(stderr,
    57                     NAME ": failed to create connection to the device: %s.\n",
    58                     str_error(rc));
     57                    NAME ": failed to create connection to device %s: %s.\n",
     58                    name, str_error(rc));
    5959                goto leave;
    6060        }
     
    6464        if (rc != EOK) {
    6565                fprintf(stderr,
    66                     NAME ": failed to create default control pipe: %s.\n",
    67                     str_error(rc));
     66                    NAME ": failed to create default control pipe to %s: %s.\n",
     67                    name, str_error(rc));
    6868                goto leave;
    6969        }
     
    7171        rc = usb_pipe_probe_default_control(&dev->ctrl_pipe);
    7272        if (rc != EOK) {
    73                 fprintf(stderr,
    74                     NAME ": probing default control pipe failed: %s.\n",
    75                     str_error(rc));
     73                if (rc == ENOENT) {
     74                        fprintf(stderr, NAME ": " \
     75                            "device %s not present or malfunctioning.\n",
     76                            name);
     77                } else {
     78                        fprintf(stderr, NAME ": " \
     79                            "probing default control pipe of %s failed: %s.\n",
     80                            name, str_error(rc));
     81                }
    7682                goto leave;
    7783        }
     
    8490        if (rc != EOK) {
    8591                fprintf(stderr,
    86                     NAME ": failed to retrieve device descriptor: %s.\n",
    87                     str_error(rc));
     92                    NAME ": failed to retrieve device descriptor of %s: %s.\n",
     93                    name, str_error(rc));
    8894                goto leave;
    8995        }
     
    9399            &dev->full_configuration_descriptor_size);
    94100        if (rc != EOK) {
    95                 fprintf(stderr,
    96                     NAME ": failed to retrieve configuration descriptor: %s.\n",
    97                     str_error(rc));
     101                fprintf(stderr, NAME ": " \
     102                    "failed to retrieve configuration descriptor of %s: %s.\n",
     103                    name, str_error(rc));
    98104                goto leave;
    99105        }
  • uspace/app/usbinfo/main.c

    r68b614e rf50f722  
    308308                }
    309309
    310                 usbinfo_device_t *dev = prepare_device(hc_handle, dev_addr);
     310                usbinfo_device_t *dev = prepare_device(devpath,
     311                    hc_handle, dev_addr);
    311312                if (dev == NULL) {
    312313                        continue;
  • uspace/app/usbinfo/usbinfo.h

    r68b614e rf50f722  
    7171}
    7272
    73 usbinfo_device_t *prepare_device(devman_handle_t, usb_address_t);
     73usbinfo_device_t *prepare_device(const char *, devman_handle_t, usb_address_t);
    7474void destroy_device(usbinfo_device_t *);
    7575
  • uspace/drv/ehci-hcd/hc_iface.c

    r68b614e rf50f722  
    106106}
    107107
     108/** Find device handle by USB address.
     109 *
     110 * @param[in] fun DDF function that was called.
     111 * @param[in] address Address in question.
     112 * @param[out] handle Where to store device handle if found.
     113 * @return Error code.
     114 */
     115static int find_by_address(ddf_fun_t *fun, usb_address_t address,
     116    devman_handle_t *handle)
     117{
     118        UNSUPPORTED("find_by_address");
     119
     120        return ENOTSUP;
     121}
     122
    108123/** Release previously requested address.
    109124 *
     
    321336        .request_address = request_address,
    322337        .bind_address = bind_address,
     338        .find_by_address = find_by_address,
    323339        .release_address = release_address,
    324340
  • uspace/drv/ohci/hc.c

    r68b614e rf50f722  
    9595}
    9696/*----------------------------------------------------------------------------*/
    97 int hc_init(hc_t *instance, ddf_fun_t *fun, ddf_dev_t *dev,
    98     uintptr_t regs, size_t reg_size, bool interrupts)
     97int hc_init(hc_t *instance, uintptr_t regs, size_t reg_size, bool interrupts)
    9998{
    10099        assert(instance);
  • uspace/drv/ohci/hc.h

    r68b614e rf50f722  
    7777int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun);
    7878
    79 int hc_init(hc_t *instance, ddf_fun_t *fun, ddf_dev_t *dev,
    80      uintptr_t regs, size_t reg_size, bool interrupts);
     79int hc_init(hc_t *instance, uintptr_t regs, size_t reg_size, bool interrupts);
    8180
    8281void hc_start_hw(hc_t *instance);
  • uspace/drv/ohci/iface.c

    r68b614e rf50f722  
    122122        return EOK;
    123123}
     124
     125
     126/** Find device handle by address interface function.
     127 *
     128 * @param[in] fun DDF function that was called.
     129 * @param[in] address Address in question.
     130 * @param[out] handle Where to store device handle if found.
     131 * @return Error code.
     132 */
     133static int find_by_address(ddf_fun_t *fun, usb_address_t address,
     134    devman_handle_t *handle)
     135{
     136        assert(fun);
     137        hc_t *hc = fun_to_hc(fun);
     138        assert(hc);
     139        bool found =
     140            usb_device_keeper_find_by_address(&hc->manager, address, handle);
     141        return found ? EOK : ENOENT;
     142}
     143
    124144/*----------------------------------------------------------------------------*/
    125145/** Release address interface function
     
    402422        .request_address = request_address,
    403423        .bind_address = bind_address,
     424        .find_by_address = find_by_address,
    404425        .release_address = release_address,
    405426
  • uspace/drv/ohci/main.c

    r68b614e rf50f722  
    4343#define NAME "ohci"
    4444
    45 static int ohci_add_device(ddf_dev_t *device);
     45/** Initializes a new ddf driver instance of OHCI hcd.
     46 *
     47 * @param[in] device DDF instance of the device to initialize.
     48 * @return Error code.
     49 */
     50static int ohci_add_device(ddf_dev_t *device)
     51{
     52        usb_log_debug("ohci_add_device() called\n");
     53        assert(device);
     54
     55        int ret = device_setup_ohci(device);
     56        if (ret != EOK) {
     57                usb_log_error("Failed to initialize OHCI driver: %s.\n",
     58                    str_error(ret));
     59                return ret;
     60        }
     61        usb_log_info("Controlling new OHCI device '%s'.\n", device->name);
     62
     63        return EOK;
     64}
    4665/*----------------------------------------------------------------------------*/
    4766static driver_ops_t ohci_driver_ops = {
     
    5372        .driver_ops = &ohci_driver_ops
    5473};
    55 /*----------------------------------------------------------------------------*/
    56 /** Initializes a new ddf driver instance of OHCI hcd.
    57  *
    58  * @param[in] device DDF instance of the device to initialize.
    59  * @return Error code.
    60  */
    61 int ohci_add_device(ddf_dev_t *device)
    62 {
    63         usb_log_debug("ohci_add_device() called\n");
    64         assert(device);
    65         ohci_t *ohci = malloc(sizeof(ohci_t));
    66         if (ohci == NULL) {
    67                 usb_log_error("Failed to allocate OHCI driver.\n");
    68                 return ENOMEM;
    69         }
    70 
    71         int ret = ohci_init(ohci, device);
    72         if (ret != EOK) {
    73                 usb_log_error("Failed to initialize OHCI driver: %s.\n",
    74                     str_error(ret));
    75                 return ret;
    76         }
    77 //      device->driver_data = ohci;
    78         hc_register_hub(&ohci->hc, ohci->rh_fun);
    79 
    80         usb_log_info("Controlling new OHCI device `%s'.\n", device->name);
    81 
    82         return EOK;
    83 }
    8474/*----------------------------------------------------------------------------*/
    8575/** Initializes global driver structures (NONE).
  • uspace/drv/ohci/ohci.c

    r68b614e rf50f722  
    4444#include "iface.h"
    4545#include "pci.h"
     46#include "hc.h"
     47#include "root_hub.h"
     48
     49typedef struct ohci {
     50        ddf_fun_t *hc_fun;
     51        ddf_fun_t *rh_fun;
     52
     53        hc_t hc;
     54        rh_t rh;
     55} ohci_t;
     56
     57static inline ohci_t * dev_to_ohci(ddf_dev_t *dev)
     58{
     59        assert(dev);
     60        assert(dev->driver_data);
     61        return dev->driver_data;
     62}
    4663
    4764/** IRQ handling callback, identifies device
     
    5370static void irq_handler(ddf_dev_t *dev, ipc_callid_t iid, ipc_call_t *call)
    5471{
    55         assert(dev);
    56         assert(dev->driver_data);
    57         hc_t *hc = &((ohci_t*)dev->driver_data)->hc;
    58         uint16_t status = IPC_GET_ARG1(*call);
     72        hc_t *hc = &dev_to_ohci(dev)->hc;
    5973        assert(hc);
     74        const uint16_t status = IPC_GET_ARG1(*call);
    6075        hc_interrupt(hc, status);
    6176}
     
    7186{
    7287        assert(fun);
    73         usb_device_keeper_t *manager = &((ohci_t*)fun->dev->driver_data)->hc.manager;
     88        usb_device_keeper_t *manager = &dev_to_ohci(fun->dev)->hc.manager;
    7489
    7590        usb_address_t addr = usb_device_keeper_find(manager, handle);
     
    94109    ddf_fun_t *fun, devman_handle_t *handle)
    95110{
    96         assert(handle);
    97         ddf_fun_t *hc_fun = ((ohci_t*)fun->dev->driver_data)->hc_fun;
    98         assert(hc_fun != NULL);
    99 
    100         *handle = hc_fun->handle;
     111        assert(fun);
     112        ddf_fun_t *hc_fun = dev_to_ohci(fun->dev)->hc_fun;
     113        assert(hc_fun);
     114
     115        if (handle != NULL)
     116                *handle = hc_fun->handle;
    101117        return EOK;
    102118}
    103119/*----------------------------------------------------------------------------*/
    104 /** This iface is generic for both RH and HC. */
     120/** Root hub USB interface */
    105121static usb_iface_t usb_iface = {
    106122        .get_hc_handle = usb_iface_get_hc_handle,
     
    108124};
    109125/*----------------------------------------------------------------------------*/
     126/** Standard USB HC options (HC interface) */
    110127static ddf_dev_ops_t hc_ops = {
    111128        .interfaces[USBHC_DEV_IFACE] = &hc_iface, /* see iface.h/c */
    112129};
    113130/*----------------------------------------------------------------------------*/
     131/** Standard USB RH options (RH interface) */
    114132static ddf_dev_ops_t rh_ops = {
    115133        .interfaces[USB_DEV_IFACE] = &usb_iface,
     
    118136/** Initialize hc and rh ddf structures and their respective drivers.
    119137 *
     138 * @param[in] device DDF instance of the device to use.
    120139 * @param[in] instance OHCI structure to use.
    121  * @param[in] device DDF instance of the device to use.
    122140 *
    123141 * This function does all the preparatory work for hc and rh drivers:
     
    127145 *  - registers interrupt handler
    128146 */
    129 int ohci_init(ohci_t *instance, ddf_dev_t *device)
    130 {
    131         assert(instance);
    132         instance->hc_fun = NULL;
     147int device_setup_ohci(ddf_dev_t *device)
     148{
     149        ohci_t *instance = malloc(sizeof(ohci_t));
     150        if (instance == NULL) {
     151                usb_log_error("Failed to allocate OHCI driver.\n");
     152                return ENOMEM;
     153        }
     154
     155#define CHECK_RET_DEST_FREE_RETURN(ret, message...) \
     156if (ret != EOK) { \
     157        if (instance->hc_fun) { \
     158                instance->hc_fun->ops = NULL; \
     159                instance->hc_fun->driver_data = NULL; \
     160                ddf_fun_destroy(instance->hc_fun); \
     161        } \
     162        if (instance->rh_fun) { \
     163                instance->rh_fun->ops = NULL; \
     164                instance->rh_fun->driver_data = NULL; \
     165                ddf_fun_destroy(instance->rh_fun); \
     166        } \
     167        free(instance); \
     168        usb_log_error(message); \
     169        return ret; \
     170} else (void)0
     171
    133172        instance->rh_fun = NULL;
    134 #define CHECK_RET_DEST_FUN_RETURN(ret, message...) \
    135 if (ret != EOK) { \
    136         usb_log_error(message); \
    137         if (instance->hc_fun) \
    138                 ddf_fun_destroy(instance->hc_fun); \
    139         if (instance->rh_fun) \
    140                 ddf_fun_destroy(instance->rh_fun); \
    141         return ret; \
    142 }
    143 
    144         uintptr_t mem_reg_base = 0;
    145         size_t mem_reg_size = 0;
     173        instance->hc_fun = ddf_fun_create(device, fun_exposed, "ohci-hc");
     174        int ret = instance->hc_fun ? EOK : ENOMEM;
     175        CHECK_RET_DEST_FREE_RETURN(ret, "Failed to create OHCI HC function.\n");
     176        instance->hc_fun->ops = &hc_ops;
     177        instance->hc_fun->driver_data = &instance->hc;
     178
     179        instance->rh_fun = ddf_fun_create(device, fun_inner, "ohci-rh");
     180        ret = instance->rh_fun ? EOK : ENOMEM;
     181        CHECK_RET_DEST_FREE_RETURN(ret, "Failed to create OHCI RH function.\n");
     182        instance->rh_fun->ops = &rh_ops;
     183
     184        uintptr_t reg_base = 0;
     185        size_t reg_size = 0;
    146186        int irq = 0;
    147187
    148         int ret =
    149             pci_get_my_registers(device, &mem_reg_base, &mem_reg_size, &irq);
    150         CHECK_RET_DEST_FUN_RETURN(ret,
     188        ret = pci_get_my_registers(device, &reg_base, &reg_size, &irq);
     189        CHECK_RET_DEST_FREE_RETURN(ret,
    151190            "Failed to get memory addresses for %" PRIun ": %s.\n",
    152191            device->handle, str_error(ret));
    153192        usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.\n",
    154             (void *) mem_reg_base, mem_reg_size, irq);
     193            (void *) reg_base, reg_size, irq);
    155194
    156195        bool interrupts = false;
    157196#ifdef CONFIG_USBHC_NO_INTERRUPTS
    158         usb_log_warning("Interrupts disabled in OS config, " \
     197        usb_log_warning("Interrupts disabled in OS config, "
    159198            "falling back to polling.\n");
    160199#else
     
    163202                usb_log_warning("Failed to enable interrupts: %s.\n",
    164203                    str_error(ret));
    165                 usb_log_info("HW interrupts not available, " \
     204                usb_log_info("HW interrupts not available, "
    166205                    "falling back to polling.\n");
    167206        } else {
     
    171210#endif
    172211
    173         instance->hc_fun = ddf_fun_create(device, fun_exposed, "ohci-hc");
    174         ret = (instance->hc_fun == NULL) ? ENOMEM : EOK;
    175         CHECK_RET_DEST_FUN_RETURN(ret,
    176             "Failed(%d) to create HC function.\n", ret);
    177 
    178         ret = hc_init(&instance->hc, instance->hc_fun, device,
    179             mem_reg_base, mem_reg_size, interrupts);
    180         CHECK_RET_DEST_FUN_RETURN(ret, "Failed(%d) to init ohci-hcd.\n", ret);
    181         instance->hc_fun->ops = &hc_ops;
    182         instance->hc_fun->driver_data = &instance->hc;
    183         ret = ddf_fun_bind(instance->hc_fun);
    184         CHECK_RET_DEST_FUN_RETURN(ret,
    185             "Failed(%d) to bind OHCI device function: %s.\n",
    186             ret, str_error(ret));
    187         ret = ddf_fun_add_to_class(instance->hc_fun, USB_HC_DDF_CLASS_NAME);
    188         CHECK_RET_DEST_FUN_RETURN(ret,
    189             "Failed to add OHCI to HC class: %s.\n", str_error(ret));
    190 
    191 #undef CHECK_RET_HC_RETURN
     212        ret = hc_init(&instance->hc, reg_base, reg_size, interrupts);
     213        CHECK_RET_DEST_FREE_RETURN(ret, "Failed(%d) to init ohci-hcd.\n", ret);
    192214
    193215#define CHECK_RET_FINI_RETURN(ret, message...) \
    194216if (ret != EOK) { \
    195         usb_log_error(message); \
    196         if (instance->hc_fun) \
    197                 ddf_fun_destroy(instance->hc_fun); \
    198         if (instance->rh_fun) \
    199                 ddf_fun_destroy(instance->rh_fun); \
    200217        hc_fini(&instance->hc); \
    201         return ret; \
    202 }
     218        CHECK_RET_DEST_FREE_RETURN(ret, message); \
     219} else (void)0
    203220
    204221        /* It does no harm if we register this on polling */
     
    208225            "Failed(%d) to register interrupt handler.\n", ret);
    209226
    210         instance->rh_fun = ddf_fun_create(device, fun_inner, "ohci-rh");
    211         ret = (instance->rh_fun == NULL) ? ENOMEM : EOK;
     227        ret = ddf_fun_bind(instance->hc_fun);
    212228        CHECK_RET_FINI_RETURN(ret,
    213             "Failed(%d) to create root hub function.\n", ret);
    214 
    215 
    216         instance->rh_fun->ops = &rh_ops;
    217         instance->rh_fun->driver_data = NULL;
    218        
     229            "Failed(%d) to bind OHCI device function: %s.\n",
     230            ret, str_error(ret));
     231
     232        ret = ddf_fun_add_to_class(instance->hc_fun, USB_HC_DDF_CLASS_NAME);
     233        CHECK_RET_FINI_RETURN(ret,
     234            "Failed to add OHCI to HC class: %s.\n", str_error(ret));
     235
    219236        device->driver_data = instance;
    220237
    221238        hc_start_hw(&instance->hc);
     239        hc_register_hub(&instance->hc, instance->rh_fun);
    222240        return EOK;
     241
     242#undef CHECK_RET_DEST_FUN_RETURN
    223243#undef CHECK_RET_FINI_RETURN
    224244}
  • uspace/drv/ohci/ohci.h

    r68b614e rf50f722  
    3838#include <ddf/driver.h>
    3939
    40 #include "hc.h"
    41 #include "root_hub.h"
    42 
    43 typedef struct ohci {
    44         ddf_fun_t *hc_fun;
    45         ddf_fun_t *rh_fun;
    46 
    47         hc_t hc;
    48         rh_t rh;
    49 } ohci_t;
    50 
    51 int ohci_init(ohci_t *instance, ddf_dev_t *device);
     40int device_setup_ohci(ddf_dev_t *device);
    5241
    5342#endif
  • uspace/drv/ohci/pci.c

    r68b614e rf50f722  
    5858    uintptr_t *mem_reg_address, size_t *mem_reg_size, int *irq_no)
    5959{
    60         assert(dev != NULL);
     60        assert(dev);
     61        assert(mem_reg_address);
     62        assert(mem_reg_size);
     63        assert(irq_no);
    6164
    6265        int parent_phone = devman_parent_device_connect(dev->handle,
  • uspace/drv/ohci/root_hub.c

    r68b614e rf50f722  
    237237                return ENOMEM;
    238238
    239         usb_log_info("OHCI root hub with %d ports initialized.\n",
     239        usb_log_info("OHCI root hub with %zu ports initialized.\n",
    240240            instance->port_count);
    241241
  • uspace/drv/uhci-hcd/hc.c

    r68b614e rf50f722  
    6060 *
    6161 * @param[in] instance Memory place to initialize.
    62  * @param[in] fun DDF function.
    6362 * @param[in] regs Address of I/O control registers.
    6463 * @param[in] size Size of I/O control registers.
     
    6968 * interrupt fibrils.
    7069 */
    71 int hc_init(hc_t *instance, ddf_fun_t *fun,
    72     void *regs, size_t reg_size, bool interrupts)
     70int hc_init(hc_t *instance, void *regs, size_t reg_size, bool interrupts)
    7371{
    7472        assert(reg_size >= sizeof(regs_t));
  • uspace/drv/uhci-hcd/hc.h

    r68b614e rf50f722  
    136136} hc_t;
    137137
    138 int hc_init(hc_t *instance, ddf_fun_t *fun,
    139     void *regs, size_t reg_size, bool interupts);
     138int hc_init(hc_t *instance, void *regs, size_t reg_size, bool interupts);
    140139
    141140int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch);
  • uspace/drv/uhci-hcd/iface.c

    r68b614e rf50f722  
    122122        return EOK;
    123123}
     124
     125/** Find device handle by address interface function.
     126 *
     127 * @param[in] fun DDF function that was called.
     128 * @param[in] address Address in question.
     129 * @param[out] handle Where to store device handle if found.
     130 * @return Error code.
     131 */
     132static int find_by_address(ddf_fun_t *fun, usb_address_t address,
     133    devman_handle_t *handle)
     134{
     135        assert(fun);
     136        hc_t *hc = fun_to_hc(fun);
     137        assert(hc);
     138        bool found =
     139            usb_device_keeper_find_by_address(&hc->manager, address, handle);
     140        return found ? EOK : ENOENT;
     141}
     142
    124143/*----------------------------------------------------------------------------*/
    125144/** Release address interface function
     
    352371        .request_address = request_address,
    353372        .bind_address = bind_address,
     373        .find_by_address = find_by_address,
    354374        .release_address = release_address,
    355375
  • uspace/drv/uhci-hcd/main.c

    r68b614e rf50f722  
    6464        assert(device);
    6565
    66         uhci_t *uhci = malloc(sizeof(uhci_t));
    67         if (uhci == NULL) {
    68                 usb_log_error("Failed to allocate UHCI driver.\n");
    69                 return ENOMEM;
    70         }
    71 
    72         int ret = uhci_init(uhci, device);
     66        int ret = device_setup_uhci(device);
    7367        if (ret != EOK) {
    7468                usb_log_error("Failed to initialize UHCI driver: %s.\n",
     
    7670                return ret;
    7771        }
    78         device->driver_data = uhci;
    79 
    8072        usb_log_info("Controlling new UHCI device '%s'.\n", device->name);
    8173
  • uspace/drv/uhci-hcd/uhci.c

    r68b614e rf50f722  
    4444#include "pci.h"
    4545
     46#include "hc.h"
     47#include "root_hub.h"
     48
     49/** Structure representing both functions of UHCI hc, USB host controller
     50 * and USB root hub */
     51typedef struct uhci {
     52        /** Pointer to DDF represenation of UHCI host controller */
     53        ddf_fun_t *hc_fun;
     54        /** Pointer to DDF represenation of UHCI root hub */
     55        ddf_fun_t *rh_fun;
     56
     57        /** Internal driver's represenation of UHCI host controller */
     58        hc_t hc;
     59        /** Internal driver's represenation of UHCI root hub */
     60        rh_t rh;
     61} uhci_t;
     62
     63static inline uhci_t * dev_to_uhci(ddf_dev_t *dev)
     64{
     65        assert(dev);
     66        assert(dev->driver_data);
     67        return dev->driver_data;
     68}
     69/*----------------------------------------------------------------------------*/
    4670/** IRQ handling callback, forward status from call to diver structure.
    4771 *
     
    6993{
    7094        assert(fun);
    71         usb_device_keeper_t *manager =
    72             &((uhci_t*)fun->dev->driver_data)->hc.manager;
    73 
     95        usb_device_keeper_t *manager = &dev_to_uhci(fun->dev)->hc.manager;
    7496        usb_address_t addr = usb_device_keeper_find(manager, handle);
     97
    7598        if (addr < 0) {
    7699                return addr;
     
    93116    ddf_fun_t *fun, devman_handle_t *handle)
    94117{
    95         assert(handle);
    96         ddf_fun_t *hc_fun = ((uhci_t*)fun->dev->driver_data)->hc_fun;
    97         assert(hc_fun != NULL);
    98 
    99         *handle = hc_fun->handle;
     118        assert(fun);
     119        ddf_fun_t *hc_fun = dev_to_uhci(fun->dev)->hc_fun;
     120        assert(hc_fun);
     121
     122        if (handle != NULL)
     123                *handle = hc_fun->handle;
    100124        return EOK;
    101125}
     
    126150static hw_res_ops_t hw_res_iface = {
    127151        .get_resource_list = get_resource_list,
    128         .enable_interrupt = NULL
     152        .enable_interrupt = NULL,
    129153};
    130154/*----------------------------------------------------------------------------*/
     
    146170 *  - registers interrupt handler
    147171 */
    148 int uhci_init(uhci_t *instance, ddf_dev_t *device)
    149 {
    150         assert(instance);
    151         instance->hc_fun = NULL;
     172int device_setup_uhci(ddf_dev_t *device)
     173{
     174        assert(device);
     175        uhci_t *instance = malloc(sizeof(uhci_t));
     176        if (instance == NULL) {
     177                usb_log_error("Failed to allocate OHCI driver.\n");
     178                return ENOMEM;
     179        }
     180
     181#define CHECK_RET_DEST_FREE_RETURN(ret, message...) \
     182if (ret != EOK) { \
     183        if (instance->hc_fun) \
     184                instance->hc_fun->ops = NULL; \
     185                instance->hc_fun->driver_data = NULL; \
     186                ddf_fun_destroy(instance->hc_fun); \
     187        if (instance->rh_fun) {\
     188                instance->rh_fun->ops = NULL; \
     189                instance->rh_fun->driver_data = NULL; \
     190                ddf_fun_destroy(instance->rh_fun); \
     191        } \
     192        free(instance); \
     193        usb_log_error(message); \
     194        return ret; \
     195} else (void)0
     196
    152197        instance->rh_fun = NULL;
    153 #define CHECK_RET_DEST_FUN_RETURN(ret, message...) \
    154 if (ret != EOK) { \
    155         usb_log_error(message); \
    156         if (instance->hc_fun) \
    157                 ddf_fun_destroy(instance->hc_fun); \
    158         if (instance->rh_fun) \
    159                 ddf_fun_destroy(instance->rh_fun); \
    160         return ret; \
    161 }
    162 
    163         uintptr_t io_reg_base = 0;
    164         size_t io_reg_size = 0;
     198        instance->hc_fun = ddf_fun_create(device, fun_exposed, "uhci-hc");
     199        int ret = (instance->hc_fun == NULL) ? ENOMEM : EOK;
     200        CHECK_RET_DEST_FREE_RETURN(ret, "Failed to create UHCI HC function.\n");
     201        instance->hc_fun->ops = &hc_ops;
     202        instance->hc_fun->driver_data = &instance->hc;
     203
     204        instance->rh_fun = ddf_fun_create(device, fun_inner, "uhci-rh");
     205        ret = (instance->rh_fun == NULL) ? ENOMEM : EOK;
     206        CHECK_RET_DEST_FREE_RETURN(ret, "Failed to create UHCI RH function.\n");
     207        instance->rh_fun->ops = &rh_ops;
     208        instance->rh_fun->driver_data = &instance->rh;
     209
     210        uintptr_t reg_base = 0;
     211        size_t reg_size = 0;
    165212        int irq = 0;
    166213
    167         int ret =
    168             pci_get_my_registers(device, &io_reg_base, &io_reg_size, &irq);
    169         CHECK_RET_DEST_FUN_RETURN(ret,
     214        ret = pci_get_my_registers(device, &reg_base, &reg_size, &irq);
     215        CHECK_RET_DEST_FREE_RETURN(ret,
    170216            "Failed to get I/O addresses for %" PRIun ": %s.\n",
    171217            device->handle, str_error(ret));
    172218        usb_log_debug("I/O regs at 0x%p (size %zu), IRQ %d.\n",
    173             (void *) io_reg_base, io_reg_size, irq);
     219            (void *) reg_base, reg_size, irq);
    174220
    175221        ret = pci_disable_legacy(device);
    176         CHECK_RET_DEST_FUN_RETURN(ret,
     222        CHECK_RET_DEST_FREE_RETURN(ret,
    177223            "Failed(%d) to disable legacy USB: %s.\n", ret, str_error(ret));
    178224
     
    194240#endif
    195241
    196         instance->hc_fun = ddf_fun_create(device, fun_exposed, "uhci-hc");
    197         ret = (instance->hc_fun == NULL) ? ENOMEM : EOK;
    198         CHECK_RET_DEST_FUN_RETURN(ret,
    199             "Failed(%d) to create HC function: %s.\n", ret, str_error(ret));
    200 
    201         ret = hc_init(&instance->hc, instance->hc_fun,
    202             (void*)io_reg_base, io_reg_size, interrupts);
    203         CHECK_RET_DEST_FUN_RETURN(ret,
     242
     243        ret = hc_init(&instance->hc, (void*)reg_base, reg_size, interrupts);
     244        CHECK_RET_DEST_FREE_RETURN(ret,
    204245            "Failed(%d) to init uhci-hcd: %s.\n", ret, str_error(ret));
    205 
    206         instance->hc_fun->ops = &hc_ops;
    207         instance->hc_fun->driver_data = &instance->hc;
    208         ret = ddf_fun_bind(instance->hc_fun);
    209         CHECK_RET_DEST_FUN_RETURN(ret,
    210             "Failed(%d) to bind UHCI device function: %s.\n",
    211             ret, str_error(ret));
    212         ret = ddf_fun_add_to_class(instance->hc_fun, USB_HC_DDF_CLASS_NAME);
    213         CHECK_RET_DEST_FUN_RETURN(ret,
    214             "Failed to add UHCI to HC class: %s.\n", str_error(ret));
    215 
    216 #undef CHECK_RET_HC_RETURN
    217246
    218247#define CHECK_RET_FINI_RETURN(ret, message...) \
    219248if (ret != EOK) { \
    220         usb_log_error(message); \
    221         if (instance->hc_fun) \
    222                 ddf_fun_destroy(instance->hc_fun); \
    223         if (instance->rh_fun) \
    224                 ddf_fun_destroy(instance->rh_fun); \
    225249        hc_fini(&instance->hc); \
     250        CHECK_RET_DEST_FREE_RETURN(ret, message); \
    226251        return ret; \
    227 }
     252} else (void)0
    228253
    229254        /* It does no harm if we register this on polling */
     
    234259            ret, str_error(ret));
    235260
    236         instance->rh_fun = ddf_fun_create(device, fun_inner, "uhci-rh");
    237         ret = (instance->rh_fun == NULL) ? ENOMEM : EOK;
    238         CHECK_RET_FINI_RETURN(ret,
    239             "Failed(%d) to create root hub function: %s.\n",
     261        ret = ddf_fun_bind(instance->hc_fun);
     262        CHECK_RET_FINI_RETURN(ret,
     263            "Failed(%d) to bind UHCI device function: %s.\n",
    240264            ret, str_error(ret));
     265
     266        ret = ddf_fun_add_to_class(instance->hc_fun, USB_HC_DDF_CLASS_NAME);
     267        CHECK_RET_FINI_RETURN(ret,
     268            "Failed to add UHCI to HC class: %s.\n", str_error(ret));
    241269
    242270        ret = rh_init(&instance->rh, instance->rh_fun,
     
    245273            "Failed(%d) to setup UHCI root hub: %s.\n", ret, str_error(ret));
    246274
    247         instance->rh_fun->ops = &rh_ops;
    248         instance->rh_fun->driver_data = &instance->rh;
    249275        ret = ddf_fun_bind(instance->rh_fun);
    250276        CHECK_RET_FINI_RETURN(ret,
    251277            "Failed(%d) to register UHCI root hub: %s.\n", ret, str_error(ret));
    252278
     279        device->driver_data = instance;
    253280        return EOK;
    254281#undef CHECK_RET_FINI_RETURN
  • uspace/drv/uhci-hcd/uhci.h

    r68b614e rf50f722  
    3838#include <ddf/driver.h>
    3939
    40 #include "hc.h"
    41 #include "root_hub.h"
    42 
    43 /** Structure representing both functions of UHCI hc, USB host controller
    44  * and USB root hub */
    45 typedef struct uhci {
    46         /** Pointer to DDF represenation of UHCI host controller */
    47         ddf_fun_t *hc_fun;
    48         /** Pointer to DDF represenation of UHCI root hub */
    49         ddf_fun_t *rh_fun;
    50 
    51         /** Internal driver's represenation of UHCI host controller */
    52         hc_t hc;
    53         /** Internal driver's represenation of UHCI root hub */
    54         rh_t rh;
    55 } uhci_t;
    56 
    57 int uhci_init(uhci_t *instance, ddf_dev_t *device);
     40int device_setup_uhci(ddf_dev_t *device);
    5841#endif
    5942/**
  • uspace/drv/vhc/connhost.c

    r68b614e rf50f722  
    9494}
    9595
     96/** Find device handle by address interface function.
     97 *
     98 * @param[in] fun DDF function that was called.
     99 * @param[in] address Address in question.
     100 * @param[out] handle Where to store device handle if found.
     101 * @return Error code.
     102 */
     103static int find_by_address(ddf_fun_t *fun, usb_address_t address,
     104    devman_handle_t *handle)
     105{
     106        VHC_DATA(vhc, fun);
     107        bool found =
     108            usb_device_keeper_find_by_address(&vhc->dev_keeper, address, handle);
     109        return found ? EOK : ENOENT;
     110}
     111
    96112/** Release previously requested address.
    97113 *
     
    444460        .request_address = request_address,
    445461        .bind_address = bind_address,
     462        .find_by_address = find_by_address,
    446463        .release_address = release_address,
    447464
  • uspace/lib/drv/generic/remote_usbhc.c

    r68b614e rf50f722  
    5252static void remote_usbhc_request_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    5353static void remote_usbhc_bind_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     54static void remote_usbhc_find_by_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    5455static void remote_usbhc_release_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    5556static void remote_usbhc_register_endpoint(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     
    6162        remote_usbhc_request_address,
    6263        remote_usbhc_bind_address,
     64        remote_usbhc_find_by_address,
    6365        remote_usbhc_release_address,
    6466
     
    163165}
    164166
     167void remote_usbhc_find_by_address(ddf_fun_t *fun, void *iface,
     168    ipc_callid_t callid, ipc_call_t *call)
     169{
     170        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
     171
     172        if (!usb_iface->find_by_address) {
     173                async_answer_0(callid, ENOTSUP);
     174                return;
     175        }
     176
     177        usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call);
     178        devman_handle_t handle;
     179        int rc = usb_iface->find_by_address(fun, address, &handle);
     180
     181        if (rc == EOK) {
     182                async_answer_1(callid, EOK, handle);
     183        } else {
     184                async_answer_0(callid, rc);
     185        }
     186}
     187
    165188void remote_usbhc_release_address(ddf_fun_t *fun, void *iface,
    166189    ipc_callid_t callid, ipc_call_t *call)
     
    302325        async_transaction_t *trans = async_transaction_create(callid);
    303326        if (trans == NULL) {
     327                async_answer_0(data_callid, ENOMEM);
    304328                async_answer_0(callid, ENOMEM);
    305329                return;
     
    314338
    315339        if (rc != EOK) {
     340                async_answer_0(data_callid, rc);
    316341                async_answer_0(callid, rc);
    317342                async_transaction_destroy(trans);
     
    460485        async_transaction_t *trans = async_transaction_create(callid);
    461486        if (trans == NULL) {
     487                async_answer_0(data_callid, ENOMEM);
    462488                async_answer_0(callid, ENOMEM);
    463489                free(setup_packet);
     
    469495        trans->buffer = malloc(data_len);
    470496        if (trans->buffer == NULL) {
     497                async_answer_0(data_callid, ENOMEM);
    471498                async_answer_0(callid, ENOMEM);
    472499                async_transaction_destroy(trans);
     
    480507
    481508        if (rc != EOK) {
     509                async_answer_0(data_callid, rc);
    482510                async_answer_0(callid, rc);
    483511                async_transaction_destroy(trans);
  • uspace/lib/drv/include/usb_iface.h

    r68b614e rf50f722  
    4949         * - arbitrary error code if returned by remote implementation
    5050         * - EOK - handle found, first parameter contains the USB address
     51         *
     52         * The handle must be the one used for binding USB address with
     53         * it (IPC_M_USBHC_BIND_ADDRESS), otherwise the host controller
     54         * (that this request would eventually reach) would not be able
     55         * to find it.
     56         * The problem is that this handle is actually assigned to the
     57         * function inside driver of the parent device (usually hub driver).
     58         * To bypass this problem, the initial caller specify handle as
     59         * zero and the first parent assigns the actual value.
     60         * See usb_iface_get_address_hub_child_impl() implementation
     61         * that could be assigned to device ops of a child device of in a
     62         * hub driver.
     63         * For example, the USB multi interface device driver (MID)
     64         * passes this initial zero without any modification because the
     65         * handle must be resolved by its parent.
    5166         */
    5267        IPC_M_USB_GET_ADDRESS,
  • uspace/lib/drv/include/usbhc_iface.h

    r68b614e rf50f722  
    105105        IPC_M_USBHC_BIND_ADDRESS,
    106106
     107        /** Get handle binded with given USB address.
     108         * Parameters
     109         * - USB address
     110         * Answer:
     111         * - EOK - address binded, first parameter is the devman handle
     112         * - ENOENT - address is not in use at the moment
     113         */
     114        IPC_M_USBHC_GET_HANDLE_BY_ADDRESS,
     115
    107116        /** Release address in use.
    108117         * Arguments:
     
    207216        int (*request_address)(ddf_fun_t *, usb_speed_t, usb_address_t *);
    208217        int (*bind_address)(ddf_fun_t *, usb_address_t, devman_handle_t);
     218        int (*find_by_address)(ddf_fun_t *, usb_address_t, devman_handle_t *);
    209219        int (*release_address)(ddf_fun_t *, usb_address_t);
    210220
  • uspace/lib/usb/include/usb/host/device_keeper.h

    r68b614e rf50f722  
    8080    devman_handle_t handle);
    8181
     82bool usb_device_keeper_find_by_address(usb_device_keeper_t *instance,
     83    usb_address_t address, devman_handle_t *handle);
     84
    8285usb_speed_t usb_device_keeper_get_speed(usb_device_keeper_t *instance,
    8386    usb_address_t address);
  • uspace/lib/usb/include/usb/hub.h

    r68b614e rf50f722  
    6363    const usb_hc_attached_device_t *);
    6464int usb_hc_unregister_device(usb_hc_connection_t *, usb_address_t);
     65int usb_hc_get_handle_by_address(usb_hc_connection_t *, usb_address_t,
     66    devman_handle_t *);
    6567
    6668#endif
  • uspace/lib/usb/src/host/device_keeper.c

    r68b614e rf50f722  
    157157        return ENOENT;
    158158}
     159
     160/** Find devman handled assigned to USB address.
     161 *
     162 * @param[in] instance Device keeper structure to use.
     163 * @param[in] address Address the caller wants to find.
     164 * @param[out] handle Where to store found handle.
     165 * @return Whether such address is currently occupied.
     166 */
     167bool usb_device_keeper_find_by_address(usb_device_keeper_t *instance,
     168    usb_address_t address, devman_handle_t *handle)
     169{
     170        assert(instance);
     171        fibril_mutex_lock(&instance->guard);
     172        if ((address < 0) || (address >= USB_ADDRESS_COUNT)) {
     173                fibril_mutex_unlock(&instance->guard);
     174                return false;
     175        }
     176        if (!instance->devices[address].occupied) {
     177                fibril_mutex_unlock(&instance->guard);
     178                return false;
     179        }
     180
     181        if (handle != NULL) {
     182                *handle = instance->devices[address].handle;
     183        }
     184
     185        fibril_mutex_unlock(&instance->guard);
     186        return true;
     187}
     188
    159189/*----------------------------------------------------------------------------*/
    160190/** Get speed associated with the address
  • uspace/lib/usb/src/hub.c

    r68b614e rf50f722  
    117117            DEV_IFACE_ID(USBHC_DEV_IFACE),
    118118            IPC_M_USBHC_RELEASE_ADDRESS, address);
     119}
     120
     121/** Get handle of USB device with given address.
     122 *
     123 * @param[in] connection Opened connection to host controller.
     124 * @param[in] address Address of device in question.
     125 * @param[out] handle Where to write the device handle.
     126 * @return Error code.
     127 */
     128int usb_hc_get_handle_by_address(usb_hc_connection_t *connection,
     129    usb_address_t address, devman_handle_t *handle)
     130{
     131        CHECK_CONNECTION(connection);
     132
     133        sysarg_t tmp;
     134        int rc = async_req_2_1(connection->hc_phone,
     135            DEV_IFACE_ID(USBHC_DEV_IFACE),
     136            IPC_M_USBHC_GET_HANDLE_BY_ADDRESS,
     137            address, &tmp);
     138        if ((rc == EOK) && (handle != NULL)) {
     139                *handle = tmp;
     140        }
     141
     142        return rc;
    119143}
    120144
Note: See TracChangeset for help on using the changeset viewer.