X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=src%2Fusb-uhci.c;h=242f3ba5aa8c24060e5b16f8c74dc9ab9f418704;hb=1e749c8583a5a8cf7a08f0e0faa2cb1edc3e44c7;hp=a8709634116dc5340b11793ac5346c277deb07d7;hpb=4547eb904992b12771f040a8c1abc84892a64f98;p=seabios.git diff --git a/src/usb-uhci.c b/src/usb-uhci.c index a870963..242f3ba 100644 --- a/src/usb-uhci.c +++ b/src/usb-uhci.c @@ -12,81 +12,83 @@ #include "pci_regs.h" // PCI_BASE_ADDRESS_4 #include "usb.h" // struct usb_s #include "farptr.h" // GET_FLATPTR -#include "biosvar.h" // GET_GLOBAL -#include "usb-hub.h" // struct usbhub_s + +struct usb_uhci_s { + struct usb_s usb; + u16 iobase; + struct uhci_qh *control_qh, *bulk_qh; + struct uhci_framelist *framelist; +}; /**************************************************************** * Root hub ****************************************************************/ -static void -init_uhci_port(void *data) +// Check if device attached to a given port +static int +uhci_hub_detect(struct usbhub_s *hub, u32 port) { - struct usbhub_s *hub = data; - u32 port = hub->port; // XXX - find better way to pass port - u16 ioport = hub->cntl->uhci.iobase + USBPORTSC1 + port * 2; + struct usb_uhci_s *cntl = container_of(hub->cntl, struct usb_uhci_s, usb); + u16 ioport = cntl->iobase + USBPORTSC1 + port * 2; u16 status = inw(ioport); if (!(status & USBPORTSC_CCS)) // No device - goto done; + return -1; // XXX - if just powered up, need to wait for USB_TIME_ATTDB? - // Reset port + // Begin reset on port outw(USBPORTSC_PR, ioport); msleep(USB_TIME_DRSTR); - mutex_lock(&hub->cntl->resetlock); + return 0; +} + +// Reset device on port +static int +uhci_hub_reset(struct usbhub_s *hub, u32 port) +{ + struct usb_uhci_s *cntl = container_of(hub->cntl, struct usb_uhci_s, usb); + u16 ioport = cntl->iobase + USBPORTSC1 + port * 2; + + // Finish reset on port outw(0, ioport); udelay(6); // 64 high-speed bit times - status = inw(ioport); + u16 status = inw(ioport); if (!(status & USBPORTSC_CCS)) // No longer connected - goto resetfail; + return -1; outw(USBPORTSC_PE, ioport); - struct usb_pipe *pipe = usb_set_address( - hub->cntl, !!(status & USBPORTSC_LSDA)); - if (!pipe) - goto resetfail; - mutex_unlock(&hub->cntl->resetlock); - - // Configure port - int count = configure_usb_device(pipe); - free_pipe(pipe); - if (! count) - // Disable port - outw(0, ioport); - hub->devcount += count; -done: - hub->threads--; - return; - -resetfail: + return !!(status & USBPORTSC_LSDA); +} + +// Disable port +static void +uhci_hub_disconnect(struct usbhub_s *hub, u32 port) +{ + struct usb_uhci_s *cntl = container_of(hub->cntl, struct usb_uhci_s, usb); + u16 ioport = cntl->iobase + USBPORTSC1 + port * 2; outw(0, ioport); - mutex_unlock(&hub->cntl->resetlock); - goto done; } +static struct usbhub_op_s uhci_HubOp = { + .detect = uhci_hub_detect, + .reset = uhci_hub_reset, + .disconnect = uhci_hub_disconnect, +}; + // Find any devices connected to the root hub. static int -check_ports(struct usb_s *cntl) +check_uhci_ports(struct usb_uhci_s *cntl) { ASSERT32FLAT(); struct usbhub_s hub; memset(&hub, 0, sizeof(hub)); - hub.cntl = cntl; - hub.threads = 2; - - // Launch a thread for every port. - run_thread(init_uhci_port, &hub); - hub.port = 1; - run_thread(init_uhci_port, &hub); - - // Wait for threads to complete. - while (hub.threads) - yield(); - + hub.cntl = &cntl->usb; + hub.portcount = 2; + hub.op = &uhci_HubOp; + usb_enumerate(&hub); return hub.devcount; } @@ -96,25 +98,27 @@ check_ports(struct usb_s *cntl) ****************************************************************/ static void -reset_uhci(struct usb_s *cntl) +reset_uhci(struct usb_uhci_s *cntl, u16 bdf) { // XXX - don't reset if not needed. // Reset PIRQ and SMI - pci_config_writew(cntl->bdf, USBLEGSUP, USBLEGSUP_RWC); + pci_config_writew(bdf, USBLEGSUP, USBLEGSUP_RWC); // Reset the HC - outw(USBCMD_HCRESET, cntl->uhci.iobase + USBCMD); + outw(USBCMD_HCRESET, cntl->iobase + USBCMD); udelay(5); // Disable interrupts and commands (just to be safe). - outw(0, cntl->uhci.iobase + USBINTR); - outw(0, cntl->uhci.iobase + USBCMD); + outw(0, cntl->iobase + USBINTR); + outw(0, cntl->iobase + USBCMD); } static void -configure_uhci(struct usb_s *cntl) +configure_uhci(void *data) { + struct usb_uhci_s *cntl = data; + // Allocate ram for schedule storage struct uhci_td *term_td = malloc_high(sizeof(*term_td)); struct uhci_framelist *fl = memalign_high(sizeof(*fl), sizeof(*fl)); @@ -122,11 +126,7 @@ configure_uhci(struct usb_s *cntl) struct uhci_qh *term_qh = malloc_high(sizeof(*term_qh)); if (!term_td || !fl || !intr_qh || !term_qh) { warn_noalloc(); - free(term_td); - free(fl); - free(intr_qh); - free(term_qh); - return; + goto fail; } // Work around for PIIX errata @@ -145,54 +145,66 @@ configure_uhci(struct usb_s *cntl) int i; for (i=0; ilinks); i++) fl->links[i] = (u32)intr_qh | UHCI_PTR_QH; - cntl->uhci.framelist = fl; - cntl->uhci.control_qh = cntl->uhci.bulk_qh = intr_qh; + cntl->framelist = fl; + cntl->control_qh = cntl->bulk_qh = intr_qh; barrier(); // Set the frame length to the default: 1 ms exactly - outb(USBSOF_DEFAULT, cntl->uhci.iobase + USBSOF); + outb(USBSOF_DEFAULT, cntl->iobase + USBSOF); // Store the frame list base address - outl((u32)fl->links, cntl->uhci.iobase + USBFLBASEADD); + outl((u32)fl->links, cntl->iobase + USBFLBASEADD); // Set the current frame number - outw(0, cntl->uhci.iobase + USBFRNUM); -} + outw(0, cntl->iobase + USBFRNUM); -static void -start_uhci(struct usb_s *cntl) -{ // Mark as configured and running with a 64-byte max packet. - outw(USBCMD_RS | USBCMD_CF | USBCMD_MAXP, cntl->uhci.iobase + USBCMD); + outw(USBCMD_RS | USBCMD_CF | USBCMD_MAXP, cntl->iobase + USBCMD); + + // Find devices + int count = check_uhci_ports(cntl); + free_pipe(cntl->usb.defaultpipe); + if (count) + // Success + return; + + // No devices found - shutdown and free controller. + outw(0, cntl->iobase + USBCMD); +fail: + free(term_td); + free(fl); + free(intr_qh); + free(term_qh); + free(cntl); } void -uhci_init(void *data) +uhci_init(struct pci_device *pci, int busid) { if (! CONFIG_USB_UHCI) return; - struct usb_s *cntl = data; - - // XXX - don't call pci_config_XXX from a thread - cntl->type = USB_TYPE_UHCI; - cntl->uhci.iobase = (pci_config_readl(cntl->bdf, PCI_BASE_ADDRESS_4) - & PCI_BASE_ADDRESS_IO_MASK); + u16 bdf = pci->bdf; + struct usb_uhci_s *cntl = malloc_tmphigh(sizeof(*cntl)); + if (!cntl) { + warn_noalloc(); + return; + } + memset(cntl, 0, sizeof(*cntl)); + cntl->usb.busid = busid; + cntl->usb.pci = pci; + cntl->usb.type = USB_TYPE_UHCI; + cntl->iobase = (pci_config_readl(bdf, PCI_BASE_ADDRESS_4) + & PCI_BASE_ADDRESS_IO_MASK); - dprintf(3, "UHCI init on dev %02x:%02x.%x (io=%x)\n" - , pci_bdf_to_bus(cntl->bdf), pci_bdf_to_dev(cntl->bdf) - , pci_bdf_to_fn(cntl->bdf), cntl->uhci.iobase); + dprintf(1, "UHCI init on dev %02x:%02x.%x (io=%x)\n" + , pci_bdf_to_bus(bdf), pci_bdf_to_dev(bdf) + , pci_bdf_to_fn(bdf), cntl->iobase); - pci_config_maskw(cntl->bdf, PCI_COMMAND, 0, PCI_COMMAND_MASTER); + pci_config_maskw(bdf, PCI_COMMAND, 0, PCI_COMMAND_MASTER); - reset_uhci(cntl); - configure_uhci(cntl); - start_uhci(cntl); + reset_uhci(cntl, bdf); - int count = check_ports(cntl); - free_pipe(cntl->defaultpipe); - if (! count) { - // XXX - no devices; free data structures. - } + run_thread(configure_uhci, cntl); } @@ -200,39 +212,25 @@ uhci_init(void *data) * End point communication ****************************************************************/ -static int -wait_qh(struct usb_s *cntl, struct uhci_qh *qh) -{ - // XXX - 500ms just a guess - u64 end = calc_future_tsc(500); - for (;;) { - if (qh->element & UHCI_PTR_TERM) - return 0; - if (check_time(end)) { - warn_timeout(); - struct uhci_td *td = (void*)(qh->element & ~UHCI_PTR_BITS); - dprintf(1, "Timeout on wait_qh %p (td=%p s=%x c=%x/%x)\n" - , qh, td, td->status - , inw(cntl->uhci.iobase + USBCMD) - , inw(cntl->uhci.iobase + USBSTS)); - return -1; - } - yield(); - } -} +struct uhci_pipe { + struct uhci_qh qh; + struct uhci_td *next_td; + struct usb_pipe pipe; + u16 iobase; + u8 toggle; +}; // Wait for next USB frame to start - for ensuring safe memory release. static void -uhci_waittick(struct usb_s *cntl) +uhci_waittick(u16 iobase) { barrier(); - u16 iobase = GET_GLOBAL(cntl->uhci.iobase); u16 startframe = inw(iobase + USBFRNUM); u64 end = calc_future_tsc(1000 * 5); for (;;) { if (inw(iobase + USBFRNUM) != startframe) break; - if (check_time(end)) { + if (check_tsc(end)) { warn_timeout(); return; } @@ -240,11 +238,28 @@ uhci_waittick(struct usb_s *cntl) } } -struct uhci_pipe { - struct uhci_qh qh; - struct uhci_td *next_td; - struct usb_pipe pipe; -}; +static int +wait_pipe(struct uhci_pipe *pipe, int timeout) +{ + u64 end = calc_future_tsc(timeout); + for (;;) { + u32 el_link = GET_FLATPTR(pipe->qh.element); + if (el_link & UHCI_PTR_TERM) + return 0; + if (check_tsc(end)) { + warn_timeout(); + struct uhci_td *td = (void*)(el_link & ~UHCI_PTR_BITS); + dprintf(1, "Timeout on wait_pipe %p (td=%p s=%x c=%x/%x)\n" + , pipe, (void*)el_link, GET_FLATPTR(td->status) + , inw(pipe->iobase + USBCMD) + , inw(pipe->iobase + USBSTS)); + SET_FLATPTR(pipe->qh.element, UHCI_PTR_TERM); + uhci_waittick(pipe->iobase); + return -1; + } + yield(); + } +} void uhci_free_pipe(struct usb_pipe *p) @@ -253,10 +268,10 @@ uhci_free_pipe(struct usb_pipe *p) return; dprintf(7, "uhci_free_pipe %p\n", p); struct uhci_pipe *pipe = container_of(p, struct uhci_pipe, pipe); - struct usb_s *cntl = pipe->pipe.cntl; + struct usb_uhci_s *cntl = container_of( + pipe->pipe.cntl, struct usb_uhci_s, usb); - struct uhci_framelist *fl = cntl->uhci.framelist; - struct uhci_qh *pos = (void*)(fl->links[0] & ~UHCI_PTR_BITS); + struct uhci_qh *pos = (void*)(cntl->framelist->links[0] & ~UHCI_PTR_BITS); for (;;) { u32 link = pos->link; if (link == UHCI_PTR_TERM) { @@ -267,11 +282,11 @@ uhci_free_pipe(struct usb_pipe *p) struct uhci_qh *next = (void*)(link & ~UHCI_PTR_BITS); if (next == &pipe->qh) { pos->link = next->link; - if (cntl->uhci.control_qh == next) - cntl->uhci.control_qh = pos; - if (cntl->uhci.bulk_qh == next) - cntl->uhci.bulk_qh = pos; - uhci_waittick(cntl); + if (cntl->control_qh == next) + cntl->control_qh = pos; + if (cntl->bulk_qh == next) + cntl->bulk_qh = pos; + uhci_waittick(cntl->iobase); free(pipe); return; } @@ -284,8 +299,9 @@ uhci_alloc_control_pipe(struct usb_pipe *dummy) { if (! CONFIG_USB_UHCI) return NULL; - struct usb_s *cntl = dummy->cntl; - dprintf(7, "uhci_alloc_control_pipe %p\n", cntl); + struct usb_uhci_s *cntl = container_of( + dummy->cntl, struct usb_uhci_s, usb); + dprintf(7, "uhci_alloc_control_pipe %p\n", &cntl->usb); // Allocate a queue head. struct uhci_pipe *pipe = malloc_tmphigh(sizeof(*pipe)); @@ -294,16 +310,17 @@ uhci_alloc_control_pipe(struct usb_pipe *dummy) return NULL; } memset(pipe, 0, sizeof(*pipe)); - pipe->qh.element = UHCI_PTR_TERM; memcpy(&pipe->pipe, dummy, sizeof(pipe->pipe)); + pipe->qh.element = UHCI_PTR_TERM; + pipe->iobase = cntl->iobase; // Add queue head to controller list. - struct uhci_qh *control_qh = cntl->uhci.control_qh; + struct uhci_qh *control_qh = cntl->control_qh; pipe->qh.link = control_qh->link; barrier(); control_qh->link = (u32)&pipe->qh | UHCI_PTR_QH; - if (cntl->uhci.bulk_qh == control_qh) - cntl->uhci.bulk_qh = &pipe->qh; + if (cntl->bulk_qh == control_qh) + cntl->bulk_qh = &pipe->qh; return &pipe->pipe; } @@ -317,14 +334,17 @@ uhci_control(struct usb_pipe *p, int dir, const void *cmd, int cmdsize dprintf(5, "uhci_control %p\n", p); struct uhci_pipe *pipe = container_of(p, struct uhci_pipe, pipe); - struct usb_s *cntl = pipe->pipe.cntl; int maxpacket = pipe->pipe.maxpacket; - int lowspeed = pipe->pipe.lowspeed; + int lowspeed = pipe->pipe.speed; int devaddr = pipe->pipe.devaddr | (pipe->pipe.ep << 7); // Setup transfer descriptors int count = 2 + DIV_ROUND_UP(datasize, maxpacket); struct uhci_td *tds = malloc_tmphigh(sizeof(*tds) * count); + if (!tds) { + warn_noalloc(); + return -1; + } tds[0].link = (u32)&tds[1] | UHCI_PTR_DEPTH; tds[0].status = (uhci_maxerr(3) | (lowspeed ? TD_CTRL_LS : 0) @@ -356,11 +376,7 @@ uhci_control(struct usb_pipe *p, int dir, const void *cmd, int cmdsize // Transfer data barrier(); pipe->qh.element = (u32)&tds[0]; - int ret = wait_qh(cntl, &pipe->qh); - if (ret) { - pipe->qh.element = UHCI_PTR_TERM; - uhci_waittick(cntl); - } + int ret = wait_pipe(pipe, 500); free(tds); return ret; } @@ -370,8 +386,9 @@ uhci_alloc_bulk_pipe(struct usb_pipe *dummy) { if (! CONFIG_USB_UHCI) return NULL; - struct usb_s *cntl = dummy->cntl; - dprintf(7, "uhci_alloc_bulk_pipe %p\n", cntl); + struct usb_uhci_s *cntl = container_of( + dummy->cntl, struct usb_uhci_s, usb); + dprintf(7, "uhci_alloc_bulk_pipe %p\n", &cntl->usb); // Allocate a queue head. struct uhci_pipe *pipe = malloc_low(sizeof(*pipe)); @@ -380,11 +397,12 @@ uhci_alloc_bulk_pipe(struct usb_pipe *dummy) return NULL; } memset(pipe, 0, sizeof(*pipe)); - pipe->qh.element = UHCI_PTR_TERM; memcpy(&pipe->pipe, dummy, sizeof(pipe->pipe)); + pipe->qh.element = UHCI_PTR_TERM; + pipe->iobase = cntl->iobase; // Add queue head to controller list. - struct uhci_qh *bulk_qh = cntl->uhci.bulk_qh; + struct uhci_qh *bulk_qh = cntl->bulk_qh; pipe->qh.link = bulk_qh->link; barrier(); bulk_qh->link = (u32)&pipe->qh | UHCI_PTR_QH; @@ -401,7 +419,7 @@ wait_td(struct uhci_td *td) status = td->status; if (!(status & TD_CTRL_ACTIVE)) break; - if (check_time(end)) { + if (check_tsc(end)) { warn_timeout(); return -1; } @@ -420,14 +438,16 @@ wait_td(struct uhci_td *td) int uhci_send_bulk(struct usb_pipe *p, int dir, void *data, int datasize) { + if (! CONFIG_USB_UHCI) + return -1; struct uhci_pipe *pipe = container_of(p, struct uhci_pipe, pipe); dprintf(7, "uhci_send_bulk qh=%p dir=%d data=%p size=%d\n" , &pipe->qh, dir, data, datasize); int maxpacket = GET_FLATPTR(pipe->pipe.maxpacket); - int lowspeed = GET_FLATPTR(pipe->pipe.lowspeed); + int lowspeed = GET_FLATPTR(pipe->pipe.speed); int devaddr = (GET_FLATPTR(pipe->pipe.devaddr) | (GET_FLATPTR(pipe->pipe.ep) << 7)); - int toggle = GET_FLATPTR(pipe->pipe.toggle) ? TD_TOKEN_TOGGLE : 0; + int toggle = GET_FLATPTR(pipe->toggle) ? TD_TOKEN_TOGGLE : 0; // Allocate 4 tds on stack (16byte aligned) u8 tdsbuf[sizeof(struct uhci_td) * STACKTDS + TDALIGN - 1]; @@ -435,6 +455,7 @@ uhci_send_bulk(struct usb_pipe *p, int dir, void *data, int datasize) memset(tds, 0, sizeof(*tds) * STACKTDS); // Enable tds + barrier(); SET_FLATPTR(pipe->qh.element, (u32)MAKE_FLATPTR(GET_SEG(SS), tds)); int tdpos = 0; @@ -462,20 +483,12 @@ uhci_send_bulk(struct usb_pipe *p, int dir, void *data, int datasize) data += transfer; datasize -= transfer; } - int i; - for (i=0; ipipe.toggle, !!toggle); - return 0; + SET_FLATPTR(pipe->toggle, !!toggle); + return wait_pipe(pipe, 5000); fail: dprintf(1, "uhci_send_bulk failed\n"); SET_FLATPTR(pipe->qh.element, UHCI_PTR_TERM); - uhci_waittick(GET_FLATPTR(pipe->pipe.cntl)); + uhci_waittick(GET_FLATPTR(pipe->iobase)); return -1; } @@ -484,29 +497,31 @@ uhci_alloc_intr_pipe(struct usb_pipe *dummy, int frameexp) { if (! CONFIG_USB_UHCI) return NULL; - struct usb_s *cntl = dummy->cntl; - dprintf(7, "uhci_alloc_intr_pipe %p %d\n", cntl, frameexp); + struct usb_uhci_s *cntl = container_of( + dummy->cntl, struct usb_uhci_s, usb); + dprintf(7, "uhci_alloc_intr_pipe %p %d\n", &cntl->usb, frameexp); if (frameexp > 10) frameexp = 10; int maxpacket = dummy->maxpacket; - int lowspeed = dummy->lowspeed; + int lowspeed = dummy->speed; int devaddr = dummy->devaddr | (dummy->ep << 7); // Determine number of entries needed for 2 timer ticks. int ms = 1< sizeof(tds[0].data)) - goto fail; memset(pipe, 0, sizeof(*pipe)); + memcpy(&pipe->pipe, dummy, sizeof(pipe->pipe)); pipe->qh.element = (u32)tds; pipe->next_td = &tds[0]; - memcpy(&pipe->pipe, dummy, sizeof(pipe->pipe)); + pipe->iobase = cntl->iobase; int toggle = 0; int i; @@ -517,22 +532,22 @@ uhci_alloc_intr_pipe(struct usb_pipe *dummy, int frameexp) tds[i].token = (uhci_explen(maxpacket) | toggle | (devaddr << TD_TOKEN_DEVADDR_SHIFT) | USB_PID_IN); - tds[i].buffer = &tds[i].data; + tds[i].buffer = data + maxpacket * i; toggle ^= TD_TOKEN_TOGGLE; } // Add to interrupt schedule. - struct uhci_framelist *fl = cntl->uhci.framelist; + struct uhci_framelist *fl = cntl->framelist; if (frameexp == 0) { // Add to existing interrupt entry. struct uhci_qh *intr_qh = (void*)(fl->links[0] & ~UHCI_PTR_BITS); pipe->qh.link = intr_qh->link; barrier(); intr_qh->link = (u32)&pipe->qh | UHCI_PTR_QH; - if (cntl->uhci.control_qh == intr_qh) - cntl->uhci.control_qh = &pipe->qh; - if (cntl->uhci.bulk_qh == intr_qh) - cntl->uhci.bulk_qh = &pipe->qh; + if (cntl->control_qh == intr_qh) + cntl->control_qh = &pipe->qh; + if (cntl->bulk_qh == intr_qh) + cntl->bulk_qh = &pipe->qh; } else { int startpos = 1<<(frameexp-1); pipe->qh.link = fl->links[startpos]; @@ -545,6 +560,7 @@ uhci_alloc_intr_pipe(struct usb_pipe *dummy, int frameexp) fail: free(pipe); free(tds); + free(data); return NULL; } @@ -565,16 +581,17 @@ uhci_poll_intr(struct usb_pipe *p, void *data) // XXX - check for errors. // Copy data. + void *tddata = GET_FLATPTR(td->buffer); memcpy_far(GET_SEG(SS), data - , FLATPTR_TO_SEG(td->data), (void*)FLATPTR_TO_OFFSET(td->data) + , FLATPTR_TO_SEG(tddata), (void*)FLATPTR_TO_OFFSET(tddata) , uhci_expected_length(token)); // Reenable this td. - u32 next = GET_FLATPTR(td->link); + struct uhci_td *next = (void*)(GET_FLATPTR(td->link) & ~UHCI_PTR_BITS); + SET_FLATPTR(pipe->next_td, next); barrier(); SET_FLATPTR(td->status, (uhci_maxerr(0) | (status & TD_CTRL_LS) | TD_CTRL_ACTIVE)); - SET_FLATPTR(pipe->next_td, (void*)(next & ~UHCI_PTR_BITS)); return 0; }