Changeset 68b5ed6e in mainline
- Timestamp:
- 2011-03-21T14:27:47Z (14 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- e34e77a
- Parents:
- 3954a63b
- Location:
- uspace
- Files:
-
- 14 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/drv/ohci/batch.c
r3954a63b r68b5ed6e 58 58 usbhc_iface_transfer_out_callback_t func_out, 59 59 void *arg, 60 device_keeper_t *manager60 usb_device_keeper_t *manager 61 61 ) 62 62 { -
uspace/drv/ohci/batch.h
r3954a63b r68b5ed6e 54 54 usbhc_iface_transfer_out_callback_t func_out, 55 55 void *arg, 56 device_keeper_t *manager56 usb_device_keeper_t *manager 57 57 ); 58 58 -
uspace/drv/ohci/hc.c
r3954a63b r68b5ed6e 65 65 } 66 66 instance->ddf_instance = fun; 67 device_keeper_init(&instance->manager);67 usb_device_keeper_init(&instance->manager); 68 68 69 69 -
uspace/drv/ohci/hc.h
r3954a63b r68b5ed6e 53 53 rh_t rh; 54 54 ddf_fun_t *ddf_instance; 55 device_keeper_t manager;55 usb_device_keeper_t manager; 56 56 } hc_t; 57 57 -
uspace/drv/ohci/iface.c
r3954a63b r68b5ed6e 64 64 assert(hc); 65 65 usb_log_debug("Default address request with speed %d.\n", speed); 66 device_keeper_reserve_default(&hc->manager, speed);66 usb_device_keeper_reserve_default_address(&hc->manager, speed); 67 67 return EOK; 68 68 } … … 79 79 assert(hc); 80 80 usb_log_debug("Default address release.\n"); 81 device_keeper_release_default(&hc->manager);81 usb_device_keeper_release_default_address(&hc->manager); 82 82 return EOK; 83 83 } … … 99 99 100 100 usb_log_debug("Address request with speed %d.\n", speed); 101 *address = device_keeper_ request(&hc->manager, speed);101 *address = device_keeper_get_free_address(&hc->manager, speed); 102 102 usb_log_debug("Address request with result: %d.\n", *address); 103 103 if (*address <= 0) … … 120 120 assert(hc); 121 121 usb_log_debug("Address bind %d-%d.\n", address, handle); 122 device_keeper_bind(&hc->manager, address, handle);122 usb_device_keeper_bind(&hc->manager, address, handle); 123 123 return EOK; 124 124 } … … 136 136 assert(hc); 137 137 usb_log_debug("Address release %d.\n", address); 138 device_keeper_release(&hc->manager, address);138 usb_device_keeper_release(&hc->manager, address); 139 139 return EOK; 140 140 } … … 200 200 hc_t *hc = fun_to_hc(fun); 201 201 assert(hc); 202 usb_speed_t speed = device_keeper_speed(&hc->manager, target.address);202 usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address); 203 203 204 204 usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n", … … 243 243 hc_t *hc = fun_to_hc(fun); 244 244 assert(hc); 245 usb_speed_t speed = device_keeper_speed(&hc->manager, target.address);245 usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address); 246 246 usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n", 247 247 target.address, target.endpoint, size, max_packet_size); … … 285 285 hc_t *hc = fun_to_hc(fun); 286 286 assert(hc); 287 usb_speed_t speed = device_keeper_speed(&hc->manager, target.address);287 usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address); 288 288 289 289 usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n", … … 329 329 hc_t *hc = fun_to_hc(fun); 330 330 assert(hc); 331 usb_speed_t speed = device_keeper_speed(&hc->manager, target.address);331 usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address); 332 332 usb_log_debug("Bulk IN %d:%d %zu(%zu).\n", 333 333 target.address, target.endpoint, size, max_packet_size); … … 376 376 hc_t *hc = fun_to_hc(fun); 377 377 assert(hc); 378 usb_speed_t speed = device_keeper_speed(&hc->manager, target.address);378 usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address); 379 379 usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n", 380 380 speed, target.address, target.endpoint, size, max_packet_size); … … 388 388 if (!batch) 389 389 return ENOMEM; 390 device_keeper_reset_if_need(&hc->manager, target, setup_data);390 usb_device_keeper_reset_if_need(&hc->manager, target, setup_data); 391 391 batch_control_write(batch); 392 392 const int ret = hc_schedule(hc, batch); … … 427 427 hc_t *hc = fun_to_hc(fun); 428 428 assert(hc); 429 usb_speed_t speed = device_keeper_speed(&hc->manager, target.address);429 usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address); 430 430 431 431 usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n", -
uspace/drv/ohci/main.c
r3954a63b r68b5ed6e 61 61 { 62 62 assert(fun); 63 device_keeper_t *manager = &fun_to_hc(fun)->manager;64 usb_address_t addr = device_keeper_find(manager, handle);63 usb_device_keeper_t *manager = &fun_to_hc(fun)->manager; 64 usb_address_t addr = usb_device_keeper_find(manager, handle); 65 65 if (addr < 0) { 66 66 return addr; -
uspace/drv/uhci-hcd/batch.c
r3954a63b r68b5ed6e 50 50 td_t *tds; 51 51 size_t packets; 52 device_keeper_t *manager;52 usb_device_keeper_t *manager; 53 53 } uhci_batch_t; 54 54 … … 88 88 usbhc_iface_transfer_in_callback_t func_in, 89 89 usbhc_iface_transfer_out_callback_t func_out, void *arg, 90 device_keeper_t *manager90 usb_device_keeper_t *manager 91 91 ) 92 92 { … … 182 182 td_print_status(&data->tds[i]); 183 183 184 device_keeper_set_toggle(data->manager,184 usb_device_keeper_set_toggle(data->manager, 185 185 instance->target, instance->direction, 186 186 td_toggle(&data->tds[i])); … … 311 311 312 312 const bool low_speed = instance->speed == USB_SPEED_LOW; 313 int toggle = device_keeper_get_toggle(313 int toggle = usb_device_keeper_get_toggle( 314 314 data->manager, instance->target, instance->direction); 315 315 assert(toggle == 0 || toggle == 1); … … 343 343 } 344 344 td_set_ioc(&data->tds[packet - 1]); 345 device_keeper_set_toggle(data->manager, instance->target,345 usb_device_keeper_set_toggle(data->manager, instance->target, 346 346 instance->direction, toggle); 347 347 } -
uspace/drv/uhci-hcd/batch.h
r3954a63b r68b5ed6e 57 57 usbhc_iface_transfer_out_callback_t func_out, 58 58 void *arg, 59 device_keeper_t *manager59 usb_device_keeper_t *manager 60 60 ); 61 61 -
uspace/drv/uhci-hcd/iface.c
r3954a63b r68b5ed6e 55 55 assert(hc); 56 56 usb_log_debug("Default address request with speed %d.\n", speed); 57 device_keeper_reserve_default(&hc->device_manager, speed);57 usb_device_keeper_reserve_default_address(&hc->device_manager, speed); 58 58 return EOK; 59 59 } … … 70 70 assert(hc); 71 71 usb_log_debug("Default address release.\n"); 72 device_keeper_release_default(&hc->device_manager);72 usb_device_keeper_release_default_address(&hc->device_manager); 73 73 return EOK; 74 74 } … … 90 90 91 91 usb_log_debug("Address request with speed %d.\n", speed); 92 *address = device_keeper_ request(&hc->device_manager, speed);92 *address = device_keeper_get_free_address(&hc->device_manager, speed); 93 93 usb_log_debug("Address request with result: %d.\n", *address); 94 94 if (*address <= 0) … … 111 111 assert(hc); 112 112 usb_log_debug("Address bind %d-%d.\n", address, handle); 113 device_keeper_bind(&hc->device_manager, address, handle);113 usb_device_keeper_bind(&hc->device_manager, address, handle); 114 114 return EOK; 115 115 } … … 127 127 assert(hc); 128 128 usb_log_debug("Address release %d.\n", address); 129 device_keeper_release(&hc->device_manager, address);129 usb_device_keeper_release(&hc->device_manager, address); 130 130 return EOK; 131 131 } … … 149 149 uhci_hc_t *hc = fun_to_uhci_hc(fun); 150 150 assert(hc); 151 usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);151 usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address); 152 152 153 153 usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n", … … 186 186 uhci_hc_t *hc = fun_to_uhci_hc(fun); 187 187 assert(hc); 188 usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);188 usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address); 189 189 usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n", 190 190 target.address, target.endpoint, size, max_packet_size); … … 222 222 uhci_hc_t *hc = fun_to_uhci_hc(fun); 223 223 assert(hc); 224 usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);224 usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address); 225 225 226 226 usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n", … … 259 259 uhci_hc_t *hc = fun_to_uhci_hc(fun); 260 260 assert(hc); 261 usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);261 usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address); 262 262 usb_log_debug("Bulk IN %d:%d %zu(%zu).\n", 263 263 target.address, target.endpoint, size, max_packet_size); … … 298 298 uhci_hc_t *hc = fun_to_uhci_hc(fun); 299 299 assert(hc); 300 usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);300 usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address); 301 301 usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n", 302 302 speed, target.address, target.endpoint, size, max_packet_size); … … 310 310 if (!batch) 311 311 return ENOMEM; 312 device_keeper_reset_if_need(&hc->device_manager, target, setup_data);312 usb_device_keeper_reset_if_need(&hc->device_manager, target, setup_data); 313 313 batch_control_write(batch); 314 314 const int ret = uhci_hc_schedule(hc, batch); … … 341 341 uhci_hc_t *hc = fun_to_uhci_hc(fun); 342 342 assert(hc); 343 usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);343 usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address); 344 344 345 345 usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n", -
uspace/drv/uhci-hcd/uhci.c
r3954a63b r68b5ed6e 70 70 { 71 71 assert(fun); 72 device_keeper_t *manager = &((uhci_t*)fun->dev->driver_data)->hc.device_manager;73 74 usb_address_t addr = device_keeper_find(manager, handle);72 usb_device_keeper_t *manager = &((uhci_t*)fun->dev->driver_data)->hc.device_manager; 73 74 usb_address_t addr = usb_device_keeper_find(manager, handle); 75 75 if (addr < 0) { 76 76 return addr; -
uspace/drv/uhci-hcd/uhci_hc.c
r3954a63b r68b5ed6e 234 234 235 235 /* Init device keeper*/ 236 device_keeper_init(&instance->device_manager);236 usb_device_keeper_init(&instance->device_manager); 237 237 usb_log_debug("Initialized device manager.\n"); 238 238 -
uspace/drv/uhci-hcd/uhci_hc.h
r3954a63b r68b5ed6e 83 83 84 84 typedef struct uhci_hc { 85 device_keeper_t device_manager;85 usb_device_keeper_t device_manager; 86 86 87 87 regs_t *registers; -
uspace/lib/usb/include/usb/host/device_keeper.h
r3954a63b r68b5ed6e 48 48 }; 49 49 50 typedef struct device_keeper{50 typedef struct { 51 51 struct usb_device_info devices[USB_ADDRESS_COUNT]; 52 52 fibril_mutex_t guard; 53 53 fibril_condvar_t default_address_occupied; 54 54 usb_address_t last_address; 55 } device_keeper_t;55 } usb_device_keeper_t; 56 56 57 void device_keeper_init(device_keeper_t *instance);57 void usb_device_keeper_init(usb_device_keeper_t *instance); 58 58 59 void device_keeper_reserve_default(60 device_keeper_t *instance, usb_speed_t speed);59 void usb_device_keeper_reserve_default_address( 60 usb_device_keeper_t *instance, usb_speed_t speed); 61 61 62 void device_keeper_release_default(device_keeper_t *instance);62 void usb_device_keeper_release_default_address(usb_device_keeper_t *instance); 63 63 64 void device_keeper_reset_if_need(65 device_keeper_t *instance, usb_target_t target,64 void usb_device_keeper_reset_if_need( 65 usb_device_keeper_t *instance, usb_target_t target, 66 66 const unsigned char *setup_data); 67 67 68 int device_keeper_get_toggle(69 device_keeper_t *instance, usb_target_t target, usb_direction_t direction);68 int usb_device_keeper_get_toggle( 69 usb_device_keeper_t *instance, usb_target_t target, usb_direction_t direction); 70 70 71 int device_keeper_set_toggle(device_keeper_t *instance,71 int usb_device_keeper_set_toggle(usb_device_keeper_t *instance, 72 72 usb_target_t target, usb_direction_t direction, bool toggle); 73 73 74 usb_address_t device_keeper_ request(75 device_keeper_t *instance, usb_speed_t speed);74 usb_address_t device_keeper_get_free_address( 75 usb_device_keeper_t *instance, usb_speed_t speed); 76 76 77 void device_keeper_bind(78 device_keeper_t *instance, usb_address_t address, devman_handle_t handle);77 void usb_device_keeper_bind( 78 usb_device_keeper_t *instance, usb_address_t address, devman_handle_t handle); 79 79 80 void device_keeper_release(device_keeper_t *instance, usb_address_t address);80 void usb_device_keeper_release(usb_device_keeper_t *instance, usb_address_t address); 81 81 82 usb_address_t device_keeper_find(83 device_keeper_t *instance, devman_handle_t handle);82 usb_address_t usb_device_keeper_find( 83 usb_device_keeper_t *instance, devman_handle_t handle); 84 84 85 usb_speed_t device_keeper_speed(86 device_keeper_t *instance, usb_address_t address);85 usb_speed_t usb_device_keeper_get_speed( 86 usb_device_keeper_t *instance, usb_address_t address); 87 87 #endif 88 88 /** -
uspace/lib/usb/src/host/device_keeper.c
r3954a63b r68b5ed6e 45 45 * Set all values to false/0. 46 46 */ 47 void device_keeper_init(device_keeper_t *instance)47 void usb_device_keeper_init(usb_device_keeper_t *instance) 48 48 { 49 49 assert(instance); … … 65 65 * @param[in] speed Speed of the device requesting default address. 66 66 */ 67 void device_keeper_reserve_default(device_keeper_t *instance, usb_speed_t speed)67 void usb_device_keeper_reserve_default_address(usb_device_keeper_t *instance, usb_speed_t speed) 68 68 { 69 69 assert(instance); … … 83 83 * @param[in] speed Speed of the device requesting default address. 84 84 */ 85 void device_keeper_release_default(device_keeper_t *instance)85 void usb_device_keeper_release_default_address(usb_device_keeper_t *instance) 86 86 { 87 87 assert(instance); … … 100 100 * Really ugly one. 101 101 */ 102 void device_keeper_reset_if_need(103 device_keeper_t *instance, usb_target_t target, const unsigned char *data)102 void usb_device_keeper_reset_if_need( 103 usb_device_keeper_t *instance, usb_target_t target, const unsigned char *data) 104 104 { 105 105 assert(instance); … … 144 144 * @return Error code 145 145 */ 146 int device_keeper_get_toggle(147 device_keeper_t *instance, usb_target_t target, usb_direction_t direction)146 int usb_device_keeper_get_toggle( 147 usb_device_keeper_t *instance, usb_target_t target, usb_direction_t direction) 148 148 { 149 149 assert(instance); … … 173 173 * @return Error code. 174 174 */ 175 int device_keeper_set_toggle(device_keeper_t *instance,175 int usb_device_keeper_set_toggle(usb_device_keeper_t *instance, 176 176 usb_target_t target, usb_direction_t direction, bool toggle) 177 177 { … … 207 207 * @return Free address, or error code. 208 208 */ 209 usb_address_t device_keeper_ request(210 device_keeper_t *instance, usb_speed_t speed)209 usb_address_t device_keeper_get_free_address( 210 usb_device_keeper_t *instance, usb_speed_t speed) 211 211 { 212 212 assert(instance); … … 241 241 * @param[in] handle Devman handle of the device. 242 242 */ 243 void device_keeper_bind(244 device_keeper_t *instance, usb_address_t address, devman_handle_t handle)243 void usb_device_keeper_bind( 244 usb_device_keeper_t *instance, usb_address_t address, devman_handle_t handle) 245 245 { 246 246 assert(instance); … … 258 258 * @param[in] address Device address 259 259 */ 260 void device_keeper_release(device_keeper_t *instance, usb_address_t address)260 void usb_device_keeper_release(usb_device_keeper_t *instance, usb_address_t address) 261 261 { 262 262 assert(instance); … … 276 276 * @return USB Address, or error code. 277 277 */ 278 usb_address_t device_keeper_find(279 device_keeper_t *instance, devman_handle_t handle)278 usb_address_t usb_device_keeper_find( 279 usb_device_keeper_t *instance, devman_handle_t handle) 280 280 { 281 281 assert(instance); … … 299 299 * @return USB speed. 300 300 */ 301 usb_speed_t device_keeper_speed(302 device_keeper_t *instance, usb_address_t address)301 usb_speed_t usb_device_keeper_get_speed( 302 usb_device_keeper_t *instance, usb_address_t address) 303 303 { 304 304 assert(instance);
Note:
See TracChangeset
for help on using the changeset viewer.