qemu/roms/SLOF/lib/libusb/usb-ehci.c

   1 /*****************************************************************************
   2  * Copyright (c) 2013 IBM Corporation
   3  * All rights reserved.
   4  * This program and the accompanying materials
   5  * are made available under the terms of the BSD License
   6  * which accompanies this distribution, and is available at
   7  * http://www.opensource.org/licenses/bsd-license.php
   8  *
   9  * Contributors:
  10  *     IBM Corporation - initial implementation
  11  *****************************************************************************/
  12
  13 #include <string.h>
  14 #include "usb.h"
  15 #include "usb-core.h"
  16 #include "usb-ehci.h"
  17 #include "tools.h"
  18 #include "paflof.h"
  19
  20 #undef EHCI_DEBUG
  21 //#define EHCI_DEBUG
  22 #ifdef EHCI_DEBUG
  23 #define dprintf(_x ...) do { printf(_x); } while(0)
  24 #else
  25 #define dprintf(_x ...)
  26 #endif
  27
  28 #ifdef EHCI_DEBUG
  29 static void dump_ehci_regs(struct ehci_hcd *ehcd)
  30 {
  31         struct ehci_cap_regs *cap_regs;
  32         struct ehci_op_regs *op_regs;
  33
  34         cap_regs = ehcd->cap_regs;
  35         op_regs = ehcd->op_regs;
  36
  37         dprintf("\n - CAPLENGTH           %02X", read_reg8(&cap_regs->caplength));
  38         dprintf("\n - HCIVERSION          %04X", read_reg16(&cap_regs->hciversion));
  39         dprintf("\n - HCSPARAMS           %08X", read_reg32(&cap_regs->hcsparams));
  40         dprintf("\n - HCCPARAMS           %08X", read_reg32(&cap_regs->hccparams));
  41         dprintf("\n - HCSP_PORTROUTE      %016llX", read_reg64(&cap_regs->portroute));
  42         dprintf("\n");
  43
  44         dprintf("\n - USBCMD              %08X", read_reg32(&op_regs->usbcmd));
  45         dprintf("\n - USBSTS              %08X", read_reg32(&op_regs->usbsts));
  46         dprintf("\n - USBINTR             %08X", read_reg32(&op_regs->usbintr));
  47         dprintf("\n - FRINDEX             %08X", read_reg32(&op_regs->frindex));
  48         dprintf("\n - CTRLDSSEGMENT       %08X", read_reg32(&op_regs->ctrldssegment));
  49         dprintf("\n - PERIODICLISTBASE    %08X", read_reg32(&op_regs->periodiclistbase));
  50         dprintf("\n - ASYNCLISTADDR       %08X", read_reg32(&op_regs->asynclistaddr));
  51         dprintf("\n - CONFIGFLAG          %08X", read_reg32(&op_regs->configflag));
  52         dprintf("\n - PORTSC              %08X", read_reg32(&op_regs->portsc[0]));
  53         dprintf("\n");
  54 }
  55 #endif
  56
  57 static int ehci_hub_check_ports(struct ehci_hcd *ehcd)
  58 {
  59         uint32_t num_ports, portsc, i;
  60         struct usb_dev *dev;
  61
  62         dprintf("%s: enter\n", __func__);
  63         num_ports = read_reg32(&ehcd->cap_regs->hcsparams) & HCS_NPORTS_MASK;
  64         for (i = 0; i < num_ports; i++) {
  65                 dprintf("%s: device %d\n", __func__, i);
  66                 portsc = read_reg32(&ehcd->op_regs->portsc[i]);
  67                 if (portsc & PORT_CONNECT) { /* Device present */
  68                         dprintf("usb-ehci: Device present on port %d\n", i);
  69                         /* Reset the port */
  70                         portsc = read_reg32(&ehcd->op_regs->portsc[i]);
  71                         portsc = (portsc & ~PORT_PE) | PORT_RESET;
  72                         write_reg32(&ehcd->op_regs->portsc[i], portsc);
  73                         SLOF_msleep(20);
  74                         portsc = read_reg32(&ehcd->op_regs->portsc[i]);
  75                         portsc &= ~PORT_RESET;
  76                         write_reg32(&ehcd->op_regs->portsc[i], portsc);
  77                         SLOF_msleep(20);
  78                         dev = usb_devpool_get();
  79                         dprintf("usb-ehci: allocated device %p\n", dev);
  80                         dev->hcidev = ehcd->hcidev;
  81                         dev->speed = USB_HIGH_SPEED; /* TODO: Check for Low/Full speed device */
  82                         if (usb_setup_new_device(dev, i))
  83                                 usb_slof_populate_new_device(dev);
  84                         else
  85                                 printf("usb-ehci: unable to setup device on port %d\n", i);
  86                 }
  87         }
  88         dprintf("%s: exit\n", __func__);
  89         return 0;
  90 }
  91
  92 static int ehci_hcd_init(struct ehci_hcd *ehcd)
  93 {
  94         uint32_t usbcmd;
  95         uint32_t time;
  96         struct ehci_framelist *fl;
  97         struct ehci_qh *qh_intr, *qh_async;
  98         int i;
  99         long fl_phys = 0, qh_intr_phys = 0, qh_async_phys;
 100
 101         /* Reset the host controller */
 102         time = SLOF_GetTimer() + 250;
 103         usbcmd = read_reg32(&ehcd->op_regs->usbcmd);
 104         write_reg32(&ehcd->op_regs->usbcmd, (usbcmd & ~(CMD_PSE | CMD_ASE)) | CMD_HCRESET);
 105         while (time > SLOF_GetTimer())
 106                 cpu_relax();
 107         usbcmd = read_reg32(&ehcd->op_regs->usbcmd);
 108         if (usbcmd & CMD_HCRESET) {
 109                 printf("usb-ehci: reset failed\n");
 110                 return -1;
 111         }
 112
 113         /* Initialize periodic list */
 114         fl = SLOF_dma_alloc(sizeof(*fl));
 115         if (!fl) {
 116                 printf("usb-ehci: Unable to allocate frame list\n");
 117                 goto fail;
 118         }
 119         fl_phys = SLOF_dma_map_in(fl, sizeof(*fl), true);
 120         dprintf("fl %p, fl_phys %lx\n", fl, fl_phys);
 121
 122         /* TODO: allocate qh pool */
 123         qh_intr = SLOF_dma_alloc(sizeof(*qh_intr));
 124         if (!qh_intr) {
 125                 printf("usb-ehci: Unable to allocate interrupt queue head\n");
 126                 goto fail_qh_intr;
 127         }
 128         qh_intr_phys = SLOF_dma_map_in(qh_intr, sizeof(*qh_intr), true);
 129         dprintf("qh_intr %p, qh_intr_phys %lx\n", qh_intr, qh_intr_phys);
 130
 131         memset(qh_intr, 0, sizeof(*qh_intr));
 132         qh_intr->qh_ptr = QH_PTR_TERM;
 133         qh_intr->ep_cap2 = cpu_to_le32(0x01 << QH_SMASK_SHIFT);
 134         qh_intr->next_qtd = qh_intr->alt_next_qtd = QH_PTR_TERM;
 135         qh_intr->token = cpu_to_le32(QH_STS_HALTED);
 136         for (i = 0; i < FL_SIZE; i++)
 137                 fl->fl_ptr[i] = cpu_to_le32(qh_intr_phys | EHCI_TYP_QH);
 138         write_reg32(&ehcd->op_regs->periodiclistbase, fl_phys);
 139
 140         /* Initialize async list */
 141         qh_async = SLOF_dma_alloc(sizeof(*qh_async));
 142         if (!qh_async) {
 143                 printf("usb-ehci: Unable to allocate async queue head\n");
 144                 goto fail_qh_async;
 145         }
 146         qh_async_phys = SLOF_dma_map_in(qh_async, sizeof(*qh_async), true);
 147         dprintf("qh_async %p, qh_async_phys %lx\n", qh_async, qh_async_phys);
 148
 149         memset(qh_async, 0, sizeof(*qh_async));
 150         qh_async->qh_ptr = cpu_to_le32(qh_async_phys | EHCI_TYP_QH);
 151         qh_async->ep_cap1 = cpu_to_le32(QH_CAP_H);
 152         qh_async->next_qtd = qh_async->alt_next_qtd = QH_PTR_TERM;
 153         qh_async->token = cpu_to_le32(QH_STS_HALTED);
 154         write_reg32(&ehcd->op_regs->asynclistaddr, qh_async_phys);
 155         ehcd->qh_async = qh_async;
 156         ehcd->qh_async_phys = qh_async_phys;
 157         ehcd->qh_intr = qh_intr;
 158         ehcd->qh_intr_phys = qh_intr_phys;
 159         ehcd->fl = fl;
 160         ehcd->fl_phys = fl_phys;
 161
 162         write_reg32(&ehcd->op_regs->usbcmd, usbcmd | CMD_ASE | CMD_RUN);
 163         write_reg32(&ehcd->op_regs->configflag, 1);
 164
 165         return 0;
 166
 167 fail_qh_async:
 168         SLOF_dma_map_out(qh_intr_phys, qh_intr, sizeof(*qh_intr));
 169         SLOF_dma_free(qh_intr, sizeof(*qh_intr));
 170 fail_qh_intr:
 171         SLOF_dma_map_out(fl_phys, fl, sizeof(*fl));
 172         SLOF_dma_free(fl, sizeof(*fl));
 173 fail:
 174         return -1;
 175 }
 176
 177 static int ehci_hcd_exit(struct ehci_hcd *ehcd)
 178 {
 179         uint32_t usbcmd;
 180
 181         if (!ehcd) {
 182                 dprintf("NULL pointer\n");
 183                 return false;
 184         }
 185
 186         usbcmd = read_reg32(&ehcd->op_regs->usbcmd);
 187         write_reg32(&ehcd->op_regs->usbcmd, usbcmd | ~CMD_RUN);
 188         write_reg32(&ehcd->op_regs->periodiclistbase, 0);
 189
 190         if (ehcd->pool) {
 191                 SLOF_dma_map_out(ehcd->pool_phys, ehcd->pool, EHCI_PIPE_POOL_SIZE);
 192                 SLOF_dma_free(ehcd->pool, EHCI_PIPE_POOL_SIZE);
 193         }
 194         if (ehcd->qh_intr) {
 195                 SLOF_dma_map_out(ehcd->qh_intr_phys, ehcd->qh_intr, sizeof(struct ehci_qh));
 196                 SLOF_dma_free(ehcd->qh_intr, sizeof(struct ehci_qh));
 197         }
 198         if (ehcd->qh_async) {
 199                 SLOF_dma_map_out(ehcd->qh_async_phys, ehcd->qh_async, sizeof(struct ehci_qh));
 200                 SLOF_dma_free(ehcd->qh_async, sizeof(struct ehci_qh));
 201         }
 202         if (ehcd->fl) {
 203                 SLOF_dma_map_out(ehcd->fl_phys, ehcd->fl, sizeof(struct ehci_framelist));
 204                 SLOF_dma_free(ehcd->fl, sizeof(struct ehci_framelist));
 205         }
 206         return true;
 207 }
 208
 209 static int ehci_alloc_pipe_pool(struct ehci_hcd *ehcd)
 210 {
 211         struct ehci_pipe *epipe, *curr, *prev;
 212         unsigned int i, count;
 213         long epipe_phys = 0;
 214
 215         count = EHCI_PIPE_POOL_SIZE/sizeof(*epipe);
 216         ehcd->pool = epipe = SLOF_dma_alloc(EHCI_PIPE_POOL_SIZE);
 217         if (!epipe)
 218                 return -1;
 219         ehcd->pool_phys = epipe_phys = SLOF_dma_map_in(epipe, EHCI_PIPE_POOL_SIZE, true);
 220         dprintf("%s: epipe %p, epipe_phys %lx\n", __func__, epipe, epipe_phys);
 221
 222         /* Although an array, link them */
 223         for (i = 0, curr = epipe, prev = NULL; i < count; i++, curr++) {
 224                 if (prev)
 225                         prev->pipe.next = &curr->pipe;
 226                 curr->pipe.next = NULL;
 227                 prev = curr;
 228                 curr->qh_phys = epipe_phys + (curr - epipe) * sizeof(*curr) +
 229                         offset_of(struct ehci_pipe, qh);
 230                 dprintf("%s - %d: qh %p, qh_phys %lx\n", __func__,
 231                         i, &curr->qh, curr->qh_phys);
 232         }
 233
 234         if (!ehcd->freelist)
 235                 ehcd->freelist = &epipe->pipe;
 236         else
 237                 ehcd->end->next = &epipe->pipe;
 238         ehcd->end = &prev->pipe;
 239
 240         return 0;
 241 }
 242
 243 static void ehci_init(struct usb_hcd_dev *hcidev)
 244 {
 245         struct ehci_hcd *ehcd;
 246
 247         printf("  EHCI: Initializing\n");
 248         dprintf("%s: device base address %p\n", __func__, hcidev->base);
 249
 250         ehcd = SLOF_alloc_mem(sizeof(*ehcd));
 251         if (!ehcd) {
 252                 printf("usb-ehci: Unable to allocate memory\n");
 253                 return;
 254         }
 255         memset(ehcd, 0, sizeof(*ehcd));
 256
 257         hcidev->nextaddr = 1;
 258         hcidev->priv = ehcd;
 259         ehcd->hcidev = hcidev;
 260         ehcd->cap_regs = (struct ehci_cap_regs *)(hcidev->base);
 261         ehcd->op_regs = (struct ehci_op_regs *)(hcidev->base +
 262                                                 read_reg8(&ehcd->cap_regs->caplength));
 263 #ifdef EHCI_DEBUG
 264         dump_ehci_regs(ehcd);
 265 #endif
 266         ehci_hcd_init(ehcd);
 267         ehci_hub_check_ports(ehcd);
 268 }
 269
 270 static void ehci_exit(struct usb_hcd_dev *hcidev)
 271 {
 272         struct ehci_hcd *ehcd;
 273         static int count = 0;
 274
 275         dprintf("%s: enter \n", __func__);
 276
 277         if (!hcidev && !hcidev->priv) {
 278                 return;
 279         }
 280         count++;
 281         if (count > 1) {
 282                 printf("%s: already called once \n", __func__);
 283                 return;
 284         }
 285         ehcd = hcidev->priv;
 286         ehci_hcd_exit(ehcd);
 287         SLOF_free_mem(ehcd, sizeof(*ehcd));
 288         hcidev->priv = NULL;
 289 }
 290
 291 static void ehci_detect(void)
 292 {
 293
 294 }
 295
 296 static void ehci_disconnect(void)
 297 {
 298
 299 }
 300
 301 static int ehci_handshake(struct ehci_hcd *ehcd, uint32_t timeout)
 302 {
 303         uint32_t usbsts = 0, time;
 304         uint32_t usbcmd;
 305         mb();
 306         usbcmd = read_reg32(&ehcd->op_regs->usbcmd);
 307         /* Ring a doorbell */
 308         write_reg32(&ehcd->op_regs->usbcmd, usbcmd | CMD_IAAD);
 309         mb();
 310         time = SLOF_GetTimer() + timeout;
 311         while ((time > SLOF_GetTimer())) {
 312                 /* Wait for controller to confirm */
 313                 usbsts = read_reg32(&ehcd->op_regs->usbsts);
 314                 if (usbsts & STS_IAA) {
 315                         /* Acknowledge it, for next doorbell to work */
 316                         write_reg32(&ehcd->op_regs->usbsts, STS_IAA);
 317                         return true;
 318                 }
 319                 cpu_relax();
 320         }
 321         return false;
 322 }
 323
 324 static int fill_qtd_buff(struct ehci_qtd *qtd, long data, uint32_t size)
 325 {
 326         long i, rem;
 327         long pos = (data + 0x1000) & ~0xfff;
 328
 329         qtd->buffer[0] = cpu_to_le32(PTR_U32(data));
 330         for (i = 1; i < 5; i++) {
 331                 if ((data + size - 1) >= pos) {
 332                         //dprintf("data spans page boundary: %d, %p\n", i, pos);
 333                         qtd->buffer[i] = cpu_to_le32(pos);
 334                         pos += 0x1000;
 335                 } else
 336                         break;
 337         }
 338         if ((data + size) > pos)
 339                 rem = data + size - pos;
 340         else
 341                 rem = 0;
 342         return rem;
 343 }
 344
 345 static int ehci_send_ctrl(struct usb_pipe *pipe, struct usb_dev_req *req, void *data)
 346 {
 347         struct ehci_hcd *ehcd;
 348         struct ehci_qtd *qtd, *qtds, *qtds_phys;
 349         struct ehci_pipe *epipe;
 350         uint32_t transfer_size = sizeof(*req);
 351         uint32_t datalen, pid;
 352         uint32_t time;
 353         long req_phys = 0, data_phys = 0;
 354         int ret = true;
 355
 356         if (pipe->type != USB_EP_TYPE_CONTROL) {
 357                 printf("usb-ehci: Not a control pipe.\n");
 358                 return false;
 359         }
 360
 361         ehcd = pipe->dev->hcidev->priv;
 362         qtds = qtd = SLOF_dma_alloc(sizeof(*qtds) * 3);
 363         if (!qtds) {
 364                 printf("Error allocating qTDs.\n");
 365                 return false;
 366         }
 367         qtds_phys = (struct ehci_qtd *)SLOF_dma_map_in(qtds, sizeof(*qtds) * 3, true);
 368         memset(qtds, 0, sizeof(*qtds) * 3);
 369         req_phys = SLOF_dma_map_in(req, sizeof(struct usb_dev_req), true);
 370         qtd->next_qtd = cpu_to_le32(PTR_U32(&qtds_phys[1]));
 371         qtd->alt_next_qtd = QH_PTR_TERM;
 372         qtd->token = cpu_to_le32((transfer_size << TOKEN_TBTT_SHIFT) |
 373                         (3 << TOKEN_CERR_SHIFT) |
 374                         (PID_SETUP << TOKEN_PID_SHIFT) |
 375                         (QH_STS_ACTIVE << TOKEN_STATUS_SHIFT));
 376         fill_qtd_buff(qtd, req_phys, sizeof(*req));
 377
 378         qtd++;
 379         datalen = cpu_to_le16(req->wLength);
 380         pid = (req->bmRequestType & REQT_DIR_IN) ? PID_IN : PID_OUT;
 381         if (datalen) {
 382                 data_phys = SLOF_dma_map_in(data, datalen, true);
 383                 qtd->next_qtd = cpu_to_le32(PTR_U32(&qtds_phys[2]));
 384                 qtd->alt_next_qtd = QH_PTR_TERM;
 385                 qtd->token = cpu_to_le32((1 << TOKEN_DT_SHIFT) |
 386                                 (datalen << TOKEN_TBTT_SHIFT) |
 387                                 (3 << TOKEN_CERR_SHIFT) |
 388                                 (pid << TOKEN_PID_SHIFT) |
 389                                 (QH_STS_ACTIVE << TOKEN_STATUS_SHIFT));
 390                 fill_qtd_buff(qtd, data_phys, datalen);
 391                 qtd++;
 392         }
 393
 394         if (pid == PID_IN)
 395                 pid = PID_OUT;
 396         else
 397                 pid = PID_IN;
 398         qtd->next_qtd = QH_PTR_TERM;
 399         qtd->alt_next_qtd = QH_PTR_TERM;
 400         qtd->token = cpu_to_le32((1 << TOKEN_DT_SHIFT) |
 401                         (3 << TOKEN_CERR_SHIFT) |
 402                         (pid << TOKEN_PID_SHIFT) |
 403                         (QH_STS_ACTIVE << TOKEN_STATUS_SHIFT));
 404
 405         /* link qtd to qh and attach to ehcd */
 406         mb();
 407         epipe = container_of(pipe, struct ehci_pipe, pipe);
 408         epipe->qh.next_qtd = cpu_to_le32(PTR_U32(qtds_phys));
 409         epipe->qh.qh_ptr = cpu_to_le32(ehcd->qh_async_phys | EHCI_TYP_QH);
 410         epipe->qh.ep_cap1 = cpu_to_le32((pipe->mps << QH_MPS_SHIFT) |
 411                                 (pipe->speed << QH_EPS_SHIFT) |
 412                                 (pipe->epno << QH_EP_SHIFT) |
 413                                 (pipe->dev->addr << QH_DEV_ADDR_SHIFT));
 414         mb();
 415
 416         ehcd->qh_async->qh_ptr = cpu_to_le32(epipe->qh_phys | EHCI_TYP_QH);
 417
 418         /* transfer data */
 419         mb();
 420         qtd = &qtds[0];
 421         time = SLOF_GetTimer() + USB_TIMEOUT;
 422         do {
 423                 if (le32_to_cpu(qtd->token) & (QH_STS_ACTIVE << TOKEN_STATUS_SHIFT))
 424                         mb();
 425                 else
 426                         qtd++;
 427
 428                 if (time < SLOF_GetTimer()) { /* timed out */
 429                         printf("usb-ehci: control transfer timed out_\n");
 430                         ret = false;
 431                         break;
 432                 }
 433         } while (qtd->next_qtd != QH_PTR_TERM);
 434
 435         ehcd->qh_async->qh_ptr = cpu_to_le32(ehcd->qh_async_phys | EHCI_TYP_QH);
 436         mb();
 437         if (!ehci_handshake(ehcd, USB_TIMEOUT)) {
 438                 printf("%s: handshake failed\n", __func__);
 439                 ret = false;
 440         }
 441
 442         SLOF_dma_map_out(req_phys, req, sizeof(struct usb_dev_req));
 443         SLOF_dma_map_out(data_phys, data, datalen);
 444         SLOF_dma_map_out(PTR_U32(qtds_phys), qtds, sizeof(*qtds) * 3);
 445         SLOF_dma_free(qtds, sizeof(*qtds) * 3);
 446
 447         return ret;
 448 }
 449
 450 static int ehci_transfer_bulk(struct usb_pipe *pipe, void *td, void *td_phys,
 451                         void *data_phys, int size)
 452 {
 453         struct ehci_hcd *ehcd;
 454         struct ehci_qtd *qtd, *qtd_phys;
 455         struct ehci_pipe *epipe;
 456         uint32_t pid;
 457         int i, rem, ret = true;
 458         uint32_t time;
 459         long ptr;
 460
 461         dprintf("usb-ehci: bulk transfer: data %p, size %d, td %p, td_phys %p\n",
 462                 data_phys, size, td, td_phys);
 463
 464         if (pipe->type != USB_EP_TYPE_BULK) {
 465                 printf("usb-ehci: Not a bulk pipe.\n");
 466                 return false;
 467         }
 468
 469         if (size > QTD_MAX_TRANSFER_LEN) {
 470                 printf("usb-ehci: bulk transfer size too big\n");
 471                 return false;
 472         }
 473
 474         ehcd = pipe->dev->hcidev->priv;
 475         pid = (pipe->dir == USB_PIPE_OUT) ? PID_OUT : PID_IN;
 476         qtd = (struct ehci_qtd *)td;
 477         qtd_phys = (struct ehci_qtd *)td_phys;
 478         ptr = (long)data_phys;
 479         for (i = 0; i < NUM_BULK_QTDS; i++) {
 480                 memset(qtd, 0, sizeof(*qtd));
 481                 rem = fill_qtd_buff(qtd, ptr, size);
 482                 qtd->token = cpu_to_le32((1 << TOKEN_DT_SHIFT) |
 483                                 ((size - rem) << TOKEN_TBTT_SHIFT) |
 484                                 (3 << TOKEN_CERR_SHIFT) |
 485                                 (pid << TOKEN_PID_SHIFT) |
 486                                 (QH_STS_ACTIVE << TOKEN_STATUS_SHIFT));
 487                 if (rem) {
 488                         qtd->next_qtd = cpu_to_le32(PTR_U32(&qtd_phys[i+1]));
 489                         qtd->alt_next_qtd = QH_PTR_TERM;
 490                         ptr += size - rem;
 491                         size = rem;
 492                         qtd++;
 493                 } else {
 494                         qtd->next_qtd = qtd->alt_next_qtd = QH_PTR_TERM;
 495                         break; /* no more data */
 496                 }
 497         }
 498
 499         /* link qtd to qh and attach to ehcd */
 500         mb();
 501         epipe = container_of(pipe, struct ehci_pipe, pipe);
 502         epipe->qh.next_qtd = cpu_to_le32(PTR_U32(qtd_phys));
 503         epipe->qh.qh_ptr = cpu_to_le32(ehcd->qh_async_phys | EHCI_TYP_QH);
 504         epipe->qh.ep_cap1 = cpu_to_le32((pipe->mps << QH_MPS_SHIFT) |
 505                                 (pipe->speed << QH_EPS_SHIFT) |
 506                                 (pipe->epno << QH_EP_SHIFT) |
 507                                 (pipe->dev->addr << QH_DEV_ADDR_SHIFT));
 508         mb();
 509
 510         ehcd->qh_async->qh_ptr = cpu_to_le32(epipe->qh_phys | EHCI_TYP_QH);
 511
 512         /* transfer data */
 513         mb();
 514         qtd = (struct ehci_qtd *)td;
 515         for (i = 0; i < NUM_BULK_QTDS; i++) {
 516                 time = SLOF_GetTimer() + USB_TIMEOUT;
 517                 while ((time > SLOF_GetTimer()) &&
 518                         (le32_to_cpu(qtd->token) & (QH_STS_ACTIVE << TOKEN_STATUS_SHIFT)))
 519                         cpu_relax();
 520                 mb();
 521                 if (qtd->next_qtd == QH_PTR_TERM)
 522                         break;
 523
 524                 if (le32_to_cpu(qtd->token) & (QH_STS_ACTIVE << TOKEN_STATUS_SHIFT)) {
 525                         printf("usb-ehci: bulk transfer timed out_\n");
 526                         ret = false;
 527                         break;
 528                 }
 529                 qtd++;
 530         }
 531
 532         ehcd->qh_async->qh_ptr = cpu_to_le32(ehcd->qh_async_phys | EHCI_TYP_QH);
 533         mb();
 534         if (!ehci_handshake(ehcd, USB_TIMEOUT)) {
 535                 printf("%s: handshake failed\n", __func__);
 536                 ret = false;
 537         }
 538         return ret;
 539 }
 540
 541 static struct usb_pipe *ehci_get_pipe(struct usb_dev *dev, struct usb_ep_descr *ep,
 542                                 char *buf, size_t len)
 543 {
 544         struct ehci_hcd *ehcd;
 545         struct usb_pipe *new = NULL;
 546
 547         if (!dev)
 548                 return NULL;
 549
 550         ehcd = (struct ehci_hcd *)dev->hcidev->priv;
 551         if (!ehcd->freelist) {
 552                 dprintf("usb-ehci: %s allocating pool\n", __func__);
 553                 if (ehci_alloc_pipe_pool(ehcd))
 554                         return NULL;
 555         }
 556
 557         new = ehcd->freelist;
 558         ehcd->freelist = ehcd->freelist->next;
 559         if (!ehcd->freelist)
 560                 ehcd->end = NULL;
 561
 562         memset(new, 0, sizeof(*new));
 563         new->dev = dev;
 564         new->next = NULL;
 565         new->type = ep->bmAttributes & USB_EP_TYPE_MASK;
 566         new->speed = dev->speed;
 567         new->mps = ep->wMaxPacketSize;
 568         new->dir = (ep->bEndpointAddress & 0x80) >> 7;
 569         new->epno = ep->bEndpointAddress & 0x0f;
 570
 571         return new;
 572 }
 573
 574 static void ehci_put_pipe(struct usb_pipe *pipe)
 575 {
 576         struct ehci_hcd *ehcd;
 577
 578         dprintf("usb-ehci: %s enter - %p\n", __func__, pipe);
 579         if (!pipe || !pipe->dev)
 580                 return;
 581         ehcd = pipe->dev->hcidev->priv;
 582         if (ehcd->end)
 583                 ehcd->end->next = pipe;
 584         else
 585                 ehcd->freelist = pipe;
 586
 587         ehcd->end = pipe;
 588         pipe->next = NULL;
 589         pipe->dev = NULL;
 590         memset(pipe, 0, sizeof(*pipe));
 591         dprintf("usb-ehci: %s exit\n", __func__);
 592 }
 593
 594 struct usb_hcd_ops ehci_ops = {
 595         .name          = "ehci-hcd",
 596         .init          = ehci_init,
 597         .exit          = ehci_exit,
 598         .detect        = ehci_detect,
 599         .disconnect    = ehci_disconnect,
 600         .get_pipe      = ehci_get_pipe,
 601         .put_pipe      = ehci_put_pipe,
 602         .send_ctrl     = ehci_send_ctrl,
 603         .transfer_bulk = ehci_transfer_bulk,
 604         .usb_type      = USB_EHCI,
 605         .next          = NULL,
 606 };
 607
 608 void usb_ehci_register(void)
 609 {
 610         usb_hcd_register(&ehci_ops);
 611 }