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

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

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