Changeset 55e388a1 in mainline for uspace/lib/usb/src
- Timestamp:
- 2011-03-24T14:57:53Z (14 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- b53d3b7
- Parents:
- 361e61b (diff), e18e0d6 (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. - Location:
- uspace/lib/usb/src
- Files:
-
- 12 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/usb/src/devdrv.c
r361e61b r55e388a1 126 126 127 127 for (i = 0; i < pipe_count; i++) { 128 dev->pipes[i].pipe = malloc(sizeof(usb_ endpoint_pipe_t));128 dev->pipes[i].pipe = malloc(sizeof(usb_pipe_t)); 129 129 if (dev->pipes[i].pipe == NULL) { 130 130 usb_log_oom(dev->ddf_dev); … … 137 137 } 138 138 139 void *config_descriptor; 140 size_t config_descriptor_size; 141 rc = usb_request_get_full_configuration_descriptor_alloc( 142 &dev->ctrl_pipe, 0, &config_descriptor, &config_descriptor_size); 143 if (rc != EOK) { 144 usb_log_error("Failed retrieving configuration of `%s': %s.\n", 145 dev->ddf_dev->name, str_error(rc)); 146 goto rollback; 147 } 148 149 rc = usb_endpoint_pipe_initialize_from_configuration(dev->pipes, 150 pipe_count, config_descriptor, config_descriptor_size, &dev->wire); 139 rc = usb_pipe_initialize_from_configuration(dev->pipes, pipe_count, 140 dev->descriptors.configuration, dev->descriptors.configuration_size, 141 &dev->wire); 151 142 if (rc != EOK) { 152 143 usb_log_error("Failed initializing USB endpoints: %s.\n", … … 172 163 for (i = 0; i < pipe_count; i++) { 173 164 if (dev->pipes[i].present) { 174 rc = usb_ endpoint_pipe_register(dev->pipes[i].pipe,165 rc = usb_pipe_register(dev->pipes[i].pipe, 175 166 dev->pipes[i].descriptor->poll_interval, 176 167 &hc_conn); … … 219 210 } 220 211 221 rc = usb_ endpoint_pipe_initialize_default_control(&dev->ctrl_pipe,212 rc = usb_pipe_initialize_default_control(&dev->ctrl_pipe, 222 213 &dev->wire); 223 214 if (rc != EOK) { … … 228 219 } 229 220 230 rc = usb_ endpoint_pipe_probe_default_control(&dev->ctrl_pipe);221 rc = usb_pipe_probe_default_control(&dev->ctrl_pipe); 231 222 if (rc != EOK) { 232 223 usb_log_error( … … 237 228 238 229 /* 239 * Initialization of other pipes requires open session on 240 * default control pipe. 230 * For further actions, we need open session on default control pipe. 241 231 */ 242 rc = usb_ endpoint_pipe_start_session(&dev->ctrl_pipe);232 rc = usb_pipe_start_session(&dev->ctrl_pipe); 243 233 if (rc != EOK) { 244 234 usb_log_error("Failed to start an IPC session: %s.\n", 245 235 str_error(rc)); 236 return rc; 237 } 238 239 /* Get the device descriptor. */ 240 rc = usb_request_get_device_descriptor(&dev->ctrl_pipe, 241 &dev->descriptors.device); 242 if (rc != EOK) { 243 usb_log_error("Failed to retrieve device descriptor: %s.\n", 244 str_error(rc)); 245 return rc; 246 } 247 248 /* Get the full configuration descriptor. */ 249 rc = usb_request_get_full_configuration_descriptor_alloc( 250 &dev->ctrl_pipe, 0, (void **) &dev->descriptors.configuration, 251 &dev->descriptors.configuration_size); 252 if (rc != EOK) { 253 usb_log_error("Failed retrieving configuration descriptor: %s.\n", 254 dev->ddf_dev->name, str_error(rc)); 246 255 return rc; 247 256 } … … 252 261 253 262 /* No checking here. */ 254 usb_endpoint_pipe_end_session(&dev->ctrl_pipe); 263 usb_pipe_end_session(&dev->ctrl_pipe); 264 265 /* Rollback actions. */ 266 if (rc != EOK) { 267 if (dev->descriptors.configuration != NULL) { 268 free(dev->descriptors.configuration); 269 } 270 } 255 271 256 272 return rc; … … 283 299 dev->ddf_dev->driver_data = dev; 284 300 dev->driver_data = NULL; 301 dev->descriptors.configuration = NULL; 285 302 286 303 rc = initialize_pipes(dev); -
uspace/lib/usb/src/devpoll.c
r361e61b r55e388a1 64 64 assert(polling_data); 65 65 66 usb_ endpoint_pipe_t *pipe66 usb_pipe_t *pipe 67 67 = polling_data->dev->pipes[polling_data->pipe_index].pipe; 68 68 … … 71 71 int rc; 72 72 73 rc = usb_ endpoint_pipe_start_session(pipe);73 rc = usb_pipe_start_session(pipe); 74 74 if (rc != EOK) { 75 75 failed_attempts++; … … 78 78 79 79 size_t actual_size; 80 rc = usb_ endpoint_pipe_read(pipe, polling_data->buffer,80 rc = usb_pipe_read(pipe, polling_data->buffer, 81 81 polling_data->request_size, &actual_size); 82 82 83 83 /* Quit the session regardless of errors. */ 84 usb_ endpoint_pipe_end_session(pipe);84 usb_pipe_end_session(pipe); 85 85 86 86 if (rc != EOK) { -
uspace/lib/usb/src/hidparser.c
r361e61b r55e388a1 84 84 { 85 85 if(parser == NULL) { 86 return -1;86 return EINVAL; 87 87 } 88 88 … … 115 115 size_t offset_output=0; 116 116 size_t offset_feature=0; 117 118 if(usb_hid_parser_init(parser) != EOK) { 119 return EINVAL; 120 } 117 121 118 122 … … 128 132 129 133 if((i+USB_HID_ITEM_SIZE(data[i]))>= size){ 130 return -1; // TODO ERROR CODE134 return EINVAL; // TODO ERROR CODE 131 135 } 132 136 … … 530 534 void usb_hid_descriptor_print(usb_hid_report_parser_t *parser) 531 535 { 536 if(parser == NULL) { 537 return; 538 } 539 532 540 usb_log_debug("INPUT:\n"); 533 541 usb_hid_descriptor_print_list(&parser->input); … … 615 623 size_t j=0; 616 624 625 if(parser == NULL) { 626 return EINVAL; 627 } 628 629 617 630 // get the size of result keycodes array 618 631 usb_hid_report_path_t path; … … 737 750 int usb_hid_report_input_length(const usb_hid_report_parser_t *parser, 738 751 const usb_hid_report_path_t *path) 739 { 752 { 740 753 int ret = 0; 741 754 link_t *item; 742 755 usb_hid_report_item_t *report_item; 743 756 757 if(parser == NULL) { 758 return EINVAL; 759 } 760 744 761 item = (&parser->input)->next; 745 762 while(&parser->input != item) { -
uspace/lib/usb/src/host/batch.c
r361e61b r55e388a1 30 30 */ 31 31 /** @file 32 * @brief OHCI driver USB transaction structure32 * USB transfer transaction structures (implementation). 33 33 */ 34 34 #include <errno.h> … … 39 39 #include <usb/host/batch.h> 40 40 41 void batch_init(42 batch_t *instance,41 void usb_transfer_batch_init( 42 usb_transfer_batch_t *instance, 43 43 usb_target_t target, 44 44 usb_transfer_type_t transfer_type, … … 85 85 * 86 86 */ 87 void batch_finish(batch_t *instance, int error)87 void usb_transfer_batch_finish(usb_transfer_batch_t *instance, int error) 88 88 { 89 89 assert(instance); … … 98 98 * parameters. 99 99 */ 100 void batch_call_in(batch_t *instance)100 void usb_transfer_batch_call_in(usb_transfer_batch_t *instance) 101 101 { 102 102 assert(instance); … … 107 107 instance->buffer_size); 108 108 109 int err = instance->error; 110 usb_log_debug("Batch(%p) callback IN(type:%d): %s(%d), %zu.\n", 111 instance, instance->transfer_type, str_error(err), err, 112 instance->transfered_size); 109 usb_log_debug("Batch %p done (T%d.%d, %s %s in, %zuB): %s (%d).\n", 110 instance, 111 instance->target.address, instance->target.endpoint, 112 usb_str_speed(instance->speed), 113 usb_str_transfer_type_short(instance->transfer_type), 114 instance->transfered_size, 115 str_error(instance->error), instance->error); 113 116 114 instance->callback_in( 115 instance-> fun, err, instance->transfered_size, instance->arg);117 instance->callback_in(instance->fun, instance->error, 118 instance->transfered_size, instance->arg); 116 119 } 117 120 /*----------------------------------------------------------------------------*/ … … 120 123 * @param[in] instance Batch structure to use. 121 124 */ 122 void batch_call_out(batch_t *instance)125 void usb_transfer_batch_call_out(usb_transfer_batch_t *instance) 123 126 { 124 127 assert(instance); 125 128 assert(instance->callback_out); 126 129 127 int err = instance->error; 128 usb_log_debug("Batch(%p) callback OUT(type:%d): %s(%d).\n", 129 instance, instance->transfer_type, str_error(err), err); 130 usb_log_debug("Batch %p done (T%d.%d, %s %s out): %s (%d).\n", 131 instance, 132 instance->target.address, instance->target.endpoint, 133 usb_str_speed(instance->speed), 134 usb_str_transfer_type_short(instance->transfer_type), 135 str_error(instance->error), instance->error); 136 130 137 instance->callback_out(instance->fun, 131 err, instance->arg);138 instance->error, instance->arg); 132 139 } 133 140 /** -
uspace/lib/usb/src/host/device_keeper.c
r361e61b r55e388a1 31 31 */ 32 32 /** @file 33 * @brief UHCI driver33 * Device keeper structure and functions (implementation). 34 34 */ 35 35 #include <assert.h> … … 45 45 * Set all values to false/0. 46 46 */ 47 void device_keeper_init(device_keeper_t *instance)47 void usb_device_keeper_init(usb_device_keeper_t *instance) 48 48 { 49 49 assert(instance); … … 65 65 * @param[in] speed Speed of the device requesting default address. 66 66 */ 67 void device_keeper_reserve_default(device_keeper_t *instance, usb_speed_t speed) 67 void usb_device_keeper_reserve_default_address(usb_device_keeper_t *instance, 68 usb_speed_t speed) 68 69 { 69 70 assert(instance); … … 83 84 * @param[in] speed Speed of the device requesting default address. 84 85 */ 85 void device_keeper_release_default(device_keeper_t *instance)86 void usb_device_keeper_release_default_address(usb_device_keeper_t *instance) 86 87 { 87 88 assert(instance); … … 100 101 * Really ugly one. 101 102 */ 102 void device_keeper_reset_if_need(103 device_keeper_t *instance, usb_target_t target, const unsigned char*data)103 void usb_device_keeper_reset_if_need(usb_device_keeper_t *instance, 104 usb_target_t target, const uint8_t *data) 104 105 { 105 106 assert(instance); … … 144 145 * @return Error code 145 146 */ 146 int device_keeper_get_toggle(147 device_keeper_t *instance,usb_target_t target, usb_direction_t direction)147 int usb_device_keeper_get_toggle(usb_device_keeper_t *instance, 148 usb_target_t target, usb_direction_t direction) 148 149 { 149 150 assert(instance); … … 173 174 * @return Error code. 174 175 */ 175 int device_keeper_set_toggle(device_keeper_t *instance,176 int usb_device_keeper_set_toggle(usb_device_keeper_t *instance, 176 177 usb_target_t target, usb_direction_t direction, bool toggle) 177 178 { … … 207 208 * @return Free address, or error code. 208 209 */ 209 usb_address_t device_keeper_request( 210 device_keeper_t *instance, usb_speed_t speed) 211 { 212 assert(instance); 213 fibril_mutex_lock(&instance->guard); 214 215 usb_address_t new_address = instance->last_address + 1; 216 while (instance->devices[new_address].occupied) { 210 usb_address_t device_keeper_get_free_address(usb_device_keeper_t *instance, 211 usb_speed_t speed) 212 { 213 assert(instance); 214 fibril_mutex_lock(&instance->guard); 215 216 usb_address_t new_address = instance->last_address; 217 do { 218 ++new_address; 219 if (new_address > USB11_ADDRESS_MAX) 220 new_address = 1; 217 221 if (new_address == instance->last_address) { 218 222 fibril_mutex_unlock(&instance->guard); 219 223 return ENOSPC; 220 224 } 221 if (new_address == USB11_ADDRESS_MAX) 222 new_address = 1; 223 ++new_address; 224 } 225 } while (instance->devices[new_address].occupied); 225 226 226 227 assert(new_address != USB_ADDRESS_DEFAULT); … … 241 242 * @param[in] handle Devman handle of the device. 242 243 */ 243 void device_keeper_bind(244 device_keeper_t *instance,usb_address_t address, devman_handle_t handle)244 void usb_device_keeper_bind(usb_device_keeper_t *instance, 245 usb_address_t address, devman_handle_t handle) 245 246 { 246 247 assert(instance); … … 258 259 * @param[in] address Device address 259 260 */ 260 void device_keeper_release(device_keeper_t *instance, usb_address_t address) 261 void usb_device_keeper_release(usb_device_keeper_t *instance, 262 usb_address_t address) 261 263 { 262 264 assert(instance); … … 276 278 * @return USB Address, or error code. 277 279 */ 278 usb_address_t device_keeper_find(279 dev ice_keeper_t *instance, devman_handle_t handle)280 usb_address_t usb_device_keeper_find(usb_device_keeper_t *instance, 281 devman_handle_t handle) 280 282 { 281 283 assert(instance); … … 299 301 * @return USB speed. 300 302 */ 301 usb_speed_t device_keeper_speed(302 device_keeper_t *instance,usb_address_t address)303 usb_speed_t usb_device_keeper_get_speed(usb_device_keeper_t *instance, 304 usb_address_t address) 303 305 { 304 306 assert(instance); … … 307 309 return instance->devices[address].speed; 308 310 } 311 309 312 /** 310 313 * @} -
uspace/lib/usb/src/hub.c
r361e61b r55e388a1 228 228 } 229 229 230 usb_ endpoint_pipe_t ctrl_pipe;231 rc = usb_ endpoint_pipe_initialize_default_control(&ctrl_pipe,230 usb_pipe_t ctrl_pipe; 231 rc = usb_pipe_initialize_default_control(&ctrl_pipe, 232 232 &dev_conn); 233 233 if (rc != EOK) { … … 235 235 goto leave_release_default_address; 236 236 } 237 rc = usb_ endpoint_pipe_probe_default_control(&ctrl_pipe);237 rc = usb_pipe_probe_default_control(&ctrl_pipe); 238 238 if (rc != EOK) { 239 239 rc = ENOTCONN; … … 241 241 } 242 242 243 rc = usb_ endpoint_pipe_start_session(&ctrl_pipe);243 rc = usb_pipe_start_session(&ctrl_pipe); 244 244 if (rc != EOK) { 245 245 rc = ENOTCONN; … … 253 253 } 254 254 255 usb_ endpoint_pipe_end_session(&ctrl_pipe);255 usb_pipe_end_session(&ctrl_pipe); 256 256 257 257 /* … … 306 306 307 307 leave_stop_session: 308 usb_ endpoint_pipe_end_session(&ctrl_pipe);308 usb_pipe_end_session(&ctrl_pipe); 309 309 310 310 leave_release_default_address: -
uspace/lib/usb/src/pipes.c
r361e61b r55e388a1 233 233 * A session is something inside what any communication occurs. 234 234 * It is expected that sessions would be started right before the transfer 235 * and ended - see usb_ endpoint_pipe_end_session() - after the last235 * and ended - see usb_pipe_end_session() - after the last 236 236 * transfer. 237 237 * The reason for this is that session actually opens some communication … … 244 244 * @return Error code. 245 245 */ 246 int usb_ endpoint_pipe_start_session(usb_endpoint_pipe_t *pipe)246 int usb_pipe_start_session(usb_pipe_t *pipe) 247 247 { 248 248 assert(pipe); 249 249 250 if (usb_ endpoint_pipe_is_session_started(pipe)) {250 if (usb_pipe_is_session_started(pipe)) { 251 251 return EBUSY; 252 252 } … … 265 265 /** Ends a session on the endpoint pipe. 266 266 * 267 * @see usb_ endpoint_pipe_start_session267 * @see usb_pipe_start_session 268 268 * 269 269 * @param pipe Endpoint pipe to end the session on. 270 270 * @return Error code. 271 271 */ 272 int usb_ endpoint_pipe_end_session(usb_endpoint_pipe_t *pipe)272 int usb_pipe_end_session(usb_pipe_t *pipe) 273 273 { 274 274 assert(pipe); 275 275 276 if (!usb_ endpoint_pipe_is_session_started(pipe)) {276 if (!usb_pipe_is_session_started(pipe)) { 277 277 return ENOENT; 278 278 } … … 296 296 * @return Whether @p pipe has opened a session. 297 297 */ 298 bool usb_ endpoint_pipe_is_session_started(usb_endpoint_pipe_t *pipe)298 bool usb_pipe_is_session_started(usb_pipe_t *pipe) 299 299 { 300 300 return (pipe->hc_phone >= 0); -
uspace/lib/usb/src/pipesinit.c
r361e61b r55e388a1 193 193 } 194 194 195 int rc = usb_ endpoint_pipe_initialize(ep_mapping->pipe, wire,195 int rc = usb_pipe_initialize(ep_mapping->pipe, wire, 196 196 ep_no, description.transfer_type, endpoint->max_packet_size, 197 197 description.direction); … … 276 276 * @return Error code. 277 277 */ 278 int usb_ endpoint_pipe_initialize_from_configuration(278 int usb_pipe_initialize_from_configuration( 279 279 usb_endpoint_mapping_t *mapping, size_t mapping_count, 280 280 uint8_t *configuration_descriptor, size_t configuration_descriptor_size, … … 342 342 * @return Error code. 343 343 */ 344 int usb_ endpoint_pipe_initialize(usb_endpoint_pipe_t *pipe,344 int usb_pipe_initialize(usb_pipe_t *pipe, 345 345 usb_device_connection_t *connection, usb_endpoint_t endpoint_no, 346 346 usb_transfer_type_t transfer_type, size_t max_packet_size, … … 367 367 * @return Error code. 368 368 */ 369 int usb_ endpoint_pipe_initialize_default_control(usb_endpoint_pipe_t *pipe,369 int usb_pipe_initialize_default_control(usb_pipe_t *pipe, 370 370 usb_device_connection_t *connection) 371 371 { … … 373 373 assert(connection); 374 374 375 int rc = usb_ endpoint_pipe_initialize(pipe, connection,375 int rc = usb_pipe_initialize(pipe, connection, 376 376 0, USB_TRANSFER_CONTROL, CTRL_PIPE_MIN_PACKET_SIZE, 377 377 USB_DIRECTION_BOTH); … … 390 390 * @return Error code. 391 391 */ 392 int usb_ endpoint_pipe_probe_default_control(usb_endpoint_pipe_t *pipe)392 int usb_pipe_probe_default_control(usb_pipe_t *pipe) 393 393 { 394 394 assert(pipe); … … 408 408 409 409 TRY_LOOP(failed_attempts) { 410 rc = usb_ endpoint_pipe_start_session(pipe);410 rc = usb_pipe_start_session(pipe); 411 411 if (rc == EOK) { 412 412 break; … … 433 433 } 434 434 } 435 usb_ endpoint_pipe_end_session(pipe);435 usb_pipe_end_session(pipe); 436 436 if (rc != EOK) { 437 437 return rc; … … 451 451 * @return Error code. 452 452 */ 453 int usb_ endpoint_pipe_register(usb_endpoint_pipe_t *pipe,453 int usb_pipe_register(usb_pipe_t *pipe, 454 454 unsigned int interval, 455 455 usb_hc_connection_t *hc_connection) … … 479 479 * @return Error code. 480 480 */ 481 int usb_ endpoint_pipe_unregister(usb_endpoint_pipe_t *pipe,481 int usb_pipe_unregister(usb_pipe_t *pipe, 482 482 usb_hc_connection_t *hc_connection) 483 483 { -
uspace/lib/usb/src/pipesio.c
r361e61b r55e388a1 58 58 * @return Error code. 59 59 */ 60 static int usb_ endpoint_pipe_read_no_checks(usb_endpoint_pipe_t *pipe,60 static int usb_pipe_read_no_checks(usb_pipe_t *pipe, 61 61 void *buffer, size_t size, size_t *size_transfered) 62 62 { … … 140 140 * @return Error code. 141 141 */ 142 int usb_ endpoint_pipe_read(usb_endpoint_pipe_t *pipe,142 int usb_pipe_read(usb_pipe_t *pipe, 143 143 void *buffer, size_t size, size_t *size_transfered) 144 144 { … … 153 153 } 154 154 155 if (!usb_ endpoint_pipe_is_session_started(pipe)) {155 if (!usb_pipe_is_session_started(pipe)) { 156 156 return EBADF; 157 157 } … … 168 168 int rc; 169 169 170 rc = usb_ endpoint_pipe_read_no_checks(pipe, buffer, size, &act_size);170 rc = usb_pipe_read_no_checks(pipe, buffer, size, &act_size); 171 171 if (rc != EOK) { 172 172 return rc; … … 190 190 * @return Error code. 191 191 */ 192 static int usb_ endpoint_pipe_write_no_check(usb_endpoint_pipe_t *pipe,192 static int usb_pipe_write_no_check(usb_pipe_t *pipe, 193 193 void *buffer, size_t size) 194 194 { … … 247 247 * @return Error code. 248 248 */ 249 int usb_ endpoint_pipe_write(usb_endpoint_pipe_t *pipe,249 int usb_pipe_write(usb_pipe_t *pipe, 250 250 void *buffer, size_t size) 251 251 { … … 260 260 } 261 261 262 if (!usb_ endpoint_pipe_is_session_started(pipe)) {262 if (!usb_pipe_is_session_started(pipe)) { 263 263 return EBADF; 264 264 } … … 272 272 } 273 273 274 int rc = usb_ endpoint_pipe_write_no_check(pipe, buffer, size);274 int rc = usb_pipe_write_no_check(pipe, buffer, size); 275 275 276 276 return rc; … … 289 289 * @return Error code. 290 290 */ 291 static int usb_ endpoint_pipe_control_read_no_check(usb_endpoint_pipe_t *pipe,291 static int usb_pipe_control_read_no_check(usb_pipe_t *pipe, 292 292 void *setup_buffer, size_t setup_buffer_size, 293 293 void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size) … … 365 365 * @return Error code. 366 366 */ 367 int usb_ endpoint_pipe_control_read(usb_endpoint_pipe_t *pipe,367 int usb_pipe_control_read(usb_pipe_t *pipe, 368 368 void *setup_buffer, size_t setup_buffer_size, 369 369 void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size) … … 379 379 } 380 380 381 if (!usb_ endpoint_pipe_is_session_started(pipe)) {381 if (!usb_pipe_is_session_started(pipe)) { 382 382 return EBADF; 383 383 } … … 389 389 390 390 size_t act_size = 0; 391 int rc = usb_ endpoint_pipe_control_read_no_check(pipe,391 int rc = usb_pipe_control_read_no_check(pipe, 392 392 setup_buffer, setup_buffer_size, 393 393 data_buffer, data_buffer_size, &act_size); … … 414 414 * @return Error code. 415 415 */ 416 static int usb_ endpoint_pipe_control_write_no_check(usb_endpoint_pipe_t *pipe,416 static int usb_pipe_control_write_no_check(usb_pipe_t *pipe, 417 417 void *setup_buffer, size_t setup_buffer_size, 418 418 void *data_buffer, size_t data_buffer_size) … … 473 473 * @return Error code. 474 474 */ 475 int usb_ endpoint_pipe_control_write(usb_endpoint_pipe_t *pipe,475 int usb_pipe_control_write(usb_pipe_t *pipe, 476 476 void *setup_buffer, size_t setup_buffer_size, 477 477 void *data_buffer, size_t data_buffer_size) … … 491 491 } 492 492 493 if (!usb_ endpoint_pipe_is_session_started(pipe)) {493 if (!usb_pipe_is_session_started(pipe)) { 494 494 return EBADF; 495 495 } … … 500 500 } 501 501 502 int rc = usb_ endpoint_pipe_control_write_no_check(pipe,502 int rc = usb_pipe_control_write_no_check(pipe, 503 503 setup_buffer, setup_buffer_size, data_buffer, data_buffer_size); 504 504 -
uspace/lib/usb/src/recognise.c
r361e61b r55e388a1 311 311 * @return Error code. 312 312 */ 313 int usb_device_create_match_ids(usb_ endpoint_pipe_t *ctrl_pipe,313 int usb_device_create_match_ids(usb_pipe_t *ctrl_pipe, 314 314 match_id_list_t *matches) 315 315 { … … 363 363 int rc; 364 364 usb_device_connection_t dev_connection; 365 usb_ endpoint_pipe_t ctrl_pipe;365 usb_pipe_t ctrl_pipe; 366 366 367 367 rc = usb_device_connection_initialize(&dev_connection, hc_handle, address); … … 370 370 } 371 371 372 rc = usb_ endpoint_pipe_initialize_default_control(&ctrl_pipe,372 rc = usb_pipe_initialize_default_control(&ctrl_pipe, 373 373 &dev_connection); 374 374 if (rc != EOK) { 375 375 goto failure; 376 376 } 377 rc = usb_ endpoint_pipe_probe_default_control(&ctrl_pipe);377 rc = usb_pipe_probe_default_control(&ctrl_pipe); 378 378 if (rc != EOK) { 379 379 goto failure; … … 404 404 child->driver_data = dev_data; 405 405 406 rc = usb_ endpoint_pipe_start_session(&ctrl_pipe);406 rc = usb_pipe_start_session(&ctrl_pipe); 407 407 if (rc != EOK) { 408 408 goto failure; … … 414 414 } 415 415 416 rc = usb_ endpoint_pipe_end_session(&ctrl_pipe);416 rc = usb_pipe_end_session(&ctrl_pipe); 417 417 if (rc != EOK) { 418 418 goto failure; -
uspace/lib/usb/src/request.c
r361e61b r55e388a1 42 42 /** Generic wrapper for SET requests using standard control request format. 43 43 * 44 * @see usb_ endpoint_pipe_control_write44 * @see usb_pipe_control_write 45 45 * 46 46 * @param pipe Pipe used for the communication. … … 60 60 * @retval ERANGE Data buffer too large. 61 61 */ 62 int usb_control_request_set(usb_ endpoint_pipe_t *pipe,62 int usb_control_request_set(usb_pipe_t *pipe, 63 63 usb_request_type_t request_type, usb_request_recipient_t recipient, 64 64 uint8_t request, … … 90 90 setup_packet.length = (uint16_t) data_size; 91 91 92 int rc = usb_ endpoint_pipe_control_write(pipe,92 int rc = usb_pipe_control_write(pipe, 93 93 &setup_packet, sizeof(setup_packet), 94 94 data, data_size); … … 99 99 /** Generic wrapper for GET requests using standard control request format. 100 100 * 101 * @see usb_ endpoint_pipe_control_read101 * @see usb_pipe_control_read 102 102 * 103 103 * @param pipe Pipe used for the communication. … … 120 120 * @retval ERANGE Data buffer too large. 121 121 */ 122 int usb_control_request_get(usb_ endpoint_pipe_t *pipe,122 int usb_control_request_get(usb_pipe_t *pipe, 123 123 usb_request_type_t request_type, usb_request_recipient_t recipient, 124 124 uint8_t request, … … 150 150 setup_packet.length = (uint16_t) data_size; 151 151 152 int rc = usb_ endpoint_pipe_control_read(pipe,152 int rc = usb_pipe_control_read(pipe, 153 153 &setup_packet, sizeof(setup_packet), 154 154 data, data_size, actual_data_size); … … 165 165 * @return Error code. 166 166 */ 167 int usb_request_get_status(usb_ endpoint_pipe_t *pipe,167 int usb_request_get_status(usb_pipe_t *pipe, 168 168 usb_request_recipient_t recipient, uint16_t index, 169 169 uint16_t *status) … … 203 203 * @return Error code. 204 204 */ 205 int usb_request_clear_feature(usb_ endpoint_pipe_t *pipe,205 int usb_request_clear_feature(usb_pipe_t *pipe, 206 206 usb_request_type_t request_type, usb_request_recipient_t recipient, 207 207 uint16_t feature_selector, uint16_t index) … … 231 231 * @return Error code. 232 232 */ 233 int usb_request_set_feature(usb_ endpoint_pipe_t *pipe,233 int usb_request_set_feature(usb_pipe_t *pipe, 234 234 usb_request_type_t request_type, usb_request_recipient_t recipient, 235 235 uint16_t feature_selector, uint16_t index) … … 258 258 * @return Error code. 259 259 */ 260 int usb_request_set_address(usb_ endpoint_pipe_t *pipe,260 int usb_request_set_address(usb_pipe_t *pipe, 261 261 usb_address_t new_address) 262 262 { … … 297 297 * @return Error code. 298 298 */ 299 int usb_request_get_descriptor(usb_ endpoint_pipe_t *pipe,299 int usb_request_get_descriptor(usb_pipe_t *pipe, 300 300 usb_request_type_t request_type, usb_request_recipient_t recipient, 301 301 uint8_t descriptor_type, uint8_t descriptor_index, … … 331 331 * @return 332 332 */ 333 int usb_request_get_descriptor_alloc(usb_ endpoint_pipe_t * pipe,333 int usb_request_get_descriptor_alloc(usb_pipe_t * pipe, 334 334 usb_request_type_t request_type, usb_request_recipient_t recipient, 335 335 uint8_t descriptor_type, uint8_t descriptor_index, … … 400 400 * @return Error code. 401 401 */ 402 int usb_request_get_device_descriptor(usb_ endpoint_pipe_t *pipe,402 int usb_request_get_device_descriptor(usb_pipe_t *pipe, 403 403 usb_standard_device_descriptor_t *descriptor) 404 404 { … … 442 442 * @return Error code. 443 443 */ 444 int usb_request_get_bare_configuration_descriptor(usb_ endpoint_pipe_t *pipe,444 int usb_request_get_bare_configuration_descriptor(usb_pipe_t *pipe, 445 445 int index, usb_standard_configuration_descriptor_t *descriptor) 446 446 { … … 488 488 * @return Error code. 489 489 */ 490 int usb_request_get_full_configuration_descriptor(usb_ endpoint_pipe_t *pipe,490 int usb_request_get_full_configuration_descriptor(usb_pipe_t *pipe, 491 491 int index, void *descriptor, size_t descriptor_size, size_t *actual_size) 492 492 { … … 514 514 */ 515 515 int usb_request_get_full_configuration_descriptor_alloc( 516 usb_ endpoint_pipe_t *pipe, int index,516 usb_pipe_t *pipe, int index, 517 517 void **descriptor_ptr, size_t *descriptor_size) 518 518 { … … 578 578 * @return Error code. 579 579 */ 580 int usb_request_set_descriptor(usb_ endpoint_pipe_t *pipe,580 int usb_request_set_descriptor(usb_pipe_t *pipe, 581 581 usb_request_type_t request_type, usb_request_recipient_t recipient, 582 582 uint8_t descriptor_type, uint8_t descriptor_index, … … 607 607 * @return Error code. 608 608 */ 609 int usb_request_get_configuration(usb_ endpoint_pipe_t *pipe,609 int usb_request_get_configuration(usb_pipe_t *pipe, 610 610 uint8_t *configuration_value) 611 611 { … … 639 639 * @return Error code. 640 640 */ 641 int usb_request_set_configuration(usb_ endpoint_pipe_t *pipe,641 int usb_request_set_configuration(usb_pipe_t *pipe, 642 642 uint8_t configuration_value) 643 643 { … … 658 658 * @return Error code. 659 659 */ 660 int usb_request_get_interface(usb_ endpoint_pipe_t *pipe,660 int usb_request_get_interface(usb_pipe_t *pipe, 661 661 uint8_t interface_index, uint8_t *alternate_setting) 662 662 { … … 691 691 * @return Error code. 692 692 */ 693 int usb_request_set_interface(usb_ endpoint_pipe_t *pipe,693 int usb_request_set_interface(usb_pipe_t *pipe, 694 694 uint8_t interface_index, uint8_t alternate_setting) 695 695 { … … 710 710 * @return Error code. 711 711 */ 712 int usb_request_get_supported_languages(usb_ endpoint_pipe_t *pipe,712 int usb_request_get_supported_languages(usb_pipe_t *pipe, 713 713 l18_win_locales_t **languages_ptr, size_t *languages_count) 714 714 { … … 782 782 * @return Error code. 783 783 */ 784 int usb_request_get_string(usb_ endpoint_pipe_t *pipe,784 int usb_request_get_string(usb_pipe_t *pipe, 785 785 size_t index, l18_win_locales_t lang, char **string_ptr) 786 786 { -
uspace/lib/usb/src/usb.c
r361e61b r55e388a1 36 36 #include <errno.h> 37 37 38 #define ARR_SIZE(arr) (sizeof(arr)/sizeof(arr[0])) 39 40 static const char *str_speed[] = { 41 "low", 42 "full", 43 "high" 44 }; 45 46 static const char *str_transfer_type[] = { 47 "control", 48 "isochronous", 49 "bulk", 50 "interrupt" 51 }; 52 53 static const char *str_transfer_type_short[] = { 54 "ctrl", 55 "iso", 56 "bulk", 57 "intr" 58 }; 38 59 39 60 /** String representation for USB transfer type. … … 42 63 * @return Transfer type as a string (in English). 43 64 */ 44 const char * 65 const char *usb_str_transfer_type(usb_transfer_type_t t) 45 66 { 46 switch (t) { 47 case USB_TRANSFER_ISOCHRONOUS: 48 return "isochronous"; 49 case USB_TRANSFER_INTERRUPT: 50 return "interrupt"; 51 case USB_TRANSFER_CONTROL: 52 return "control"; 53 case USB_TRANSFER_BULK: 54 return "bulk"; 55 default: 56 return "unknown"; 67 if (t >= ARR_SIZE(str_transfer_type)) { 68 return "invalid"; 57 69 } 70 return str_transfer_type[t]; 71 } 72 73 /** String representation for USB transfer type (short version). 74 * 75 * @param t Transfer type. 76 * @return Transfer type as a short string for debugging messages. 77 */ 78 const char *usb_str_transfer_type_short(usb_transfer_type_t t) 79 { 80 if (t >= ARR_SIZE(str_transfer_type_short)) { 81 return "invl"; 82 } 83 return str_transfer_type_short[t]; 84 } 85 86 /** String representation of USB speed. 87 * 88 * @param s The speed. 89 * @return USB speed as a string (in English). 90 */ 91 const char *usb_str_speed(usb_speed_t s) 92 { 93 if (s >= ARR_SIZE(str_speed)) { 94 return "invalid"; 95 } 96 return str_speed[s]; 58 97 } 59 98
Note:
See TracChangeset
for help on using the changeset viewer.