src/usb-ehci.c

   1 // Code for handling EHCI USB controllers.
   2 //
   3 // Copyright (C) 2010  Kevin O'Connor <kevin@koconnor.net>
   4 //
   5 // This file may be distributed under the terms of the GNU LGPLv3 license.
   6
   7 #include "util.h" // dprintf
   8 #include "pci.h" // pci_bdf_to_bus
   9 #include "config.h" // CONFIG_*
  10 #include "ioport.h" // outw
  11 #include "usb-ehci.h" // struct ehci_qh
  12 #include "pci_ids.h" // PCI_CLASS_SERIAL_USB_UHCI
  13 #include "pci_regs.h" // PCI_BASE_ADDRESS_0
  14 #include "usb.h" // struct usb_s
  15 #include "farptr.h" // GET_FLATPTR
  16 #include "usb-uhci.h" // init_uhci
  17 #include "usb-ohci.h" // init_ohci
  18
  19 struct usb_ehci_s {
  20     struct usb_s usb;
  21     struct ehci_caps *caps;
  22     struct ehci_regs *regs;
  23     struct ehci_qh *async_qh;
  24     struct pci_device *companion[8];
  25     int checkports;
  26     int legacycount;
  27 };
  28
  29
  30 /****************************************************************
  31  * Root hub
  32  ****************************************************************/
  33
  34 #define EHCI_TIME_POSTPOWER 20
  35 #define EHCI_TIME_POSTRESET 2
  36
  37 // Check if need companion controllers for full/low speed devices
  38 static void
  39 ehci_note_port(struct usb_ehci_s *cntl)
  40 {
  41     if (--cntl->checkports)
  42         // Ports still being detected.
  43         return;
  44     if (! cntl->legacycount)
  45         // No full/low speed devices found.
  46         return;
  47     // Start companion controllers.
  48     int i;
  49     for (i=0; i<ARRAY_SIZE(cntl->companion); i++) {
  50         struct pci_device *pci = cntl->companion[i];
  51         if (!pci)
  52             break;
  53
  54         // ohci/uhci_init call pci_config_XXX - don't run from irq handler.
  55         wait_preempt();
  56
  57         if (pci_classprog(pci) == PCI_CLASS_SERIAL_USB_UHCI)
  58             uhci_init(pci, cntl->usb.busid + i);
  59         else if (pci_classprog(pci) == PCI_CLASS_SERIAL_USB_OHCI)
  60             ohci_init(pci, cntl->usb.busid + i);
  61     }
  62 }
  63
  64 // Check if device attached to port
  65 static int
  66 ehci_hub_detect(struct usbhub_s *hub, u32 port)
  67 {
  68     struct usb_ehci_s *cntl = container_of(hub->cntl, struct usb_ehci_s, usb);
  69     u32 *portreg = &cntl->regs->portsc[port];
  70     u32 portsc = readl(portreg);
  71
  72     // Power up port.
  73     if (!(portsc & PORT_POWER)) {
  74         portsc |= PORT_POWER;
  75         writel(portreg, portsc);
  76         msleep(EHCI_TIME_POSTPOWER);
  77     } else {
  78         msleep(1); // XXX - time for connect to be detected.
  79     }
  80     portsc = readl(portreg);
  81
  82     if (!(portsc & PORT_CONNECT))
  83         // No device present
  84         goto doneearly;
  85
  86     if ((portsc & PORT_LINESTATUS_MASK) == PORT_LINESTATUS_KSTATE) {
  87         // low speed device
  88         cntl->legacycount++;
  89         writel(portreg, portsc | PORT_OWNER);
  90         goto doneearly;
  91     }
  92
  93     // XXX - if just powered up, need to wait for USB_TIME_ATTDB?
  94
  95     // Begin reset on port
  96     portsc = (portsc & ~PORT_PE) | PORT_RESET;
  97     writel(portreg, portsc);
  98     msleep(USB_TIME_DRSTR);
  99     return 0;
 100
 101 doneearly:
 102     ehci_note_port(cntl);
 103     return -1;
 104 }
 105
 106 // Reset device on port
 107 static int
 108 ehci_hub_reset(struct usbhub_s *hub, u32 port)
 109 {
 110     struct usb_ehci_s *cntl = container_of(hub->cntl, struct usb_ehci_s, usb);
 111     u32 *portreg = &cntl->regs->portsc[port];
 112     u32 portsc = readl(portreg);
 113
 114     // Finish reset on port
 115     portsc &= ~PORT_RESET;
 116     writel(portreg, portsc);
 117     msleep(EHCI_TIME_POSTRESET);
 118
 119     int rv = -1;
 120     portsc = readl(portreg);
 121     if (!(portsc & PORT_CONNECT))
 122         // No longer connected
 123         goto resetfail;
 124     if (!(portsc & PORT_PE)) {
 125         // full speed device
 126         cntl->legacycount++;
 127         writel(portreg, portsc | PORT_OWNER);
 128         goto resetfail;
 129     }
 130
 131     rv = USB_HIGHSPEED;
 132 resetfail:
 133     ehci_note_port(cntl);
 134     return rv;
 135 }
 136
 137 // Disable port
 138 static void
 139 ehci_hub_disconnect(struct usbhub_s *hub, u32 port)
 140 {
 141     struct usb_ehci_s *cntl = container_of(hub->cntl, struct usb_ehci_s, usb);
 142     u32 *portreg = &cntl->regs->portsc[port];
 143     u32 portsc = readl(portreg);
 144     writel(portreg, portsc & ~PORT_PE);
 145 }
 146
 147 static struct usbhub_op_s ehci_HubOp = {
 148     .detect = ehci_hub_detect,
 149     .reset = ehci_hub_reset,
 150     .disconnect = ehci_hub_disconnect,
 151 };
 152
 153 // Find any devices connected to the root hub.
 154 static int
 155 check_ehci_ports(struct usb_ehci_s *cntl)
 156 {
 157     ASSERT32FLAT();
 158     struct usbhub_s hub;
 159     memset(&hub, 0, sizeof(hub));
 160     hub.cntl = &cntl->usb;
 161     hub.portcount = cntl->checkports;
 162     hub.op = &ehci_HubOp;
 163     usb_enumerate(&hub);
 164     return hub.devcount;
 165 }
 166
 167
 168 /****************************************************************
 169  * Setup
 170  ****************************************************************/
 171
 172 static void
 173 configure_ehci(void *data)
 174 {
 175     struct usb_ehci_s *cntl = data;
 176
 177     // Allocate ram for schedule storage
 178     struct ehci_framelist *fl = memalign_high(sizeof(*fl), sizeof(*fl));
 179     struct ehci_qh *intr_qh = memalign_high(EHCI_QH_ALIGN, sizeof(*intr_qh));
 180     struct ehci_qh *async_qh = memalign_high(EHCI_QH_ALIGN, sizeof(*async_qh));
 181     if (!fl || !intr_qh || !async_qh) {
 182         warn_noalloc();
 183         goto fail;
 184     }
 185
 186     // XXX - check for halted?
 187
 188     // Reset the HC
 189     u32 cmd = readl(&cntl->regs->usbcmd);
 190     writel(&cntl->regs->usbcmd, (cmd & ~(CMD_ASE | CMD_PSE)) | CMD_HCRESET);
 191     u64 end = calc_future_tsc(250);
 192     for (;;) {
 193         cmd = readl(&cntl->regs->usbcmd);
 194         if (!(cmd & CMD_HCRESET))
 195             break;
 196         if (check_tsc(end)) {
 197             warn_timeout();
 198             goto fail;
 199         }
 200         yield();
 201     }
 202
 203     // Disable interrupts (just to be safe).
 204     writel(&cntl->regs->usbintr, 0);
 205
 206     // Set schedule to point to primary intr queue head
 207     memset(intr_qh, 0, sizeof(*intr_qh));
 208     intr_qh->next = EHCI_PTR_TERM;
 209     intr_qh->info2 = (0x01 << QH_SMASK_SHIFT);
 210     intr_qh->token = QTD_STS_HALT;
 211     intr_qh->qtd_next = intr_qh->alt_next = EHCI_PTR_TERM;
 212     int i;
 213     for (i=0; i<ARRAY_SIZE(fl->links); i++)
 214         fl->links[i] = (u32)intr_qh | EHCI_PTR_QH;
 215     writel(&cntl->regs->periodiclistbase, (u32)fl);
 216
 217     // Set async list to point to primary async queue head
 218     memset(async_qh, 0, sizeof(*async_qh));
 219     async_qh->next = (u32)async_qh | EHCI_PTR_QH;
 220     async_qh->info1 = QH_HEAD;
 221     async_qh->token = QTD_STS_HALT;
 222     async_qh->qtd_next = async_qh->alt_next = EHCI_PTR_TERM;
 223     cntl->async_qh = async_qh;
 224     writel(&cntl->regs->asynclistbase, (u32)async_qh);
 225
 226     // Enable queues
 227     writel(&cntl->regs->usbcmd, cmd | CMD_ASE | CMD_PSE | CMD_RUN);
 228
 229     // Set default of high speed for root hub.
 230     writel(&cntl->regs->configflag, 1);
 231     cntl->checkports = readl(&cntl->caps->hcsparams) & HCS_N_PORTS_MASK;
 232
 233     // Find devices
 234     int count = check_ehci_ports(cntl);
 235     free_pipe(cntl->usb.defaultpipe);
 236     if (count)
 237         // Success
 238         return;
 239
 240     // No devices found - shutdown and free controller.
 241     writel(&cntl->regs->usbcmd, cmd & ~CMD_RUN);
 242     msleep(4);  // 2ms to stop reading memory - XXX
 243 fail:
 244     free(fl);
 245     free(intr_qh);
 246     free(async_qh);
 247     free(cntl);
 248 }
 249
 250 int
 251 ehci_init(struct pci_device *pci, int busid, struct pci_device *comppci)
 252 {
 253     if (! CONFIG_USB_EHCI)
 254         return -1;
 255
 256     u16 bdf = pci->bdf;
 257     u32 baseaddr = pci_config_readl(bdf, PCI_BASE_ADDRESS_0);
 258     struct ehci_caps *caps = (void*)(baseaddr & PCI_BASE_ADDRESS_MEM_MASK);
 259     u32 hcc_params = readl(&caps->hccparams);
 260     if (hcc_params & HCC_64BIT_ADDR) {
 261         dprintf(1, "No support for 64bit EHCI\n");
 262         return -1;
 263     }
 264
 265     struct usb_ehci_s *cntl = malloc_tmphigh(sizeof(*cntl));
 266     if (!cntl) {
 267         warn_noalloc();
 268         return -1;
 269     }
 270     memset(cntl, 0, sizeof(*cntl));
 271     cntl->usb.busid = busid;
 272     cntl->usb.pci = pci;
 273     cntl->usb.type = USB_TYPE_EHCI;
 274     cntl->caps = caps;
 275     cntl->regs = (void*)caps + readb(&caps->caplength);
 276
 277     dprintf(1, "EHCI init on dev %02x:%02x.%x (regs=%p)\n"
 278             , pci_bdf_to_bus(bdf), pci_bdf_to_dev(bdf)
 279             , pci_bdf_to_fn(bdf), cntl->regs);
 280
 281     pci_config_maskw(bdf, PCI_COMMAND, 0, PCI_COMMAND_MASTER);
 282
 283     // XXX - check for and disable SMM control?
 284
 285     // Find companion controllers.
 286     int count = 0;
 287     for (;;) {
 288         if (!comppci || comppci == pci)
 289             break;
 290         if (pci_classprog(comppci) == PCI_CLASS_SERIAL_USB_UHCI)
 291             cntl->companion[count++] = comppci;
 292         else if (pci_classprog(comppci) == PCI_CLASS_SERIAL_USB_OHCI)
 293             cntl->companion[count++] = comppci;
 294         comppci = comppci->next;
 295     }
 296
 297     run_thread(configure_ehci, cntl);
 298     return 0;
 299 }
 300
 301
 302 /****************************************************************
 303  * End point communication
 304  ****************************************************************/
 305
 306 struct ehci_pipe {
 307     struct ehci_qh qh;
 308     struct ehci_qtd *next_td, *tds;
 309     void *data;
 310     struct usb_pipe pipe;
 311 };
 312
 313 // Wait for next USB async frame to start - for ensuring safe memory release.
 314 static void
 315 ehci_waittick(struct usb_ehci_s *cntl)
 316 {
 317     if (MODE16) {
 318         msleep(10);
 319         return;
 320     }
 321     // Wait for access to "doorbell"
 322     barrier();
 323     u32 cmd, sts;
 324     u64 end = calc_future_tsc(100);
 325     for (;;) {
 326         sts = readl(&cntl->regs->usbsts);
 327         if (!(sts & STS_IAA)) {
 328             cmd = readl(&cntl->regs->usbcmd);
 329             if (!(cmd & CMD_IAAD))
 330                 break;
 331         }
 332         if (check_tsc(end)) {
 333             warn_timeout();
 334             return;
 335         }
 336         yield();
 337     }
 338     // Ring "doorbell"
 339     writel(&cntl->regs->usbcmd, cmd | CMD_IAAD);
 340     // Wait for completion
 341     for (;;) {
 342         sts = readl(&cntl->regs->usbsts);
 343         if (sts & STS_IAA)
 344             break;
 345         if (check_tsc(end)) {
 346             warn_timeout();
 347             return;
 348         }
 349         yield();
 350     }
 351     // Ack completion
 352     writel(&cntl->regs->usbsts, STS_IAA);
 353 }
 354
 355 static void
 356 ehci_reset_pipe(struct ehci_pipe *pipe)
 357 {
 358     SET_FLATPTR(pipe->qh.qtd_next, EHCI_PTR_TERM);
 359     SET_FLATPTR(pipe->qh.alt_next, EHCI_PTR_TERM);
 360     barrier();
 361     SET_FLATPTR(pipe->qh.token, GET_FLATPTR(pipe->qh.token) & QTD_TOGGLE);
 362 }
 363
 364 static int
 365 ehci_wait_td(struct ehci_pipe *pipe, struct ehci_qtd *td, int timeout)
 366 {
 367     u64 end = calc_future_tsc(timeout);
 368     u32 status;
 369     for (;;) {
 370         status = td->token;
 371         if (!(status & QTD_STS_ACTIVE))
 372             break;
 373         if (check_tsc(end)) {
 374             u32 cur = GET_FLATPTR(pipe->qh.current);
 375             u32 tok = GET_FLATPTR(pipe->qh.token);
 376             u32 next = GET_FLATPTR(pipe->qh.qtd_next);
 377             warn_timeout();
 378             dprintf(1, "ehci pipe=%p cur=%08x tok=%08x next=%x td=%p status=%x\n"
 379                     , pipe, cur, tok, next, td, status);
 380             ehci_reset_pipe(pipe);
 381             struct usb_ehci_s *cntl = container_of(
 382                 GET_FLATPTR(pipe->pipe.cntl), struct usb_ehci_s, usb);
 383             ehci_waittick(cntl);
 384             return -1;
 385         }
 386         yield();
 387     }
 388     if (status & QTD_STS_HALT) {
 389         dprintf(1, "ehci_wait_td error - status=%x\n", status);
 390         ehci_reset_pipe(pipe);
 391         return -2;
 392     }
 393     return 0;
 394 }
 395
 396 void
 397 ehci_free_pipe(struct usb_pipe *p)
 398 {
 399     if (! CONFIG_USB_EHCI)
 400         return;
 401     dprintf(7, "ehci_free_pipe %p\n", p);
 402     struct ehci_pipe *pipe = container_of(p, struct ehci_pipe, pipe);
 403     struct usb_ehci_s *cntl = container_of(
 404         pipe->pipe.cntl, struct usb_ehci_s, usb);
 405
 406     struct ehci_qh *start = cntl->async_qh;
 407     struct ehci_qh *pos = start;
 408     for (;;) {
 409         struct ehci_qh *next = (void*)(pos->next & ~EHCI_PTR_BITS);
 410         if (next == start) {
 411             // Not found?!  Exit without freeing.
 412             warn_internalerror();
 413             return;
 414         }
 415         if (next == &pipe->qh) {
 416             pos->next = next->next;
 417             ehci_waittick(cntl);
 418             free(pipe);
 419             return;
 420         }
 421         pos = next;
 422     }
 423 }
 424
 425 struct usb_pipe *
 426 ehci_alloc_control_pipe(struct usb_pipe *dummy)
 427 {
 428     if (! CONFIG_USB_EHCI)
 429         return NULL;
 430     struct usb_ehci_s *cntl = container_of(
 431         dummy->cntl, struct usb_ehci_s, usb);
 432     dprintf(7, "ehci_alloc_control_pipe %p\n", &cntl->usb);
 433
 434     // Allocate a queue head.
 435     struct ehci_pipe *pipe = memalign_tmphigh(EHCI_QH_ALIGN, sizeof(*pipe));
 436     if (!pipe) {
 437         warn_noalloc();
 438         return NULL;
 439     }
 440     memset(pipe, 0, sizeof(*pipe));
 441     memcpy(&pipe->pipe, dummy, sizeof(pipe->pipe));
 442     pipe->qh.qtd_next = pipe->qh.alt_next = EHCI_PTR_TERM;
 443
 444     // Add queue head to controller list.
 445     struct ehci_qh *async_qh = cntl->async_qh;
 446     pipe->qh.next = async_qh->next;
 447     barrier();
 448     async_qh->next = (u32)&pipe->qh | EHCI_PTR_QH;
 449     return &pipe->pipe;
 450 }
 451
 452 static int
 453 fillTDbuffer(struct ehci_qtd *td, u16 maxpacket, const void *buf, int bytes)
 454 {
 455     u32 dest = (u32)buf;
 456     u32 *pos = td->buf;
 457     while (bytes) {
 458         if (pos >= &td->buf[ARRAY_SIZE(td->buf)])
 459             // More data than can transfer in a single qtd - only use
 460             // full packets to prevent a babble error.
 461             return ALIGN_DOWN(dest - (u32)buf, maxpacket);
 462         u32 count = bytes;
 463         u32 max = 0x1000 - (dest & 0xfff);
 464         if (count > max)
 465             count = max;
 466         *pos = dest;
 467         bytes -= count;
 468         dest += count;
 469         pos++;
 470     }
 471     return dest - (u32)buf;
 472 }
 473
 474 int
 475 ehci_control(struct usb_pipe *p, int dir, const void *cmd, int cmdsize
 476              , void *data, int datasize)
 477 {
 478     ASSERT32FLAT();
 479     if (! CONFIG_USB_EHCI)
 480         return -1;
 481     dprintf(5, "ehci_control %p (dir=%d cmd=%d data=%d)\n"
 482             , p, dir, cmdsize, datasize);
 483     if (datasize > 4*4096 || cmdsize > 4*4096) {
 484         // XXX - should support larger sizes.
 485         warn_noalloc();
 486         return -1;
 487     }
 488     struct ehci_pipe *pipe = container_of(p, struct ehci_pipe, pipe);
 489
 490     u16 maxpacket = pipe->pipe.maxpacket;
 491     int speed = pipe->pipe.speed;
 492
 493     // Setup fields in qh
 494     pipe->qh.info1 = (
 495         (1 << QH_MULT_SHIFT) | (speed != USB_HIGHSPEED ? QH_CONTROL : 0)
 496         | (maxpacket << QH_MAXPACKET_SHIFT)
 497         | QH_TOGGLECONTROL
 498         | (speed << QH_SPEED_SHIFT)
 499         | (pipe->pipe.ep << QH_EP_SHIFT)
 500         | (pipe->pipe.devaddr << QH_DEVADDR_SHIFT));
 501     pipe->qh.info2 = ((1 << QH_MULT_SHIFT)
 502                       | (pipe->pipe.tt_port << QH_HUBPORT_SHIFT)
 503                       | (pipe->pipe.tt_devaddr << QH_HUBADDR_SHIFT));
 504
 505     // Setup transfer descriptors
 506     struct ehci_qtd *tds = memalign_tmphigh(EHCI_QTD_ALIGN, sizeof(*tds) * 3);
 507     if (!tds) {
 508         warn_noalloc();
 509         return -1;
 510     }
 511     memset(tds, 0, sizeof(*tds) * 3);
 512     struct ehci_qtd *td = tds;
 513
 514     td->qtd_next = (u32)&td[1];
 515     td->alt_next = EHCI_PTR_TERM;
 516     td->token = (ehci_explen(cmdsize) | QTD_STS_ACTIVE
 517                  | QTD_PID_SETUP | ehci_maxerr(3));
 518     fillTDbuffer(td, maxpacket, cmd, cmdsize);
 519     td++;
 520
 521     if (datasize) {
 522         td->qtd_next = (u32)&td[1];
 523         td->alt_next = EHCI_PTR_TERM;
 524         td->token = (QTD_TOGGLE | ehci_explen(datasize) | QTD_STS_ACTIVE
 525                      | (dir ? QTD_PID_IN : QTD_PID_OUT) | ehci_maxerr(3));
 526         fillTDbuffer(td, maxpacket, data, datasize);
 527         td++;
 528     }
 529
 530     td->qtd_next = EHCI_PTR_TERM;
 531     td->alt_next = EHCI_PTR_TERM;
 532     td->token = (QTD_TOGGLE | QTD_STS_ACTIVE
 533                  | (dir ? QTD_PID_OUT : QTD_PID_IN) | ehci_maxerr(3));
 534
 535     // Transfer data
 536     barrier();
 537     pipe->qh.qtd_next = (u32)tds;
 538     int i, ret=0;
 539     for (i=0; i<3; i++) {
 540         struct ehci_qtd *td = &tds[i];
 541         ret = ehci_wait_td(pipe, td, 500);
 542         if (ret)
 543             break;
 544     }
 545     free(tds);
 546     return ret;
 547 }
 548
 549 struct usb_pipe *
 550 ehci_alloc_bulk_pipe(struct usb_pipe *dummy)
 551 {
 552     // XXX - this func is same as alloc_control except for malloc_low
 553     if (! CONFIG_USB_EHCI)
 554         return NULL;
 555     struct usb_ehci_s *cntl = container_of(
 556         dummy->cntl, struct usb_ehci_s, usb);
 557     dprintf(7, "ehci_alloc_bulk_pipe %p\n", &cntl->usb);
 558
 559     // Allocate a queue head.
 560     struct ehci_pipe *pipe = memalign_low(EHCI_QH_ALIGN, sizeof(*pipe));
 561     if (!pipe) {
 562         warn_noalloc();
 563         return NULL;
 564     }
 565     memset(pipe, 0, sizeof(*pipe));
 566     memcpy(&pipe->pipe, dummy, sizeof(pipe->pipe));
 567     pipe->qh.qtd_next = pipe->qh.alt_next = EHCI_PTR_TERM;
 568
 569     // Add queue head to controller list.
 570     struct ehci_qh *async_qh = cntl->async_qh;
 571     pipe->qh.next = async_qh->next;
 572     barrier();
 573     async_qh->next = (u32)&pipe->qh | EHCI_PTR_QH;
 574     return &pipe->pipe;
 575 }
 576
 577 #define STACKQTDS 4
 578
 579 int
 580 ehci_send_bulk(struct usb_pipe *p, int dir, void *data, int datasize)
 581 {
 582     if (! CONFIG_USB_EHCI)
 583         return -1;
 584     struct ehci_pipe *pipe = container_of(p, struct ehci_pipe, pipe);
 585     dprintf(7, "ehci_send_bulk qh=%p dir=%d data=%p size=%d\n"
 586             , &pipe->qh, dir, data, datasize);
 587
 588     // Allocate 4 tds on stack (16byte aligned)
 589     u8 tdsbuf[sizeof(struct ehci_qtd) * STACKQTDS + EHCI_QTD_ALIGN - 1];
 590     struct ehci_qtd *tds = (void*)ALIGN((u32)tdsbuf, EHCI_QTD_ALIGN);
 591     memset(tds, 0, sizeof(*tds) * STACKQTDS);
 592
 593     // Setup fields in qh
 594     u16 maxpacket = GET_FLATPTR(pipe->pipe.maxpacket);
 595     SET_FLATPTR(pipe->qh.info1
 596                 , ((1 << QH_MULT_SHIFT)
 597                    | (maxpacket << QH_MAXPACKET_SHIFT)
 598                    | (GET_FLATPTR(pipe->pipe.speed) << QH_SPEED_SHIFT)
 599                    | (GET_FLATPTR(pipe->pipe.ep) << QH_EP_SHIFT)
 600                    | (GET_FLATPTR(pipe->pipe.devaddr) << QH_DEVADDR_SHIFT)));
 601     SET_FLATPTR(pipe->qh.info2
 602                 , ((1 << QH_MULT_SHIFT)
 603                    | (GET_FLATPTR(pipe->pipe.tt_port) << QH_HUBPORT_SHIFT)
 604                    | (GET_FLATPTR(pipe->pipe.tt_devaddr) << QH_HUBADDR_SHIFT)));
 605     barrier();
 606     SET_FLATPTR(pipe->qh.qtd_next, (u32)MAKE_FLATPTR(GET_SEG(SS), tds));
 607
 608     int tdpos = 0;
 609     while (datasize) {
 610         struct ehci_qtd *td = &tds[tdpos++ % STACKQTDS];
 611         int ret = ehci_wait_td(pipe, td, 5000);
 612         if (ret)
 613             return -1;
 614
 615         struct ehci_qtd *nexttd_fl = MAKE_FLATPTR(GET_SEG(SS)
 616                                                  , &tds[tdpos % STACKQTDS]);
 617
 618         int transfer = fillTDbuffer(td, maxpacket, data, datasize);
 619         td->qtd_next = (transfer==datasize ? EHCI_PTR_TERM : (u32)nexttd_fl);
 620         td->alt_next = EHCI_PTR_TERM;
 621         barrier();
 622         td->token = (ehci_explen(transfer) | QTD_STS_ACTIVE
 623                      | (dir ? QTD_PID_IN : QTD_PID_OUT) | ehci_maxerr(3));
 624
 625         data += transfer;
 626         datasize -= transfer;
 627     }
 628     int i;
 629     for (i=0; i<STACKQTDS; i++) {
 630         struct ehci_qtd *td = &tds[tdpos++ % STACKQTDS];
 631         int ret = ehci_wait_td(pipe, td, 5000);
 632         if (ret)
 633             return -1;
 634     }
 635
 636     return 0;
 637 }
 638
 639 struct usb_pipe *
 640 ehci_alloc_intr_pipe(struct usb_pipe *dummy, int frameexp)
 641 {
 642     if (! CONFIG_USB_EHCI)
 643         return NULL;
 644     struct usb_ehci_s *cntl = container_of(
 645         dummy->cntl, struct usb_ehci_s, usb);
 646     dprintf(7, "ehci_alloc_intr_pipe %p %d\n", &cntl->usb, frameexp);
 647
 648     if (frameexp > 10)
 649         frameexp = 10;
 650     int maxpacket = dummy->maxpacket;
 651     // Determine number of entries needed for 2 timer ticks.
 652     int ms = 1<<frameexp;
 653     int count = DIV_ROUND_UP(PIT_TICK_INTERVAL * 1000 * 2, PIT_TICK_RATE * ms);
 654     struct ehci_pipe *pipe = memalign_low(EHCI_QH_ALIGN, sizeof(*pipe));
 655     struct ehci_qtd *tds = memalign_low(EHCI_QTD_ALIGN, sizeof(*tds) * count);
 656     void *data = malloc_low(maxpacket * count);
 657     if (!pipe || !tds || !data) {
 658         warn_noalloc();
 659         goto fail;
 660     }
 661     memset(pipe, 0, sizeof(*pipe));
 662     memcpy(&pipe->pipe, dummy, sizeof(pipe->pipe));
 663     pipe->next_td = pipe->tds = tds;
 664     pipe->data = data;
 665
 666     pipe->qh.info1 = (
 667         (1 << QH_MULT_SHIFT)
 668         | (maxpacket << QH_MAXPACKET_SHIFT)
 669         | (pipe->pipe.speed << QH_SPEED_SHIFT)
 670         | (pipe->pipe.ep << QH_EP_SHIFT)
 671         | (pipe->pipe.devaddr << QH_DEVADDR_SHIFT));
 672     pipe->qh.info2 = ((1 << QH_MULT_SHIFT)
 673                       | (pipe->pipe.tt_port << QH_HUBPORT_SHIFT)
 674                       | (pipe->pipe.tt_devaddr << QH_HUBADDR_SHIFT)
 675                       | (0x01 << QH_SMASK_SHIFT)
 676                       | (0x1c << QH_CMASK_SHIFT));
 677     pipe->qh.qtd_next = (u32)tds;
 678
 679     int i;
 680     for (i=0; i<count; i++) {
 681         struct ehci_qtd *td = &tds[i];
 682         td->qtd_next = (i==count-1 ? (u32)tds : (u32)&td[1]);
 683         td->alt_next = EHCI_PTR_TERM;
 684         td->token = (ehci_explen(maxpacket) | QTD_STS_ACTIVE
 685                      | QTD_PID_IN | ehci_maxerr(3));
 686         td->buf[0] = (u32)data + maxpacket * i;
 687     }
 688
 689     // Add to interrupt schedule.
 690     struct ehci_framelist *fl = (void*)readl(&cntl->regs->periodiclistbase);
 691     if (frameexp == 0) {
 692         // Add to existing interrupt entry.
 693         struct ehci_qh *intr_qh = (void*)(fl->links[0] & ~EHCI_PTR_BITS);
 694         pipe->qh.next = intr_qh->next;
 695         barrier();
 696         intr_qh->next = (u32)&pipe->qh | EHCI_PTR_QH;
 697     } else {
 698         int startpos = 1<<(frameexp-1);
 699         pipe->qh.next = fl->links[startpos];
 700         barrier();
 701         for (i=startpos; i<ARRAY_SIZE(fl->links); i+=ms)
 702             fl->links[i] = (u32)&pipe->qh | EHCI_PTR_QH;
 703     }
 704
 705     return &pipe->pipe;
 706 fail:
 707     free(pipe);
 708     free(tds);
 709     free(data);
 710     return NULL;
 711 }
 712
 713 int
 714 ehci_poll_intr(struct usb_pipe *p, void *data)
 715 {
 716     ASSERT16();
 717     if (! CONFIG_USB_EHCI)
 718         return -1;
 719     struct ehci_pipe *pipe = container_of(p, struct ehci_pipe, pipe);
 720     struct ehci_qtd *td = GET_FLATPTR(pipe->next_td);
 721     u32 token = GET_FLATPTR(td->token);
 722     if (token & QTD_STS_ACTIVE)
 723         // No intrs found.
 724         return -1;
 725     // XXX - check for errors.
 726
 727     // Copy data.
 728     int maxpacket = GET_FLATPTR(pipe->pipe.maxpacket);
 729     int pos = td - GET_FLATPTR(pipe->tds);
 730     void *tddata = GET_FLATPTR(pipe->data) + maxpacket * pos;
 731     memcpy_far(GET_SEG(SS), data
 732                , FLATPTR_TO_SEG(tddata), (void*)FLATPTR_TO_OFFSET(tddata)
 733                , maxpacket);
 734
 735     // Reenable this td.
 736     struct ehci_qtd *next = (void*)(GET_FLATPTR(td->qtd_next) & ~EHCI_PTR_BITS);
 737     SET_FLATPTR(pipe->next_td, next);
 738     SET_FLATPTR(td->buf[0], (u32)tddata);
 739     barrier();
 740     SET_FLATPTR(td->token, (ehci_explen(maxpacket) | QTD_STS_ACTIVE
 741                             | QTD_PID_IN | ehci_maxerr(3)));
 742
 743     return 0;
 744 }