Changeset d15809b4 in mainline
- Timestamp:
- 2011-02-14T10:14:31Z (14 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- 962ce100
- Parents:
- 0d36c20 (diff), 45c01a1 (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:
-
- 3 added
- 1 deleted
- 23 edited
- 1 moved
Legend:
- Unmodified
- Added
- Removed
-
uspace/app/usbinfo/info.c
r0d36c20 rd15809b4 39 39 #include <usb/usbdrv.h> 40 40 #include <usb/pipes.h> 41 #include <usb/recognise.h> 41 42 #include <usb/request.h> 42 43 #include "usbinfo.h" … … 47 48 usb_device_connection_t wire; 48 49 usb_endpoint_pipe_t ctrl_pipe; 49 ctrl_pipe.hc_phone = -1;50 51 int hc_phone = devman_device_connect(hc_handle, 0);52 if (hc_phone < 0) {53 fprintf(stderr,54 NAME ": failed to connect to host controller (%zu): %s.\n",55 (size_t) hc_handle, str_error(hc_phone));56 return hc_phone;57 }58 59 /*60 * Dump information about possible match ids.61 */62 match_id_list_t match_id_list;63 init_match_ids(&match_id_list);64 rc = usb_drv_create_device_match_ids(hc_phone, &match_id_list, address);65 if (rc != EOK) {66 fprintf(stderr,67 NAME ": failed to fetch match ids of the device: %s.\n",68 str_error(rc));69 goto leave;70 }71 dump_match_ids(&match_id_list);72 50 73 51 /* … … 95 73 goto leave; 96 74 } 75 76 /* 77 * Dump information about possible match ids. 78 */ 79 match_id_list_t match_id_list; 80 init_match_ids(&match_id_list); 81 rc = usb_device_create_match_ids(&ctrl_pipe, &match_id_list); 82 if (rc != EOK) { 83 fprintf(stderr, 84 NAME ": failed to fetch match ids of the device: %s.\n", 85 str_error(rc)); 86 goto leave; 87 } 88 dump_match_ids(&match_id_list); 97 89 98 90 /* … … 141 133 leave: 142 134 /* Ignoring errors here. */ 143 async_hangup(hc_phone);144 135 usb_endpoint_pipe_end_session(&ctrl_pipe); 145 136 -
uspace/app/usbinfo/main.c
r0d36c20 rd15809b4 81 81 { 82 82 int rc; 83 84 if (str_cmp(path, "uhci") == 0) { 85 path = "/hw/pci0/00:01.2"; 86 } 83 87 84 88 devman_handle_t handle; -
uspace/drv/uhci-hcd/Makefile
r0d36c20 rd15809b4 40 40 uhci_struct/transfer_descriptor.c \ 41 41 pci.c \ 42 tracker.c42 batch.c 43 43 44 44 include $(USPACE_PREFIX)/Makefile.common -
uspace/drv/uhci-hcd/batch.h
r0d36c20 rd15809b4 32 32 * @brief UHCI driver 33 33 */ 34 #ifndef DRV_UHCI_ TRACKER_H35 #define DRV_UHCI_ TRACKER_H34 #ifndef DRV_UHCI_BATCH_H 35 #define DRV_UHCI_BATCH_H 36 36 37 37 #include <adt/list.h> … … 41 41 42 42 #include "uhci_struct/transfer_descriptor.h" 43 #include "uhci_struct/queue_head.h" 43 44 44 45 typedef enum { … … 47 48 } dev_speed_t; 48 49 49 typedef struct tracker50 typedef struct batch 50 51 { 51 52 link_t link; 53 dev_speed_t speed; 52 54 usb_target_t target; 53 55 usb_transfer_type_t transfer_type; … … 57 59 }; 58 60 void *arg; 61 char *transport_buffer; 62 char *setup_buffer; 63 size_t setup_size; 59 64 char *buffer; 60 char *packet;61 65 size_t buffer_size; 62 66 size_t max_packet_size; 63 size_t packet _size;64 size_t buffer_offset;65 dev_speed_t speed;67 size_t packets; 68 size_t transfered_size; 69 int error; 66 70 device_t *dev; 67 transfer_descriptor_t *td;68 void (*next_step)(struct tracker*);69 unsigned toggle:1;70 } tracker_t;71 queue_head_t *qh; 72 transfer_descriptor_t *tds; 73 void (*next_step)(struct batch*); 74 } batch_t; 71 75 72 73 tracker_t * tracker_get(device_t *dev, usb_target_t target, 76 batch_t * batch_get(device_t *dev, usb_target_t target, 74 77 usb_transfer_type_t transfer_type, size_t max_packet_size, 75 78 dev_speed_t speed, char *buffer, size_t size, 79 char *setup_buffer, size_t setup_size, 76 80 usbhc_iface_transfer_in_callback_t func_in, 77 81 usbhc_iface_transfer_out_callback_t func_out, void *arg); 78 82 79 void tracker_control_write( 80 tracker_t *instance, char* setup_buffer, size_t setup_size); 83 bool batch_is_complete(batch_t *instance); 81 84 82 void tracker_control_read( 83 tracker_t *instance, char* setup_buffer, size_t setup_size); 85 void batch_control_write(batch_t *instance); 84 86 85 void tracker_interrupt_in(tracker_t *instance);87 void batch_control_read(batch_t *instance); 86 88 87 void tracker_interrupt_out(tracker_t *instance); 89 void batch_interrupt_in(batch_t *instance); 90 91 void batch_interrupt_out(batch_t *instance); 88 92 89 93 /* DEPRECATED FUNCTIONS NEEDED BY THE OLD API */ 90 void tracker_control_setup_old(tracker_t *instance);94 void batch_control_setup_old(batch_t *instance); 91 95 92 void tracker_control_write_data_old(tracker_t *instance);96 void batch_control_write_data_old(batch_t *instance); 93 97 94 void tracker_control_read_data_old(tracker_t *instance);98 void batch_control_read_data_old(batch_t *instance); 95 99 96 void tracker_control_write_status_old(tracker_t *instance);100 void batch_control_write_status_old(batch_t *instance); 97 101 98 void tracker_control_read_status_old(tracker_t *instance);102 void batch_control_read_status_old(batch_t *instance); 99 103 #endif 100 104 /** -
uspace/drv/uhci-hcd/iface.c
r0d36c20 rd15809b4 109 109 dev_speed_t speed = FULL_SPEED; 110 110 111 tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_INTERRUPT,112 max_packet_size, speed, data, size, NULL, callback, arg);113 if (! tracker)114 return ENOMEM; 115 tracker_interrupt_out(tracker);111 batch_t *batch = batch_get(dev, target, USB_TRANSFER_INTERRUPT, 112 max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg); 113 if (!batch) 114 return ENOMEM; 115 batch_interrupt_out(batch); 116 116 return EOK; 117 117 } … … 124 124 dev_speed_t speed = FULL_SPEED; 125 125 126 tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_INTERRUPT,127 max_packet_size, speed, data, size, callback, NULL, arg);128 if (! tracker)129 return ENOMEM; 130 tracker_interrupt_in(tracker);126 batch_t *batch = batch_get(dev, target, USB_TRANSFER_INTERRUPT, 127 max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg); 128 if (!batch) 129 return ENOMEM; 130 batch_interrupt_in(batch); 131 131 return EOK; 132 132 } … … 139 139 dev_speed_t speed = FULL_SPEED; 140 140 141 tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL, 142 max_packet_size, speed, data, size, NULL, callback, arg); 143 if (!tracker) 144 return ENOMEM; 145 tracker_control_write(tracker, setup_data, setup_size); 141 batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL, 142 max_packet_size, speed, data, size, setup_data, setup_size, 143 NULL, callback, arg); 144 if (!batch) 145 return ENOMEM; 146 batch_control_write(batch); 146 147 return EOK; 147 148 } … … 154 155 dev_speed_t speed = FULL_SPEED; 155 156 156 tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL, 157 max_packet_size, speed, data, size, callback, NULL, arg); 158 if (!tracker) 159 return ENOMEM; 160 tracker_control_read(tracker, setup_data, setup_size); 157 batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL, 158 max_packet_size, speed, data, size, setup_data, setup_size, callback, 159 NULL, arg); 160 if (!batch) 161 return ENOMEM; 162 batch_control_read(batch); 161 163 return EOK; 162 164 } … … 166 168 usbhc_iface_transfer_out_callback_t callback, void *arg) 167 169 { 168 usb_log_warning("Using deprecated API control write setup.\n"); 169 tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL, 170 8, FULL_SPEED, data, size, NULL, callback, arg); 171 if (!tracker) 172 return ENOMEM; 173 tracker_control_setup_old(tracker); 170 size_t max_packet_size = 8; 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); 174 179 return EOK; 175 180 } … … 179 184 usbhc_iface_transfer_out_callback_t callback, void *arg) 180 185 { 181 tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL, 182 size, FULL_SPEED, data, size, NULL, callback, arg); 183 if (!tracker) 184 return ENOMEM; 185 tracker_control_write_data_old(tracker); 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); 186 195 return EOK; 187 196 } … … 190 199 usbhc_iface_transfer_in_callback_t callback, void *arg) 191 200 { 192 tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL, 193 0, FULL_SPEED, NULL, 0, callback, NULL, arg); 194 if (!tracker) 195 return ENOMEM; 196 tracker_control_write_status_old(tracker); 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); 197 210 return EOK; 198 211 } … … 202 215 usbhc_iface_transfer_out_callback_t callback, void *arg) 203 216 { 204 usb_log_warning("Using deprecated API control read setup.\n"); 205 tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL, 206 8, FULL_SPEED, data, size, NULL, callback, arg); 207 if (!tracker) 208 return ENOMEM; 209 tracker_control_setup_old(tracker); 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); 210 226 return EOK; 211 227 } … … 215 231 usbhc_iface_transfer_in_callback_t callback, void *arg) 216 232 { 217 tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL, 218 size, FULL_SPEED, data, size, callback, NULL, arg); 219 if (!tracker) 220 return ENOMEM; 221 tracker_control_read_data_old(tracker); 233 size_t max_packet_size = 8; 234 dev_speed_t speed = FULL_SPEED; 235 236 usb_log_warning("Using deprecated API %s.\n", __FUNCTION__); 237 batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL, 238 max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg); 239 if (!batch) 240 return ENOMEM; 241 batch_control_read_data_old(batch); 222 242 return EOK; 223 243 } … … 226 246 usbhc_iface_transfer_out_callback_t callback, void *arg) 227 247 { 228 tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL, 229 0, FULL_SPEED, NULL, 0, NULL, callback, arg); 230 if (!tracker) 231 return ENOMEM; 232 tracker_control_read_status_old(tracker); 248 size_t max_packet_size = 8; 249 dev_speed_t speed = FULL_SPEED; 250 251 usb_log_warning("Using deprecated API %s.\n", __FUNCTION__); 252 batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL, 253 max_packet_size, speed, NULL, 0, NULL, 0, NULL, callback, arg); 254 if (!batch) 255 return ENOMEM; 256 batch_control_read_status_old(batch); 233 257 return EOK; 234 258 } -
uspace/drv/uhci-hcd/root_hub.c
r0d36c20 rd15809b4 35 35 #include <errno.h> 36 36 #include <stdio.h> 37 38 37 #include <usb_iface.h> 39 40 38 #include <usb/debug.h> 41 39 42 40 #include "root_hub.h" 41 42 extern device_ops_t child_ops; 43 43 /*----------------------------------------------------------------------------*/ 44 static int usb_iface_get_hc_handle(device_t *dev, devman_handle_t *handle)45 {46 assert(dev);47 assert(dev->parent != NULL);48 49 device_t *parent = dev->parent;50 51 if (parent->ops && parent->ops->interfaces[USB_DEV_IFACE]) {52 usb_iface_t *usb_iface53 = (usb_iface_t *) parent->ops->interfaces[USB_DEV_IFACE];54 assert(usb_iface != NULL);55 if (usb_iface->get_hc_handle) {56 int rc = usb_iface->get_hc_handle(parent, handle);57 return rc;58 }59 }60 61 return ENOTSUP;62 }63 /*----------------------------------------------------------------------------*/64 static usb_iface_t usb_iface = {65 .get_hc_handle = usb_iface_get_hc_handle66 };67 68 static device_ops_t rh_ops = {69 .interfaces[USB_DEV_IFACE] = &usb_iface70 };71 72 44 int setup_root_hub(device_t **device, device_t *hc) 73 45 { … … 108 80 hub->name = name; 109 81 hub->parent = hc; 110 hub->ops = & rh_ops;82 hub->ops = &child_ops; 111 83 112 84 *device = hub; -
uspace/drv/uhci-hcd/transfer_list.c
r0d36c20 rd15809b4 51 51 52 52 queue_head_init(instance->queue_head); 53 list_initialize(&instance->batch_list); 54 fibril_mutex_initialize(&instance->guard); 53 55 return EOK; 54 56 } … … 58 60 assert(instance); 59 61 assert(next); 60 instance->next = next;61 62 if (!instance->queue_head) 62 63 return; 63 queue_head_add_next(instance->queue_head, next->queue_head_pa); 64 queue_head_append_qh(instance->queue_head, next->queue_head_pa); 65 instance->queue_head->element = instance->queue_head->next_queue; 64 66 } 65 67 /*----------------------------------------------------------------------------*/ 66 void transfer_list_add_ tracker(transfer_list_t *instance, tracker_t *tracker)68 void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch) 67 69 { 68 70 assert(instance); 69 assert( tracker);71 assert(batch); 70 72 71 uint32_t pa = (uintptr_t)addr_to_phys( tracker->td);73 uint32_t pa = (uintptr_t)addr_to_phys(batch->qh); 72 74 assert((pa & LINK_POINTER_ADDRESS_MASK) == pa); 75 pa |= LINK_POINTER_QUEUE_HEAD_FLAG; 73 76 77 batch->qh->next_queue = instance->queue_head->next_queue; 74 78 75 if (instance->queue_head->element & LINK_POINTER_TERMINATE_FLAG) {76 usb_log_debug2("Adding td(%X:%X) to queue %s first.\n", 77 tracker->td->status, tracker->td->device, instance->name);79 fibril_mutex_lock(&instance->guard); 80 81 if (instance->queue_head->element == instance->queue_head->next_queue) { 78 82 /* there is nothing scheduled */ 79 instance->last_tracker = tracker;83 list_append(&batch->link, &instance->batch_list); 80 84 instance->queue_head->element = pa; 81 usb_log_debug2("Added td(%X:%X) to queue %s first.\n", 82 tracker->td->status, tracker->td->device, instance->name); 85 usb_log_debug2("Added batch(%p) to queue %s first.\n", 86 batch, instance->name); 87 fibril_mutex_unlock(&instance->guard); 83 88 return; 84 89 } 85 usb_log_debug2("Adding td(%X:%X) to queue %s last.%p\n", 86 tracker->td->status, tracker->td->device, instance->name, 87 instance->last_tracker); 88 /* now we can be sure that last_tracker is a valid pointer */ 89 instance->last_tracker->td->next = pa; 90 instance->last_tracker = tracker; 90 /* now we can be sure that there is someting scheduled */ 91 assert(!list_empty(&instance->batch_list)); 92 batch_t *first = list_get_instance( 93 instance->batch_list.next, batch_t, link); 94 batch_t *last = list_get_instance( 95 instance->batch_list.prev, batch_t, link); 96 queue_head_append_qh(last->qh, pa); 97 list_append(&batch->link, &instance->batch_list); 98 usb_log_debug2("Added batch(%p) to queue %s last, first is %p.\n", 99 batch, instance->name, first ); 100 fibril_mutex_unlock(&instance->guard); 101 } 102 /*----------------------------------------------------------------------------*/ 103 static void transfer_list_remove_batch( 104 transfer_list_t *instance, batch_t *batch) 105 { 106 assert(instance); 107 assert(batch); 108 assert(instance->queue_head); 109 assert(batch->qh); 91 110 92 usb_log_debug2("Added td(%X:%X) to queue %s last.\n", 93 tracker->td->status, tracker->td->device, instance->name); 111 /* I'm the first one here */ 112 if (batch->link.prev == &instance->batch_list) { 113 usb_log_debug("Removing tracer %p was first, next element %x.\n", 114 batch, batch->qh->next_queue); 115 instance->queue_head->element = batch->qh->next_queue; 116 } else { 117 usb_log_debug("Removing tracer %p was NOT first, next element %x.\n", 118 batch, batch->qh->next_queue); 119 batch_t *prev = list_get_instance(batch->link.prev, batch_t, link); 120 prev->qh->next_queue = batch->qh->next_queue; 121 } 122 list_remove(&batch->link); 123 } 124 /*----------------------------------------------------------------------------*/ 125 void transfer_list_check(transfer_list_t *instance) 126 { 127 assert(instance); 128 fibril_mutex_lock(&instance->guard); 129 link_t *current = instance->batch_list.next; 130 while (current != &instance->batch_list) { 131 link_t *next = current->next; 132 batch_t *batch = list_get_instance(current, batch_t, link); 94 133 95 /* check again, may be use atomic compare and swap */96 if (instance->queue_head->element & LINK_POINTER_TERMINATE_FLAG) {97 instance->queue_head->element = pa;98 usb_log_debug2("Added td(%X:%X) to queue first2 %s.\n",99 tracker->td->status, tracker->td->device, instance->name);134 if (batch_is_complete(batch)) { 135 transfer_list_remove_batch(instance, batch); 136 batch->next_step(batch); 137 } 138 current = next; 100 139 } 140 fibril_mutex_unlock(&instance->guard); 101 141 } 102 142 /** -
uspace/drv/uhci-hcd/transfer_list.h
r0d36c20 rd15809b4 35 35 #define DRV_UHCI_TRANSFER_LIST_H 36 36 37 #include <fibril_synch.h> 38 37 39 #include "uhci_struct/queue_head.h" 38 #include "tracker.h" 40 41 #include "batch.h" 39 42 40 43 typedef struct transfer_list 41 44 { 42 tracker_t *last_tracker; 43 45 fibril_mutex_t guard; 44 46 queue_head_t *queue_head; 45 47 uint32_t queue_head_pa; 46 48 struct transfer_list *next; 47 49 const char *name; 50 link_t batch_list; 48 51 } transfer_list_t; 49 52 … … 57 60 queue_head_dispose(instance->queue_head); 58 61 } 62 void transfer_list_check(transfer_list_t *instance); 59 63 60 61 void transfer_list_add_tracker(transfer_list_t *instance, tracker_t *tracker); 62 64 void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch); 63 65 #endif 64 66 /** -
uspace/drv/uhci-hcd/uhci.c
r0d36c20 rd15809b4 89 89 pio_write_32(&instance->registers->flbaseadd, (uint32_t)pa); 90 90 91 list_initialize(&instance-> tracker_list);92 fibril_mutex_initialize(&instance-> tracker_list_mutex);91 list_initialize(&instance->batch_list); 92 fibril_mutex_initialize(&instance->batch_list_mutex); 93 93 94 94 instance->cleaner = fibril_create(uhci_clean_finished, instance); … … 152 152 } 153 153 /*----------------------------------------------------------------------------*/ 154 int uhci_schedule(uhci_t *instance, tracker_t *tracker)155 { 156 assert(instance); 157 assert( tracker);158 const int low_speed = ( tracker->speed == LOW_SPEED);154 int uhci_schedule(uhci_t *instance, batch_t *batch) 155 { 156 assert(instance); 157 assert(batch); 158 const int low_speed = (batch->speed == LOW_SPEED); 159 159 if (!allowed_usb_packet( 160 low_speed, tracker->transfer_type, tracker->packet_size)) {160 low_speed, batch->transfer_type, batch->max_packet_size)) { 161 161 usb_log_warning("Invalid USB packet specified %s SPEED %d %zu.\n", 162 low_speed ? "LOW" : "FULL" , tracker->transfer_type,163 tracker->packet_size);162 low_speed ? "LOW" : "FULL" , batch->transfer_type, 163 batch->max_packet_size); 164 164 return ENOTSUP; 165 165 } 166 166 /* TODO: check available bandwith here */ 167 167 168 usb_log_debug2("Scheduler(%d) acquiring tracker list mutex.\n",169 fibril_get_id());170 fibril_mutex_lock(&instance->tracker_list_mutex);171 usb_log_debug2("Scheduler(%d) acquired tracker list mutex.\n",172 fibril_get_id());173 174 168 transfer_list_t *list = 175 instance->transfers[low_speed][ tracker->transfer_type];169 instance->transfers[low_speed][batch->transfer_type]; 176 170 assert(list); 177 transfer_list_add_tracker(list, tracker); 178 list_append(&tracker->link, &instance->tracker_list); 179 180 usb_log_debug2("Scheduler(%d) releasing tracker list mutex.\n", 181 fibril_get_id()); 182 fibril_mutex_unlock(&instance->tracker_list_mutex); 183 usb_log_debug2("Scheduler(%d) released tracker list mutex.\n", 184 fibril_get_id()); 171 transfer_list_add_batch(list, batch); 185 172 186 173 return EOK; … … 194 181 195 182 while(1) { 196 LIST_INITIALIZE(done_trackers); 197 /* tracker iteration */ 198 199 usb_log_debug2("Cleaner(%d) acquiring tracker list mutex.\n", 200 fibril_get_id()); 201 fibril_mutex_lock(&instance->tracker_list_mutex); 202 usb_log_debug2("Cleaner(%d) acquired tracker list mutex.\n", 203 fibril_get_id()); 204 205 link_t *current = instance->tracker_list.next; 206 while (current != &instance->tracker_list) 207 { 208 209 link_t *next = current->next; 210 tracker_t *tracker = list_get_instance(current, tracker_t, link); 211 212 assert(current == &tracker->link); 213 assert(tracker); 214 assert(tracker->next_step); 215 assert(tracker->td); 216 217 if (!transfer_descriptor_is_active(tracker->td)) { 218 usb_log_info("Found inactive tracker with status: %x:%x.\n", 219 tracker->td->status, tracker->td->device); 220 list_remove(current); 221 list_append(current, &done_trackers); 222 } 223 current = next; 224 } 225 226 usb_log_debug2("Cleaner(%d) releasing tracker list mutex.\n", 227 fibril_get_id()); 228 fibril_mutex_unlock(&instance->tracker_list_mutex); 229 usb_log_debug2("Cleaner(%d) released tracker list mutex.\n", 230 fibril_get_id()); 231 232 while (!list_empty(&done_trackers)) { 233 tracker_t *tracker = list_get_instance( 234 done_trackers.next, tracker_t, link); 235 list_remove(&tracker->link); 236 tracker->next_step(tracker); 237 } 183 transfer_list_check(&instance->transfers_interrupt); 184 transfer_list_check(&instance->transfers_control_slow); 185 transfer_list_check(&instance->transfers_control_full); 186 transfer_list_check(&instance->transfers_bulk_full); 238 187 async_usleep(UHCI_CLEANER_TIMEOUT); 239 188 } -
uspace/drv/uhci-hcd/uhci.h
r0d36c20 rd15809b4 44 44 45 45 #include "transfer_list.h" 46 #include " tracker.h"46 #include "batch.h" 47 47 48 48 typedef struct uhci_regs { … … 81 81 link_pointer_t *frame_list; 82 82 83 link_t tracker_list;84 fibril_mutex_t tracker_list_mutex;83 link_t batch_list; 84 fibril_mutex_t batch_list_mutex; 85 85 86 86 transfer_list_t transfers_bulk_full; … … 113 113 void *arg ); 114 114 115 int uhci_schedule(uhci_t *instance, tracker_t *tracker);115 int uhci_schedule(uhci_t *instance, batch_t *batch); 116 116 117 117 static inline uhci_t * dev_to_uhci(device_t *dev) -
uspace/drv/uhci-hcd/uhci_struct/queue_head.h
r0d36c20 rd15809b4 55 55 } 56 56 57 static inline void queue_head_a dd_next(queue_head_t *instance, uint32_t next_queue_pa)57 static inline void queue_head_append_qh(queue_head_t *instance, uint32_t pa) 58 58 { 59 if ( next_queue_pa) {60 instance->next_queue = ( next_queue_pa & LINK_POINTER_ADDRESS_MASK)61 | LINK_POINTER_QUEUE_HEAD_FLAG;59 if (pa) { 60 instance->next_queue = (pa & LINK_POINTER_ADDRESS_MASK) 61 | LINK_POINTER_QUEUE_HEAD_FLAG; 62 62 } 63 63 } 64 64 65 static inline queue_head_t * queue_head_get() 66 { return malloc32(sizeof(queue_head_t)); } 65 static inline void queue_head_element_qh(queue_head_t *instance, uint32_t pa) 66 { 67 if (pa) { 68 instance->next_queue = (pa & LINK_POINTER_ADDRESS_MASK) 69 | LINK_POINTER_QUEUE_HEAD_FLAG; 70 } 71 } 72 73 static inline void queue_head_element_td(queue_head_t *instance, uint32_t pa) 74 { 75 if (pa) { 76 instance->element = (pa & LINK_POINTER_ADDRESS_MASK); 77 } 78 } 79 80 static inline queue_head_t * queue_head_get() { 81 queue_head_t *ret = malloc32(sizeof(queue_head_t)); 82 if (ret) 83 queue_head_init(ret); 84 return ret; 85 } 67 86 68 87 static inline void queue_head_dispose(queue_head_t *head) -
uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.c
r0d36c20 rd15809b4 40 40 void transfer_descriptor_init(transfer_descriptor_t *instance, 41 41 int error_count, size_t size, bool toggle, bool isochronous, 42 usb_target_t target, int pid, void *buffer )42 usb_target_t target, int pid, void *buffer, transfer_descriptor_t *next) 43 43 { 44 44 assert(instance); 45 45 46 instance->next = 0 | LINK_POINTER_TERMINATE_FLAG; 46 instance->next = 0 47 | LINK_POINTER_VERTICAL_FLAG 48 | ((next != NULL) ? addr_to_phys(next) : LINK_POINTER_TERMINATE_FLAG); 47 49 48 50 instance->status = 0 … … 80 82 #endif 81 83 } 82 83 static inline usb_transaction_outcome_t convert_outcome(uint32_t status)84 {85 /*TODO: refactor into something sane */86 /*TODO: add additional usb_errors to usb_outcome_t */87 88 if (status & TD_STATUS_ERROR_STALLED)89 return USB_OUTCOME_CRCERROR;90 91 if (status & TD_STATUS_ERROR_BUFFER)92 return USB_OUTCOME_CRCERROR;93 94 if (status & TD_STATUS_ERROR_BABBLE)95 return USB_OUTCOME_BABBLE;96 97 if (status & TD_STATUS_ERROR_NAK)98 return USB_OUTCOME_CRCERROR;99 100 if (status & TD_STATUS_ERROR_CRC)101 return USB_OUTCOME_CRCERROR;102 103 if (status & TD_STATUS_ERROR_BIT_STUFF)104 return USB_OUTCOME_CRCERROR;105 106 // assert((((status >> TD_STATUS_ERROR_POS) & TD_STATUS_ERROR_MASK)107 // | TD_STATUS_ERROR_RESERVED) == TD_STATUS_ERROR_RESERVED);108 return USB_OUTCOME_OK;109 }110 84 /*----------------------------------------------------------------------------*/ 111 85 int transfer_descriptor_status(transfer_descriptor_t *instance) 112 86 { 113 87 assert(instance); 114 if (convert_outcome(instance->status)) 115 return EINVAL; //TODO: use sane error value here 88 89 if ((instance->status & TD_STATUS_ERROR_STALLED) != 0) 90 return EIO; 91 92 if ((instance->status & TD_STATUS_ERROR_CRC) != 0) 93 return EAGAIN; 94 95 if ((instance->status & TD_STATUS_ERROR_BUFFER) != 0) 96 return EAGAIN; 97 98 if ((instance->status & TD_STATUS_ERROR_BABBLE) != 0) 99 return EIO; 100 101 if ((instance->status & TD_STATUS_ERROR_NAK) != 0) 102 return EAGAIN; 103 104 if ((instance->status & TD_STATUS_ERROR_BIT_STUFF) != 0) 105 return EAGAIN; 106 116 107 return EOK; 117 108 } -
uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.h
r0d36c20 rd15809b4 93 93 void transfer_descriptor_init(transfer_descriptor_t *instance, 94 94 int error_count, size_t size, bool toggle, bool isochronous, 95 usb_target_t target, int pid, void *buffer );95 usb_target_t target, int pid, void *buffer, transfer_descriptor_t * next); 96 96 97 97 int transfer_descriptor_status(transfer_descriptor_t *instance); 98 99 static inline size_t transfer_descriptor_actual_size( 100 transfer_descriptor_t *instance) 101 { 102 assert(instance); 103 return 104 ((instance->status >> TD_STATUS_ACTLEN_POS) + 1) & TD_STATUS_ACTLEN_MASK; 105 } 98 106 99 107 static inline bool transfer_descriptor_is_active( -
uspace/drv/uhci-hcd/utils/malloc32.h
r0d36c20 rd15809b4 45 45 #define UHCI_REQUIRED_PAGE_SIZE 4096 46 46 47 static inline void *addr_to_phys(void *addr)47 static inline uintptr_t addr_to_phys(void *addr) 48 48 { 49 49 uintptr_t result; … … 51 51 52 52 assert(ret == 0); 53 return ( void*)(result | ((uintptr_t)addr & 0xfff));53 return (result | ((uintptr_t)addr & 0xfff)); 54 54 } 55 55 -
uspace/drv/uhci-rhd/port.c
r0d36c20 rd15809b4 33 33 */ 34 34 #include <errno.h> 35 #include <str_error.h> 35 36 36 37 #include <usb/usb.h> /* usb_address_t */ 37 38 #include <usb/usbdrv.h> /* usb_drv_* */ 38 39 #include <usb/debug.h> 40 #include <usb/recognise.h> 39 41 40 42 #include "port.h" … … 204 206 assert(port->attached_device == 0); 205 207 206 ret = usb_drv_register_child_in_devman(port->hc_phone, port->rh, 207 usb_address, &port->attached_device); 208 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); 209 219 if (ret != EOK) { /* something went wrong */ 210 220 usb_log_error("Failed(%d) in usb_drv_register_child.\n", ret); -
uspace/drv/usbhid/main.c
r0d36c20 rd15809b4 45 45 #include <str_error.h> 46 46 #include <fibril.h> 47 #include <usb/debug.h> 48 #include <usb/classes/classes.h> 47 49 #include <usb/classes/hid.h> 48 50 #include <usb/classes/hidparser.h> … … 61 63 #define GUESSED_POLL_ENDPOINT 1 62 64 65 /** Keyboard polling endpoint description for boot protocol class. */ 66 static usb_endpoint_description_t poll_endpoint_description = { 67 .transfer_type = USB_TRANSFER_INTERRUPT, 68 .direction = USB_DIRECTION_IN, 69 .interface_class = USB_CLASS_HID, 70 .interface_subclass = USB_HID_SUBCLASS_BOOT, 71 .interface_protocol = USB_HID_PROTOCOL_KEYBOARD, 72 .flags = 0 73 }; 74 63 75 static void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *); 64 76 static device_ops_t keyboard_ops = { … … 330 342 } 331 343 344 /* 345 * Initialize the interrupt in endpoint. 346 */ 347 usb_endpoint_mapping_t endpoint_mapping[1] = { 348 { 349 .pipe = &kbd_dev->poll_pipe, 350 .description = &poll_endpoint_description 351 } 352 }; 353 rc = usb_endpoint_pipe_initialize_from_configuration( 354 endpoint_mapping, 1, 355 descriptors, config_desc.total_length, 356 &kbd_dev->wire); 357 if (rc != EOK) { 358 usb_log_error("Failed to initialize poll pipe: %s.\n", 359 str_error(rc)); 360 return rc; 361 } 362 if (!endpoint_mapping[0].present) { 363 usb_log_warning("Not accepting device, " \ 364 "not boot-protocol keyboard.\n"); 365 return EREFUSED; 366 } 367 368 369 370 332 371 kbd_dev->conf = (usb_hid_configuration_t *)calloc(1, 333 372 sizeof(usb_hid_configuration_t)); … … 337 376 } 338 377 339 rc = usbkbd_parse_descriptors(descriptors, transferred, kbd_dev->conf);378 /*rc = usbkbd_parse_descriptors(descriptors, transferred, kbd_dev->conf); 340 379 free(descriptors); 341 380 if (rc != EOK) { … … 344 383 } 345 384 346 // get and report descriptors 385 // get and report descriptors*/ 347 386 rc = usbkbd_get_report_descriptor(kbd_dev); 348 387 if (rc != EOK) { … … 361 400 * as the endpoint for polling 362 401 */ 363 402 364 403 return EOK; 365 404 } … … 396 435 if (rc != EOK) { 397 436 printf("Failed to initialize default control pipe: %s.\n", 398 str_error(rc));399 goto error_leave;400 }401 402 rc = usb_endpoint_pipe_initialize(&kbd_dev->poll_pipe, &kbd_dev->wire,403 GUESSED_POLL_ENDPOINT, USB_TRANSFER_INTERRUPT, USB_DIRECTION_IN);404 if (rc != EOK) {405 printf("Failed to initialize interrupt in pipe: %s.\n",406 437 str_error(rc)); 407 438 goto error_leave; … … 418 449 usb_endpoint_pipe_start_session(&kbd_dev->ctrl_pipe); 419 450 //usb_request_set_configuration(&kbd_dev->ctrl_pipe, 1); 420 usbkbd_process_descriptors(kbd_dev);451 rc = usbkbd_process_descriptors(kbd_dev); 421 452 usb_endpoint_pipe_end_session(&kbd_dev->ctrl_pipe); 453 if (rc != EOK) { 454 goto error_leave; 455 } 422 456 423 457 return kbd_dev; … … 577 611 int main(int argc, char *argv[]) 578 612 { 613 usb_log_enable(USB_LOG_LEVEL_INFO, "usbhid"); 579 614 return driver_main(&kbd_driver); 580 615 } -
uspace/drv/usbhub/usbhub.c
r0d36c20 rd15809b4 36 36 #include <bool.h> 37 37 #include <errno.h> 38 #include <str_error.h> 38 39 39 40 #include <usb_iface.h> 40 41 #include <usb/usbdrv.h> 41 42 #include <usb/descriptor.h> 43 #include <usb/recognise.h> 42 44 #include <usb/devreq.h> 43 45 #include <usb/classes/hub.h> … … 317 319 } 318 320 321 devman_handle_t hc_handle; 322 opResult = usb_drv_find_hc(hub->device, &hc_handle); 323 if (opResult != EOK) { 324 usb_log_error("Failed to get handle of host controller: %s.\n", 325 str_error(opResult)); 326 return; 327 } 328 319 329 devman_handle_t child_handle; 320 opResult = usb_drv_register_child_in_devman(hc, hub->device,321 new_device_address, &child_handle);330 opResult = usb_device_register_child_in_devman(new_device_address, 331 hc_handle, hub->device, &child_handle); 322 332 if (opResult != EOK) { 323 333 dprintf(USB_LOG_LEVEL_ERROR, "could not start driver for new device"); -
uspace/drv/vhc/hub.c
r0d36c20 rd15809b4 41 41 #include <driver.h> 42 42 #include <usb/usbdrv.h> 43 #include <usb/recognise.h> 43 44 44 45 #include "hub.h" … … 93 94 94 95 devman_handle_t hub_handle; 95 usb_drv_register_child_in_devman(hc, hc_dev, hub_address, &hub_handle); 96 usb_device_register_child_in_devman(hub_address, hc_dev->handle, 97 hc_dev, &hub_handle); 98 //usb_drv_register_child_in_devman(hc, hc_dev, hub_address, &hub_handle); 96 99 usb_drv_bind_address(hc, hub_address, hub_handle); 97 100 -
uspace/lib/usb/Makefile
r0d36c20 rd15809b4 44 44 src/localdrv.c \ 45 45 src/pipes.c \ 46 src/pipesinit.c \ 46 47 src/recognise.c \ 47 48 src/remotedrv.c \ -
uspace/lib/usb/include/usb/classes/hid.h
r0d36c20 rd15809b4 50 50 USB_HIDREQ_SET_PROTOCOL = 11 51 51 } usb_hid_request_t; 52 53 /** USB/HID subclass constants. */ 54 typedef enum { 55 USB_HID_SUBCLASS_NONE = 0, 56 USB_HID_SUBCLASS_BOOT = 1 57 } usb_hid_subclass_t; 52 58 53 59 /** USB/HID interface protocols. */ -
uspace/lib/usb/include/usb/pipes.h
r0d36c20 rd15809b4 38 38 #include <sys/types.h> 39 39 #include <usb/usb.h> 40 #include <usb/descriptor.h> 40 41 #include <ipc/devman.h> 41 42 #include <driver.h> … … 73 74 usb_direction_t direction; 74 75 76 /** Maximum packet size for the endpoint. */ 77 size_t max_packet_size; 78 75 79 /** Phone to the host controller. 76 80 * Negative when no session is active. … … 79 83 } usb_endpoint_pipe_t; 80 84 85 86 /** Description of endpoint characteristics. */ 87 typedef struct { 88 /** Transfer type (e.g. control or interrupt). */ 89 usb_transfer_type_t transfer_type; 90 /** Transfer direction (to or from a device). */ 91 usb_direction_t direction; 92 /** Interface class this endpoint belongs to (-1 for any). */ 93 int interface_class; 94 /** Interface subclass this endpoint belongs to (-1 for any). */ 95 int interface_subclass; 96 /** Interface protocol this endpoint belongs to (-1 for any). */ 97 int interface_protocol; 98 /** Extra endpoint flags. */ 99 unsigned int flags; 100 } usb_endpoint_description_t; 101 102 /** Mapping of endpoint pipes and endpoint descriptions. */ 103 typedef struct { 104 /** Endpoint pipe. */ 105 usb_endpoint_pipe_t *pipe; 106 /** Endpoint description. */ 107 const usb_endpoint_description_t *description; 108 /** Found descriptor fitting the description. */ 109 usb_standard_endpoint_descriptor_t *descriptor; 110 /** Interface the endpoint belongs to. */ 111 usb_standard_interface_descriptor_t *interface; 112 /** Whether the endpoint was actually found. */ 113 bool present; 114 } usb_endpoint_mapping_t; 81 115 82 116 int usb_device_connection_initialize_from_device(usb_device_connection_t *, … … 87 121 int usb_endpoint_pipe_initialize(usb_endpoint_pipe_t *, 88 122 usb_device_connection_t *, 89 usb_endpoint_t, usb_transfer_type_t, usb_direction_t);123 usb_endpoint_t, usb_transfer_type_t, size_t, usb_direction_t); 90 124 int usb_endpoint_pipe_initialize_default_control(usb_endpoint_pipe_t *, 91 125 usb_device_connection_t *); 126 int usb_endpoint_pipe_initialize_from_configuration(usb_endpoint_mapping_t *, 127 size_t, uint8_t *, size_t, usb_device_connection_t *); 92 128 93 129 -
uspace/lib/usb/include/usb/usbdrv.h
r0d36c20 rd15809b4 106 106 const void *, size_t); 107 107 108 int usb_drv_create_device_match_ids(int, match_id_list_t *, usb_address_t);109 int usb_drv_register_child_in_devman(int, device_t *, usb_address_t,110 devman_handle_t *);111 112 108 113 109 #endif -
uspace/lib/usb/src/pipes.c
r0d36c20 rd15809b4 123 123 * @param endpoint_no Endpoint number (in USB 1.1 in range 0 to 15). 124 124 * @param transfer_type Transfer type (e.g. interrupt or bulk). 125 * @param max_packet_size Maximum packet size in bytes. 125 126 * @param direction Endpoint direction (in/out). 126 127 * @return Error code. … … 128 129 int usb_endpoint_pipe_initialize(usb_endpoint_pipe_t *pipe, 129 130 usb_device_connection_t *connection, usb_endpoint_t endpoint_no, 130 usb_transfer_type_t transfer_type, usb_direction_t direction) 131 usb_transfer_type_t transfer_type, size_t max_packet_size, 132 usb_direction_t direction) 131 133 { 132 134 assert(pipe); … … 137 139 pipe->endpoint_no = endpoint_no; 138 140 pipe->transfer_type = transfer_type; 141 pipe->max_packet_size = max_packet_size; 139 142 pipe->direction = direction; 140 143 … … 156 159 157 160 int rc = usb_endpoint_pipe_initialize(pipe, connection, 158 0, USB_TRANSFER_CONTROL, USB_DIRECTION_BOTH);161 0, USB_TRANSFER_CONTROL, 8, USB_DIRECTION_BOTH); 159 162 160 163 return rc; -
uspace/lib/usb/src/recognise.c
r0d36c20 rd15809b4 36 36 #include <usb_iface.h> 37 37 #include <usb/usbdrv.h> 38 #include <usb/pipes.h> 39 #include <usb/recognise.h> 40 #include <usb/request.h> 38 41 #include <usb/classes/classes.h> 39 42 #include <stdio.h> 40 43 #include <errno.h> 44 45 static size_t device_name_index = 0; 46 static FIBRIL_MUTEX_INITIALIZE(device_name_index_mutex); 41 47 42 48 /** Callback for getting host controller handle. … … 70 76 }; 71 77 72 staticdevice_ops_t child_ops = {78 device_ops_t child_ops = { 73 79 .interfaces[USB_DEV_IFACE] = &usb_iface 74 80 }; … … 155 161 /* First, with release number. */ 156 162 rc = usb_add_match_id(matches, 100, 157 "usb&vendor= %d&product=%d&release=" BCD_FMT,163 "usb&vendor=0x%04x&product=0x%04x&release=" BCD_FMT, 158 164 (int) device_descriptor->vendor_id, 159 165 (int) device_descriptor->product_id, … … 164 170 165 171 /* Next, without release number. */ 166 rc = usb_add_match_id(matches, 90, "usb&vendor=%d&product=%d", 172 rc = usb_add_match_id(matches, 90, 173 "usb&vendor=0x%04x&product=0x%04x", 167 174 (int) device_descriptor->vendor_id, 168 175 (int) device_descriptor->product_id); … … 241 248 /** Add match ids based on configuration descriptor. 242 249 * 243 * @param hc Open phone to host controller.250 * @param pipe Control pipe to the device. 244 251 * @param matches Match ids list to add matches to. 245 * @param address USB address of the attached device.246 252 * @param config_count Number of configurations the device has. 247 253 * @return Error code. 248 254 */ 249 static int usb_add_config_descriptor_match_ids(int hc, 250 match_id_list_t *matches, usb_address_t address, 251 int config_count) 255 static int usb_add_config_descriptor_match_ids(usb_endpoint_pipe_t *pipe, 256 match_id_list_t *matches, int config_count) 252 257 { 253 258 int final_rc = EOK; … … 257 262 int rc; 258 263 usb_standard_configuration_descriptor_t config_descriptor; 259 rc = usb_ drv_req_get_bare_configuration_descriptor(hc,260 address,config_index, &config_descriptor);264 rc = usb_request_get_bare_configuration_descriptor(pipe, 265 config_index, &config_descriptor); 261 266 if (rc != EOK) { 262 267 final_rc = rc; … … 267 272 void *full_config_descriptor 268 273 = malloc(config_descriptor.total_length); 269 rc = usb_ drv_req_get_full_configuration_descriptor(hc,270 address,config_index,274 rc = usb_request_get_full_configuration_descriptor(pipe, 275 config_index, 271 276 full_config_descriptor, config_descriptor.total_length, 272 277 &full_config_descriptor_size); … … 299 304 * function exits with error. 300 305 * 301 * @param hc Open phone to host controller. 306 * @param ctrl_pipe Control pipe to given device (session must be already 307 * started). 302 308 * @param matches Initialized list of match ids. 303 * @param address USB address of the attached device. 304 * @return Error code. 305 */ 306 int usb_drv_create_device_match_ids(int hc, match_id_list_t *matches, 307 usb_address_t address) 309 * @return Error code. 310 */ 311 int usb_device_create_match_ids(usb_endpoint_pipe_t *ctrl_pipe, 312 match_id_list_t *matches) 308 313 { 309 314 int rc; 310 311 315 /* 312 316 * Retrieve device descriptor and add matches from it. … … 314 318 usb_standard_device_descriptor_t device_descriptor; 315 319 316 rc = usb_drv_req_get_device_descriptor(hc, address, 317 &device_descriptor); 320 rc = usb_request_get_device_descriptor(ctrl_pipe, &device_descriptor); 318 321 if (rc != EOK) { 319 322 return rc; 320 323 } 321 324 322 325 rc = usb_drv_create_match_ids_from_device_descriptor(matches, 323 326 &device_descriptor); … … 325 328 return rc; 326 329 } 327 330 328 331 /* 329 332 * Go through all configurations and add matches 330 333 * based on interface class. 331 334 */ 332 rc = usb_add_config_descriptor_match_ids( hc, matches,333 address,device_descriptor.configuration_count);335 rc = usb_add_config_descriptor_match_ids(ctrl_pipe, matches, 336 device_descriptor.configuration_count); 334 337 if (rc != EOK) { 335 338 return rc; … … 347 350 } 348 351 349 350 352 /** Probe for device kind and register it in devman. 351 353 * 352 * @param[in] hc Open phone to the host controller. 354 * @param[in] address Address of the (unknown) attached device. 355 * @param[in] hc_handle Handle of the host controller. 353 356 * @param[in] parent Parent device. 354 * @param[in] address Address of the (unknown) attached device.355 357 * @param[out] child_handle Handle of the child device. 356 358 * @return Error code. 357 359 */ 358 int usb_drv_register_child_in_devman(int hc, device_t *parent, 359 usb_address_t address, devman_handle_t *child_handle) 360 { 361 static size_t device_name_index = 0; 362 static FIBRIL_MUTEX_INITIALIZE(device_name_index_mutex); 363 360 int usb_device_register_child_in_devman(usb_address_t address, 361 devman_handle_t hc_handle, 362 device_t *parent, devman_handle_t *child_handle) 363 { 364 364 size_t this_device_name_index; 365 365 … … 369 369 fibril_mutex_unlock(&device_name_index_mutex); 370 370 371 372 371 device_t *child = NULL; 373 372 char *child_name = NULL; 374 373 int rc; 374 usb_device_connection_t dev_connection; 375 usb_endpoint_pipe_t ctrl_pipe; 376 377 rc = usb_device_connection_initialize(&dev_connection, hc_handle, address); 378 if (rc != EOK) { 379 goto failure; 380 } 381 382 rc = usb_endpoint_pipe_initialize_default_control(&ctrl_pipe, 383 &dev_connection); 384 if (rc != EOK) { 385 goto failure; 386 } 375 387 376 388 child = create_device(); … … 391 403 child->name = child_name; 392 404 child->ops = &child_ops; 393 394 rc = usb_drv_create_device_match_ids(hc, &child->match_ids, address); 405 406 rc = usb_endpoint_pipe_start_session(&ctrl_pipe); 407 if (rc != EOK) { 408 goto failure; 409 } 410 411 rc = usb_device_create_match_ids(&ctrl_pipe, &child->match_ids); 412 if (rc != EOK) { 413 goto failure; 414 } 415 416 rc = usb_endpoint_pipe_end_session(&ctrl_pipe); 395 417 if (rc != EOK) { 396 418 goto failure; … … 405 427 *child_handle = child->handle; 406 428 } 407 429 408 430 return EOK; 409 431 … … 419 441 420 442 return rc; 421 422 443 } 423 444
Note:
See TracChangeset
for help on using the changeset viewer.