hw/usb/hcd-ohci.c

   1 /*
   2  * QEMU USB OHCI Emulation
   3  * Copyright (c) 2004 Gianni Tedesco
   4  * Copyright (c) 2006 CodeSourcery
   5  * Copyright (c) 2006 Openedhand Ltd.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  19  *
  20  * TODO:
  21  *  o Isochronous transfers
  22  *  o Allocate bandwidth in frames properly
  23  *  o Disable timers when nothing needs to be done, or remove timer usage
  24  *    all together.
  25  *  o BIOS work to boot from USB storage
  26 */
  27
  28 #include "qemu/osdep.h"
  29 #include "hw/hw.h"
  30 #include "qapi/error.h"
  31 #include "qemu/timer.h"
  32 #include "hw/usb.h"
  33 #include "hw/pci/pci.h"
  34 #include "hw/sysbus.h"
  35 #include "hw/qdev-dma.h"
  36 #include "trace.h"
  37
  38 /* This causes frames to occur 1000x slower */
  39 //#define OHCI_TIME_WARP 1
  40
  41 /* Number of Downstream Ports on the root hub.  */
  42
  43 #define OHCI_MAX_PORTS 15
  44
  45 #define ED_LINK_LIMIT 32
  46
  47 static int64_t usb_frame_time;
  48 static int64_t usb_bit_time;
  49
  50 typedef struct OHCIPort {
  51     USBPort port;
  52     uint32_t ctrl;
  53 } OHCIPort;
  54
  55 typedef struct OHCIState {
  56     USBBus bus;
  57     qemu_irq irq;
  58     MemoryRegion mem;
  59     AddressSpace *as;
  60     uint32_t num_ports;
  61     const char *name;
  62
  63     QEMUTimer *eof_timer;
  64     int64_t sof_time;
  65
  66     /* OHCI state */
  67     /* Control partition */
  68     uint32_t ctl, status;
  69     uint32_t intr_status;
  70     uint32_t intr;
  71
  72     /* memory pointer partition */
  73     uint32_t hcca;
  74     uint32_t ctrl_head, ctrl_cur;
  75     uint32_t bulk_head, bulk_cur;
  76     uint32_t per_cur;
  77     uint32_t done;
  78     int32_t done_count;
  79
  80     /* Frame counter partition */
  81     uint16_t fsmps;
  82     uint8_t fit;
  83     uint16_t fi;
  84     uint8_t frt;
  85     uint16_t frame_number;
  86     uint16_t padding;
  87     uint32_t pstart;
  88     uint32_t lst;
  89
  90     /* Root Hub partition */
  91     uint32_t rhdesc_a, rhdesc_b;
  92     uint32_t rhstatus;
  93     OHCIPort rhport[OHCI_MAX_PORTS];
  94
  95     /* PXA27x Non-OHCI events */
  96     uint32_t hstatus;
  97     uint32_t hmask;
  98     uint32_t hreset;
  99     uint32_t htest;
 100
 101     /* SM501 local memory offset */
 102     dma_addr_t localmem_base;
 103
 104     /* Active packets.  */
 105     uint32_t old_ctl;
 106     USBPacket usb_packet;
 107     uint8_t usb_buf[8192];
 108     uint32_t async_td;
 109     bool async_complete;
 110
 111     void (*ohci_die)(struct OHCIState *ohci);
 112 } OHCIState;
 113
 114 /* Host Controller Communications Area */
 115 struct ohci_hcca {
 116     uint32_t intr[32];
 117     uint16_t frame, pad;
 118     uint32_t done;
 119 };
 120 #define HCCA_WRITEBACK_OFFSET   offsetof(struct ohci_hcca, frame)
 121 #define HCCA_WRITEBACK_SIZE     8 /* frame, pad, done */
 122
 123 #define ED_WBACK_OFFSET offsetof(struct ohci_ed, head)
 124 #define ED_WBACK_SIZE   4
 125
 126 static void ohci_bus_stop(OHCIState *ohci);
 127 static void ohci_async_cancel_device(OHCIState *ohci, USBDevice *dev);
 128
 129 /* Bitfields for the first word of an Endpoint Desciptor.  */
 130 #define OHCI_ED_FA_SHIFT  0
 131 #define OHCI_ED_FA_MASK   (0x7f<<OHCI_ED_FA_SHIFT)
 132 #define OHCI_ED_EN_SHIFT  7
 133 #define OHCI_ED_EN_MASK   (0xf<<OHCI_ED_EN_SHIFT)
 134 #define OHCI_ED_D_SHIFT   11
 135 #define OHCI_ED_D_MASK    (3<<OHCI_ED_D_SHIFT)
 136 #define OHCI_ED_S         (1<<13)
 137 #define OHCI_ED_K         (1<<14)
 138 #define OHCI_ED_F         (1<<15)
 139 #define OHCI_ED_MPS_SHIFT 16
 140 #define OHCI_ED_MPS_MASK  (0x7ff<<OHCI_ED_MPS_SHIFT)
 141
 142 /* Flags in the head field of an Endpoint Desciptor.  */
 143 #define OHCI_ED_H         1
 144 #define OHCI_ED_C         2
 145
 146 /* Bitfields for the first word of a Transfer Desciptor.  */
 147 #define OHCI_TD_R         (1<<18)
 148 #define OHCI_TD_DP_SHIFT  19
 149 #define OHCI_TD_DP_MASK   (3<<OHCI_TD_DP_SHIFT)
 150 #define OHCI_TD_DI_SHIFT  21
 151 #define OHCI_TD_DI_MASK   (7<<OHCI_TD_DI_SHIFT)
 152 #define OHCI_TD_T0        (1<<24)
 153 #define OHCI_TD_T1        (1<<25)
 154 #define OHCI_TD_EC_SHIFT  26
 155 #define OHCI_TD_EC_MASK   (3<<OHCI_TD_EC_SHIFT)
 156 #define OHCI_TD_CC_SHIFT  28
 157 #define OHCI_TD_CC_MASK   (0xf<<OHCI_TD_CC_SHIFT)
 158
 159 /* Bitfields for the first word of an Isochronous Transfer Desciptor.  */
 160 /* CC & DI - same as in the General Transfer Desciptor */
 161 #define OHCI_TD_SF_SHIFT  0
 162 #define OHCI_TD_SF_MASK   (0xffff<<OHCI_TD_SF_SHIFT)
 163 #define OHCI_TD_FC_SHIFT  24
 164 #define OHCI_TD_FC_MASK   (7<<OHCI_TD_FC_SHIFT)
 165
 166 /* Isochronous Transfer Desciptor - Offset / PacketStatusWord */
 167 #define OHCI_TD_PSW_CC_SHIFT 12
 168 #define OHCI_TD_PSW_CC_MASK  (0xf<<OHCI_TD_PSW_CC_SHIFT)
 169 #define OHCI_TD_PSW_SIZE_SHIFT 0
 170 #define OHCI_TD_PSW_SIZE_MASK  (0xfff<<OHCI_TD_PSW_SIZE_SHIFT)
 171
 172 #define OHCI_PAGE_MASK    0xfffff000
 173 #define OHCI_OFFSET_MASK  0xfff
 174
 175 #define OHCI_DPTR_MASK    0xfffffff0
 176
 177 #define OHCI_BM(val, field) \
 178   (((val) & OHCI_##field##_MASK) >> OHCI_##field##_SHIFT)
 179
 180 #define OHCI_SET_BM(val, field, newval) do { \
 181     val &= ~OHCI_##field##_MASK; \
 182     val |= ((newval) << OHCI_##field##_SHIFT) & OHCI_##field##_MASK; \
 183     } while(0)
 184
 185 /* endpoint descriptor */
 186 struct ohci_ed {
 187     uint32_t flags;
 188     uint32_t tail;
 189     uint32_t head;
 190     uint32_t next;
 191 };
 192
 193 /* General transfer descriptor */
 194 struct ohci_td {
 195     uint32_t flags;
 196     uint32_t cbp;
 197     uint32_t next;
 198     uint32_t be;
 199 };
 200
 201 /* Isochronous transfer descriptor */
 202 struct ohci_iso_td {
 203     uint32_t flags;
 204     uint32_t bp;
 205     uint32_t next;
 206     uint32_t be;
 207     uint16_t offset[8];
 208 };
 209
 210 #define USB_HZ                      12000000
 211
 212 /* OHCI Local stuff */
 213 #define OHCI_CTL_CBSR         ((1<<0)|(1<<1))
 214 #define OHCI_CTL_PLE          (1<<2)
 215 #define OHCI_CTL_IE           (1<<3)
 216 #define OHCI_CTL_CLE          (1<<4)
 217 #define OHCI_CTL_BLE          (1<<5)
 218 #define OHCI_CTL_HCFS         ((1<<6)|(1<<7))
 219 #define  OHCI_USB_RESET       0x00
 220 #define  OHCI_USB_RESUME      0x40
 221 #define  OHCI_USB_OPERATIONAL 0x80
 222 #define  OHCI_USB_SUSPEND     0xc0
 223 #define OHCI_CTL_IR           (1<<8)
 224 #define OHCI_CTL_RWC          (1<<9)
 225 #define OHCI_CTL_RWE          (1<<10)
 226
 227 #define OHCI_STATUS_HCR       (1<<0)
 228 #define OHCI_STATUS_CLF       (1<<1)
 229 #define OHCI_STATUS_BLF       (1<<2)
 230 #define OHCI_STATUS_OCR       (1<<3)
 231 #define OHCI_STATUS_SOC       ((1<<6)|(1<<7))
 232
 233 #define OHCI_INTR_SO          (1U<<0) /* Scheduling overrun */
 234 #define OHCI_INTR_WD          (1U<<1) /* HcDoneHead writeback */
 235 #define OHCI_INTR_SF          (1U<<2) /* Start of frame */
 236 #define OHCI_INTR_RD          (1U<<3) /* Resume detect */
 237 #define OHCI_INTR_UE          (1U<<4) /* Unrecoverable error */
 238 #define OHCI_INTR_FNO         (1U<<5) /* Frame number overflow */
 239 #define OHCI_INTR_RHSC        (1U<<6) /* Root hub status change */
 240 #define OHCI_INTR_OC          (1U<<30) /* Ownership change */
 241 #define OHCI_INTR_MIE         (1U<<31) /* Master Interrupt Enable */
 242
 243 #define OHCI_HCCA_SIZE        0x100
 244 #define OHCI_HCCA_MASK        0xffffff00
 245
 246 #define OHCI_EDPTR_MASK       0xfffffff0
 247
 248 #define OHCI_FMI_FI           0x00003fff
 249 #define OHCI_FMI_FSMPS        0xffff0000
 250 #define OHCI_FMI_FIT          0x80000000
 251
 252 #define OHCI_FR_RT            (1U<<31)
 253
 254 #define OHCI_LS_THRESH        0x628
 255
 256 #define OHCI_RHA_RW_MASK      0x00000000 /* Mask of supported features.  */
 257 #define OHCI_RHA_PSM          (1<<8)
 258 #define OHCI_RHA_NPS          (1<<9)
 259 #define OHCI_RHA_DT           (1<<10)
 260 #define OHCI_RHA_OCPM         (1<<11)
 261 #define OHCI_RHA_NOCP         (1<<12)
 262 #define OHCI_RHA_POTPGT_MASK  0xff000000
 263
 264 #define OHCI_RHS_LPS          (1U<<0)
 265 #define OHCI_RHS_OCI          (1U<<1)
 266 #define OHCI_RHS_DRWE         (1U<<15)
 267 #define OHCI_RHS_LPSC         (1U<<16)
 268 #define OHCI_RHS_OCIC         (1U<<17)
 269 #define OHCI_RHS_CRWE         (1U<<31)
 270
 271 #define OHCI_PORT_CCS         (1<<0)
 272 #define OHCI_PORT_PES         (1<<1)
 273 #define OHCI_PORT_PSS         (1<<2)
 274 #define OHCI_PORT_POCI        (1<<3)
 275 #define OHCI_PORT_PRS         (1<<4)
 276 #define OHCI_PORT_PPS         (1<<8)
 277 #define OHCI_PORT_LSDA        (1<<9)
 278 #define OHCI_PORT_CSC         (1<<16)
 279 #define OHCI_PORT_PESC        (1<<17)
 280 #define OHCI_PORT_PSSC        (1<<18)
 281 #define OHCI_PORT_OCIC        (1<<19)
 282 #define OHCI_PORT_PRSC        (1<<20)
 283 #define OHCI_PORT_WTC         (OHCI_PORT_CSC|OHCI_PORT_PESC|OHCI_PORT_PSSC \
 284                                |OHCI_PORT_OCIC|OHCI_PORT_PRSC)
 285
 286 #define OHCI_TD_DIR_SETUP     0x0
 287 #define OHCI_TD_DIR_OUT       0x1
 288 #define OHCI_TD_DIR_IN        0x2
 289 #define OHCI_TD_DIR_RESERVED  0x3
 290
 291 #define OHCI_CC_NOERROR             0x0
 292 #define OHCI_CC_CRC                 0x1
 293 #define OHCI_CC_BITSTUFFING         0x2
 294 #define OHCI_CC_DATATOGGLEMISMATCH  0x3
 295 #define OHCI_CC_STALL               0x4
 296 #define OHCI_CC_DEVICENOTRESPONDING 0x5
 297 #define OHCI_CC_PIDCHECKFAILURE     0x6
 298 #define OHCI_CC_UNDEXPETEDPID       0x7
 299 #define OHCI_CC_DATAOVERRUN         0x8
 300 #define OHCI_CC_DATAUNDERRUN        0x9
 301 #define OHCI_CC_BUFFEROVERRUN       0xc
 302 #define OHCI_CC_BUFFERUNDERRUN      0xd
 303
 304 #define OHCI_HRESET_FSBIR       (1 << 0)
 305
 306 static void ohci_die(OHCIState *ohci)
 307 {
 308     ohci->ohci_die(ohci);
 309 }
 310
 311 /* Update IRQ levels */
 312 static inline void ohci_intr_update(OHCIState *ohci)
 313 {
 314     int level = 0;
 315
 316     if ((ohci->intr & OHCI_INTR_MIE) &&
 317         (ohci->intr_status & ohci->intr))
 318         level = 1;
 319
 320     qemu_set_irq(ohci->irq, level);
 321 }
 322
 323 /* Set an interrupt */
 324 static inline void ohci_set_interrupt(OHCIState *ohci, uint32_t intr)
 325 {
 326     ohci->intr_status |= intr;
 327     ohci_intr_update(ohci);
 328 }
 329
 330 /* Attach or detach a device on a root hub port.  */
 331 static void ohci_attach(USBPort *port1)
 332 {
 333     OHCIState *s = port1->opaque;
 334     OHCIPort *port = &s->rhport[port1->index];
 335     uint32_t old_state = port->ctrl;
 336
 337     /* set connect status */
 338     port->ctrl |= OHCI_PORT_CCS | OHCI_PORT_CSC;
 339
 340     /* update speed */
 341     if (port->port.dev->speed == USB_SPEED_LOW) {
 342         port->ctrl |= OHCI_PORT_LSDA;
 343     } else {
 344         port->ctrl &= ~OHCI_PORT_LSDA;
 345     }
 346
 347     /* notify of remote-wakeup */
 348     if ((s->ctl & OHCI_CTL_HCFS) == OHCI_USB_SUSPEND) {
 349         ohci_set_interrupt(s, OHCI_INTR_RD);
 350     }
 351
 352     trace_usb_ohci_port_attach(port1->index);
 353
 354     if (old_state != port->ctrl) {
 355         ohci_set_interrupt(s, OHCI_INTR_RHSC);
 356     }
 357 }
 358
 359 static void ohci_detach(USBPort *port1)
 360 {
 361     OHCIState *s = port1->opaque;
 362     OHCIPort *port = &s->rhport[port1->index];
 363     uint32_t old_state = port->ctrl;
 364
 365     ohci_async_cancel_device(s, port1->dev);
 366
 367     /* set connect status */
 368     if (port->ctrl & OHCI_PORT_CCS) {
 369         port->ctrl &= ~OHCI_PORT_CCS;
 370         port->ctrl |= OHCI_PORT_CSC;
 371     }
 372     /* disable port */
 373     if (port->ctrl & OHCI_PORT_PES) {
 374         port->ctrl &= ~OHCI_PORT_PES;
 375         port->ctrl |= OHCI_PORT_PESC;
 376     }
 377     trace_usb_ohci_port_detach(port1->index);
 378
 379     if (old_state != port->ctrl) {
 380         ohci_set_interrupt(s, OHCI_INTR_RHSC);
 381     }
 382 }
 383
 384 static void ohci_wakeup(USBPort *port1)
 385 {
 386     OHCIState *s = port1->opaque;
 387     OHCIPort *port = &s->rhport[port1->index];
 388     uint32_t intr = 0;
 389     if (port->ctrl & OHCI_PORT_PSS) {
 390         trace_usb_ohci_port_wakeup(port1->index);
 391         port->ctrl |= OHCI_PORT_PSSC;
 392         port->ctrl &= ~OHCI_PORT_PSS;
 393         intr = OHCI_INTR_RHSC;
 394     }
 395     /* Note that the controller can be suspended even if this port is not */
 396     if ((s->ctl & OHCI_CTL_HCFS) == OHCI_USB_SUSPEND) {
 397         trace_usb_ohci_remote_wakeup(s->name);
 398         /* This is the one state transition the controller can do by itself */
 399         s->ctl &= ~OHCI_CTL_HCFS;
 400         s->ctl |= OHCI_USB_RESUME;
 401         /* In suspend mode only ResumeDetected is possible, not RHSC:
 402          * see the OHCI spec 5.1.2.3.
 403          */
 404         intr = OHCI_INTR_RD;
 405     }
 406     ohci_set_interrupt(s, intr);
 407 }
 408
 409 static void ohci_child_detach(USBPort *port1, USBDevice *child)
 410 {
 411     OHCIState *s = port1->opaque;
 412
 413     ohci_async_cancel_device(s, child);
 414 }
 415
 416 static USBDevice *ohci_find_device(OHCIState *ohci, uint8_t addr)
 417 {
 418     USBDevice *dev;
 419     int i;
 420
 421     for (i = 0; i < ohci->num_ports; i++) {
 422         if ((ohci->rhport[i].ctrl & OHCI_PORT_PES) == 0) {
 423             continue;
 424         }
 425         dev = usb_find_device(&ohci->rhport[i].port, addr);
 426         if (dev != NULL) {
 427             return dev;
 428         }
 429     }
 430     return NULL;
 431 }
 432
 433 static void ohci_stop_endpoints(OHCIState *ohci)
 434 {
 435     USBDevice *dev;
 436     int i, j;
 437
 438     for (i = 0; i < ohci->num_ports; i++) {
 439         dev = ohci->rhport[i].port.dev;
 440         if (dev && dev->attached) {
 441             usb_device_ep_stopped(dev, &dev->ep_ctl);
 442             for (j = 0; j < USB_MAX_ENDPOINTS; j++) {
 443                 usb_device_ep_stopped(dev, &dev->ep_in[j]);
 444                 usb_device_ep_stopped(dev, &dev->ep_out[j]);
 445             }
 446         }
 447     }
 448 }
 449
 450 static void ohci_roothub_reset(OHCIState *ohci)
 451 {
 452     OHCIPort *port;
 453     int i;
 454
 455     ohci_bus_stop(ohci);
 456     ohci->rhdesc_a = OHCI_RHA_NPS | ohci->num_ports;
 457     ohci->rhdesc_b = 0x0; /* Impl. specific */
 458     ohci->rhstatus = 0;
 459
 460     for (i = 0; i < ohci->num_ports; i++) {
 461         port = &ohci->rhport[i];
 462         port->ctrl = 0;
 463         if (port->port.dev && port->port.dev->attached) {
 464             usb_port_reset(&port->port);
 465         }
 466     }
 467     if (ohci->async_td) {
 468         usb_cancel_packet(&ohci->usb_packet);
 469         ohci->async_td = 0;
 470     }
 471     ohci_stop_endpoints(ohci);
 472 }
 473
 474 /* Reset the controller */
 475 static void ohci_soft_reset(OHCIState *ohci)
 476 {
 477     trace_usb_ohci_reset(ohci->name);
 478
 479     ohci_bus_stop(ohci);
 480     ohci->ctl = (ohci->ctl & OHCI_CTL_IR) | OHCI_USB_SUSPEND;
 481     ohci->old_ctl = 0;
 482     ohci->status = 0;
 483     ohci->intr_status = 0;
 484     ohci->intr = OHCI_INTR_MIE;
 485
 486     ohci->hcca = 0;
 487     ohci->ctrl_head = ohci->ctrl_cur = 0;
 488     ohci->bulk_head = ohci->bulk_cur = 0;
 489     ohci->per_cur = 0;
 490     ohci->done = 0;
 491     ohci->done_count = 7;
 492
 493     /* FSMPS is marked TBD in OCHI 1.0, what gives ffs?
 494      * I took the value linux sets ...
 495      */
 496     ohci->fsmps = 0x2778;
 497     ohci->fi = 0x2edf;
 498     ohci->fit = 0;
 499     ohci->frt = 0;
 500     ohci->frame_number = 0;
 501     ohci->pstart = 0;
 502     ohci->lst = OHCI_LS_THRESH;
 503 }
 504
 505 static void ohci_hard_reset(OHCIState *ohci)
 506 {
 507     ohci_soft_reset(ohci);
 508     ohci->ctl = 0;
 509     ohci_roothub_reset(ohci);
 510 }
 511
 512 /* Get an array of dwords from main memory */
 513 static inline int get_dwords(OHCIState *ohci,
 514                              dma_addr_t addr, uint32_t *buf, int num)
 515 {
 516     int i;
 517
 518     addr += ohci->localmem_base;
 519
 520     for (i = 0; i < num; i++, buf++, addr += sizeof(*buf)) {
 521         if (dma_memory_read(ohci->as, addr, buf, sizeof(*buf))) {
 522             return -1;
 523         }
 524         *buf = le32_to_cpu(*buf);
 525     }
 526
 527     return 0;
 528 }
 529
 530 /* Put an array of dwords in to main memory */
 531 static inline int put_dwords(OHCIState *ohci,
 532                              dma_addr_t addr, uint32_t *buf, int num)
 533 {
 534     int i;
 535
 536     addr += ohci->localmem_base;
 537
 538     for (i = 0; i < num; i++, buf++, addr += sizeof(*buf)) {
 539         uint32_t tmp = cpu_to_le32(*buf);
 540         if (dma_memory_write(ohci->as, addr, &tmp, sizeof(tmp))) {
 541             return -1;
 542         }
 543     }
 544
 545     return 0;
 546 }
 547
 548 /* Get an array of words from main memory */
 549 static inline int get_words(OHCIState *ohci,
 550                             dma_addr_t addr, uint16_t *buf, int num)
 551 {
 552     int i;
 553
 554     addr += ohci->localmem_base;
 555
 556     for (i = 0; i < num; i++, buf++, addr += sizeof(*buf)) {
 557         if (dma_memory_read(ohci->as, addr, buf, sizeof(*buf))) {
 558             return -1;
 559         }
 560         *buf = le16_to_cpu(*buf);
 561     }
 562
 563     return 0;
 564 }
 565
 566 /* Put an array of words in to main memory */
 567 static inline int put_words(OHCIState *ohci,
 568                             dma_addr_t addr, uint16_t *buf, int num)
 569 {
 570     int i;
 571
 572     addr += ohci->localmem_base;
 573
 574     for (i = 0; i < num; i++, buf++, addr += sizeof(*buf)) {
 575         uint16_t tmp = cpu_to_le16(*buf);
 576         if (dma_memory_write(ohci->as, addr, &tmp, sizeof(tmp))) {
 577             return -1;
 578         }
 579     }
 580
 581     return 0;
 582 }
 583
 584 static inline int ohci_read_ed(OHCIState *ohci,
 585                                dma_addr_t addr, struct ohci_ed *ed)
 586 {
 587     return get_dwords(ohci, addr, (uint32_t *)ed, sizeof(*ed) >> 2);
 588 }
 589
 590 static inline int ohci_read_td(OHCIState *ohci,
 591                                dma_addr_t addr, struct ohci_td *td)
 592 {
 593     return get_dwords(ohci, addr, (uint32_t *)td, sizeof(*td) >> 2);
 594 }
 595
 596 static inline int ohci_read_iso_td(OHCIState *ohci,
 597                                    dma_addr_t addr, struct ohci_iso_td *td)
 598 {
 599     return get_dwords(ohci, addr, (uint32_t *)td, 4) ||
 600            get_words(ohci, addr + 16, td->offset, 8);
 601 }
 602
 603 static inline int ohci_read_hcca(OHCIState *ohci,
 604                                  dma_addr_t addr, struct ohci_hcca *hcca)
 605 {
 606     return dma_memory_read(ohci->as, addr + ohci->localmem_base,
 607                            hcca, sizeof(*hcca));
 608 }
 609
 610 static inline int ohci_put_ed(OHCIState *ohci,
 611                               dma_addr_t addr, struct ohci_ed *ed)
 612 {
 613     /* ed->tail is under control of the HCD.
 614      * Since just ed->head is changed by HC, just write back this
 615      */
 616
 617     return put_dwords(ohci, addr + ED_WBACK_OFFSET,
 618                       (uint32_t *)((char *)ed + ED_WBACK_OFFSET),
 619                       ED_WBACK_SIZE >> 2);
 620 }
 621
 622 static inline int ohci_put_td(OHCIState *ohci,
 623                               dma_addr_t addr, struct ohci_td *td)
 624 {
 625     return put_dwords(ohci, addr, (uint32_t *)td, sizeof(*td) >> 2);
 626 }
 627
 628 static inline int ohci_put_iso_td(OHCIState *ohci,
 629                                   dma_addr_t addr, struct ohci_iso_td *td)
 630 {
 631     return put_dwords(ohci, addr, (uint32_t *)td, 4) ||
 632            put_words(ohci, addr + 16, td->offset, 8);
 633 }
 634
 635 static inline int ohci_put_hcca(OHCIState *ohci,
 636                                 dma_addr_t addr, struct ohci_hcca *hcca)
 637 {
 638     return dma_memory_write(ohci->as,
 639                             addr + ohci->localmem_base + HCCA_WRITEBACK_OFFSET,
 640                             (char *)hcca + HCCA_WRITEBACK_OFFSET,
 641                             HCCA_WRITEBACK_SIZE);
 642 }
 643
 644 /* Read/Write the contents of a TD from/to main memory.  */
 645 static int ohci_copy_td(OHCIState *ohci, struct ohci_td *td,
 646                         uint8_t *buf, int len, DMADirection dir)
 647 {
 648     dma_addr_t ptr, n;
 649
 650     ptr = td->cbp;
 651     n = 0x1000 - (ptr & 0xfff);
 652     if (n > len)
 653         n = len;
 654
 655     if (dma_memory_rw(ohci->as, ptr + ohci->localmem_base, buf, n, dir)) {
 656         return -1;
 657     }
 658     if (n == len) {
 659         return 0;
 660     }
 661     ptr = td->be & ~0xfffu;
 662     buf += n;
 663     if (dma_memory_rw(ohci->as, ptr + ohci->localmem_base, buf,
 664                       len - n, dir)) {
 665         return -1;
 666     }
 667     return 0;
 668 }
 669
 670 /* Read/Write the contents of an ISO TD from/to main memory.  */
 671 static int ohci_copy_iso_td(OHCIState *ohci,
 672                             uint32_t start_addr, uint32_t end_addr,
 673                             uint8_t *buf, int len, DMADirection dir)
 674 {
 675     dma_addr_t ptr, n;
 676
 677     ptr = start_addr;
 678     n = 0x1000 - (ptr & 0xfff);
 679     if (n > len)
 680         n = len;
 681
 682     if (dma_memory_rw(ohci->as, ptr + ohci->localmem_base, buf, n, dir)) {
 683         return -1;
 684     }
 685     if (n == len) {
 686         return 0;
 687     }
 688     ptr = end_addr & ~0xfffu;
 689     buf += n;
 690     if (dma_memory_rw(ohci->as, ptr + ohci->localmem_base, buf,
 691                       len - n, dir)) {
 692         return -1;
 693     }
 694     return 0;
 695 }
 696
 697 static void ohci_process_lists(OHCIState *ohci, int completion);
 698
 699 static void ohci_async_complete_packet(USBPort *port, USBPacket *packet)
 700 {
 701     OHCIState *ohci = container_of(packet, OHCIState, usb_packet);
 702
 703     trace_usb_ohci_async_complete();
 704     ohci->async_complete = true;
 705     ohci_process_lists(ohci, 1);
 706 }
 707
 708 #define USUB(a, b) ((int16_t)((uint16_t)(a) - (uint16_t)(b)))
 709
 710 static int ohci_service_iso_td(OHCIState *ohci, struct ohci_ed *ed,
 711                                int completion)
 712 {
 713     int dir;
 714     size_t len = 0;
 715     const char *str = NULL;
 716     int pid;
 717     int ret;
 718     int i;
 719     USBDevice *dev;
 720     USBEndpoint *ep;
 721     struct ohci_iso_td iso_td;
 722     uint32_t addr;
 723     uint16_t starting_frame;
 724     int16_t relative_frame_number;
 725     int frame_count;
 726     uint32_t start_offset, next_offset, end_offset = 0;
 727     uint32_t start_addr, end_addr;
 728
 729     addr = ed->head & OHCI_DPTR_MASK;
 730
 731     if (ohci_read_iso_td(ohci, addr, &iso_td)) {
 732         trace_usb_ohci_iso_td_read_failed(addr);
 733         ohci_die(ohci);
 734         return 1;
 735     }
 736
 737     starting_frame = OHCI_BM(iso_td.flags, TD_SF);
 738     frame_count = OHCI_BM(iso_td.flags, TD_FC);
 739     relative_frame_number = USUB(ohci->frame_number, starting_frame);
 740
 741     trace_usb_ohci_iso_td_head(
 742            ed->head & OHCI_DPTR_MASK, ed->tail & OHCI_DPTR_MASK,
 743            iso_td.flags, iso_td.bp, iso_td.next, iso_td.be,
 744            ohci->frame_number, starting_frame,
 745            frame_count, relative_frame_number);
 746     trace_usb_ohci_iso_td_head_offset(
 747            iso_td.offset[0], iso_td.offset[1],
 748            iso_td.offset[2], iso_td.offset[3],
 749            iso_td.offset[4], iso_td.offset[5],
 750            iso_td.offset[6], iso_td.offset[7]);
 751
 752     if (relative_frame_number < 0) {
 753         trace_usb_ohci_iso_td_relative_frame_number_neg(relative_frame_number);
 754         return 1;
 755     } else if (relative_frame_number > frame_count) {
 756         /* ISO TD expired - retire the TD to the Done Queue and continue with
 757            the next ISO TD of the same ED */
 758         trace_usb_ohci_iso_td_relative_frame_number_big(relative_frame_number,
 759                                                         frame_count);
 760         OHCI_SET_BM(iso_td.flags, TD_CC, OHCI_CC_DATAOVERRUN);
 761         ed->head &= ~OHCI_DPTR_MASK;
 762         ed->head |= (iso_td.next & OHCI_DPTR_MASK);
 763         iso_td.next = ohci->done;
 764         ohci->done = addr;
 765         i = OHCI_BM(iso_td.flags, TD_DI);
 766         if (i < ohci->done_count)
 767             ohci->done_count = i;
 768         if (ohci_put_iso_td(ohci, addr, &iso_td)) {
 769             ohci_die(ohci);
 770             return 1;
 771         }
 772         return 0;
 773     }
 774
 775     dir = OHCI_BM(ed->flags, ED_D);
 776     switch (dir) {
 777     case OHCI_TD_DIR_IN:
 778         str = "in";
 779         pid = USB_TOKEN_IN;
 780         break;
 781     case OHCI_TD_DIR_OUT:
 782         str = "out";
 783         pid = USB_TOKEN_OUT;
 784         break;
 785     case OHCI_TD_DIR_SETUP:
 786         str = "setup";
 787         pid = USB_TOKEN_SETUP;
 788         break;
 789     default:
 790         trace_usb_ohci_iso_td_bad_direction(dir);
 791         return 1;
 792     }
 793
 794     if (!iso_td.bp || !iso_td.be) {
 795         trace_usb_ohci_iso_td_bad_bp_be(iso_td.bp, iso_td.be);
 796         return 1;
 797     }
 798
 799     start_offset = iso_td.offset[relative_frame_number];
 800     next_offset = iso_td.offset[relative_frame_number + 1];
 801
 802     if (!(OHCI_BM(start_offset, TD_PSW_CC) & 0xe) ||
 803         ((relative_frame_number < frame_count) &&
 804          !(OHCI_BM(next_offset, TD_PSW_CC) & 0xe))) {
 805         trace_usb_ohci_iso_td_bad_cc_not_accessed(start_offset, next_offset);
 806         return 1;
 807     }
 808
 809     if ((relative_frame_number < frame_count) && (start_offset > next_offset)) {
 810         trace_usb_ohci_iso_td_bad_cc_overrun(start_offset, next_offset);
 811         return 1;
 812     }
 813
 814     if ((start_offset & 0x1000) == 0) {
 815         start_addr = (iso_td.bp & OHCI_PAGE_MASK) |
 816             (start_offset & OHCI_OFFSET_MASK);
 817     } else {
 818         start_addr = (iso_td.be & OHCI_PAGE_MASK) |
 819             (start_offset & OHCI_OFFSET_MASK);
 820     }
 821
 822     if (relative_frame_number < frame_count) {
 823         end_offset = next_offset - 1;
 824         if ((end_offset & 0x1000) == 0) {
 825             end_addr = (iso_td.bp & OHCI_PAGE_MASK) |
 826                 (end_offset & OHCI_OFFSET_MASK);
 827         } else {
 828             end_addr = (iso_td.be & OHCI_PAGE_MASK) |
 829                 (end_offset & OHCI_OFFSET_MASK);
 830         }
 831     } else {
 832         /* Last packet in the ISO TD */
 833         end_addr = iso_td.be;
 834     }
 835
 836     if ((start_addr & OHCI_PAGE_MASK) != (end_addr & OHCI_PAGE_MASK)) {
 837         len = (end_addr & OHCI_OFFSET_MASK) + 0x1001
 838             - (start_addr & OHCI_OFFSET_MASK);
 839     } else {
 840         len = end_addr - start_addr + 1;
 841     }
 842
 843     if (len && dir != OHCI_TD_DIR_IN) {
 844         if (ohci_copy_iso_td(ohci, start_addr, end_addr, ohci->usb_buf, len,
 845                              DMA_DIRECTION_TO_DEVICE)) {
 846             ohci_die(ohci);
 847             return 1;
 848         }
 849     }
 850
 851     if (!completion) {
 852         bool int_req = relative_frame_number == frame_count &&
 853                        OHCI_BM(iso_td.flags, TD_DI) == 0;
 854         dev = ohci_find_device(ohci, OHCI_BM(ed->flags, ED_FA));
 855         if (dev == NULL) {
 856             trace_usb_ohci_td_dev_error();
 857             return 1;
 858         }
 859         ep = usb_ep_get(dev, pid, OHCI_BM(ed->flags, ED_EN));
 860         usb_packet_setup(&ohci->usb_packet, pid, ep, 0, addr, false, int_req);
 861         usb_packet_addbuf(&ohci->usb_packet, ohci->usb_buf, len);
 862         usb_handle_packet(dev, &ohci->usb_packet);
 863         if (ohci->usb_packet.status == USB_RET_ASYNC) {
 864             usb_device_flush_ep_queue(dev, ep);
 865             return 1;
 866         }
 867     }
 868     if (ohci->usb_packet.status == USB_RET_SUCCESS) {
 869         ret = ohci->usb_packet.actual_length;
 870     } else {
 871         ret = ohci->usb_packet.status;
 872     }
 873
 874     trace_usb_ohci_iso_td_so(start_offset, end_offset, start_addr, end_addr,
 875                              str, len, ret);
 876
 877     /* Writeback */
 878     if (dir == OHCI_TD_DIR_IN && ret >= 0 && ret <= len) {
 879         /* IN transfer succeeded */
 880         if (ohci_copy_iso_td(ohci, start_addr, end_addr, ohci->usb_buf, ret,
 881                              DMA_DIRECTION_FROM_DEVICE)) {
 882             ohci_die(ohci);
 883             return 1;
 884         }
 885         OHCI_SET_BM(iso_td.offset[relative_frame_number], TD_PSW_CC,
 886                     OHCI_CC_NOERROR);
 887         OHCI_SET_BM(iso_td.offset[relative_frame_number], TD_PSW_SIZE, ret);
 888     } else if (dir == OHCI_TD_DIR_OUT && ret == len) {
 889         /* OUT transfer succeeded */
 890         OHCI_SET_BM(iso_td.offset[relative_frame_number], TD_PSW_CC,
 891                     OHCI_CC_NOERROR);
 892         OHCI_SET_BM(iso_td.offset[relative_frame_number], TD_PSW_SIZE, 0);
 893     } else {
 894         if (ret > (ssize_t) len) {
 895             trace_usb_ohci_iso_td_data_overrun(ret, len);
 896             OHCI_SET_BM(iso_td.offset[relative_frame_number], TD_PSW_CC,
 897                         OHCI_CC_DATAOVERRUN);
 898             OHCI_SET_BM(iso_td.offset[relative_frame_number], TD_PSW_SIZE,
 899                         len);
 900         } else if (ret >= 0) {
 901             trace_usb_ohci_iso_td_data_underrun(ret);
 902             OHCI_SET_BM(iso_td.offset[relative_frame_number], TD_PSW_CC,
 903                         OHCI_CC_DATAUNDERRUN);
 904         } else {
 905             switch (ret) {
 906             case USB_RET_IOERROR:
 907             case USB_RET_NODEV:
 908                 OHCI_SET_BM(iso_td.offset[relative_frame_number], TD_PSW_CC,
 909                             OHCI_CC_DEVICENOTRESPONDING);
 910                 OHCI_SET_BM(iso_td.offset[relative_frame_number], TD_PSW_SIZE,
 911                             0);
 912                 break;
 913             case USB_RET_NAK:
 914             case USB_RET_STALL:
 915                 trace_usb_ohci_iso_td_nak(ret);
 916                 OHCI_SET_BM(iso_td.offset[relative_frame_number], TD_PSW_CC,
 917                             OHCI_CC_STALL);
 918                 OHCI_SET_BM(iso_td.offset[relative_frame_number], TD_PSW_SIZE,
 919                             0);
 920                 break;
 921             default:
 922                 trace_usb_ohci_iso_td_bad_response(ret);
 923                 OHCI_SET_BM(iso_td.offset[relative_frame_number], TD_PSW_CC,
 924                             OHCI_CC_UNDEXPETEDPID);
 925                 break;
 926             }
 927         }
 928     }
 929
 930     if (relative_frame_number == frame_count) {
 931         /* Last data packet of ISO TD - retire the TD to the Done Queue */
 932         OHCI_SET_BM(iso_td.flags, TD_CC, OHCI_CC_NOERROR);
 933         ed->head &= ~OHCI_DPTR_MASK;
 934         ed->head |= (iso_td.next & OHCI_DPTR_MASK);
 935         iso_td.next = ohci->done;
 936         ohci->done = addr;
 937         i = OHCI_BM(iso_td.flags, TD_DI);
 938         if (i < ohci->done_count)
 939             ohci->done_count = i;
 940     }
 941     if (ohci_put_iso_td(ohci, addr, &iso_td)) {
 942         ohci_die(ohci);
 943     }
 944     return 1;
 945 }
 946
 947 static void ohci_td_pkt(const char *msg, const uint8_t *buf, size_t len)
 948 {
 949     bool print16;
 950     bool printall;
 951     const int width = 16;
 952     int i;
 953     char tmp[3 * width + 1];
 954     char *p = tmp;
 955
 956     print16 = !!trace_event_get_state_backends(TRACE_USB_OHCI_TD_PKT_SHORT);
 957     printall = !!trace_event_get_state_backends(TRACE_USB_OHCI_TD_PKT_FULL);
 958
 959     if (!printall && !print16) {
 960         return;
 961     }
 962
 963     for (i = 0; ; i++) {
 964         if (i && (!(i % width) || (i == len))) {
 965             if (!printall) {
 966                 trace_usb_ohci_td_pkt_short(msg, tmp);
 967                 break;
 968             }
 969             trace_usb_ohci_td_pkt_full(msg, tmp);
 970             p = tmp;
 971             *p = 0;
 972         }
 973         if (i == len) {
 974             break;
 975         }
 976
 977         p += sprintf(p, " %.2x", buf[i]);
 978     }
 979 }
 980
 981 /* Service a transport descriptor.
 982    Returns nonzero to terminate processing of this endpoint.  */
 983
 984 static int ohci_service_td(OHCIState *ohci, struct ohci_ed *ed)
 985 {
 986     int dir;
 987     size_t len = 0, pktlen = 0;
 988     const char *str = NULL;
 989     int pid;
 990     int ret;
 991     int i;
 992     USBDevice *dev;
 993     USBEndpoint *ep;
 994     struct ohci_td td;
 995     uint32_t addr;
 996     int flag_r;
 997     int completion;
 998
 999     addr = ed->head & OHCI_DPTR_MASK;
1000     /* See if this TD has already been submitted to the device.  */
1001     completion = (addr == ohci->async_td);
1002     if (completion && !ohci->async_complete) {
1003         trace_usb_ohci_td_skip_async();
1004         return 1;
1005     }
1006     if (ohci_read_td(ohci, addr, &td)) {
1007         trace_usb_ohci_td_read_error(addr);
1008         ohci_die(ohci);
1009         return 1;
1010     }
1011
1012     dir = OHCI_BM(ed->flags, ED_D);
1013     switch (dir) {
1014     case OHCI_TD_DIR_OUT:
1015     case OHCI_TD_DIR_IN:
1016         /* Same value.  */
1017         break;
1018     default:
1019         dir = OHCI_BM(td.flags, TD_DP);
1020         break;
1021     }
1022
1023     switch (dir) {
1024     case OHCI_TD_DIR_IN:
1025         str = "in";
1026         pid = USB_TOKEN_IN;
1027         break;
1028     case OHCI_TD_DIR_OUT:
1029         str = "out";
1030         pid = USB_TOKEN_OUT;
1031         break;
1032     case OHCI_TD_DIR_SETUP:
1033         str = "setup";
1034         pid = USB_TOKEN_SETUP;
1035         break;
1036     default:
1037         trace_usb_ohci_td_bad_direction(dir);
1038         return 1;
1039     }
1040     if (td.cbp && td.be) {
1041         if ((td.cbp & 0xfffff000) != (td.be & 0xfffff000)) {
1042             len = (td.be & 0xfff) + 0x1001 - (td.cbp & 0xfff);
1043         } else {
1044             len = (td.be - td.cbp) + 1;
1045         }
1046
1047         pktlen = len;
1048         if (len && dir != OHCI_TD_DIR_IN) {
1049             /* The endpoint may not allow us to transfer it all now */
1050             pktlen = (ed->flags & OHCI_ED_MPS_MASK) >> OHCI_ED_MPS_SHIFT;
1051             if (pktlen > len) {
1052                 pktlen = len;
1053             }
1054             if (!completion) {
1055                 if (ohci_copy_td(ohci, &td, ohci->usb_buf, pktlen,
1056                                  DMA_DIRECTION_TO_DEVICE)) {
1057                     ohci_die(ohci);
1058                 }
1059             }
1060         }
1061     }
1062
1063     flag_r = (td.flags & OHCI_TD_R) != 0;
1064     trace_usb_ohci_td_pkt_hdr(addr, (int64_t)pktlen, (int64_t)len, str,
1065                               flag_r, td.cbp, td.be);
1066     ohci_td_pkt("OUT", ohci->usb_buf, pktlen);
1067
1068     if (completion) {
1069         ohci->async_td = 0;
1070         ohci->async_complete = false;
1071     } else {
1072         if (ohci->async_td) {
1073             /* ??? The hardware should allow one active packet per
1074                endpoint.  We only allow one active packet per controller.
1075                This should be sufficient as long as devices respond in a
1076                timely manner.
1077             */
1078             trace_usb_ohci_td_too_many_pending();
1079             return 1;
1080         }
1081         dev = ohci_find_device(ohci, OHCI_BM(ed->flags, ED_FA));
1082         if (dev == NULL) {
1083             trace_usb_ohci_td_dev_error();
1084             return 1;
1085         }
1086         ep = usb_ep_get(dev, pid, OHCI_BM(ed->flags, ED_EN));
1087         usb_packet_setup(&ohci->usb_packet, pid, ep, 0, addr, !flag_r,
1088                          OHCI_BM(td.flags, TD_DI) == 0);
1089         usb_packet_addbuf(&ohci->usb_packet, ohci->usb_buf, pktlen);
1090         usb_handle_packet(dev, &ohci->usb_packet);
1091         trace_usb_ohci_td_packet_status(ohci->usb_packet.status);
1092
1093         if (ohci->usb_packet.status == USB_RET_ASYNC) {
1094             usb_device_flush_ep_queue(dev, ep);
1095             ohci->async_td = addr;
1096             return 1;
1097         }
1098     }
1099     if (ohci->usb_packet.status == USB_RET_SUCCESS) {
1100         ret = ohci->usb_packet.actual_length;
1101     } else {
1102         ret = ohci->usb_packet.status;
1103     }
1104
1105     if (ret >= 0) {
1106         if (dir == OHCI_TD_DIR_IN) {
1107             if (ohci_copy_td(ohci, &td, ohci->usb_buf, ret,
1108                              DMA_DIRECTION_FROM_DEVICE)) {
1109                 ohci_die(ohci);
1110             }
1111             ohci_td_pkt("IN", ohci->usb_buf, pktlen);
1112         } else {
1113             ret = pktlen;
1114         }
1115     }
1116
1117     /* Writeback */
1118     if (ret == pktlen || (dir == OHCI_TD_DIR_IN && ret >= 0 && flag_r)) {
1119         /* Transmission succeeded.  */
1120         if (ret == len) {
1121             td.cbp = 0;
1122         } else {
1123             if ((td.cbp & 0xfff) + ret > 0xfff) {
1124                 td.cbp = (td.be & ~0xfff) + ((td.cbp + ret) & 0xfff);
1125             } else {
1126                 td.cbp += ret;
1127             }
1128         }
1129         td.flags |= OHCI_TD_T1;
1130         td.flags ^= OHCI_TD_T0;
1131         OHCI_SET_BM(td.flags, TD_CC, OHCI_CC_NOERROR);
1132         OHCI_SET_BM(td.flags, TD_EC, 0);
1133
1134         if ((dir != OHCI_TD_DIR_IN) && (ret != len)) {
1135             /* Partial packet transfer: TD not ready to retire yet */
1136             goto exit_no_retire;
1137         }
1138
1139         /* Setting ED_C is part of the TD retirement process */
1140         ed->head &= ~OHCI_ED_C;
1141         if (td.flags & OHCI_TD_T0)
1142             ed->head |= OHCI_ED_C;
1143     } else {
1144         if (ret >= 0) {
1145             trace_usb_ohci_td_underrun();
1146             OHCI_SET_BM(td.flags, TD_CC, OHCI_CC_DATAUNDERRUN);
1147         } else {
1148             switch (ret) {
1149             case USB_RET_IOERROR:
1150             case USB_RET_NODEV:
1151                 trace_usb_ohci_td_dev_error();
1152                 OHCI_SET_BM(td.flags, TD_CC, OHCI_CC_DEVICENOTRESPONDING);
1153                 break;
1154             case USB_RET_NAK:
1155                 trace_usb_ohci_td_nak();
1156                 return 1;
1157             case USB_RET_STALL:
1158                 trace_usb_ohci_td_stall();
1159                 OHCI_SET_BM(td.flags, TD_CC, OHCI_CC_STALL);
1160                 break;
1161             case USB_RET_BABBLE:
1162                 trace_usb_ohci_td_babble();
1163                 OHCI_SET_BM(td.flags, TD_CC, OHCI_CC_DATAOVERRUN);
1164                 break;
1165             default:
1166                 trace_usb_ohci_td_bad_device_response(ret);
1167                 OHCI_SET_BM(td.flags, TD_CC, OHCI_CC_UNDEXPETEDPID);
1168                 OHCI_SET_BM(td.flags, TD_EC, 3);
1169                 break;
1170             }
1171             /* An error occured so we have to clear the interrupt counter. See
1172              * spec at 6.4.4 on page 104 */
1173             ohci->done_count = 0;
1174         }
1175         ed->head |= OHCI_ED_H;
1176     }
1177
1178     /* Retire this TD */
1179     ed->head &= ~OHCI_DPTR_MASK;
1180     ed->head |= td.next & OHCI_DPTR_MASK;
1181     td.next = ohci->done;
1182     ohci->done = addr;
1183     i = OHCI_BM(td.flags, TD_DI);
1184     if (i < ohci->done_count)
1185         ohci->done_count = i;
1186 exit_no_retire:
1187     if (ohci_put_td(ohci, addr, &td)) {
1188         ohci_die(ohci);
1189         return 1;
1190     }
1191     return OHCI_BM(td.flags, TD_CC) != OHCI_CC_NOERROR;
1192 }
1193
1194 /* Service an endpoint list.  Returns nonzero if active TD were found.  */
1195 static int ohci_service_ed_list(OHCIState *ohci, uint32_t head, int completion)
1196 {
1197     struct ohci_ed ed;
1198     uint32_t next_ed;
1199     uint32_t cur;
1200     int active;
1201     uint32_t link_cnt = 0;
1202     active = 0;
1203
1204     if (head == 0)
1205         return 0;
1206
1207     for (cur = head; cur && link_cnt++ < ED_LINK_LIMIT; cur = next_ed) {
1208         if (ohci_read_ed(ohci, cur, &ed)) {
1209             trace_usb_ohci_ed_read_error(cur);
1210             ohci_die(ohci);
1211             return 0;
1212         }
1213
1214         next_ed = ed.next & OHCI_DPTR_MASK;
1215
1216         if ((ed.head & OHCI_ED_H) || (ed.flags & OHCI_ED_K)) {
1217             uint32_t addr;
1218             /* Cancel pending packets for ED that have been paused.  */
1219             addr = ed.head & OHCI_DPTR_MASK;
1220             if (ohci->async_td && addr == ohci->async_td) {
1221                 usb_cancel_packet(&ohci->usb_packet);
1222                 ohci->async_td = 0;
1223                 usb_device_ep_stopped(ohci->usb_packet.ep->dev,
1224                                       ohci->usb_packet.ep);
1225             }
1226             continue;
1227         }
1228
1229         while ((ed.head & OHCI_DPTR_MASK) != ed.tail) {
1230             trace_usb_ohci_ed_pkt(cur, (ed.head & OHCI_ED_H) != 0,
1231                     (ed.head & OHCI_ED_C) != 0, ed.head & OHCI_DPTR_MASK,
1232                     ed.tail & OHCI_DPTR_MASK, ed.next & OHCI_DPTR_MASK);
1233             trace_usb_ohci_ed_pkt_flags(
1234                     OHCI_BM(ed.flags, ED_FA), OHCI_BM(ed.flags, ED_EN),
1235                     OHCI_BM(ed.flags, ED_D), (ed.flags & OHCI_ED_S)!= 0,
1236                     (ed.flags & OHCI_ED_K) != 0, (ed.flags & OHCI_ED_F) != 0,
1237                     OHCI_BM(ed.flags, ED_MPS));
1238
1239             active = 1;
1240
1241             if ((ed.flags & OHCI_ED_F) == 0) {
1242                 if (ohci_service_td(ohci, &ed))
1243                     break;
1244             } else {
1245                 /* Handle isochronous endpoints */
1246                 if (ohci_service_iso_td(ohci, &ed, completion))
1247                     break;
1248             }
1249         }
1250
1251         if (ohci_put_ed(ohci, cur, &ed)) {
1252             ohci_die(ohci);
1253             return 0;
1254         }
1255     }
1256
1257     return active;
1258 }
1259
1260 /* set a timer for EOF */
1261 static void ohci_eof_timer(OHCIState *ohci)
1262 {
1263     timer_mod(ohci->eof_timer, ohci->sof_time + usb_frame_time);
1264 }
1265 /* Set a timer for EOF and generate a SOF event */
1266 static void ohci_sof(OHCIState *ohci)
1267 {
1268     ohci->sof_time += usb_frame_time;
1269     ohci_eof_timer(ohci);
1270     ohci_set_interrupt(ohci, OHCI_INTR_SF);
1271 }
1272
1273 /* Process Control and Bulk lists.  */
1274 static void ohci_process_lists(OHCIState *ohci, int completion)
1275 {
1276     if ((ohci->ctl & OHCI_CTL_CLE) && (ohci->status & OHCI_STATUS_CLF)) {
1277         if (ohci->ctrl_cur && ohci->ctrl_cur != ohci->ctrl_head) {
1278             trace_usb_ohci_process_lists(ohci->ctrl_head, ohci->ctrl_cur);
1279         }
1280         if (!ohci_service_ed_list(ohci, ohci->ctrl_head, completion)) {
1281             ohci->ctrl_cur = 0;
1282             ohci->status &= ~OHCI_STATUS_CLF;
1283         }
1284     }
1285
1286     if ((ohci->ctl & OHCI_CTL_BLE) && (ohci->status & OHCI_STATUS_BLF)) {
1287         if (!ohci_service_ed_list(ohci, ohci->bulk_head, completion)) {
1288             ohci->bulk_cur = 0;
1289             ohci->status &= ~OHCI_STATUS_BLF;
1290         }
1291     }
1292 }
1293
1294 /* Do frame processing on frame boundary */
1295 static void ohci_frame_boundary(void *opaque)
1296 {
1297     OHCIState *ohci = opaque;
1298     struct ohci_hcca hcca;
1299
1300     if (ohci_read_hcca(ohci, ohci->hcca, &hcca)) {
1301         trace_usb_ohci_hcca_read_error(ohci->hcca);
1302         ohci_die(ohci);
1303         return;
1304     }
1305
1306     /* Process all the lists at the end of the frame */
1307     if (ohci->ctl & OHCI_CTL_PLE) {
1308         int n;
1309
1310         n = ohci->frame_number & 0x1f;
1311         ohci_service_ed_list(ohci, le32_to_cpu(hcca.intr[n]), 0);
1312     }
1313
1314     /* Cancel all pending packets if either of the lists has been disabled.  */
1315     if (ohci->old_ctl & (~ohci->ctl) & (OHCI_CTL_BLE | OHCI_CTL_CLE)) {
1316         if (ohci->async_td) {
1317             usb_cancel_packet(&ohci->usb_packet);
1318             ohci->async_td = 0;
1319         }
1320         ohci_stop_endpoints(ohci);
1321     }
1322     ohci->old_ctl = ohci->ctl;
1323     ohci_process_lists(ohci, 0);
1324
1325     /* Stop if UnrecoverableError happened or ohci_sof will crash */
1326     if (ohci->intr_status & OHCI_INTR_UE) {
1327         return;
1328     }
1329
1330     /* Frame boundary, so do EOF stuf here */
1331     ohci->frt = ohci->fit;
1332
1333     /* Increment frame number and take care of endianness. */
1334     ohci->frame_number = (ohci->frame_number + 1) & 0xffff;
1335     hcca.frame = cpu_to_le16(ohci->frame_number);
1336
1337     if (ohci->done_count == 0 && !(ohci->intr_status & OHCI_INTR_WD)) {
1338         if (!ohci->done)
1339             abort();
1340         if (ohci->intr & ohci->intr_status)
1341             ohci->done |= 1;
1342         hcca.done = cpu_to_le32(ohci->done);
1343         ohci->done = 0;
1344         ohci->done_count = 7;
1345         ohci_set_interrupt(ohci, OHCI_INTR_WD);
1346     }
1347
1348     if (ohci->done_count != 7 && ohci->done_count != 0)
1349         ohci->done_count--;
1350
1351     /* Do SOF stuff here */
1352     ohci_sof(ohci);
1353
1354     /* Writeback HCCA */
1355     if (ohci_put_hcca(ohci, ohci->hcca, &hcca)) {
1356         ohci_die(ohci);
1357     }
1358 }
1359
1360 /* Start sending SOF tokens across the USB bus, lists are processed in
1361  * next frame
1362  */
1363 static int ohci_bus_start(OHCIState *ohci)
1364 {
1365     trace_usb_ohci_start(ohci->name);
1366
1367     /* Delay the first SOF event by one frame time as
1368      * linux driver is not ready to receive it and
1369      * can meet some race conditions
1370      */
1371
1372     ohci->sof_time = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
1373     ohci_eof_timer(ohci);
1374
1375     return 1;
1376 }
1377
1378 /* Stop sending SOF tokens on the bus */
1379 static void ohci_bus_stop(OHCIState *ohci)
1380 {
1381     trace_usb_ohci_stop(ohci->name);
1382     timer_del(ohci->eof_timer);
1383 }
1384
1385 /* Sets a flag in a port status register but only set it if the port is
1386  * connected, if not set ConnectStatusChange flag. If flag is enabled
1387  * return 1.
1388  */
1389 static int ohci_port_set_if_connected(OHCIState *ohci, int i, uint32_t val)
1390 {
1391     int ret = 1;
1392
1393     /* writing a 0 has no effect */
1394     if (val == 0)
1395         return 0;
1396
1397     /* If CurrentConnectStatus is cleared we set
1398      * ConnectStatusChange
1399      */
1400     if (!(ohci->rhport[i].ctrl & OHCI_PORT_CCS)) {
1401         ohci->rhport[i].ctrl |= OHCI_PORT_CSC;
1402         if (ohci->rhstatus & OHCI_RHS_DRWE) {
1403             /* TODO: CSC is a wakeup event */
1404         }
1405         return 0;
1406     }
1407
1408     if (ohci->rhport[i].ctrl & val)
1409         ret = 0;
1410
1411     /* set the bit */
1412     ohci->rhport[i].ctrl |= val;
1413
1414     return ret;
1415 }
1416
1417 /* Set the frame interval - frame interval toggle is manipulated by the hcd only */
1418 static void ohci_set_frame_interval(OHCIState *ohci, uint16_t val)
1419 {
1420     val &= OHCI_FMI_FI;
1421
1422     if (val != ohci->fi) {
1423         trace_usb_ohci_set_frame_interval(ohci->name, ohci->fi, ohci->fi);
1424     }
1425
1426     ohci->fi = val;
1427 }
1428
1429 static void ohci_port_power(OHCIState *ohci, int i, int p)
1430 {
1431     if (p) {
1432         ohci->rhport[i].ctrl |= OHCI_PORT_PPS;
1433     } else {
1434         ohci->rhport[i].ctrl &= ~(OHCI_PORT_PPS|
1435                     OHCI_PORT_CCS|
1436                     OHCI_PORT_PSS|
1437                     OHCI_PORT_PRS);
1438     }
1439 }
1440
1441 /* Set HcControlRegister */
1442 static void ohci_set_ctl(OHCIState *ohci, uint32_t val)
1443 {
1444     uint32_t old_state;
1445     uint32_t new_state;
1446
1447     old_state = ohci->ctl & OHCI_CTL_HCFS;
1448     ohci->ctl = val;
1449     new_state = ohci->ctl & OHCI_CTL_HCFS;
1450
1451     /* no state change */
1452     if (old_state == new_state)
1453         return;
1454
1455     trace_usb_ohci_set_ctl(ohci->name, new_state);
1456     switch (new_state) {
1457     case OHCI_USB_OPERATIONAL:
1458         ohci_bus_start(ohci);
1459         break;
1460     case OHCI_USB_SUSPEND:
1461         ohci_bus_stop(ohci);
1462         /* clear pending SF otherwise linux driver loops in ohci_irq() */
1463         ohci->intr_status &= ~OHCI_INTR_SF;
1464         ohci_intr_update(ohci);
1465         break;
1466     case OHCI_USB_RESUME:
1467         trace_usb_ohci_resume(ohci->name);
1468         break;
1469     case OHCI_USB_RESET:
1470         ohci_roothub_reset(ohci);
1471         break;
1472     }
1473 }
1474
1475 static uint32_t ohci_get_frame_remaining(OHCIState *ohci)
1476 {
1477     uint16_t fr;
1478     int64_t tks;
1479
1480     if ((ohci->ctl & OHCI_CTL_HCFS) != OHCI_USB_OPERATIONAL)
1481         return (ohci->frt << 31);
1482
1483     /* Being in USB operational state guarnatees sof_time was
1484      * set already.
1485      */
1486     tks = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) - ohci->sof_time;
1487     if (tks < 0) {
1488         tks = 0;
1489     }
1490
1491     /* avoid muldiv if possible */
1492     if (tks >= usb_frame_time)
1493         return (ohci->frt << 31);
1494
1495     tks = tks / usb_bit_time;
1496     fr = (uint16_t)(ohci->fi - tks);
1497
1498     return (ohci->frt << 31) | fr;
1499 }
1500
1501
1502 /* Set root hub status */
1503 static void ohci_set_hub_status(OHCIState *ohci, uint32_t val)
1504 {
1505     uint32_t old_state;
1506
1507     old_state = ohci->rhstatus;
1508
1509     /* write 1 to clear OCIC */
1510     if (val & OHCI_RHS_OCIC)
1511         ohci->rhstatus &= ~OHCI_RHS_OCIC;
1512
1513     if (val & OHCI_RHS_LPS) {
1514         int i;
1515
1516         for (i = 0; i < ohci->num_ports; i++)
1517             ohci_port_power(ohci, i, 0);
1518         trace_usb_ohci_hub_power_down();
1519     }
1520
1521     if (val & OHCI_RHS_LPSC) {
1522         int i;
1523
1524         for (i = 0; i < ohci->num_ports; i++)
1525             ohci_port_power(ohci, i, 1);
1526         trace_usb_ohci_hub_power_up();
1527     }
1528
1529     if (val & OHCI_RHS_DRWE)
1530         ohci->rhstatus |= OHCI_RHS_DRWE;
1531
1532     if (val & OHCI_RHS_CRWE)
1533         ohci->rhstatus &= ~OHCI_RHS_DRWE;
1534
1535     if (old_state != ohci->rhstatus)
1536         ohci_set_interrupt(ohci, OHCI_INTR_RHSC);
1537 }
1538
1539 /* Set root hub port status */
1540 static void ohci_port_set_status(OHCIState *ohci, int portnum, uint32_t val)
1541 {
1542     uint32_t old_state;
1543     OHCIPort *port;
1544
1545     port = &ohci->rhport[portnum];
1546     old_state = port->ctrl;
1547
1548     /* Write to clear CSC, PESC, PSSC, OCIC, PRSC */
1549     if (val & OHCI_PORT_WTC)
1550         port->ctrl &= ~(val & OHCI_PORT_WTC);
1551
1552     if (val & OHCI_PORT_CCS)
1553         port->ctrl &= ~OHCI_PORT_PES;
1554
1555     ohci_port_set_if_connected(ohci, portnum, val & OHCI_PORT_PES);
1556
1557     if (ohci_port_set_if_connected(ohci, portnum, val & OHCI_PORT_PSS)) {
1558         trace_usb_ohci_port_suspend(portnum);
1559     }
1560
1561     if (ohci_port_set_if_connected(ohci, portnum, val & OHCI_PORT_PRS)) {
1562         trace_usb_ohci_port_reset(portnum);
1563         usb_device_reset(port->port.dev);
1564         port->ctrl &= ~OHCI_PORT_PRS;
1565         /* ??? Should this also set OHCI_PORT_PESC.  */
1566         port->ctrl |= OHCI_PORT_PES | OHCI_PORT_PRSC;
1567     }
1568
1569     /* Invert order here to ensure in ambiguous case, device is
1570      * powered up...
1571      */
1572     if (val & OHCI_PORT_LSDA)
1573         ohci_port_power(ohci, portnum, 0);
1574     if (val & OHCI_PORT_PPS)
1575         ohci_port_power(ohci, portnum, 1);
1576
1577     if (old_state != port->ctrl)
1578         ohci_set_interrupt(ohci, OHCI_INTR_RHSC);
1579 }
1580
1581 static uint64_t ohci_mem_read(void *opaque,
1582                               hwaddr addr,
1583                               unsigned size)
1584 {
1585     OHCIState *ohci = opaque;
1586     uint32_t retval;
1587
1588     /* Only aligned reads are allowed on OHCI */
1589     if (addr & 3) {
1590         trace_usb_ohci_mem_read_unaligned(addr);
1591         return 0xffffffff;
1592     } else if (addr >= 0x54 && addr < 0x54 + ohci->num_ports * 4) {
1593         /* HcRhPortStatus */
1594         retval = ohci->rhport[(addr - 0x54) >> 2].ctrl | OHCI_PORT_PPS;
1595     } else {
1596         switch (addr >> 2) {
1597         case 0: /* HcRevision */
1598             retval = 0x10;
1599             break;
1600
1601         case 1: /* HcControl */
1602             retval = ohci->ctl;
1603             break;
1604
1605         case 2: /* HcCommandStatus */
1606             retval = ohci->status;
1607             break;
1608
1609         case 3: /* HcInterruptStatus */
1610             retval = ohci->intr_status;
1611             break;
1612
1613         case 4: /* HcInterruptEnable */
1614         case 5: /* HcInterruptDisable */
1615             retval = ohci->intr;
1616             break;
1617
1618         case 6: /* HcHCCA */
1619             retval = ohci->hcca;
1620             break;
1621
1622         case 7: /* HcPeriodCurrentED */
1623             retval = ohci->per_cur;
1624             break;
1625
1626         case 8: /* HcControlHeadED */
1627             retval = ohci->ctrl_head;
1628             break;
1629
1630         case 9: /* HcControlCurrentED */
1631             retval = ohci->ctrl_cur;
1632             break;
1633
1634         case 10: /* HcBulkHeadED */
1635             retval = ohci->bulk_head;
1636             break;
1637
1638         case 11: /* HcBulkCurrentED */
1639             retval = ohci->bulk_cur;
1640             break;
1641
1642         case 12: /* HcDoneHead */
1643             retval = ohci->done;
1644             break;
1645
1646         case 13: /* HcFmInterretval */
1647             retval = (ohci->fit << 31) | (ohci->fsmps << 16) | (ohci->fi);
1648             break;
1649
1650         case 14: /* HcFmRemaining */
1651             retval = ohci_get_frame_remaining(ohci);
1652             break;
1653
1654         case 15: /* HcFmNumber */
1655             retval = ohci->frame_number;
1656             break;
1657
1658         case 16: /* HcPeriodicStart */
1659             retval = ohci->pstart;
1660             break;
1661
1662         case 17: /* HcLSThreshold */
1663             retval = ohci->lst;
1664             break;
1665
1666         case 18: /* HcRhDescriptorA */
1667             retval = ohci->rhdesc_a;
1668             break;
1669
1670         case 19: /* HcRhDescriptorB */
1671             retval = ohci->rhdesc_b;
1672             break;
1673
1674         case 20: /* HcRhStatus */
1675             retval = ohci->rhstatus;
1676             break;
1677
1678         /* PXA27x specific registers */
1679         case 24: /* HcStatus */
1680             retval = ohci->hstatus & ohci->hmask;
1681             break;
1682
1683         case 25: /* HcHReset */
1684             retval = ohci->hreset;
1685             break;
1686
1687         case 26: /* HcHInterruptEnable */
1688             retval = ohci->hmask;
1689             break;
1690
1691         case 27: /* HcHInterruptTest */
1692             retval = ohci->htest;
1693             break;
1694
1695         default:
1696             trace_usb_ohci_mem_read_bad_offset(addr);
1697             retval = 0xffffffff;
1698         }
1699     }
1700
1701     return retval;
1702 }
1703
1704 static void ohci_mem_write(void *opaque,
1705                            hwaddr addr,
1706                            uint64_t val,
1707                            unsigned size)
1708 {
1709     OHCIState *ohci = opaque;
1710
1711     /* Only aligned reads are allowed on OHCI */
1712     if (addr & 3) {
1713         trace_usb_ohci_mem_write_unaligned(addr);
1714         return;
1715     }
1716
1717     if (addr >= 0x54 && addr < 0x54 + ohci->num_ports * 4) {
1718         /* HcRhPortStatus */
1719         ohci_port_set_status(ohci, (addr - 0x54) >> 2, val);
1720         return;
1721     }
1722
1723     switch (addr >> 2) {
1724     case 1: /* HcControl */
1725         ohci_set_ctl(ohci, val);
1726         break;
1727
1728     case 2: /* HcCommandStatus */
1729         /* SOC is read-only */
1730         val = (val & ~OHCI_STATUS_SOC);
1731
1732         /* Bits written as '0' remain unchanged in the register */
1733         ohci->status |= val;
1734
1735         if (ohci->status & OHCI_STATUS_HCR)
1736             ohci_soft_reset(ohci);
1737         break;
1738
1739     case 3: /* HcInterruptStatus */
1740         ohci->intr_status &= ~val;
1741         ohci_intr_update(ohci);
1742         break;
1743
1744     case 4: /* HcInterruptEnable */
1745         ohci->intr |= val;
1746         ohci_intr_update(ohci);
1747         break;
1748
1749     case 5: /* HcInterruptDisable */
1750         ohci->intr &= ~val;
1751         ohci_intr_update(ohci);
1752         break;
1753
1754     case 6: /* HcHCCA */
1755         ohci->hcca = val & OHCI_HCCA_MASK;
1756         break;
1757
1758     case 7: /* HcPeriodCurrentED */
1759         /* Ignore writes to this read-only register, Linux does them */
1760         break;
1761
1762     case 8: /* HcControlHeadED */
1763         ohci->ctrl_head = val & OHCI_EDPTR_MASK;
1764         break;
1765
1766     case 9: /* HcControlCurrentED */
1767         ohci->ctrl_cur = val & OHCI_EDPTR_MASK;
1768         break;
1769
1770     case 10: /* HcBulkHeadED */
1771         ohci->bulk_head = val & OHCI_EDPTR_MASK;
1772         break;
1773
1774     case 11: /* HcBulkCurrentED */
1775         ohci->bulk_cur = val & OHCI_EDPTR_MASK;
1776         break;
1777
1778     case 13: /* HcFmInterval */
1779         ohci->fsmps = (val & OHCI_FMI_FSMPS) >> 16;
1780         ohci->fit = (val & OHCI_FMI_FIT) >> 31;
1781         ohci_set_frame_interval(ohci, val);
1782         break;
1783
1784     case 15: /* HcFmNumber */
1785         break;
1786
1787     case 16: /* HcPeriodicStart */
1788         ohci->pstart = val & 0xffff;
1789         break;
1790
1791     case 17: /* HcLSThreshold */
1792         ohci->lst = val & 0xffff;
1793         break;
1794
1795     case 18: /* HcRhDescriptorA */
1796         ohci->rhdesc_a &= ~OHCI_RHA_RW_MASK;
1797         ohci->rhdesc_a |= val & OHCI_RHA_RW_MASK;
1798         break;
1799
1800     case 19: /* HcRhDescriptorB */
1801         break;
1802
1803     case 20: /* HcRhStatus */
1804         ohci_set_hub_status(ohci, val);
1805         break;
1806
1807     /* PXA27x specific registers */
1808     case 24: /* HcStatus */
1809         ohci->hstatus &= ~(val & ohci->hmask);
1810         break;
1811
1812     case 25: /* HcHReset */
1813         ohci->hreset = val & ~OHCI_HRESET_FSBIR;
1814         if (val & OHCI_HRESET_FSBIR)
1815             ohci_hard_reset(ohci);
1816         break;
1817
1818     case 26: /* HcHInterruptEnable */
1819         ohci->hmask = val;
1820         break;
1821
1822     case 27: /* HcHInterruptTest */
1823         ohci->htest = val;
1824         break;
1825
1826     default:
1827         trace_usb_ohci_mem_write_bad_offset(addr);
1828         break;
1829     }
1830 }
1831
1832 static void ohci_async_cancel_device(OHCIState *ohci, USBDevice *dev)
1833 {
1834     if (ohci->async_td &&
1835         usb_packet_is_inflight(&ohci->usb_packet) &&
1836         ohci->usb_packet.ep->dev == dev) {
1837         usb_cancel_packet(&ohci->usb_packet);
1838         ohci->async_td = 0;
1839     }
1840 }
1841
1842 static const MemoryRegionOps ohci_mem_ops = {
1843     .read = ohci_mem_read,
1844     .write = ohci_mem_write,
1845     .endianness = DEVICE_LITTLE_ENDIAN,
1846 };
1847
1848 static USBPortOps ohci_port_ops = {
1849     .attach = ohci_attach,
1850     .detach = ohci_detach,
1851     .child_detach = ohci_child_detach,
1852     .wakeup = ohci_wakeup,
1853     .complete = ohci_async_complete_packet,
1854 };
1855
1856 static USBBusOps ohci_bus_ops = {
1857 };
1858
1859 static void usb_ohci_init(OHCIState *ohci, DeviceState *dev,
1860                           uint32_t num_ports, dma_addr_t localmem_base,
1861                           char *masterbus, uint32_t firstport, AddressSpace *as,
1862                           void (*ohci_die_fn)(struct OHCIState *), Error **errp)
1863 {
1864     Error *err = NULL;
1865     int i;
1866
1867     ohci->as = as;
1868     ohci->ohci_die = ohci_die_fn;
1869
1870     if (num_ports > OHCI_MAX_PORTS) {
1871         error_setg(errp, "OHCI num-ports=%u is too big (limit is %u ports)",
1872                    num_ports, OHCI_MAX_PORTS);
1873         return;
1874     }
1875
1876     if (usb_frame_time == 0) {
1877 #ifdef OHCI_TIME_WARP
1878         usb_frame_time = NANOSECONDS_PER_SECOND;
1879         usb_bit_time = NANOSECONDS_PER_SECOND / (USB_HZ / 1000);
1880 #else
1881         usb_frame_time = NANOSECONDS_PER_SECOND / 1000;
1882         if (NANOSECONDS_PER_SECOND >= USB_HZ) {
1883             usb_bit_time = NANOSECONDS_PER_SECOND / USB_HZ;
1884         } else {
1885             usb_bit_time = 1;
1886         }
1887 #endif
1888         trace_usb_ohci_init_time(usb_frame_time, usb_bit_time);
1889     }
1890
1891     ohci->num_ports = num_ports;
1892     if (masterbus) {
1893         USBPort *ports[OHCI_MAX_PORTS];
1894         for(i = 0; i < num_ports; i++) {
1895             ports[i] = &ohci->rhport[i].port;
1896         }
1897         usb_register_companion(masterbus, ports, num_ports,
1898                                firstport, ohci, &ohci_port_ops,
1899                                USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL,
1900                                &err);
1901         if (err) {
1902             error_propagate(errp, err);
1903             return;
1904         }
1905     } else {
1906         usb_bus_new(&ohci->bus, sizeof(ohci->bus), &ohci_bus_ops, dev);
1907         for (i = 0; i < num_ports; i++) {
1908             usb_register_port(&ohci->bus, &ohci->rhport[i].port,
1909                               ohci, i, &ohci_port_ops,
1910                               USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL);
1911         }
1912     }
1913
1914     memory_region_init_io(&ohci->mem, OBJECT(dev), &ohci_mem_ops,
1915                           ohci, "ohci", 256);
1916     ohci->localmem_base = localmem_base;
1917
1918     ohci->name = object_get_typename(OBJECT(dev));
1919     usb_packet_init(&ohci->usb_packet);
1920
1921     ohci->async_td = 0;
1922
1923     ohci->eof_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
1924                                    ohci_frame_boundary, ohci);
1925 }
1926
1927 #define TYPE_PCI_OHCI "pci-ohci"
1928 #define PCI_OHCI(obj) OBJECT_CHECK(OHCIPCIState, (obj), TYPE_PCI_OHCI)
1929
1930 typedef struct {
1931     /*< private >*/
1932     PCIDevice parent_obj;
1933     /*< public >*/
1934
1935     OHCIState state;
1936     char *masterbus;
1937     uint32_t num_ports;
1938     uint32_t firstport;
1939 } OHCIPCIState;
1940
1941 /**
1942  * A typical OHCI will stop operating and set itself into error state
1943  * (which can be queried by MMIO) to signal that it got an error.
1944  */
1945 static void ohci_sysbus_die(struct OHCIState *ohci)
1946 {
1947     trace_usb_ohci_die();
1948
1949     ohci_set_interrupt(ohci, OHCI_INTR_UE);
1950     ohci_bus_stop(ohci);
1951 }
1952
1953 /**
1954  * A typical PCI OHCI will additionally set PERR in its configspace to
1955  * signal that it got an error.
1956  */
1957 static void ohci_pci_die(struct OHCIState *ohci)
1958 {
1959     OHCIPCIState *dev = container_of(ohci, OHCIPCIState, state);
1960
1961     ohci_sysbus_die(ohci);
1962
1963     pci_set_word(dev->parent_obj.config + PCI_STATUS,
1964                  PCI_STATUS_DETECTED_PARITY);
1965 }
1966
1967 static void usb_ohci_realize_pci(PCIDevice *dev, Error **errp)
1968 {
1969     Error *err = NULL;
1970     OHCIPCIState *ohci = PCI_OHCI(dev);
1971
1972     dev->config[PCI_CLASS_PROG] = 0x10; /* OHCI */
1973     dev->config[PCI_INTERRUPT_PIN] = 0x01; /* interrupt pin A */
1974
1975     usb_ohci_init(&ohci->state, DEVICE(dev), ohci->num_ports, 0,
1976                   ohci->masterbus, ohci->firstport,
1977                   pci_get_address_space(dev), ohci_pci_die, &err);
1978     if (err) {
1979         error_propagate(errp, err);
1980         return;
1981     }
1982
1983     ohci->state.irq = pci_allocate_irq(dev);
1984     pci_register_bar(dev, 0, 0, &ohci->state.mem);
1985 }
1986
1987 static void usb_ohci_exit(PCIDevice *dev)
1988 {
1989     OHCIPCIState *ohci = PCI_OHCI(dev);
1990     OHCIState *s = &ohci->state;
1991
1992     trace_usb_ohci_exit(s->name);
1993     ohci_bus_stop(s);
1994
1995     if (s->async_td) {
1996         usb_cancel_packet(&s->usb_packet);
1997         s->async_td = 0;
1998     }
1999     ohci_stop_endpoints(s);
2000
2001     if (!ohci->masterbus) {
2002         usb_bus_release(&s->bus);
2003     }
2004
2005     timer_del(s->eof_timer);
2006     timer_free(s->eof_timer);
2007 }
2008
2009 static void usb_ohci_reset_pci(DeviceState *d)
2010 {
2011     PCIDevice *dev = PCI_DEVICE(d);
2012     OHCIPCIState *ohci = PCI_OHCI(dev);
2013     OHCIState *s = &ohci->state;
2014
2015     ohci_hard_reset(s);
2016 }
2017
2018 #define TYPE_SYSBUS_OHCI "sysbus-ohci"
2019 #define SYSBUS_OHCI(obj) OBJECT_CHECK(OHCISysBusState, (obj), TYPE_SYSBUS_OHCI)
2020
2021 typedef struct {
2022     /*< private >*/
2023     SysBusDevice parent_obj;
2024     /*< public >*/
2025
2026     OHCIState ohci;
2027     char *masterbus;
2028     uint32_t num_ports;
2029     uint32_t firstport;
2030     dma_addr_t dma_offset;
2031 } OHCISysBusState;
2032
2033 static void ohci_realize_pxa(DeviceState *dev, Error **errp)
2034 {
2035     OHCISysBusState *s = SYSBUS_OHCI(dev);
2036     SysBusDevice *sbd = SYS_BUS_DEVICE(dev);
2037     Error *err = NULL;
2038
2039     usb_ohci_init(&s->ohci, dev, s->num_ports, s->dma_offset,
2040                   s->masterbus, s->firstport,
2041                   &address_space_memory, ohci_sysbus_die, &err);
2042     if (err) {
2043         error_propagate(errp, err);
2044         return;
2045     }
2046     sysbus_init_irq(sbd, &s->ohci.irq);
2047     sysbus_init_mmio(sbd, &s->ohci.mem);
2048 }
2049
2050 static void usb_ohci_reset_sysbus(DeviceState *dev)
2051 {
2052     OHCISysBusState *s = SYSBUS_OHCI(dev);
2053     OHCIState *ohci = &s->ohci;
2054
2055     ohci_hard_reset(ohci);
2056 }
2057
2058 static Property ohci_pci_properties[] = {
2059     DEFINE_PROP_STRING("masterbus", OHCIPCIState, masterbus),
2060     DEFINE_PROP_UINT32("num-ports", OHCIPCIState, num_ports, 3),
2061     DEFINE_PROP_UINT32("firstport", OHCIPCIState, firstport, 0),
2062     DEFINE_PROP_END_OF_LIST(),
2063 };
2064
2065 static const VMStateDescription vmstate_ohci_state_port = {
2066     .name = "ohci-core/port",
2067     .version_id = 1,
2068     .minimum_version_id = 1,
2069     .fields = (VMStateField[]) {
2070         VMSTATE_UINT32(ctrl, OHCIPort),
2071         VMSTATE_END_OF_LIST()
2072     },
2073 };
2074
2075 static bool ohci_eof_timer_needed(void *opaque)
2076 {
2077     OHCIState *ohci = opaque;
2078
2079     return timer_pending(ohci->eof_timer);
2080 }
2081
2082 static const VMStateDescription vmstate_ohci_eof_timer = {
2083     .name = "ohci-core/eof-timer",
2084     .version_id = 1,
2085     .minimum_version_id = 1,
2086     .needed = ohci_eof_timer_needed,
2087     .fields = (VMStateField[]) {
2088         VMSTATE_TIMER_PTR(eof_timer, OHCIState),
2089         VMSTATE_END_OF_LIST()
2090     },
2091 };
2092
2093 static const VMStateDescription vmstate_ohci_state = {
2094     .name = "ohci-core",
2095     .version_id = 1,
2096     .minimum_version_id = 1,
2097     .fields = (VMStateField[]) {
2098         VMSTATE_INT64(sof_time, OHCIState),
2099         VMSTATE_UINT32(ctl, OHCIState),
2100         VMSTATE_UINT32(status, OHCIState),
2101         VMSTATE_UINT32(intr_status, OHCIState),
2102         VMSTATE_UINT32(intr, OHCIState),
2103         VMSTATE_UINT32(hcca, OHCIState),
2104         VMSTATE_UINT32(ctrl_head, OHCIState),
2105         VMSTATE_UINT32(ctrl_cur, OHCIState),
2106         VMSTATE_UINT32(bulk_head, OHCIState),
2107         VMSTATE_UINT32(bulk_cur, OHCIState),
2108         VMSTATE_UINT32(per_cur, OHCIState),
2109         VMSTATE_UINT32(done, OHCIState),
2110         VMSTATE_INT32(done_count, OHCIState),
2111         VMSTATE_UINT16(fsmps, OHCIState),
2112         VMSTATE_UINT8(fit, OHCIState),
2113         VMSTATE_UINT16(fi, OHCIState),
2114         VMSTATE_UINT8(frt, OHCIState),
2115         VMSTATE_UINT16(frame_number, OHCIState),
2116         VMSTATE_UINT16(padding, OHCIState),
2117         VMSTATE_UINT32(pstart, OHCIState),
2118         VMSTATE_UINT32(lst, OHCIState),
2119         VMSTATE_UINT32(rhdesc_a, OHCIState),
2120         VMSTATE_UINT32(rhdesc_b, OHCIState),
2121         VMSTATE_UINT32(rhstatus, OHCIState),
2122         VMSTATE_STRUCT_ARRAY(rhport, OHCIState, OHCI_MAX_PORTS, 0,
2123                              vmstate_ohci_state_port, OHCIPort),
2124         VMSTATE_UINT32(hstatus, OHCIState),
2125         VMSTATE_UINT32(hmask, OHCIState),
2126         VMSTATE_UINT32(hreset, OHCIState),
2127         VMSTATE_UINT32(htest, OHCIState),
2128         VMSTATE_UINT32(old_ctl, OHCIState),
2129         VMSTATE_UINT8_ARRAY(usb_buf, OHCIState, 8192),
2130         VMSTATE_UINT32(async_td, OHCIState),
2131         VMSTATE_BOOL(async_complete, OHCIState),
2132         VMSTATE_END_OF_LIST()
2133     },
2134     .subsections = (const VMStateDescription*[]) {
2135         &vmstate_ohci_eof_timer,
2136         NULL
2137     }
2138 };
2139
2140 static const VMStateDescription vmstate_ohci = {
2141     .name = "ohci",
2142     .version_id = 1,
2143     .minimum_version_id = 1,
2144     .fields = (VMStateField[]) {
2145         VMSTATE_PCI_DEVICE(parent_obj, OHCIPCIState),
2146         VMSTATE_STRUCT(state, OHCIPCIState, 1, vmstate_ohci_state, OHCIState),
2147         VMSTATE_END_OF_LIST()
2148     }
2149 };
2150
2151 static void ohci_pci_class_init(ObjectClass *klass, void *data)
2152 {
2153     DeviceClass *dc = DEVICE_CLASS(klass);
2154     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
2155
2156     k->realize = usb_ohci_realize_pci;
2157     k->exit = usb_ohci_exit;
2158     k->vendor_id = PCI_VENDOR_ID_APPLE;
2159     k->device_id = PCI_DEVICE_ID_APPLE_IPID_USB;
2160     k->class_id = PCI_CLASS_SERIAL_USB;
2161     set_bit(DEVICE_CATEGORY_USB, dc->categories);
2162     dc->desc = "Apple USB Controller";
2163     dc->props = ohci_pci_properties;
2164     dc->hotpluggable = false;
2165     dc->vmsd = &vmstate_ohci;
2166     dc->reset = usb_ohci_reset_pci;
2167 }
2168
2169 static const TypeInfo ohci_pci_info = {
2170     .name          = TYPE_PCI_OHCI,
2171     .parent        = TYPE_PCI_DEVICE,
2172     .instance_size = sizeof(OHCIPCIState),
2173     .class_init    = ohci_pci_class_init,
2174     .interfaces = (InterfaceInfo[]) {
2175         { INTERFACE_CONVENTIONAL_PCI_DEVICE },
2176         { },
2177     },
2178 };
2179
2180 static Property ohci_sysbus_properties[] = {
2181     DEFINE_PROP_STRING("masterbus", OHCISysBusState, masterbus),
2182     DEFINE_PROP_UINT32("num-ports", OHCISysBusState, num_ports, 3),
2183     DEFINE_PROP_UINT32("firstport", OHCISysBusState, firstport, 0),
2184     DEFINE_PROP_DMAADDR("dma-offset", OHCISysBusState, dma_offset, 0),
2185     DEFINE_PROP_END_OF_LIST(),
2186 };
2187
2188 static void ohci_sysbus_class_init(ObjectClass *klass, void *data)
2189 {
2190     DeviceClass *dc = DEVICE_CLASS(klass);
2191
2192     dc->realize = ohci_realize_pxa;
2193     set_bit(DEVICE_CATEGORY_USB, dc->categories);
2194     dc->desc = "OHCI USB Controller";
2195     dc->props = ohci_sysbus_properties;
2196     dc->reset = usb_ohci_reset_sysbus;
2197 }
2198
2199 static const TypeInfo ohci_sysbus_info = {
2200     .name          = TYPE_SYSBUS_OHCI,
2201     .parent        = TYPE_SYS_BUS_DEVICE,
2202     .instance_size = sizeof(OHCISysBusState),
2203     .class_init    = ohci_sysbus_class_init,
2204 };
2205
2206 static void ohci_register_types(void)
2207 {
2208     type_register_static(&ohci_pci_info);
2209     type_register_static(&ohci_sysbus_info);
2210 }
2211
2212 type_init(ohci_register_types)