Changeset b4b534ac in mainline for uspace/lib/usbdev/src/devdrv.c
- Timestamp:
- 2016-07-22T08:24:47Z (8 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- f76d2c2
- Parents:
- 5b18137 (diff), 8351f9a4 (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. - File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/usbdev/src/devdrv.c
r5b18137 rb4b534ac 33 33 * USB device driver framework. 34 34 */ 35 #include <usb/dev/driver.h> 35 36 #include <usb_iface.h> 37 #include <usb/dev/alternate_ifaces.h> 38 #include <usb/dev/device.h> 39 #include <usb/dev/pipes.h> 36 40 #include <usb/dev/request.h> 37 41 #include <usb/debug.h> 38 #include <usb/dev.h> 42 #include <usb/descriptor.h> 43 #include <usb/usb.h> 44 45 #include <assert.h> 46 #include <async.h> 47 #include <devman.h> 39 48 #include <errno.h> 40 #include <str_error.h> 41 #include <assert.h> 42 43 static int generic_device_add(ddf_dev_t *); 44 static int generic_device_remove(ddf_dev_t *); 45 static int generic_device_gone(ddf_dev_t *); 46 47 static driver_ops_t generic_driver_ops = { 48 .dev_add = generic_device_add, 49 .dev_remove = generic_device_remove, 50 .dev_gone = generic_device_gone, 51 }; 52 static driver_t generic_driver = { 53 .driver_ops = &generic_driver_ops 54 }; 55 56 static const usb_driver_t *driver = NULL; 57 58 /** Main routine of USB device driver. 59 * 60 * Under normal conditions, this function never returns. 61 * 62 * @param drv USB device driver structure. 63 * @return Task exit status. 64 */ 65 int usb_driver_main(const usb_driver_t *drv) 66 { 67 assert(drv != NULL); 68 69 /* Prepare the generic driver. */ 70 generic_driver.name = drv->name; 71 72 driver = drv; 73 74 return ddf_driver_main(&generic_driver); 75 } 49 #include <stdlib.h> 50 51 #include <ddf/driver.h> 52 53 /** USB device structure. */ 54 typedef struct usb_device { 55 /** Connection to device on USB bus */ 56 usb_dev_session_t *bus_session; 57 /** devman handle */ 58 devman_handle_t handle; 59 /** The default control pipe. */ 60 usb_pipe_t ctrl_pipe; 61 62 /** Other endpoint pipes. 63 * This is an array of other endpoint pipes in the same order as 64 * in usb_driver_t. 65 */ 66 usb_endpoint_mapping_t *pipes; 67 /** Number of other endpoint pipes. */ 68 size_t pipes_count; 69 /** Current interface. 70 * Usually, drivers operate on single interface only. 71 * This item contains the value of the interface or -1 for any. 72 */ 73 int interface_no; 74 /** Alternative interfaces. */ 75 usb_alternate_interfaces_t alternate_interfaces; 76 /** Some useful descriptors for USB device. */ 77 usb_device_descriptors_t descriptors; 78 /** Generic DDF device backing this one. DO NOT TOUCH! */ 79 ddf_dev_t *ddf_dev; 80 /** Custom driver data. 81 * Do not use the entry in generic device, that is already used 82 * by the framework. 83 */ 84 void *driver_data; 85 86 } usb_device_t; 76 87 77 88 /** Count number of pipes the driver expects. … … 80 91 * @return Number of pipes (excluding default control pipe). 81 92 */ 82 static inline size_t count_other_pipes( 83 const usb_endpoint_description_t **endpoints) 93 static inline size_t count_pipes(const usb_endpoint_description_t **endpoints) 84 94 { 85 95 size_t count; 86 96 for (count = 0; endpoints != NULL && endpoints[count] != NULL; ++count); 87 97 return count; 88 }89 90 /** Callback when a new device is supposed to be controlled by this driver.91 *92 * This callback is a wrapper for USB specific version of @c device_add.93 *94 * @param gen_dev Device structure as prepared by DDF.95 * @return Error code.96 */97 int generic_device_add(ddf_dev_t *gen_dev)98 {99 assert(driver);100 assert(driver->ops);101 assert(driver->ops->device_add);102 103 /* Get place for driver data. */104 usb_device_t *dev = ddf_dev_data_alloc(gen_dev, sizeof(usb_device_t));105 if (dev == NULL) {106 usb_log_error("USB device `%s' structure allocation failed.\n",107 ddf_dev_get_name(gen_dev));108 return ENOMEM;109 }110 111 /* Initialize generic USB driver data. */112 const char *err_msg = NULL;113 int rc = usb_device_init(dev, gen_dev, driver->endpoints, &err_msg);114 if (rc != EOK) {115 usb_log_error("USB device `%s' init failed (%s): %s.\n",116 ddf_dev_get_name(gen_dev), err_msg, str_error(rc));117 return rc;118 }119 120 /* Start USB driver specific initialization. */121 rc = driver->ops->device_add(dev);122 if (rc != EOK)123 usb_device_deinit(dev);124 return rc;125 }126 127 /** Callback when a device is supposed to be removed from the system.128 *129 * This callback is a wrapper for USB specific version of @c device_remove.130 *131 * @param gen_dev Device structure as prepared by DDF.132 * @return Error code.133 */134 int generic_device_remove(ddf_dev_t *gen_dev)135 {136 assert(driver);137 assert(driver->ops);138 if (driver->ops->device_rem == NULL)139 return ENOTSUP;140 /* Just tell the driver to stop whatever it is doing */141 usb_device_t *usb_dev = ddf_dev_data_get(gen_dev);142 const int ret = driver->ops->device_rem(usb_dev);143 if (ret != EOK)144 return ret;145 usb_device_deinit(usb_dev);146 return EOK;147 }148 149 /** Callback when a device was removed from the system.150 *151 * This callback is a wrapper for USB specific version of @c device_gone.152 *153 * @param gen_dev Device structure as prepared by DDF.154 * @return Error code.155 */156 int generic_device_gone(ddf_dev_t *gen_dev)157 {158 assert(driver);159 assert(driver->ops);160 if (driver->ops->device_gone == NULL)161 return ENOTSUP;162 usb_device_t *usb_dev = ddf_dev_data_get(gen_dev);163 const int ret = driver->ops->device_gone(usb_dev);164 if (ret == EOK)165 usb_device_deinit(usb_dev);166 167 return ret;168 }169 170 /** Destroy existing pipes of a USB device.171 *172 * @param dev Device where to destroy the pipes.173 */174 static void destroy_current_pipes(usb_device_t *dev)175 {176 usb_device_destroy_pipes(dev->pipes, dev->pipes_count);177 dev->pipes = NULL;178 dev->pipes_count = 0;179 98 } 180 99 … … 201 120 * @return Error code. 202 121 */ 203 int usb_device_select_interface(usb_device_t *dev, uint8_t alternate_setting, 204 const usb_endpoint_description_t **endpoints) 205 { 206 if (dev->interface_no < 0) { 122 int usb_device_select_interface(usb_device_t *usb_dev, 123 uint8_t alternate_setting, const usb_endpoint_description_t **endpoints) 124 { 125 assert(usb_dev); 126 127 if (usb_dev->interface_no < 0) { 207 128 return EINVAL; 208 129 } 209 130 210 /* Destroy existing pipes. */211 destroy_current_pipes(dev);212 213 131 /* Change the interface itself. */ 214 int rc = usb_request_set_interface(& dev->ctrl_pipe, dev->interface_no,215 alternate_setting);132 int rc = usb_request_set_interface(&usb_dev->ctrl_pipe, 133 usb_dev->interface_no, alternate_setting); 216 134 if (rc != EOK) { 217 135 return rc; 218 136 } 219 137 138 /* Change current alternative */ 139 usb_dev->alternate_interfaces.current = alternate_setting; 140 141 /* Destroy existing pipes. */ 142 usb_device_destroy_pipes(usb_dev); 143 220 144 /* Create new pipes. */ 221 rc = usb_device_create_pipes(&dev->wire, endpoints, 222 dev->descriptors.configuration, dev->descriptors.configuration_size, 223 dev->interface_no, (int)alternate_setting, 224 &dev->pipes, &dev->pipes_count); 145 rc = usb_device_create_pipes(usb_dev, endpoints); 225 146 226 147 return rc; … … 233 154 * @return Error code. 234 155 */ 235 int usb_device_retrieve_descriptors(usb_pipe_t *ctrl_pipe, 236 usb_device_descriptors_t *descriptors) 237 { 238 assert(descriptors != NULL); 239 240 descriptors->configuration = NULL; 241 242 int rc; 243 244 /* It is worth to start a long transfer. */ 245 usb_pipe_start_long_transfer(ctrl_pipe); 156 static int usb_device_retrieve_descriptors(usb_device_t *usb_dev) 157 { 158 assert(usb_dev); 159 assert(usb_dev->descriptors.full_config == NULL); 246 160 247 161 /* Get the device descriptor. */ 248 rc = usb_request_get_device_descriptor(ctrl_pipe, &descriptors->device); 162 int rc = usb_request_get_device_descriptor(&usb_dev->ctrl_pipe, 163 &usb_dev->descriptors.device); 249 164 if (rc != EOK) { 250 goto leave;165 return rc; 251 166 } 252 167 253 168 /* Get the full configuration descriptor. */ 254 169 rc = usb_request_get_full_configuration_descriptor_alloc( 255 ctrl_pipe, 0, (void **) &descriptors->configuration, 256 &descriptors->configuration_size); 257 258 leave: 259 usb_pipe_end_long_transfer(ctrl_pipe); 170 &usb_dev->ctrl_pipe, 0, 171 &usb_dev->descriptors.full_config, 172 &usb_dev->descriptors.full_config_size); 173 260 174 261 175 return rc; … … 266 180 * @param[in] descriptors Where to store the descriptors. 267 181 */ 268 void usb_device_release_descriptors(usb_device_descriptors_t *descriptors) 269 { 270 assert(descriptors); 271 free(descriptors->configuration); 272 descriptors->configuration = NULL; 182 static void usb_device_release_descriptors(usb_device_t *usb_dev) 183 { 184 assert(usb_dev); 185 free(usb_dev->descriptors.full_config); 186 usb_dev->descriptors.full_config = NULL; 187 usb_dev->descriptors.full_config_size = 0; 273 188 } 274 189 … … 280 195 * - registers endpoints with the host controller 281 196 * 282 * @param[in] wire Initialized backing connection to the host controller.283 197 * @param[in] endpoints Endpoints description, NULL terminated. 284 198 * @param[in] config_descr Configuration descriptor of active configuration. … … 292 206 * @return Error code. 293 207 */ 294 int usb_device_create_pipes(usb_device_connection_t *wire, 295 const usb_endpoint_description_t **endpoints, 296 const uint8_t *config_descr, size_t config_descr_size, 297 int interface_no, int interface_setting, 298 usb_endpoint_mapping_t **pipes_ptr, size_t *pipes_count_ptr) 299 { 300 assert(wire != NULL); 301 assert(config_descr != NULL); 302 assert(config_descr_size > 0); 303 assert(pipes_ptr != NULL); 304 305 size_t i; 306 int rc; 307 308 const size_t pipe_count = count_other_pipes(endpoints); 208 int usb_device_create_pipes(usb_device_t *usb_dev, 209 const usb_endpoint_description_t **endpoints) 210 { 211 assert(usb_dev); 212 assert(usb_dev->descriptors.full_config); 213 assert(usb_dev->pipes == NULL); 214 assert(usb_dev->pipes_count == 0); 215 216 size_t pipe_count = count_pipes(endpoints); 309 217 if (pipe_count == 0) { 310 if (pipes_count_ptr)311 *pipes_count_ptr = pipe_count;312 *pipes_ptr = NULL;313 218 return EOK; 314 219 } 315 220 316 usb_endpoint_mapping_t *pipes 317 =calloc(pipe_count, sizeof(usb_endpoint_mapping_t));221 usb_endpoint_mapping_t *pipes = 222 calloc(pipe_count, sizeof(usb_endpoint_mapping_t)); 318 223 if (pipes == NULL) { 319 224 return ENOMEM; … … 321 226 322 227 /* Now initialize. */ 323 for ( i = 0; i < pipe_count; i++) {228 for (size_t i = 0; i < pipe_count; i++) { 324 229 pipes[i].description = endpoints[i]; 325 pipes[i].interface_no = interface_no; 326 pipes[i].interface_setting = interface_setting; 230 pipes[i].interface_no = usb_dev->interface_no; 231 pipes[i].interface_setting = 232 usb_dev->alternate_interfaces.current; 327 233 } 328 234 329 235 /* Find the mapping from configuration descriptor. */ 330 rc = usb_pipe_initialize_from_configuration(pipes, pipe_count, 331 config_descr, config_descr_size, wire); 236 int rc = usb_pipe_initialize_from_configuration(pipes, pipe_count, 237 usb_dev->descriptors.full_config, 238 usb_dev->descriptors.full_config_size, 239 usb_dev->bus_session); 332 240 if (rc != EOK) { 333 241 free(pipes); … … 336 244 337 245 /* Register created pipes. */ 338 for ( i = 0; i < pipe_count; i++) {246 for (size_t i = 0; i < pipe_count; i++) { 339 247 if (pipes[i].present) { 340 248 rc = usb_pipe_register(&pipes[i].pipe, … … 346 254 } 347 255 348 *pipes_ptr = pipes; 349 if (pipes_count_ptr != NULL) { 350 *pipes_count_ptr = pipe_count; 351 } 256 usb_dev->pipes = pipes; 257 usb_dev->pipes_count = pipe_count; 352 258 353 259 return EOK; … … 360 266 */ 361 267 rollback_unregister_endpoints: 362 for ( i = 0; i < pipe_count; i++) {268 for (size_t i = 0; i < pipe_count; i++) { 363 269 if (pipes[i].present) { 364 270 usb_pipe_unregister(&pipes[i].pipe); … … 372 278 /** Destroy pipes previously created by usb_device_create_pipes. 373 279 * 374 * @param[in] pipes Endpoint mapping to be destroyed. 375 * @param[in] pipes_count Number of endpoints. 376 */ 377 void usb_device_destroy_pipes(usb_endpoint_mapping_t *pipes, size_t pipes_count) 378 { 280 * @param[in] usb_dev USB device. 281 */ 282 void usb_device_destroy_pipes(usb_device_t *usb_dev) 283 { 284 assert(usb_dev); 285 assert(usb_dev->pipes || usb_dev->pipes_count == 0); 379 286 /* Destroy the pipes. */ 380 for (size_t i = 0; i < pipes_count; ++i) { 381 assert(pipes); 287 for (size_t i = 0; i < usb_dev->pipes_count; ++i) { 382 288 usb_log_debug2("Unregistering pipe %zu: %spresent.\n", 383 i, pipes[i].present ? "" : "not "); 384 if (pipes[i].present) 385 usb_pipe_unregister(&pipes[i].pipe); 386 } 387 free(pipes); 289 i, usb_dev->pipes[i].present ? "" : "not "); 290 if (usb_dev->pipes[i].present) 291 usb_pipe_unregister(&usb_dev->pipes[i].pipe); 292 } 293 free(usb_dev->pipes); 294 usb_dev->pipes = NULL; 295 usb_dev->pipes_count = 0; 296 } 297 298 usb_pipe_t *usb_device_get_default_pipe(usb_device_t *usb_dev) 299 { 300 assert(usb_dev); 301 return &usb_dev->ctrl_pipe; 302 } 303 304 usb_endpoint_mapping_t *usb_device_get_mapped_ep_desc(usb_device_t *usb_dev, 305 const usb_endpoint_description_t *desc) 306 { 307 assert(usb_dev); 308 for (unsigned i = 0; i < usb_dev->pipes_count; ++i) { 309 if (usb_dev->pipes[i].description == desc) 310 return &usb_dev->pipes[i]; 311 } 312 return NULL; 313 } 314 315 usb_endpoint_mapping_t * usb_device_get_mapped_ep( 316 usb_device_t *usb_dev, usb_endpoint_t ep) 317 { 318 assert(usb_dev); 319 for (unsigned i = 0; i < usb_dev->pipes_count; ++i) { 320 if (usb_dev->pipes[i].pipe.endpoint_no == ep) 321 return &usb_dev->pipes[i]; 322 } 323 return NULL; 324 } 325 326 int usb_device_get_iface_number(usb_device_t *usb_dev) 327 { 328 assert(usb_dev); 329 return usb_dev->interface_no; 330 } 331 332 devman_handle_t usb_device_get_devman_handle(usb_device_t *usb_dev) 333 { 334 assert(usb_dev); 335 return usb_dev->handle; 336 } 337 338 const usb_device_descriptors_t *usb_device_descriptors(usb_device_t *usb_dev) 339 { 340 assert(usb_dev); 341 return &usb_dev->descriptors; 342 } 343 344 const usb_alternate_interfaces_t * usb_device_get_alternative_ifaces( 345 usb_device_t *usb_dev) 346 { 347 assert(usb_dev); 348 return &usb_dev->alternate_interfaces; 349 } 350 351 /** Clean instance of a USB device. 352 * 353 * @param dev Device to be de-initialized. 354 * 355 * Does not free/destroy supplied pointer. 356 */ 357 static void usb_device_fini(usb_device_t *usb_dev) 358 { 359 if (usb_dev) { 360 /* Destroy existing pipes. */ 361 usb_device_destroy_pipes(usb_dev); 362 /* Ignore errors and hope for the best. */ 363 usb_alternate_interfaces_deinit(&usb_dev->alternate_interfaces); 364 usb_device_release_descriptors(usb_dev); 365 free(usb_dev->driver_data); 366 usb_dev->driver_data = NULL; 367 usb_dev_disconnect(usb_dev->bus_session); 368 usb_dev->bus_session = NULL; 369 } 388 370 } 389 371 … … 397 379 * @return Error code. 398 380 */ 399 int usb_device_init(usb_device_t *usb_dev, ddf_dev_t *ddf_dev, 400 const usb_endpoint_description_t **endpoints, const char **errstr_ptr) 381 static int usb_device_init(usb_device_t *usb_dev, ddf_dev_t *ddf_dev, 382 const usb_endpoint_description_t **endpoints, const char **errstr_ptr, 383 devman_handle_t handle, int interface_no) 401 384 { 402 385 assert(usb_dev != NULL); 403 assert( ddf_dev != NULL);386 assert(errstr_ptr); 404 387 405 388 *errstr_ptr = NULL; 406 389 407 390 usb_dev->ddf_dev = ddf_dev; 391 usb_dev->handle = handle; 392 usb_dev->interface_no = interface_no; 408 393 usb_dev->driver_data = NULL; 409 usb_dev->descriptors.configuration = NULL; 394 usb_dev->descriptors.full_config = NULL; 395 usb_dev->descriptors.full_config_size = 0; 410 396 usb_dev->pipes_count = 0; 411 397 usb_dev->pipes = NULL; 412 398 413 /* Get assigned params */ 414 devman_handle_t hc_handle; 415 usb_address_t address; 416 417 int rc = usb_get_info_by_handle(ddf_dev_get_handle(ddf_dev), 418 &hc_handle, &address, &usb_dev->interface_no); 419 if (rc != EOK) { 420 *errstr_ptr = "device parameters retrieval"; 421 return rc; 422 } 423 424 /* Initialize hc connection. */ 425 usb_hc_connection_initialize(&usb_dev->hc_conn, hc_handle); 426 427 /* Initialize backing wire and control pipe. */ 428 rc = usb_device_connection_initialize( 429 &usb_dev->wire, &usb_dev->hc_conn, address); 430 if (rc != EOK) { 431 *errstr_ptr = "device connection initialization"; 432 return rc; 399 usb_dev->bus_session = usb_dev_connect(handle); 400 401 if (!usb_dev->bus_session) { 402 *errstr_ptr = "device bus session create"; 403 return ENOMEM; 433 404 } 434 405 435 406 /* This pipe was registered by the hub driver, 436 407 * during device initialization. */ 437 rc = usb_pipe_initialize_default_control(438 &usb_dev->ctrl_pipe, &usb_dev->wire);408 int rc = usb_pipe_initialize_default_control( 409 &usb_dev->ctrl_pipe, usb_dev->bus_session); 439 410 if (rc != EOK) { 411 usb_dev_disconnect(usb_dev->bus_session); 440 412 *errstr_ptr = "default control pipe initialization"; 441 413 return rc; 442 414 } 443 415 444 /* Open hc connection for pipe registration. */445 rc = usb_hc_connection_open(&usb_dev->hc_conn);446 if (rc != EOK) {447 *errstr_ptr = "hc connection open";448 return rc;449 }450 451 416 /* Retrieve standard descriptors. */ 452 rc = usb_device_retrieve_descriptors( 453 &usb_dev->ctrl_pipe, &usb_dev->descriptors); 417 rc = usb_device_retrieve_descriptors(usb_dev); 454 418 if (rc != EOK) { 455 419 *errstr_ptr = "descriptor retrieval"; 456 usb_ hc_connection_close(&usb_dev->hc_conn);420 usb_dev_disconnect(usb_dev->bus_session); 457 421 return rc; 458 422 } … … 463 427 * controlling a device. */ 464 428 rc = usb_alternate_interfaces_init(&usb_dev->alternate_interfaces, 465 usb_dev->descriptors.configuration, 466 usb_dev->descriptors.configuration_size, usb_dev->interface_no); 467 const int alternate_iface = 468 (rc == EOK) ? usb_dev->alternate_interfaces.current : 0; 469 470 /* Create and register other pipes than default control (EP 0) */ 471 rc = usb_device_create_pipes(&usb_dev->wire, endpoints, 472 usb_dev->descriptors.configuration, 473 usb_dev->descriptors.configuration_size, 474 usb_dev->interface_no, (int)alternate_iface, 475 &usb_dev->pipes, &usb_dev->pipes_count); 476 if (rc != EOK) { 477 usb_hc_connection_close(&usb_dev->hc_conn); 478 /* Full configuration descriptor is allocated. */ 479 usb_device_release_descriptors(&usb_dev->descriptors); 480 /* Alternate interfaces may be allocated */ 481 usb_alternate_interfaces_deinit(&usb_dev->alternate_interfaces); 482 *errstr_ptr = "pipes initialization"; 483 return rc; 484 } 485 486 usb_hc_connection_close(&usb_dev->hc_conn); 429 usb_dev->descriptors.full_config, 430 usb_dev->descriptors.full_config_size, usb_dev->interface_no); 431 432 if (endpoints) { 433 /* Create and register other pipes than default control (EP 0)*/ 434 rc = usb_device_create_pipes(usb_dev, endpoints); 435 if (rc != EOK) { 436 usb_device_fini(usb_dev); 437 *errstr_ptr = "pipes initialization"; 438 return rc; 439 } 440 } 441 487 442 return EOK; 488 443 } 489 444 490 /** Clean instance of a USB device. 491 * 492 * @param dev Device to be de-initialized. 493 * 494 * Does not free/destroy supplied pointer. 495 */ 496 void usb_device_deinit(usb_device_t *dev) 497 { 498 if (dev) { 499 /* Destroy existing pipes. */ 500 destroy_current_pipes(dev); 501 /* Ignore errors and hope for the best. */ 502 usb_hc_connection_deinitialize(&dev->hc_conn); 503 usb_alternate_interfaces_deinit(&dev->alternate_interfaces); 504 usb_device_release_descriptors(&dev->descriptors); 505 free(dev->driver_data); 506 dev->driver_data = NULL; 507 } 445 static int usb_device_get_info(async_sess_t *sess, devman_handle_t *handle, 446 int *iface_no) 447 { 448 assert(handle); 449 assert(iface_no); 450 async_exch_t *exch = async_exchange_begin(sess); 451 if (!exch) 452 return EPARTY; 453 int ret = usb_get_my_device_handle(exch, handle); 454 if (ret == EOK) { 455 ret = usb_get_my_interface(exch, iface_no); 456 if (ret == ENOTSUP) { 457 *iface_no = -1; 458 ret = EOK; 459 } 460 } 461 async_exchange_end(exch); 462 return ret; 463 } 464 465 int usb_device_create_ddf(ddf_dev_t *ddf_dev, 466 const usb_endpoint_description_t **desc, const char **err) 467 { 468 assert(ddf_dev); 469 assert(err); 470 471 devman_handle_t h = 0; 472 int iface_no = -1; 473 474 async_sess_t *sess = devman_parent_device_connect( 475 ddf_dev_get_handle(ddf_dev), IPC_FLAG_BLOCKING); 476 const int ret = usb_device_get_info(sess, &h, &iface_no); 477 async_hangup(sess); 478 if (ret != EOK) 479 return ret; 480 481 usb_device_t *usb_dev = 482 ddf_dev_data_alloc(ddf_dev, sizeof(usb_device_t)); 483 if (usb_dev == NULL) { 484 *err = "DDF data alloc"; 485 return ENOMEM; 486 } 487 488 return usb_device_init(usb_dev, ddf_dev, desc, err, h, iface_no); 489 } 490 491 void usb_device_destroy_ddf(ddf_dev_t *ddf_dev) 492 { 493 assert(ddf_dev); 494 usb_device_t *usb_dev = ddf_dev_data_get(ddf_dev); 495 assert(usb_dev); 496 usb_device_fini(usb_dev); 497 return; 498 } 499 500 usb_device_t * usb_device_create(devman_handle_t handle) 501 { 502 devman_handle_t h = 0; 503 int iface_no = -1; 504 505 async_sess_t *sess = devman_device_connect(handle, IPC_FLAG_BLOCKING); 506 int ret = usb_device_get_info(sess, &h, &iface_no); 507 if (sess) 508 async_hangup(sess); 509 if (ret != EOK) 510 return NULL; 511 512 usb_device_t *usb_dev = malloc(sizeof(usb_device_t)); 513 if (!usb_dev) 514 return NULL; 515 516 const char* dummy = NULL; 517 ret = usb_device_init(usb_dev, NULL, NULL, &dummy, handle, iface_no); 518 if (ret != EOK) { 519 free(usb_dev); 520 usb_dev = NULL; 521 } 522 return usb_dev; 523 } 524 525 void usb_device_destroy(usb_device_t *usb_dev) 526 { 527 if (usb_dev) { 528 usb_device_fini(usb_dev); 529 free(usb_dev); 530 } 531 } 532 533 const char *usb_device_get_name(usb_device_t *usb_dev) 534 { 535 assert(usb_dev); 536 if (usb_dev->ddf_dev) 537 return ddf_dev_get_name(usb_dev->ddf_dev); 538 return NULL; 539 } 540 541 ddf_fun_t *usb_device_ddf_fun_create(usb_device_t *usb_dev, fun_type_t ftype, 542 const char* name) 543 { 544 assert(usb_dev); 545 if (usb_dev->ddf_dev) 546 return ddf_fun_create(usb_dev->ddf_dev, ftype, name); 547 return NULL; 548 } 549 550 async_exch_t * usb_device_bus_exchange_begin(usb_device_t *usb_dev) 551 { 552 assert(usb_dev); 553 return async_exchange_begin(usb_dev->bus_session); 554 } 555 556 void usb_device_bus_exchange_end(async_exch_t *exch) 557 { 558 async_exchange_end(exch); 508 559 } 509 560 … … 521 572 } 522 573 574 void * usb_device_data_get(usb_device_t *usb_dev) 575 { 576 assert(usb_dev); 577 return usb_dev->driver_data; 578 } 579 523 580 /** 524 581 * @}
Note:
See TracChangeset
for help on using the changeset viewer.