Changes in uspace/drv/ohci/root_hub.c [ccbcd895:be11749] in mainline
- File:
-
- 1 edited
-
uspace/drv/ohci/root_hub.c (modified) (31 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/drv/ohci/root_hub.c
rccbcd895 rbe11749 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, … … 112 108 113 109 static const uint32_t hub_clear_feature_valid_mask = 114 (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER) +115 110 (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER) | 111 (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT); 116 112 117 113 static const uint32_t hub_clear_feature_by_writing_one_mask = … … 119 115 120 116 static const uint32_t hub_set_feature_valid_mask = 121 (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT); 122 123 117 (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT) | 118 (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER); 119 120 124 121 static const uint32_t hub_set_feature_direct_mask = 125 122 (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT); 126 123 127 124 static const uint32_t port_set_feature_valid_mask = 128 (1 << USB_HUB_FEATURE_PORT_ENABLE) +129 (1 << USB_HUB_FEATURE_PORT_SUSPEND) + 130 (1 << USB_HUB_FEATURE_PORT_RESET) + 131 125 (1 << USB_HUB_FEATURE_PORT_ENABLE) | 126 (1 << USB_HUB_FEATURE_PORT_SUSPEND) | 127 (1 << USB_HUB_FEATURE_PORT_RESET) | 128 (1 << USB_HUB_FEATURE_PORT_POWER); 132 129 133 130 static const uint32_t port_clear_feature_valid_mask = 134 (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_CONNECTION) | 132 (1 << USB_HUB_FEATURE_PORT_SUSPEND) | 133 (1 << USB_HUB_FEATURE_PORT_OVER_CURRENT) | 134 (1 << USB_HUB_FEATURE_PORT_POWER) | 135 (1 << USB_HUB_FEATURE_C_PORT_CONNECTION) | 136 (1 << USB_HUB_FEATURE_C_PORT_ENABLE) | 137 (1 << USB_HUB_FEATURE_C_PORT_SUSPEND) | 138 (1 << USB_HUB_FEATURE_C_PORT_OVER_CURRENT) | 139 (1 << USB_HUB_FEATURE_C_PORT_RESET); 140 //note that USB_HUB_FEATURE_PORT_POWER bit is translated into 141 //USB_HUB_FEATURE_PORT_LOW_SPEED 142 143 static const uint32_t port_status_change_mask = 144 (1<< USB_HUB_FEATURE_C_PORT_CONNECTION) | 145 (1<< USB_HUB_FEATURE_C_PORT_ENABLE) | 146 (1<< USB_HUB_FEATURE_C_PORT_OVER_CURRENT) | 147 (1<< USB_HUB_FEATURE_C_PORT_RESET) | 148 (1<< USB_HUB_FEATURE_C_PORT_SUSPEND); 149 150 151 static void usb_create_serialized_hub_descriptor(rh_t *instance, 152 uint8_t ** out_result, 153 size_t * out_size); 154 155 static void rh_init_descriptors(rh_t *instance); 156 157 static int process_get_port_status_request(rh_t *instance, uint16_t port, 158 usb_transfer_batch_t * request); 159 160 static int process_get_hub_status_request(rh_t *instance, 161 usb_transfer_batch_t * request); 162 163 static int process_get_status_request(rh_t *instance, 164 usb_transfer_batch_t * request); 165 166 static void create_interrupt_mask(rh_t *instance, void ** buffer, 167 size_t * buffer_size); 168 169 static int process_get_descriptor_request(rh_t *instance, 170 usb_transfer_batch_t *request); 171 172 static int process_get_configuration_request(rh_t *instance, 173 usb_transfer_batch_t *request); 174 175 static int process_hub_feature_set_request(rh_t *instance, uint16_t feature); 176 177 static int process_hub_feature_clear_request(rh_t *instance, 178 uint16_t feature); 179 180 static int process_port_feature_set_request(rh_t *instance, 181 uint16_t feature, uint16_t port); 182 183 static int process_port_feature_clear_request(rh_t *instance, 184 uint16_t feature, uint16_t port); 185 186 static int process_address_set_request(rh_t *instance, 187 uint16_t address); 188 189 static int process_request_with_output(rh_t *instance, 190 usb_transfer_batch_t *request); 191 192 static int process_request_with_input(rh_t *instance, 193 usb_transfer_batch_t *request); 194 195 static int process_request_without_data(rh_t *instance, 196 usb_transfer_batch_t *request); 197 198 static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request); 199 200 static int process_interrupt(rh_t *instance, usb_transfer_batch_t * request, 201 void * change_buffer, size_t buffe_size); 202 203 static bool is_zeros(void * buffer, size_t size); 204 205 206 207 /** Root hub initialization 208 * @return Error code. 209 */ 210 int rh_init(rh_t *instance, ohci_regs_t *regs) { 211 assert(instance); 212 instance->registers = regs; 213 instance->port_count = 214 (instance->registers->rh_desc_a >> RHDA_NDS_SHIFT) & RHDA_NDS_MASK; 215 rh_init_descriptors(instance); 216 // set port power mode to no-power-switching 217 instance->registers->rh_desc_a |= RHDA_NPS_FLAG; 218 instance->unfinished_interrupt_transfer = NULL; 219 usb_log_info("OHCI root hub with %d ports.\n", instance->port_count); 220 return EOK; 221 } 222 /*----------------------------------------------------------------------------*/ 223 224 /** 225 * process root hub request 226 * 227 * @param instance root hub instance 228 * @param request structure containing both request and response information 229 * @return error code 230 */ 231 int rh_request(rh_t *instance, usb_transfer_batch_t *request) { 232 assert(instance); 233 assert(request); 234 int opResult; 235 if (request->ep->transfer_type == USB_TRANSFER_CONTROL) { 236 usb_log_info("Root hub got CONTROL packet\n"); 237 opResult = process_ctrl_request(instance, request); 238 usb_transfer_batch_finish_error(request, opResult); 239 } else if (request->ep->transfer_type == USB_TRANSFER_INTERRUPT) { 240 usb_log_info("Root hub got INTERRUPT packet\n"); 241 void * buffer; 242 size_t buffer_size; 243 create_interrupt_mask(instance, &buffer, 244 &buffer_size); 245 if(is_zeros(buffer,buffer_size)){ 246 usb_log_debug("no changes.."); 247 instance->unfinished_interrupt_transfer= 248 request; 249 //will be finished later 250 }else{ 251 usb_log_debug("processing changes.."); 252 process_interrupt(instance, request, 253 buffer, buffer_size); 254 } 255 free(buffer); 256 opResult = EOK; 257 } else { 258 opResult = EINVAL; 259 usb_transfer_batch_finish_error(request, opResult); 260 } 261 return EOK; 262 } 263 264 /*----------------------------------------------------------------------------*/ 265 266 267 void rh_interrupt(rh_t *instance) { 268 //usb_log_info("Whoa whoa wait, I`m not supposed to receive any " 269 // "interrupts, am I?\n"); 270 if(!instance->unfinished_interrupt_transfer){ 271 return; 272 } 273 size_t size; 274 void * buffer; 275 create_interrupt_mask(instance, &buffer, 276 &size); 277 process_interrupt(instance,instance->unfinished_interrupt_transfer, 278 buffer,size); 279 free(buffer); 280 } 281 /*----------------------------------------------------------------------------*/ 147 282 148 283 /** … … 157 292 */ 158 293 static void usb_create_serialized_hub_descriptor(rh_t *instance, 159 160 294 uint8_t ** out_result, 295 size_t * out_size) { 161 296 //base size 162 297 size_t size = 7; 163 298 //variable size according to port count 164 299 size_t var_size = instance->port_count / 8 + 165 300 ((instance->port_count % 8 > 0) ? 1 : 0); 166 301 size += 2 * var_size; 167 302 uint8_t * result = (uint8_t*) malloc(size); 168 bzero(result, size);303 bzero(result, size); 169 304 //size 170 305 result[0] = size; … … 174 309 uint32_t hub_desc_reg = instance->registers->rh_desc_a; 175 310 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);311 ((hub_desc_reg >> 8) % 2) + 312 (((hub_desc_reg >> 9) % 2) << 1) + 313 (((hub_desc_reg >> 10) % 2) << 2) + 314 (((hub_desc_reg >> 11) % 2) << 3) + 315 (((hub_desc_reg >> 12) % 2) << 4); 181 316 result[4] = 0; 182 317 result[5] = /*descriptor->pwr_on_2_good_time*/ 50; … … 185 320 int port; 186 321 for (port = 1; port <= instance->port_count; ++port) { 187 result[7 + port/8] += 188 ((instance->registers->rh_desc_b >> port)%2) << (port%8); 322 uint8_t is_non_removable = 323 instance->registers->rh_desc_b >> port % 2; 324 result[7 + port / 8] += 325 is_non_removable << (port % 8); 189 326 } 190 327 size_t i; … … 195 332 (*out_size) = size; 196 333 } 197 334 /*----------------------------------------------------------------------------*/ 198 335 199 336 /** initialize hub descriptors … … 203 340 * @instance root hub instance 204 341 */ 205 static void rh_init_descriptors(rh_t *instance) {342 static void rh_init_descriptors(rh_t *instance) { 206 343 memcpy(&instance->descriptors.device, &ohci_rh_device_descriptor, 207 sizeof (ohci_rh_device_descriptor)208 );344 sizeof (ohci_rh_device_descriptor) 345 ); 209 346 usb_standard_configuration_descriptor_t descriptor; 210 memcpy(&descriptor, &ohci_rh_conf_descriptor,211 sizeof(ohci_rh_conf_descriptor));347 memcpy(&descriptor, &ohci_rh_conf_descriptor, 348 sizeof (ohci_rh_conf_descriptor)); 212 349 uint8_t * hub_descriptor; 213 350 size_t hub_desc_size; 214 351 usb_create_serialized_hub_descriptor(instance, &hub_descriptor, 215 352 &hub_desc_size); 216 353 217 354 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 355 sizeof (usb_standard_configuration_descriptor_t) + 356 sizeof (usb_standard_endpoint_descriptor_t) + 357 sizeof (usb_standard_interface_descriptor_t) + 358 hub_desc_size; 359 223 360 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 361 (uint8_t*) malloc(descriptor.total_length); 362 memcpy(full_config_descriptor, &descriptor, sizeof (descriptor)); 363 memcpy(full_config_descriptor + sizeof (descriptor), 364 &ohci_rh_iface_descriptor, sizeof (ohci_rh_iface_descriptor)); 365 memcpy(full_config_descriptor + sizeof (descriptor) + 366 sizeof (ohci_rh_iface_descriptor), 367 &ohci_rh_ep_descriptor, sizeof (ohci_rh_ep_descriptor)); 368 memcpy(full_config_descriptor + sizeof (descriptor) + 369 sizeof (ohci_rh_iface_descriptor) + 370 sizeof (ohci_rh_ep_descriptor), 371 hub_descriptor, hub_desc_size); 372 236 373 instance->descriptors.configuration = full_config_descriptor; 237 374 instance->descriptors.configuration_size = descriptor.total_length; 238 375 } 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 376 /*----------------------------------------------------------------------------*/ 262 377 … … 272 387 */ 273 388 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;389 usb_transfer_batch_t * request) { 390 if (port < 1 || port > instance->port_count) 391 return EINVAL; 392 uint32_t * uint32_buffer = (uint32_t*) request->data_buffer; 278 393 request->transfered_size = 4; 279 uint32_buffer[0] = instance->registers->rh_port_status[port -1]; 280 return EOK; 281 } 394 uint32_buffer[0] = instance->registers->rh_port_status[port - 1]; 395 #if 0 396 int i; 397 for (i = 0; i < instance->port_count; ++i) { 398 usb_log_debug("port status %d,x%x\n", 399 instance->registers->rh_port_status[i], 400 instance->registers->rh_port_status[i]); 401 } 402 #endif 403 return EOK; 404 } 405 /*----------------------------------------------------------------------------*/ 282 406 283 407 /** … … 291 415 */ 292 416 static int process_get_hub_status_request(rh_t *instance, 293 usb_transfer_batch_t * request){ 294 uint32_t * uint32_buffer = (uint32_t*)request->transport_buffer; 417 usb_transfer_batch_t * request) { 418 uint32_t * uint32_buffer = (uint32_t*) request->data_buffer; 419 request->transfered_size = 4; 295 420 //bits, 0,1,16,17 296 request->transfered_size = 4; 297 uint32_t mask = 1 & (1<<1) & (1<<16) & (1<<17); 421 uint32_t mask = 1 | (1 << 1) | (1 << 16) | (1 << 17); 298 422 uint32_buffer[0] = mask & instance->registers->rh_status; 299 423 return EOK; 300 301 } 302 303 424 } 425 /*----------------------------------------------------------------------------*/ 304 426 305 427 /** … … 313 435 */ 314 436 static int process_get_status_request(rh_t *instance, 315 usb_transfer_batch_t * request) 316 { 437 usb_transfer_batch_t * request) { 317 438 size_t buffer_size = request->buffer_size; 318 439 usb_device_request_setup_packet_t * request_packet = 319 320 440 (usb_device_request_setup_packet_t*) 441 request->setup_buffer; 321 442 322 443 usb_hub_bm_request_type_t request_type = request_packet->request_type; 323 if (buffer_size<4/*request_packet->length*/){///\TODO444 if (buffer_size < 4/*request_packet->length*/) {///\TODO 324 445 usb_log_warning("requested more data than buffer size\n"); 325 446 return EINVAL; 326 447 } 327 448 328 if (request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS)449 if (request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS) 329 450 return process_get_hub_status_request(instance, request); 330 if(request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS) 331 return process_get_port_status_request(instance, request_packet->index, 332 request); 451 if (request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS) 452 return process_get_port_status_request(instance, 453 request_packet->index, 454 request); 333 455 return ENOTSUP; 334 456 } 457 /*----------------------------------------------------------------------------*/ 335 458 336 459 /** … … 339 462 * Result contains bitmap where bit 0 indicates change on hub and 340 463 * bit i indicates change on i`th port (i>0). For more info see 341 * Hub and Port status bitmap specification in USB specification. 464 * Hub and Port status bitmap specification in USB specification 465 * (chapter 11.13.4) 342 466 * @param instance root hub instance 343 467 * @param@out buffer pointer to created interrupt mas … … 345 469 */ 346 470 static void create_interrupt_mask(rh_t *instance, void ** buffer, 347 size_t * buffer_size){471 size_t * buffer_size) { 348 472 int bit_count = instance->port_count + 1; 349 (*buffer_size) = (bit_count / 8) + (bit_count%8==0)?0:1; 473 (*buffer_size) = (bit_count / 8) + ((bit_count % 8 == 0) ? 0 : 1); 474 350 475 (*buffer) = malloc(*buffer_size); 351 uint8_t * bitmap = (uint8_t*)(*buffer); 352 uint32_t mask = (1<<16) + (1<<17); 353 bzero(bitmap,(*buffer_size)); 354 if(instance->registers->rh_status & mask){ 476 uint8_t * bitmap = (uint8_t*) (*buffer); 477 uint32_t mask = (1 << (USB_HUB_FEATURE_C_HUB_LOCAL_POWER + 16)) 478 | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16)); 479 bzero(bitmap, (*buffer_size)); 480 if (instance->registers->rh_status & mask) { 355 481 bitmap[0] = 1; 356 482 } 357 483 int port; 358 mask = 0; 359 int i; 360 for(i=16;i<=20;++i) 361 mask += 1<<i; 362 for(port = 1; port<=instance->port_count;++port){ 363 if(mask & instance->registers->rh_port_status[port-1]){ 364 bitmap[(port+1)/8] += 1<<(port%8); 365 } 366 } 367 } 368 484 mask = port_status_change_mask; 485 for (port = 1; port <= instance->port_count; ++port) { 486 if (mask & instance->registers->rh_port_status[port - 1]) { 487 bitmap[(port) / 8] += 1 << (port % 8); 488 } 489 } 490 } 491 /*----------------------------------------------------------------------------*/ 492 369 493 /** 370 494 * create answer to a descriptor request … … 377 501 */ 378 502 static int process_get_descriptor_request(rh_t *instance, 379 usb_transfer_batch_t *request){503 usb_transfer_batch_t *request) { 380 504 usb_device_request_setup_packet_t * setup_request = 381 (usb_device_request_setup_packet_t*)request->setup_buffer;505 (usb_device_request_setup_packet_t*) request->setup_buffer; 382 506 size_t size; 383 507 const void * result_descriptor = NULL; 384 508 const uint16_t setup_request_value = setup_request->value_high; 385 509 //(setup_request->value_low << 8); 386 510 bool del = false; 387 switch (setup_request_value) 388 {389 case USB_DESCTYPE_HUB:{511 switch (setup_request_value) { 512 case USB_DESCTYPE_HUB: 513 { 390 514 uint8_t * descriptor; 391 515 usb_create_serialized_hub_descriptor( 392 516 instance, &descriptor, &size); 393 517 result_descriptor = descriptor; 394 if (result_descriptor) del = true;518 if (result_descriptor) del = true; 395 519 break; 396 520 } 397 case USB_DESCTYPE_DEVICE: { 521 case USB_DESCTYPE_DEVICE: 522 { 398 523 usb_log_debug("USB_DESCTYPE_DEVICE\n"); 399 524 result_descriptor = &ohci_rh_device_descriptor; 400 size = sizeof (ohci_rh_device_descriptor);525 size = sizeof (ohci_rh_device_descriptor); 401 526 break; 402 527 } 403 case USB_DESCTYPE_CONFIGURATION: { 528 case USB_DESCTYPE_CONFIGURATION: 529 { 404 530 usb_log_debug("USB_DESCTYPE_CONFIGURATION\n"); 405 531 result_descriptor = instance->descriptors.configuration; … … 407 533 break; 408 534 } 409 case USB_DESCTYPE_INTERFACE: { 535 case USB_DESCTYPE_INTERFACE: 536 { 410 537 usb_log_debug("USB_DESCTYPE_INTERFACE\n"); 411 538 result_descriptor = &ohci_rh_iface_descriptor; 412 size = sizeof (ohci_rh_iface_descriptor);539 size = sizeof (ohci_rh_iface_descriptor); 413 540 break; 414 541 } 415 case USB_DESCTYPE_ENDPOINT: { 542 case USB_DESCTYPE_ENDPOINT: 543 { 416 544 usb_log_debug("USB_DESCTYPE_ENDPOINT\n"); 417 545 result_descriptor = &ohci_rh_ep_descriptor; 418 size = sizeof (ohci_rh_ep_descriptor);546 size = sizeof (ohci_rh_ep_descriptor); 419 547 break; 420 548 } 421 default: { 422 usb_log_debug("USB_DESCTYPE_EINVAL %d \n",setup_request->value); 423 usb_log_debug("\ttype %d\n\trequest %d\n\tvalue %d\n\tindex %d\n\tlen %d\n ", 424 setup_request->request_type, 425 setup_request->request, 426 setup_request_value, 427 setup_request->index, 428 setup_request->length 429 ); 549 default: 550 { 551 usb_log_debug("USB_DESCTYPE_EINVAL %d \n", 552 setup_request->value); 553 usb_log_debug("\ttype %d\n\trequest %d\n\tvalue " 554 "%d\n\tindex %d\n\tlen %d\n ", 555 setup_request->request_type, 556 setup_request->request, 557 setup_request_value, 558 setup_request->index, 559 setup_request->length 560 ); 430 561 return EINVAL; 431 562 } 432 563 } 433 if (request->buffer_size < size){564 if (request->buffer_size < size) { 434 565 size = request->buffer_size; 435 566 } 436 567 request->transfered_size = size; 437 memcpy(request->transport_buffer,result_descriptor,size); 438 usb_log_debug("sent desctiptor: %s\n", 439 usb_debug_str_buffer((uint8_t*)request->transport_buffer,size,size)); 568 memcpy(request->data_buffer, result_descriptor, size); 440 569 if (del) 441 570 free(result_descriptor); 442 571 return EOK; 443 572 } 573 /*----------------------------------------------------------------------------*/ 444 574 445 575 /** … … 451 581 * @return error code 452 582 */ 453 static int process_get_configuration_request(rh_t *instance, 454 usb_transfer_batch_t *request){583 static int process_get_configuration_request(rh_t *instance, 584 usb_transfer_batch_t *request) { 455 585 //set and get configuration requests do not have any meaning, only dummy 456 586 //values are returned 457 if (request->buffer_size != 1)458 return EINVAL; 459 request-> transport_buffer[0] = 1;587 if (request->buffer_size != 1) 588 return EINVAL; 589 request->data_buffer[0] = 1; 460 590 request->transfered_size = 1; 461 591 return EOK; 462 592 } 593 /*----------------------------------------------------------------------------*/ 463 594 464 595 /** 465 596 * process feature-enabling request on hub 466 * 597 * 467 598 * @param instance root hub instance 468 599 * @param feature feature selector … … 470 601 */ 471 602 static int process_hub_feature_set_request(rh_t *instance, 472 uint16_t feature){ 473 if(! ((1<<feature) & hub_set_feature_valid_mask)) 474 return EINVAL; 603 uint16_t feature) { 604 if (!((1 << feature) & hub_set_feature_valid_mask)) 605 return EINVAL; 606 if(feature == USB_HUB_FEATURE_C_HUB_LOCAL_POWER) 607 feature = USB_HUB_FEATURE_C_HUB_LOCAL_POWER << 16; 475 608 instance->registers->rh_status = 476 (instance->registers->rh_status | (1<<feature)) 477 & (~ hub_clear_feature_by_writing_one_mask); 478 return EOK; 479 } 609 (instance->registers->rh_status | (1 << feature)) 610 & (~hub_clear_feature_by_writing_one_mask); 611 return EOK; 612 } 613 /*----------------------------------------------------------------------------*/ 480 614 481 615 /** … … 487 621 */ 488 622 static int process_hub_feature_clear_request(rh_t *instance, 489 uint16_t feature){490 if (! ((1<<feature) & hub_clear_feature_valid_mask))623 uint16_t feature) { 624 if (!((1 << feature) & hub_clear_feature_valid_mask)) 491 625 return EINVAL; 492 626 //is the feature cleared directly? 493 if ((1 <<feature) & hub_set_feature_direct_mask){627 if ((1 << feature) & hub_set_feature_direct_mask) { 494 628 instance->registers->rh_status = 495 (instance->registers->rh_status & (~(1 <<feature)))496 & (~ 497 } else{//the feature is cleared by writing '1'629 (instance->registers->rh_status & (~(1 << feature))) 630 & (~hub_clear_feature_by_writing_one_mask); 631 } else {//the feature is cleared by writing '1' 498 632 instance->registers->rh_status = 499 (instance->registers->rh_status 500 & (~ hub_clear_feature_by_writing_one_mask)) 501 | (1<<feature); 502 } 503 return EOK; 504 } 505 506 633 (instance->registers->rh_status 634 & (~hub_clear_feature_by_writing_one_mask)) 635 | (1 << feature); 636 } 637 return EOK; 638 } 639 /*----------------------------------------------------------------------------*/ 507 640 508 641 /** 509 642 * process feature-enabling request on hub 510 * 643 * 511 644 * @param instance root hub instance 512 645 * @param feature feature selector … … 516 649 */ 517 650 static int process_port_feature_set_request(rh_t *instance, 518 uint16_t feature, uint16_t port){519 if (!((1<<feature) & port_set_feature_valid_mask))520 return EINVAL; 521 if (port<1 || port>instance->port_count)651 uint16_t feature, uint16_t port) { 652 if (!((1 << feature) & port_set_feature_valid_mask)) 653 return EINVAL; 654 if (port < 1 || port > instance->port_count) 522 655 return EINVAL; 523 656 instance->registers->rh_port_status[port - 1] = 524 (instance->registers->rh_port_status[port - 1] | (1<<feature))525 657 (instance->registers->rh_port_status[port - 1] | (1 << feature)) 658 & (~port_clear_feature_valid_mask); 526 659 /// \TODO any error? 527 660 return EOK; 528 661 } 662 /*----------------------------------------------------------------------------*/ 529 663 530 664 /** … … 538 672 */ 539 673 static int process_port_feature_clear_request(rh_t *instance, 540 uint16_t feature, uint16_t port){541 if (!((1<<feature) & port_clear_feature_valid_mask))542 return EINVAL; 543 if (port<1 || port>instance->port_count)544 return EINVAL; 545 if (feature == USB_HUB_FEATURE_PORT_POWER)674 uint16_t feature, uint16_t port) { 675 if (!((1 << feature) & port_clear_feature_valid_mask)) 676 return EINVAL; 677 if (port < 1 || port > instance->port_count) 678 return EINVAL; 679 if (feature == USB_HUB_FEATURE_PORT_POWER) 546 680 feature = USB_HUB_FEATURE_PORT_LOW_SPEED; 547 if (feature == USB_HUB_FEATURE_PORT_SUSPEND)681 if (feature == USB_HUB_FEATURE_PORT_SUSPEND) 548 682 feature = USB_HUB_FEATURE_PORT_OVER_CURRENT; 549 683 instance->registers->rh_port_status[port - 1] = 550 (instance->registers->rh_port_status[port - 1]551 552 | (1<<feature);684 (instance->registers->rh_port_status[port - 1] 685 & (~port_clear_feature_valid_mask)) 686 | (1 << feature); 553 687 /// \TODO any error? 554 688 return EOK; 555 689 } 556 690 /*----------------------------------------------------------------------------*/ 557 691 558 692 /** 559 693 * register address to this device 560 * 694 * 561 695 * @param instance root hub instance 562 696 * @param address new address … … 564 698 */ 565 699 static int process_address_set_request(rh_t *instance, 566 uint16_t address){700 uint16_t address) { 567 701 instance->address = address; 568 702 return EOK; 569 703 } 704 /*----------------------------------------------------------------------------*/ 570 705 571 706 /** … … 579 714 */ 580 715 static int process_request_with_output(rh_t *instance, 581 usb_transfer_batch_t *request){716 usb_transfer_batch_t *request) { 582 717 usb_device_request_setup_packet_t * setup_request = 583 (usb_device_request_setup_packet_t*)request->setup_buffer;584 if (setup_request->request == USB_DEVREQ_GET_STATUS){718 (usb_device_request_setup_packet_t*) request->setup_buffer; 719 if (setup_request->request == USB_DEVREQ_GET_STATUS) { 585 720 usb_log_debug("USB_DEVREQ_GET_STATUS\n"); 586 721 return process_get_status_request(instance, request); 587 722 } 588 if (setup_request->request == USB_DEVREQ_GET_DESCRIPTOR){723 if (setup_request->request == USB_DEVREQ_GET_DESCRIPTOR) { 589 724 usb_log_debug("USB_DEVREQ_GET_DESCRIPTOR\n"); 590 725 return process_get_descriptor_request(instance, request); 591 726 } 592 if (setup_request->request == USB_DEVREQ_GET_CONFIGURATION){727 if (setup_request->request == USB_DEVREQ_GET_CONFIGURATION) { 593 728 usb_log_debug("USB_DEVREQ_GET_CONFIGURATION\n"); 594 729 return process_get_configuration_request(instance, request); … … 596 731 return ENOTSUP; 597 732 } 733 /*----------------------------------------------------------------------------*/ 598 734 599 735 /** … … 607 743 */ 608 744 static int process_request_with_input(rh_t *instance, 609 usb_transfer_batch_t *request){745 usb_transfer_batch_t *request) { 610 746 usb_device_request_setup_packet_t * setup_request = 611 (usb_device_request_setup_packet_t*)request->setup_buffer;747 (usb_device_request_setup_packet_t*) request->setup_buffer; 612 748 request->transfered_size = 0; 613 if (setup_request->request == USB_DEVREQ_SET_DESCRIPTOR){749 if (setup_request->request == USB_DEVREQ_SET_DESCRIPTOR) { 614 750 return ENOTSUP; 615 751 } 616 if (setup_request->request == USB_DEVREQ_SET_CONFIGURATION){752 if (setup_request->request == USB_DEVREQ_SET_CONFIGURATION) { 617 753 //set and get configuration requests do not have any meaning, 618 754 //only dummy values are returned … … 621 757 return ENOTSUP; 622 758 } 759 /*----------------------------------------------------------------------------*/ 623 760 624 761 /** … … 632 769 */ 633 770 static int process_request_without_data(rh_t *instance, 634 usb_transfer_batch_t *request){771 usb_transfer_batch_t *request) { 635 772 usb_device_request_setup_packet_t * setup_request = 636 (usb_device_request_setup_packet_t*)request->setup_buffer;773 (usb_device_request_setup_packet_t*) request->setup_buffer; 637 774 request->transfered_size = 0; 638 if (setup_request->request == USB_DEVREQ_CLEAR_FEATURE){639 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE){775 if (setup_request->request == USB_DEVREQ_CLEAR_FEATURE) { 776 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE) { 640 777 usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n"); 641 778 return process_hub_feature_clear_request(instance, 642 643 } 644 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE){779 setup_request->value); 780 } 781 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE) { 645 782 usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n"); 646 783 return process_port_feature_clear_request(instance, 647 648 784 setup_request->value, 785 setup_request->index); 649 786 } 650 787 usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n", 651 652 return EINVAL; 653 } 654 if (setup_request->request == USB_DEVREQ_SET_FEATURE){655 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE){788 setup_request->request_type); 789 return EINVAL; 790 } 791 if (setup_request->request == USB_DEVREQ_SET_FEATURE) { 792 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE) { 656 793 usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n"); 657 794 return process_hub_feature_set_request(instance, 658 659 } 660 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE){795 setup_request->value); 796 } 797 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE) { 661 798 usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n"); 662 799 return process_port_feature_set_request(instance, 663 setup_request->value, 664 setup_request->index); 665 } 666 usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",setup_request->request_type); 667 return EINVAL; 668 } 669 if(setup_request->request == USB_DEVREQ_SET_ADDRESS){ 800 setup_request->value, 801 setup_request->index); 802 } 803 usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n", 804 setup_request->request_type); 805 return EINVAL; 806 } 807 if (setup_request->request == USB_DEVREQ_SET_ADDRESS) { 670 808 usb_log_debug("USB_DEVREQ_SET_ADDRESS\n"); 671 return process_address_set_request(instance, setup_request->value); 672 } 673 usb_log_debug("USB_DEVREQ_SET_ENOTSUP %d\n",setup_request->request_type); 809 return process_address_set_request(instance, 810 setup_request->value); 811 } 812 usb_log_debug("USB_DEVREQ_SET_ENOTSUP %d\n", 813 setup_request->request_type); 674 814 return ENOTSUP; 675 815 } 816 /*----------------------------------------------------------------------------*/ 676 817 677 818 /** … … 693 834 * @return error code 694 835 */ 695 static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request){ 836 static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request) { 837 if (!request->setup_buffer) { 838 usb_log_error("root hub received empty transaction?"); 839 return EINVAL; 840 } 696 841 int opResult; 697 if ( request->setup_buffer) {698 if(sizeof(usb_device_request_setup_packet_t)>request->setup_size){699 usb_log_error("setup packet too small\n");700 return EINVAL;701 }702 usb_ log_info("CTRL packet: %s.\n",703 usb_debug_str_buffer((const uint8_t *)request->setup_buffer, 8, 8));704 705 (usb_device_request_setup_packet_t*)request->setup_buffer;706 if(707 setup_request->request == USB_DEVREQ_GET_STATUS708 || setup_request->request == USB_DEVREQ_GET_DESCRIPTOR709 || setup_request->request == USB_DEVREQ_GET_CONFIGURATION710 ){842 if (sizeof (usb_device_request_setup_packet_t) > request->setup_size) { 843 usb_log_error("setup packet too small\n"); 844 return EINVAL; 845 } 846 usb_log_info("CTRL packet: %s.\n", 847 usb_debug_str_buffer( 848 (const uint8_t *) request->setup_buffer, 8, 8)); 849 usb_device_request_setup_packet_t * setup_request = 850 (usb_device_request_setup_packet_t*) 851 request->setup_buffer; 852 switch (setup_request->request) { 853 case USB_DEVREQ_GET_STATUS: 854 case USB_DEVREQ_GET_DESCRIPTOR: 855 case USB_DEVREQ_GET_CONFIGURATION: 711 856 usb_log_debug("processing request with output\n"); 712 opResult = process_request_with_output(instance,request); 713 }else if( 714 setup_request->request == USB_DEVREQ_CLEAR_FEATURE 715 || setup_request->request == USB_DEVREQ_SET_FEATURE 716 || setup_request->request == USB_DEVREQ_SET_ADDRESS 717 ){ 718 usb_log_debug("processing request without additional data\n"); 719 opResult = process_request_without_data(instance,request); 720 }else if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR 721 || setup_request->request == USB_DEVREQ_SET_CONFIGURATION 722 ){ 723 usb_log_debug("processing request with input\n"); 724 opResult = process_request_with_input(instance,request); 725 }else{ 726 usb_log_warning("received unsuported request: %d\n", 727 setup_request->request 728 ); 857 opResult = process_request_with_output( 858 instance, request); 859 break; 860 case USB_DEVREQ_CLEAR_FEATURE: 861 case USB_DEVREQ_SET_FEATURE: 862 case USB_DEVREQ_SET_ADDRESS: 863 usb_log_debug("processing request without " 864 "additional data\n"); 865 opResult = process_request_without_data( 866 instance, request); 867 break; 868 case USB_DEVREQ_SET_DESCRIPTOR: 869 case USB_DEVREQ_SET_CONFIGURATION: 870 usb_log_debug("processing request with " 871 "input\n"); 872 opResult = process_request_with_input( 873 instance, request); 874 break; 875 default: 876 usb_log_warning("received unsuported request: " 877 "%d\n", 878 setup_request->request 879 ); 729 880 opResult = ENOTSUP; 730 }731 }else{732 usb_log_error("root hub received empty transaction?");733 opResult = EINVAL;734 881 } 735 882 return opResult; 736 883 } 737 738 /** 739 * process root hub request 740 * 741 * @param instance root hub instance 742 * @param request structure containing both request and response information 743 * @return error code 744 */ 745 int rh_request(rh_t *instance, usb_transfer_batch_t *request) 746 { 747 assert(instance); 748 assert(request); 749 int opResult; 750 if(request->transfer_type == USB_TRANSFER_CONTROL){ 751 usb_log_info("Root hub got CONTROL packet\n"); 752 opResult = process_ctrl_request(instance,request); 753 }else if(request->transfer_type == USB_TRANSFER_INTERRUPT){ 754 usb_log_info("Root hub got INTERRUPT packet\n"); 755 void * buffer; 756 create_interrupt_mask(instance, &buffer, 757 &(request->transfered_size)); 758 memcpy(request->transport_buffer,buffer, request->transfered_size); 759 opResult = EOK; 760 }else{ 761 opResult = EINVAL; 762 } 763 usb_transfer_batch_finish(request, opResult); 764 return EOK; 765 } 766 /*----------------------------------------------------------------------------*/ 767 768 769 void rh_interrupt(rh_t *instance) 770 { 771 usb_log_info("Whoa whoa wait, I`m not supposed to receive any interrupts, am I?\n"); 772 /* TODO: implement? */ 773 } 884 /*----------------------------------------------------------------------------*/ 885 886 /** 887 * process hanging interrupt request 888 * 889 * If an interrupt transfer has been received and there was no change, 890 * the driver stores the transfer information and waits for change to occcur. 891 * This routine is called when that happens and it finalizes the interrupt 892 * transfer. 893 * 894 * @param instance hub instance 895 * @param request batch request to be processed 896 * @param change_buffer chages on hub 897 * @param buffer_size size of change buffer 898 * 899 * @return 900 */ 901 static int process_interrupt(rh_t *instance, usb_transfer_batch_t * request, 902 void * change_buffer, size_t buffe_size){ 903 create_interrupt_mask(instance, &change_buffer, 904 &(request->transfered_size)); 905 memcpy(request->data_buffer, change_buffer,request->transfered_size); 906 instance->unfinished_interrupt_transfer = NULL; 907 usb_transfer_batch_finish_error(request, EOK); 908 return EOK; 909 } 910 911 /*----------------------------------------------------------------------------*/ 912 913 /** 914 * return whether the buffer is full of zeros 915 * 916 * Convenience function. 917 * @param buffer 918 * @param size 919 * @return 920 */ 921 static bool is_zeros(void * buffer, size_t size){ 922 if(!buffer) return true; 923 if(!size) return true; 924 size_t i; 925 for(i=0;i<size;++i){ 926 if(((char*)buffer)[i]) 927 return false; 928 } 929 return true; 930 } 931 774 932 /** 775 933 * @}
Note:
See TracChangeset
for help on using the changeset viewer.
