Changeset 816f5f4 in mainline
- Timestamp:
- 2017-10-15T16:55:48Z (8 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- 9b2f69e
- Parents:
- 2770b66
- Location:
- uspace
- Files:
-
- 12 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/drv/bus/usb/usbhid/main.c
r2770b66 r816f5f4 95 95 usb_hid_polling_callback, 96 96 /* How much data to request. */ 97 hid_dev->poll_pipe_mapping->pipe. max_packet_size,97 hid_dev->poll_pipe_mapping->pipe.desc.max_packet_size, 98 98 /* Delay */ 99 99 -1, -
uspace/drv/bus/usb/usbmast/main.c
r2770b66 r816f5f4 172 172 usb_device_get_name(dev)); 173 173 usb_log_debug("Bulk in endpoint: %d [%zuB].\n", 174 epm_in->pipe. endpoint_no, epm_in->pipe.max_packet_size);174 epm_in->pipe.desc.endpoint_no, epm_in->pipe.desc.max_packet_size); 175 175 usb_log_debug("Bulk out endpoint: %d [%zuB].\n", 176 epm_out->pipe. endpoint_no, epm_out->pipe.max_packet_size);176 epm_out->pipe.desc.endpoint_no, epm_out->pipe.desc.max_packet_size); 177 177 178 178 usb_log_debug("Get LUN count...\n"); -
uspace/lib/drv/generic/remote_usb.c
r2770b66 r816f5f4 175 175 } pack8_t; 176 176 177 int usb_register_endpoint(async_exch_t *exch, usb_endpoint_t endpoint, 178 usb_transfer_type_t type, usb_direction_t direction, 179 size_t mps, unsigned packets, unsigned interval) 180 { 181 if (!exch) 182 return EBADMEM; 183 pack8_t pack; 184 pack.arr[0] = type; 185 pack.arr[1] = direction; 186 pack.arr[2] = interval; 187 pack.arr[3] = packets; 188 189 return async_req_4_0(exch, DEV_IFACE_ID(USB_DEV_IFACE), 190 IPC_M_USB_REGISTER_ENDPOINT, endpoint, pack.arg, mps); 191 192 } 193 194 int usb_unregister_endpoint(async_exch_t *exch, usb_endpoint_t endpoint, 195 usb_direction_t direction) 196 { 197 if (!exch) 198 return EBADMEM; 199 return async_req_3_0(exch, DEV_IFACE_ID(USB_DEV_IFACE), 200 IPC_M_USB_UNREGISTER_ENDPOINT, endpoint, direction); 177 int usb_register_endpoint(async_exch_t *exch, 178 usb_endpoint_desc_t *endpoint_desc) 179 { 180 if (!exch) 181 return EBADMEM; 182 183 aid_t opening_request = async_send_1(exch, 184 DEV_IFACE_ID(USB_DEV_IFACE), IPC_M_USB_REGISTER_ENDPOINT, NULL); 185 186 if (opening_request == 0) { 187 return ENOMEM; 188 } 189 190 const int ret = async_data_write_start(exch, (void *) endpoint_desc, 191 sizeof(usb_endpoint_desc_t)); 192 193 if (ret != EOK) { 194 async_forget(opening_request); 195 return ret; 196 } 197 198 /* Wait for the answer. */ 199 sysarg_t opening_request_rc; 200 async_wait_for(opening_request, &opening_request_rc); 201 202 return (int) opening_request_rc; 203 } 204 205 int usb_unregister_endpoint(async_exch_t *exch, 206 usb_endpoint_desc_t *endpoint_desc) 207 { 208 if (!exch) 209 return EBADMEM; 210 211 aid_t opening_request = async_send_1(exch, 212 DEV_IFACE_ID(USB_DEV_IFACE), IPC_M_USB_UNREGISTER_ENDPOINT, NULL); 213 214 if (opening_request == 0) { 215 return ENOMEM; 216 } 217 218 const int ret = async_data_write_start(exch, endpoint_desc, 219 sizeof(usb_endpoint_desc_t)); 220 if (ret != EOK) { 221 async_forget(opening_request); 222 return ret; 223 } 224 225 /* Wait for the answer. */ 226 sysarg_t opening_request_rc; 227 async_wait_for(opening_request, &opening_request_rc); 228 229 return (int) opening_request_rc; 201 230 } 202 231 … … 317 346 }; 318 347 348 typedef struct { 349 ipc_callid_t caller; 350 ipc_callid_t data_caller; 351 void *buffer; 352 } async_transaction_t; 353 319 354 void remote_usb_get_my_interface(ddf_fun_t *fun, void *iface, 320 355 ipc_callid_t callid, ipc_call_t *call) … … 417 452 ipc_callid_t callid, ipc_call_t *call) 418 453 { 419 usb_iface_t *usb_iface = (usb_iface_t *) iface; 454 assert(fun); 455 assert(iface); 456 assert(call); 457 458 const usb_iface_t *usb_iface = iface; 420 459 421 460 if (!usb_iface->register_endpoint) { … … 424 463 } 425 464 426 const usb_endpoint_t endpoint = DEV_IPC_GET_ARG1(*call); 427 const pack8_t pack = { .arg = DEV_IPC_GET_ARG2(*call)}; 428 const size_t max_packet_size = DEV_IPC_GET_ARG3(*call); 429 430 const usb_transfer_type_t transfer_type = pack.arr[0]; 431 const usb_direction_t direction = pack.arr[1]; 432 unsigned packets = pack.arr[2]; 433 unsigned interval = pack.arr[3]; 434 435 const int ret = usb_iface->register_endpoint(fun, endpoint, 436 transfer_type, direction, max_packet_size, packets, interval); 437 438 async_answer_0(callid, ret); 465 void *buffer = malloc(sizeof(usb_endpoint_desc_t)); 466 if (!buffer) { 467 async_answer_0(callid, ENOMEM); 468 return; 469 } 470 471 size_t size = 0; 472 int rc = async_data_write_accept(&buffer, false, 473 1, sizeof(usb_endpoint_desc_t), 0, &size); 474 475 if (rc != EOK) { 476 free(buffer); 477 async_answer_0(callid, rc); 478 return; 479 } 480 481 usb_endpoint_desc_t *endpoint_desc = (usb_endpoint_desc_t *) buffer; 482 rc = usb_iface->register_endpoint(fun, endpoint_desc); 483 484 free(buffer); 485 async_answer_0(callid, rc); 439 486 } 440 487 … … 442 489 ipc_callid_t callid, ipc_call_t *call) 443 490 { 444 usb_iface_t *usb_iface = (usb_iface_t *) iface; 491 assert(fun); 492 assert(iface); 493 assert(call); 494 495 const usb_iface_t *usb_iface = iface; 445 496 446 497 if (!usb_iface->unregister_endpoint) { … … 449 500 } 450 501 451 usb_endpoint_t endpoint = (usb_endpoint_t) DEV_IPC_GET_ARG1(*call); 452 usb_direction_t direction = (usb_direction_t) DEV_IPC_GET_ARG2(*call); 453 454 int rc = usb_iface->unregister_endpoint(fun, endpoint, direction); 455 456 async_answer_0(callid, rc); 457 } 458 459 typedef struct { 460 ipc_callid_t caller; 461 ipc_callid_t data_caller; 462 void *buffer; 463 } async_transaction_t; 502 void *buffer = malloc(sizeof(usb_endpoint_desc_t)); 503 if (!buffer) { 504 async_answer_0(callid, ENOMEM); 505 return; 506 } 507 508 size_t size = 0; 509 int rc = async_data_write_accept(&buffer, false, 510 1, sizeof(usb_endpoint_desc_t), 0, &size); 511 512 if (rc != EOK) { 513 free(buffer); 514 async_answer_0(callid, rc); 515 return; 516 } 517 518 usb_endpoint_desc_t *endpoint_desc = (usb_endpoint_desc_t *) buffer; 519 usb_iface->unregister_endpoint(fun, endpoint_desc); 520 521 free(buffer); 522 if (rc != EOK) { 523 async_answer_0(callid, rc); 524 } 525 } 464 526 465 527 static void async_transaction_destroy(async_transaction_t *trans) -
uspace/lib/drv/include/usb_iface.h
r2770b66 r816f5f4 57 57 extern int usb_device_remove(async_exch_t *, unsigned port); 58 58 59 extern int usb_register_endpoint(async_exch_t *, usb_endpoint_t, 60 usb_transfer_type_t, usb_direction_t, size_t, unsigned, unsigned); 61 extern int usb_unregister_endpoint(async_exch_t *, usb_endpoint_t, 62 usb_direction_t); 59 extern int usb_register_endpoint(async_exch_t *, usb_endpoint_desc_t *); 60 extern int usb_unregister_endpoint(async_exch_t *, usb_endpoint_desc_t *); 63 61 extern int usb_read(async_exch_t *, usb_endpoint_t, uint64_t, void *, size_t, 64 62 size_t *); … … 83 81 int (*device_remove)(ddf_fun_t *, unsigned); 84 82 85 int (*register_endpoint)(ddf_fun_t *, usb_endpoint_t, 86 usb_transfer_type_t, usb_direction_t, size_t, unsigned, unsigned); 87 int (*unregister_endpoint)(ddf_fun_t *, usb_endpoint_t, 88 usb_direction_t); 83 int (*register_endpoint)(ddf_fun_t *, usb_endpoint_desc_t *); 84 int (*unregister_endpoint)(ddf_fun_t *, usb_endpoint_desc_t *); 89 85 90 86 int (*read)(ddf_fun_t *, usb_endpoint_t, uint64_t, uint8_t *, size_t, -
uspace/lib/usb/include/usb/usb.h
r2770b66 r816f5f4 163 163 164 164 165 /** USB complete address type. 165 /** USB complete address type. 166 166 * Pair address + endpoint is identification of transaction recipient. 167 167 */ … … 173 173 uint32_t packed; 174 174 } usb_target_t; 175 176 /** Description of usb endpoint. 177 */ 178 typedef struct { 179 /** Endpoint number. */ 180 usb_endpoint_t endpoint_no; 181 182 /** Endpoint transfer type. */ 183 usb_transfer_type_t transfer_type; 184 185 /** Endpoint direction. */ 186 usb_direction_t direction; 187 188 /** Maximum packet size for the endpoint. */ 189 size_t max_packet_size; 190 191 /** Number of packets per frame/uframe. 192 * Only valid for HS INT and ISO transfers. All others should set to 1*/ 193 unsigned packets; 194 195 struct { 196 unsigned polling_interval; 197 } usb2; 198 } usb_endpoint_desc_t; 175 199 176 200 /** Check USB target for allowed values (address and endpoint). -
uspace/lib/usbdev/include/usb/dev/pipes.h
r2770b66 r816f5f4 50 50 */ 51 51 typedef struct { 52 /** Endpoint number. */ 53 usb_endpoint_t endpoint_no; 54 55 /** Endpoint transfer type. */ 56 usb_transfer_type_t transfer_type; 57 58 /** Endpoint direction. */ 59 usb_direction_t direction; 60 61 /** Maximum packet size for the endpoint. */ 62 size_t max_packet_size; 63 64 /** Number of packets per frame/uframe. 65 * Only valid for HS INT and ISO transfers. All others should set to 1*/ 66 unsigned packets; 67 52 /** Endpoint description */ 53 usb_endpoint_desc_t desc; 68 54 /** Whether to automatically reset halt on the endpoint. 69 55 * Valid only for control endpoint zero. 70 56 */ 71 57 bool auto_reset_halt; 72 73 58 /** The connection used for sending the data. */ 74 59 usb_dev_session_t *bus_session; -
uspace/lib/usbdev/src/devdrv.c
r2770b66 r816f5f4 56 56 /** Connection to device on USB bus */ 57 57 usb_dev_session_t *bus_session; 58 58 59 59 /** devman handle */ 60 60 devman_handle_t handle; 61 61 62 62 /** The default control pipe. */ 63 63 usb_pipe_t ctrl_pipe; 64 64 65 65 /** Other endpoint pipes. 66 66 * … … 69 69 */ 70 70 usb_endpoint_mapping_t *pipes; 71 71 72 72 /** Number of other endpoint pipes. */ 73 73 size_t pipes_count; 74 74 75 75 /** Current interface. 76 76 * … … 79 79 */ 80 80 int interface_no; 81 81 82 82 /** Alternative interfaces. */ 83 83 usb_alternate_interfaces_t alternate_interfaces; 84 84 85 85 /** Some useful descriptors for USB device. */ 86 86 usb_device_descriptors_t descriptors; 87 87 88 88 /** Generic DDF device backing this one. DO NOT TOUCH! */ 89 89 ddf_dev_t *ddf_dev; 90 90 91 91 /** Custom driver data. 92 92 * … … 146 146 return rc; 147 147 } 148 148 149 149 /* Change current alternative */ 150 150 usb_dev->alternate_interfaces.current = alternate_setting; … … 296 296 assert(usb_dev); 297 297 assert(usb_dev->pipes || usb_dev->pipes_count == 0); 298 298 299 299 /* Destroy the pipes. */ 300 300 for (size_t i = 0; i < usb_dev->pipes_count; ++i) { … … 304 304 usb_pipe_unregister(&usb_dev->pipes[i].pipe); 305 305 } 306 306 307 307 free(usb_dev->pipes); 308 308 usb_dev->pipes = NULL; … … 332 332 assert(usb_dev); 333 333 for (unsigned i = 0; i < usb_dev->pipes_count; ++i) { 334 if (usb_dev->pipes[i].pipe. endpoint_no == ep)334 if (usb_dev->pipes[i].pipe.desc.endpoint_no == ep) 335 335 return &usb_dev->pipes[i]; 336 336 } … … 462 462 assert(handle); 463 463 assert(iface_no); 464 464 465 465 async_exch_t *exch = async_exchange_begin(sess); 466 466 if (!exch) 467 467 return EPARTY; 468 468 469 469 int ret = usb_get_my_device_handle(exch, handle); 470 470 if (ret == EOK) { … … 475 475 } 476 476 } 477 477 478 478 async_exchange_end(exch); 479 479 return ret; … … 504 504 return ENOMEM; 505 505 } 506 506 507 507 return usb_device_init(usb_dev, ddf_dev, desc, err, h, iface_no); 508 508 } -
uspace/lib/usbdev/src/devpoll.c
r2770b66 r816f5f4 96 96 (int) mapping->interface->interface_subclass, 97 97 (int) mapping->interface->interface_protocol, 98 data->request_size, pipe-> max_packet_size);98 data->request_size, pipe->desc.max_packet_size); 99 99 } 100 100 … … 128 128 usb_request_clear_endpoint_halt( 129 129 usb_device_get_default_pipe(data->dev), 130 pipe-> endpoint_no);130 pipe->desc.endpoint_no); 131 131 } 132 132 … … 156 156 157 157 /* Take a rest before next request. */ 158 158 159 159 // FIXME TODO: This is broken, the time is in ms not us. 160 160 // but first we need to fix drivers to actually stop using this, … … 216 216 if (request_size == 0) 217 217 return EINVAL; 218 219 if (!epm || (epm->pipe. transfer_type != USB_TRANSFER_INTERRUPT) ||220 (epm->pipe.d irection != USB_DIRECTION_IN))218 219 if (!epm || (epm->pipe.desc.transfer_type != USB_TRANSFER_INTERRUPT) || 220 (epm->pipe.desc.direction != USB_DIRECTION_IN)) 221 221 return EINVAL; 222 222 223 223 224 224 polling_data_t *polling_data = malloc(sizeof(polling_data_t)); -
uspace/lib/usbdev/src/pipes.c
r2770b66 r816f5f4 51 51 assert(pipe != NULL); 52 52 53 if (!pipe->auto_reset_halt || (pipe-> endpoint_no != 0)) {53 if (!pipe->auto_reset_halt || (pipe->desc.endpoint_no != 0)) { 54 54 return; 55 55 } … … 88 88 } 89 89 90 if ((pipe->d irection != USB_DIRECTION_BOTH)91 || (pipe-> transfer_type != USB_TRANSFER_CONTROL)) {90 if ((pipe->desc.direction != USB_DIRECTION_BOTH) 91 || (pipe->desc.transfer_type != USB_TRANSFER_CONTROL)) { 92 92 return EBADF; 93 93 } … … 98 98 async_exch_t *exch = async_exchange_begin(pipe->bus_session); 99 99 size_t act_size = 0; 100 const int rc = usb_read(exch, pipe-> endpoint_no, setup_packet, buffer,100 const int rc = usb_read(exch, pipe->desc.endpoint_no, setup_packet, buffer, 101 101 buffer_size, &act_size); 102 102 async_exchange_end(exch); … … 142 142 } 143 143 144 if ((pipe->d irection != USB_DIRECTION_BOTH)145 || (pipe-> transfer_type != USB_TRANSFER_CONTROL)) {144 if ((pipe->desc.direction != USB_DIRECTION_BOTH) 145 || (pipe->desc.transfer_type != USB_TRANSFER_CONTROL)) { 146 146 return EBADF; 147 147 } … … 152 152 async_exch_t *exch = async_exchange_begin(pipe->bus_session); 153 153 const int rc = usb_write(exch, 154 pipe-> endpoint_no, setup_packet, buffer, buffer_size);154 pipe->desc.endpoint_no, setup_packet, buffer, buffer_size); 155 155 async_exchange_end(exch); 156 156 … … 183 183 } 184 184 185 if (pipe->d irection != USB_DIRECTION_IN) {186 return EBADF; 187 } 188 189 if (pipe-> transfer_type == USB_TRANSFER_CONTROL) {185 if (pipe->desc.direction != USB_DIRECTION_IN) { 186 return EBADF; 187 } 188 189 if (pipe->desc.transfer_type == USB_TRANSFER_CONTROL) { 190 190 return EBADF; 191 191 } 192 192 193 193 /* Isochronous transfer are not supported (yet) */ 194 if (pipe-> transfer_type != USB_TRANSFER_INTERRUPT &&195 pipe-> transfer_type != USB_TRANSFER_BULK)194 if (pipe->desc.transfer_type != USB_TRANSFER_INTERRUPT && 195 pipe->desc.transfer_type != USB_TRANSFER_BULK) 196 196 return ENOTSUP; 197 197 … … 199 199 size_t act_size = 0; 200 200 const int rc = 201 usb_read(exch, pipe-> endpoint_no, 0, buffer, size, &act_size);201 usb_read(exch, pipe->desc.endpoint_no, 0, buffer, size, &act_size); 202 202 async_exchange_end(exch); 203 203 … … 224 224 } 225 225 226 if (pipe->d irection != USB_DIRECTION_OUT) {227 return EBADF; 228 } 229 230 if (pipe-> transfer_type == USB_TRANSFER_CONTROL) {226 if (pipe->desc.direction != USB_DIRECTION_OUT) { 227 return EBADF; 228 } 229 230 if (pipe->desc.transfer_type == USB_TRANSFER_CONTROL) { 231 231 return EBADF; 232 232 } 233 233 234 234 /* Isochronous transfer are not supported (yet) */ 235 if (pipe-> transfer_type != USB_TRANSFER_INTERRUPT &&236 pipe-> transfer_type != USB_TRANSFER_BULK)235 if (pipe->desc.transfer_type != USB_TRANSFER_INTERRUPT && 236 pipe->desc.transfer_type != USB_TRANSFER_BULK) 237 237 return ENOTSUP; 238 238 239 239 async_exch_t *exch = async_exchange_begin(pipe->bus_session); 240 const int rc = usb_write(exch, pipe-> endpoint_no, 0, buffer, size);240 const int rc = usb_write(exch, pipe->desc.endpoint_no, 0, buffer, size); 241 241 async_exchange_end(exch); 242 242 return rc; … … 258 258 assert(pipe); 259 259 260 pipe-> endpoint_no = endpoint_no;261 pipe-> transfer_type = transfer_type;262 pipe-> packets = packets;263 pipe-> max_packet_size = max_packet_size;264 pipe->d irection = direction;260 pipe->desc.endpoint_no = endpoint_no; 261 pipe->desc.transfer_type = transfer_type; 262 pipe->desc.packets = packets; 263 pipe->desc.max_packet_size = max_packet_size; 264 pipe->desc.direction = direction; 265 265 pipe->auto_reset_halt = false; 266 266 pipe->bus_session = bus_session; … … 297 297 assert(pipe); 298 298 assert(pipe->bus_session); 299 300 pipe->desc.usb2.polling_interval = interval; 299 301 async_exch_t *exch = async_exchange_begin(pipe->bus_session); 300 302 if (!exch) 301 303 return ENOMEM; 302 const int ret = usb_register_endpoint(exch, pipe->endpoint_no, 303 pipe->transfer_type, pipe->direction, pipe->max_packet_size,304 pipe->packets, interval); 304 305 const int ret = usb_register_endpoint(exch, &pipe->desc); 306 305 307 async_exchange_end(exch); 306 308 return ret; … … 319 321 if (!exch) 320 322 return ENOMEM; 321 const int ret = usb_unregister_endpoint(exch, pipe->endpoint_no, 322 pipe->direction); 323 324 const int ret = usb_unregister_endpoint(exch, &pipe->desc); 325 323 326 async_exchange_end(exch); 324 327 return ret; -
uspace/lib/usbdev/src/pipesinit.c
r2770b66 r816f5f4 288 288 if (config_descriptor == NULL) 289 289 return EBADMEM; 290 290 291 291 if (config_descriptor_size < 292 292 sizeof(usb_standard_configuration_descriptor_t)) { … … 343 343 static_assert(DEV_DESCR_MAX_PACKET_SIZE_OFFSET < CTRL_PIPE_MIN_PACKET_SIZE); 344 344 345 if ((pipe->d irection != USB_DIRECTION_BOTH) ||346 (pipe-> transfer_type != USB_TRANSFER_CONTROL) ||347 (pipe-> endpoint_no != 0)) {345 if ((pipe->desc.direction != USB_DIRECTION_BOTH) || 346 (pipe->desc.transfer_type != USB_TRANSFER_CONTROL) || 347 (pipe->desc.endpoint_no != 0)) { 348 348 return EINVAL; 349 349 } … … 369 369 } 370 370 371 pipe-> max_packet_size371 pipe->desc.max_packet_size 372 372 = dev_descr_start[DEV_DESCR_MAX_PACKET_SIZE_OFFSET]; 373 373 -
uspace/lib/usbdev/src/request.c
r2770b66 r816f5f4 844 844 } 845 845 return usb_request_clear_endpoint_halt(ctrl_pipe, 846 target_pipe-> endpoint_no);846 target_pipe->desc.endpoint_no); 847 847 } 848 848 … … 858 858 { 859 859 uint16_t status_tmp; 860 uint16_t pipe_index = (uint16_t) pipe-> endpoint_no;860 uint16_t pipe_index = (uint16_t) pipe->desc.endpoint_no; 861 861 int rc = usb_request_get_status(ctrl_pipe, 862 862 USB_REQUEST_RECIPIENT_ENDPOINT, uint16_host2usb(pipe_index), -
uspace/lib/usbhost/src/ddf_helpers.c
r2770b66 r816f5f4 86 86 /** Register endpoint interface function. 87 87 * @param fun DDF function. 88 * @param address USB address of the device. 89 * @param endpoint USB endpoint number to be registered. 90 * @param transfer_type Endpoint's transfer type. 91 * @param direction USB communication direction the endpoint is capable of. 92 * @param max_packet_size Maximu size of packets the endpoint accepts. 93 * @param interval Preferred timeout between communication. 88 * @param endpoint_desc Endpoint description. 94 89 * @return Error code. 95 90 */ 96 91 static int register_endpoint( 97 ddf_fun_t *fun, usb_endpoint_t endpoint, 98 usb_transfer_type_t transfer_type, usb_direction_t direction, 99 size_t max_packet_size, unsigned packets, unsigned interval) 92 ddf_fun_t *fun, usb_endpoint_desc_t *endpoint_desc) 100 93 { 101 94 assert(fun); … … 105 98 assert(hcd->bus); 106 99 assert(dev); 107 const size_t size = max_packet_size; 100 101 const size_t size = endpoint_desc->max_packet_size; 108 102 109 103 usb_log_debug("Register endpoint %d:%d %s-%s %zuB %ums.\n", 110 dev->address, endpoint, usb_str_transfer_type(transfer_type), 111 usb_str_direction(direction), max_packet_size, interval); 112 113 return bus_add_ep(hcd->bus, dev, endpoint, direction, transfer_type, 114 max_packet_size, packets, size); 115 } 116 117 /** Unregister endpoint interface function. 118 * @param fun DDF function. 119 * @param address USB address of the endpoint. 120 * @param endpoint USB endpoint number. 121 * @param direction Communication direction of the enpdoint to unregister. 122 * @return Error code. 123 */ 104 dev->address, endpoint_desc->endpoint_no, 105 usb_str_transfer_type(endpoint_desc->transfer_type), 106 usb_str_direction(endpoint_desc->direction), 107 endpoint_desc->max_packet_size, endpoint_desc->usb2.polling_interval); 108 109 return bus_add_ep(hcd->bus, dev, endpoint_desc->endpoint_no, 110 endpoint_desc->direction, endpoint_desc->transfer_type, 111 endpoint_desc->max_packet_size, endpoint_desc->packets, 112 size); 113 } 114 115 /** Unregister endpoint interface function. 116 * @param fun DDF function. 117 * @param endpoint_desc Endpoint description. 118 * @return Error code. 119 */ 124 120 static int unregister_endpoint( 125 ddf_fun_t *fun, usb_endpoint_t endpoint, usb_direction_t direction)121 ddf_fun_t *fun, usb_endpoint_desc_t *endpoint_desc) 126 122 { 127 123 assert(fun); … … 131 127 assert(hcd->bus); 132 128 assert(dev); 129 133 130 const usb_target_t target = {{ 134 131 .address = dev->address, 135 .endpoint = endpoint 132 .endpoint = endpoint_desc->endpoint_no 136 133 }}; 134 137 135 usb_log_debug("Unregister endpoint %d:%d %s.\n", 138 dev->address, endpoint, usb_str_direction(direction)); 139 return bus_remove_ep(hcd->bus, target, direction); 136 dev->address, endpoint_desc->endpoint_no, 137 usb_str_direction(endpoint_desc->direction)); 138 return bus_remove_ep(hcd->bus, target, endpoint_desc->direction); 140 139 } 141 140
Note:
See TracChangeset
for help on using the changeset viewer.