source: mainline/uspace/drv/ohci/root_hub.c@ 7013b14

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 7013b14 was 8148ee3a, checked in by Jan Vesely <jano.vesely@…>, 15 years ago

Root hub does not need ddf device pointer

Use endpoint manager registration wrapper
  • Property mode set to 100644
File size: 27.3 KB
Line 
1/*
2 * Copyright (c) 2011 Jan Vesely
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28/** @addtogroup drvusbohci
29 * @{
30 */
31/** @file
32 * @brief OHCI driver
33 */
34#include <assert.h>
35#include <errno.h>
36#include <str_error.h>
37
38#include <usb/debug.h>
39
40#include "root_hub.h"
41#include "usb/classes/classes.h"
42#include "usb/devdrv.h"
43#include <usb/request.h>
44#include <usb/classes/hub.h>
45
46/**
47 * standart device descriptor for ohci root hub
48 */
49static 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,
64};
65
66/**
67 * standart configuration descriptor with filled common values
68 * for ohci root hubs
69 */
70static const usb_standard_configuration_descriptor_t ohci_rh_conf_descriptor = {
71 /// \TODO some values are default or guessed
72 .attributes = 1 << 7,
73 .configuration_number = 1,
74 .descriptor_type = USB_DESCTYPE_CONFIGURATION,
75 .interface_count = 1,
76 .length = sizeof (usb_standard_configuration_descriptor_t),
77 .max_power = 100,
78 .str_configuration = 0,
79};
80
81/**
82 * standart ohci root hub interface descriptor
83 */
84static const usb_standard_interface_descriptor_t ohci_rh_iface_descriptor = {
85 .alternate_setting = 0,
86 .descriptor_type = USB_DESCTYPE_INTERFACE,
87 .endpoint_count = 1,
88 .interface_class = USB_CLASS_HUB,
89 /// \TODO is this correct?
90 .interface_number = 1,
91 .interface_protocol = 0,
92 .interface_subclass = 0,
93 .length = sizeof (usb_standard_interface_descriptor_t),
94 .str_interface = 0,
95};
96
97/**
98 * standart ohci root hub endpoint descriptor
99 */
100static const usb_standard_endpoint_descriptor_t ohci_rh_ep_descriptor = {
101 .attributes = USB_TRANSFER_INTERRUPT,
102 .descriptor_type = USB_DESCTYPE_ENDPOINT,
103 .endpoint_address = 1 + (1 << 7),
104 .length = sizeof (usb_standard_endpoint_descriptor_t),
105 .max_packet_size = 8,
106 .poll_interval = 255,
107};
108
109static const uint32_t hub_clear_feature_valid_mask =
110 (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER) |
111(1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
112
113static const uint32_t hub_clear_feature_by_writing_one_mask =
114 1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER;
115
116static const uint32_t hub_set_feature_valid_mask =
117 (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT) |
118(1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
119
120
121static const uint32_t hub_set_feature_direct_mask =
122 (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
123
124static const uint32_t port_set_feature_valid_mask =
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);
129
130static const uint32_t port_clear_feature_valid_mask =
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
143static 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
151static void usb_create_serialized_hub_descriptor(rh_t *instance,
152 uint8_t ** out_result,
153 size_t * out_size);
154
155static void rh_init_descriptors(rh_t *instance);
156
157static int process_get_port_status_request(rh_t *instance, uint16_t port,
158 usb_transfer_batch_t * request);
159
160static int process_get_hub_status_request(rh_t *instance,
161 usb_transfer_batch_t * request);
162
163static int process_get_status_request(rh_t *instance,
164 usb_transfer_batch_t * request);
165
166static void create_interrupt_mask(rh_t *instance, void ** buffer,
167 size_t * buffer_size);
168
169static int process_get_descriptor_request(rh_t *instance,
170 usb_transfer_batch_t *request);
171
172static int process_get_configuration_request(rh_t *instance,
173 usb_transfer_batch_t *request);
174
175static int process_hub_feature_set_request(rh_t *instance, uint16_t feature);
176
177static int process_hub_feature_clear_request(rh_t *instance,
178 uint16_t feature);
179
180static int process_port_feature_set_request(rh_t *instance,
181 uint16_t feature, uint16_t port);
182
183static int process_port_feature_clear_request(rh_t *instance,
184 uint16_t feature, uint16_t port);
185
186static int process_address_set_request(rh_t *instance,
187 uint16_t address);
188
189static int process_request_with_output(rh_t *instance,
190 usb_transfer_batch_t *request);
191
192static int process_request_with_input(rh_t *instance,
193 usb_transfer_batch_t *request);
194
195static int process_request_without_data(rh_t *instance,
196 usb_transfer_batch_t *request);
197
198static 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 */
207int rh_init(rh_t *instance, ohci_regs_t *regs) {
208 assert(instance);
209 instance->registers = regs;
210 instance->port_count =
211 (instance->registers->rh_desc_a >> RHDA_NDS_SHIFT) & RHDA_NDS_MASK;
212 rh_init_descriptors(instance);
213 // set port power mode to no-power-switching
214 instance->registers->rh_desc_a |= RHDA_NPS_FLAG;
215
216 usb_log_info("OHCI root hub with %d ports.\n", instance->port_count);
217 return EOK;
218}
219/*----------------------------------------------------------------------------*/
220
221/**
222 * process root hub request
223 *
224 * @param instance root hub instance
225 * @param request structure containing both request and response information
226 * @return error code
227 */
228int rh_request(rh_t *instance, usb_transfer_batch_t *request) {
229 assert(instance);
230 assert(request);
231 int opResult;
232 if (request->ep->transfer_type == USB_TRANSFER_CONTROL) {
233 usb_log_info("Root hub got CONTROL packet\n");
234 opResult = process_ctrl_request(instance, request);
235 } else if (request->ep->transfer_type == USB_TRANSFER_INTERRUPT) {
236 usb_log_info("Root hub got INTERRUPT packet\n");
237 void * buffer;
238 create_interrupt_mask(instance, &buffer,
239 &(request->transfered_size));
240 memcpy(request->data_buffer, buffer,
241 request->transfered_size);
242 opResult = EOK;
243 } else {
244 opResult = EINVAL;
245 }
246 usb_transfer_batch_finish_error(request, opResult);
247 return EOK;
248}
249
250/*----------------------------------------------------------------------------*/
251
252
253void rh_interrupt(rh_t *instance) {
254 usb_log_info("Whoa whoa wait, I`m not supposed to receive any "
255 "interrupts, am I?\n");
256 /* TODO: implement? */
257}
258/*----------------------------------------------------------------------------*/
259
260/**
261 * Create hub descriptor used in hub-driver <-> hub communication
262 *
263 * This means creating byt array from data in root hub registers. For more
264 * info see usb hub specification.
265 *
266 * @param instance root hub instance
267 * @param@out out_result pointer to resultant serialized descriptor
268 * @param@out out_size size of serialized descriptor
269 */
270static void usb_create_serialized_hub_descriptor(rh_t *instance,
271 uint8_t ** out_result,
272 size_t * out_size) {
273 //base size
274 size_t size = 7;
275 //variable size according to port count
276 size_t var_size = instance->port_count / 8 +
277 ((instance->port_count % 8 > 0) ? 1 : 0);
278 size += 2 * var_size;
279 uint8_t * result = (uint8_t*) malloc(size);
280 bzero(result, size);
281 //size
282 result[0] = size;
283 //descriptor type
284 result[1] = USB_DESCTYPE_HUB;
285 result[2] = instance->port_count;
286 uint32_t hub_desc_reg = instance->registers->rh_desc_a;
287 result[3] =
288 ((hub_desc_reg >> 8) % 2) +
289 (((hub_desc_reg >> 9) % 2) << 1) +
290 (((hub_desc_reg >> 10) % 2) << 2) +
291 (((hub_desc_reg >> 11) % 2) << 3) +
292 (((hub_desc_reg >> 12) % 2) << 4);
293 result[4] = 0;
294 result[5] = /*descriptor->pwr_on_2_good_time*/ 50;
295 result[6] = 50;
296
297 int port;
298 for (port = 1; port <= instance->port_count; ++port) {
299 uint8_t is_non_removable =
300 instance->registers->rh_desc_b >> port % 2;
301 result[7 + port / 8] +=
302 is_non_removable << (port % 8);
303 }
304 size_t i;
305 for (i = 0; i < var_size; ++i) {
306 result[7 + var_size + i] = 255;
307 }
308 (*out_result) = result;
309 (*out_size) = size;
310}
311/*----------------------------------------------------------------------------*/
312
313/** initialize hub descriptors
314 *
315 * Initialized are device and full configuration descriptor. These need to
316 * be initialized only once per hub.
317 * @instance root hub instance
318 */
319static void rh_init_descriptors(rh_t *instance) {
320 memcpy(&instance->descriptors.device, &ohci_rh_device_descriptor,
321 sizeof (ohci_rh_device_descriptor)
322 );
323 usb_standard_configuration_descriptor_t descriptor;
324 memcpy(&descriptor, &ohci_rh_conf_descriptor,
325 sizeof (ohci_rh_conf_descriptor));
326 uint8_t * hub_descriptor;
327 size_t hub_desc_size;
328 usb_create_serialized_hub_descriptor(instance, &hub_descriptor,
329 &hub_desc_size);
330
331 descriptor.total_length =
332 sizeof (usb_standard_configuration_descriptor_t) +
333 sizeof (usb_standard_endpoint_descriptor_t) +
334 sizeof (usb_standard_interface_descriptor_t) +
335 hub_desc_size;
336
337 uint8_t * full_config_descriptor =
338 (uint8_t*) malloc(descriptor.total_length);
339 memcpy(full_config_descriptor, &descriptor, sizeof (descriptor));
340 memcpy(full_config_descriptor + sizeof (descriptor),
341 &ohci_rh_iface_descriptor, sizeof (ohci_rh_iface_descriptor));
342 memcpy(full_config_descriptor + sizeof (descriptor) +
343 sizeof (ohci_rh_iface_descriptor),
344 &ohci_rh_ep_descriptor, sizeof (ohci_rh_ep_descriptor));
345 memcpy(full_config_descriptor + sizeof (descriptor) +
346 sizeof (ohci_rh_iface_descriptor) +
347 sizeof (ohci_rh_ep_descriptor),
348 hub_descriptor, hub_desc_size);
349
350 instance->descriptors.configuration = full_config_descriptor;
351 instance->descriptors.configuration_size = descriptor.total_length;
352}
353/*----------------------------------------------------------------------------*/
354
355/**
356 * create answer to port status_request
357 *
358 * Copy content of corresponding port status register to answer buffer.
359 *
360 * @param instance root hub instance
361 * @param port port number, counted from 1
362 * @param request structure containing both request and response information
363 * @return error code
364 */
365static int process_get_port_status_request(rh_t *instance, uint16_t port,
366 usb_transfer_batch_t * request) {
367 if (port < 1 || port > instance->port_count)
368 return EINVAL;
369 uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
370 request->transfered_size = 4;
371 uint32_buffer[0] = instance->registers->rh_port_status[port - 1];
372#if 0
373 int i;
374 for (i = 0; i < instance->port_count; ++i) {
375 usb_log_debug("port status %d,x%x\n",
376 instance->registers->rh_port_status[i],
377 instance->registers->rh_port_status[i]);
378 }
379#endif
380 return EOK;
381}
382/*----------------------------------------------------------------------------*/
383
384/**
385 * create answer to port status_request
386 *
387 * Copy content of hub status register to answer buffer.
388 *
389 * @param instance root hub instance
390 * @param request structure containing both request and response information
391 * @return error code
392 */
393static int process_get_hub_status_request(rh_t *instance,
394 usb_transfer_batch_t * request) {
395 uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
396 request->transfered_size = 4;
397 //bits, 0,1,16,17
398 uint32_t mask = 1 | (1 << 1) | (1 << 16) | (1 << 17);
399 uint32_buffer[0] = mask & instance->registers->rh_status;
400 return EOK;
401}
402/*----------------------------------------------------------------------------*/
403
404/**
405 * create answer to status request
406 *
407 * This might be either hub status or port status request. If neither,
408 * ENOTSUP is returned.
409 * @param instance root hub instance
410 * @param request structure containing both request and response information
411 * @return error code
412 */
413static int process_get_status_request(rh_t *instance,
414 usb_transfer_batch_t * request) {
415 size_t buffer_size = request->buffer_size;
416 usb_device_request_setup_packet_t * request_packet =
417 (usb_device_request_setup_packet_t*)
418 request->setup_buffer;
419
420 usb_hub_bm_request_type_t request_type = request_packet->request_type;
421 if (buffer_size < 4/*request_packet->length*/) {///\TODO
422 usb_log_warning("requested more data than buffer size\n");
423 return EINVAL;
424 }
425
426 if (request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS)
427 return process_get_hub_status_request(instance, request);
428 if (request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS)
429 return process_get_port_status_request(instance,
430 request_packet->index,
431 request);
432 return ENOTSUP;
433}
434/*----------------------------------------------------------------------------*/
435
436/**
437 * create answer to status interrupt consisting of change bitmap
438 *
439 * Result contains bitmap where bit 0 indicates change on hub and
440 * bit i indicates change on i`th port (i>0). For more info see
441 * Hub and Port status bitmap specification in USB specification
442 * (chapter 11.13.4)
443 * @param instance root hub instance
444 * @param@out buffer pointer to created interrupt mas
445 * @param@out buffer_size size of created interrupt mask
446 */
447static void create_interrupt_mask(rh_t *instance, void ** buffer,
448 size_t * buffer_size) {
449 int bit_count = instance->port_count + 1;
450 (*buffer_size) = (bit_count / 8) + ((bit_count % 8 == 0) ? 0 : 1);
451
452 (*buffer) = malloc(*buffer_size);
453 uint8_t * bitmap = (uint8_t*) (*buffer);
454 uint32_t mask = (1 << (USB_HUB_FEATURE_C_HUB_LOCAL_POWER + 16))
455 | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16));
456 bzero(bitmap, (*buffer_size));
457 if (instance->registers->rh_status & mask) {
458 bitmap[0] = 1;
459 }
460 int port;
461 mask = port_status_change_mask;
462 for (port = 1; port <= instance->port_count; ++port) {
463 if (mask & instance->registers->rh_port_status[port - 1]) {
464 bitmap[(port) / 8] += 1 << (port % 8);
465 }
466 }
467}
468/*----------------------------------------------------------------------------*/
469
470/**
471 * create answer to a descriptor request
472 *
473 * This might be a request for standard (configuration, device, endpoint or
474 * interface) or device specific (hub) descriptor.
475 * @param instance root hub instance
476 * @param request structure containing both request and response information
477 * @return error code
478 */
479static int process_get_descriptor_request(rh_t *instance,
480 usb_transfer_batch_t *request) {
481 usb_device_request_setup_packet_t * setup_request =
482 (usb_device_request_setup_packet_t*) request->setup_buffer;
483 size_t size;
484 const void * result_descriptor = NULL;
485 const uint16_t setup_request_value = setup_request->value_high;
486 //(setup_request->value_low << 8);
487 bool del = false;
488 switch (setup_request_value) {
489 case USB_DESCTYPE_HUB:
490 {
491 uint8_t * descriptor;
492 usb_create_serialized_hub_descriptor(
493 instance, &descriptor, &size);
494 result_descriptor = descriptor;
495 if (result_descriptor) del = true;
496 break;
497 }
498 case USB_DESCTYPE_DEVICE:
499 {
500 usb_log_debug("USB_DESCTYPE_DEVICE\n");
501 result_descriptor = &ohci_rh_device_descriptor;
502 size = sizeof (ohci_rh_device_descriptor);
503 break;
504 }
505 case USB_DESCTYPE_CONFIGURATION:
506 {
507 usb_log_debug("USB_DESCTYPE_CONFIGURATION\n");
508 result_descriptor = instance->descriptors.configuration;
509 size = instance->descriptors.configuration_size;
510 break;
511 }
512 case USB_DESCTYPE_INTERFACE:
513 {
514 usb_log_debug("USB_DESCTYPE_INTERFACE\n");
515 result_descriptor = &ohci_rh_iface_descriptor;
516 size = sizeof (ohci_rh_iface_descriptor);
517 break;
518 }
519 case USB_DESCTYPE_ENDPOINT:
520 {
521 usb_log_debug("USB_DESCTYPE_ENDPOINT\n");
522 result_descriptor = &ohci_rh_ep_descriptor;
523 size = sizeof (ohci_rh_ep_descriptor);
524 break;
525 }
526 default:
527 {
528 usb_log_debug("USB_DESCTYPE_EINVAL %d \n",
529 setup_request->value);
530 usb_log_debug("\ttype %d\n\trequest %d\n\tvalue "
531 "%d\n\tindex %d\n\tlen %d\n ",
532 setup_request->request_type,
533 setup_request->request,
534 setup_request_value,
535 setup_request->index,
536 setup_request->length
537 );
538 return EINVAL;
539 }
540 }
541 if (request->buffer_size < size) {
542 size = request->buffer_size;
543 }
544 request->transfered_size = size;
545 memcpy(request->data_buffer, result_descriptor, size);
546 if (del)
547 free(result_descriptor);
548 return EOK;
549}
550/*----------------------------------------------------------------------------*/
551
552/**
553 * answer to get configuration request
554 *
555 * Root hub works independently on the configuration.
556 * @param instance root hub instance
557 * @param request structure containing both request and response information
558 * @return error code
559 */
560static int process_get_configuration_request(rh_t *instance,
561 usb_transfer_batch_t *request) {
562 //set and get configuration requests do not have any meaning, only dummy
563 //values are returned
564 if (request->buffer_size != 1)
565 return EINVAL;
566 request->data_buffer[0] = 1;
567 request->transfered_size = 1;
568 return EOK;
569}
570/*----------------------------------------------------------------------------*/
571
572/**
573 * process feature-enabling request on hub
574 *
575 * @param instance root hub instance
576 * @param feature feature selector
577 * @return error code
578 */
579static int process_hub_feature_set_request(rh_t *instance,
580 uint16_t feature) {
581 if (!((1 << feature) & hub_set_feature_valid_mask))
582 return EINVAL;
583 if(feature == USB_HUB_FEATURE_C_HUB_LOCAL_POWER)
584 feature = USB_HUB_FEATURE_C_HUB_LOCAL_POWER << 16;
585 instance->registers->rh_status =
586 (instance->registers->rh_status | (1 << feature))
587 & (~hub_clear_feature_by_writing_one_mask);
588 return EOK;
589}
590/*----------------------------------------------------------------------------*/
591
592/**
593 * process feature-disabling request on hub
594 *
595 * @param instance root hub instance
596 * @param feature feature selector
597 * @return error code
598 */
599static int process_hub_feature_clear_request(rh_t *instance,
600 uint16_t feature) {
601 if (!((1 << feature) & hub_clear_feature_valid_mask))
602 return EINVAL;
603 //is the feature cleared directly?
604 if ((1 << feature) & hub_set_feature_direct_mask) {
605 instance->registers->rh_status =
606 (instance->registers->rh_status & (~(1 << feature)))
607 & (~hub_clear_feature_by_writing_one_mask);
608 } else {//the feature is cleared by writing '1'
609 instance->registers->rh_status =
610 (instance->registers->rh_status
611 & (~hub_clear_feature_by_writing_one_mask))
612 | (1 << feature);
613 }
614 return EOK;
615}
616/*----------------------------------------------------------------------------*/
617
618/**
619 * process feature-enabling request on hub
620 *
621 * @param instance root hub instance
622 * @param feature feature selector
623 * @param port port number, counted from 1
624 * @param enable enable or disable the specified feature
625 * @return error code
626 */
627static int process_port_feature_set_request(rh_t *instance,
628 uint16_t feature, uint16_t port) {
629 if (!((1 << feature) & port_set_feature_valid_mask))
630 return EINVAL;
631 if (port < 1 || port > instance->port_count)
632 return EINVAL;
633 instance->registers->rh_port_status[port - 1] =
634 (instance->registers->rh_port_status[port - 1] | (1 << feature))
635 & (~port_clear_feature_valid_mask);
636 /// \TODO any error?
637 return EOK;
638}
639/*----------------------------------------------------------------------------*/
640
641/**
642 * process feature-disabling request on hub
643 *
644 * @param instance root hub instance
645 * @param feature feature selector
646 * @param port port number, counted from 1
647 * @param enable enable or disable the specified feature
648 * @return error code
649 */
650static int process_port_feature_clear_request(rh_t *instance,
651 uint16_t feature, uint16_t port) {
652 if (!((1 << feature) & port_clear_feature_valid_mask))
653 return EINVAL;
654 if (port < 1 || port > instance->port_count)
655 return EINVAL;
656 if (feature == USB_HUB_FEATURE_PORT_POWER)
657 feature = USB_HUB_FEATURE_PORT_LOW_SPEED;
658 if (feature == USB_HUB_FEATURE_PORT_SUSPEND)
659 feature = USB_HUB_FEATURE_PORT_OVER_CURRENT;
660 instance->registers->rh_port_status[port - 1] =
661 (instance->registers->rh_port_status[port - 1]
662 & (~port_clear_feature_valid_mask))
663 | (1 << feature);
664 /// \TODO any error?
665 return EOK;
666}
667/*----------------------------------------------------------------------------*/
668
669/**
670 * register address to this device
671 *
672 * @param instance root hub instance
673 * @param address new address
674 * @return error code
675 */
676static int process_address_set_request(rh_t *instance,
677 uint16_t address) {
678 instance->address = address;
679 return EOK;
680}
681/*----------------------------------------------------------------------------*/
682
683/**
684 * process one of requests that requere output data
685 *
686 * Request can be one of USB_DEVREQ_GET_STATUS, USB_DEVREQ_GET_DESCRIPTOR or
687 * USB_DEVREQ_GET_CONFIGURATION.
688 * @param instance root hub instance
689 * @param request structure containing both request and response information
690 * @return error code
691 */
692static int process_request_with_output(rh_t *instance,
693 usb_transfer_batch_t *request) {
694 usb_device_request_setup_packet_t * setup_request =
695 (usb_device_request_setup_packet_t*) request->setup_buffer;
696 if (setup_request->request == USB_DEVREQ_GET_STATUS) {
697 usb_log_debug("USB_DEVREQ_GET_STATUS\n");
698 return process_get_status_request(instance, request);
699 }
700 if (setup_request->request == USB_DEVREQ_GET_DESCRIPTOR) {
701 usb_log_debug("USB_DEVREQ_GET_DESCRIPTOR\n");
702 return process_get_descriptor_request(instance, request);
703 }
704 if (setup_request->request == USB_DEVREQ_GET_CONFIGURATION) {
705 usb_log_debug("USB_DEVREQ_GET_CONFIGURATION\n");
706 return process_get_configuration_request(instance, request);
707 }
708 return ENOTSUP;
709}
710/*----------------------------------------------------------------------------*/
711
712/**
713 * process one of requests that carry input data
714 *
715 * Request can be one of USB_DEVREQ_SET_DESCRIPTOR or
716 * USB_DEVREQ_SET_CONFIGURATION.
717 * @param instance root hub instance
718 * @param request structure containing both request and response information
719 * @return error code
720 */
721static int process_request_with_input(rh_t *instance,
722 usb_transfer_batch_t *request) {
723 usb_device_request_setup_packet_t * setup_request =
724 (usb_device_request_setup_packet_t*) request->setup_buffer;
725 request->transfered_size = 0;
726 if (setup_request->request == USB_DEVREQ_SET_DESCRIPTOR) {
727 return ENOTSUP;
728 }
729 if (setup_request->request == USB_DEVREQ_SET_CONFIGURATION) {
730 //set and get configuration requests do not have any meaning,
731 //only dummy values are returned
732 return EOK;
733 }
734 return ENOTSUP;
735}
736/*----------------------------------------------------------------------------*/
737
738/**
739 * process one of requests that do not request nor carry additional data
740 *
741 * Request can be one of USB_DEVREQ_CLEAR_FEATURE, USB_DEVREQ_SET_FEATURE or
742 * USB_DEVREQ_SET_ADDRESS.
743 * @param instance root hub instance
744 * @param request structure containing both request and response information
745 * @return error code
746 */
747static int process_request_without_data(rh_t *instance,
748 usb_transfer_batch_t *request) {
749 usb_device_request_setup_packet_t * setup_request =
750 (usb_device_request_setup_packet_t*) request->setup_buffer;
751 request->transfered_size = 0;
752 if (setup_request->request == USB_DEVREQ_CLEAR_FEATURE) {
753 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE) {
754 usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n");
755 return process_hub_feature_clear_request(instance,
756 setup_request->value);
757 }
758 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE) {
759 usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
760 return process_port_feature_clear_request(instance,
761 setup_request->value,
762 setup_request->index);
763 }
764 usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",
765 setup_request->request_type);
766 return EINVAL;
767 }
768 if (setup_request->request == USB_DEVREQ_SET_FEATURE) {
769 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE) {
770 usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n");
771 return process_hub_feature_set_request(instance,
772 setup_request->value);
773 }
774 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE) {
775 usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
776 return process_port_feature_set_request(instance,
777 setup_request->value,
778 setup_request->index);
779 }
780 usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",
781 setup_request->request_type);
782 return EINVAL;
783 }
784 if (setup_request->request == USB_DEVREQ_SET_ADDRESS) {
785 usb_log_debug("USB_DEVREQ_SET_ADDRESS\n");
786 return process_address_set_request(instance,
787 setup_request->value);
788 }
789 usb_log_debug("USB_DEVREQ_SET_ENOTSUP %d\n",
790 setup_request->request_type);
791 return ENOTSUP;
792}
793/*----------------------------------------------------------------------------*/
794
795/**
796 * process hub control request
797 *
798 * If needed, writes answer into the request structure.
799 * Request can be one of
800 * USB_DEVREQ_GET_STATUS,
801 * USB_DEVREQ_GET_DESCRIPTOR,
802 * USB_DEVREQ_GET_CONFIGURATION,
803 * USB_DEVREQ_CLEAR_FEATURE,
804 * USB_DEVREQ_SET_FEATURE,
805 * USB_DEVREQ_SET_ADDRESS,
806 * USB_DEVREQ_SET_DESCRIPTOR or
807 * USB_DEVREQ_SET_CONFIGURATION.
808 *
809 * @param instance root hub instance
810 * @param request structure containing both request and response information
811 * @return error code
812 */
813static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request) {
814 if (!request->setup_buffer) {
815 usb_log_error("root hub received empty transaction?");
816 return EINVAL;
817 }
818 int opResult;
819 if (sizeof (usb_device_request_setup_packet_t) > request->setup_size) {
820 usb_log_error("setup packet too small\n");
821 return EINVAL;
822 }
823 usb_log_info("CTRL packet: %s.\n",
824 usb_debug_str_buffer(
825 (const uint8_t *) request->setup_buffer, 8, 8));
826 usb_device_request_setup_packet_t * setup_request =
827 (usb_device_request_setup_packet_t*)
828 request->setup_buffer;
829 switch (setup_request->request) {
830 case USB_DEVREQ_GET_STATUS:
831 case USB_DEVREQ_GET_DESCRIPTOR:
832 case USB_DEVREQ_GET_CONFIGURATION:
833 usb_log_debug("processing request with output\n");
834 opResult = process_request_with_output(
835 instance, request);
836 break;
837 case USB_DEVREQ_CLEAR_FEATURE:
838 case USB_DEVREQ_SET_FEATURE:
839 case USB_DEVREQ_SET_ADDRESS:
840 usb_log_debug("processing request without "
841 "additional data\n");
842 opResult = process_request_without_data(
843 instance, request);
844 break;
845 case USB_DEVREQ_SET_DESCRIPTOR:
846 case USB_DEVREQ_SET_CONFIGURATION:
847 usb_log_debug("processing request with "
848 "input\n");
849 opResult = process_request_with_input(
850 instance, request);
851 break;
852 default:
853 usb_log_warning("received unsuported request: "
854 "%d\n",
855 setup_request->request
856 );
857 opResult = ENOTSUP;
858 }
859 return opResult;
860}
861
862/**
863 * @}
864 */
Note: See TracBrowser for help on using the repository browser.