Changeset 1387692 in mainline
- Timestamp:
- 2011-03-21T15:01:52Z (14 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- c92c13f
- Parents:
- e34e77a
- Location:
- uspace
- Files:
-
- 16 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/drv/ohci/batch.c
re34e77a r1387692 41 41 #include "utils/malloc32.h" 42 42 43 static void batch_call_in_and_dispose( batch_t *instance);44 static void batch_call_out_and_dispose( batch_t *instance);43 static void batch_call_in_and_dispose(usb_transfer_batch_t *instance); 44 static void batch_call_out_and_dispose(usb_transfer_batch_t *instance); 45 45 46 46 #define DEFAULT_ERROR_COUNT 3 47 batch_t * batch_get(47 usb_transfer_batch_t * batch_get( 48 48 ddf_fun_t *fun, 49 49 usb_target_t target, … … 70 70 } else (void)0 71 71 72 batch_t *instance = malloc(sizeof(batch_t));72 usb_transfer_batch_t *instance = malloc(sizeof(usb_transfer_batch_t)); 73 73 CHECK_NULL_DISPOSE_RETURN(instance, 74 74 "Failed to allocate batch instance.\n"); 75 batch_init(instance, target, transfer_type, speed, max_packet_size,75 usb_transfer_batch_init(instance, target, transfer_type, speed, max_packet_size, 76 76 buffer, NULL, buffer_size, NULL, setup_size, func_in, 77 77 func_out, arg, fun, NULL); … … 94 94 } 95 95 /*----------------------------------------------------------------------------*/ 96 void batch_dispose( batch_t *instance)96 void batch_dispose(usb_transfer_batch_t *instance) 97 97 { 98 98 assert(instance); … … 102 102 } 103 103 /*----------------------------------------------------------------------------*/ 104 void batch_control_write( batch_t *instance)104 void batch_control_write(usb_transfer_batch_t *instance) 105 105 { 106 106 assert(instance); … … 113 113 } 114 114 /*----------------------------------------------------------------------------*/ 115 void batch_control_read( batch_t *instance)115 void batch_control_read(usb_transfer_batch_t *instance) 116 116 { 117 117 assert(instance); … … 121 121 } 122 122 /*----------------------------------------------------------------------------*/ 123 void batch_interrupt_in( batch_t *instance)123 void batch_interrupt_in(usb_transfer_batch_t *instance) 124 124 { 125 125 assert(instance); … … 130 130 } 131 131 /*----------------------------------------------------------------------------*/ 132 void batch_interrupt_out( batch_t *instance)132 void batch_interrupt_out(usb_transfer_batch_t *instance) 133 133 { 134 134 assert(instance); … … 142 142 } 143 143 /*----------------------------------------------------------------------------*/ 144 void batch_bulk_in( batch_t *instance)144 void batch_bulk_in(usb_transfer_batch_t *instance) 145 145 { 146 146 assert(instance); … … 151 151 } 152 152 /*----------------------------------------------------------------------------*/ 153 void batch_bulk_out( batch_t *instance)153 void batch_bulk_out(usb_transfer_batch_t *instance) 154 154 { 155 155 assert(instance); … … 164 164 * @param[in] instance Batch structure to use. 165 165 */ 166 void batch_call_in_and_dispose( batch_t *instance)166 void batch_call_in_and_dispose(usb_transfer_batch_t *instance) 167 167 { 168 168 assert(instance); 169 batch_call_in(instance);169 usb_transfer_batch_call_in(instance); 170 170 batch_dispose(instance); 171 171 } … … 175 175 * @param[in] instance Batch structure to use. 176 176 */ 177 void batch_call_out_and_dispose( batch_t *instance)177 void batch_call_out_and_dispose(usb_transfer_batch_t *instance) 178 178 { 179 179 assert(instance); 180 batch_call_out(instance);180 usb_transfer_batch_call_out(instance); 181 181 batch_dispose(instance); 182 182 } -
uspace/drv/ohci/batch.h
re34e77a r1387692 41 41 #include <usb/host/batch.h> 42 42 43 batch_t * batch_get(43 usb_transfer_batch_t * batch_get( 44 44 ddf_fun_t *fun, 45 45 usb_target_t target, … … 57 57 ); 58 58 59 void batch_dispose( batch_t *instance);59 void batch_dispose(usb_transfer_batch_t *instance); 60 60 61 void batch_control_write( batch_t *instance);61 void batch_control_write(usb_transfer_batch_t *instance); 62 62 63 void batch_control_read( batch_t *instance);63 void batch_control_read(usb_transfer_batch_t *instance); 64 64 65 void batch_interrupt_in( batch_t *instance);65 void batch_interrupt_in(usb_transfer_batch_t *instance); 66 66 67 void batch_interrupt_out( batch_t *instance);67 void batch_interrupt_out(usb_transfer_batch_t *instance); 68 68 69 void batch_bulk_in( batch_t *instance);69 void batch_bulk_in(usb_transfer_batch_t *instance); 70 70 71 void batch_bulk_out( batch_t *instance);71 void batch_bulk_out(usb_transfer_batch_t *instance); 72 72 #endif 73 73 /** -
uspace/drv/ohci/hc.c
re34e77a r1387692 106 106 } 107 107 /*----------------------------------------------------------------------------*/ 108 int hc_schedule(hc_t *instance, batch_t *batch)108 int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch) 109 109 { 110 110 assert(instance); -
uspace/drv/ohci/hc.h
re34e77a r1387692 61 61 int hc_register_hub(hc_t *instance); 62 62 63 int hc_schedule(hc_t *instance, batch_t *batch);63 int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch); 64 64 65 65 void hc_interrupt(hc_t *instance, uint16_t status); -
uspace/drv/ohci/iface.c
re34e77a r1387692 205 205 target.address, target.endpoint, size, max_packet_size); 206 206 207 batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,207 usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT, 208 208 max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg, 209 209 &hc->manager); … … 247 247 target.address, target.endpoint, size, max_packet_size); 248 248 249 batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,249 usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT, 250 250 max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg, 251 251 &hc->manager); … … 290 290 target.address, target.endpoint, size, max_packet_size); 291 291 292 batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,292 usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK, 293 293 max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg, 294 294 &hc->manager); … … 333 333 target.address, target.endpoint, size, max_packet_size); 334 334 335 batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,335 usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK, 336 336 max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg, 337 337 &hc->manager); … … 383 383 return EINVAL; 384 384 385 batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,385 usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL, 386 386 max_packet_size, speed, data, size, setup_data, setup_size, 387 387 NULL, callback, arg, &hc->manager); … … 431 431 usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n", 432 432 speed, target.address, target.endpoint, size, max_packet_size); 433 batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,433 usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL, 434 434 max_packet_size, speed, data, size, setup_data, setup_size, callback, 435 435 NULL, arg, &hc->manager); -
uspace/drv/ohci/root_hub.c
re34e77a r1387692 56 56 } 57 57 /*----------------------------------------------------------------------------*/ 58 int rh_request(rh_t *instance, batch_t *request)58 int rh_request(rh_t *instance, usb_transfer_batch_t *request) 59 59 { 60 60 assert(instance); … … 66 66 } 67 67 usb_log_error("Root hub request processing not implemented.\n"); 68 batch_finish(request, ENOTSUP);68 usb_transfer_batch_finish(request, ENOTSUP); 69 69 return EOK; 70 70 } -
uspace/drv/ohci/root_hub.h
re34e77a r1387692 49 49 int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs); 50 50 51 int rh_request(rh_t *instance, batch_t *request);51 int rh_request(rh_t *instance, usb_transfer_batch_t *request); 52 52 53 53 void rh_interrupt(rh_t *instance); -
uspace/drv/uhci-hcd/batch.c
re34e77a r1387692 53 53 } uhci_batch_t; 54 54 55 static void batch_control( batch_t *instance,55 static void batch_control(usb_transfer_batch_t *instance, 56 56 usb_packet_id data_stage, usb_packet_id status_stage); 57 static void batch_data( batch_t *instance, usb_packet_id pid);58 static void batch_call_in_and_dispose( batch_t *instance);59 static void batch_call_out_and_dispose( batch_t *instance);57 static void batch_data(usb_transfer_batch_t *instance, usb_packet_id pid); 58 static void batch_call_in_and_dispose(usb_transfer_batch_t *instance); 59 static void batch_call_out_and_dispose(usb_transfer_batch_t *instance); 60 60 61 61 … … 82 82 * transaction and callback. 83 83 */ 84 batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,84 usb_transfer_batch_t * batch_get(ddf_fun_t *fun, usb_target_t target, 85 85 usb_transfer_type_t transfer_type, size_t max_packet_size, 86 86 usb_speed_t speed, char *buffer, size_t buffer_size, … … 103 103 } else (void)0 104 104 105 batch_t *instance = malloc(sizeof(batch_t));105 usb_transfer_batch_t *instance = malloc(sizeof(usb_transfer_batch_t)); 106 106 CHECK_NULL_DISPOSE_RETURN(instance, 107 107 "Failed to allocate batch instance.\n"); 108 batch_init(instance, target, transfer_type, speed, max_packet_size,108 usb_transfer_batch_init(instance, target, transfer_type, speed, max_packet_size, 109 109 buffer, NULL, buffer_size, NULL, setup_size, func_in, 110 110 func_out, arg, fun, NULL); … … 161 161 * is reached. 162 162 */ 163 bool batch_is_complete( batch_t *instance)163 bool batch_is_complete(usb_transfer_batch_t *instance) 164 164 { 165 165 assert(instance); … … 205 205 * Uses genercir control function with pids OUT and IN. 206 206 */ 207 void batch_control_write( batch_t *instance)207 void batch_control_write(usb_transfer_batch_t *instance) 208 208 { 209 209 assert(instance); … … 222 222 * Uses generic control with pids IN and OUT. 223 223 */ 224 void batch_control_read( batch_t *instance)224 void batch_control_read(usb_transfer_batch_t *instance) 225 225 { 226 226 assert(instance); … … 236 236 * Data transaction with PID_IN. 237 237 */ 238 void batch_interrupt_in( batch_t *instance)238 void batch_interrupt_in(usb_transfer_batch_t *instance) 239 239 { 240 240 assert(instance); … … 251 251 * Data transaction with PID_OUT. 252 252 */ 253 void batch_interrupt_out( batch_t *instance)253 void batch_interrupt_out(usb_transfer_batch_t *instance) 254 254 { 255 255 assert(instance); … … 269 269 * Data transaction with PID_IN. 270 270 */ 271 void batch_bulk_in( batch_t *instance)271 void batch_bulk_in(usb_transfer_batch_t *instance) 272 272 { 273 273 assert(instance); … … 284 284 * Data transaction with PID_OUT. 285 285 */ 286 void batch_bulk_out( batch_t *instance)286 void batch_bulk_out(usb_transfer_batch_t *instance) 287 287 { 288 288 assert(instance); … … 304 304 * The last packet is marked with IOC flag. 305 305 */ 306 void batch_data( batch_t *instance, usb_packet_id pid)306 void batch_data(usb_transfer_batch_t *instance, usb_packet_id pid) 307 307 { 308 308 assert(instance); … … 358 358 * The last packet is marked with IOC. 359 359 */ 360 void batch_control( batch_t *instance,360 void batch_control(usb_transfer_batch_t *instance, 361 361 usb_packet_id data_stage, usb_packet_id status_stage) 362 362 { … … 411 411 } 412 412 /*----------------------------------------------------------------------------*/ 413 qh_t * batch_qh( batch_t *instance)413 qh_t * batch_qh(usb_transfer_batch_t *instance) 414 414 { 415 415 assert(instance); … … 423 423 * @param[in] instance Batch structure to use. 424 424 */ 425 void batch_call_in_and_dispose( batch_t *instance)426 { 427 assert(instance); 428 batch_call_in(instance);425 void batch_call_in_and_dispose(usb_transfer_batch_t *instance) 426 { 427 assert(instance); 428 usb_transfer_batch_call_in(instance); 429 429 batch_dispose(instance); 430 430 } … … 434 434 * @param[in] instance Batch structure to use. 435 435 */ 436 void batch_call_out_and_dispose( batch_t *instance)437 { 438 assert(instance); 439 batch_call_out(instance);436 void batch_call_out_and_dispose(usb_transfer_batch_t *instance) 437 { 438 assert(instance); 439 usb_transfer_batch_call_out(instance); 440 440 batch_dispose(instance); 441 441 } … … 445 445 * @param[in] instance Batch structure to use. 446 446 */ 447 void batch_dispose( batch_t *instance)447 void batch_dispose(usb_transfer_batch_t *instance) 448 448 { 449 449 assert(instance); -
uspace/drv/uhci-hcd/batch.h
re34e77a r1387692 44 44 #include "uhci_struct/queue_head.h" 45 45 46 batch_t * batch_get(46 usb_transfer_batch_t * batch_get( 47 47 ddf_fun_t *fun, 48 48 usb_target_t target, … … 60 60 ); 61 61 62 void batch_dispose( batch_t *instance);62 void batch_dispose(usb_transfer_batch_t *instance); 63 63 64 bool batch_is_complete( batch_t *instance);64 bool batch_is_complete(usb_transfer_batch_t *instance); 65 65 66 void batch_control_write( batch_t *instance);66 void batch_control_write(usb_transfer_batch_t *instance); 67 67 68 void batch_control_read( batch_t *instance);68 void batch_control_read(usb_transfer_batch_t *instance); 69 69 70 void batch_interrupt_in( batch_t *instance);70 void batch_interrupt_in(usb_transfer_batch_t *instance); 71 71 72 void batch_interrupt_out( batch_t *instance);72 void batch_interrupt_out(usb_transfer_batch_t *instance); 73 73 74 void batch_bulk_in( batch_t *instance);74 void batch_bulk_in(usb_transfer_batch_t *instance); 75 75 76 void batch_bulk_out( batch_t *instance);76 void batch_bulk_out(usb_transfer_batch_t *instance); 77 77 78 qh_t * batch_qh( batch_t *instance);78 qh_t * batch_qh(usb_transfer_batch_t *instance); 79 79 #endif 80 80 /** -
uspace/drv/uhci-hcd/iface.c
re34e77a r1387692 154 154 target.address, target.endpoint, size, max_packet_size); 155 155 156 batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,156 usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT, 157 157 max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg, 158 158 &hc->device_manager); … … 190 190 target.address, target.endpoint, size, max_packet_size); 191 191 192 batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,192 usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT, 193 193 max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg, 194 194 &hc->device_manager); … … 227 227 target.address, target.endpoint, size, max_packet_size); 228 228 229 batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,229 usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK, 230 230 max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg, 231 231 &hc->device_manager); … … 263 263 target.address, target.endpoint, size, max_packet_size); 264 264 265 batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,265 usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK, 266 266 max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg, 267 267 &hc->device_manager); … … 305 305 return EINVAL; 306 306 307 batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,307 usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL, 308 308 max_packet_size, speed, data, size, setup_data, setup_size, 309 309 NULL, callback, arg, &hc->device_manager); … … 345 345 usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n", 346 346 speed, target.address, target.endpoint, size, max_packet_size); 347 batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,347 usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL, 348 348 max_packet_size, speed, data, size, setup_data, setup_size, callback, 349 349 NULL, arg, &hc->device_manager); -
uspace/drv/uhci-hcd/transfer_list.c
re34e77a r1387692 38 38 39 39 static void transfer_list_remove_batch( 40 transfer_list_t *instance, batch_t *batch);40 transfer_list_t *instance, usb_transfer_batch_t *batch); 41 41 /*----------------------------------------------------------------------------*/ 42 42 /** Initialize transfer list structures. … … 92 92 * The batch is added to the end of the list and queue. 93 93 */ 94 void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch)94 void transfer_list_add_batch(transfer_list_t *instance, usb_transfer_batch_t *batch) 95 95 { 96 96 assert(instance); … … 115 115 } else { 116 116 /* There is something scheduled */ 117 batch_t *last = list_get_instance(118 instance->batch_list.prev, batch_t, link);117 usb_transfer_batch_t *last = list_get_instance( 118 instance->batch_list.prev, usb_transfer_batch_t, link); 119 119 qh_set_next_qh(batch_qh(last), pa); 120 120 } … … 122 122 list_append(&batch->link, &instance->batch_list); 123 123 124 batch_t *first = list_get_instance(125 instance->batch_list.next, batch_t, link);124 usb_transfer_batch_t *first = list_get_instance( 125 instance->batch_list.next, usb_transfer_batch_t, link); 126 126 usb_log_debug("Batch(%p) added to queue %s, first is %p.\n", 127 127 batch, instance->name, first); … … 148 148 while (current != &instance->batch_list) { 149 149 link_t *next = current->next; 150 batch_t *batch = list_get_instance(current,batch_t, link);150 usb_transfer_batch_t *batch = list_get_instance(current, usb_transfer_batch_t, link); 151 151 152 152 if (batch_is_complete(batch)) { … … 162 162 link_t *item = done.next; 163 163 list_remove(item); 164 batch_t *batch = list_get_instance(item,batch_t, link);164 usb_transfer_batch_t *batch = list_get_instance(item, usb_transfer_batch_t, link); 165 165 batch->next_step(batch); 166 166 } … … 176 176 while (list_empty(&instance->batch_list)) { 177 177 link_t *current = instance->batch_list.next; 178 batch_t *batch = list_get_instance(current,batch_t, link);178 usb_transfer_batch_t *batch = list_get_instance(current, usb_transfer_batch_t, link); 179 179 transfer_list_remove_batch(instance, batch); 180 batch_finish(batch, EIO);180 usb_transfer_batch_finish(batch, EIO); 181 181 } 182 182 fibril_mutex_unlock(&instance->guard); … … 191 191 * Does not lock the transfer list, caller is responsible for that. 192 192 */ 193 void transfer_list_remove_batch(transfer_list_t *instance, batch_t *batch)193 void transfer_list_remove_batch(transfer_list_t *instance, usb_transfer_batch_t *batch) 194 194 { 195 195 assert(instance); … … 207 207 pos = "FIRST"; 208 208 } else { 209 batch_t *prev =210 list_get_instance(batch->link.prev, batch_t, link);209 usb_transfer_batch_t *prev = 210 list_get_instance(batch->link.prev, usb_transfer_batch_t, link); 211 211 qh_set_next_qh(batch_qh(prev), batch_qh(batch)->next); 212 212 pos = "NOT FIRST"; -
uspace/drv/uhci-hcd/transfer_list.h
re34e77a r1387692 66 66 void transfer_list_set_next(transfer_list_t *instance, transfer_list_t *next); 67 67 68 void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch);68 void transfer_list_add_batch(transfer_list_t *instance, usb_transfer_batch_t *batch); 69 69 70 70 void transfer_list_remove_finished(transfer_list_t *instance); -
uspace/drv/uhci-hcd/uhci_hc.c
re34e77a r1387692 316 316 * Checks for bandwidth availability and appends the batch to the proper queue. 317 317 */ 318 int uhci_hc_schedule(uhci_hc_t *instance, batch_t *batch)318 int uhci_hc_schedule(uhci_hc_t *instance, usb_transfer_batch_t *batch) 319 319 { 320 320 assert(instance); -
uspace/drv/uhci-hcd/uhci_hc.h
re34e77a r1387692 109 109 void *regs, size_t reg_size, bool interupts); 110 110 111 int uhci_hc_schedule(uhci_hc_t *instance, batch_t *batch);111 int uhci_hc_schedule(uhci_hc_t *instance, usb_transfer_batch_t *batch); 112 112 113 113 void uhci_hc_interrupt(uhci_hc_t *instance, uint16_t status); -
uspace/lib/usb/include/usb/host/batch.h
re34e77a r1387692 40 40 #include <usb/usb.h> 41 41 42 typedef struct batch43 {42 typedef struct usb_transfer_batch usb_transfer_batch_t; 43 struct usb_transfer_batch { 44 44 link_t link; 45 45 usb_target_t target; … … 56 56 size_t max_packet_size; 57 57 size_t transfered_size; 58 void (*next_step)( struct batch*);58 void (*next_step)(usb_transfer_batch_t *); 59 59 int error; 60 60 ddf_fun_t *fun; 61 61 void *arg; 62 62 void *private_data; 63 } batch_t;63 }; 64 64 65 void batch_init(66 batch_t *instance,65 void usb_transfer_batch_init( 66 usb_transfer_batch_t *instance, 67 67 usb_target_t target, 68 68 usb_transfer_type_t transfer_type, … … 81 81 ); 82 82 83 static inline batch_t *batch_from_link(link_t *link_ptr)83 static inline usb_transfer_batch_t *usb_transfer_batch_from_link(link_t *link_ptr) 84 84 { 85 85 assert(link_ptr); 86 return list_get_instance(link_ptr, batch_t, link);86 return list_get_instance(link_ptr, usb_transfer_batch_t, link); 87 87 } 88 88 89 void batch_call_in(batch_t *instance); 90 void batch_call_out(batch_t *instance); 91 void batch_finish(batch_t *instance, int error); 89 void usb_transfer_batch_call_in(usb_transfer_batch_t *instance); 90 void usb_transfer_batch_call_out(usb_transfer_batch_t *instance); 91 void usb_transfer_batch_finish(usb_transfer_batch_t *instance, int error); 92 92 93 #endif 93 94 /** -
uspace/lib/usb/src/host/batch.c
re34e77a r1387692 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); … … 120 120 * @param[in] instance Batch structure to use. 121 121 */ 122 void batch_call_out(batch_t *instance)122 void usb_transfer_batch_call_out(usb_transfer_batch_t *instance) 123 123 { 124 124 assert(instance);
Note:
See TracChangeset
for help on using the changeset viewer.