Changes in uspace/drv/ohci/root_hub.c [ccbcd895:f35b294] in mainline
- File:
-
- 1 edited
-
uspace/drv/ohci/root_hub.c (modified) (33 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/drv/ohci/root_hub.c
rccbcd895 rf35b294 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 201 202 203 204 /** Root hub initialization 205 * @return Error code. 206 */ 207 int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs) { 208 assert(instance); 209 //instance->address = -1; 210 instance->registers = regs; 211 instance->device = dev; 212 instance->port_count = instance->registers->rh_desc_a & 0xff; 213 rh_init_descriptors(instance); 214 // set port power mode to no-power-switching 215 instance->registers->rh_desc_a = 216 instance->registers->rh_desc_a | (1<<9); 217 218 usb_log_info("OHCI root hub with %d ports.\n", instance->port_count); 219 220 //start generic usb hub driver 221 222 /* TODO: implement */ 223 return EOK; 224 } 225 /*----------------------------------------------------------------------------*/ 226 227 /** 228 * process root hub request 229 * 230 * @param instance root hub instance 231 * @param request structure containing both request and response information 232 * @return error code 233 */ 234 int rh_request(rh_t *instance, usb_transfer_batch_t *request) { 235 assert(instance); 236 assert(request); 237 int opResult; 238 if (request->transfer_type == USB_TRANSFER_CONTROL) { 239 usb_log_info("Root hub got CONTROL packet\n"); 240 opResult = process_ctrl_request(instance, request); 241 } else if (request->transfer_type == USB_TRANSFER_INTERRUPT) { 242 usb_log_info("Root hub got INTERRUPT packet\n"); 243 void * buffer; 244 create_interrupt_mask(instance, &buffer, 245 &(request->transfered_size)); 246 memcpy(request->transport_buffer, buffer, 247 request->transfered_size); 248 opResult = EOK; 249 } else { 250 opResult = EINVAL; 251 } 252 usb_transfer_batch_finish_error(request, opResult); 253 return EOK; 254 } 255 256 /*----------------------------------------------------------------------------*/ 257 258 259 void rh_interrupt(rh_t *instance) { 260 usb_log_info("Whoa whoa wait, I`m not supposed to receive any " 261 "interrupts, am I?\n"); 262 /* TODO: implement? */ 263 } 264 /*----------------------------------------------------------------------------*/ 147 265 148 266 /** … … 157 275 */ 158 276 static void usb_create_serialized_hub_descriptor(rh_t *instance, 159 160 277 uint8_t ** out_result, 278 size_t * out_size) { 161 279 //base size 162 280 size_t size = 7; 163 281 //variable size according to port count 164 282 size_t var_size = instance->port_count / 8 + 165 283 ((instance->port_count % 8 > 0) ? 1 : 0); 166 284 size += 2 * var_size; 167 285 uint8_t * result = (uint8_t*) malloc(size); 168 bzero(result, size);286 bzero(result, size); 169 287 //size 170 288 result[0] = size; … … 174 292 uint32_t hub_desc_reg = instance->registers->rh_desc_a; 175 293 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);294 ((hub_desc_reg >> 8) % 2) + 295 (((hub_desc_reg >> 9) % 2) << 1) + 296 (((hub_desc_reg >> 10) % 2) << 2) + 297 (((hub_desc_reg >> 11) % 2) << 3) + 298 (((hub_desc_reg >> 12) % 2) << 4); 181 299 result[4] = 0; 182 300 result[5] = /*descriptor->pwr_on_2_good_time*/ 50; … … 185 303 int port; 186 304 for (port = 1; port <= instance->port_count; ++port) { 187 result[7 + port/8] += 188 ((instance->registers->rh_desc_b >> port)%2) << (port%8); 305 uint8_t is_non_removable = 306 instance->registers->rh_desc_b >> port % 2; 307 result[7 + port / 8] += 308 is_non_removable << (port % 8); 189 309 } 190 310 size_t i; … … 195 315 (*out_size) = size; 196 316 } 197 317 /*----------------------------------------------------------------------------*/ 198 318 199 319 /** initialize hub descriptors … … 203 323 * @instance root hub instance 204 324 */ 205 static void rh_init_descriptors(rh_t *instance) {325 static void rh_init_descriptors(rh_t *instance) { 206 326 memcpy(&instance->descriptors.device, &ohci_rh_device_descriptor, 207 sizeof (ohci_rh_device_descriptor)208 );327 sizeof (ohci_rh_device_descriptor) 328 ); 209 329 usb_standard_configuration_descriptor_t descriptor; 210 memcpy(&descriptor, &ohci_rh_conf_descriptor,211 sizeof(ohci_rh_conf_descriptor));330 memcpy(&descriptor, &ohci_rh_conf_descriptor, 331 sizeof (ohci_rh_conf_descriptor)); 212 332 uint8_t * hub_descriptor; 213 333 size_t hub_desc_size; 214 334 usb_create_serialized_hub_descriptor(instance, &hub_descriptor, 215 335 &hub_desc_size); 216 336 217 337 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 338 sizeof (usb_standard_configuration_descriptor_t) + 339 sizeof (usb_standard_endpoint_descriptor_t) + 340 sizeof (usb_standard_interface_descriptor_t) + 341 hub_desc_size; 342 223 343 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 344 (uint8_t*) malloc(descriptor.total_length); 345 memcpy(full_config_descriptor, &descriptor, sizeof (descriptor)); 346 memcpy(full_config_descriptor + sizeof (descriptor), 347 &ohci_rh_iface_descriptor, sizeof (ohci_rh_iface_descriptor)); 348 memcpy(full_config_descriptor + sizeof (descriptor) + 349 sizeof (ohci_rh_iface_descriptor), 350 &ohci_rh_ep_descriptor, sizeof (ohci_rh_ep_descriptor)); 351 memcpy(full_config_descriptor + sizeof (descriptor) + 352 sizeof (ohci_rh_iface_descriptor) + 353 sizeof (ohci_rh_ep_descriptor), 354 hub_descriptor, hub_desc_size); 355 236 356 instance->descriptors.configuration = full_config_descriptor; 237 357 instance->descriptors.configuration_size = descriptor.total_length; 238 358 } 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 359 /*----------------------------------------------------------------------------*/ 262 360 … … 272 370 */ 273 371 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;372 usb_transfer_batch_t * request) { 373 if (port < 1 || port > instance->port_count) 374 return EINVAL; 375 uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer; 278 376 request->transfered_size = 4; 279 uint32_buffer[0] = instance->registers->rh_port_status[port -1]; 280 return EOK; 281 } 377 uint32_buffer[0] = instance->registers->rh_port_status[port - 1]; 378 #if 0 379 int i; 380 for (i = 0; i < instance->port_count; ++i) { 381 usb_log_debug("port status %d,x%x\n", 382 instance->registers->rh_port_status[i], 383 instance->registers->rh_port_status[i]); 384 } 385 #endif 386 return EOK; 387 } 388 /*----------------------------------------------------------------------------*/ 282 389 283 390 /** … … 291 398 */ 292 399 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; 400 usb_transfer_batch_t * request) { 401 uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer; 402 request->transfered_size = 4; 295 403 //bits, 0,1,16,17 296 request->transfered_size = 4; 297 uint32_t mask = 1 & (1<<1) & (1<<16) & (1<<17); 404 uint32_t mask = 1 | (1 << 1) | (1 << 16) | (1 << 17); 298 405 uint32_buffer[0] = mask & instance->registers->rh_status; 299 406 return EOK; 300 301 } 302 303 407 } 408 /*----------------------------------------------------------------------------*/ 304 409 305 410 /** … … 313 418 */ 314 419 static int process_get_status_request(rh_t *instance, 315 usb_transfer_batch_t * request) 316 { 420 usb_transfer_batch_t * request) { 317 421 size_t buffer_size = request->buffer_size; 318 422 usb_device_request_setup_packet_t * request_packet = 319 320 423 (usb_device_request_setup_packet_t*) 424 request->setup_buffer; 321 425 322 426 usb_hub_bm_request_type_t request_type = request_packet->request_type; 323 if (buffer_size<4/*request_packet->length*/){///\TODO427 if (buffer_size < 4/*request_packet->length*/) {///\TODO 324 428 usb_log_warning("requested more data than buffer size\n"); 325 429 return EINVAL; 326 430 } 327 431 328 if (request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS)432 if (request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS) 329 433 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); 434 if (request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS) 435 return process_get_port_status_request(instance, 436 request_packet->index, 437 request); 333 438 return ENOTSUP; 334 439 } 440 /*----------------------------------------------------------------------------*/ 335 441 336 442 /** … … 339 445 * Result contains bitmap where bit 0 indicates change on hub and 340 446 * bit i indicates change on i`th port (i>0). For more info see 341 * Hub and Port status bitmap specification in USB specification. 447 * Hub and Port status bitmap specification in USB specification 448 * (chapter 11.13.4) 342 449 * @param instance root hub instance 343 450 * @param@out buffer pointer to created interrupt mas … … 345 452 */ 346 453 static void create_interrupt_mask(rh_t *instance, void ** buffer, 347 size_t * buffer_size){454 size_t * buffer_size) { 348 455 int bit_count = instance->port_count + 1; 349 (*buffer_size) = (bit_count / 8) + (bit_count%8==0)?0:1; 456 (*buffer_size) = (bit_count / 8) + ((bit_count % 8 == 0) ? 0 : 1); 457 350 458 (*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){ 459 uint8_t * bitmap = (uint8_t*) (*buffer); 460 uint32_t mask = (1 << (USB_HUB_FEATURE_C_HUB_LOCAL_POWER + 16)) 461 | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16)); 462 bzero(bitmap, (*buffer_size)); 463 if (instance->registers->rh_status & mask) { 355 464 bitmap[0] = 1; 356 465 } 357 466 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 467 mask = port_status_change_mask; 468 for (port = 1; port <= instance->port_count; ++port) { 469 if (mask & instance->registers->rh_port_status[port - 1]) { 470 bitmap[(port) / 8] += 1 << (port % 8); 471 } 472 } 473 } 474 /*----------------------------------------------------------------------------*/ 475 369 476 /** 370 477 * create answer to a descriptor request … … 377 484 */ 378 485 static int process_get_descriptor_request(rh_t *instance, 379 usb_transfer_batch_t *request){486 usb_transfer_batch_t *request) { 380 487 usb_device_request_setup_packet_t * setup_request = 381 (usb_device_request_setup_packet_t*)request->setup_buffer;488 (usb_device_request_setup_packet_t*) request->setup_buffer; 382 489 size_t size; 383 490 const void * result_descriptor = NULL; 384 491 const uint16_t setup_request_value = setup_request->value_high; 385 492 //(setup_request->value_low << 8); 386 493 bool del = false; 387 switch (setup_request_value) 388 {389 case USB_DESCTYPE_HUB:{494 switch (setup_request_value) { 495 case USB_DESCTYPE_HUB: 496 { 390 497 uint8_t * descriptor; 391 498 usb_create_serialized_hub_descriptor( 392 499 instance, &descriptor, &size); 393 500 result_descriptor = descriptor; 394 if (result_descriptor) del = true;501 if (result_descriptor) del = true; 395 502 break; 396 503 } 397 case USB_DESCTYPE_DEVICE: { 504 case USB_DESCTYPE_DEVICE: 505 { 398 506 usb_log_debug("USB_DESCTYPE_DEVICE\n"); 399 507 result_descriptor = &ohci_rh_device_descriptor; 400 size = sizeof (ohci_rh_device_descriptor);508 size = sizeof (ohci_rh_device_descriptor); 401 509 break; 402 510 } 403 case USB_DESCTYPE_CONFIGURATION: { 511 case USB_DESCTYPE_CONFIGURATION: 512 { 404 513 usb_log_debug("USB_DESCTYPE_CONFIGURATION\n"); 405 514 result_descriptor = instance->descriptors.configuration; … … 407 516 break; 408 517 } 409 case USB_DESCTYPE_INTERFACE: { 518 case USB_DESCTYPE_INTERFACE: 519 { 410 520 usb_log_debug("USB_DESCTYPE_INTERFACE\n"); 411 521 result_descriptor = &ohci_rh_iface_descriptor; 412 size = sizeof (ohci_rh_iface_descriptor);522 size = sizeof (ohci_rh_iface_descriptor); 413 523 break; 414 524 } 415 case USB_DESCTYPE_ENDPOINT: { 525 case USB_DESCTYPE_ENDPOINT: 526 { 416 527 usb_log_debug("USB_DESCTYPE_ENDPOINT\n"); 417 528 result_descriptor = &ohci_rh_ep_descriptor; 418 size = sizeof (ohci_rh_ep_descriptor);529 size = sizeof (ohci_rh_ep_descriptor); 419 530 break; 420 531 } 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 ); 532 default: 533 { 534 usb_log_debug("USB_DESCTYPE_EINVAL %d \n", 535 setup_request->value); 536 usb_log_debug("\ttype %d\n\trequest %d\n\tvalue " 537 "%d\n\tindex %d\n\tlen %d\n ", 538 setup_request->request_type, 539 setup_request->request, 540 setup_request_value, 541 setup_request->index, 542 setup_request->length 543 ); 430 544 return EINVAL; 431 545 } 432 546 } 433 if (request->buffer_size < size){547 if (request->buffer_size < size) { 434 548 size = request->buffer_size; 435 549 } 436 550 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)); 551 memcpy(request->transport_buffer, result_descriptor, size); 440 552 if (del) 441 553 free(result_descriptor); 442 554 return EOK; 443 555 } 556 /*----------------------------------------------------------------------------*/ 444 557 445 558 /** … … 451 564 * @return error code 452 565 */ 453 static int process_get_configuration_request(rh_t *instance, 454 usb_transfer_batch_t *request){566 static int process_get_configuration_request(rh_t *instance, 567 usb_transfer_batch_t *request) { 455 568 //set and get configuration requests do not have any meaning, only dummy 456 569 //values are returned 457 if (request->buffer_size != 1)570 if (request->buffer_size != 1) 458 571 return EINVAL; 459 572 request->transport_buffer[0] = 1; … … 461 574 return EOK; 462 575 } 576 /*----------------------------------------------------------------------------*/ 463 577 464 578 /** 465 579 * process feature-enabling request on hub 466 * 580 * 467 581 * @param instance root hub instance 468 582 * @param feature feature selector … … 470 584 */ 471 585 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; 586 uint16_t feature) { 587 if (!((1 << feature) & hub_set_feature_valid_mask)) 588 return EINVAL; 589 if(feature == USB_HUB_FEATURE_C_HUB_LOCAL_POWER) 590 feature = USB_HUB_FEATURE_C_HUB_LOCAL_POWER << 16; 475 591 instance->registers->rh_status = 476 (instance->registers->rh_status | (1<<feature)) 477 & (~ hub_clear_feature_by_writing_one_mask); 478 return EOK; 479 } 592 (instance->registers->rh_status | (1 << feature)) 593 & (~hub_clear_feature_by_writing_one_mask); 594 return EOK; 595 } 596 /*----------------------------------------------------------------------------*/ 480 597 481 598 /** … … 487 604 */ 488 605 static int process_hub_feature_clear_request(rh_t *instance, 489 uint16_t feature){490 if (! ((1<<feature) & hub_clear_feature_valid_mask))606 uint16_t feature) { 607 if (!((1 << feature) & hub_clear_feature_valid_mask)) 491 608 return EINVAL; 492 609 //is the feature cleared directly? 493 if ((1 <<feature) & hub_set_feature_direct_mask){610 if ((1 << feature) & hub_set_feature_direct_mask) { 494 611 instance->registers->rh_status = 495 (instance->registers->rh_status & (~(1 <<feature)))496 & (~ 497 } else{//the feature is cleared by writing '1'612 (instance->registers->rh_status & (~(1 << feature))) 613 & (~hub_clear_feature_by_writing_one_mask); 614 } else {//the feature is cleared by writing '1' 498 615 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 616 (instance->registers->rh_status 617 & (~hub_clear_feature_by_writing_one_mask)) 618 | (1 << feature); 619 } 620 return EOK; 621 } 622 /*----------------------------------------------------------------------------*/ 507 623 508 624 /** 509 625 * process feature-enabling request on hub 510 * 626 * 511 627 * @param instance root hub instance 512 628 * @param feature feature selector … … 516 632 */ 517 633 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)634 uint16_t feature, uint16_t port) { 635 if (!((1 << feature) & port_set_feature_valid_mask)) 636 return EINVAL; 637 if (port < 1 || port > instance->port_count) 522 638 return EINVAL; 523 639 instance->registers->rh_port_status[port - 1] = 524 (instance->registers->rh_port_status[port - 1] | (1<<feature))525 640 (instance->registers->rh_port_status[port - 1] | (1 << feature)) 641 & (~port_clear_feature_valid_mask); 526 642 /// \TODO any error? 527 643 return EOK; 528 644 } 645 /*----------------------------------------------------------------------------*/ 529 646 530 647 /** … … 538 655 */ 539 656 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)657 uint16_t feature, uint16_t port) { 658 if (!((1 << feature) & port_clear_feature_valid_mask)) 659 return EINVAL; 660 if (port < 1 || port > instance->port_count) 661 return EINVAL; 662 if (feature == USB_HUB_FEATURE_PORT_POWER) 546 663 feature = USB_HUB_FEATURE_PORT_LOW_SPEED; 547 if (feature == USB_HUB_FEATURE_PORT_SUSPEND)664 if (feature == USB_HUB_FEATURE_PORT_SUSPEND) 548 665 feature = USB_HUB_FEATURE_PORT_OVER_CURRENT; 549 666 instance->registers->rh_port_status[port - 1] = 550 (instance->registers->rh_port_status[port - 1]551 552 | (1<<feature);667 (instance->registers->rh_port_status[port - 1] 668 & (~port_clear_feature_valid_mask)) 669 | (1 << feature); 553 670 /// \TODO any error? 554 671 return EOK; 555 672 } 556 673 /*----------------------------------------------------------------------------*/ 557 674 558 675 /** 559 676 * register address to this device 560 * 677 * 561 678 * @param instance root hub instance 562 679 * @param address new address … … 564 681 */ 565 682 static int process_address_set_request(rh_t *instance, 566 uint16_t address){683 uint16_t address) { 567 684 instance->address = address; 568 685 return EOK; 569 686 } 687 /*----------------------------------------------------------------------------*/ 570 688 571 689 /** … … 579 697 */ 580 698 static int process_request_with_output(rh_t *instance, 581 usb_transfer_batch_t *request){699 usb_transfer_batch_t *request) { 582 700 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){701 (usb_device_request_setup_packet_t*) request->setup_buffer; 702 if (setup_request->request == USB_DEVREQ_GET_STATUS) { 585 703 usb_log_debug("USB_DEVREQ_GET_STATUS\n"); 586 704 return process_get_status_request(instance, request); 587 705 } 588 if (setup_request->request == USB_DEVREQ_GET_DESCRIPTOR){706 if (setup_request->request == USB_DEVREQ_GET_DESCRIPTOR) { 589 707 usb_log_debug("USB_DEVREQ_GET_DESCRIPTOR\n"); 590 708 return process_get_descriptor_request(instance, request); 591 709 } 592 if (setup_request->request == USB_DEVREQ_GET_CONFIGURATION){710 if (setup_request->request == USB_DEVREQ_GET_CONFIGURATION) { 593 711 usb_log_debug("USB_DEVREQ_GET_CONFIGURATION\n"); 594 712 return process_get_configuration_request(instance, request); … … 596 714 return ENOTSUP; 597 715 } 716 /*----------------------------------------------------------------------------*/ 598 717 599 718 /** … … 607 726 */ 608 727 static int process_request_with_input(rh_t *instance, 609 usb_transfer_batch_t *request){728 usb_transfer_batch_t *request) { 610 729 usb_device_request_setup_packet_t * setup_request = 611 (usb_device_request_setup_packet_t*)request->setup_buffer;730 (usb_device_request_setup_packet_t*) request->setup_buffer; 612 731 request->transfered_size = 0; 613 if (setup_request->request == USB_DEVREQ_SET_DESCRIPTOR){732 if (setup_request->request == USB_DEVREQ_SET_DESCRIPTOR) { 614 733 return ENOTSUP; 615 734 } 616 if (setup_request->request == USB_DEVREQ_SET_CONFIGURATION){735 if (setup_request->request == USB_DEVREQ_SET_CONFIGURATION) { 617 736 //set and get configuration requests do not have any meaning, 618 737 //only dummy values are returned … … 621 740 return ENOTSUP; 622 741 } 742 /*----------------------------------------------------------------------------*/ 623 743 624 744 /** … … 632 752 */ 633 753 static int process_request_without_data(rh_t *instance, 634 usb_transfer_batch_t *request){754 usb_transfer_batch_t *request) { 635 755 usb_device_request_setup_packet_t * setup_request = 636 (usb_device_request_setup_packet_t*)request->setup_buffer;756 (usb_device_request_setup_packet_t*) request->setup_buffer; 637 757 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){758 if (setup_request->request == USB_DEVREQ_CLEAR_FEATURE) { 759 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE) { 640 760 usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n"); 641 761 return process_hub_feature_clear_request(instance, 642 643 } 644 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE){762 setup_request->value); 763 } 764 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE) { 645 765 usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n"); 646 766 return process_port_feature_clear_request(instance, 647 648 767 setup_request->value, 768 setup_request->index); 649 769 } 650 770 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){771 setup_request->request_type); 772 return EINVAL; 773 } 774 if (setup_request->request == USB_DEVREQ_SET_FEATURE) { 775 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE) { 656 776 usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n"); 657 777 return process_hub_feature_set_request(instance, 658 659 } 660 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE){778 setup_request->value); 779 } 780 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE) { 661 781 usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n"); 662 782 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){ 783 setup_request->value, 784 setup_request->index); 785 } 786 usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n", 787 setup_request->request_type); 788 return EINVAL; 789 } 790 if (setup_request->request == USB_DEVREQ_SET_ADDRESS) { 670 791 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); 792 return process_address_set_request(instance, 793 setup_request->value); 794 } 795 usb_log_debug("USB_DEVREQ_SET_ENOTSUP %d\n", 796 setup_request->request_type); 674 797 return ENOTSUP; 675 798 } 799 /*----------------------------------------------------------------------------*/ 676 800 677 801 /** … … 693 817 * @return error code 694 818 */ 695 static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request){ 819 static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request) { 820 if (!request->setup_buffer) { 821 usb_log_error("root hub received empty transaction?"); 822 return EINVAL; 823 } 696 824 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 ){825 if (sizeof (usb_device_request_setup_packet_t) > request->setup_size) { 826 usb_log_error("setup packet too small\n"); 827 return EINVAL; 828 } 829 usb_log_info("CTRL packet: %s.\n", 830 usb_debug_str_buffer( 831 (const uint8_t *) request->setup_buffer, 8, 8)); 832 usb_device_request_setup_packet_t * setup_request = 833 (usb_device_request_setup_packet_t*) 834 request->setup_buffer; 835 switch (setup_request->request) { 836 case USB_DEVREQ_GET_STATUS: 837 case USB_DEVREQ_GET_DESCRIPTOR: 838 case USB_DEVREQ_GET_CONFIGURATION: 711 839 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 ); 840 opResult = process_request_with_output( 841 instance, request); 842 break; 843 case USB_DEVREQ_CLEAR_FEATURE: 844 case USB_DEVREQ_SET_FEATURE: 845 case USB_DEVREQ_SET_ADDRESS: 846 usb_log_debug("processing request without " 847 "additional data\n"); 848 opResult = process_request_without_data( 849 instance, request); 850 break; 851 case USB_DEVREQ_SET_DESCRIPTOR: 852 case USB_DEVREQ_SET_CONFIGURATION: 853 usb_log_debug("processing request with " 854 "input\n"); 855 opResult = process_request_with_input( 856 instance, request); 857 break; 858 default: 859 usb_log_warning("received unsuported request: " 860 "%d\n", 861 setup_request->request 862 ); 729 863 opResult = ENOTSUP; 730 }731 }else{732 usb_log_error("root hub received empty transaction?");733 opResult = EINVAL;734 864 } 735 865 return opResult; … … 737 867 738 868 /** 739 * process root hub request740 *741 * @param instance root hub instance742 * @param request structure containing both request and response information743 * @return error code744 */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 }774 /**775 869 * @} 776 870 */
Note:
See TracChangeset
for help on using the changeset viewer.
