source: mainline/uspace/drv/ohci/root_hub.c@ dc4c19e

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

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