qemu/roms/seabios/src/hw/usb-xhci.c

   1 // Code for handling XHCI "Super speed" USB controllers.
   2 //
   3 // Copyright (C) 2013  Gerd Hoffmann <kraxel@redhat.com>
   4 // Copyright (C) 2014  Kevin O'Connor <kevin@koconnor.net>
   5 //
   6 // This file may be distributed under the terms of the GNU LGPLv3 license.
   7
   8 #include "config.h" // CONFIG_*
   9 #include "malloc.h" // memalign_low
  10 #include "memmap.h" // PAGE_SIZE
  11 #include "output.h" // dprintf
  12 #include "pci.h" // pci_bdf_to_bus
  13 #include "pci_ids.h" // PCI_CLASS_SERIAL_USB_XHCI
  14 #include "pci_regs.h" // PCI_BASE_ADDRESS_0
  15 #include "string.h" // memcpy
  16 #include "usb.h" // struct usb_s
  17 #include "usb-xhci.h" // struct ehci_qh
  18 #include "util.h" // timer_calc
  19 #include "x86.h" // readl
  20
  21 // --------------------------------------------------------------
  22 // configuration
  23
  24 #define XHCI_RING_ITEMS          16
  25 #define XHCI_RING_SIZE           (XHCI_RING_ITEMS*sizeof(struct xhci_trb))
  26
  27 /*
  28  *  xhci_ring structs are allocated with XHCI_RING_SIZE alignment,
  29  *  then we can get it from a trb pointer (provided by evt ring).
  30  */
  31 #define XHCI_RING(_trb)          \
  32     ((struct xhci_ring*)((u32)(_trb) & ~(XHCI_RING_SIZE-1)))
  33
  34 // --------------------------------------------------------------
  35 // bit definitions
  36
  37 #define XHCI_CMD_RS              (1<<0)
  38 #define XHCI_CMD_HCRST           (1<<1)
  39 #define XHCI_CMD_INTE            (1<<2)
  40 #define XHCI_CMD_HSEE            (1<<3)
  41 #define XHCI_CMD_LHCRST          (1<<7)
  42 #define XHCI_CMD_CSS             (1<<8)
  43 #define XHCI_CMD_CRS             (1<<9)
  44 #define XHCI_CMD_EWE             (1<<10)
  45 #define XHCI_CMD_EU3S            (1<<11)
  46
  47 #define XHCI_STS_HCH             (1<<0)
  48 #define XHCI_STS_HSE             (1<<2)
  49 #define XHCI_STS_EINT            (1<<3)
  50 #define XHCI_STS_PCD             (1<<4)
  51 #define XHCI_STS_SSS             (1<<8)
  52 #define XHCI_STS_RSS             (1<<9)
  53 #define XHCI_STS_SRE             (1<<10)
  54 #define XHCI_STS_CNR             (1<<11)
  55 #define XHCI_STS_HCE             (1<<12)
  56
  57 #define XHCI_PORTSC_CCS          (1<<0)
  58 #define XHCI_PORTSC_PED          (1<<1)
  59 #define XHCI_PORTSC_OCA          (1<<3)
  60 #define XHCI_PORTSC_PR           (1<<4)
  61 #define XHCI_PORTSC_PLS_SHIFT        5
  62 #define XHCI_PORTSC_PLS_MASK     0xf
  63 #define XHCI_PORTSC_PP           (1<<9)
  64 #define XHCI_PORTSC_SPEED_SHIFT      10
  65 #define XHCI_PORTSC_SPEED_MASK   0xf
  66 #define XHCI_PORTSC_SPEED_FULL   (1<<10)
  67 #define XHCI_PORTSC_SPEED_LOW    (2<<10)
  68 #define XHCI_PORTSC_SPEED_HIGH   (3<<10)
  69 #define XHCI_PORTSC_SPEED_SUPER  (4<<10)
  70 #define XHCI_PORTSC_PIC_SHIFT        14
  71 #define XHCI_PORTSC_PIC_MASK     0x3
  72 #define XHCI_PORTSC_LWS          (1<<16)
  73 #define XHCI_PORTSC_CSC          (1<<17)
  74 #define XHCI_PORTSC_PEC          (1<<18)
  75 #define XHCI_PORTSC_WRC          (1<<19)
  76 #define XHCI_PORTSC_OCC          (1<<20)
  77 #define XHCI_PORTSC_PRC          (1<<21)
  78 #define XHCI_PORTSC_PLC          (1<<22)
  79 #define XHCI_PORTSC_CEC          (1<<23)
  80 #define XHCI_PORTSC_CAS          (1<<24)
  81 #define XHCI_PORTSC_WCE          (1<<25)
  82 #define XHCI_PORTSC_WDE          (1<<26)
  83 #define XHCI_PORTSC_WOE          (1<<27)
  84 #define XHCI_PORTSC_DR           (1<<30)
  85 #define XHCI_PORTSC_WPR          (1<<31)
  86
  87 #define TRB_C               (1<<0)
  88 #define TRB_TYPE_SHIFT          10
  89 #define TRB_TYPE_MASK       0x3f
  90 #define TRB_TYPE(t)         (((t) >> TRB_TYPE_SHIFT) & TRB_TYPE_MASK)
  91
  92 #define TRB_EV_ED           (1<<2)
  93
  94 #define TRB_TR_ENT          (1<<1)
  95 #define TRB_TR_ISP          (1<<2)
  96 #define TRB_TR_NS           (1<<3)
  97 #define TRB_TR_CH           (1<<4)
  98 #define TRB_TR_IOC          (1<<5)
  99 #define TRB_TR_IDT          (1<<6)
 100 #define TRB_TR_TBC_SHIFT        7
 101 #define TRB_TR_TBC_MASK     0x3
 102 #define TRB_TR_BEI          (1<<9)
 103 #define TRB_TR_TLBPC_SHIFT      16
 104 #define TRB_TR_TLBPC_MASK   0xf
 105 #define TRB_TR_FRAMEID_SHIFT    20
 106 #define TRB_TR_FRAMEID_MASK 0x7ff
 107 #define TRB_TR_SIA          (1<<31)
 108
 109 #define TRB_TR_DIR          (1<<16)
 110
 111 #define TRB_CR_SLOTID_SHIFT     24
 112 #define TRB_CR_SLOTID_MASK  0xff
 113 #define TRB_CR_EPID_SHIFT       16
 114 #define TRB_CR_EPID_MASK    0x1f
 115
 116 #define TRB_CR_BSR          (1<<9)
 117 #define TRB_CR_DC           (1<<9)
 118
 119 #define TRB_LK_TC           (1<<1)
 120
 121 #define TRB_INTR_SHIFT          22
 122 #define TRB_INTR_MASK       0x3ff
 123 #define TRB_INTR(t)         (((t).status >> TRB_INTR_SHIFT) & TRB_INTR_MASK)
 124
 125 typedef enum TRBType {
 126     TRB_RESERVED = 0,
 127     TR_NORMAL,
 128     TR_SETUP,
 129     TR_DATA,
 130     TR_STATUS,
 131     TR_ISOCH,
 132     TR_LINK,
 133     TR_EVDATA,
 134     TR_NOOP,
 135     CR_ENABLE_SLOT,
 136     CR_DISABLE_SLOT,
 137     CR_ADDRESS_DEVICE,
 138     CR_CONFIGURE_ENDPOINT,
 139     CR_EVALUATE_CONTEXT,
 140     CR_RESET_ENDPOINT,
 141     CR_STOP_ENDPOINT,
 142     CR_SET_TR_DEQUEUE,
 143     CR_RESET_DEVICE,
 144     CR_FORCE_EVENT,
 145     CR_NEGOTIATE_BW,
 146     CR_SET_LATENCY_TOLERANCE,
 147     CR_GET_PORT_BANDWIDTH,
 148     CR_FORCE_HEADER,
 149     CR_NOOP,
 150     ER_TRANSFER = 32,
 151     ER_COMMAND_COMPLETE,
 152     ER_PORT_STATUS_CHANGE,
 153     ER_BANDWIDTH_REQUEST,
 154     ER_DOORBELL,
 155     ER_HOST_CONTROLLER,
 156     ER_DEVICE_NOTIFICATION,
 157     ER_MFINDEX_WRAP,
 158 } TRBType;
 159
 160 typedef enum TRBCCode {
 161     CC_INVALID = 0,
 162     CC_SUCCESS,
 163     CC_DATA_BUFFER_ERROR,
 164     CC_BABBLE_DETECTED,
 165     CC_USB_TRANSACTION_ERROR,
 166     CC_TRB_ERROR,
 167     CC_STALL_ERROR,
 168     CC_RESOURCE_ERROR,
 169     CC_BANDWIDTH_ERROR,
 170     CC_NO_SLOTS_ERROR,
 171     CC_INVALID_STREAM_TYPE_ERROR,
 172     CC_SLOT_NOT_ENABLED_ERROR,
 173     CC_EP_NOT_ENABLED_ERROR,
 174     CC_SHORT_PACKET,
 175     CC_RING_UNDERRUN,
 176     CC_RING_OVERRUN,
 177     CC_VF_ER_FULL,
 178     CC_PARAMETER_ERROR,
 179     CC_BANDWIDTH_OVERRUN,
 180     CC_CONTEXT_STATE_ERROR,
 181     CC_NO_PING_RESPONSE_ERROR,
 182     CC_EVENT_RING_FULL_ERROR,
 183     CC_INCOMPATIBLE_DEVICE_ERROR,
 184     CC_MISSED_SERVICE_ERROR,
 185     CC_COMMAND_RING_STOPPED,
 186     CC_COMMAND_ABORTED,
 187     CC_STOPPED,
 188     CC_STOPPED_LENGTH_INVALID,
 189     CC_MAX_EXIT_LATENCY_TOO_LARGE_ERROR = 29,
 190     CC_ISOCH_BUFFER_OVERRUN = 31,
 191     CC_EVENT_LOST_ERROR,
 192     CC_UNDEFINED_ERROR,
 193     CC_INVALID_STREAM_ID_ERROR,
 194     CC_SECONDARY_BANDWIDTH_ERROR,
 195     CC_SPLIT_TRANSACTION_ERROR
 196 } TRBCCode;
 197
 198 enum {
 199     PLS_U0              =  0,
 200     PLS_U1              =  1,
 201     PLS_U2              =  2,
 202     PLS_U3              =  3,
 203     PLS_DISABLED        =  4,
 204     PLS_RX_DETECT       =  5,
 205     PLS_INACTIVE        =  6,
 206     PLS_POLLING         =  7,
 207     PLS_RECOVERY        =  8,
 208     PLS_HOT_RESET       =  9,
 209     PLS_COMPILANCE_MODE = 10,
 210     PLS_TEST_MODE       = 11,
 211     PLS_RESUME          = 15,
 212 };
 213
 214 #define xhci_get_field(data, field)             \
 215     (((data) >> field##_SHIFT) & field##_MASK)
 216
 217 // --------------------------------------------------------------
 218 // state structs
 219
 220 struct xhci_ring {
 221     struct xhci_trb      ring[XHCI_RING_ITEMS];
 222     struct xhci_trb      evt;
 223     u32                  eidx;
 224     u32                  nidx;
 225     u32                  cs;
 226     struct mutex_s       lock;
 227 };
 228
 229 struct usb_xhci_s {
 230     struct usb_s         usb;
 231
 232     /* devinfo */
 233     u32                  baseaddr;
 234     u32                  xcap;
 235     u32                  ports;
 236     u32                  slots;
 237     u8                   context64;
 238
 239     /* xhci registers */
 240     struct xhci_caps     *caps;
 241     struct xhci_op       *op;
 242     struct xhci_pr       *pr;
 243     struct xhci_ir       *ir;
 244     struct xhci_db       *db;
 245
 246     /* xhci data structures */
 247     struct xhci_devlist  *devs;
 248     struct xhci_ring     *cmds;
 249     struct xhci_ring     *evts;
 250     struct xhci_er_seg   *eseg;
 251 };
 252
 253 struct xhci_pipe {
 254     struct xhci_ring     reqs;
 255
 256     struct usb_pipe      pipe;
 257     u32                  slotid;
 258     u32                  epid;
 259     void                 *buf;
 260     int                  bufused;
 261 };
 262
 263 // --------------------------------------------------------------
 264 // tables
 265
 266 static const char *speed_name[16] = {
 267     [ 0 ] = " - ",
 268     [ 1 ] = "Full",
 269     [ 2 ] = "Low",
 270     [ 3 ] = "High",
 271     [ 4 ] = "Super",
 272 };
 273
 274 static const int speed_from_xhci[16] = {
 275     [ 0 ] = -1,
 276     [ 1 ] = USB_FULLSPEED,
 277     [ 2 ] = USB_LOWSPEED,
 278     [ 3 ] = USB_HIGHSPEED,
 279     [ 4 ] = USB_SUPERSPEED,
 280     [ 5 ... 15 ] = -1,
 281 };
 282
 283 static const int speed_to_xhci[] = {
 284     [ USB_FULLSPEED  ] = 1,
 285     [ USB_LOWSPEED   ] = 2,
 286     [ USB_HIGHSPEED  ] = 3,
 287     [ USB_SUPERSPEED ] = 4,
 288 };
 289
 290 static const int eptype_to_xhci_in[] = {
 291     [ USB_ENDPOINT_XFER_CONTROL] = 4,
 292     [ USB_ENDPOINT_XFER_ISOC   ] = 5,
 293     [ USB_ENDPOINT_XFER_BULK   ] = 6,
 294     [ USB_ENDPOINT_XFER_INT    ] = 7,
 295 };
 296
 297 static const int eptype_to_xhci_out[] = {
 298     [ USB_ENDPOINT_XFER_CONTROL] = 4,
 299     [ USB_ENDPOINT_XFER_ISOC   ] = 1,
 300     [ USB_ENDPOINT_XFER_BULK   ] = 2,
 301     [ USB_ENDPOINT_XFER_INT    ] = 3,
 302 };
 303
 304 static int wait_bit(u32 *reg, u32 mask, int value, u32 timeout)
 305 {
 306     u32 end = timer_calc(timeout);
 307
 308     while ((readl(reg) & mask) != value) {
 309         if (timer_check(end)) {
 310             warn_timeout();
 311             return -1;
 312         }
 313         yield();
 314     }
 315     return 0;
 316 }
 317
 318
 319 /****************************************************************
 320  * Root hub
 321  ****************************************************************/
 322
 323 #define XHCI_TIME_POSTPOWER 20
 324
 325 // Check if device attached to port
 326 static void
 327 xhci_print_port_state(int loglevel, const char *prefix, u32 port, u32 portsc)
 328 {
 329     u32 pls = xhci_get_field(portsc, XHCI_PORTSC_PLS);
 330     u32 speed = xhci_get_field(portsc, XHCI_PORTSC_SPEED);
 331
 332     dprintf(loglevel, "%s port #%d: 0x%08x,%s%s pls %d, speed %d [%s]\n",
 333             prefix, port + 1, portsc,
 334             (portsc & XHCI_PORTSC_PP)  ? " powered," : "",
 335             (portsc & XHCI_PORTSC_PED) ? " enabled," : "",
 336             pls, speed, speed_name[speed]);
 337 }
 338
 339 static int
 340 xhci_hub_detect(struct usbhub_s *hub, u32 port)
 341 {
 342     struct usb_xhci_s *xhci = container_of(hub->cntl, struct usb_xhci_s, usb);
 343     u32 portsc = readl(&xhci->pr[port].portsc);
 344     return (portsc & XHCI_PORTSC_CCS) ? 1 : 0;
 345 }
 346
 347 // Reset device on port
 348 static int
 349 xhci_hub_reset(struct usbhub_s *hub, u32 port)
 350 {
 351     struct usb_xhci_s *xhci = container_of(hub->cntl, struct usb_xhci_s, usb);
 352     u32 portsc = readl(&xhci->pr[port].portsc);
 353     int rc;
 354
 355     switch (xhci_get_field(portsc, XHCI_PORTSC_PLS)) {
 356     case PLS_U0:
 357         rc = speed_from_xhci[xhci_get_field(portsc, XHCI_PORTSC_SPEED)];
 358         break;
 359     case PLS_POLLING:
 360         xhci_print_port_state(3, __func__, port, portsc);
 361         portsc |= XHCI_PORTSC_PR;
 362         writel(&xhci->pr[port].portsc, portsc);
 363         if (wait_bit(&xhci->pr[port].portsc, XHCI_PORTSC_PED, XHCI_PORTSC_PED, 100) != 0)
 364             return -1;
 365         portsc = readl(&xhci->pr[port].portsc);
 366         rc = speed_from_xhci[xhci_get_field(portsc, XHCI_PORTSC_SPEED)];
 367         break;
 368     default:
 369         rc = -1;
 370         break;
 371     }
 372
 373     xhci_print_port_state(1, "XHCI", port, portsc);
 374     return rc;
 375 }
 376
 377 static void
 378 xhci_hub_disconnect(struct usbhub_s *hub, u32 port)
 379 {
 380     // XXX - should turn the port power off.
 381 }
 382
 383 static struct usbhub_op_s xhci_hub_ops = {
 384     .detect = xhci_hub_detect,
 385     .reset = xhci_hub_reset,
 386     .disconnect = xhci_hub_disconnect,
 387 };
 388
 389 // Find any devices connected to the root hub.
 390 static int
 391 xhci_check_ports(struct usb_xhci_s *xhci)
 392 {
 393     // Wait for port power to stabilize.
 394     msleep(XHCI_TIME_POSTPOWER);
 395
 396     struct usbhub_s hub;
 397     memset(&hub, 0, sizeof(hub));
 398     hub.cntl = &xhci->usb;
 399     hub.portcount = xhci->ports;
 400     hub.op = &xhci_hub_ops;
 401     usb_enumerate(&hub);
 402     return hub.devcount;
 403 }
 404
 405
 406 /****************************************************************
 407  * Setup
 408  ****************************************************************/
 409
 410 static void
 411 xhci_free_pipes(struct usb_xhci_s *xhci)
 412 {
 413     // XXX - should walk list of pipes and free unused pipes.
 414 }
 415
 416 static void
 417 configure_xhci(void *data)
 418 {
 419     struct usb_xhci_s *xhci = data;
 420     u32 reg;
 421
 422     xhci->devs = memalign_high(64, sizeof(*xhci->devs) * (xhci->slots + 1));
 423     xhci->eseg = memalign_high(64, sizeof(*xhci->eseg));
 424     xhci->cmds = memalign_high(XHCI_RING_SIZE, sizeof(*xhci->cmds));
 425     xhci->evts = memalign_high(XHCI_RING_SIZE, sizeof(*xhci->evts));
 426     if (!xhci->devs || !xhci->cmds || !xhci->evts || !xhci->eseg) {
 427         warn_noalloc();
 428         goto fail;
 429     }
 430     memset(xhci->devs, 0, sizeof(*xhci->devs) * (xhci->slots + 1));
 431     memset(xhci->cmds, 0, sizeof(*xhci->cmds));
 432     memset(xhci->evts, 0, sizeof(*xhci->evts));
 433     memset(xhci->eseg, 0, sizeof(*xhci->eseg));
 434
 435     reg = readl(&xhci->op->usbcmd);
 436     if (reg & XHCI_CMD_RS) {
 437         reg &= ~XHCI_CMD_RS;
 438         writel(&xhci->op->usbcmd, reg);
 439         if (wait_bit(&xhci->op->usbsts, XHCI_STS_HCH, XHCI_STS_HCH, 32) != 0)
 440             goto fail;
 441     }
 442
 443     dprintf(3, "%s: resetting\n", __func__);
 444     writel(&xhci->op->usbcmd, XHCI_CMD_HCRST);
 445     if (wait_bit(&xhci->op->usbcmd, XHCI_CMD_HCRST, 0, 100) != 0)
 446         goto fail;
 447     if (wait_bit(&xhci->op->usbsts, XHCI_STS_CNR, 0, 100) != 0)
 448         goto fail;
 449
 450     writel(&xhci->op->config, xhci->slots);
 451     writel(&xhci->op->dcbaap_low, (u32)xhci->devs);
 452     writel(&xhci->op->dcbaap_high, 0);
 453     writel(&xhci->op->crcr_low, (u32)xhci->cmds | 1);
 454     writel(&xhci->op->crcr_high, 0);
 455     xhci->cmds->cs = 1;
 456
 457     xhci->eseg->ptr_low = (u32)xhci->evts;
 458     xhci->eseg->ptr_high = 0;
 459     xhci->eseg->size = XHCI_RING_ITEMS;
 460     writel(&xhci->ir->erstsz, 1);
 461     writel(&xhci->ir->erdp_low, (u32)xhci->evts);
 462     writel(&xhci->ir->erdp_high, 0);
 463     writel(&xhci->ir->erstba_low, (u32)xhci->eseg);
 464     writel(&xhci->ir->erstba_high, 0);
 465     xhci->evts->cs = 1;
 466
 467     reg = readl(&xhci->caps->hcsparams2);
 468     u32 spb = reg >> 27;
 469     if (spb) {
 470         dprintf(3, "%s: setup %d scratch pad buffers\n", __func__, spb);
 471         u64 *spba = memalign_high(64, sizeof(*spba) * spb);
 472         void *pad = memalign_high(PAGE_SIZE, PAGE_SIZE * spb);
 473         if (!spba || !pad) {
 474             warn_noalloc();
 475             free(spba);
 476             free(pad);
 477             goto fail;
 478         }
 479         int i;
 480         for (i = 0; i < spb; i++)
 481             spba[i] = (u32)pad + (i * PAGE_SIZE);
 482         xhci->devs[0].ptr_low = (u32)spba;
 483         xhci->devs[0].ptr_high = 0;
 484     }
 485
 486     reg = readl(&xhci->op->usbcmd);
 487     reg |= XHCI_CMD_RS;
 488     writel(&xhci->op->usbcmd, reg);
 489
 490     // Find devices
 491     int count = xhci_check_ports(xhci);
 492     xhci_free_pipes(xhci);
 493     if (count)
 494         // Success
 495         return;
 496
 497     // No devices found - shutdown and free controller.
 498     dprintf(1, "XHCI no devices found\n");
 499     reg = readl(&xhci->op->usbcmd);
 500     reg &= ~XHCI_CMD_RS;
 501     writel(&xhci->op->usbcmd, reg);
 502     wait_bit(&xhci->op->usbsts, XHCI_STS_HCH, XHCI_STS_HCH, 32);
 503
 504 fail:
 505     free(xhci->eseg);
 506     free(xhci->evts);
 507     free(xhci->cmds);
 508     free(xhci->devs);
 509     free(xhci);
 510 }
 511
 512 static void
 513 xhci_controller_setup(struct pci_device *pci)
 514 {
 515     struct usb_xhci_s *xhci = malloc_high(sizeof(*xhci));
 516     if (!xhci) {
 517         warn_noalloc();
 518         return;
 519     }
 520     memset(xhci, 0, sizeof(*xhci));
 521
 522     wait_preempt();  // Avoid pci_config_readl when preempting
 523     xhci->baseaddr = pci_config_readl(pci->bdf, PCI_BASE_ADDRESS_0)
 524         & PCI_BASE_ADDRESS_MEM_MASK;
 525     xhci->caps  = (void*)(xhci->baseaddr);
 526     xhci->op    = (void*)(xhci->baseaddr + readb(&xhci->caps->caplength));
 527     xhci->pr    = (void*)(xhci->baseaddr + readb(&xhci->caps->caplength) + 0x400);
 528     xhci->db    = (void*)(xhci->baseaddr + readl(&xhci->caps->dboff));
 529     xhci->ir    = (void*)(xhci->baseaddr + readl(&xhci->caps->rtsoff) + 0x20);
 530
 531     u32 hcs1 = readl(&xhci->caps->hcsparams1);
 532     u32 hcc  = readl(&xhci->caps->hccparams);
 533     xhci->ports = (hcs1 >> 24) & 0xff;
 534     xhci->slots = hcs1         & 0xff;
 535     xhci->xcap  = ((hcc >> 16) & 0xffff) << 2;
 536     xhci->context64 = (hcc & 0x04) ? 1 : 0;
 537
 538     xhci->usb.pci = pci;
 539     xhci->usb.type = USB_TYPE_XHCI;
 540
 541     dprintf(1, "XHCI init on dev %02x:%02x.%x: regs @ %p, %d ports, %d slots"
 542             ", %d byte contexts\n"
 543             , pci_bdf_to_bus(pci->bdf), pci_bdf_to_dev(pci->bdf)
 544             , pci_bdf_to_fn(pci->bdf), xhci->caps
 545             , xhci->ports, xhci->slots, xhci->context64 ? 64 : 32);
 546
 547     if (xhci->xcap) {
 548         u32 off, addr = xhci->baseaddr + xhci->xcap;
 549         do {
 550             struct xhci_xcap *xcap = (void*)addr;
 551             u32 ports, name, cap = readl(&xcap->cap);
 552             switch (cap & 0xff) {
 553             case 0x02:
 554                 name  = readl(&xcap->data[0]);
 555                 ports = readl(&xcap->data[1]);
 556                 dprintf(1, "XHCI    protocol %c%c%c%c %x.%02x"
 557                         ", %d ports (offset %d), def %x\n"
 558                         , (name >>  0) & 0xff
 559                         , (name >>  8) & 0xff
 560                         , (name >> 16) & 0xff
 561                         , (name >> 24) & 0xff
 562                         , (cap >> 24) & 0xff
 563                         , (cap >> 16) & 0xff
 564                         , (ports >>  8) & 0xff
 565                         , (ports >>  0) & 0xff
 566                         , ports >> 16);
 567                 break;
 568             default:
 569                 dprintf(1, "XHCI    extcap 0x%x @ %x\n", cap & 0xff, addr);
 570                 break;
 571             }
 572             off = (cap >> 8) & 0xff;
 573             addr += off << 2;
 574         } while (off > 0);
 575     }
 576
 577     u32 pagesize = readl(&xhci->op->pagesize);
 578     if (PAGE_SIZE != (pagesize<<12)) {
 579         dprintf(1, "XHCI driver does not support page size code %d\n"
 580                 , pagesize<<12);
 581         free(xhci);
 582         return;
 583     }
 584
 585     pci_config_maskw(pci->bdf, PCI_COMMAND, 0, PCI_COMMAND_MASTER);
 586
 587     run_thread(configure_xhci, xhci);
 588 }
 589
 590 void
 591 xhci_setup(void)
 592 {
 593     if (! CONFIG_USB_XHCI)
 594         return;
 595     struct pci_device *pci;
 596     foreachpci(pci) {
 597         if (pci_classprog(pci) == PCI_CLASS_SERIAL_USB_XHCI)
 598             xhci_controller_setup(pci);
 599     }
 600 }
 601
 602
 603 /****************************************************************
 604  * End point communication
 605  ****************************************************************/
 606
 607 static void xhci_doorbell(struct usb_xhci_s *xhci, u32 slotid, u32 value)
 608 {
 609     struct xhci_db *db = xhci->db;
 610     void *addr = &db[slotid].doorbell;
 611     writel(addr, value);
 612 }
 613
 614 static void xhci_process_events(struct usb_xhci_s *xhci)
 615 {
 616     struct xhci_ring *evts = xhci->evts;
 617
 618     for (;;) {
 619         /* check for event */
 620         u32 nidx = evts->nidx;
 621         u32 cs = evts->cs;
 622         struct xhci_trb *etrb = evts->ring + nidx;
 623         u32 control = etrb->control;
 624         if ((control & TRB_C) != (cs ? 1 : 0))
 625             return;
 626
 627         /* process event */
 628         u32 evt_type = TRB_TYPE(control);
 629         u32 evt_cc = (etrb->status >> 24) & 0xff;
 630         switch (evt_type) {
 631         case ER_TRANSFER:
 632         case ER_COMMAND_COMPLETE:
 633         {
 634             struct xhci_trb  *rtrb = (void*)etrb->ptr_low;
 635             struct xhci_ring *ring = XHCI_RING(rtrb);
 636             struct xhci_trb  *evt = &ring->evt;
 637             u32 eidx = rtrb - ring->ring + 1;
 638             dprintf(5, "%s: ring %p [trb %p, evt %p, type %d, eidx %d, cc %d]\n",
 639                     __func__, ring, rtrb, evt, evt_type, eidx, evt_cc);
 640             memcpy(evt, etrb, sizeof(*etrb));
 641             ring->eidx = eidx;
 642             break;
 643         }
 644         case ER_PORT_STATUS_CHANGE:
 645         {
 646             u32 portid = (etrb->ptr_low >> 24) & 0xff;
 647             dprintf(3, "%s: status change port #%d\n",
 648                     __func__, portid);
 649             break;
 650         }
 651         default:
 652             dprintf(1, "%s: unknown event, type %d, cc %d\n",
 653                     __func__, evt_type, evt_cc);
 654             break;
 655         }
 656
 657         /* move ring index, notify xhci */
 658         nidx++;
 659         if (nidx == XHCI_RING_ITEMS) {
 660             nidx = 0;
 661             cs = cs ? 0 : 1;
 662             evts->cs = cs;
 663         }
 664         evts->nidx = nidx;
 665         struct xhci_ir *ir = xhci->ir;
 666         u32 erdp = (u32)(evts->ring + nidx);
 667         writel(&ir->erdp_low, erdp);
 668         writel(&ir->erdp_high, 0);
 669     }
 670 }
 671
 672 static int xhci_ring_busy(struct xhci_ring *ring)
 673 {
 674     u32 eidx = ring->eidx;
 675     u32 nidx = ring->nidx;
 676     return (eidx != nidx);
 677 }
 678
 679 static int xhci_event_wait(struct usb_xhci_s *xhci,
 680                            struct xhci_ring *ring,
 681                            u32 timeout)
 682 {
 683     u32 end = timer_calc(timeout);
 684
 685     for (;;) {
 686         xhci_process_events(xhci);
 687         if (!xhci_ring_busy(ring)) {
 688             u32 status = ring->evt.status;
 689             return (status >> 24) & 0xff;
 690         }
 691         if (timer_check(end)) {
 692             warn_timeout();
 693             return -1;
 694         }
 695         yield();
 696     }
 697 }
 698
 699 static void xhci_trb_queue(struct xhci_ring *ring,
 700                            struct xhci_trb *trb)
 701 {
 702     u32 nidx = ring->nidx;
 703     u32 cs   = ring->cs;
 704     struct xhci_trb *dst;
 705     u32 control;
 706
 707     if (nidx == XHCI_RING_ITEMS-1) {
 708         dst = ring->ring + nidx;
 709         control  = (TR_LINK << 10); // trb type
 710         control |= TRB_LK_TC;
 711         control |= (cs ? TRB_C : 0);
 712         dst->ptr_low = (u32)&ring[0];
 713         dst->ptr_high = 0;
 714         dst->status = 0;
 715         dst->control = control;
 716         nidx = 0;
 717         cs = cs ? 0 : 1;
 718         ring->nidx = nidx;
 719         ring->cs = cs;
 720
 721         dprintf(5, "%s: ring %p [linked]\n", __func__, ring);
 722     }
 723
 724     dst = ring->ring + nidx;
 725     control = trb->control | (cs ? TRB_C : 0);
 726
 727     dst->ptr_low =  trb->ptr_low;
 728     dst->ptr_high = trb->ptr_high;
 729     dst->status =   trb->status;
 730     dst->control =  control;
 731     nidx++;
 732     ring->nidx = nidx;
 733
 734     dprintf(5, "%s: ring %p [nidx %d, len %d]\n",
 735             __func__, ring, nidx,
 736             trb->status & 0xffff);
 737 }
 738
 739 static int xhci_cmd_submit(struct usb_xhci_s *xhci,
 740                            struct xhci_trb *cmd)
 741 {
 742     int rc;
 743
 744     mutex_lock(&xhci->cmds->lock);
 745     xhci_trb_queue(xhci->cmds, cmd);
 746     xhci_doorbell(xhci, 0, 0);
 747     rc = xhci_event_wait(xhci, xhci->cmds, 1000);
 748     mutex_unlock(&xhci->cmds->lock);
 749     return rc;
 750 }
 751
 752 static int xhci_cmd_enable_slot(struct usb_xhci_s *xhci)
 753 {
 754     struct xhci_trb cmd = {
 755         .ptr_low  = 0,
 756         .ptr_high = 0,
 757         .status   = 0,
 758         .control  = (CR_ENABLE_SLOT << 10)
 759     };
 760     dprintf(3, "%s:\n", __func__);
 761     int cc = xhci_cmd_submit(xhci, &cmd);
 762     if (cc != CC_SUCCESS)
 763         return -1;
 764     return (xhci->cmds->evt.control >> 24) & 0xff;
 765 }
 766
 767 #if 0
 768 static int xhci_cmd_disable_slot(struct usb_xhci_s *xhci, u32 slotid)
 769 {
 770     struct xhci_trb cmd = {
 771         .ptr_low  = 0,
 772         .ptr_high = 0,
 773         .status   = 0,
 774         .control  = (slotid << 24) | (CR_DISABLE_SLOT << 10)
 775     };
 776     dprintf(3, "%s: slotid %d\n", __func__, slotid);
 777     return xhci_cmd_submit(xhci, &cmd);
 778 }
 779 #endif
 780
 781 static int xhci_cmd_address_device(struct usb_xhci_s *xhci, u32 slotid
 782                                    , struct xhci_inctx *inctx)
 783 {
 784     struct xhci_trb cmd = {
 785         .ptr_low  = (u32)inctx,
 786         .ptr_high = 0,
 787         .status   = 0,
 788         .control  = (slotid << 24) | (CR_ADDRESS_DEVICE << 10)
 789     };
 790     dprintf(3, "%s: slotid %d\n", __func__, slotid);
 791     return xhci_cmd_submit(xhci, &cmd);
 792 }
 793
 794 static int xhci_cmd_configure_endpoint(struct usb_xhci_s *xhci, u32 slotid
 795                                        , struct xhci_inctx *inctx)
 796 {
 797     struct xhci_trb cmd = {
 798         .ptr_low  = (u32)inctx,
 799         .ptr_high = 0,
 800         .status   = 0,
 801         .control  = (slotid << 24) | (CR_CONFIGURE_ENDPOINT << 10)
 802     };
 803     dprintf(3, "%s: slotid %d, add 0x%x, del 0x%x\n", __func__,
 804             slotid, inctx->add, inctx->del);
 805     return xhci_cmd_submit(xhci, &cmd);
 806 }
 807
 808 static int xhci_cmd_evaluate_context(struct usb_xhci_s *xhci, u32 slotid
 809                                      , struct xhci_inctx *inctx)
 810 {
 811     struct xhci_trb cmd = {
 812         .ptr_low  = (u32)inctx,
 813         .ptr_high = 0,
 814         .status   = 0,
 815         .control  = (slotid << 24) | (CR_EVALUATE_CONTEXT << 10)
 816     };
 817     dprintf(3, "%s: slotid %d, add 0x%x, del 0x%x\n", __func__,
 818             slotid, inctx->add, inctx->del);
 819     return xhci_cmd_submit(xhci, &cmd);
 820 }
 821
 822 static struct xhci_inctx *
 823 xhci_alloc_inctx(struct usbdevice_s *usbdev, int maxepid)
 824 {
 825     struct usb_xhci_s *xhci = container_of(
 826         usbdev->hub->cntl, struct usb_xhci_s, usb);
 827     int size = (sizeof(struct xhci_inctx) * 33) << xhci->context64;
 828     struct xhci_inctx *in = memalign_tmphigh(2048 << xhci->context64, size);
 829     if (!in) {
 830         warn_noalloc();
 831         return NULL;
 832     }
 833     memset(in, 0, size);
 834
 835     struct xhci_slotctx *slot = (void*)&in[1 << xhci->context64];
 836     slot->ctx[0]    |= maxepid << 27; // context entries
 837     slot->ctx[0]    |= speed_to_xhci[usbdev->speed] << 20;
 838
 839     // Set high-speed hub flags.
 840     struct usbdevice_s *hubdev = usbdev->hub->usbdev;
 841     if (hubdev) {
 842         if (usbdev->speed == USB_LOWSPEED || usbdev->speed == USB_FULLSPEED) {
 843             struct xhci_pipe *hpipe = container_of(
 844                 hubdev->defpipe, struct xhci_pipe, pipe);
 845             if (hubdev->speed == USB_HIGHSPEED) {
 846                 slot->ctx[2] |= hpipe->slotid;
 847                 slot->ctx[2] |= (usbdev->port+1) << 8;
 848             } else {
 849                 struct xhci_slotctx *hslot = (void*)xhci->devs[hpipe->slotid].ptr_low;
 850                 slot->ctx[2] = hslot->ctx[2];
 851             }
 852         }
 853         u32 route = 0;
 854         while (usbdev->hub->usbdev) {
 855             route <<= 4;
 856             route |= (usbdev->port+1) & 0xf;
 857             usbdev = usbdev->hub->usbdev;
 858         }
 859         slot->ctx[0]    |= route;
 860     }
 861
 862     slot->ctx[1]    |= (usbdev->port+1) << 16;
 863
 864     return in;
 865 }
 866
 867 static int xhci_config_hub(struct usbhub_s *hub)
 868 {
 869     struct usb_xhci_s *xhci = container_of(
 870         hub->cntl, struct usb_xhci_s, usb);
 871     struct xhci_pipe *pipe = container_of(
 872         hub->usbdev->defpipe, struct xhci_pipe, pipe);
 873     struct xhci_slotctx *hdslot = (void*)xhci->devs[pipe->slotid].ptr_low;
 874     if ((hdslot->ctx[3] >> 27) == 3)
 875         // Already configured
 876         return 0;
 877     struct xhci_inctx *in = xhci_alloc_inctx(hub->usbdev, 1);
 878     if (!in)
 879         return -1;
 880     in->add = 0x01;
 881     struct xhci_slotctx *slot = (void*)&in[1 << xhci->context64];
 882     slot->ctx[0] |= 1 << 26;
 883     slot->ctx[1] |= hub->portcount << 24;
 884
 885     int cc = xhci_cmd_configure_endpoint(xhci, pipe->slotid, in);
 886     free(in);
 887     if (cc != CC_SUCCESS) {
 888         dprintf(1, "%s: configure hub: failed (cc %d)\n", __func__, cc);
 889         return -1;
 890     }
 891     return 0;
 892 }
 893
 894 static struct usb_pipe *
 895 xhci_alloc_pipe(struct usbdevice_s *usbdev
 896                 , struct usb_endpoint_descriptor *epdesc)
 897 {
 898     u8 eptype = epdesc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
 899     struct usb_xhci_s *xhci = container_of(
 900         usbdev->hub->cntl, struct usb_xhci_s, usb);
 901     struct xhci_pipe *pipe;
 902     u32 epid;
 903
 904     if (epdesc->bEndpointAddress == 0) {
 905         epid = 1;
 906     } else {
 907         epid = (epdesc->bEndpointAddress & 0x0f) * 2;
 908         epid += (epdesc->bEndpointAddress & USB_DIR_IN) ? 1 : 0;
 909     }
 910
 911     if (eptype == USB_ENDPOINT_XFER_CONTROL)
 912         pipe = memalign_high(XHCI_RING_SIZE, sizeof(*pipe));
 913     else
 914         pipe = memalign_low(XHCI_RING_SIZE, sizeof(*pipe));
 915     if (!pipe) {
 916         warn_noalloc();
 917         return NULL;
 918     }
 919     memset(pipe, 0, sizeof(*pipe));
 920
 921     usb_desc2pipe(&pipe->pipe, usbdev, epdesc);
 922     pipe->epid = epid;
 923     pipe->reqs.cs = 1;
 924     if (eptype == USB_ENDPOINT_XFER_INT)
 925         pipe->buf = malloc_high(pipe->pipe.maxpacket);
 926
 927     // Allocate input context and initialize endpoint info.
 928     struct xhci_inctx *in = xhci_alloc_inctx(usbdev, epid);
 929     if (!in)
 930         goto fail;
 931     in->add = 0x01 | (1 << epid);
 932     struct xhci_epctx *ep = (void*)&in[(pipe->epid+1) << xhci->context64];
 933     if (eptype == USB_ENDPOINT_XFER_INT)
 934         ep->ctx[0] = (usb_get_period(usbdev, epdesc) + 3) << 16;
 935     ep->ctx[1]   |= eptype << 3;
 936     if (epdesc->bEndpointAddress & USB_DIR_IN
 937         || eptype == USB_ENDPOINT_XFER_CONTROL)
 938         ep->ctx[1] |= 1 << 5;
 939     ep->ctx[1]   |= pipe->pipe.maxpacket << 16;
 940     ep->deq_low  = (u32)&pipe->reqs.ring[0];
 941     ep->deq_low  |= 1;         // dcs
 942     ep->length   = pipe->pipe.maxpacket;
 943
 944     dprintf(3, "%s: usbdev %p, ring %p, slotid %d, epid %d\n", __func__,
 945             usbdev, &pipe->reqs, pipe->slotid, pipe->epid);
 946     if (pipe->epid == 1) {
 947         if (usbdev->hub->usbdev) {
 948             // Make sure parent hub is configured.
 949             int ret = xhci_config_hub(usbdev->hub);
 950             if (ret)
 951                 goto fail;
 952         }
 953         // Enable slot.
 954         u32 size = (sizeof(struct xhci_slotctx) * 32) << xhci->context64;
 955         struct xhci_slotctx *dev = memalign_high(1024 << xhci->context64, size);
 956         if (!dev) {
 957             warn_noalloc();
 958             goto fail;
 959         }
 960         int slotid = xhci_cmd_enable_slot(xhci);
 961         if (slotid < 0) {
 962             dprintf(1, "%s: enable slot: failed\n", __func__);
 963             free(dev);
 964             goto fail;
 965         }
 966         dprintf(3, "%s: enable slot: got slotid %d\n", __func__, slotid);
 967         memset(dev, 0, size);
 968         pipe->slotid = usbdev->slotid = slotid;
 969         xhci->devs[slotid].ptr_low = (u32)dev;
 970         xhci->devs[slotid].ptr_high = 0;
 971
 972         // Send set_address command.
 973         int cc = xhci_cmd_address_device(xhci, slotid, in);
 974         if (cc != CC_SUCCESS) {
 975             dprintf(1, "%s: address device: failed (cc %d)\n", __func__, cc);
 976             goto fail;
 977         }
 978     } else {
 979         pipe->slotid = usbdev->slotid;
 980         // Send configure command.
 981         int cc = xhci_cmd_configure_endpoint(xhci, pipe->slotid, in);
 982         if (cc != CC_SUCCESS) {
 983             dprintf(1, "%s: configure endpoint: failed (cc %d)\n", __func__, cc);
 984             goto fail;
 985         }
 986     }
 987     free(in);
 988     return &pipe->pipe;
 989
 990 fail:
 991     free(pipe);
 992     free(in);
 993     return NULL;
 994 }
 995
 996 struct usb_pipe *
 997 xhci_realloc_pipe(struct usbdevice_s *usbdev, struct usb_pipe *upipe
 998                   , struct usb_endpoint_descriptor *epdesc)
 999 {
1000     if (!CONFIG_USB_XHCI)
1001         return NULL;
1002     if (!epdesc) {
1003         usb_add_freelist(upipe);
1004         return NULL;
1005     }
1006     if (!upipe)
1007         return xhci_alloc_pipe(usbdev, epdesc);
1008     u8 eptype = epdesc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
1009     int oldmaxpacket = upipe->maxpacket;
1010     usb_desc2pipe(upipe, usbdev, epdesc);
1011     struct xhci_pipe *pipe = container_of(upipe, struct xhci_pipe, pipe);
1012     struct usb_xhci_s *xhci = container_of(
1013         pipe->pipe.cntl, struct usb_xhci_s, usb);
1014     dprintf(3, "%s: usbdev %p, ring %p, slotid %d, epid %d\n", __func__,
1015             usbdev, &pipe->reqs, pipe->slotid, pipe->epid);
1016     if (eptype != USB_ENDPOINT_XFER_CONTROL || upipe->maxpacket == oldmaxpacket)
1017         return upipe;
1018
1019     // maxpacket has changed on control endpoint - update controller.
1020     dprintf(1, "%s: reconf ctl endpoint pkt size: %d -> %d\n",
1021             __func__, oldmaxpacket, pipe->pipe.maxpacket);
1022     struct xhci_inctx *in = xhci_alloc_inctx(usbdev, 1);
1023     if (!in)
1024         return upipe;
1025     in->add = (1 << 1);
1026     struct xhci_epctx *ep = (void*)&in[2 << xhci->context64];
1027     ep->ctx[1] |= (pipe->pipe.maxpacket << 16);
1028     int cc = xhci_cmd_evaluate_context(xhci, pipe->slotid, in);
1029     if (cc != CC_SUCCESS) {
1030         dprintf(1, "%s: reconf ctl endpoint: failed (cc %d)\n",
1031                 __func__, cc);
1032     }
1033     free(in);
1034
1035     return upipe;
1036 }
1037
1038 static void xhci_xfer_queue(struct xhci_pipe *pipe,
1039                             void *data, int datalen, u32 flags)
1040 {
1041     struct xhci_trb trb;
1042     memset(&trb, 0, sizeof(trb));
1043     if (flags & TRB_TR_IDT)
1044         memcpy(&trb.ptr_low, data, datalen);
1045     else
1046         trb.ptr_low  = (u32)data;
1047     trb.status = datalen;
1048     trb.control = flags;
1049     xhci_trb_queue(&pipe->reqs, &trb);
1050 }
1051
1052 static void xhci_xfer_kick(struct xhci_pipe *pipe)
1053 {
1054     struct usb_xhci_s *xhci = container_of(
1055         pipe->pipe.cntl, struct usb_xhci_s, usb);
1056     u32 slotid = pipe->slotid;
1057     u32 epid = pipe->epid;
1058
1059     dprintf(5, "%s: ring %p, slotid %d, epid %d\n",
1060             __func__, &pipe->reqs, slotid, epid);
1061     xhci_doorbell(xhci, slotid, epid);
1062 }
1063
1064 static void xhci_xfer_normal(struct xhci_pipe *pipe,
1065                              void *data, int datalen)
1066 {
1067     xhci_xfer_queue(pipe, data, datalen, (TR_NORMAL << 10) | TRB_TR_IOC);
1068     xhci_xfer_kick(pipe);
1069 }
1070
1071 int
1072 xhci_send_pipe(struct usb_pipe *p, int dir, const void *cmd
1073                , void *data, int datalen)
1074 {
1075     if (!CONFIG_USB_XHCI)
1076         return -1;
1077     struct xhci_pipe *pipe = container_of(p, struct xhci_pipe, pipe);
1078     struct usb_xhci_s *xhci = container_of(
1079         pipe->pipe.cntl, struct usb_xhci_s, usb);
1080
1081     if (cmd) {
1082         const struct usb_ctrlrequest *req = cmd;
1083         if (req->bRequest == USB_REQ_SET_ADDRESS)
1084             // Set address command sent during xhci_alloc_pipe.
1085             return 0;
1086
1087         xhci_xfer_queue(pipe, (void*)req, USB_CONTROL_SETUP_SIZE
1088                         , (TR_SETUP << 10) | TRB_TR_IDT
1089                         | ((datalen ? (dir ? 3 : 2) : 0) << 16));
1090         if (datalen)
1091             xhci_xfer_queue(pipe, data, datalen, (TR_DATA << 10)
1092                             | ((dir ? 1 : 0) << 16));
1093         xhci_xfer_queue(pipe, NULL, 0, (TR_STATUS << 10) | TRB_TR_IOC
1094                         | ((dir ? 0 : 1) << 16));
1095         xhci_xfer_kick(pipe);
1096     } else {
1097         xhci_xfer_normal(pipe, data, datalen);
1098     }
1099
1100     int cc = xhci_event_wait(xhci, &pipe->reqs, usb_xfer_time(p, datalen));
1101     if (cc != CC_SUCCESS) {
1102         dprintf(1, "%s: xfer failed (cc %d)\n", __func__, cc);
1103         return -1;
1104     }
1105
1106     return 0;
1107 }
1108
1109 int VISIBLE32FLAT
1110 xhci_poll_intr(struct usb_pipe *p, void *data)
1111 {
1112     if (!CONFIG_USB_XHCI)
1113         return -1;
1114
1115     struct xhci_pipe *pipe = container_of(p, struct xhci_pipe, pipe);
1116     struct usb_xhci_s *xhci = container_of(
1117         pipe->pipe.cntl, struct usb_xhci_s, usb);
1118     u32 len = pipe->pipe.maxpacket;
1119     void *buf = pipe->buf;
1120     int bufused = pipe->bufused;
1121
1122     if (!bufused) {
1123         xhci_xfer_normal(pipe, buf, len);
1124         bufused = 1;
1125         pipe->bufused = bufused;
1126         return -1;
1127     }
1128
1129     xhci_process_events(xhci);
1130     if (xhci_ring_busy(&pipe->reqs))
1131         return -1;
1132     dprintf(5, "%s: st %x ct %x [ %p <= %p / %d ]\n", __func__,
1133             pipe->reqs.evt.status,
1134             pipe->reqs.evt.control,
1135             data, buf, len);
1136     memcpy(data, buf, len);
1137     xhci_xfer_normal(pipe, buf, len);
1138     return 0;
1139 }