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

Changeset 19065c7 in mainline


Ignore:
Timestamp:
2011-05-08T15:43:38Z (11 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master
Children:
3e4f2e0
Parents:
5dfee52 (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:

Merge development/ changes

Location:
uspace/drv
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/ohci/hc.c

    r5dfee52 r19065c7  
    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

    r5dfee52 r19065c7  
    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/main.c

    r5dfee52 r19065c7  
    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

    r5dfee52 r19065c7  
    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

    r5dfee52 r19065c7  
    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

    r5dfee52 r19065c7  
    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

    r5dfee52 r19065c7  
    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

    r5dfee52 r19065c7  
    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

    r5dfee52 r19065c7  
    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/main.c

    r5dfee52 r19065c7  
    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

    r5dfee52 r19065c7  
    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

    r5dfee52 r19065c7  
    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/**
Note: See TracChangeset for help on using the changeset viewer.