Changeset 98d06b8 in mainline
- Timestamp:
- 2010-12-10T15:11:24Z (14 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- c01255c
- Parents:
- b5ec347
- Location:
- uspace/drv
- Files:
-
- 4 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/drv/usbhub/port_status.h
rb5ec347 r98d06b8 43 43 * 44 44 */ 45 typedef uint 8_t usb_port_status_t[4];45 typedef uint32_t usb_port_status_t; 46 46 47 47 /** … … 103 103 } 104 104 105 /** 106 * set the device request to be a port disable request 107 * @param request 108 * @param port 109 */ 110 static inline void usb_hub_set_disable_port_request( 111 usb_device_request_setup_packet_t * request, uint16_t port 112 ){ 113 request->index = port; 114 request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE; 115 request->request = USB_HUB_REQUEST_SET_FEATURE; 116 request->value = USB_HUB_FEATURE_C_PORT_SUSPEND; 117 request->length = 0; 118 } 119 120 /** 121 * disable specified port 122 * @param port 123 * @return 124 */ 125 static inline usb_device_request_setup_packet_t * 126 usb_hub_create_disable_port_request(uint16_t port){ 127 usb_device_request_setup_packet_t * result = 128 usb_new(usb_device_request_setup_packet_t); 129 usb_hub_set_disable_port_request(result,port); 130 return result; 131 } 132 133 /** 134 * set the device request to be a port disable request 135 * @param request 136 * @param port 137 */ 138 static inline void usb_hub_set_reset_port_request( 139 usb_device_request_setup_packet_t * request, uint16_t port 140 ){ 141 request->index = port; 142 request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE; 143 request->request = USB_HUB_REQUEST_SET_FEATURE; 144 request->value = USB_HUB_FEATURE_PORT_RESET; 145 request->length = 0; 146 } 147 148 /** 149 * disable specified port 150 * @param port 151 * @return 152 */ 153 static inline usb_device_request_setup_packet_t * 154 usb_hub_create_reset_port_request(uint16_t port){ 155 usb_device_request_setup_packet_t * result = 156 usb_new(usb_device_request_setup_packet_t); 157 usb_hub_set_reset_port_request(result,port); 158 return result; 159 } 160 161 /** 162 * set the device request to be a port disable request 163 * @param request 164 * @param port 165 */ 166 static inline void usb_hub_set_power_port_request( 167 usb_device_request_setup_packet_t * request, uint16_t port 168 ){ 169 request->index = port; 170 request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE; 171 request->request = USB_HUB_REQUEST_SET_FEATURE; 172 request->value = USB_HUB_FEATURE_PORT_POWER; 173 request->length = 0; 174 } 105 175 106 176 /** get i`th bit of port status */ 107 177 static inline bool usb_port_get_bit(usb_port_status_t * status, int idx) 108 178 { 109 return (((*status) [idx/8])>>(idx%8))%2;179 return (((*status)>>(idx))%2); 110 180 } 111 181 … … 114 184 usb_port_status_t * status, int idx, bool value) 115 185 { 116 (*status) [idx/8]= value?117 ((*status) [idx/8]|(1<<(idx%8))):118 ((*status) [idx/8]&(~(1<<(idx%8))));186 (*status) = value? 187 ((*status)|(1<<(idx))): 188 ((*status)&(~(1<<(idx)))); 119 189 } 120 190 -
uspace/drv/usbhub/usbhub_private.h
rb5ec347 r98d06b8 100 100 * @brief create hub structure instance 101 101 * 102 * Set the address and port count information most importantly. 103 * 102 104 * @param device 105 * @param hc host controller phone 103 106 * @return 104 107 */ 105 usb_hub_info_t * usb_create_hub_info(device_t * device );108 usb_hub_info_t * usb_create_hub_info(device_t * device, int hc); 106 109 107 110 /** list of hubs maanged by this driver */ … … 146 149 147 150 /** 148 * set the device requ sst to be a set address request151 * set the device request to be a set address request 149 152 * @param request 150 153 * @param addr … … 154 157 ){ 155 158 request->index = 0; 156 request->request_type = 0;/// \TODO this is not very nice sollution 159 request->request_type = 0;/// \TODO this is not very nice sollution, we ned constant 157 160 request->request = USB_DEVREQ_SET_ADDRESS; 158 161 request->value = addr; 159 162 request->length = 0; 160 163 } 164 165 /** 166 * set the device request to be a get hub descriptor request. 167 * @warning the size is allways set to USB_HUB_MAX_DESCRIPTOR_SIZE 168 * @param request 169 * @param addr 170 */ 171 static inline void usb_hub_get_descriptor_request( 172 usb_device_request_setup_packet_t * request 173 ){ 174 request->index = 0; 175 request->request_type = USB_HUB_REQ_TYPE_GET_DESCRIPTOR; 176 request->request = USB_HUB_REQUEST_GET_DESCRIPTOR; 177 request->value = USB_DESCTYPE_HUB; 178 request->length = USB_HUB_MAX_DESCRIPTOR_SIZE; 179 } 180 161 181 162 182 -
uspace/drv/usbhub/utils.c
rb5ec347 r98d06b8 58 58 59 59 //hub descriptor utils 60 60 61 void * usb_serialize_hub_descriptor(usb_hub_descriptor_t * descriptor) { 61 62 //base size … … 107 108 108 109 //control transactions 110 109 111 int usb_drv_sync_control_read( 110 111 112 113 ){112 int phone, usb_target_t target, 113 usb_device_request_setup_packet_t * request, 114 void * rcvd_buffer, size_t rcvd_size, size_t * actual_size 115 ) { 114 116 usb_handle_t handle; 115 117 int opResult; 116 118 //setup 117 119 opResult = usb_drv_async_control_read_setup(phone, target, 118 request, sizeof(usb_device_request_setup_packet_t),119 120 if (opResult!=EOK){120 request, sizeof (usb_device_request_setup_packet_t), 121 &handle); 122 if (opResult != EOK) { 121 123 return opResult; 122 124 } 123 125 opResult = usb_drv_async_wait_for(handle); 124 if (opResult!=EOK){126 if (opResult != EOK) { 125 127 return opResult; 126 128 } 127 129 //read 128 130 opResult = usb_drv_async_control_read_data(phone, target, 129 rcvd_buffer,rcvd_size, actual_size,130 131 if (opResult!=EOK){131 rcvd_buffer, rcvd_size, actual_size, 132 &handle); 133 if (opResult != EOK) { 132 134 return opResult; 133 135 } 134 136 opResult = usb_drv_async_wait_for(handle); 135 if (opResult!=EOK){137 if (opResult != EOK) { 136 138 return opResult; 137 139 } 138 140 //finalize 139 141 opResult = usb_drv_async_control_read_status(phone, target, 140 141 if (opResult!=EOK){142 &handle); 143 if (opResult != EOK) { 142 144 return opResult; 143 145 } 144 146 opResult = usb_drv_async_wait_for(handle); 145 if (opResult!=EOK){147 if (opResult != EOK) { 146 148 return opResult; 147 149 } … … 149 151 } 150 152 151 152 153 int usb_drv_sync_control_write( 153 154 155 156 ){154 int phone, usb_target_t target, 155 usb_device_request_setup_packet_t * request, 156 void * sent_buffer, size_t sent_size 157 ) { 157 158 usb_handle_t handle; 158 159 int opResult; 159 160 //setup 160 161 opResult = usb_drv_async_control_write_setup(phone, target, 161 request, sizeof(usb_device_request_setup_packet_t),162 163 if (opResult!=EOK){162 request, sizeof (usb_device_request_setup_packet_t), 163 &handle); 164 if (opResult != EOK) { 164 165 return opResult; 165 166 } 166 167 opResult = usb_drv_async_wait_for(handle); 167 if (opResult!=EOK){168 if (opResult != EOK) { 168 169 return opResult; 169 170 } 170 171 //write 171 172 opResult = usb_drv_async_control_write_data(phone, target, 172 173 174 if (opResult!=EOK){173 sent_buffer, sent_size, 174 &handle); 175 if (opResult != EOK) { 175 176 return opResult; 176 177 } 177 178 opResult = usb_drv_async_wait_for(handle); 178 if (opResult!=EOK){179 if (opResult != EOK) { 179 180 return opResult; 180 181 } 181 182 //finalize 182 183 opResult = usb_drv_async_control_write_status(phone, target, 183 184 if (opResult!=EOK){184 &handle); 185 if (opResult != EOK) { 185 186 return opResult; 186 187 } 187 188 opResult = usb_drv_async_wait_for(handle); 188 if (opResult!=EOK){189 if (opResult != EOK) { 189 190 return opResult; 190 191 } … … 194 195 //list implementation 195 196 196 usb_general_list_t * usb_lst_create(void) {197 usb_general_list_t * usb_lst_create(void) { 197 198 usb_general_list_t* result = usb_new(usb_general_list_t); 198 199 usb_lst_init(result); … … 200 201 } 201 202 202 void usb_lst_init(usb_general_list_t * lst) {203 void usb_lst_init(usb_general_list_t * lst) { 203 204 lst->prev = lst; 204 205 lst->next = lst; … … 206 207 } 207 208 208 void usb_lst_prepend(usb_general_list_t* item, void* data) {209 void usb_lst_prepend(usb_general_list_t* item, void* data) { 209 210 usb_general_list_t* appended = usb_new(usb_general_list_t); 210 appended->data =data;211 appended->next =item;212 appended->prev =item->prev;211 appended->data = data; 212 appended->next = item; 213 appended->prev = item->prev; 213 214 item->prev->next = appended; 214 215 item->prev = appended; 215 216 } 216 217 217 void usb_lst_append(usb_general_list_t* item, void* data) {218 usb_general_list_t* appended = usb_new(usb_general_list_t);219 appended->data =data;220 appended->next =item->next;221 appended->prev =item;218 void usb_lst_append(usb_general_list_t* item, void* data) { 219 usb_general_list_t* appended = usb_new(usb_general_list_t); 220 appended->data = data; 221 appended->next = item->next; 222 appended->prev = item; 222 223 item->next->prev = appended; 223 224 item->next = appended; 224 225 } 225 226 226 227 void usb_lst_remove(usb_general_list_t* item){ 227 void usb_lst_remove(usb_general_list_t* item) { 228 228 item->next->prev = item->prev; 229 229 item->prev->next = item->next; 230 230 } 231 231 232 232 static void usb_hub_test_port_status(void) { 233 printf("[usb_hub] -------------port status test---------\n"); 234 usb_port_status_t status = 0; 235 236 //printf("original status %d (should be 0)\n",(uint32_t)status); 237 usb_port_set_bit(&status, 1, 1); 238 //printf("%d =?= 2\n",(uint32_t)status); 239 if (status != 2) { 240 printf("[usb_port_status] test failed: wrong set of bit 1\n"); 241 return; 242 } 243 usb_port_set_bit(&status, 3, 1); 244 if (status != 10) { 245 printf("[usb_port_status] test failed: wrong set of bit 3\n"); 246 return; 247 } 248 249 usb_port_set_bit(&status, 15, 1); 250 if (status != 10 + (1 << 15)) { 251 printf("[usb_port_status] test failed: wrong set of bit 15\n"); 252 return; 253 } 254 usb_port_set_bit(&status, 1, 0); 255 if (status != 8 + (1 << 15)) { 256 printf("[usb_port_status] test failed: wrong unset of bit 1\n"); 257 return; 258 } 259 int i; 260 for (i = 0; i < 32; ++i) { 261 if (i == 3 || i == 15) { 262 if (!usb_port_get_bit(&status, i)) { 263 printf("[usb_port_status] test failed: wrong bit at %d\n", i); 264 } 265 } else { 266 if (usb_port_get_bit(&status, i)) { 267 printf("[usb_port_status] test failed: wrong bit at %d\n", i); 268 } 269 } 270 } 271 272 printf("test ok\n"); 273 274 275 //printf("%d =?= 10\n",(uint32_t)status); 276 277 //printf("this should be 0: %d \n",usb_port_get_bit(&status,0)); 278 //printf("this should be 1: %d \n",usb_port_get_bit(&status,1)); 279 //printf("this should be 0: %d \n",usb_port_get_bit(&status,2)); 280 //printf("this should be 1: %d \n",usb_port_get_bit(&status,3)); 281 //printf("this should be 0: %d \n",usb_port_get_bit(&status,4)); 282 283 284 285 286 } 233 287 234 288 //********************************************* 235 289 // 236 // hub driver code 290 // hub driver code, initialization 237 291 // 238 292 //********************************************* 239 293 240 usb_hub_info_t * usb_create_hub_info(device_t * device ) {294 usb_hub_info_t * usb_create_hub_info(device_t * device, int hc) { 241 295 usb_hub_info_t* result = usb_new(usb_hub_info_t); 242 296 //result->device = device; 243 297 result->port_count = -1; 244 298 245 //get hc connection 246 int hc = usb_drv_hc_connect(NULL, 0); 247 printf("[usb_hub] phone to hc = %d\n",hc); 299 300 printf("[usb_hub] phone to hc = %d\n", hc); 248 301 if (hc < 0) { 249 302 return result; 250 303 } 251 304 //get some hub info 252 253 usb_address_t addr = usb_drv_get_my_address(hc,device); 254 printf("[usb_hub] addres of newly created hub = %d\n",addr); 305 /// \TODO get correct params 306 usb_address_t addr = usb_drv_get_my_address(hc, device); 307 addr = 7; 308 printf("[usb_hub] addres of newly created hub = %d\n", addr); 255 309 /*if(addr<0){ 256 310 //return result; 257 311 258 312 }*/ 313 259 314 result->device = usb_new(usb_hcd_attached_device_info_t); 260 result->device->address=addr; 261 //hub configuration? 315 result->device->address = addr; 316 317 // get hub descriptor 318 usb_target_t target; 319 target.address = addr; 320 target.endpoint = 0; 321 usb_device_request_setup_packet_t request; 322 usb_hub_get_descriptor_request(&request); 323 void * serialized_descriptor = malloc(USB_HUB_MAX_DESCRIPTOR_SIZE); 324 usb_hub_descriptor_t * descriptor; 325 size_t received_size; 326 int opResult; 327 328 opResult = usb_drv_sync_control_read( 329 hc, target, &request, serialized_descriptor, 330 USB_HUB_MAX_DESCRIPTOR_SIZE, &received_size); 331 if (opResult != EOK) { 332 printf("[usb_hub] failed when receiving hub descriptor \n"); 333 } 334 descriptor = usb_deserialize_hub_desriptor(serialized_descriptor); 335 result->port_count = descriptor->ports_count; 336 free(serialized_descriptor); 337 free(descriptor); 338 339 //finish 340 262 341 printf("[usb_hub] hub info created\n"); 263 342 264 265 266 343 return result; 267 344 } … … 283 360 284 361 //create the hub structure 285 usb_hub_info_t * hub_info = usb_create_hub_info(dev); 362 //get hc connection 363 /// \TODO correct params 364 int hc = usb_drv_hc_connect(NULL, 0); 365 366 usb_hub_info_t * hub_info = usb_create_hub_info(dev, hc); 367 int port; 368 int opResult; 369 usb_device_request_setup_packet_t request; 370 usb_target_t target; 371 target.address = hub_info->device->address; 372 target.endpoint = 0; 373 for (port = 0; port < hub_info->port_count; ++port) { 374 usb_hub_set_power_port_request(&request, port); 375 opResult = usb_drv_sync_control_write(hc, target, &request, NULL, 0); 376 if (opResult != EOK) { 377 printf("[usb_hub]something went wrong when setting hub`s %dth port\n", port); 378 } 379 } 380 //ports powered, hub seems to be enabled 381 382 ipc_hangup(hc); 383 384 //add the hub to list 286 385 usb_lst_append(&usb_hub_list, hub_info); 287 386 printf("[usb_hub] hub info added to list\n"); 288 387 //(void)hub_info; 289 388 check_hub_changes(); 389 390 /// \TODO start the check loop, if not already started... 391 392 //this is just a test for port status bitmap type 393 usb_hub_test_port_status(); 394 290 395 printf("[usb_hub] hub dev added\n"); 291 //test port status type...292 396 293 397 return EOK; … … 295 399 } 296 400 297 298 401 //********************************************* 402 // 403 // hub driver code, main loop 404 // 405 //********************************************* 406 407 /** 408 * reset the port with new device and reserve the default address 409 * @param hc 410 * @param port 411 * @param target 412 */ 413 414 static void usb_hub_init_add_device(int hc, uint16_t port, usb_target_t target) { 415 usb_device_request_setup_packet_t request; 416 int opResult; 417 printf("[usb_hub] some connection changed\n"); 418 opResult = usb_drv_reserve_default_address(hc); 419 if (opResult != EOK) { 420 printf("[usb_hub] cannot assign default address, it is probably used\n"); 421 } 422 //reset port 423 usb_hub_set_reset_port_request(&request, port); 424 opResult = usb_drv_sync_control_write( 425 hc, target, 426 &request, 427 NULL, 0 428 ); 429 if (opResult != EOK) { 430 //continue; 431 printf("[usb_hub] something went wrong when reseting a port\n"); 432 } 433 } 434 435 /** 436 * finalize adding new device after port reset 437 * @param hc 438 * @param port 439 * @param target 440 */ 441 static void usb_hub_finalize_add_device( 442 int hc, uint16_t port, usb_target_t target) { 443 444 usb_device_request_setup_packet_t request; 445 int opResult; 446 printf("[usb_hub] finalizing add device\n"); 447 usb_address_t new_device_address = 448 usb_drv_request_address(hc); 449 usb_hub_set_set_address_request 450 (&request, new_device_address); 451 opResult = usb_drv_sync_control_write( 452 hc, target, 453 &request, 454 NULL, 0 455 ); 456 if (opResult != EOK) { 457 printf("[usb_hub] could not set address for new device\n"); 458 } 459 usb_drv_release_default_address(hc); 460 461 462 /// \TODO driver work 463 } 464 465 /** 466 * unregister device address in hc, close the port 467 * @param hc 468 * @param port 469 * @param target 470 */ 471 static void usb_hub_removed_device(int hc, uint16_t port, usb_target_t target) { 472 usb_device_request_setup_packet_t request; 473 int opResult; 474 //disable port 475 usb_hub_set_disable_port_request(&request, port); 476 opResult = usb_drv_sync_control_write( 477 hc, target, 478 &request, 479 NULL, 0 480 ); 481 if (opResult != EOK) { 482 //continue; 483 printf("[usb_hub] something went wrong when disabling a port\n"); 484 } 485 //remove device 486 //close address 487 // 488 489 ///\TODO this code is not complete 490 } 491 492 /** 493 * process interrupts on given hub port 494 * @param hc 495 * @param port 496 * @param target 497 */ 498 static void usb_hub_process_interrupt(int hc, uint16_t port, usb_target_t target) { 499 printf("[usb_hub] interrupt at port %d\n", port); 500 //determine type of change 501 usb_port_status_t status; 502 size_t rcvd_size; 503 usb_device_request_setup_packet_t request; 504 int opResult; 505 usb_hub_set_port_status_request(&request, port); 506 507 opResult = usb_drv_sync_control_read( 508 hc, target, 509 &request, 510 &status, 4, &rcvd_size 511 ); 512 if (opResult != EOK) { 513 printf("[usb_hub] ERROR: could not get port status\n"); 514 return; 515 } 516 if (rcvd_size != sizeof (usb_port_status_t)) { 517 printf("[usb_hub] ERROR: received status has incorrect size\n"); 518 return; 519 } 520 //something connected/disconnected 521 if (usb_port_connect_change(&status)) { 522 if (usb_port_dev_connected(&status)) { 523 printf("[usb_hub] some connection changed\n"); 524 usb_hub_init_add_device(hc, port, target); 525 } else { 526 usb_hub_removed_device(hc, port, target); 527 } 528 } 529 //port reset 530 if (usb_port_reset_completed(&status)) { 531 printf("[usb_hub] finalizing add device\n"); 532 if (usb_port_enabled(&status)) { 533 usb_hub_finalize_add_device(hc, port, target); 534 } else { 535 printf("[usb_hub] ERROR: port reset, but port still not enabled\n"); 536 } 537 } 538 539 usb_port_set_connect_change(&status, false); 540 usb_port_set_reset(&status, false); 541 usb_port_set_reset_completed(&status, false); 542 usb_port_set_dev_connected(&status, false); 543 if (status) { 544 printf("[usb_hub]there was some unsupported change on port\n"); 545 } 546 /// \TODO handle other changes 547 /// \TODO debug log for various situations 548 549 550 551 /* 552 //configure device 553 usb_drv_reserve_default_address(hc); 554 555 usb_address_t new_device_address = usb_drv_request_address(hc); 556 557 558 usb_drv_release_default_address(hc); 559 * */ 560 } 299 561 300 562 /** Check changes on all known hubs. … … 306 568 usb_general_list_t * lst_item; 307 569 for (lst_item = usb_hub_list.next; 308 309 570 lst_item != &usb_hub_list; 571 lst_item = lst_item->next) { 310 572 printf("[usb_hub] checking hub changes\n"); 311 573 /* 312 574 * Check status change pipe of this hub. 313 575 */ 314 576 315 577 usb_target_t target = { 316 578 .address = 5, … … 327 589 /// \FIXME this is incorrect code: here 328 590 /// must be used particular device instead of NULL 591 //which one? 329 592 int hc = usb_drv_hc_connect(NULL, 0); 330 593 if (hc < 0) { … … 348 611 usb_drv_async_wait_for(handle); 349 612 350 if (opResult!=EOK){613 if (opResult != EOK) { 351 614 printf("[usb_hub] something went wrong while getting status of hub\n"); 352 615 continue; 353 616 } 354 617 unsigned int port; 355 for(port=0;port<port_count;++port){ 356 bool interrupt = (((uint8_t*)change_bitmap)[port/8]>>(port%8))%2; 357 if(interrupt){ 358 printf("[usb_hub] interrupt at port %d\n",port); 359 //determine type of change 360 usb_port_status_t status; 361 size_t rcvd_size; 362 usb_device_request_setup_packet_t request; 363 usb_hub_set_port_status_request(&request,port); 364 365 opResult = usb_drv_sync_control_read( 366 hc, target, 367 &request, 368 &status, 4, &rcvd_size 369 ); 370 if(opResult!=EOK){ 371 continue; 372 } 373 if(rcvd_size!=sizeof(usb_port_status_t)){ 374 continue; 375 } 376 377 if(usb_port_connect_change(&status)){ 378 printf("[usb_hub] some connectionchanged\n"); 379 usb_drv_reserve_default_address(hc); 380 //enable port 381 usb_hub_set_enable_port_request(&request,port); 382 opResult = usb_drv_sync_control_write( 383 hc, target, 384 &request, 385 NULL, 0 386 ); 387 if(opResult!=EOK){ 388 continue; 389 } 390 //set address 391 usb_address_t new_device_address = 392 usb_drv_request_address(hc); 393 usb_hub_set_set_address_request 394 (&request,new_device_address); 395 opResult = usb_drv_sync_control_write( 396 hc, target, 397 &request, 398 NULL, 0 399 ); 400 //some other work with drivers 401 /// \TODO do the work with drivers 402 403 404 usb_drv_release_default_address(hc); 405 }else{ 406 printf("[usb_hub] no supported event occured\n"); 407 } 408 /// \TODO handle other changes 409 /// \TODO debug log for various situations 410 411 412 413 /* 414 //configure device 415 usb_drv_reserve_default_address(hc); 416 417 usb_address_t new_device_address = usb_drv_request_address(hc); 418 419 420 usb_drv_release_default_address(hc); 421 * */ 618 for (port = 0; port < port_count; ++port) { 619 bool interrupt = (((uint8_t*) change_bitmap)[port / 8] >> (port % 8)) % 2; 620 if (interrupt) { 621 usb_hub_process_interrupt(hc, port, target); 422 622 } 423 623 } -
uspace/drv/vhc/hub.c
rb5ec347 r98d06b8 161 161 162 162 usbvirt_connect_local(&virthub_dev); 163 164 virthub_dev.address = 7; 163 165 164 166 dprintf(1, "virtual hub (%d ports) created", HUB_PORT_COUNT);
Note:
See TracChangeset
for help on using the changeset viewer.