source: mainline/uspace/drv/bus/usb/ehci/hc.c@ 928afc8d

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 928afc8d was a5b3de6, checked in by Ondřej Hlavatý <aearsis@…>, 8 years ago

usbhost endpoint: removed target

The reasons for having usb_target_t inside endpoint have been dismissed. Enpoint is not a target of a transaction, so this was just misleading.
  • Property mode set to 100644
File size: 14.8 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 drvusbehcihc
30 * @{
31 */
32/** @file
33 * @brief EHCI Host controller driver routines
34 */
35
36#include <assert.h>
37#include <async.h>
38#include <errno.h>
39#include <macros.h>
40#include <mem.h>
41#include <stdlib.h>
42#include <stdint.h>
43#include <str_error.h>
44
45#include <usb/debug.h>
46#include <usb/usb.h>
47#include <usb/host/utils/malloc32.h>
48
49#include "ehci_batch.h"
50
51#include "hc.h"
52
53#define EHCI_USED_INTERRUPTS \
54 (USB_INTR_IRQ_FLAG | USB_INTR_ERR_IRQ_FLAG | USB_INTR_PORT_CHANGE_FLAG | \
55 USB_INTR_ASYNC_ADVANCE_FLAG | USB_INTR_HOST_ERR_FLAG)
56
57static const irq_pio_range_t ehci_pio_ranges[] = {
58 {
59 .base = 0,
60 .size = sizeof(ehci_regs_t)
61 }
62};
63
64static const irq_cmd_t ehci_irq_commands[] = {
65 {
66 .cmd = CMD_PIO_READ_32,
67 .dstarg = 1,
68 .addr = NULL
69 },
70 {
71 .cmd = CMD_AND,
72 .srcarg = 1,
73 .dstarg = 2,
74 .value = 0
75 },
76 {
77 .cmd = CMD_PREDICATE,
78 .srcarg = 2,
79 .value = 2
80 },
81 {
82 .cmd = CMD_PIO_WRITE_A_32,
83 .srcarg = 1,
84 .addr = NULL
85 },
86 {
87 .cmd = CMD_ACCEPT
88 }
89};
90
91static int hc_init_memory(hc_t *instance);
92
93/** Generate IRQ code.
94 * @param[out] ranges PIO ranges buffer.
95 * @param[in] hw_res Device's resources.
96 *
97 * @return Error code.
98 */
99int ehci_hc_gen_irq_code(irq_code_t *code, hcd_t *hcd, const hw_res_list_parsed_t *hw_res)
100{
101 assert(code);
102 assert(hw_res);
103
104 hc_t *instance = hcd_get_driver_data(hcd);
105
106 if (hw_res->irqs.count != 1 || hw_res->mem_ranges.count != 1)
107 return EINVAL;
108
109 addr_range_t regs = hw_res->mem_ranges.ranges[0];
110
111 if (RNGSZ(regs) < sizeof(ehci_regs_t))
112 return EOVERFLOW;
113
114 code->ranges = malloc(sizeof(ehci_pio_ranges));
115 if (code->ranges == NULL)
116 return ENOMEM;
117
118 code->cmds = malloc(sizeof(ehci_irq_commands));
119 if (code->cmds == NULL) {
120 free(code->ranges);
121 return ENOMEM;
122 }
123
124 code->rangecount = ARRAY_SIZE(ehci_pio_ranges);
125 code->cmdcount = ARRAY_SIZE(ehci_irq_commands);
126
127 memcpy(code->ranges, ehci_pio_ranges, sizeof(ehci_pio_ranges));
128 code->ranges[0].base = RNGABS(regs);
129
130 memcpy(code->cmds, ehci_irq_commands, sizeof(ehci_irq_commands));
131
132 ehci_regs_t *registers =
133 (ehci_regs_t *)(RNGABSPTR(regs) + EHCI_RD8(instance->caps->caplength));
134 code->cmds[0].addr = (void *) &registers->usbsts;
135 code->cmds[3].addr = (void *) &registers->usbsts;
136 EHCI_WR(code->cmds[1].value, EHCI_USED_INTERRUPTS);
137
138 usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.\n",
139 RNGABSPTR(regs), RNGSZ(regs), hw_res->irqs.irqs[0]);
140
141 return hw_res->irqs.irqs[0];
142}
143
144/** Initialize EHCI hc driver structure
145 *
146 * @param[in] instance Memory place for the structure.
147 * @param[in] regs Device's I/O registers range.
148 * @param[in] interrupts True if w interrupts should be used
149 * @return Error code
150 */
151int hc_init(hc_t *instance, const hw_res_list_parsed_t *hw_res)
152{
153 assert(instance);
154 assert(hw_res);
155 if (hw_res->mem_ranges.count != 1 ||
156 hw_res->mem_ranges.ranges[0].size <
157 (sizeof(ehci_caps_regs_t) + sizeof(ehci_regs_t)))
158 return EINVAL;
159
160 int ret = pio_enable_range(&hw_res->mem_ranges.ranges[0],
161 (void **)&instance->caps);
162 if (ret != EOK) {
163 usb_log_error("HC(%p): Failed to gain access to device "
164 "registers: %s.\n", instance, str_error(ret));
165 return ret;
166 }
167
168 usb_log_info("HC(%p): Device registers at %"PRIx64" (%zuB) accessible.",
169 instance, hw_res->mem_ranges.ranges[0].address.absolute,
170 hw_res->mem_ranges.ranges[0].size);
171 instance->registers =
172 (void*)instance->caps + EHCI_RD8(instance->caps->caplength);
173 usb_log_info("HC(%p): Device control registers at %" PRIx64, instance,
174 hw_res->mem_ranges.ranges[0].address.absolute
175 + EHCI_RD8(instance->caps->caplength));
176
177 list_initialize(&instance->pending_batches);
178 fibril_mutex_initialize(&instance->guard);
179 fibril_condvar_initialize(&instance->async_doorbell);
180
181 ret = hc_init_memory(instance);
182 if (ret != EOK) {
183 usb_log_error("HC(%p): Failed to create EHCI memory structures:"
184 " %s.", instance, str_error(ret));
185 return ret;
186 }
187
188 usb_log_info("HC(%p): Initializing RH(%p).", instance, &instance->rh);
189 ehci_rh_init(
190 &instance->rh, instance->caps, instance->registers, "ehci rh");
191
192 ehci_bus_init(&instance->bus, instance);
193 return EOK;
194}
195
196/** Safely dispose host controller internal structures
197 *
198 * @param[in] instance Host controller structure to use.
199 */
200void hc_fini(hc_t *instance)
201{
202 assert(instance);
203 //TODO: stop the hw
204#if 0
205 endpoint_list_fini(&instance->async_list);
206 endpoint_list_fini(&instance->int_list);
207 return_page(instance->periodic_list_base);
208#endif
209};
210
211void hc_enqueue_endpoint(hc_t *instance, const endpoint_t *ep)
212{
213 assert(instance);
214 assert(ep);
215 ehci_endpoint_t *ehci_ep = ehci_endpoint_get(ep);
216 usb_log_debug("HC(%p) enqueue EP(%d:%d:%s:%s)\n", instance,
217 ep->device->address, ep->endpoint,
218 usb_str_transfer_type_short(ep->transfer_type),
219 usb_str_direction(ep->direction));
220 switch (ep->transfer_type)
221 {
222 case USB_TRANSFER_CONTROL:
223 case USB_TRANSFER_BULK:
224 endpoint_list_append_ep(&instance->async_list, ehci_ep);
225 break;
226 case USB_TRANSFER_INTERRUPT:
227 endpoint_list_append_ep(&instance->int_list, ehci_ep);
228 break;
229 case USB_TRANSFER_ISOCHRONOUS:
230 /* NOT SUPPORTED */
231 break;
232 }
233}
234
235void hc_dequeue_endpoint(hc_t *instance, const endpoint_t *ep)
236{
237 assert(instance);
238 assert(ep);
239 ehci_endpoint_t *ehci_ep = ehci_endpoint_get(ep);
240 usb_log_debug("HC(%p) dequeue EP(%d:%d:%s:%s)\n", instance,
241 ep->device->address, ep->endpoint,
242 usb_str_transfer_type_short(ep->transfer_type),
243 usb_str_direction(ep->direction));
244 switch (ep->transfer_type)
245 {
246 case USB_TRANSFER_INTERRUPT:
247 endpoint_list_remove_ep(&instance->int_list, ehci_ep);
248 /* Fall through */
249 case USB_TRANSFER_ISOCHRONOUS:
250 /* NOT SUPPORTED */
251 return;
252 case USB_TRANSFER_CONTROL:
253 case USB_TRANSFER_BULK:
254 endpoint_list_remove_ep(&instance->async_list, ehci_ep);
255 break;
256 }
257 fibril_mutex_lock(&instance->guard);
258 usb_log_debug("HC(%p): Waiting for doorbell", instance);
259 EHCI_SET(instance->registers->usbcmd, USB_CMD_IRQ_ASYNC_DOORBELL);
260 fibril_condvar_wait(&instance->async_doorbell, &instance->guard);
261 usb_log_debug2("HC(%p): Got doorbell", instance);
262 fibril_mutex_unlock(&instance->guard);
263}
264
265int ehci_hc_status(hcd_t *hcd, uint32_t *status)
266{
267 assert(hcd);
268 hc_t *instance = hcd_get_driver_data(hcd);
269 assert(instance);
270 assert(status);
271 *status = 0;
272 if (instance->registers) {
273 *status = EHCI_RD(instance->registers->usbsts);
274 EHCI_WR(instance->registers->usbsts, *status);
275 }
276 usb_log_debug2("HC(%p): Read status: %x", instance, *status);
277 return EOK;
278}
279
280/** Add USB transfer to the schedule.
281 *
282 * @param[in] hcd HCD driver structure.
283 * @param[in] batch Batch representing the transfer.
284 * @return Error code.
285 */
286int ehci_hc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch)
287{
288 assert(hcd);
289 hc_t *instance = hcd_get_driver_data(hcd);
290 assert(instance);
291
292 /* Check for root hub communication */
293 if (batch->target.address == ehci_rh_get_address(&instance->rh)) {
294 usb_log_debug("HC(%p): Scheduling BATCH(%p) for RH(%p)",
295 instance, batch, &instance->rh);
296 return ehci_rh_schedule(&instance->rh, batch);
297 }
298
299 ehci_transfer_batch_t *ehci_batch = ehci_transfer_batch_get(batch);
300
301 const int err = ehci_transfer_batch_prepare(ehci_batch);
302 if (err)
303 return err;
304
305 fibril_mutex_lock(&instance->guard);
306 usb_log_debug2("HC(%p): Appending BATCH(%p)", instance, batch);
307 list_append(&ehci_batch->link, &instance->pending_batches);
308 usb_log_debug("HC(%p): Committing BATCH(%p)", instance, batch);
309 ehci_transfer_batch_commit(ehci_batch);
310
311 fibril_mutex_unlock(&instance->guard);
312 return EOK;
313}
314
315/** Interrupt handling routine
316 *
317 * @param[in] hcd HCD driver structure.
318 * @param[in] status Value of the status register at the time of interrupt.
319 */
320void ehci_hc_interrupt(hcd_t *hcd, uint32_t status)
321{
322 assert(hcd);
323 hc_t *instance = hcd_get_driver_data(hcd);
324 status = EHCI_RD(status);
325 assert(instance);
326
327 usb_log_debug2("HC(%p): Interrupt: %"PRIx32, instance, status);
328 if (status & USB_STS_PORT_CHANGE_FLAG) {
329 ehci_rh_interrupt(&instance->rh);
330 }
331
332 if (status & USB_STS_IRQ_ASYNC_ADVANCE_FLAG) {
333 fibril_mutex_lock(&instance->guard);
334 usb_log_debug2("HC(%p): Signaling doorbell", instance);
335 fibril_condvar_broadcast(&instance->async_doorbell);
336 fibril_mutex_unlock(&instance->guard);
337 }
338
339 if (status & (USB_STS_IRQ_FLAG | USB_STS_ERR_IRQ_FLAG)) {
340 fibril_mutex_lock(&instance->guard);
341
342 usb_log_debug2("HC(%p): Scanning %lu pending batches", instance,
343 list_count(&instance->pending_batches));
344 list_foreach_safe(instance->pending_batches, current, next) {
345 ehci_transfer_batch_t *batch =
346 ehci_transfer_batch_from_link(current);
347
348 if (ehci_transfer_batch_check_completed(batch)) {
349 list_remove(current);
350 usb_transfer_batch_finish(&batch->base);
351 }
352 }
353 fibril_mutex_unlock(&instance->guard);
354 }
355
356 if (status & USB_STS_HOST_ERROR_FLAG) {
357 usb_log_fatal("HCD(%p): HOST SYSTEM ERROR!", instance);
358 //TODO do something here
359 }
360}
361
362/** EHCI hw initialization routine.
363 *
364 * @param[in] instance EHCI hc driver structure.
365 */
366int hc_start(hc_t *instance, bool interrupts)
367{
368 assert(instance);
369 usb_log_debug("HC(%p): Starting HW.", instance);
370
371 /* Turn off the HC if it's running, Reseting a running device is
372 * undefined */
373 if (!(EHCI_RD(instance->registers->usbsts) & USB_STS_HC_HALTED_FLAG)) {
374 /* disable all interrupts */
375 EHCI_WR(instance->registers->usbintr, 0);
376 /* ack all interrupts */
377 EHCI_WR(instance->registers->usbsts, 0x3f);
378 /* Stop HC hw */
379 EHCI_WR(instance->registers->usbcmd, 0);
380 /* Wait until hc is halted */
381 while ((EHCI_RD(instance->registers->usbsts) & USB_STS_HC_HALTED_FLAG) == 0) {
382 async_usleep(1);
383 }
384 usb_log_info("HC(%p): EHCI turned off.", instance);
385 } else {
386 usb_log_info("HC(%p): EHCI was not running.", instance);
387 }
388
389 /* Hw initialization sequence, see page 53 (pdf 63) */
390 EHCI_SET(instance->registers->usbcmd, USB_CMD_HC_RESET_FLAG);
391 usb_log_info("HC(%p): Waiting for HW reset.", instance);
392 while (EHCI_RD(instance->registers->usbcmd) & USB_CMD_HC_RESET_FLAG) {
393 async_usleep(1);
394 }
395 usb_log_debug("HC(%p): HW reset OK.", instance);
396
397 /* Use the lowest 4G segment */
398 EHCI_WR(instance->registers->ctrldssegment, 0);
399
400 /* Enable periodic list */
401 assert(instance->periodic_list_base);
402 uintptr_t phys_base =
403 addr_to_phys((void*)instance->periodic_list_base);
404 assert((phys_base & USB_PERIODIC_LIST_BASE_MASK) == phys_base);
405 EHCI_WR(instance->registers->periodiclistbase, phys_base);
406 EHCI_SET(instance->registers->usbcmd, USB_CMD_PERIODIC_SCHEDULE_FLAG);
407 usb_log_debug("HC(%p): Enabled periodic list.", instance);
408
409
410 /* Enable Async schedule */
411 phys_base = addr_to_phys((void*)instance->async_list.list_head);
412 assert((phys_base & USB_ASYNCLIST_MASK) == phys_base);
413 EHCI_WR(instance->registers->asynclistaddr, phys_base);
414 EHCI_SET(instance->registers->usbcmd, USB_CMD_ASYNC_SCHEDULE_FLAG);
415 usb_log_debug("HC(%p): Enabled async list.", instance);
416
417 /* Start hc and get all ports */
418 EHCI_SET(instance->registers->usbcmd, USB_CMD_RUN_FLAG);
419 EHCI_SET(instance->registers->configflag, USB_CONFIG_FLAG_FLAG);
420 usb_log_debug("HC(%p): HW started.", instance);
421
422 usb_log_debug2("HC(%p): Registers: \n"
423 "\tUSBCMD(%p): %x(0x00080000 = at least 1ms between interrupts)\n"
424 "\tUSBSTS(%p): %x(0x00001000 = HC halted)\n"
425 "\tUSBINT(%p): %x(0x0 = no interrupts).\n"
426 "\tCONFIG(%p): %x(0x0 = ports controlled by companion hc).\n",
427 instance,
428 &instance->registers->usbcmd, EHCI_RD(instance->registers->usbcmd),
429 &instance->registers->usbsts, EHCI_RD(instance->registers->usbsts),
430 &instance->registers->usbintr, EHCI_RD(instance->registers->usbintr),
431 &instance->registers->configflag, EHCI_RD(instance->registers->configflag));
432 /* Clear and Enable interrupts */
433 EHCI_WR(instance->registers->usbsts, EHCI_RD(instance->registers->usbsts));
434 EHCI_WR(instance->registers->usbintr, EHCI_USED_INTERRUPTS);
435
436 return EOK;
437}
438
439/** Initialize memory structures used by the EHCI hcd.
440 *
441 * @param[in] instance EHCI hc driver structure.
442 * @return Error code.
443 */
444int hc_init_memory(hc_t *instance)
445{
446 assert(instance);
447 usb_log_debug2("HC(%p): Initializing Async list(%p).", instance,
448 &instance->async_list);
449 int ret = endpoint_list_init(&instance->async_list, "ASYNC");
450 if (ret != EOK) {
451 usb_log_error("HC(%p): Failed to setup ASYNC list: %s",
452 instance, str_error(ret));
453 return ret;
454 }
455 /* Specs say "Software must set queue head horizontal pointer T-bits to
456 * a zero for queue heads in the asynchronous schedule" (4.4.0).
457 * So we must maintain circular buffer (all horizontal pointers
458 * have to be valid */
459 endpoint_list_chain(&instance->async_list, &instance->async_list);
460
461 usb_log_debug2("HC(%p): Initializing Interrupt list (%p).", instance,
462 &instance->int_list);
463 ret = endpoint_list_init(&instance->int_list, "INT");
464 if (ret != EOK) {
465 usb_log_error("HC(%p): Failed to setup INT list: %s",
466 instance, str_error(ret));
467 endpoint_list_fini(&instance->async_list);
468 return ret;
469 }
470
471 /* Take 1024 periodic list heads, we ignore low mem options */
472 instance->periodic_list_base = get_page();
473 if (!instance->periodic_list_base) {
474 usb_log_error("HC(%p): Failed to get ISO schedule page.",
475 instance);
476 endpoint_list_fini(&instance->async_list);
477 endpoint_list_fini(&instance->int_list);
478 return ENOMEM;
479 }
480
481 usb_log_debug2("HC(%p): Initializing Periodic list.", instance);
482 for (unsigned i = 0;
483 i < PAGE_SIZE/sizeof(instance->periodic_list_base[0]); ++i)
484 {
485 /* Disable everything for now */
486 instance->periodic_list_base[i] =
487 LINK_POINTER_QH(addr_to_phys(instance->int_list.list_head));
488 }
489 return EOK;
490}
491
492/**
493 * @}
494 */
Note: See TracBrowser for help on using the repository browser.