Changeset 2e85b3c in mainline
- Timestamp:
- 2011-02-16T18:22:43Z (14 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- f4c87aa9
- Parents:
- 600733e (diff), ec59693 (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
- Files:
-
- 5 added
- 6 deleted
- 30 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/app/tester/adt/usbaddrkeep.c
r600733e r2e85b3c 29 29 #include <stdio.h> 30 30 #include <stdlib.h> 31 #include <usb/ hcd.h>31 #include <usb/addrkeep.h> 32 32 #include <errno.h> 33 33 #include "../tester.h" -
uspace/app/virtusbkbd/kbdconfig.c
r600733e r2e85b3c 61 61 .endpoint_count = 1, 62 62 .interface_class = USB_CLASS_HID, 63 .interface_subclass = 0,63 .interface_subclass = USB_HID_SUBCLASS_BOOT, 64 64 .interface_protocol = USB_HID_PROTOCOL_KEYBOARD, 65 65 .str_interface = 0 -
uspace/drv/uhci-hcd/iface.c
r600733e r2e85b3c 103 103 /*----------------------------------------------------------------------------*/ 104 104 static int interrupt_out(device_t *dev, usb_target_t target, 105 void *data, size_tsize,106 usbhc_iface_transfer_out_callback_t callback, void *arg)107 { 108 size_t max_packet_size = 8; 105 size_t max_packet_size, 106 void *data, size_t size, 107 usbhc_iface_transfer_out_callback_t callback, void *arg) 108 { 109 109 dev_speed_t speed = FULL_SPEED; 110 110 … … 118 118 /*----------------------------------------------------------------------------*/ 119 119 static int interrupt_in(device_t *dev, usb_target_t target, 120 void *data, size_tsize,121 usbhc_iface_transfer_in_callback_t callback, void *arg)122 { 123 size_t max_packet_size = 4; 120 size_t max_packet_size, 121 void *data, size_t size, 122 usbhc_iface_transfer_in_callback_t callback, void *arg) 123 { 124 124 dev_speed_t speed = FULL_SPEED; 125 125 … … 133 133 /*----------------------------------------------------------------------------*/ 134 134 static int control_write(device_t *dev, usb_target_t target, 135 size_t max_packet_size, 135 136 void *setup_data, size_t setup_size, void *data, size_t size, 136 137 usbhc_iface_transfer_out_callback_t callback, void *arg) 137 138 { 138 size_t max_packet_size = 8;139 139 dev_speed_t speed = FULL_SPEED; 140 140 … … 149 149 /*----------------------------------------------------------------------------*/ 150 150 static int control_read(device_t *dev, usb_target_t target, 151 size_t max_packet_size, 151 152 void *setup_data, size_t setup_size, void *data, size_t size, 152 153 usbhc_iface_transfer_in_callback_t callback, void *arg) 153 154 { 154 size_t max_packet_size = 8;155 155 dev_speed_t speed = FULL_SPEED; 156 156 … … 165 165 /*----------------------------------------------------------------------------*/ 166 166 static int control_write_setup(device_t *dev, usb_target_t target, 167 void *data, size_t size, 168 usbhc_iface_transfer_out_callback_t callback, void *arg) 167 size_t max_packet_size, 168 void *data, size_t size, 169 usbhc_iface_transfer_out_callback_t callback, void *arg) 170 { 171 dev_speed_t speed = FULL_SPEED; 172 173 usb_log_warning("Using deprecated API %s.\n", __FUNCTION__); 174 batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL, 175 max_packet_size, speed, NULL, 0, data, size, NULL, callback, arg); 176 if (!batch) 177 return ENOMEM; 178 batch_control_setup_old(batch); 179 return EOK; 180 } 181 /*----------------------------------------------------------------------------*/ 182 static int control_write_data(device_t *dev, usb_target_t target, 183 size_t max_packet_size, 184 void *data, size_t size, 185 usbhc_iface_transfer_out_callback_t callback, void *arg) 186 { 187 dev_speed_t speed = FULL_SPEED; 188 189 usb_log_warning("Using deprecated API %s.\n", __FUNCTION__); 190 batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL, 191 max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg); 192 if (!batch) 193 return ENOMEM; 194 batch_control_write_data_old(batch); 195 return EOK; 196 } 197 /*----------------------------------------------------------------------------*/ 198 static int control_write_status(device_t *dev, usb_target_t target, 199 usbhc_iface_transfer_in_callback_t callback, void *arg) 169 200 { 170 201 size_t max_packet_size = 8; … … 173 204 usb_log_warning("Using deprecated API %s.\n", __FUNCTION__); 174 205 batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL, 206 max_packet_size, speed, NULL, 0, NULL, 0, callback, NULL, arg); 207 if (!batch) 208 return ENOMEM; 209 batch_control_write_status_old(batch); 210 return EOK; 211 } 212 /*----------------------------------------------------------------------------*/ 213 static int control_read_setup(device_t *dev, usb_target_t target, 214 size_t max_packet_size, 215 void *data, size_t size, 216 usbhc_iface_transfer_out_callback_t callback, void *arg) 217 { 218 dev_speed_t speed = FULL_SPEED; 219 220 usb_log_warning("Using deprecated API %s.\n", __FUNCTION__); 221 batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL, 175 222 max_packet_size, speed, NULL, 0, data, size, NULL, callback, arg); 176 223 if (!batch) … … 180 227 } 181 228 /*----------------------------------------------------------------------------*/ 182 static int control_write_data(device_t *dev, usb_target_t target,183 void *data, size_t size,184 usbhc_iface_transfer_out_callback_t callback, void *arg)185 {186 size_t max_packet_size = 8;187 dev_speed_t speed = FULL_SPEED;188 189 usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);190 batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,191 max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg);192 if (!batch)193 return ENOMEM;194 batch_control_write_data_old(batch);195 return EOK;196 }197 /*----------------------------------------------------------------------------*/198 static int control_write_status(device_t *dev, usb_target_t target,199 usbhc_iface_transfer_in_callback_t callback, void *arg)200 {201 size_t max_packet_size = 8;202 dev_speed_t speed = FULL_SPEED;203 204 usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);205 batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,206 max_packet_size, speed, NULL, 0, NULL, 0, callback, NULL, arg);207 if (!batch)208 return ENOMEM;209 batch_control_write_status_old(batch);210 return EOK;211 }212 /*----------------------------------------------------------------------------*/213 static int control_read_setup(device_t *dev, usb_target_t target,214 void *data, size_t size,215 usbhc_iface_transfer_out_callback_t callback, void *arg)216 {217 size_t max_packet_size = 8;218 dev_speed_t speed = FULL_SPEED;219 220 usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);221 batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,222 max_packet_size, speed, NULL, 0, data, size, NULL, callback, arg);223 if (!batch)224 return ENOMEM;225 batch_control_setup_old(batch);226 return EOK;227 }228 /*----------------------------------------------------------------------------*/229 229 static int control_read_data(device_t *dev, usb_target_t target, 230 void *data, size_tsize,231 usbhc_iface_transfer_in_callback_t callback, void *arg)232 { 233 size_t max_packet_size = 8; 230 size_t max_packet_size, 231 void *data, size_t size, 232 usbhc_iface_transfer_in_callback_t callback, void *arg) 233 { 234 234 dev_speed_t speed = FULL_SPEED; 235 235 -
uspace/drv/uhci-rhd/port.c
r600733e r2e85b3c 36 36 37 37 #include <usb/usb.h> /* usb_address_t */ 38 #include <usb/usbdrv.h> /* usb_drv_* */ 38 #include <usb/usbdevice.h> 39 #include <usb/hub.h> 40 #include <usb/request.h> 39 41 #include <usb/debug.h> 40 42 #include <usb/recognise.h> … … 58 60 port->attached_device = 0; 59 61 port->rh = rh; 60 port->hc_phone = parent_phone; 62 int rc = usb_hc_connection_initialize_from_device( 63 &port->hc_connection, rh); 64 if (rc != EOK) { 65 usb_log_error("Failed to initialize connection to HC."); 66 return rc; 67 } 61 68 62 69 port->checker = fibril_create(uhci_port_check, port); … … 98 105 99 106 if (port_status & STATUS_CONNECTED_CHANGED) { 107 int rc = usb_hc_connection_open( 108 &port_instance->hc_connection); 109 if (rc != EOK) { 110 usb_log_error("Failed to connect to HC."); 111 goto next; 112 } 113 100 114 if (port_status & STATUS_CONNECTED) { 101 115 /* new device */ … … 104 118 uhci_port_remove_device(port_instance); 105 119 } 120 121 rc = usb_hc_connection_close( 122 &port_instance->hc_connection); 123 if (rc != EOK) { 124 usb_log_error("Failed to disconnect from HC."); 125 goto next; 126 } 106 127 } 128 next: 107 129 async_usleep(port_instance->wait_period_usec); 108 130 } … … 113 135 { 114 136 assert(port); 115 assert( port->hc_phone);137 assert(usb_hc_connection_is_opened(&port->hc_connection)); 116 138 117 139 usb_log_info("Adding new device on port %d.\n", port->number); 118 140 119 141 /* get address of the future device */ 120 const usb_address_t usb_address = usb_ drv_request_address(port->hc_phone);142 const usb_address_t usb_address = usb_hc_request_address(&port->hc_connection); 121 143 122 144 if (usb_address <= 0) { … … 128 150 129 151 /* get default address */ 130 int ret = usb_ drv_reserve_default_address(port->hc_phone);152 int ret = usb_hc_reserve_default_address(&port->hc_connection); 131 153 if (ret != EOK) { 132 154 usb_log_error("Failed to reserve default address on port %d.\n", 133 155 port->number); 134 int ret2 = 135 usb_drv_release_address(port->hc_phone,usb_address);156 int ret2 = usb_hc_unregister_device(&port->hc_connection, 157 usb_address); 136 158 if (ret2 != EOK) { 137 159 usb_log_fatal("Failed to return requested address on port %d.\n", … … 174 196 } 175 197 176 /* assign address to device */ 177 ret = usb_drv_req_set_address(port->hc_phone, 0, usb_address); 198 /* 199 * Initialize connection to the device. 200 */ 201 /* FIXME: check for errors. */ 202 usb_device_connection_t new_dev_connection; 203 usb_endpoint_pipe_t new_dev_ctrl_pipe; 204 usb_device_connection_initialize_on_default_address( 205 &new_dev_connection, &port->hc_connection); 206 usb_endpoint_pipe_initialize_default_control(&new_dev_ctrl_pipe, 207 &new_dev_connection); 208 209 /* 210 * Assign new address to the device. This function updates 211 * the backing connection to still point to the same device. 212 */ 213 /* FIXME: check for errors. */ 214 usb_endpoint_pipe_start_session(&new_dev_ctrl_pipe); 215 ret = usb_request_set_address(&new_dev_ctrl_pipe, usb_address); 216 usb_endpoint_pipe_end_session(&new_dev_ctrl_pipe); 178 217 179 218 if (ret != EOK) { /* address assigning went wrong */ 180 219 usb_log_error("Failed(%d) to assign address to the device.\n", ret); 181 220 uhci_port_set_enabled(port, false); 182 int release = usb_ drv_release_default_address(port->hc_phone);221 int release = usb_hc_release_default_address(&port->hc_connection); 183 222 if (release != EOK) { 184 223 usb_log_error("Failed to release default address on port %d.\n", … … 194 233 195 234 /* release default address */ 196 ret = usb_ drv_release_default_address(port->hc_phone);235 ret = usb_hc_release_default_address(&port->hc_connection); 197 236 if (ret != EOK) { 198 237 usb_log_error("Failed to release default address on port %d.\n", … … 206 245 assert(port->attached_device == 0); 207 246 208 devman_handle_t hc_handle; 209 ret = usb_drv_find_hc(port->rh, &hc_handle); 210 if (ret != EOK) { 211 usb_log_error("Failed to get handle of host controller: %s.\n", 212 str_error(ret)); 213 uhci_port_set_enabled(port, false); 214 return ENOMEM; 215 } 216 217 ret = usb_device_register_child_in_devman(usb_address, hc_handle, 218 port->rh, &port->attached_device); 247 ret = usb_device_register_child_in_devman(new_dev_connection.address, 248 new_dev_connection.hc_handle, port->rh, &port->attached_device); 249 219 250 if (ret != EOK) { /* something went wrong */ 220 251 usb_log_error("Failed(%d) in usb_drv_register_child.\n", ret); … … 225 256 port->number, usb_address, port->attached_device); 226 257 227 ret = 228 usb_drv_bind_address(port->hc_phone, usb_address, port->attached_device); 258 /* 259 * Register the device in the host controller. 260 */ 261 usb_hc_attached_device_t new_device = { 262 .address = new_dev_connection.address, 263 .handle = port->attached_device 264 }; 265 266 ret = usb_hc_register_device(&port->hc_connection, &new_device); 229 267 // TODO: proper error check here 230 268 assert(ret == EOK); -
uspace/drv/uhci-rhd/port.h
r600733e r2e85b3c 38 38 #include <driver.h> /* device_t */ 39 39 #include <stdint.h> 40 #include <usb/usbdevice.h> 40 41 41 42 #include "port_status.h" … … 46 47 unsigned number; 47 48 unsigned wait_period_usec; 48 int hc_phone;49 usb_hc_connection_t hc_connection; 49 50 device_t *rh; 50 51 devman_handle_t attached_device; -
uspace/drv/usbhub/usbhub.c
r600733e r2e85b3c 84 84 }*/ 85 85 86 result->usb_device = usb_new(usb_hcd_attached_device_info_t); 87 result->usb_device->address = addr; 86 result->address = addr; 88 87 89 88 // get hub descriptor … … 155 154 int opResult; 156 155 usb_target_t target; 157 target.address = hub_info-> usb_device->address;156 target.address = hub_info->address; 158 157 target.endpoint = 0; 159 158 … … 216 215 dprintf(USB_LOG_LEVEL_INFO, "hub dev added"); 217 216 dprintf(USB_LOG_LEVEL_DEBUG, "\taddress %d, has %d ports ", 218 hub_info-> usb_device->address,217 hub_info->address, 219 218 hub_info->port_count); 220 219 dprintf(USB_LOG_LEVEL_DEBUG, "\tused configuration %d",config_descriptor.configuration_number); … … 465 464 466 465 usb_target_t target; 467 target.address = hub_info-> usb_device->address;466 target.address = hub_info->address; 468 467 target.endpoint = 1;/// \TODO get from endpoint descriptor 469 468 dprintf(USB_LOG_LEVEL_INFO, "checking changes for hub at addr %d", … … 507 506 if (interrupt) { 508 507 usb_hub_process_interrupt( 509 hub_info, hc, port, hub_info-> usb_device->address);508 hub_info, hc, port, hub_info->address); 510 509 } 511 510 } -
uspace/drv/usbhub/usbhub.h
r600733e r2e85b3c 36 36 #define DRV_USBHUB_USBHUB_H 37 37 38 #include <ipc/devman.h> 39 #include <usb/usb.h> 40 #include <driver.h> 41 38 42 #define NAME "usbhub" 39 40 #include "usb/hcdhubd.h"41 43 42 44 /** basic information about device attached to hub */ … … 52 54 /** attached device handles */ 53 55 usb_hub_attached_device_t * attached_devs; 54 /** General usb device info. */55 usb_ hcd_attached_device_info_t * usb_device;56 /** USB address of the hub. */ 57 usb_address_t address; 56 58 /** General device info*/ 57 59 device_t * device; 58 59 60 } usb_hub_info_t; 60 61 -
uspace/drv/vhc/conn.h
r600733e r2e85b3c 37 37 38 38 #include <usb/usb.h> 39 #include <usb/hcdhubd.h>40 39 #include <usbhc_iface.h> 41 40 #include "vhcd.h" … … 44 43 void connection_handler_host(sysarg_t); 45 44 46 usb_hcd_transfer_ops_t vhc_transfer_ops;47 45 usbhc_iface_t vhc_iface; 48 46 -
uspace/drv/vhc/connhost.c
r600733e r2e85b3c 36 36 #include <errno.h> 37 37 #include <usb/usb.h> 38 #include <usb/ hcd.h>38 #include <usb/addrkeep.h> 39 39 40 40 #include "vhcd.h" … … 64 64 65 65 static void universal_callback(void *buffer, size_t size, 66 usb_transaction_outcome_t outcome, void *arg)66 int outcome, void *arg) 67 67 { 68 68 transfer_info_t *transfer = (transfer_info_t *) arg; … … 107 107 108 108 static void control_abort_prematurely(control_transfer_info_t *transfer, 109 size_t size, usb_transaction_outcome_t outcome)109 size_t size, int outcome) 110 110 { 111 111 switch (transfer->direction) { … … 127 127 128 128 static void control_callback_two(void *buffer, size_t size, 129 usb_transaction_outcome_t outcome, void *arg)129 int outcome, void *arg) 130 130 { 131 131 control_transfer_info_t *ctrl_transfer = (control_transfer_info_t *) arg; 132 132 133 if (outcome != USB_OUTCOME_OK) {133 if (outcome != EOK) { 134 134 control_abort_prematurely(ctrl_transfer, outcome, size); 135 135 free(ctrl_transfer); … … 165 165 166 166 static void control_callback_one(void *buffer, size_t size, 167 usb_transaction_outcome_t outcome, void *arg)167 int outcome, void *arg) 168 168 { 169 169 control_transfer_info_t *transfer = (control_transfer_info_t *) arg; 170 170 171 if (outcome != USB_OUTCOME_OK) {171 if (outcome != EOK) { 172 172 control_abort_prematurely(transfer, outcome, size); 173 173 free(transfer); … … 276 276 277 277 static int interrupt_out(device_t *dev, usb_target_t target, 278 size_t max_packet_size, 278 279 void *data, size_t size, 279 280 usbhc_iface_transfer_out_callback_t callback, void *arg) … … 285 286 286 287 static int interrupt_in(device_t *dev, usb_target_t target, 288 size_t max_packet_size, 287 289 void *data, size_t size, 288 290 usbhc_iface_transfer_in_callback_t callback, void *arg) … … 294 296 295 297 static int control_write_setup(device_t *dev, usb_target_t target, 298 size_t max_packet_size, 296 299 void *data, size_t size, 297 300 usbhc_iface_transfer_out_callback_t callback, void *arg) … … 303 306 304 307 static int control_write_data(device_t *dev, usb_target_t target, 308 size_t max_packet_size, 305 309 void *data, size_t size, 306 310 usbhc_iface_transfer_out_callback_t callback, void *arg) … … 320 324 321 325 static int control_write(device_t *dev, usb_target_t target, 326 size_t max_packet_size, 322 327 void *setup_packet, size_t setup_packet_size, 323 328 void *data, size_t data_size, … … 337 342 338 343 static int control_read_setup(device_t *dev, usb_target_t target, 344 size_t max_packet_size, 339 345 void *data, size_t size, 340 346 usbhc_iface_transfer_out_callback_t callback, void *arg) … … 346 352 347 353 static int control_read_data(device_t *dev, usb_target_t target, 354 size_t max_packet_size, 348 355 void *data, size_t size, 349 356 usbhc_iface_transfer_in_callback_t callback, void *arg) … … 363 370 364 371 static int control_read(device_t *dev, usb_target_t target, 372 size_t max_packet_size, 365 373 void *setup_packet, size_t setup_packet_size, 366 374 void *data, size_t data_size, -
uspace/drv/vhc/devices.c
r600733e r2e85b3c 112 112 * @param transaction Transaction to be sent over the bus. 113 113 */ 114 usb_transaction_outcome_t virtdev_send_to_all(transaction_t *transaction)114 int virtdev_send_to_all(transaction_t *transaction) 115 115 { 116 116 /* For easier debugging. */ … … 126 126 assert(false && "unreachable branch in switch()"); 127 127 } 128 usb_transaction_outcome_t outcome = USB_OUTCOME_BABBLE;128 int outcome = EBADCHECKSUM; 129 129 130 130 link_t *pos; … … 185 185 */ 186 186 if (rc == EOK) { 187 outcome = USB_OUTCOME_OK;187 outcome = EOK; 188 188 } 189 189 } … … 221 221 break; 222 222 } 223 outcome = USB_OUTCOME_OK;223 outcome = EOK; 224 224 } 225 225 -
uspace/drv/vhc/devices.h
r600733e r2e85b3c 54 54 virtdev_connection_t *virtdev_find(sysarg_t); 55 55 void virtdev_destroy_device(virtdev_connection_t *); 56 usb_transaction_outcome_t virtdev_send_to_all(transaction_t *);56 int virtdev_send_to_all(transaction_t *); 57 57 58 58 #endif -
uspace/drv/vhc/hc.c
r600733e r2e85b3c 89 89 */ 90 90 static void process_transaction_with_outcome(transaction_t * transaction, 91 usb_transaction_outcome_t outcome)91 int outcome) 92 92 { 93 93 usb_log_debug2("Transaction " TRANSACTION_FORMAT " done: %s.\n", 94 94 TRANSACTION_PRINTF(*transaction), 95 usb_str_transaction_outcome(outcome));95 str_error(outcome)); 96 96 97 97 transaction->callback(transaction->buffer, transaction->actual_len, … … 127 127 TRANSACTION_PRINTF(*transaction), ports); 128 128 129 usb_transaction_outcome_t outcome;129 int outcome; 130 130 outcome = virtdev_send_to_all(transaction); 131 131 -
uspace/drv/vhc/hc.h
r600733e r2e85b3c 47 47 */ 48 48 typedef void (*hc_transaction_done_callback_t)(void *buffer, size_t size, 49 usb_transaction_outcome_t outcome, void *arg);49 int outcome, void *arg); 50 50 51 51 /** Pending transaction details. */ -
uspace/lib/c/generic/str_error.c
r600733e r2e85b3c 33 33 */ 34 34 35 #include <errno.h> 35 36 #include <str_error.h> 36 37 #include <stdio.h> … … 63 64 static fibril_local char noerr[NOERR_LEN]; 64 65 65 const char *str_error(const int e rrno)66 const char *str_error(const int e) 66 67 { 67 if ((e rrno <= 0) && (errno>= MIN_ERRNO))68 return err_desc[-e rrno];68 if ((e <= 0) && (e >= MIN_ERRNO)) 69 return err_desc[-e]; 69 70 70 snprintf(noerr, NOERR_LEN, "Unkown error code %d", errno); 71 /* Ad hoc descriptions of error codes interesting for USB. */ 72 switch (e) { 73 case EBADCHECKSUM: 74 return "Bad checksum"; 75 case EAGAIN: 76 return "Resource temporarily unavailable"; 77 default: 78 break; 79 } 80 81 snprintf(noerr, NOERR_LEN, "Unkown error code %d", e); 71 82 return noerr; 72 83 } -
uspace/lib/c/include/errno.h
r600733e r2e85b3c 56 56 #define EMLINK (-266) 57 57 58 /** Bad checksum. */ 59 #define EBADCHECKSUM (-300) 60 58 61 /** An API function is called while another blocking function is in progress. */ 59 62 #define EINPROGRESS (-10036) -
uspace/lib/drv/generic/remote_usbhc.c
r600733e r2e85b3c 40 40 41 41 #define USB_MAX_PAYLOAD_SIZE 1020 42 #define HACK_MAX_PACKET_SIZE 8 43 #define HACK_MAX_PACKET_SIZE_INTERRUPT_IN 4 42 44 43 45 static void remote_usbhc_get_address(device_t *, void *, ipc_callid_t, ipc_call_t *); … … 240 242 241 243 static void callback_out(device_t *device, 242 usb_transaction_outcome_t outcome, void *arg)244 int outcome, void *arg) 243 245 { 244 246 async_transaction_t *trans = (async_transaction_t *)arg; … … 250 252 251 253 static void callback_in(device_t *device, 252 usb_transaction_outcome_t outcome, size_t actual_size, void *arg)254 int outcome, size_t actual_size, void *arg) 253 255 { 254 256 async_transaction_t *trans = (async_transaction_t *)arg; 255 257 256 if (outcome != USB_OUTCOME_OK) {258 if (outcome != EOK) { 257 259 async_answer_0(trans->caller, outcome); 258 260 if (trans->data_caller) { … … 270 272 } 271 273 272 async_answer_0(trans->caller, USB_OUTCOME_OK);274 async_answer_0(trans->caller, EOK); 273 275 274 276 async_transaction_destroy(trans); … … 322 324 trans->size = len; 323 325 324 int rc = transfer_func(device, target, buffer, len, 326 int rc = transfer_func(device, target, HACK_MAX_PACKET_SIZE, 327 buffer, len, 325 328 callback_out, trans); 326 329 … … 368 371 trans->size = len; 369 372 370 int rc = transfer_func(device, target, trans->buffer, len, 373 int rc = transfer_func(device, target, HACK_MAX_PACKET_SIZE_INTERRUPT_IN, 374 trans->buffer, len, 371 375 callback_in, trans); 372 376 … … 540 544 .endpoint = DEV_IPC_GET_ARG2(*call) 541 545 }; 546 size_t data_buffer_len = DEV_IPC_GET_ARG3(*call); 542 547 543 548 int rc; … … 546 551 void *data_buffer = NULL; 547 552 size_t setup_packet_len = 0; 548 size_t data_buffer_len = 0;549 553 550 554 rc = async_data_write_accept(&setup_packet, false, … … 554 558 return; 555 559 } 556 rc = async_data_write_accept(&data_buffer, false, 557 1, USB_MAX_PAYLOAD_SIZE, 0, &data_buffer_len); 558 if (rc != EOK) { 559 async_answer_0(callid, rc); 560 free(setup_packet); 561 return; 560 561 if (data_buffer_len > 0) { 562 rc = async_data_write_accept(&data_buffer, false, 563 1, USB_MAX_PAYLOAD_SIZE, 0, &data_buffer_len); 564 if (rc != EOK) { 565 async_answer_0(callid, rc); 566 free(setup_packet); 567 return; 568 } 562 569 } 563 570 … … 573 580 trans->size = data_buffer_len; 574 581 575 rc = usb_iface->control_write(device, target, 582 rc = usb_iface->control_write(device, target, HACK_MAX_PACKET_SIZE, 576 583 setup_packet, setup_packet_len, 577 584 data_buffer, data_buffer_len, … … 596 603 } 597 604 598 size_t data_len = DEV_IPC_GET_ARG3(*call);599 605 usb_target_t target = { 600 606 .address = DEV_IPC_GET_ARG1(*call), … … 606 612 void *setup_packet = NULL; 607 613 size_t setup_packet_len = 0; 614 size_t data_len = 0; 608 615 609 616 rc = async_data_write_accept(&setup_packet, false, … … 637 644 } 638 645 639 rc = usb_iface->control_read(device, target, 646 rc = usb_iface->control_read(device, target, HACK_MAX_PACKET_SIZE, 640 647 setup_packet, setup_packet_len, 641 648 trans->buffer, trans->size, -
uspace/lib/drv/include/usbhc_iface.h
r600733e r2e85b3c 207 207 /** Callback for outgoing transfer. */ 208 208 typedef void (*usbhc_iface_transfer_out_callback_t)(device_t *, 209 usb_transaction_outcome_t, void *);209 int, void *); 210 210 211 211 /** Callback for incoming transfer. */ 212 212 typedef void (*usbhc_iface_transfer_in_callback_t)(device_t *, 213 usb_transaction_outcome_t, size_t, void *);213 int, size_t, void *); 214 214 215 215 216 216 /** Out transfer processing function prototype. */ 217 typedef int (*usbhc_iface_transfer_out_t)(device_t *, usb_target_t, 217 typedef int (*usbhc_iface_transfer_out_t)(device_t *, usb_target_t, size_t, 218 218 void *, size_t, 219 219 usbhc_iface_transfer_out_callback_t, void *); 220 220 221 /** Setup transfer processing function prototype. */221 /** Setup transfer processing function prototype. @deprecated */ 222 222 typedef usbhc_iface_transfer_out_t usbhc_iface_transfer_setup_t; 223 223 224 224 /** In transfer processing function prototype. */ 225 typedef int (*usbhc_iface_transfer_in_t)(device_t *, usb_target_t, 225 typedef int (*usbhc_iface_transfer_in_t)(device_t *, usb_target_t, size_t, 226 226 void *, size_t, 227 227 usbhc_iface_transfer_in_callback_t, void *); … … 251 251 252 252 int (*control_write)(device_t *, usb_target_t, 253 size_t, 253 254 void *, size_t, void *, size_t, 254 255 usbhc_iface_transfer_out_callback_t, void *); 255 256 256 257 int (*control_read)(device_t *, usb_target_t, 258 size_t, 257 259 void *, size_t, void *, size_t, 258 260 usbhc_iface_transfer_in_callback_t, void *); -
uspace/lib/usb/Makefile
r600733e r2e85b3c 39 39 src/drvpsync.c \ 40 40 src/dump.c \ 41 src/hcdhubd.c \42 src/hcdrv.c \43 41 src/hidparser.c \ 44 src/ localdrv.c \42 src/hub.c \ 45 43 src/pipes.c \ 46 44 src/pipesinit.c \ 45 src/pipesio.c \ 47 46 src/recognise.c \ 48 src/remotedrv.c \49 47 src/request.c \ 50 48 src/usb.c \ 49 src/usbdevice.c \ 51 50 src/usbdrvreq.c \ 52 51 src/usbdrv.c \ -
uspace/lib/usb/include/usb/addrkeep.h
-
Property mode
changed from
120000
to100644
r600733e r2e85b3c 1 hcd.h 1 /* 2 * Copyright (c) 2010 Vojtech Horky 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 9 * - Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * - Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * - The name of the author may not be used to endorse or promote products 15 * derived from this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 /** @addtogroup libusb 30 * @{ 31 */ 32 /** @file 33 * USB address keeping for host controller drivers. 34 */ 35 #ifndef LIBUSB_ADDRKEEP_H_ 36 #define LIBUSB_ADDRKEEP_H_ 37 38 #include <usb/usb.h> 39 #include <fibril_synch.h> 40 #include <devman.h> 41 42 /** Info about used address. */ 43 typedef struct { 44 /** Linked list member. */ 45 link_t link; 46 /** Address. */ 47 usb_address_t address; 48 /** Corresponding devman handle. */ 49 devman_handle_t devman_handle; 50 } usb_address_keeping_used_t; 51 52 /** Structure for keeping track of free and used USB addresses. */ 53 typedef struct { 54 /** Head of list of used addresses. */ 55 link_t used_addresses; 56 /** Upper bound for USB addresses. */ 57 usb_address_t max_address; 58 /** Mutex protecting used address. */ 59 fibril_mutex_t used_addresses_guard; 60 /** Condition variable for used addresses. */ 61 fibril_condvar_t used_addresses_condvar; 62 63 /** Condition variable mutex for default address. */ 64 fibril_mutex_t default_condvar_guard; 65 /** Condition variable for default address. */ 66 fibril_condvar_t default_condvar; 67 /** Whether is default address available. */ 68 bool default_available; 69 } usb_address_keeping_t; 70 71 void usb_address_keeping_init(usb_address_keeping_t *, usb_address_t); 72 73 void usb_address_keeping_reserve_default(usb_address_keeping_t *); 74 void usb_address_keeping_release_default(usb_address_keeping_t *); 75 76 usb_address_t usb_address_keeping_request(usb_address_keeping_t *); 77 int usb_address_keeping_release(usb_address_keeping_t *, usb_address_t); 78 void usb_address_keeping_devman_bind(usb_address_keeping_t *, usb_address_t, 79 devman_handle_t); 80 usb_address_t usb_address_keeping_find(usb_address_keeping_t *, 81 devman_handle_t); 82 83 #endif 84 /** 85 * @} 86 */ -
Property mode
changed from
-
uspace/lib/usb/include/usb/classes/hub.h
r600733e r2e85b3c 37 37 38 38 #include <sys/types.h> 39 #include <usb/hcdhubd.h>40 41 39 42 40 /** Hub class feature selector. … … 80 78 /** 81 79 D1...D0: Logical Power Switching Mode 82 00: Ganged power switching (all ports ’power at80 00: Ganged power switching (all ports power at 83 81 once) 84 82 01: Individual port power switching … … 91 89 00: Global Over-current Protection. The hub 92 90 reports over-current as a summation of all 93 ports ’current draw, without a breakdown of91 ports current draw, without a breakdown of 94 92 individual port over-current status. 95 93 01: Individual Port Over-current Protection. The -
uspace/lib/usb/include/usb/pipes.h
r600733e r2e85b3c 31 31 */ 32 32 /** @file 33 * Communication between device drivers and host controller driver.33 * USB pipes representation. 34 34 */ 35 35 #ifndef LIBUSB_PIPES_H_ … … 38 38 #include <sys/types.h> 39 39 #include <usb/usb.h> 40 #include <usb/usbdevice.h> 40 41 #include <usb/descriptor.h> 41 42 #include <ipc/devman.h> … … 114 115 } usb_endpoint_mapping_t; 115 116 117 int usb_device_connection_initialize_on_default_address( 118 usb_device_connection_t *, usb_hc_connection_t *); 116 119 int usb_device_connection_initialize_from_device(usb_device_connection_t *, 117 120 device_t *); … … 139 142 void *, size_t); 140 143 141 142 143 int usb_endpoint_pipe_async_read(usb_endpoint_pipe_t *, void *, size_t,144 size_t *, usb_handle_t *);145 int usb_endpoint_pipe_async_write(usb_endpoint_pipe_t *, void *, size_t,146 usb_handle_t *);147 148 int usb_endpoint_pipe_async_control_read(usb_endpoint_pipe_t *, void *, size_t,149 void *, size_t, size_t *, usb_handle_t *);150 int usb_endpoint_pipe_async_control_write(usb_endpoint_pipe_t *, void *, size_t,151 void *, size_t, usb_handle_t *);152 153 int usb_endpoint_pipe_wait_for(usb_endpoint_pipe_t *, usb_handle_t);154 155 144 #endif 156 145 /** -
uspace/lib/usb/include/usb/recognise.h
r600733e r2e85b3c 39 39 #include <usb/usb.h> 40 40 #include <usb/pipes.h> 41 #include <ipc/devman.h> 41 42 42 43 int usb_device_create_match_ids(usb_endpoint_pipe_t *, match_id_list_t *); -
uspace/lib/usb/include/usb/usb.h
r600733e r2e85b3c 83 83 } usb_request_recipient_t; 84 84 85 /** USB transaction outcome. */86 typedef enum {87 USB_OUTCOME_OK,88 USB_OUTCOME_CRCERROR,89 USB_OUTCOME_BABBLE90 } usb_transaction_outcome_t;91 92 const char * usb_str_transaction_outcome(usb_transaction_outcome_t o);93 94 85 /** USB address type. 95 86 * Negative values could be used to indicate error. -
uspace/lib/usb/src/addrkeep.c
r600733e r2e85b3c 33 33 * @brief Address keeping. 34 34 */ 35 #include <usb/ hcd.h>35 #include <usb/addrkeep.h> 36 36 #include <errno.h> 37 37 #include <assert.h> -
uspace/lib/usb/src/dump.c
r600733e r2e85b3c 147 147 PRINTLINE("bDeviceProtocol = 0x%02x", d->device_protocol); 148 148 PRINTLINE("bMaxPacketSize0 = %d", d->max_packet_size); 149 PRINTLINE("idVendor = %d", d->vendor_id);150 PRINTLINE("idProduct = %d", d->product_id);149 PRINTLINE("idVendor = 0x%04x", d->vendor_id); 150 PRINTLINE("idProduct = 0x%04x", d->product_id); 151 151 PRINTLINE("bcdDevice = %d", d->device_version); 152 152 PRINTLINE("iManufacturer = %d", d->str_manufacturer); -
uspace/lib/usb/src/pipes.c
r600733e r2e85b3c 31 31 */ 32 32 /** @file 33 * Communication between device drivers and host controller driver. 34 * 35 * Note on synchronousness of the operations: there is ABSOLUTELY NO 36 * guarantee that a call to particular function will not trigger a fibril 37 * switch. 38 * The initialization functions may actually involve contacting some other 39 * task, starting/ending a session might involve asynchronous IPC and since 40 * the transfer functions uses IPC, asynchronous nature of them is obvious. 41 * The pseudo synchronous versions for the transfers internally call the 42 * asynchronous ones and so fibril switch is possible in them as well. 33 * USB endpoint pipes miscellaneous functions. 43 34 */ 44 35 #include <usb/usb.h> … … 47 38 #include <assert.h> 48 39 #include <usb/usbdrv.h> 49 50 #define _PREPARE_TARGET(varname, pipe) \51 usb_target_t varname = { \52 .address = (pipe)->wire->address, \53 .endpoint = (pipe)->endpoint_no \54 }55 40 56 41 /** Initialize connection to USB device. … … 117 102 } 118 103 119 /** Initialize USB endpoint pipe.104 /** Initialize connection to USB device on default address. 120 105 * 121 * @param pipe Endpoint pipe to be initialized. 122 * @param connection Connection to the USB device backing this pipe (the wire). 123 * @param endpoint_no Endpoint number (in USB 1.1 in range 0 to 15). 124 * @param transfer_type Transfer type (e.g. interrupt or bulk). 125 * @param max_packet_size Maximum packet size in bytes. 126 * @param direction Endpoint direction (in/out). 106 * @param dev_connection Device connection structure to be initialized. 107 * @param hc_connection Initialized connection to host controller. 127 108 * @return Error code. 128 109 */ 129 int usb_endpoint_pipe_initialize(usb_endpoint_pipe_t *pipe, 130 usb_device_connection_t *connection, usb_endpoint_t endpoint_no, 131 usb_transfer_type_t transfer_type, size_t max_packet_size, 132 usb_direction_t direction) 110 int usb_device_connection_initialize_on_default_address( 111 usb_device_connection_t *dev_connection, 112 usb_hc_connection_t *hc_connection) 133 113 { 134 assert(pipe); 135 assert(connection); 114 assert(dev_connection); 136 115 137 pipe->wire = connection; 138 pipe->hc_phone = -1; 139 pipe->endpoint_no = endpoint_no; 140 pipe->transfer_type = transfer_type; 141 pipe->max_packet_size = max_packet_size; 142 pipe->direction = direction; 116 if (hc_connection == NULL) { 117 return EBADMEM; 118 } 143 119 144 return EOK; 145 } 146 147 148 /** Initialize USB endpoint pipe as the default zero control pipe. 149 * 150 * @param pipe Endpoint pipe to be initialized. 151 * @param connection Connection to the USB device backing this pipe (the wire). 152 * @return Error code. 153 */ 154 int usb_endpoint_pipe_initialize_default_control(usb_endpoint_pipe_t *pipe, 155 usb_device_connection_t *connection) 156 { 157 assert(pipe); 158 assert(connection); 159 160 int rc = usb_endpoint_pipe_initialize(pipe, connection, 161 0, USB_TRANSFER_CONTROL, 8, USB_DIRECTION_BOTH); 162 163 return rc; 120 return usb_device_connection_initialize(dev_connection, 121 hc_connection->hc_handle, (usb_address_t) 0); 164 122 } 165 123 … … 224 182 } 225 183 226 227 /** Request a read (in) transfer on an endpoint pipe.228 *229 * @param[in] pipe Pipe used for the transfer.230 * @param[out] buffer Buffer where to store the data.231 * @param[in] size Size of the buffer (in bytes).232 * @param[out] size_transfered Number of bytes that were actually transfered.233 * @return Error code.234 */235 int usb_endpoint_pipe_read(usb_endpoint_pipe_t *pipe,236 void *buffer, size_t size, size_t *size_transfered)237 {238 assert(pipe);239 240 int rc;241 usb_handle_t handle;242 243 rc = usb_endpoint_pipe_async_read(pipe, buffer, size, size_transfered,244 &handle);245 if (rc != EOK) {246 return rc;247 }248 249 rc = usb_endpoint_pipe_wait_for(pipe, handle);250 return rc;251 }252 253 /** Request a write (out) transfer on an endpoint pipe.254 *255 * @param[in] pipe Pipe used for the transfer.256 * @param[in] buffer Buffer with data to transfer.257 * @param[in] size Size of the buffer (in bytes).258 * @return Error code.259 */260 int usb_endpoint_pipe_write(usb_endpoint_pipe_t *pipe,261 void *buffer, size_t size)262 {263 assert(pipe);264 265 int rc;266 usb_handle_t handle;267 268 rc = usb_endpoint_pipe_async_write(pipe, buffer, size, &handle);269 if (rc != EOK) {270 return rc;271 }272 273 rc = usb_endpoint_pipe_wait_for(pipe, handle);274 return rc;275 }276 277 278 /** Request a control read transfer on an endpoint pipe.279 *280 * This function encapsulates all three stages of a control transfer.281 *282 * @param[in] pipe Pipe used for the transfer.283 * @param[in] setup_buffer Buffer with the setup packet.284 * @param[in] setup_buffer_size Size of the setup packet (in bytes).285 * @param[out] data_buffer Buffer for incoming data.286 * @param[in] data_buffer_size Size of the buffer for incoming data (in bytes).287 * @param[out] data_transfered_size Number of bytes that were actually288 * transfered during the DATA stage.289 * @return Error code.290 */291 int usb_endpoint_pipe_control_read(usb_endpoint_pipe_t *pipe,292 void *setup_buffer, size_t setup_buffer_size,293 void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size)294 {295 assert(pipe);296 297 int rc;298 usb_handle_t handle;299 300 rc = usb_endpoint_pipe_async_control_read(pipe,301 setup_buffer, setup_buffer_size,302 data_buffer, data_buffer_size, data_transfered_size,303 &handle);304 if (rc != EOK) {305 return rc;306 }307 308 rc = usb_endpoint_pipe_wait_for(pipe, handle);309 return rc;310 }311 312 313 /** Request a control write transfer on an endpoint pipe.314 *315 * This function encapsulates all three stages of a control transfer.316 *317 * @param[in] pipe Pipe used for the transfer.318 * @param[in] setup_buffer Buffer with the setup packet.319 * @param[in] setup_buffer_size Size of the setup packet (in bytes).320 * @param[in] data_buffer Buffer with data to be sent.321 * @param[in] data_buffer_size Size of the buffer with outgoing data (in bytes).322 * @return Error code.323 */324 int usb_endpoint_pipe_control_write(usb_endpoint_pipe_t *pipe,325 void *setup_buffer, size_t setup_buffer_size,326 void *data_buffer, size_t data_buffer_size)327 {328 assert(pipe);329 330 int rc;331 usb_handle_t handle;332 333 rc = usb_endpoint_pipe_async_control_write(pipe,334 setup_buffer, setup_buffer_size,335 data_buffer, data_buffer_size,336 &handle);337 if (rc != EOK) {338 return rc;339 }340 341 rc = usb_endpoint_pipe_wait_for(pipe, handle);342 return rc;343 }344 345 346 /** Request a read (in) transfer on an endpoint pipe (asynchronous version).347 *348 * @param[in] pipe Pipe used for the transfer.349 * @param[out] buffer Buffer where to store the data.350 * @param[in] size Size of the buffer (in bytes).351 * @param[out] size_transfered Number of bytes that were actually transfered.352 * @param[out] handle Handle of the transfer.353 * @return Error code.354 */355 int usb_endpoint_pipe_async_read(usb_endpoint_pipe_t *pipe,356 void *buffer, size_t size, size_t *size_transfered,357 usb_handle_t *handle)358 {359 assert(pipe);360 361 if (pipe->hc_phone < 0) {362 return EBADF;363 }364 365 if (pipe->direction != USB_DIRECTION_IN) {366 return EBADF;367 }368 369 int rc;370 _PREPARE_TARGET(target, pipe);371 372 switch (pipe->transfer_type) {373 case USB_TRANSFER_INTERRUPT:374 rc = usb_drv_async_interrupt_in(pipe->hc_phone, target,375 buffer, size, size_transfered, handle);376 break;377 case USB_TRANSFER_CONTROL:378 rc = EBADF;379 break;380 default:381 rc = ENOTSUP;382 break;383 }384 385 return rc;386 }387 388 389 /** Request a write (out) transfer on an endpoint pipe (asynchronous version).390 *391 * @param[in] pipe Pipe used for the transfer.392 * @param[in] buffer Buffer with data to transfer.393 * @param[in] size Size of the buffer (in bytes).394 * @param[out] handle Handle of the transfer.395 * @return Error code.396 */397 int usb_endpoint_pipe_async_write(usb_endpoint_pipe_t *pipe,398 void *buffer, size_t size,399 usb_handle_t *handle)400 {401 assert(pipe);402 403 if (pipe->hc_phone < 0) {404 return EBADF;405 }406 407 if (pipe->direction != USB_DIRECTION_OUT) {408 return EBADF;409 }410 411 int rc;412 _PREPARE_TARGET(target, pipe);413 414 switch (pipe->transfer_type) {415 case USB_TRANSFER_INTERRUPT:416 rc = usb_drv_async_interrupt_out(pipe->hc_phone, target,417 buffer, size, handle);418 break;419 case USB_TRANSFER_CONTROL:420 rc = EBADF;421 break;422 default:423 rc = ENOTSUP;424 break;425 }426 427 return rc;428 }429 430 431 /** Request a control read transfer on an endpoint pipe (asynchronous version).432 *433 * This function encapsulates all three stages of a control transfer.434 *435 * @param[in] pipe Pipe used for the transfer.436 * @param[in] setup_buffer Buffer with the setup packet.437 * @param[in] setup_buffer_size Size of the setup packet (in bytes).438 * @param[out] data_buffer Buffer for incoming data.439 * @param[in] data_buffer_size Size of the buffer for incoming data (in bytes).440 * @param[out] data_transfered_size Number of bytes that were actually441 * transfered during the DATA stage.442 * @param[out] handle Handle of the transfer.443 * @return Error code.444 */445 int usb_endpoint_pipe_async_control_read(usb_endpoint_pipe_t *pipe,446 void *setup_buffer, size_t setup_buffer_size,447 void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size,448 usb_handle_t *handle)449 {450 assert(pipe);451 452 if (pipe->hc_phone < 0) {453 return EBADF;454 }455 456 if ((pipe->direction != USB_DIRECTION_BOTH)457 || (pipe->transfer_type != USB_TRANSFER_CONTROL)) {458 return EBADF;459 }460 461 int rc;462 _PREPARE_TARGET(target, pipe);463 464 rc = usb_drv_async_control_read(pipe->hc_phone, target,465 setup_buffer, setup_buffer_size,466 data_buffer, data_buffer_size, data_transfered_size,467 handle);468 469 return rc;470 }471 472 473 /** Request a control write transfer on an endpoint pipe (asynchronous version).474 *475 * This function encapsulates all three stages of a control transfer.476 *477 * @param[in] pipe Pipe used for the transfer.478 * @param[in] setup_buffer Buffer with the setup packet.479 * @param[in] setup_buffer_size Size of the setup packet (in bytes).480 * @param[in] data_buffer Buffer with data to be sent.481 * @param[in] data_buffer_size Size of the buffer with outgoing data (in bytes).482 * @param[out] handle Handle of the transfer.483 * @return Error code.484 */485 int usb_endpoint_pipe_async_control_write(usb_endpoint_pipe_t *pipe,486 void *setup_buffer, size_t setup_buffer_size,487 void *data_buffer, size_t data_buffer_size,488 usb_handle_t *handle)489 {490 assert(pipe);491 492 if (pipe->hc_phone < 0) {493 return EBADF;494 }495 496 if ((pipe->direction != USB_DIRECTION_BOTH)497 || (pipe->transfer_type != USB_TRANSFER_CONTROL)) {498 return EBADF;499 }500 501 int rc;502 _PREPARE_TARGET(target, pipe);503 504 rc = usb_drv_async_control_write(pipe->hc_phone, target,505 setup_buffer, setup_buffer_size,506 data_buffer, data_buffer_size,507 handle);508 509 return rc;510 }511 512 /** Wait for transfer completion.513 *514 * The function blocks the caller fibril until the transfer associated515 * with given @p handle is completed.516 *517 * @param[in] pipe Pipe the transfer executed on.518 * @param[in] handle Transfer handle.519 * @return Error code.520 */521 int usb_endpoint_pipe_wait_for(usb_endpoint_pipe_t *pipe, usb_handle_t handle)522 {523 return usb_drv_async_wait_for(handle);524 }525 526 527 184 /** 528 185 * @} -
uspace/lib/usb/src/pipesinit.c
r600733e r2e85b3c 320 320 } 321 321 322 /** Initialize USB endpoint pipe. 323 * 324 * @param pipe Endpoint pipe to be initialized. 325 * @param connection Connection to the USB device backing this pipe (the wire). 326 * @param endpoint_no Endpoint number (in USB 1.1 in range 0 to 15). 327 * @param transfer_type Transfer type (e.g. interrupt or bulk). 328 * @param max_packet_size Maximum packet size in bytes. 329 * @param direction Endpoint direction (in/out). 330 * @return Error code. 331 */ 332 int usb_endpoint_pipe_initialize(usb_endpoint_pipe_t *pipe, 333 usb_device_connection_t *connection, usb_endpoint_t endpoint_no, 334 usb_transfer_type_t transfer_type, size_t max_packet_size, 335 usb_direction_t direction) 336 { 337 assert(pipe); 338 assert(connection); 339 340 pipe->wire = connection; 341 pipe->hc_phone = -1; 342 pipe->endpoint_no = endpoint_no; 343 pipe->transfer_type = transfer_type; 344 pipe->max_packet_size = max_packet_size; 345 pipe->direction = direction; 346 347 return EOK; 348 } 349 350 351 /** Initialize USB endpoint pipe as the default zero control pipe. 352 * 353 * @param pipe Endpoint pipe to be initialized. 354 * @param connection Connection to the USB device backing this pipe (the wire). 355 * @return Error code. 356 */ 357 int usb_endpoint_pipe_initialize_default_control(usb_endpoint_pipe_t *pipe, 358 usb_device_connection_t *connection) 359 { 360 assert(pipe); 361 assert(connection); 362 363 int rc = usb_endpoint_pipe_initialize(pipe, connection, 364 0, USB_TRANSFER_CONTROL, 8, USB_DIRECTION_BOTH); 365 366 return rc; 367 } 368 322 369 /** 323 370 * @} -
uspace/lib/usb/src/usb.c
r600733e r2e85b3c 54 54 } 55 55 56 /** String representation of USB transaction outcome. */57 const char * usb_str_transaction_outcome(usb_transaction_outcome_t o)58 {59 switch (o) {60 case USB_OUTCOME_OK:61 return "ok";62 case USB_OUTCOME_CRCERROR:63 return "CRC error";64 case USB_OUTCOME_BABBLE:65 return "babble";66 default:67 return "unknown";68 }69 }70 71 72 56 /** 73 57 * @} -
uspace/lib/usb/src/usbdrv.c
r600733e r2e85b3c 464 464 assert(setup_packet != NULL); 465 465 assert(setup_packet_size > 0); 466 assert( buffer != NULL);467 assert(buffer_size > 0);466 assert(((buffer != NULL) && (buffer_size > 0)) 467 || ((buffer == NULL) && (buffer_size == 0))); 468 468 assert(handle != NULL); 469 469 … … 494 494 } 495 495 496 rc = async_data_write_start(phone, buffer, buffer_size); 497 if (rc != EOK) { 498 async_wait_for(transfer->request, NULL); 499 return rc; 496 if (buffer_size > 0) { 497 rc = async_data_write_start(phone, buffer, buffer_size); 498 if (rc != EOK) { 499 async_wait_for(transfer->request, NULL); 500 return rc; 501 } 500 502 } 501 503 -
uspace/lib/usbvirt/Makefile
r600733e r2e85b3c 30 30 LIBRARY = libusbvirt 31 31 32 LIBS = $(LIBUSB_PREFIX)/libusb.a33 32 EXTRA_CFLAGS = -I$(LIBUSB_PREFIX)/include -Iinclude 34 33
Note:
See TracChangeset
for help on using the changeset viewer.