summaryrefslogtreecommitdiff
path: root/sys/dev/usb
diff options
context:
space:
mode:
Diffstat (limited to 'sys/dev/usb')
-rw-r--r--sys/dev/usb/xhci.c384
1 files changed, 384 insertions, 0 deletions
diff --git a/sys/dev/usb/xhci.c b/sys/dev/usb/xhci.c
new file mode 100644
index 0000000..d657b46
--- /dev/null
+++ b/sys/dev/usb/xhci.c
@@ -0,0 +1,384 @@
+/*
+ * Copyright (c) 2023-2024 Ian Marco Moffett and the Osmora Team.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of Hyra nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/driver.h>
+#include <dev/pci/pci.h>
+#include <sys/syslog.h>
+#include <sys/timer.h>
+#include <dev/usb/xhciregs.h>
+#include <dev/usb/xhcivar.h>
+#include <vm/physseg.h>
+#include <vm/dynalloc.h>
+#include <vm/page.h>
+#include <vm/vm.h>
+#include <string.h>
+#include <assert.h>
+
+__MODULE_NAME("xhci");
+__KERNEL_META("$Hyra$: xhci.c, Ian Marco Moffett, "
+ "xHCI driver");
+
+static struct pci_device *hci_dev;
+static struct timer driver_tmr;
+
+static inline uint32_t *
+xhci_get_portsc(struct xhci_hc *hc, uint8_t portno)
+{
+ if (portno > hc->maxports) {
+ portno = hc->maxports;
+ }
+ return XHCI_BASE_OFF(hc->opregs, 0x400 + (0x10 * (portno - 1)));
+}
+
+/*
+ * Set event ring segment table base
+ * address.
+ *
+ * @hc: Host controler descriptor.
+ * @pa: Physical address.
+ */
+static inline void
+xhci_set_erst_base(struct xhci_hc *hc, uintptr_t pa)
+{
+ struct xhci_caps *caps = XHCI_CAPS(hc->base);
+ void *runtime_base = XHCI_RTS(hc->base, caps->rtsoff);
+ uintptr_t *erstba;
+
+ /*
+ * The spec states that the Event Ring Segment Table
+ * Base Address register is at 'runtime_base + 0x30 +
+ * (32 * interrupter)'. See the xHCI spec, section 5.5.2.3.2
+ */
+ erstba = XHCI_BASE_OFF(runtime_base, 0x30);
+ *erstba = pa;
+}
+
+/*
+ * Set up an xHCI event ring segment.
+ */
+static int
+xhci_init_evring_segment(struct xhci_evring_segment *seg)
+{
+ size_t evring_size;
+ void *event_ring;
+
+ evring_size = XHCI_TRB_SIZE * XHCI_EVRING_LEN;
+ event_ring = dynalloc_memalign(evring_size, 64);
+
+ seg->base = VIRT_TO_PHYS(event_ring);
+ seg->size = XHCI_EVRING_LEN;
+ return 0;
+}
+
+/*
+ * Submit a command by pushing a TRB to the
+ * command ring.
+ *
+ * @hc: Host controller descriptor.
+ * @trb: Transfer Request Block of command.
+ */
+static int
+xhci_submit_cmd(struct xhci_hc *hc, struct xhci_trb trb)
+{
+ volatile uint32_t *cmd_db;
+ struct xhci_caps *caps = XHCI_CAPS(hc->base);
+
+ /* Push the TRB to the command ring */
+ cmd_db = XHCI_CMD_DB(hc->base, caps->dboff);
+ hc->cmd_ring[hc->cmd_ptr++] = trb;
+
+ /* Wrap if needed */
+ if (hc->cmd_ptr >= XHCI_CMDRING_LEN) {
+ hc->cmd_ptr = 0;
+ }
+
+ /* Ring the command doorbell */
+ *cmd_db = 0;
+ return 0;
+}
+
+/*
+ * Parse xHCI extended caps
+ */
+static int
+xhci_parse_ecp(struct xhci_hc *hc)
+{
+ struct xhci_caps *caps = XHCI_CAPS(hc->base);
+ struct xhci_proto *proto;
+ uint32_t *p, val, dword2;
+ uint32_t cap_ptr = XHCI_ECP(caps->hccparams1);
+
+ p = XHCI_BASE_OFF(hc->base, cap_ptr*4);
+ while (cap_ptr != 0) {
+ val = *p;
+ dword2 = *((uint32_t *)XHCI_BASE_OFF(p, 8));
+
+ /* Get the next cap */
+ p = XHCI_BASE_OFF(p, XHCI_PROTO_NEXT(val) * 4);
+ cap_ptr = XHCI_PROTO_NEXT(val);
+
+ if (XHCI_PROTO_ID(val) != XHCI_ECAP_PROTO) {
+ /* Not a Supported Protocol Capability */
+ continue;
+ }
+
+ if (hc->protocnt > XHCI_MAX_PROTOS) {
+ /* Too many protocols */
+ break;
+ }
+
+ proto = &hc->protos[hc->protocnt++];
+ proto->major = XHCI_PROTO_MAJOR(val);
+ proto->port_count = XHCI_PROTO_PORTCNT(dword2);
+ proto->port_start = XHCI_PROTO_PORTOFF(dword2);
+ }
+
+ return 0;
+}
+
+/*
+ * Set of xHCI scratchpad buffers.
+ */
+static int
+xhci_init_scratchpads(struct xhci_hc *hc)
+{
+ struct xhci_caps *caps = XHCI_CAPS(hc->base);
+ uint16_t max_bufs_lo, max_bufs_hi, max_bufs;
+ uintptr_t buffer_array;
+
+ max_bufs_lo = XHCI_MAX_SP_LO(caps->hcsparams2);
+ max_bufs_hi = XHCI_MAX_SP_HI(caps->hcsparams2);
+ max_bufs = (max_bufs_hi << 5) | max_bufs_lo;
+ if (max_bufs == 0) {
+ /*
+ * Some emulators like QEMU don't need any
+ * scratchpad buffers so we can just return
+ * early.
+ */
+ return 0;
+ }
+
+ KINFO("HC requires %d max scratchpad buffers(s)\n", max_bufs);
+ buffer_array = vm_alloc_pageframe(max_bufs);
+ if (buffer_array == 0) {
+ KERR("Failed to allocate scratchpad buffer(s)\n");
+ return -1;
+ }
+
+ vm_zero_page(PHYS_TO_VIRT(buffer_array), max_bufs);
+ hc->dcbaap[0] = buffer_array;
+ return 0;
+}
+
+/*
+ * Init USB ports on the root hub.
+ */
+static int
+xhci_init_ports(struct xhci_hc *hc)
+{
+ struct xhci_caps *caps = XHCI_CAPS(hc->base);
+ size_t maxports = XHCI_MAXPORTS(caps->hcsparams1);
+ uint32_t *portsc;
+
+ for (size_t i = 1; i < maxports; ++i) {
+ portsc = xhci_get_portsc(hc, i);
+ if (__TEST(*portsc, XHCI_PORTSC_CCS)) {
+ KINFO("Device connected on port %d, resetting...\n", i);
+ *portsc |= XHCI_PORTSC_PR;
+ }
+ }
+
+ return 0;
+}
+
+/*
+ * Poll USBSTS.HCH to be val
+ *
+ * Returns 0 on success. Non-zero values returned
+ * indicate a hang.
+ */
+static int
+xhci_poll_hch(struct xhci_hc *hc, uint8_t val)
+{
+ struct xhci_opregs *opregs = hc->opregs;
+ size_t time_waiting = 0;
+
+ while ((opregs->usbsts & USBSTS_HCH) != val) {
+ if (time_waiting >= XHCI_TIMEOUT) {
+ /* Hang */
+ return -1;
+ }
+
+ time_waiting += 50;
+ driver_tmr.msleep(50);
+ }
+
+ return 0;
+}
+
+/*
+ * Start up the host controller by setting
+ * the USBCMD run/stop bit.
+ */
+static int
+xhci_start_hc(struct xhci_hc *hc)
+{
+ struct xhci_opregs *opregs = hc->opregs;
+ int status;
+
+ opregs->usbcmd |= USBCMD_RUN;
+
+ if ((status = xhci_poll_hch(hc, 0)) != 0) {
+ return status;
+ }
+
+ return 0;
+}
+
+static int
+xhci_reset_hc(struct xhci_hc *hc)
+{
+ struct xhci_opregs *opregs = hc->opregs;
+ size_t time_waiting = 0; /* In ms */
+
+ KINFO("Resetting host controller...\n");
+
+ /*
+ * Set USBCMD.HCRST to reset the controller and
+ * wait for it to become zero.
+ */
+ opregs->usbcmd |= USBCMD_HCRST;
+ while (1) {
+ if (!__TEST(opregs->usbcmd, USBCMD_HCRST)) {
+ /* Reset is complete */
+ break;
+ }
+ if (time_waiting >= XHCI_TIMEOUT) {
+ KERR("Hang while polling USBCMD.HCRST to be zero\n");
+ return -1;
+ }
+ driver_tmr.msleep(50);
+ time_waiting += 50;
+ }
+ return 0;
+}
+
+static int
+xhci_init_hc(struct xhci_hc *hc)
+{
+ struct xhci_caps *caps;
+ struct xhci_opregs *opregs;
+ size_t dcbaa_size, cmdring_size;
+ size_t evring_segment_sz;
+
+ /* Get some information from the controller */
+ caps = XHCI_CAPS(hc->base);
+ hc->caplen = caps->caplength;
+ hc->maxslots = XHCI_MAXSLOTS(caps->hcsparams1);
+ hc->maxports = XHCI_MAXSLOTS(caps->hcsparams1);
+
+ opregs->config |= hc->maxslots;
+
+ /* Fetch the opregs */
+ opregs = XHCI_OPBASE(hc->base, hc->caplen);
+ hc->opregs = XHCI_OPBASE(hc->base, hc->caplen);
+
+ if (xhci_reset_hc(hc) != 0) {
+ return -1;
+ }
+
+ /* Set cmdring state */
+ hc->cycle = 0;
+ hc->cmd_ptr = 0;
+
+ /* Allocate and set DCBAA */
+ dcbaa_size = sizeof(uintptr_t) * hc->maxslots;
+ hc->dcbaap = dynalloc_memalign(dcbaa_size, 0x1000);
+ __assert(hc->dcbaap != NULL);
+ opregs->dcbaa_ptr = VIRT_TO_PHYS(hc->dcbaap);
+
+ xhci_init_scratchpads(hc);
+ cmdring_size = XHCI_TRB_SIZE * XHCI_CMDRING_LEN;
+
+ /* Create command ring */
+ hc->cmd_ring = dynalloc_memalign(cmdring_size, 0x1000);
+ __assert(hc->cmd_ring != NULL);
+ opregs->cmd_ring = VIRT_TO_PHYS(hc->cmd_ring);
+
+ /* Allocate event ring segment */
+ evring_segment_sz = sizeof(struct xhci_evring_segment);
+ hc->evring_seg = dynalloc_memalign(evring_segment_sz, 0x1000);
+ xhci_init_evring_segment(hc->evring_seg);
+
+ /* Tell the HC about the event ring segment */
+ __assert(hc->evring_seg != NULL);
+ xhci_set_erst_base(hc, VIRT_TO_PHYS(hc->evring_seg));
+
+ /* We're ready, start up the HC and ports */
+ xhci_start_hc(hc);
+ xhci_parse_ecp(hc);
+ xhci_init_ports(hc);
+ return 0;
+}
+
+static int
+xhci_init(void)
+{
+ uintptr_t bar0, bar1, base;
+ struct xhci_hc hc;
+ struct pci_lookup hc_lookup = {
+ .pci_class = 0x0C,
+ .pci_subclass = 0x03
+ };
+
+ /* Find the host controller on the bus */
+ hci_dev = pci_get_device(hc_lookup, PCI_CLASS | PCI_SUBCLASS);
+ if (hci_dev == NULL) {
+ return -1;
+ }
+
+ bar0 = hci_dev->bar[0] & ~7;
+ bar1 = hci_dev->bar[1] & ~7;
+ base = __COMBINE32(bar1, bar0);
+ hc.base = PHYS_TO_VIRT(base);
+ KINFO("xHCI HC base @ 0x%p\n", base);
+
+ if (req_timer(TIMER_GP, &driver_tmr) != 0) {
+ KERR("Failed to fetch general purpose timer\n");
+ return -1;
+ }
+ if (driver_tmr.msleep == NULL) {
+ KERR("Timer does not have msleep()\n");
+ return -1;
+ }
+
+ return xhci_init_hc(&hc);
+}
+
+DRIVER_EXPORT(xhci_init);
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-09 02:03:30 +0000