Changeset 195890b in mainline for uspace/drv/ohci/root_hub.c
- Timestamp:
- 2011-04-03T21:39:28Z (13 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade
- Children:
- 3bb6b35
- Parents:
- 6c399765
- File:
-
- 1 edited
-
uspace/drv/ohci/root_hub.c (modified) (33 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/drv/ohci/root_hub.c
r6c399765 r195890b 47 47 * standart device descriptor for ohci root hub 48 48 */ 49 static const usb_standard_device_descriptor_t ohci_rh_device_descriptor = 50 { 51 .configuration_count = 1, 52 .descriptor_type = USB_DESCTYPE_DEVICE, 53 .device_class = USB_CLASS_HUB, 54 .device_protocol = 0, 55 .device_subclass = 0, 56 .device_version = 0, 57 .length = sizeof(usb_standard_device_descriptor_t), 58 /// \TODO this value is guessed 59 .max_packet_size = 8, 60 .vendor_id = 0x16db, 61 .product_id = 0x0001, 62 /// \TODO these values migt be different 63 .str_serial_number = 0, 64 .usb_spec_version = 0x110, 49 static const usb_standard_device_descriptor_t ohci_rh_device_descriptor = { 50 .configuration_count = 1, 51 .descriptor_type = USB_DESCTYPE_DEVICE, 52 .device_class = USB_CLASS_HUB, 53 .device_protocol = 0, 54 .device_subclass = 0, 55 .device_version = 0, 56 .length = sizeof (usb_standard_device_descriptor_t), 57 /// \TODO this value is guessed 58 .max_packet_size = 8, 59 .vendor_id = 0x16db, 60 .product_id = 0x0001, 61 /// \TODO these values migt be different 62 .str_serial_number = 0, 63 .usb_spec_version = 0x110, 65 64 }; 66 65 … … 69 68 * for ohci root hubs 70 69 */ 71 static const usb_standard_configuration_descriptor_t ohci_rh_conf_descriptor = 72 { 70 static const usb_standard_configuration_descriptor_t ohci_rh_conf_descriptor = { 73 71 /// \TODO some values are default or guessed 74 .attributes = 1 <<7,72 .attributes = 1 << 7, 75 73 .configuration_number = 1, 76 74 .descriptor_type = USB_DESCTYPE_CONFIGURATION, 77 75 .interface_count = 1, 78 .length = sizeof (usb_standard_configuration_descriptor_t),76 .length = sizeof (usb_standard_configuration_descriptor_t), 79 77 .max_power = 100, 80 78 .str_configuration = 0, … … 84 82 * standart ohci root hub interface descriptor 85 83 */ 86 static const usb_standard_interface_descriptor_t ohci_rh_iface_descriptor = 87 { 84 static const usb_standard_interface_descriptor_t ohci_rh_iface_descriptor = { 88 85 .alternate_setting = 0, 89 86 .descriptor_type = USB_DESCTYPE_INTERFACE, … … 94 91 .interface_protocol = 0, 95 92 .interface_subclass = 0, 96 .length = sizeof (usb_standard_interface_descriptor_t),93 .length = sizeof (usb_standard_interface_descriptor_t), 97 94 .str_interface = 0, 98 95 }; … … 101 98 * standart ohci root hub endpoint descriptor 102 99 */ 103 static const usb_standard_endpoint_descriptor_t ohci_rh_ep_descriptor = 104 { 100 static const usb_standard_endpoint_descriptor_t ohci_rh_ep_descriptor = { 105 101 .attributes = USB_TRANSFER_INTERRUPT, 106 102 .descriptor_type = USB_DESCTYPE_ENDPOINT, 107 .endpoint_address = 1 + (1 <<7),108 .length = sizeof (usb_standard_endpoint_descriptor_t),103 .endpoint_address = 1 + (1 << 7), 104 .length = sizeof (usb_standard_endpoint_descriptor_t), 109 105 .max_packet_size = 8, 110 106 .poll_interval = 255, … … 113 109 static const uint32_t hub_clear_feature_valid_mask = 114 110 (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER) + 115 111 (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT); 116 112 117 113 static const uint32_t hub_clear_feature_by_writing_one_mask = … … 121 117 (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT); 122 118 123 119 124 120 static const uint32_t hub_set_feature_direct_mask = 125 121 (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT); … … 127 123 static const uint32_t port_set_feature_valid_mask = 128 124 (1 << USB_HUB_FEATURE_PORT_ENABLE) + 129 130 131 125 (1 << USB_HUB_FEATURE_PORT_SUSPEND) + 126 (1 << USB_HUB_FEATURE_PORT_RESET) + 127 (1 << USB_HUB_FEATURE_PORT_POWER); 132 128 133 129 static const uint32_t port_clear_feature_valid_mask = 134 130 (1 << USB_HUB_FEATURE_PORT_CONNECTION) + 135 (1 << USB_HUB_FEATURE_PORT_SUSPEND) + 136 (1 << USB_HUB_FEATURE_PORT_OVER_CURRENT) + 137 (1 << USB_HUB_FEATURE_PORT_POWER) + 138 (1 << USB_HUB_FEATURE_C_PORT_CONNECTION) + 139 (1 << USB_HUB_FEATURE_C_PORT_ENABLE) + 140 (1 << USB_HUB_FEATURE_C_PORT_SUSPEND) + 141 (1 << USB_HUB_FEATURE_C_PORT_OVER_CURRENT) + 142 (1 << USB_HUB_FEATURE_C_PORT_RESET); 143 //note that USB_HUB_FEATURE_PORT_POWER bit is translated into USB_HUB_FEATURE_PORT_LOW_SPEED 144 145 146 131 (1 << USB_HUB_FEATURE_PORT_SUSPEND) + 132 (1 << USB_HUB_FEATURE_PORT_OVER_CURRENT) + 133 (1 << USB_HUB_FEATURE_PORT_POWER) + 134 (1 << USB_HUB_FEATURE_C_PORT_CONNECTION) + 135 (1 << USB_HUB_FEATURE_C_PORT_ENABLE) + 136 (1 << USB_HUB_FEATURE_C_PORT_SUSPEND) + 137 (1 << USB_HUB_FEATURE_C_PORT_OVER_CURRENT) + 138 (1 << USB_HUB_FEATURE_C_PORT_RESET); 139 //note that USB_HUB_FEATURE_PORT_POWER bit is translated into 140 //USB_HUB_FEATURE_PORT_LOW_SPEED 141 142 static void usb_create_serialized_hub_descriptor(rh_t *instance, 143 uint8_t ** out_result, 144 size_t * out_size); 145 146 static void rh_init_descriptors(rh_t *instance); 147 148 static int process_get_port_status_request(rh_t *instance, uint16_t port, 149 usb_transfer_batch_t * request); 150 151 static int process_get_hub_status_request(rh_t *instance, 152 usb_transfer_batch_t * request); 153 154 static int process_get_status_request(rh_t *instance, 155 usb_transfer_batch_t * request); 156 157 static void create_interrupt_mask(rh_t *instance, void ** buffer, 158 size_t * buffer_size); 159 160 static int process_get_descriptor_request(rh_t *instance, 161 usb_transfer_batch_t *request); 162 163 static int process_get_configuration_request(rh_t *instance, 164 usb_transfer_batch_t *request); 165 166 static int process_hub_feature_set_request(rh_t *instance, uint16_t feature); 167 168 169 static int process_hub_feature_clear_request(rh_t *instance, 170 uint16_t feature); 171 172 static int process_port_feature_set_request(rh_t *instance, 173 uint16_t feature, uint16_t port); 174 175 static int process_port_feature_clear_request(rh_t *instance, 176 uint16_t feature, uint16_t port); 177 178 static int process_address_set_request(rh_t *instance, 179 uint16_t address); 180 181 static int process_request_with_output(rh_t *instance, 182 usb_transfer_batch_t *request); 183 184 static int process_request_with_input(rh_t *instance, 185 usb_transfer_batch_t *request); 186 187 static int process_request_without_data(rh_t *instance, 188 usb_transfer_batch_t *request); 189 190 static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request); 191 192 193 194 195 196 /** Root hub initialization 197 * @return Error code. 198 */ 199 int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs) { 200 assert(instance); 201 //instance->address = -1; 202 instance->registers = regs; 203 instance->device = dev; 204 instance->port_count = instance->registers->rh_desc_a & 0xff; 205 rh_init_descriptors(instance); 206 /// \TODO set port power mode 207 208 209 usb_log_info("OHCI root hub with %d ports.\n", instance->port_count); 210 211 //start generic usb hub driver 212 213 /* TODO: implement */ 214 return EOK; 215 } 216 /*----------------------------------------------------------------------------*/ 217 218 /** 219 * process root hub request 220 * 221 * @param instance root hub instance 222 * @param request structure containing both request and response information 223 * @return error code 224 */ 225 int rh_request(rh_t *instance, usb_transfer_batch_t *request) { 226 assert(instance); 227 assert(request); 228 int opResult; 229 if (request->transfer_type == USB_TRANSFER_CONTROL) { 230 usb_log_info("Root hub got CONTROL packet\n"); 231 opResult = process_ctrl_request(instance, request); 232 } else if (request->transfer_type == USB_TRANSFER_INTERRUPT) { 233 usb_log_info("Root hub got INTERRUPT packet\n"); 234 void * buffer; 235 create_interrupt_mask(instance, &buffer, 236 &(request->transfered_size)); 237 memcpy(request->transport_buffer, buffer, 238 request->transfered_size); 239 opResult = EOK; 240 } else { 241 opResult = EINVAL; 242 } 243 usb_transfer_batch_finish(request, opResult); 244 return EOK; 245 } 246 247 /*----------------------------------------------------------------------------*/ 248 249 250 void rh_interrupt(rh_t *instance) { 251 usb_log_info("Whoa whoa wait, I`m not supposed to receive any " 252 "interrupts, am I?\n"); 253 /* TODO: implement? */ 254 } 255 /*----------------------------------------------------------------------------*/ 147 256 148 257 /** … … 157 266 */ 158 267 static void usb_create_serialized_hub_descriptor(rh_t *instance, 159 160 268 uint8_t ** out_result, 269 size_t * out_size) { 161 270 //base size 162 271 size_t size = 7; 163 272 //variable size according to port count 164 273 size_t var_size = instance->port_count / 8 + 165 274 ((instance->port_count % 8 > 0) ? 1 : 0); 166 275 size += 2 * var_size; 167 276 uint8_t * result = (uint8_t*) malloc(size); 168 bzero(result, size);277 bzero(result, size); 169 278 //size 170 279 result[0] = size; … … 174 283 uint32_t hub_desc_reg = instance->registers->rh_desc_a; 175 284 result[3] = 176 ((hub_desc_reg >> 8) %2) +177 (((hub_desc_reg >> 9) %2) << 1) +178 (((hub_desc_reg >> 10) %2) << 2) +179 (((hub_desc_reg >> 11) %2) << 3) +180 (((hub_desc_reg >> 12) %2) << 4);285 ((hub_desc_reg >> 8) % 2) + 286 (((hub_desc_reg >> 9) % 2) << 1) + 287 (((hub_desc_reg >> 10) % 2) << 2) + 288 (((hub_desc_reg >> 11) % 2) << 3) + 289 (((hub_desc_reg >> 12) % 2) << 4); 181 290 result[4] = 0; 182 291 result[5] = /*descriptor->pwr_on_2_good_time*/ 50; … … 185 294 int port; 186 295 for (port = 1; port <= instance->port_count; ++port) { 187 result[7 + port/8] += 188 ((instance->registers->rh_desc_b >> port)%2) << (port%8); 296 uint8_t is_non_removable = 297 instance->registers->rh_desc_b >> port % 2; 298 result[7 + port / 8] += 299 is_non_removable << (port % 8); 189 300 } 190 301 size_t i; … … 195 306 (*out_size) = size; 196 307 } 197 308 /*----------------------------------------------------------------------------*/ 198 309 199 310 /** initialize hub descriptors … … 203 314 * @instance root hub instance 204 315 */ 205 static void rh_init_descriptors(rh_t *instance) {316 static void rh_init_descriptors(rh_t *instance) { 206 317 memcpy(&instance->descriptors.device, &ohci_rh_device_descriptor, 207 sizeof (ohci_rh_device_descriptor)208 );318 sizeof (ohci_rh_device_descriptor) 319 ); 209 320 usb_standard_configuration_descriptor_t descriptor; 210 memcpy(&descriptor, &ohci_rh_conf_descriptor,211 sizeof(ohci_rh_conf_descriptor));321 memcpy(&descriptor, &ohci_rh_conf_descriptor, 322 sizeof (ohci_rh_conf_descriptor)); 212 323 uint8_t * hub_descriptor; 213 324 size_t hub_desc_size; 214 325 usb_create_serialized_hub_descriptor(instance, &hub_descriptor, 215 326 &hub_desc_size); 216 327 217 328 descriptor.total_length = 218 sizeof(usb_standard_configuration_descriptor_t)+219 sizeof(usb_standard_endpoint_descriptor_t)+220 sizeof(usb_standard_interface_descriptor_t)+221 222 329 sizeof (usb_standard_configuration_descriptor_t) + 330 sizeof (usb_standard_endpoint_descriptor_t) + 331 sizeof (usb_standard_interface_descriptor_t) + 332 hub_desc_size; 333 223 334 uint8_t * full_config_descriptor = 224 225 memcpy(full_config_descriptor, &descriptor, sizeof (descriptor));226 memcpy(full_config_descriptor + sizeof (descriptor),227 &ohci_rh_iface_descriptor, sizeof(ohci_rh_iface_descriptor));228 memcpy(full_config_descriptor + sizeof (descriptor) +229 sizeof(ohci_rh_iface_descriptor),230 &ohci_rh_ep_descriptor, sizeof(ohci_rh_ep_descriptor));231 memcpy(full_config_descriptor + sizeof (descriptor) +232 sizeof(ohci_rh_iface_descriptor) +233 sizeof(ohci_rh_ep_descriptor),234 235 335 (uint8_t*) malloc(descriptor.total_length); 336 memcpy(full_config_descriptor, &descriptor, sizeof (descriptor)); 337 memcpy(full_config_descriptor + sizeof (descriptor), 338 &ohci_rh_iface_descriptor, sizeof (ohci_rh_iface_descriptor)); 339 memcpy(full_config_descriptor + sizeof (descriptor) + 340 sizeof (ohci_rh_iface_descriptor), 341 &ohci_rh_ep_descriptor, sizeof (ohci_rh_ep_descriptor)); 342 memcpy(full_config_descriptor + sizeof (descriptor) + 343 sizeof (ohci_rh_iface_descriptor) + 344 sizeof (ohci_rh_ep_descriptor), 345 hub_descriptor, hub_desc_size); 346 236 347 instance->descriptors.configuration = full_config_descriptor; 237 348 instance->descriptors.configuration_size = descriptor.total_length; 238 349 } 239 240 /** Root hub initialization241 * @return Error code.242 */243 int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs)244 {245 assert(instance);246 //instance->address = -1;247 instance->registers = regs;248 instance->device = dev;249 instance->port_count = instance->registers->rh_desc_a & 0xff;250 rh_init_descriptors(instance);251 /// \TODO set port power mode252 253 254 usb_log_info("OHCI root hub with %d ports.\n", instance->port_count);255 256 //start generic usb hub driver257 258 /* TODO: implement */259 return EOK;260 }261 350 /*----------------------------------------------------------------------------*/ 262 351 … … 272 361 */ 273 362 static int process_get_port_status_request(rh_t *instance, uint16_t port, 274 usb_transfer_batch_t * request){275 if (port<1 || port>instance->port_count)276 return EINVAL; 277 uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;363 usb_transfer_batch_t * request) { 364 if (port < 1 || port > instance->port_count) 365 return EINVAL; 366 uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer; 278 367 request->transfered_size = 4; 279 uint32_buffer[0] = instance->registers->rh_port_status[port - 1];368 uint32_buffer[0] = instance->registers->rh_port_status[port - 1]; 280 369 #if 0 281 370 int i; 282 for (i=0;i<instance->port_count;++i){371 for (i = 0; i < instance->port_count; ++i) { 283 372 usb_log_debug("port status %d,x%x\n", 284 285 373 instance->registers->rh_port_status[i], 374 instance->registers->rh_port_status[i]); 286 375 } 287 376 #endif 288 377 return EOK; 289 378 } 379 /*----------------------------------------------------------------------------*/ 290 380 291 381 /** … … 299 389 */ 300 390 static int process_get_hub_status_request(rh_t *instance, 301 usb_transfer_batch_t * request){302 uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;391 usb_transfer_batch_t * request) { 392 uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer; 303 393 //bits, 0,1,16,17 304 394 request->transfered_size = 4; 305 uint32_t mask = 1 & (1 <<1) & (1<<16) & (1<<17);395 uint32_t mask = 1 & (1 << 1) & (1 << 16) & (1 << 17); 306 396 uint32_buffer[0] = mask & instance->registers->rh_status; 307 397 return EOK; 308 398 } 309 310 399 /*----------------------------------------------------------------------------*/ 311 400 312 401 /** … … 320 409 */ 321 410 static int process_get_status_request(rh_t *instance, 322 usb_transfer_batch_t * request) 323 { 411 usb_transfer_batch_t * request) { 324 412 size_t buffer_size = request->buffer_size; 325 413 usb_device_request_setup_packet_t * request_packet = 326 327 414 (usb_device_request_setup_packet_t*) 415 request->setup_buffer; 328 416 329 417 usb_hub_bm_request_type_t request_type = request_packet->request_type; 330 if (buffer_size<4/*request_packet->length*/){///\TODO418 if (buffer_size < 4/*request_packet->length*/) {///\TODO 331 419 usb_log_warning("requested more data than buffer size\n"); 332 420 return EINVAL; 333 421 } 334 422 335 if (request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS)423 if (request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS) 336 424 return process_get_hub_status_request(instance, request); 337 if(request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS) 338 return process_get_port_status_request(instance, request_packet->index, 339 request); 425 if (request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS) 426 return process_get_port_status_request(instance, 427 request_packet->index, 428 request); 340 429 return ENOTSUP; 341 430 } 431 /*----------------------------------------------------------------------------*/ 342 432 343 433 /** … … 353 443 */ 354 444 static void create_interrupt_mask(rh_t *instance, void ** buffer, 355 size_t * buffer_size){445 size_t * buffer_size) { 356 446 int bit_count = instance->port_count + 1; 357 (*buffer_size) = (bit_count / 8) + ((bit_count %8==0)?0:1);358 447 (*buffer_size) = (bit_count / 8) + ((bit_count % 8 == 0) ? 0 : 1); 448 359 449 (*buffer) = malloc(*buffer_size); 360 uint8_t * bitmap = (uint8_t*) (*buffer);361 uint32_t mask = (1 <<(USB_HUB_FEATURE_C_HUB_LOCAL_POWER+16))362 | (1<<(USB_HUB_FEATURE_C_HUB_OVER_CURRENT+16));363 bzero(bitmap, (*buffer_size));364 if (instance->registers->rh_status & mask){450 uint8_t * bitmap = (uint8_t*) (*buffer); 451 uint32_t mask = (1 << (USB_HUB_FEATURE_C_HUB_LOCAL_POWER + 16)) 452 | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16)); 453 bzero(bitmap, (*buffer_size)); 454 if (instance->registers->rh_status & mask) { 365 455 bitmap[0] = 1; 366 456 } … … 368 458 mask = 0; 369 459 int i; 370 for(i=16;i<=20;++i){ 371 mask += 1<<i; 372 } 373 for(port = 1; port<=instance->port_count;++port){ 374 if(mask & instance->registers->rh_port_status[port-1]){ 375 bitmap[(port)/8] += 1<<(port%8); 376 } 377 } 378 } 379 460 for (i = 16; i <= 20; ++i) { 461 mask += 1 << i; 462 } 463 for (port = 1; port <= instance->port_count; ++port) { 464 if (mask & instance->registers->rh_port_status[port - 1]) { 465 bitmap[(port) / 8] += 1 << (port % 8); 466 } 467 } 468 } 469 /*----------------------------------------------------------------------------*/ 470 380 471 /** 381 472 * create answer to a descriptor request … … 388 479 */ 389 480 static int process_get_descriptor_request(rh_t *instance, 390 usb_transfer_batch_t *request){481 usb_transfer_batch_t *request) { 391 482 usb_device_request_setup_packet_t * setup_request = 392 (usb_device_request_setup_packet_t*)request->setup_buffer;483 (usb_device_request_setup_packet_t*) request->setup_buffer; 393 484 size_t size; 394 485 const void * result_descriptor = NULL; 395 486 const uint16_t setup_request_value = setup_request->value_high; 396 487 //(setup_request->value_low << 8); 397 488 bool del = false; 398 switch (setup_request_value) 399 {400 case USB_DESCTYPE_HUB:{489 switch (setup_request_value) { 490 case USB_DESCTYPE_HUB: 491 { 401 492 uint8_t * descriptor; 402 493 usb_create_serialized_hub_descriptor( 403 494 instance, &descriptor, &size); 404 495 result_descriptor = descriptor; 405 if (result_descriptor) del = true;496 if (result_descriptor) del = true; 406 497 break; 407 498 } 408 case USB_DESCTYPE_DEVICE: { 499 case USB_DESCTYPE_DEVICE: 500 { 409 501 usb_log_debug("USB_DESCTYPE_DEVICE\n"); 410 502 result_descriptor = &ohci_rh_device_descriptor; 411 size = sizeof (ohci_rh_device_descriptor);503 size = sizeof (ohci_rh_device_descriptor); 412 504 break; 413 505 } 414 case USB_DESCTYPE_CONFIGURATION: { 506 case USB_DESCTYPE_CONFIGURATION: 507 { 415 508 usb_log_debug("USB_DESCTYPE_CONFIGURATION\n"); 416 509 result_descriptor = instance->descriptors.configuration; … … 418 511 break; 419 512 } 420 case USB_DESCTYPE_INTERFACE: { 513 case USB_DESCTYPE_INTERFACE: 514 { 421 515 usb_log_debug("USB_DESCTYPE_INTERFACE\n"); 422 516 result_descriptor = &ohci_rh_iface_descriptor; 423 size = sizeof (ohci_rh_iface_descriptor);517 size = sizeof (ohci_rh_iface_descriptor); 424 518 break; 425 519 } 426 case USB_DESCTYPE_ENDPOINT: { 520 case USB_DESCTYPE_ENDPOINT: 521 { 427 522 usb_log_debug("USB_DESCTYPE_ENDPOINT\n"); 428 523 result_descriptor = &ohci_rh_ep_descriptor; 429 size = sizeof (ohci_rh_ep_descriptor);524 size = sizeof (ohci_rh_ep_descriptor); 430 525 break; 431 526 } 432 default: { 433 usb_log_debug("USB_DESCTYPE_EINVAL %d \n",setup_request->value); 434 usb_log_debug("\ttype %d\n\trequest %d\n\tvalue %d\n\tindex %d\n\tlen %d\n ", 435 setup_request->request_type, 436 setup_request->request, 437 setup_request_value, 438 setup_request->index, 439 setup_request->length 440 ); 527 default: 528 { 529 usb_log_debug("USB_DESCTYPE_EINVAL %d \n", 530 setup_request->value); 531 usb_log_debug("\ttype %d\n\trequest %d\n\tvalue " 532 "%d\n\tindex %d\n\tlen %d\n ", 533 setup_request->request_type, 534 setup_request->request, 535 setup_request_value, 536 setup_request->index, 537 setup_request->length 538 ); 441 539 return EINVAL; 442 540 } 443 541 } 444 if (request->buffer_size < size){542 if (request->buffer_size < size) { 445 543 size = request->buffer_size; 446 544 } 447 545 request->transfered_size = size; 448 memcpy(request->transport_buffer, result_descriptor,size);546 memcpy(request->transport_buffer, result_descriptor, size); 449 547 if (del) 450 548 free(result_descriptor); 451 549 return EOK; 452 550 } 551 /*----------------------------------------------------------------------------*/ 453 552 454 553 /** … … 460 559 * @return error code 461 560 */ 462 static int process_get_configuration_request(rh_t *instance, 463 usb_transfer_batch_t *request){561 static int process_get_configuration_request(rh_t *instance, 562 usb_transfer_batch_t *request) { 464 563 //set and get configuration requests do not have any meaning, only dummy 465 564 //values are returned 466 if (request->buffer_size != 1)565 if (request->buffer_size != 1) 467 566 return EINVAL; 468 567 request->transport_buffer[0] = 1; … … 470 569 return EOK; 471 570 } 571 /*----------------------------------------------------------------------------*/ 472 572 473 573 /** 474 574 * process feature-enabling request on hub 475 * 575 * 476 576 * @param instance root hub instance 477 577 * @param feature feature selector … … 479 579 */ 480 580 static int process_hub_feature_set_request(rh_t *instance, 481 uint16_t feature){482 if (! ((1<<feature) & hub_set_feature_valid_mask))581 uint16_t feature) { 582 if (!((1 << feature) & hub_set_feature_valid_mask)) 483 583 return EINVAL; 484 584 instance->registers->rh_status = 485 (instance->registers->rh_status | (1<<feature)) 486 & (~ hub_clear_feature_by_writing_one_mask); 487 return EOK; 488 } 585 (instance->registers->rh_status | (1 << feature)) 586 & (~hub_clear_feature_by_writing_one_mask); 587 return EOK; 588 } 589 /*----------------------------------------------------------------------------*/ 489 590 490 591 /** … … 496 597 */ 497 598 static int process_hub_feature_clear_request(rh_t *instance, 498 uint16_t feature){499 if (! ((1<<feature) & hub_clear_feature_valid_mask))599 uint16_t feature) { 600 if (!((1 << feature) & hub_clear_feature_valid_mask)) 500 601 return EINVAL; 501 602 //is the feature cleared directly? 502 if ((1 <<feature) & hub_set_feature_direct_mask){603 if ((1 << feature) & hub_set_feature_direct_mask) { 503 604 instance->registers->rh_status = 504 (instance->registers->rh_status & (~(1 <<feature)))505 & (~ 506 } else{//the feature is cleared by writing '1'605 (instance->registers->rh_status & (~(1 << feature))) 606 & (~hub_clear_feature_by_writing_one_mask); 607 } else {//the feature is cleared by writing '1' 507 608 instance->registers->rh_status = 508 (instance->registers->rh_status 509 & (~ hub_clear_feature_by_writing_one_mask)) 510 | (1<<feature); 511 } 512 return EOK; 513 } 514 515 609 (instance->registers->rh_status 610 & (~hub_clear_feature_by_writing_one_mask)) 611 | (1 << feature); 612 } 613 return EOK; 614 } 615 /*----------------------------------------------------------------------------*/ 516 616 517 617 /** 518 618 * process feature-enabling request on hub 519 * 619 * 520 620 * @param instance root hub instance 521 621 * @param feature feature selector … … 525 625 */ 526 626 static int process_port_feature_set_request(rh_t *instance, 527 uint16_t feature, uint16_t port){528 if (!((1<<feature) & port_set_feature_valid_mask))529 return EINVAL; 530 if (port<1 || port>instance->port_count)627 uint16_t feature, uint16_t port) { 628 if (!((1 << feature) & port_set_feature_valid_mask)) 629 return EINVAL; 630 if (port < 1 || port > instance->port_count) 531 631 return EINVAL; 532 632 instance->registers->rh_port_status[port - 1] = 533 (instance->registers->rh_port_status[port - 1] | (1<<feature))534 633 (instance->registers->rh_port_status[port - 1] | (1 << feature)) 634 & (~port_clear_feature_valid_mask); 535 635 /// \TODO any error? 536 636 return EOK; 537 637 } 638 /*----------------------------------------------------------------------------*/ 538 639 539 640 /** … … 547 648 */ 548 649 static int process_port_feature_clear_request(rh_t *instance, 549 uint16_t feature, uint16_t port){550 if (!((1<<feature) & port_clear_feature_valid_mask))551 return EINVAL; 552 if (port<1 || port>instance->port_count)553 return EINVAL; 554 if (feature == USB_HUB_FEATURE_PORT_POWER)650 uint16_t feature, uint16_t port) { 651 if (!((1 << feature) & port_clear_feature_valid_mask)) 652 return EINVAL; 653 if (port < 1 || port > instance->port_count) 654 return EINVAL; 655 if (feature == USB_HUB_FEATURE_PORT_POWER) 555 656 feature = USB_HUB_FEATURE_PORT_LOW_SPEED; 556 if (feature == USB_HUB_FEATURE_PORT_SUSPEND)657 if (feature == USB_HUB_FEATURE_PORT_SUSPEND) 557 658 feature = USB_HUB_FEATURE_PORT_OVER_CURRENT; 558 659 instance->registers->rh_port_status[port - 1] = 559 (instance->registers->rh_port_status[port - 1]560 561 | (1<<feature);660 (instance->registers->rh_port_status[port - 1] 661 & (~port_clear_feature_valid_mask)) 662 | (1 << feature); 562 663 /// \TODO any error? 563 664 return EOK; 564 665 } 565 666 /*----------------------------------------------------------------------------*/ 566 667 567 668 /** 568 669 * register address to this device 569 * 670 * 570 671 * @param instance root hub instance 571 672 * @param address new address … … 573 674 */ 574 675 static int process_address_set_request(rh_t *instance, 575 uint16_t address){676 uint16_t address) { 576 677 instance->address = address; 577 678 return EOK; 578 679 } 680 /*----------------------------------------------------------------------------*/ 579 681 580 682 /** … … 588 690 */ 589 691 static int process_request_with_output(rh_t *instance, 590 usb_transfer_batch_t *request){692 usb_transfer_batch_t *request) { 591 693 usb_device_request_setup_packet_t * setup_request = 592 (usb_device_request_setup_packet_t*)request->setup_buffer;593 if (setup_request->request == USB_DEVREQ_GET_STATUS){694 (usb_device_request_setup_packet_t*) request->setup_buffer; 695 if (setup_request->request == USB_DEVREQ_GET_STATUS) { 594 696 usb_log_debug("USB_DEVREQ_GET_STATUS\n"); 595 697 return process_get_status_request(instance, request); 596 698 } 597 if (setup_request->request == USB_DEVREQ_GET_DESCRIPTOR){699 if (setup_request->request == USB_DEVREQ_GET_DESCRIPTOR) { 598 700 usb_log_debug("USB_DEVREQ_GET_DESCRIPTOR\n"); 599 701 return process_get_descriptor_request(instance, request); 600 702 } 601 if (setup_request->request == USB_DEVREQ_GET_CONFIGURATION){703 if (setup_request->request == USB_DEVREQ_GET_CONFIGURATION) { 602 704 usb_log_debug("USB_DEVREQ_GET_CONFIGURATION\n"); 603 705 return process_get_configuration_request(instance, request); … … 605 707 return ENOTSUP; 606 708 } 709 /*----------------------------------------------------------------------------*/ 607 710 608 711 /** … … 616 719 */ 617 720 static int process_request_with_input(rh_t *instance, 618 usb_transfer_batch_t *request){721 usb_transfer_batch_t *request) { 619 722 usb_device_request_setup_packet_t * setup_request = 620 (usb_device_request_setup_packet_t*)request->setup_buffer;723 (usb_device_request_setup_packet_t*) request->setup_buffer; 621 724 request->transfered_size = 0; 622 if (setup_request->request == USB_DEVREQ_SET_DESCRIPTOR){725 if (setup_request->request == USB_DEVREQ_SET_DESCRIPTOR) { 623 726 return ENOTSUP; 624 727 } 625 if (setup_request->request == USB_DEVREQ_SET_CONFIGURATION){728 if (setup_request->request == USB_DEVREQ_SET_CONFIGURATION) { 626 729 //set and get configuration requests do not have any meaning, 627 730 //only dummy values are returned … … 630 733 return ENOTSUP; 631 734 } 735 /*----------------------------------------------------------------------------*/ 632 736 633 737 /** … … 641 745 */ 642 746 static int process_request_without_data(rh_t *instance, 643 usb_transfer_batch_t *request){747 usb_transfer_batch_t *request) { 644 748 usb_device_request_setup_packet_t * setup_request = 645 (usb_device_request_setup_packet_t*)request->setup_buffer;749 (usb_device_request_setup_packet_t*) request->setup_buffer; 646 750 request->transfered_size = 0; 647 if (setup_request->request == USB_DEVREQ_CLEAR_FEATURE){648 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE){751 if (setup_request->request == USB_DEVREQ_CLEAR_FEATURE) { 752 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE) { 649 753 usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n"); 650 754 return process_hub_feature_clear_request(instance, 651 652 } 653 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE){755 setup_request->value); 756 } 757 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE) { 654 758 usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n"); 655 759 return process_port_feature_clear_request(instance, 656 657 760 setup_request->value, 761 setup_request->index); 658 762 } 659 763 usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n", 660 661 return EINVAL; 662 } 663 if (setup_request->request == USB_DEVREQ_SET_FEATURE){664 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE){764 setup_request->request_type); 765 return EINVAL; 766 } 767 if (setup_request->request == USB_DEVREQ_SET_FEATURE) { 768 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE) { 665 769 usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n"); 666 770 return process_hub_feature_set_request(instance, 667 668 } 669 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE){771 setup_request->value); 772 } 773 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE) { 670 774 usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n"); 671 775 return process_port_feature_set_request(instance, 672 setup_request->value, 673 setup_request->index); 674 } 675 usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",setup_request->request_type); 676 return EINVAL; 677 } 678 if(setup_request->request == USB_DEVREQ_SET_ADDRESS){ 776 setup_request->value, 777 setup_request->index); 778 } 779 usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n", 780 setup_request->request_type); 781 return EINVAL; 782 } 783 if (setup_request->request == USB_DEVREQ_SET_ADDRESS) { 679 784 usb_log_debug("USB_DEVREQ_SET_ADDRESS\n"); 680 return process_address_set_request(instance, setup_request->value); 681 } 682 usb_log_debug("USB_DEVREQ_SET_ENOTSUP %d\n",setup_request->request_type); 785 return process_address_set_request(instance, 786 setup_request->value); 787 } 788 usb_log_debug("USB_DEVREQ_SET_ENOTSUP %d\n", 789 setup_request->request_type); 683 790 return ENOTSUP; 684 791 } 792 /*----------------------------------------------------------------------------*/ 685 793 686 794 /** … … 702 810 * @return error code 703 811 */ 704 static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request){ 812 static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request) { 813 if (!request->setup_buffer) { 814 usb_log_error("root hub received empty transaction?"); 815 return EINVAL; 816 } 705 817 int opResult; 706 if ( request->setup_buffer) {707 if(sizeof(usb_device_request_setup_packet_t)>request->setup_size){708 usb_log_error("setup packet too small\n");709 return EINVAL;710 }711 usb_ log_info("CTRL packet: %s.\n",712 usb_debug_str_buffer((const uint8_t *)request->setup_buffer, 8, 8));713 714 (usb_device_request_setup_packet_t*)request->setup_buffer;715 if(716 setup_request->request == USB_DEVREQ_GET_STATUS717 || setup_request->request == USB_DEVREQ_GET_DESCRIPTOR718 || setup_request->request == USB_DEVREQ_GET_CONFIGURATION719 ){818 if (sizeof (usb_device_request_setup_packet_t) > request->setup_size) { 819 usb_log_error("setup packet too small\n"); 820 return EINVAL; 821 } 822 usb_log_info("CTRL packet: %s.\n", 823 usb_debug_str_buffer( 824 (const uint8_t *) request->setup_buffer, 8, 8)); 825 usb_device_request_setup_packet_t * setup_request = 826 (usb_device_request_setup_packet_t*) 827 request->setup_buffer; 828 switch (setup_request->request) { 829 case USB_DEVREQ_GET_STATUS: 830 case USB_DEVREQ_GET_DESCRIPTOR: 831 case USB_DEVREQ_GET_CONFIGURATION: 720 832 usb_log_debug("processing request with output\n"); 721 opResult = process_request_with_output(instance,request); 722 }else if( 723 setup_request->request == USB_DEVREQ_CLEAR_FEATURE 724 || setup_request->request == USB_DEVREQ_SET_FEATURE 725 || setup_request->request == USB_DEVREQ_SET_ADDRESS 726 ){ 727 usb_log_debug("processing request without additional data\n"); 728 opResult = process_request_without_data(instance,request); 729 }else if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR 730 || setup_request->request == USB_DEVREQ_SET_CONFIGURATION 731 ){ 732 usb_log_debug("processing request with input\n"); 733 opResult = process_request_with_input(instance,request); 734 }else{ 735 usb_log_warning("received unsuported request: %d\n", 736 setup_request->request 737 ); 833 opResult = process_request_with_output( 834 instance, request); 835 break; 836 case USB_DEVREQ_CLEAR_FEATURE: 837 case USB_DEVREQ_SET_FEATURE: 838 case USB_DEVREQ_SET_ADDRESS: 839 usb_log_debug("processing request without " 840 "additional data\n"); 841 opResult = process_request_without_data( 842 instance, request); 843 break; 844 case USB_DEVREQ_SET_DESCRIPTOR: 845 case USB_DEVREQ_SET_CONFIGURATION: 846 usb_log_debug("processing request with " 847 "input\n"); 848 opResult = process_request_with_input( 849 instance, request); 850 break; 851 default: 852 usb_log_warning("received unsuported request: " 853 "%d\n", 854 setup_request->request 855 ); 738 856 opResult = ENOTSUP; 739 }740 }else{741 usb_log_error("root hub received empty transaction?");742 opResult = EINVAL;743 857 } 744 858 return opResult; 745 859 } 746 860 747 /** 748 * process root hub request 749 * 750 * @param instance root hub instance 751 * @param request structure containing both request and response information 752 * @return error code 753 */ 754 int rh_request(rh_t *instance, usb_transfer_batch_t *request) 755 { 756 assert(instance); 757 assert(request); 758 int opResult; 759 if(request->transfer_type == USB_TRANSFER_CONTROL){ 760 usb_log_info("Root hub got CONTROL packet\n"); 761 opResult = process_ctrl_request(instance,request); 762 }else if(request->transfer_type == USB_TRANSFER_INTERRUPT){ 763 usb_log_info("Root hub got INTERRUPT packet\n"); 764 void * buffer; 765 create_interrupt_mask(instance, &buffer, 766 &(request->transfered_size)); 767 memcpy(request->transport_buffer,buffer, request->transfered_size); 768 opResult = EOK; 769 }else{ 770 opResult = EINVAL; 771 } 772 usb_transfer_batch_finish(request, opResult); 773 return EOK; 774 } 775 /*----------------------------------------------------------------------------*/ 776 777 778 void rh_interrupt(rh_t *instance) 779 { 780 usb_log_info("Whoa whoa wait, I`m not supposed to receive any interrupts, am I?\n"); 781 /* TODO: implement? */ 782 } 861 862 863 783 864 /** 784 865 * @}
Note:
See TracChangeset
for help on using the changeset viewer.
