source: mainline/uspace/drv/bus/usb/ohci/hc.c@ 8d40181

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

usb: Move HC driver implementation functions to a separate structure.
  • Property mode set to 100644
File size: 17.2 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
29/** @addtogroup drvusbohcihc
30 * @{
31 */
32/** @file
33 * @brief OHCI Host controller driver routines
34 */
35
36#include <errno.h>
37#include <str_error.h>
38#include <adt/list.h>
39#include <libarch/ddi.h>
40
41#include <usb/debug.h>
42#include <usb/usb.h>
43
44#include "hc.h"
45#include "ohci_endpoint.h"
46
47#define OHCI_USED_INTERRUPTS \
48 (I_SO | I_WDH | I_UE | I_RHSC)
49
50static const irq_pio_range_t ohci_pio_ranges[] = {
51 {
52 .base = 0,
53 .size = sizeof(ohci_regs_t)
54 }
55};
56
57static const irq_cmd_t ohci_irq_commands[] = {
58 {
59 .cmd = CMD_PIO_READ_32,
60 .dstarg = 1,
61 .addr = NULL
62 },
63 {
64 .cmd = CMD_AND,
65 .srcarg = 1,
66 .dstarg = 2,
67 .value = 0
68 },
69 {
70 .cmd = CMD_PREDICATE,
71 .srcarg = 2,
72 .value = 2
73 },
74 {
75 .cmd = CMD_PIO_WRITE_A_32,
76 .srcarg = 1,
77 .addr = NULL
78 },
79 {
80 .cmd = CMD_ACCEPT
81 }
82};
83
84static void hc_gain_control(hc_t *instance);
85static void hc_start(hc_t *instance);
86static int hc_init_transfer_lists(hc_t *instance);
87static int hc_init_memory(hc_t *instance);
88static int interrupt_emulator(hc_t *instance);
89
90/** Get number of PIO ranges used in IRQ code.
91 * @return Number of ranges.
92 */
93size_t hc_irq_pio_range_count(void)
94{
95 return sizeof(ohci_pio_ranges) / sizeof(irq_pio_range_t);
96}
97
98/** Get number of commands used in IRQ code.
99 * @return Number of commands.
100 */
101size_t hc_irq_cmd_count(void)
102{
103 return sizeof(ohci_irq_commands) / sizeof(irq_cmd_t);
104}
105
106/** Generate IRQ code.
107 * @param[out] ranges PIO ranges buffer.
108 * @param[in] ranges_size Size of the ranges buffer (bytes).
109 * @param[out] cmds Commands buffer.
110 * @param[in] cmds_size Size of the commands buffer (bytes).
111 * @param[in] regs Device's register range.
112 *
113 * @return Error code.
114 */
115int
116hc_get_irq_code(irq_pio_range_t ranges[], size_t ranges_size, irq_cmd_t cmds[],
117 size_t cmds_size, addr_range_t *regs)
118{
119 if ((ranges_size < sizeof(ohci_pio_ranges)) ||
120 (cmds_size < sizeof(ohci_irq_commands)) ||
121 (RNGSZ(*regs) < sizeof(ohci_regs_t)))
122 return EOVERFLOW;
123
124 memcpy(ranges, ohci_pio_ranges, sizeof(ohci_pio_ranges));
125 ranges[0].base = RNGABS(*regs);
126
127 memcpy(cmds, ohci_irq_commands, sizeof(ohci_irq_commands));
128 ohci_regs_t *registers = (ohci_regs_t *) RNGABSPTR(*regs);
129 cmds[0].addr = (void *) &registers->interrupt_status;
130 cmds[3].addr = (void *) &registers->interrupt_status;
131 OHCI_WR(cmds[1].value, OHCI_USED_INTERRUPTS);
132
133 return EOK;
134}
135
136/** Register interrupt handler.
137 *
138 * @param[in] device Host controller DDF device
139 * @param[in] regs Register range
140 * @param[in] irq Interrupt number
141 * @paran[in] handler Interrupt handler
142 *
143 * @return EOK on success or negative error code
144 */
145int hc_register_irq_handler(ddf_dev_t *device, addr_range_t *regs, int irq,
146 interrupt_handler_t handler)
147{
148 int rc;
149
150 irq_pio_range_t irq_ranges[hc_irq_pio_range_count()];
151 irq_cmd_t irq_cmds[hc_irq_cmd_count()];
152
153 irq_code_t irq_code = {
154 .rangecount = hc_irq_pio_range_count(),
155 .ranges = irq_ranges,
156 .cmdcount = hc_irq_cmd_count(),
157 .cmds = irq_cmds
158 };
159
160 rc = hc_get_irq_code(irq_ranges, sizeof(irq_ranges), irq_cmds,
161 sizeof(irq_cmds), regs);
162 if (rc != EOK) {
163 usb_log_error("Failed to generate IRQ code: %s.\n",
164 str_error(rc));
165 return rc;
166 }
167
168 /* Register handler to avoid interrupt lockup */
169 rc = register_interrupt_handler(device, irq, handler, &irq_code);
170 if (rc != EOK) {
171 usb_log_error("Failed to register interrupt handler: %s.\n",
172 str_error(rc));
173 return rc;
174 }
175
176 return EOK;
177}
178
179/** Initialize OHCI hc driver structure
180 *
181 * @param[in] instance Memory place for the structure.
182 * @param[in] regs Device's I/O registers range.
183 * @param[in] interrupts True if w interrupts should be used
184 * @return Error code
185 */
186int hc_init(hc_t *instance, addr_range_t *regs, bool interrupts)
187{
188 assert(instance);
189
190 int ret = pio_enable_range(regs, (void **) &instance->registers);
191 if (ret != EOK) {
192 usb_log_error("Failed to gain access to device registers: %s.\n",
193 str_error(ret));
194 return ret;
195 }
196
197 list_initialize(&instance->pending_batches);
198 fibril_mutex_initialize(&instance->guard);
199
200 ret = hc_init_memory(instance);
201 if (ret != EOK) {
202 usb_log_error("Failed to create OHCI memory structures: %s.\n",
203 str_error(ret));
204 return ret;
205 }
206
207 hc_gain_control(instance);
208
209 if (!interrupts) {
210 instance->interrupt_emulator =
211 fibril_create((int(*)(void*))interrupt_emulator, instance);
212 fibril_add_ready(instance->interrupt_emulator);
213 }
214
215 ohci_rh_init(&instance->rh, instance->registers, "ohci rh");
216 hc_start(instance);
217
218 return EOK;
219}
220
221void hc_enqueue_endpoint(hc_t *instance, const endpoint_t *ep)
222{
223 assert(instance);
224 assert(ep);
225
226 endpoint_list_t *list = &instance->lists[ep->transfer_type];
227 ohci_endpoint_t *ohci_ep = ohci_endpoint_get(ep);
228 assert(list);
229 assert(ohci_ep);
230
231 /* Enqueue ep */
232 switch (ep->transfer_type) {
233 case USB_TRANSFER_CONTROL:
234 OHCI_CLR(instance->registers->control, C_CLE);
235 endpoint_list_add_ep(list, ohci_ep);
236 OHCI_WR(instance->registers->control_current, 0);
237 OHCI_SET(instance->registers->control, C_CLE);
238 break;
239 case USB_TRANSFER_BULK:
240 OHCI_CLR(instance->registers->control, C_BLE);
241 endpoint_list_add_ep(list, ohci_ep);
242 OHCI_WR(instance->registers->bulk_current, 0);
243 OHCI_SET(instance->registers->control, C_BLE);
244 break;
245 case USB_TRANSFER_ISOCHRONOUS:
246 case USB_TRANSFER_INTERRUPT:
247 OHCI_CLR(instance->registers->control, C_PLE | C_IE);
248 endpoint_list_add_ep(list, ohci_ep);
249 OHCI_SET(instance->registers->control, C_PLE | C_IE);
250 break;
251 }
252}
253
254void hc_dequeue_endpoint(hc_t *instance, const endpoint_t *ep)
255{
256 assert(instance);
257 assert(ep);
258
259 /* Dequeue ep */
260 endpoint_list_t *list = &instance->lists[ep->transfer_type];
261 ohci_endpoint_t *ohci_ep = ohci_endpoint_get(ep);
262
263 assert(list);
264 assert(ohci_ep);
265 switch (ep->transfer_type) {
266 case USB_TRANSFER_CONTROL:
267 OHCI_CLR(instance->registers->control, C_CLE);
268 endpoint_list_remove_ep(list, ohci_ep);
269 OHCI_WR(instance->registers->control_current, 0);
270 OHCI_SET(instance->registers->control, C_CLE);
271 break;
272 case USB_TRANSFER_BULK:
273 OHCI_CLR(instance->registers->control, C_BLE);
274 endpoint_list_remove_ep(list, ohci_ep);
275 OHCI_WR(instance->registers->bulk_current, 0);
276 OHCI_SET(instance->registers->control, C_BLE);
277 break;
278 case USB_TRANSFER_ISOCHRONOUS:
279 case USB_TRANSFER_INTERRUPT:
280 OHCI_CLR(instance->registers->control, C_PLE | C_IE);
281 endpoint_list_remove_ep(list, ohci_ep);
282 OHCI_SET(instance->registers->control, C_PLE | C_IE);
283 break;
284 default:
285 break;
286 }
287}
288
289/** Add USB transfer to the schedule.
290 *
291 * @param[in] instance OHCI hc driver structure.
292 * @param[in] batch Batch representing the transfer.
293 * @return Error code.
294 */
295int hc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch)
296{
297 assert(hcd);
298 hc_t *instance = hcd->driver.data;
299 assert(instance);
300
301 /* Check for root hub communication */
302 if (batch->ep->address == ohci_rh_get_address(&instance->rh)) {
303 usb_log_debug("OHCI root hub request.\n");
304 return ohci_rh_schedule(&instance->rh, batch);
305 }
306 ohci_transfer_batch_t *ohci_batch = ohci_transfer_batch_get(batch);
307 if (!ohci_batch)
308 return ENOMEM;
309
310 fibril_mutex_lock(&instance->guard);
311 list_append(&ohci_batch->link, &instance->pending_batches);
312 ohci_transfer_batch_commit(ohci_batch);
313
314 /* Control and bulk schedules need a kick to start working */
315 switch (batch->ep->transfer_type)
316 {
317 case USB_TRANSFER_CONTROL:
318 OHCI_SET(instance->registers->command_status, CS_CLF);
319 break;
320 case USB_TRANSFER_BULK:
321 OHCI_SET(instance->registers->command_status, CS_BLF);
322 break;
323 default:
324 break;
325 }
326 fibril_mutex_unlock(&instance->guard);
327 return EOK;
328}
329
330/** Interrupt handling routine
331 *
332 * @param[in] instance OHCI hc driver structure.
333 * @param[in] status Value of the status register at the time of interrupt.
334 */
335void hc_interrupt(hc_t *instance, uint32_t status)
336{
337 status = OHCI_RD(status);
338 assert(instance);
339 if ((status & ~I_SF) == 0) /* ignore sof status */
340 return;
341 usb_log_debug2("OHCI(%p) interrupt: %x.\n", instance, status);
342 if (status & I_RHSC)
343 ohci_rh_interrupt(&instance->rh);
344
345 if (status & I_WDH) {
346 fibril_mutex_lock(&instance->guard);
347 usb_log_debug2("HCCA: %p-%#" PRIx32 " (%p).\n", instance->hcca,
348 OHCI_RD(instance->registers->hcca),
349 (void *) addr_to_phys(instance->hcca));
350 usb_log_debug2("Periodic current: %#" PRIx32 ".\n",
351 OHCI_RD(instance->registers->periodic_current));
352
353 link_t *current = list_first(&instance->pending_batches);
354 while (current && current != &instance->pending_batches.head) {
355 link_t *next = current->next;
356 ohci_transfer_batch_t *batch =
357 ohci_transfer_batch_from_link(current);
358
359 if (ohci_transfer_batch_is_complete(batch)) {
360 list_remove(current);
361 ohci_transfer_batch_finish_dispose(batch);
362 }
363
364 current = next;
365 }
366 fibril_mutex_unlock(&instance->guard);
367 }
368
369 if (status & I_UE) {
370 usb_log_fatal("Error like no other!\n");
371 hc_start(instance);
372 }
373
374}
375
376/** Check status register regularly
377 *
378 * @param[in] instance OHCI hc driver structure.
379 * @return Error code
380 */
381int interrupt_emulator(hc_t *instance)
382{
383 assert(instance);
384 usb_log_info("Started interrupt emulator.\n");
385 while (1) {
386 const uint32_t status = instance->registers->interrupt_status;
387 instance->registers->interrupt_status = status;
388 hc_interrupt(instance, status);
389 async_usleep(10000);
390 }
391 return EOK;
392}
393
394/** Turn off any (BIOS)driver that might be in control of the device.
395 *
396 * This function implements routines described in chapter 5.1.1.3 of the OHCI
397 * specification (page 40, pdf page 54).
398 *
399 * @param[in] instance OHCI hc driver structure.
400 */
401void hc_gain_control(hc_t *instance)
402{
403 assert(instance);
404
405 usb_log_debug("Requesting OHCI control.\n");
406 if (OHCI_RD(instance->registers->revision) & R_LEGACY_FLAG) {
407 /* Turn off legacy emulation, it should be enough to zero
408 * the lowest bit, but it caused problems. Thus clear all
409 * except GateA20 (causes restart on some hw).
410 * See page 145 of the specs for details.
411 */
412 volatile uint32_t *ohci_emulation_reg =
413 (uint32_t*)((char*)instance->registers + LEGACY_REGS_OFFSET);
414 usb_log_debug("OHCI legacy register %p: %x.\n",
415 ohci_emulation_reg, OHCI_RD(*ohci_emulation_reg));
416 /* Zero everything but A20State */
417 OHCI_CLR(*ohci_emulation_reg, ~0x100);
418 usb_log_debug(
419 "OHCI legacy register (should be 0 or 0x100) %p: %x.\n",
420 ohci_emulation_reg, OHCI_RD(*ohci_emulation_reg));
421 }
422
423 /* Interrupt routing enabled => smm driver is active */
424 if (OHCI_RD(instance->registers->control) & C_IR) {
425 usb_log_debug("SMM driver: request ownership change.\n");
426 OHCI_SET(instance->registers->command_status, CS_OCR);
427 /* Hope that SMM actually knows its stuff or we can hang here */
428 while (OHCI_RD(instance->registers->control & C_IR)) {
429 async_usleep(1000);
430 }
431 usb_log_info("SMM driver: Ownership taken.\n");
432 C_HCFS_SET(instance->registers->control, C_HCFS_RESET);
433 async_usleep(50000);
434 return;
435 }
436
437 const unsigned hc_status = C_HCFS_GET(instance->registers->control);
438 /* Interrupt routing disabled && status != USB_RESET => BIOS active */
439 if (hc_status != C_HCFS_RESET) {
440 usb_log_debug("BIOS driver found.\n");
441 if (hc_status == C_HCFS_OPERATIONAL) {
442 usb_log_info("BIOS driver: HC operational.\n");
443 return;
444 }
445 /* HC is suspended assert resume for 20ms */
446 C_HCFS_SET(instance->registers->control, C_HCFS_RESUME);
447 async_usleep(20000);
448 usb_log_info("BIOS driver: HC resumed.\n");
449 return;
450 }
451
452 /* HC is in reset (hw startup) => no other driver
453 * maintain reset for at least the time specified in USB spec (50 ms)*/
454 usb_log_debug("Host controller found in reset state.\n");
455 async_usleep(50000);
456}
457
458/** OHCI hw initialization routine.
459 *
460 * @param[in] instance OHCI hc driver structure.
461 */
462void hc_start(hc_t *instance)
463{
464 /* OHCI guide page 42 */
465 assert(instance);
466 usb_log_debug2("Started hc initialization routine.\n");
467
468 /* Save contents of fm_interval register */
469 const uint32_t fm_interval = OHCI_RD(instance->registers->fm_interval);
470 usb_log_debug2("Old value of HcFmInterval: %x.\n", fm_interval);
471
472 /* Reset hc */
473 usb_log_debug2("HC reset.\n");
474 size_t time = 0;
475 OHCI_WR(instance->registers->command_status, CS_HCR);
476 while (OHCI_RD(instance->registers->command_status) & CS_HCR) {
477 async_usleep(10);
478 time += 10;
479 }
480 usb_log_debug2("HC reset complete in %zu us.\n", time);
481
482 /* Restore fm_interval */
483 OHCI_WR(instance->registers->fm_interval, fm_interval);
484 assert((OHCI_RD(instance->registers->command_status) & CS_HCR) == 0);
485
486 /* hc is now in suspend state */
487 usb_log_debug2("HC should be in suspend state(%x).\n",
488 OHCI_RD(instance->registers->control));
489
490 /* Use HCCA */
491 OHCI_WR(instance->registers->hcca, addr_to_phys(instance->hcca));
492
493 /* Use queues */
494 OHCI_WR(instance->registers->bulk_head,
495 instance->lists[USB_TRANSFER_BULK].list_head_pa);
496 usb_log_debug2("Bulk HEAD set to: %p (%#" PRIx32 ").\n",
497 instance->lists[USB_TRANSFER_BULK].list_head,
498 instance->lists[USB_TRANSFER_BULK].list_head_pa);
499
500 OHCI_WR(instance->registers->control_head,
501 instance->lists[USB_TRANSFER_CONTROL].list_head_pa);
502 usb_log_debug2("Control HEAD set to: %p (%#" PRIx32 ").\n",
503 instance->lists[USB_TRANSFER_CONTROL].list_head,
504 instance->lists[USB_TRANSFER_CONTROL].list_head_pa);
505
506 /* Enable queues */
507 OHCI_SET(instance->registers->control, (C_PLE | C_IE | C_CLE | C_BLE));
508 usb_log_debug("Queues enabled(%x).\n",
509 OHCI_RD(instance->registers->control));
510
511 /* Enable interrupts */
512 OHCI_WR(instance->registers->interrupt_enable, OHCI_USED_INTERRUPTS);
513 usb_log_debug("Enabled interrupts: %x.\n",
514 OHCI_RD(instance->registers->interrupt_enable));
515 OHCI_WR(instance->registers->interrupt_enable, I_MI);
516
517 /* Set periodic start to 90% */
518 const uint32_t frame_length =
519 (fm_interval >> FMI_FI_SHIFT) & FMI_FI_MASK;
520 OHCI_WR(instance->registers->periodic_start,
521 ((frame_length / 10) * 9) & PS_MASK << PS_SHIFT);
522 usb_log_debug2("All periodic start set to: %x(%u - 90%% of %d).\n",
523 OHCI_RD(instance->registers->periodic_start),
524 OHCI_RD(instance->registers->periodic_start), frame_length);
525 C_HCFS_SET(instance->registers->control, C_HCFS_OPERATIONAL);
526 usb_log_debug("OHCI HC up and running (ctl_reg=0x%x).\n",
527 OHCI_RD(instance->registers->control));
528}
529
530/** Initialize schedule queues
531 *
532 * @param[in] instance OHCI hc driver structure
533 * @return Error code
534 */
535int hc_init_transfer_lists(hc_t *instance)
536{
537 assert(instance);
538#define SETUP_ENDPOINT_LIST(type) \
539do { \
540 const char *name = usb_str_transfer_type(type); \
541 const int ret = endpoint_list_init(&instance->lists[type], name); \
542 if (ret != EOK) { \
543 usb_log_error("Failed to setup %s endpoint list: %s.\n", \
544 name, str_error(ret)); \
545 endpoint_list_fini(&instance->lists[USB_TRANSFER_ISOCHRONOUS]);\
546 endpoint_list_fini(&instance->lists[USB_TRANSFER_INTERRUPT]); \
547 endpoint_list_fini(&instance->lists[USB_TRANSFER_CONTROL]); \
548 endpoint_list_fini(&instance->lists[USB_TRANSFER_BULK]); \
549 return ret; \
550 } \
551} while (0)
552
553 SETUP_ENDPOINT_LIST(USB_TRANSFER_ISOCHRONOUS);
554 SETUP_ENDPOINT_LIST(USB_TRANSFER_INTERRUPT);
555 SETUP_ENDPOINT_LIST(USB_TRANSFER_CONTROL);
556 SETUP_ENDPOINT_LIST(USB_TRANSFER_BULK);
557#undef SETUP_ENDPOINT_LIST
558 endpoint_list_set_next(&instance->lists[USB_TRANSFER_INTERRUPT],
559 &instance->lists[USB_TRANSFER_ISOCHRONOUS]);
560
561 return EOK;
562}
563
564/** Initialize memory structures used by the OHCI hcd.
565 *
566 * @param[in] instance OHCI hc driver structure.
567 * @return Error code.
568 */
569int hc_init_memory(hc_t *instance)
570{
571 assert(instance);
572
573 memset(&instance->rh, 0, sizeof(instance->rh));
574 /* Init queues */
575 const int ret = hc_init_transfer_lists(instance);
576 if (ret != EOK) {
577 return ret;
578 }
579
580 /*Init HCCA */
581 instance->hcca = hcca_get();
582 if (instance->hcca == NULL)
583 return ENOMEM;
584 usb_log_debug2("OHCI HCCA initialized at %p.\n", instance->hcca);
585
586 for (unsigned i = 0; i < HCCA_INT_EP_COUNT; ++i) {
587 hcca_set_int_ep(instance->hcca, i,
588 instance->lists[USB_TRANSFER_INTERRUPT].list_head_pa);
589 }
590 usb_log_debug2("Interrupt HEADs set to: %p (%#" PRIx32 ").\n",
591 instance->lists[USB_TRANSFER_INTERRUPT].list_head,
592 instance->lists[USB_TRANSFER_INTERRUPT].list_head_pa);
593
594 return EOK;
595}
596
597/**
598 * @}
599 */
Note: See TracBrowser for help on using the repository browser.