Changes in / [7b6f116:5dfee52] in mainline
- Location:
- uspace
- Files:
-
- 3 added
- 2 deleted
- 12 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/drv/ohci/hc.c
r7b6f116 r5dfee52 95 95 } 96 96 /*----------------------------------------------------------------------------*/ 97 int hc_init(hc_t *instance, uintptr_t regs, size_t reg_size, bool interrupts) 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) 98 99 { 99 100 assert(instance); -
uspace/drv/ohci/hc.h
r7b6f116 r5dfee52 77 77 int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun); 78 78 79 int hc_init(hc_t *instance, uintptr_t regs, size_t reg_size, bool interrupts); 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); 80 81 81 82 void hc_start_hw(hc_t *instance); -
uspace/drv/ohci/main.c
r7b6f116 r5dfee52 43 43 #define NAME "ohci" 44 44 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 */ 50 static 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 } 45 static int ohci_add_device(ddf_dev_t *device); 65 46 /*----------------------------------------------------------------------------*/ 66 47 static driver_ops_t ohci_driver_ops = { … … 72 53 .driver_ops = &ohci_driver_ops 73 54 }; 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 } 74 84 /*----------------------------------------------------------------------------*/ 75 85 /** Initializes global driver structures (NONE). -
uspace/drv/ohci/ohci.c
r7b6f116 r5dfee52 44 44 #include "iface.h" 45 45 #include "pci.h" 46 #include "hc.h"47 #include "root_hub.h"48 49 typedef 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 57 static 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 }63 46 64 47 /** IRQ handling callback, identifies device … … 70 53 static void irq_handler(ddf_dev_t *dev, ipc_callid_t iid, ipc_call_t *call) 71 54 { 72 hc_t *hc = &dev_to_ohci(dev)->hc; 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); 73 59 assert(hc); 74 const uint16_t status = IPC_GET_ARG1(*call);75 60 hc_interrupt(hc, status); 76 61 } … … 86 71 { 87 72 assert(fun); 88 usb_device_keeper_t *manager = & dev_to_ohci(fun->dev)->hc.manager;73 usb_device_keeper_t *manager = &((ohci_t*)fun->dev->driver_data)->hc.manager; 89 74 90 75 usb_address_t addr = usb_device_keeper_find(manager, handle); … … 109 94 ddf_fun_t *fun, devman_handle_t *handle) 110 95 { 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; 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; 117 101 return EOK; 118 102 } 119 103 /*----------------------------------------------------------------------------*/ 120 /** Root hub USB interface*/104 /** This iface is generic for both RH and HC. */ 121 105 static usb_iface_t usb_iface = { 122 106 .get_hc_handle = usb_iface_get_hc_handle, … … 124 108 }; 125 109 /*----------------------------------------------------------------------------*/ 126 /** Standard USB HC options (HC interface) */127 110 static ddf_dev_ops_t hc_ops = { 128 111 .interfaces[USBHC_DEV_IFACE] = &hc_iface, /* see iface.h/c */ 129 112 }; 130 113 /*----------------------------------------------------------------------------*/ 131 /** Standard USB RH options (RH interface) */132 114 static ddf_dev_ops_t rh_ops = { 133 115 .interfaces[USB_DEV_IFACE] = &usb_iface, … … 136 118 /** Initialize hc and rh ddf structures and their respective drivers. 137 119 * 120 * @param[in] instance OHCI structure to use. 138 121 * @param[in] device DDF instance of the device to use. 139 * @param[in] instance OHCI structure to use.140 122 * 141 123 * This function does all the preparatory work for hc and rh drivers: … … 145 127 * - registers interrupt handler 146 128 */ 147 int 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...) \ 129 int ohci_init(ohci_t *instance, ddf_dev_t *device) 130 { 131 assert(instance); 132 instance->hc_fun = NULL; 133 instance->rh_fun = NULL; 134 #define CHECK_RET_DEST_FUN_RETURN(ret, message...) \ 156 135 if (ret != EOK) { \ 157 if (instance->hc_fun) { \ 158 instance->hc_fun->ops = NULL; \ 159 instance->hc_fun->driver_data = NULL; \ 136 usb_log_error(message); \ 137 if (instance->hc_fun) \ 160 138 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; \ 139 if (instance->rh_fun) \ 165 140 ddf_fun_destroy(instance->rh_fun); \ 166 } \167 free(instance); \168 usb_log_error(message); \169 141 return ret; \ 170 } else (void)0 171 172 instance->rh_fun = NULL; 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; 142 } 143 144 uintptr_t mem_reg_base = 0; 145 size_t mem_reg_size = 0; 186 146 int irq = 0; 187 147 188 ret = pci_get_my_registers(device, ®_base, ®_size, &irq); 189 CHECK_RET_DEST_FREE_RETURN(ret, 148 int ret = 149 pci_get_my_registers(device, &mem_reg_base, &mem_reg_size, &irq); 150 CHECK_RET_DEST_FUN_RETURN(ret, 190 151 "Failed to get memory addresses for %" PRIun ": %s.\n", 191 152 device->handle, str_error(ret)); 192 153 usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.\n", 193 (void *) reg_base,reg_size, irq);154 (void *) mem_reg_base, mem_reg_size, irq); 194 155 195 156 bool interrupts = false; 196 157 #ifdef CONFIG_USBHC_NO_INTERRUPTS 197 usb_log_warning("Interrupts disabled in OS config, " 158 usb_log_warning("Interrupts disabled in OS config, " \ 198 159 "falling back to polling.\n"); 199 160 #else … … 202 163 usb_log_warning("Failed to enable interrupts: %s.\n", 203 164 str_error(ret)); 204 usb_log_info("HW interrupts not available, " 165 usb_log_info("HW interrupts not available, " \ 205 166 "falling back to polling.\n"); 206 167 } else { … … 210 171 #endif 211 172 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); 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 214 192 215 193 #define CHECK_RET_FINI_RETURN(ret, message...) \ 216 194 if (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); \ 217 200 hc_fini(&instance->hc); \ 218 CHECK_RET_DEST_FREE_RETURN(ret, message); \219 } else (void)0201 return ret; \ 202 } 220 203 221 204 /* It does no harm if we register this on polling */ … … 225 208 "Failed(%d) to register interrupt handler.\n", ret); 226 209 227 ret = ddf_fun_bind(instance->hc_fun); 210 instance->rh_fun = ddf_fun_create(device, fun_inner, "ohci-rh"); 211 ret = (instance->rh_fun == NULL) ? ENOMEM : EOK; 228 212 CHECK_RET_FINI_RETURN(ret, 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 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 236 219 device->driver_data = instance; 237 220 238 221 hc_start_hw(&instance->hc); 239 hc_register_hub(&instance->hc, instance->rh_fun);240 222 return EOK; 241 242 #undef CHECK_RET_DEST_FUN_RETURN243 223 #undef CHECK_RET_FINI_RETURN 244 224 } -
uspace/drv/ohci/ohci.h
r7b6f116 r5dfee52 38 38 #include <ddf/driver.h> 39 39 40 int device_setup_ohci(ddf_dev_t *device); 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); 41 52 42 53 #endif -
uspace/drv/ohci/pci.c
r7b6f116 r5dfee52 58 58 uintptr_t *mem_reg_address, size_t *mem_reg_size, int *irq_no) 59 59 { 60 assert(dev); 61 assert(mem_reg_address); 62 assert(mem_reg_size); 63 assert(irq_no); 60 assert(dev != NULL); 64 61 65 62 int parent_phone = devman_parent_device_connect(dev->handle, -
uspace/drv/ohci/root_hub.c
r7b6f116 r5dfee52 237 237 return ENOMEM; 238 238 239 usb_log_info("OHCI root hub with % zuports initialized.\n",239 usb_log_info("OHCI root hub with %d ports initialized.\n", 240 240 instance->port_count); 241 241 -
uspace/drv/uhci-hcd/hc.c
r7b6f116 r5dfee52 60 60 * 61 61 * @param[in] instance Memory place to initialize. 62 * @param[in] fun DDF function. 62 63 * @param[in] regs Address of I/O control registers. 63 64 * @param[in] size Size of I/O control registers. … … 68 69 * interrupt fibrils. 69 70 */ 70 int hc_init(hc_t *instance, void *regs, size_t reg_size, bool interrupts) 71 int hc_init(hc_t *instance, ddf_fun_t *fun, 72 void *regs, size_t reg_size, bool interrupts) 71 73 { 72 74 assert(reg_size >= sizeof(regs_t)); -
uspace/drv/uhci-hcd/hc.h
r7b6f116 r5dfee52 136 136 } hc_t; 137 137 138 int hc_init(hc_t *instance, void *regs, size_t reg_size, bool interupts); 138 int hc_init(hc_t *instance, ddf_fun_t *fun, 139 void *regs, size_t reg_size, bool interupts); 139 140 140 141 int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch); -
uspace/drv/uhci-hcd/main.c
r7b6f116 r5dfee52 64 64 assert(device); 65 65 66 int ret = device_setup_uhci(device); 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); 67 73 if (ret != EOK) { 68 74 usb_log_error("Failed to initialize UHCI driver: %s.\n", … … 70 76 return ret; 71 77 } 78 device->driver_data = uhci; 79 72 80 usb_log_info("Controlling new UHCI device '%s'.\n", device->name); 73 81 -
uspace/drv/uhci-hcd/uhci.c
r7b6f116 r5dfee52 44 44 #include "pci.h" 45 45 46 #include "hc.h"47 #include "root_hub.h"48 49 /** Structure representing both functions of UHCI hc, USB host controller50 * and USB root hub */51 typedef 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 63 static 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 /*----------------------------------------------------------------------------*/70 46 /** IRQ handling callback, forward status from call to diver structure. 71 47 * … … 93 69 { 94 70 assert(fun); 95 usb_device_keeper_t *manager = &dev_to_uhci(fun->dev)->hc.manager; 71 usb_device_keeper_t *manager = 72 &((uhci_t*)fun->dev->driver_data)->hc.manager; 73 96 74 usb_address_t addr = usb_device_keeper_find(manager, handle); 97 98 75 if (addr < 0) { 99 76 return addr; … … 116 93 ddf_fun_t *fun, devman_handle_t *handle) 117 94 { 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; 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; 124 100 return EOK; 125 101 } … … 150 126 static hw_res_ops_t hw_res_iface = { 151 127 .get_resource_list = get_resource_list, 152 .enable_interrupt = NULL ,128 .enable_interrupt = NULL 153 129 }; 154 130 /*----------------------------------------------------------------------------*/ … … 170 146 * - registers interrupt handler 171 147 */ 172 int 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...) \ 148 int uhci_init(uhci_t *instance, ddf_dev_t *device) 149 { 150 assert(instance); 151 instance->hc_fun = NULL; 152 instance->rh_fun = NULL; 153 #define CHECK_RET_DEST_FUN_RETURN(ret, message...) \ 182 154 if (ret != EOK) { \ 155 usb_log_error(message); \ 183 156 if (instance->hc_fun) \ 184 instance->hc_fun->ops = NULL; \185 instance->hc_fun->driver_data = NULL; \186 157 ddf_fun_destroy(instance->hc_fun); \ 187 if (instance->rh_fun) {\ 188 instance->rh_fun->ops = NULL; \ 189 instance->rh_fun->driver_data = NULL; \ 158 if (instance->rh_fun) \ 190 159 ddf_fun_destroy(instance->rh_fun); \ 191 } \192 free(instance); \193 usb_log_error(message); \194 160 return ret; \ 195 } else (void)0 196 197 instance->rh_fun = NULL; 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; 161 } 162 163 uintptr_t io_reg_base = 0; 164 size_t io_reg_size = 0; 212 165 int irq = 0; 213 166 214 ret = pci_get_my_registers(device, ®_base, ®_size, &irq); 215 CHECK_RET_DEST_FREE_RETURN(ret, 167 int ret = 168 pci_get_my_registers(device, &io_reg_base, &io_reg_size, &irq); 169 CHECK_RET_DEST_FUN_RETURN(ret, 216 170 "Failed to get I/O addresses for %" PRIun ": %s.\n", 217 171 device->handle, str_error(ret)); 218 172 usb_log_debug("I/O regs at 0x%p (size %zu), IRQ %d.\n", 219 (void *) reg_base,reg_size, irq);173 (void *) io_reg_base, io_reg_size, irq); 220 174 221 175 ret = pci_disable_legacy(device); 222 CHECK_RET_DEST_F REE_RETURN(ret,176 CHECK_RET_DEST_FUN_RETURN(ret, 223 177 "Failed(%d) to disable legacy USB: %s.\n", ret, str_error(ret)); 224 178 … … 240 194 #endif 241 195 242 243 ret = hc_init(&instance->hc, (void*)reg_base, reg_size, interrupts); 244 CHECK_RET_DEST_FREE_RETURN(ret, 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, 245 204 "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 246 217 247 218 #define CHECK_RET_FINI_RETURN(ret, message...) \ 248 219 if (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); \ 249 225 hc_fini(&instance->hc); \ 250 CHECK_RET_DEST_FREE_RETURN(ret, message); \251 226 return ret; \ 252 } else (void)0227 } 253 228 254 229 /* It does no harm if we register this on polling */ … … 259 234 ret, str_error(ret)); 260 235 261 ret = ddf_fun_bind(instance->hc_fun); 262 CHECK_RET_FINI_RETURN(ret, 263 "Failed(%d) to bind UHCI device function: %s.\n", 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", 264 240 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));269 241 270 242 ret = rh_init(&instance->rh, instance->rh_fun, … … 273 245 "Failed(%d) to setup UHCI root hub: %s.\n", ret, str_error(ret)); 274 246 247 instance->rh_fun->ops = &rh_ops; 248 instance->rh_fun->driver_data = &instance->rh; 275 249 ret = ddf_fun_bind(instance->rh_fun); 276 250 CHECK_RET_FINI_RETURN(ret, 277 251 "Failed(%d) to register UHCI root hub: %s.\n", ret, str_error(ret)); 278 252 279 device->driver_data = instance;280 253 return EOK; 281 254 #undef CHECK_RET_FINI_RETURN -
uspace/drv/uhci-hcd/uhci.h
r7b6f116 r5dfee52 38 38 #include <ddf/driver.h> 39 39 40 int device_setup_uhci(ddf_dev_t *device); 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); 41 58 #endif 42 59 /**
Note:
See TracChangeset
for help on using the changeset viewer.