vcs.maemo.org Git - qemu/blob - hw/usb-uhci.c

   1 /*
   2  * USB UHCI controller emulation
   3  *
   4  * Copyright (c) 2005 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "vl.h"
  25
  26 //#define DEBUG
  27 //#define DEBUG_PACKET
  28 //#define DEBUG_ISOCH
  29
  30 #define UHCI_CMD_FGR      (1 << 4)
  31 #define UHCI_CMD_EGSM     (1 << 3)
  32 #define UHCI_CMD_GRESET   (1 << 2)
  33 #define UHCI_CMD_HCRESET  (1 << 1)
  34 #define UHCI_CMD_RS       (1 << 0)
  35
  36 #define UHCI_STS_HCHALTED (1 << 5)
  37 #define UHCI_STS_HCPERR   (1 << 4)
  38 #define UHCI_STS_HSERR    (1 << 3)
  39 #define UHCI_STS_RD       (1 << 2)
  40 #define UHCI_STS_USBERR   (1 << 1)
  41 #define UHCI_STS_USBINT   (1 << 0)
  42
  43 #define TD_CTRL_SPD     (1 << 29)
  44 #define TD_CTRL_ERROR_SHIFT  27
  45 #define TD_CTRL_IOS     (1 << 25)
  46 #define TD_CTRL_IOC     (1 << 24)
  47 #define TD_CTRL_ACTIVE  (1 << 23)
  48 #define TD_CTRL_STALL   (1 << 22)
  49 #define TD_CTRL_BABBLE  (1 << 20)
  50 #define TD_CTRL_NAK     (1 << 19)
  51 #define TD_CTRL_TIMEOUT (1 << 18)
  52
  53 #define UHCI_PORT_RESET (1 << 9)
  54 #define UHCI_PORT_LSDA  (1 << 8)
  55 #define UHCI_PORT_ENC   (1 << 3)
  56 #define UHCI_PORT_EN    (1 << 2)
  57 #define UHCI_PORT_CSC   (1 << 1)
  58 #define UHCI_PORT_CCS   (1 << 0)
  59
  60 #define FRAME_TIMER_FREQ 1000
  61
  62 #define FRAME_MAX_LOOPS  100
  63
  64 #define NB_PORTS 2
  65
  66 typedef struct UHCIPort {
  67     USBPort port;
  68     uint16_t ctrl;
  69 } UHCIPort;
  70
  71 typedef struct UHCIState {
  72     PCIDevice dev;
  73     uint16_t cmd; /* cmd register */
  74     uint16_t status;
  75     uint16_t intr; /* interrupt enable register */
  76     uint16_t frnum; /* frame number */
  77     uint32_t fl_base_addr; /* frame list base address */
  78     uint8_t sof_timing;
  79     uint8_t status2; /* bit 0 and 1 are used to generate UHCI_STS_USBINT */
  80     QEMUTimer *frame_timer;
  81     UHCIPort ports[NB_PORTS];
  82
  83     /* Interrupts that should be raised at the end of the current frame.  */
  84     uint32_t pending_int_mask;
  85     /* For simplicity of implementation we only allow a single pending USB
  86        request.  This means all usb traffic on this controller is effectively
  87        suspended until that transfer completes.  When the transfer completes
  88        the next transfer from that queue will be processed.  However
  89        other queues will not be processed until the next frame.  The solution
  90        is to allow multiple pending requests.  */
  91     uint32_t async_qh;
  92     uint32_t async_frame_addr;
  93     USBPacket usb_packet;
  94     uint8_t usb_buf[2048];
  95 } UHCIState;
  96
  97 typedef struct UHCI_TD {
  98     uint32_t link;
  99     uint32_t ctrl; /* see TD_CTRL_xxx */
 100     uint32_t token;
 101     uint32_t buffer;
 102 } UHCI_TD;
 103
 104 typedef struct UHCI_QH {
 105     uint32_t link;
 106     uint32_t el_link;
 107 } UHCI_QH;
 108
 109 static void uhci_attach(USBPort *port1, USBDevice *dev);
 110
 111 static void uhci_update_irq(UHCIState *s)
 112 {
 113     int level;
 114     if (((s->status2 & 1) && (s->intr & (1 << 2))) ||
 115         ((s->status2 & 2) && (s->intr & (1 << 3))) ||
 116         ((s->status & UHCI_STS_USBERR) && (s->intr & (1 << 0))) ||
 117         ((s->status & UHCI_STS_RD) && (s->intr & (1 << 1))) ||
 118         (s->status & UHCI_STS_HSERR) ||
 119         (s->status & UHCI_STS_HCPERR)) {
 120         level = 1;
 121     } else {
 122         level = 0;
 123     }
 124     qemu_set_irq(s->dev.irq[3], level);
 125 }
 126
 127 static void uhci_reset(UHCIState *s)
 128 {
 129     uint8_t *pci_conf;
 130     int i;
 131     UHCIPort *port;
 132
 133     pci_conf = s->dev.config;
 134
 135     pci_conf[0x6a] = 0x01; /* usb clock */
 136     pci_conf[0x6b] = 0x00;
 137     s->cmd = 0;
 138     s->status = 0;
 139     s->status2 = 0;
 140     s->intr = 0;
 141     s->fl_base_addr = 0;
 142     s->sof_timing = 64;
 143     for(i = 0; i < NB_PORTS; i++) {
 144         port = &s->ports[i];
 145         port->ctrl = 0x0080;
 146         if (port->port.dev)
 147             uhci_attach(&port->port, port->port.dev);
 148     }
 149 }
 150
 151 static void uhci_save(QEMUFile *f, void *opaque)
 152 {
 153     UHCIState *s = opaque;
 154     uint8_t num_ports = NB_PORTS;
 155     int i;
 156
 157     pci_device_save(&s->dev, f);
 158
 159     qemu_put_8s(f, &num_ports);
 160     for (i = 0; i < num_ports; ++i)
 161         qemu_put_be16s(f, &s->ports[i].ctrl);
 162     qemu_put_be16s(f, &s->cmd);
 163     qemu_put_be16s(f, &s->status);
 164     qemu_put_be16s(f, &s->intr);
 165     qemu_put_be16s(f, &s->frnum);
 166     qemu_put_be32s(f, &s->fl_base_addr);
 167     qemu_put_8s(f, &s->sof_timing);
 168     qemu_put_8s(f, &s->status2);
 169     qemu_put_timer(f, s->frame_timer);
 170 }
 171
 172 static int uhci_load(QEMUFile *f, void *opaque, int version_id)
 173 {
 174     UHCIState *s = opaque;
 175     uint8_t num_ports;
 176     int i, ret;
 177
 178     if (version_id > 1)
 179         return -EINVAL;
 180
 181     ret = pci_device_load(&s->dev, f);
 182     if (ret < 0)
 183         return ret;
 184
 185     qemu_get_8s(f, &num_ports);
 186     if (num_ports != NB_PORTS)
 187         return -EINVAL;
 188
 189     for (i = 0; i < num_ports; ++i)
 190         qemu_get_be16s(f, &s->ports[i].ctrl);
 191     qemu_get_be16s(f, &s->cmd);
 192     qemu_get_be16s(f, &s->status);
 193     qemu_get_be16s(f, &s->intr);
 194     qemu_get_be16s(f, &s->frnum);
 195     qemu_get_be32s(f, &s->fl_base_addr);
 196     qemu_get_8s(f, &s->sof_timing);
 197     qemu_get_8s(f, &s->status2);
 198     qemu_get_timer(f, s->frame_timer);
 199
 200     return 0;
 201 }
 202
 203 static void uhci_ioport_writeb(void *opaque, uint32_t addr, uint32_t val)
 204 {
 205     UHCIState *s = opaque;
 206
 207     addr &= 0x1f;
 208     switch(addr) {
 209     case 0x0c:
 210         s->sof_timing = val;
 211         break;
 212     }
 213 }
 214
 215 static uint32_t uhci_ioport_readb(void *opaque, uint32_t addr)
 216 {
 217     UHCIState *s = opaque;
 218     uint32_t val;
 219
 220     addr &= 0x1f;
 221     switch(addr) {
 222     case 0x0c:
 223         val = s->sof_timing;
 224         break;
 225     default:
 226         val = 0xff;
 227         break;
 228     }
 229     return val;
 230 }
 231
 232 static void uhci_ioport_writew(void *opaque, uint32_t addr, uint32_t val)
 233 {
 234     UHCIState *s = opaque;
 235
 236     addr &= 0x1f;
 237 #ifdef DEBUG
 238     printf("uhci writew port=0x%04x val=0x%04x\n", addr, val);
 239 #endif
 240     switch(addr) {
 241     case 0x00:
 242         if ((val & UHCI_CMD_RS) && !(s->cmd & UHCI_CMD_RS)) {
 243             /* start frame processing */
 244             qemu_mod_timer(s->frame_timer, qemu_get_clock(vm_clock));
 245             s->status &= ~UHCI_STS_HCHALTED;
 246         } else if (!(val & UHCI_CMD_RS)) {
 247             s->status |= UHCI_STS_HCHALTED;
 248         }
 249         if (val & UHCI_CMD_GRESET) {
 250             UHCIPort *port;
 251             USBDevice *dev;
 252             int i;
 253
 254             /* send reset on the USB bus */
 255             for(i = 0; i < NB_PORTS; i++) {
 256                 port = &s->ports[i];
 257                 dev = port->port.dev;
 258                 if (dev) {
 259                     usb_send_msg(dev, USB_MSG_RESET);
 260                 }
 261             }
 262             uhci_reset(s);
 263             return;
 264         }
 265         if (val & UHCI_CMD_HCRESET) {
 266             uhci_reset(s);
 267             return;
 268         }
 269         s->cmd = val;
 270         break;
 271     case 0x02:
 272         s->status &= ~val;
 273         /* XXX: the chip spec is not coherent, so we add a hidden
 274            register to distinguish between IOC and SPD */
 275         if (val & UHCI_STS_USBINT)
 276             s->status2 = 0;
 277         uhci_update_irq(s);
 278         break;
 279     case 0x04:
 280         s->intr = val;
 281         uhci_update_irq(s);
 282         break;
 283     case 0x06:
 284         if (s->status & UHCI_STS_HCHALTED)
 285             s->frnum = val & 0x7ff;
 286         break;
 287     case 0x10 ... 0x1f:
 288         {
 289             UHCIPort *port;
 290             USBDevice *dev;
 291             int n;
 292
 293             n = (addr >> 1) & 7;
 294             if (n >= NB_PORTS)
 295                 return;
 296             port = &s->ports[n];
 297             dev = port->port.dev;
 298             if (dev) {
 299                 /* port reset */
 300                 if ( (val & UHCI_PORT_RESET) &&
 301                      !(port->ctrl & UHCI_PORT_RESET) ) {
 302                     usb_send_msg(dev, USB_MSG_RESET);
 303                 }
 304             }
 305             port->ctrl = (port->ctrl & 0x01fb) | (val & ~0x01fb);
 306             /* some bits are reset when a '1' is written to them */
 307             port->ctrl &= ~(val & 0x000a);
 308         }
 309         break;
 310     }
 311 }
 312
 313 static uint32_t uhci_ioport_readw(void *opaque, uint32_t addr)
 314 {
 315     UHCIState *s = opaque;
 316     uint32_t val;
 317
 318     addr &= 0x1f;
 319     switch(addr) {
 320     case 0x00:
 321         val = s->cmd;
 322         break;
 323     case 0x02:
 324         val = s->status;
 325         break;
 326     case 0x04:
 327         val = s->intr;
 328         break;
 329     case 0x06:
 330         val = s->frnum;
 331         break;
 332     case 0x10 ... 0x1f:
 333         {
 334             UHCIPort *port;
 335             int n;
 336             n = (addr >> 1) & 7;
 337             if (n >= NB_PORTS)
 338                 goto read_default;
 339             port = &s->ports[n];
 340             val = port->ctrl;
 341         }
 342         break;
 343     default:
 344     read_default:
 345         val = 0xff7f; /* disabled port */
 346         break;
 347     }
 348 #ifdef DEBUG
 349     printf("uhci readw port=0x%04x val=0x%04x\n", addr, val);
 350 #endif
 351     return val;
 352 }
 353
 354 static void uhci_ioport_writel(void *opaque, uint32_t addr, uint32_t val)
 355 {
 356     UHCIState *s = opaque;
 357
 358     addr &= 0x1f;
 359 #ifdef DEBUG
 360     printf("uhci writel port=0x%04x val=0x%08x\n", addr, val);
 361 #endif
 362     switch(addr) {
 363     case 0x08:
 364         s->fl_base_addr = val & ~0xfff;
 365         break;
 366     }
 367 }
 368
 369 static uint32_t uhci_ioport_readl(void *opaque, uint32_t addr)
 370 {
 371     UHCIState *s = opaque;
 372     uint32_t val;
 373
 374     addr &= 0x1f;
 375     switch(addr) {
 376     case 0x08:
 377         val = s->fl_base_addr;
 378         break;
 379     default:
 380         val = 0xffffffff;
 381         break;
 382     }
 383     return val;
 384 }
 385
 386 /* signal resume if controller suspended */
 387 static void uhci_resume (void *opaque)
 388 {
 389     UHCIState *s = (UHCIState *)opaque;
 390
 391     if (!s)
 392         return;
 393
 394     if (s->cmd & UHCI_CMD_EGSM) {
 395         s->cmd |= UHCI_CMD_FGR;
 396         s->status |= UHCI_STS_RD;
 397         uhci_update_irq(s);
 398     }
 399 }
 400
 401 static void uhci_attach(USBPort *port1, USBDevice *dev)
 402 {
 403     UHCIState *s = port1->opaque;
 404     UHCIPort *port = &s->ports[port1->index];
 405
 406     if (dev) {
 407         if (port->port.dev) {
 408             usb_attach(port1, NULL);
 409         }
 410         /* set connect status */
 411         port->ctrl |= UHCI_PORT_CCS | UHCI_PORT_CSC;
 412
 413         /* update speed */
 414         if (dev->speed == USB_SPEED_LOW)
 415             port->ctrl |= UHCI_PORT_LSDA;
 416         else
 417             port->ctrl &= ~UHCI_PORT_LSDA;
 418
 419         uhci_resume(s);
 420
 421         port->port.dev = dev;
 422         /* send the attach message */
 423         usb_send_msg(dev, USB_MSG_ATTACH);
 424     } else {
 425         /* set connect status */
 426         if (port->ctrl & UHCI_PORT_CCS) {
 427             port->ctrl &= ~UHCI_PORT_CCS;
 428             port->ctrl |= UHCI_PORT_CSC;
 429         }
 430         /* disable port */
 431         if (port->ctrl & UHCI_PORT_EN) {
 432             port->ctrl &= ~UHCI_PORT_EN;
 433             port->ctrl |= UHCI_PORT_ENC;
 434         }
 435
 436         uhci_resume(s);
 437
 438         dev = port->port.dev;
 439         if (dev) {
 440             /* send the detach message */
 441             usb_send_msg(dev, USB_MSG_DETACH);
 442         }
 443         port->port.dev = NULL;
 444     }
 445 }
 446
 447 static int uhci_broadcast_packet(UHCIState *s, USBPacket *p)
 448 {
 449     UHCIPort *port;
 450     USBDevice *dev;
 451     int i, ret;
 452
 453 #ifdef DEBUG_PACKET
 454     {
 455         const char *pidstr;
 456         switch(p->pid) {
 457         case USB_TOKEN_SETUP: pidstr = "SETUP"; break;
 458         case USB_TOKEN_IN: pidstr = "IN"; break;
 459         case USB_TOKEN_OUT: pidstr = "OUT"; break;
 460         default: pidstr = "?"; break;
 461         }
 462         printf("frame %d: pid=%s addr=0x%02x ep=%d len=%d\n",
 463                s->frnum, pidstr, p->devaddr, p->devep, p->len);
 464         if (p->pid != USB_TOKEN_IN) {
 465             printf("     data_out=");
 466             for(i = 0; i < p->len; i++) {
 467                 printf(" %02x", p->data[i]);
 468             }
 469             printf("\n");
 470         }
 471     }
 472 #endif
 473     for(i = 0; i < NB_PORTS; i++) {
 474         port = &s->ports[i];
 475         dev = port->port.dev;
 476         if (dev && (port->ctrl & UHCI_PORT_EN)) {
 477             ret = dev->handle_packet(dev, p);
 478             if (ret != USB_RET_NODEV) {
 479 #ifdef DEBUG_PACKET
 480                 if (ret == USB_RET_ASYNC) {
 481                     printf("usb-uhci: Async packet\n");
 482                 } else {
 483                     printf("     ret=%d ", ret);
 484                     if (p->pid == USB_TOKEN_IN && ret > 0) {
 485                         printf("data_in=");
 486                         for(i = 0; i < ret; i++) {
 487                             printf(" %02x", p->data[i]);
 488                         }
 489                     }
 490                     printf("\n");
 491                 }
 492 #endif
 493                 return ret;
 494             }
 495         }
 496     }
 497     return USB_RET_NODEV;
 498 }
 499
 500 static void uhci_async_complete_packet(USBPacket * packet, void *opaque);
 501
 502 /* return -1 if fatal error (frame must be stopped)
 503           0 if TD successful
 504           1 if TD unsuccessful or inactive
 505 */
 506 static int uhci_handle_td(UHCIState *s, UHCI_TD *td, int *int_mask,
 507                           int completion)
 508 {
 509     uint8_t pid;
 510     int len = 0, max_len, err, ret = 0;
 511
 512     /* ??? This is wrong for async completion.  */
 513     if (td->ctrl & TD_CTRL_IOC) {
 514         *int_mask |= 0x01;
 515     }
 516
 517     if (!(td->ctrl & TD_CTRL_ACTIVE))
 518         return 1;
 519
 520     /* TD is active */
 521     max_len = ((td->token >> 21) + 1) & 0x7ff;
 522     pid = td->token & 0xff;
 523
 524     if (completion && (s->async_qh || s->async_frame_addr)) {
 525         ret = s->usb_packet.len;
 526         if (ret >= 0) {
 527             len = ret;
 528             if (len > max_len) {
 529                 len = max_len;
 530                 ret = USB_RET_BABBLE;
 531             }
 532             if (len > 0) {
 533                 /* write the data back */
 534                 cpu_physical_memory_write(td->buffer, s->usb_buf, len);
 535             }
 536         } else {
 537             len = 0;
 538         }
 539         s->async_qh = 0;
 540         s->async_frame_addr = 0;
 541     } else if (!completion) {
 542         s->usb_packet.pid = pid;
 543         s->usb_packet.devaddr = (td->token >> 8) & 0x7f;
 544         s->usb_packet.devep = (td->token >> 15) & 0xf;
 545         s->usb_packet.data = s->usb_buf;
 546         s->usb_packet.len = max_len;
 547         s->usb_packet.complete_cb = uhci_async_complete_packet;
 548         s->usb_packet.complete_opaque = s;
 549         switch(pid) {
 550         case USB_TOKEN_OUT:
 551         case USB_TOKEN_SETUP:
 552             cpu_physical_memory_read(td->buffer, s->usb_buf, max_len);
 553             ret = uhci_broadcast_packet(s, &s->usb_packet);
 554             len = max_len;
 555             break;
 556         case USB_TOKEN_IN:
 557             ret = uhci_broadcast_packet(s, &s->usb_packet);
 558             if (ret >= 0) {
 559                 len = ret;
 560                 if (len > max_len) {
 561                     len = max_len;
 562                     ret = USB_RET_BABBLE;
 563                 }
 564                 if (len > 0) {
 565                     /* write the data back */
 566                     cpu_physical_memory_write(td->buffer, s->usb_buf, len);
 567                 }
 568             } else {
 569                 len = 0;
 570             }
 571             break;
 572         default:
 573             /* invalid pid : frame interrupted */
 574             s->status |= UHCI_STS_HCPERR;
 575             uhci_update_irq(s);
 576             return -1;
 577         }
 578     }
 579
 580     if (ret == USB_RET_ASYNC) {
 581         return 2;
 582     }
 583     if (td->ctrl & TD_CTRL_IOS)
 584         td->ctrl &= ~TD_CTRL_ACTIVE;
 585     if (ret >= 0) {
 586         td->ctrl = (td->ctrl & ~0x7ff) | ((len - 1) & 0x7ff);
 587         /* The NAK bit may have been set by a previous frame, so clear it
 588            here.  The docs are somewhat unclear, but win2k relies on this
 589            behavior.  */
 590         td->ctrl &= ~(TD_CTRL_ACTIVE | TD_CTRL_NAK);
 591         if (pid == USB_TOKEN_IN &&
 592             (td->ctrl & TD_CTRL_SPD) &&
 593             len < max_len) {
 594             *int_mask |= 0x02;
 595             /* short packet: do not update QH */
 596             return 1;
 597         } else {
 598             /* success */
 599             return 0;
 600         }
 601     } else {
 602         switch(ret) {
 603         default:
 604         case USB_RET_NODEV:
 605         do_timeout:
 606             td->ctrl |= TD_CTRL_TIMEOUT;
 607             err = (td->ctrl >> TD_CTRL_ERROR_SHIFT) & 3;
 608             if (err != 0) {
 609                 err--;
 610                 if (err == 0) {
 611                     td->ctrl &= ~TD_CTRL_ACTIVE;
 612                     s->status |= UHCI_STS_USBERR;
 613                     uhci_update_irq(s);
 614                 }
 615             }
 616             td->ctrl = (td->ctrl & ~(3 << TD_CTRL_ERROR_SHIFT)) |
 617                 (err << TD_CTRL_ERROR_SHIFT);
 618             return 1;
 619         case USB_RET_NAK:
 620             td->ctrl |= TD_CTRL_NAK;
 621             if (pid == USB_TOKEN_SETUP)
 622                 goto do_timeout;
 623             return 1;
 624         case USB_RET_STALL:
 625             td->ctrl |= TD_CTRL_STALL;
 626             td->ctrl &= ~TD_CTRL_ACTIVE;
 627             return 1;
 628         case USB_RET_BABBLE:
 629             td->ctrl |= TD_CTRL_BABBLE | TD_CTRL_STALL;
 630             td->ctrl &= ~TD_CTRL_ACTIVE;
 631             /* frame interrupted */
 632             return -1;
 633         }
 634     }
 635 }
 636
 637 static void uhci_async_complete_packet(USBPacket * packet, void *opaque)
 638 {
 639     UHCIState *s = opaque;
 640     UHCI_QH qh;
 641     UHCI_TD td;
 642     uint32_t link;
 643     uint32_t old_td_ctrl;
 644     uint32_t val;
 645     uint32_t frame_addr;
 646     int ret;
 647
 648     /* Handle async isochronous packet completion */
 649     frame_addr = s->async_frame_addr;
 650     if (frame_addr) {
 651         cpu_physical_memory_read(frame_addr, (uint8_t *)&link, 4);
 652         le32_to_cpus(&link);
 653
 654         cpu_physical_memory_read(link & ~0xf, (uint8_t *)&td, sizeof(td));
 655         le32_to_cpus(&td.link);
 656         le32_to_cpus(&td.ctrl);
 657         le32_to_cpus(&td.token);
 658         le32_to_cpus(&td.buffer);
 659         old_td_ctrl = td.ctrl;
 660         ret = uhci_handle_td(s, &td, &s->pending_int_mask, 1);
 661
 662         /* update the status bits of the TD */
 663         if (old_td_ctrl != td.ctrl) {
 664             val = cpu_to_le32(td.ctrl);
 665             cpu_physical_memory_write((link & ~0xf) + 4,
 666                                       (const uint8_t *)&val,
 667                                       sizeof(val));
 668         }
 669         if (ret == 2) {
 670             s->async_frame_addr = frame_addr;
 671         } else if (ret == 0) {
 672             /* update qh element link */
 673             val = cpu_to_le32(td.link);
 674             cpu_physical_memory_write(frame_addr,
 675                                       (const uint8_t *)&val,
 676                                       sizeof(val));
 677         }
 678         return;
 679     }
 680
 681     link = s->async_qh;
 682     if (!link) {
 683         /* This should never happen. It means a TD somehow got removed
 684            without cancelling the associated async IO request.  */
 685         return;
 686     }
 687     cpu_physical_memory_read(link & ~0xf, (uint8_t *)&qh, sizeof(qh));
 688     le32_to_cpus(&qh.link);
 689     le32_to_cpus(&qh.el_link);
 690     /* Re-process the queue containing the async packet.  */
 691     while (1) {
 692         cpu_physical_memory_read(qh.el_link & ~0xf,
 693                                  (uint8_t *)&td, sizeof(td));
 694         le32_to_cpus(&td.link);
 695         le32_to_cpus(&td.ctrl);
 696         le32_to_cpus(&td.token);
 697         le32_to_cpus(&td.buffer);
 698         old_td_ctrl = td.ctrl;
 699         ret = uhci_handle_td(s, &td, &s->pending_int_mask, 1);
 700
 701         /* update the status bits of the TD */
 702         if (old_td_ctrl != td.ctrl) {
 703             val = cpu_to_le32(td.ctrl);
 704             cpu_physical_memory_write((qh.el_link & ~0xf) + 4,
 705                                       (const uint8_t *)&val,
 706                                       sizeof(val));
 707         }
 708         if (ret < 0)
 709             break; /* interrupted frame */
 710         if (ret == 2) {
 711             s->async_qh = link;
 712             break;
 713         } else if (ret == 0) {
 714             /* update qh element link */
 715             qh.el_link = td.link;
 716             val = cpu_to_le32(qh.el_link);
 717             cpu_physical_memory_write((link & ~0xf) + 4,
 718                                       (const uint8_t *)&val,
 719                                       sizeof(val));
 720             if (!(qh.el_link & 4))
 721                 break;
 722         }
 723         break;
 724     }
 725 }
 726
 727 static void uhci_frame_timer(void *opaque)
 728 {
 729     UHCIState *s = opaque;
 730     int64_t expire_time;
 731     uint32_t frame_addr, link, old_td_ctrl, val;
 732     int int_mask, cnt, ret;
 733     UHCI_TD td;
 734     UHCI_QH qh;
 735     uint32_t old_async_qh;
 736
 737     if (!(s->cmd & UHCI_CMD_RS)) {
 738         qemu_del_timer(s->frame_timer);
 739         /* set hchalted bit in status - UHCI11D 2.1.2 */
 740         s->status |= UHCI_STS_HCHALTED;
 741         return;
 742     }
 743     /* Complete the previous frame.  */
 744     s->frnum = (s->frnum + 1) & 0x7ff;
 745     if (s->pending_int_mask) {
 746         s->status2 |= s->pending_int_mask;
 747         s->status |= UHCI_STS_USBINT;
 748         uhci_update_irq(s);
 749     }
 750     old_async_qh = s->async_qh;
 751     frame_addr = s->fl_base_addr + ((s->frnum & 0x3ff) << 2);
 752     cpu_physical_memory_read(frame_addr, (uint8_t *)&link, 4);
 753     le32_to_cpus(&link);
 754     int_mask = 0;
 755     cnt = FRAME_MAX_LOOPS;
 756     while ((link & 1) == 0) {
 757         if (--cnt == 0)
 758             break;
 759         /* valid frame */
 760         if (link & 2) {
 761             /* QH */
 762             if (link == s->async_qh) {
 763                 /* We've found a previously issues packet.
 764                    Nothing else to do.  */
 765                 old_async_qh = 0;
 766                 break;
 767             }
 768             cpu_physical_memory_read(link & ~0xf, (uint8_t *)&qh, sizeof(qh));
 769             le32_to_cpus(&qh.link);
 770             le32_to_cpus(&qh.el_link);
 771         depth_first:
 772             if (qh.el_link & 1) {
 773                 /* no element : go to next entry */
 774                 link = qh.link;
 775             } else if (qh.el_link & 2) {
 776                 /* QH */
 777                 link = qh.el_link;
 778             } else if (s->async_qh) {
 779                 /* We can only cope with one pending packet.  Keep looking
 780                    for the previously issued packet.  */
 781                 link = qh.link;
 782             } else {
 783                 /* TD */
 784                 if (--cnt == 0)
 785                     break;
 786                 cpu_physical_memory_read(qh.el_link & ~0xf,
 787                                          (uint8_t *)&td, sizeof(td));
 788                 le32_to_cpus(&td.link);
 789                 le32_to_cpus(&td.ctrl);
 790                 le32_to_cpus(&td.token);
 791                 le32_to_cpus(&td.buffer);
 792                 old_td_ctrl = td.ctrl;
 793                 ret = uhci_handle_td(s, &td, &int_mask, 0);
 794
 795                 /* update the status bits of the TD */
 796                 if (old_td_ctrl != td.ctrl) {
 797                     val = cpu_to_le32(td.ctrl);
 798                     cpu_physical_memory_write((qh.el_link & ~0xf) + 4,
 799                                               (const uint8_t *)&val,
 800                                               sizeof(val));
 801                 }
 802                 if (ret < 0)
 803                     break; /* interrupted frame */
 804                 if (ret == 2) {
 805                     s->async_qh = link;
 806                 } else if (ret == 0) {
 807                     /* update qh element link */
 808                     qh.el_link = td.link;
 809                     val = cpu_to_le32(qh.el_link);
 810                     cpu_physical_memory_write((link & ~0xf) + 4,
 811                                               (const uint8_t *)&val,
 812                                               sizeof(val));
 813                     if (qh.el_link & 4) {
 814                         /* depth first */
 815                         goto depth_first;
 816                     }
 817                 }
 818                 /* go to next entry */
 819                 link = qh.link;
 820             }
 821         } else {
 822             /* TD */
 823             cpu_physical_memory_read(link & ~0xf, (uint8_t *)&td, sizeof(td));
 824             le32_to_cpus(&td.link);
 825             le32_to_cpus(&td.ctrl);
 826             le32_to_cpus(&td.token);
 827             le32_to_cpus(&td.buffer);
 828
 829             /* Handle isochonous transfer.  */
 830             /* FIXME: might be more than one isoc in frame */
 831             old_td_ctrl = td.ctrl;
 832             ret = uhci_handle_td(s, &td, &int_mask, 0);
 833
 834             /* update the status bits of the TD */
 835             if (old_td_ctrl != td.ctrl) {
 836                 val = cpu_to_le32(td.ctrl);
 837                 cpu_physical_memory_write((link & ~0xf) + 4,
 838                                           (const uint8_t *)&val,
 839                                           sizeof(val));
 840             }
 841             if (ret < 0)
 842                 break; /* interrupted frame */
 843             if (ret == 2) {
 844                 s->async_frame_addr = frame_addr;
 845             }
 846             link = td.link;
 847         }
 848     }
 849     s->pending_int_mask = int_mask;
 850     if (old_async_qh) {
 851         /* A previously started transfer has disappeared from the transfer
 852            list.  There's nothing useful we can do with it now, so just
 853            discard the packet and hope it wasn't too important.  */
 854 #ifdef DEBUG
 855         printf("Discarding USB packet\n");
 856 #endif
 857         usb_cancel_packet(&s->usb_packet);
 858         s->async_qh = 0;
 859     }
 860
 861     /* prepare the timer for the next frame */
 862     expire_time = qemu_get_clock(vm_clock) +
 863         (ticks_per_sec / FRAME_TIMER_FREQ);
 864     qemu_mod_timer(s->frame_timer, expire_time);
 865 }
 866
 867 static void uhci_map(PCIDevice *pci_dev, int region_num,
 868                     uint32_t addr, uint32_t size, int type)
 869 {
 870     UHCIState *s = (UHCIState *)pci_dev;
 871
 872     register_ioport_write(addr, 32, 2, uhci_ioport_writew, s);
 873     register_ioport_read(addr, 32, 2, uhci_ioport_readw, s);
 874     register_ioport_write(addr, 32, 4, uhci_ioport_writel, s);
 875     register_ioport_read(addr, 32, 4, uhci_ioport_readl, s);
 876     register_ioport_write(addr, 32, 1, uhci_ioport_writeb, s);
 877     register_ioport_read(addr, 32, 1, uhci_ioport_readb, s);
 878 }
 879
 880 void usb_uhci_piix3_init(PCIBus *bus, int devfn)
 881 {
 882     UHCIState *s;
 883     uint8_t *pci_conf;
 884     int i;
 885
 886     s = (UHCIState *)pci_register_device(bus,
 887                                         "USB-UHCI", sizeof(UHCIState),
 888                                         devfn, NULL, NULL);
 889     pci_conf = s->dev.config;
 890     pci_conf[0x00] = 0x86;
 891     pci_conf[0x01] = 0x80;
 892     pci_conf[0x02] = 0x20;
 893     pci_conf[0x03] = 0x70;
 894     pci_conf[0x08] = 0x01; // revision number
 895     pci_conf[0x09] = 0x00;
 896     pci_conf[0x0a] = 0x03;
 897     pci_conf[0x0b] = 0x0c;
 898     pci_conf[0x0e] = 0x00; // header_type
 899     pci_conf[0x3d] = 4; // interrupt pin 3
 900     pci_conf[0x60] = 0x10; // release number
 901
 902     for(i = 0; i < NB_PORTS; i++) {
 903         qemu_register_usb_port(&s->ports[i].port, s, i, uhci_attach);
 904     }
 905     s->frame_timer = qemu_new_timer(vm_clock, uhci_frame_timer, s);
 906
 907     uhci_reset(s);
 908
 909     /* Use region 4 for consistency with real hardware.  BSD guests seem
 910        to rely on this.  */
 911     pci_register_io_region(&s->dev, 4, 0x20,
 912                            PCI_ADDRESS_SPACE_IO, uhci_map);
 913 }
 914
 915 void usb_uhci_piix4_init(PCIBus *bus, int devfn)
 916 {
 917     UHCIState *s;
 918     uint8_t *pci_conf;
 919     int i;
 920
 921     s = (UHCIState *)pci_register_device(bus,
 922                                         "USB-UHCI", sizeof(UHCIState),
 923                                         devfn, NULL, NULL);
 924     pci_conf = s->dev.config;
 925     pci_conf[0x00] = 0x86;
 926     pci_conf[0x01] = 0x80;
 927     pci_conf[0x02] = 0x12;
 928     pci_conf[0x03] = 0x71;
 929     pci_conf[0x08] = 0x01; // revision number
 930     pci_conf[0x09] = 0x00;
 931     pci_conf[0x0a] = 0x03;
 932     pci_conf[0x0b] = 0x0c;
 933     pci_conf[0x0e] = 0x00; // header_type
 934     pci_conf[0x3d] = 4; // interrupt pin 3
 935     pci_conf[0x60] = 0x10; // release number
 936
 937     for(i = 0; i < NB_PORTS; i++) {
 938         qemu_register_usb_port(&s->ports[i].port, s, i, uhci_attach);
 939     }
 940     s->frame_timer = qemu_new_timer(vm_clock, uhci_frame_timer, s);
 941
 942     uhci_reset(s);
 943
 944     /* Use region 4 for consistency with real hardware.  BSD guests seem
 945        to rely on this.  */
 946     pci_register_io_region(&s->dev, 4, 0x20,
 947                            PCI_ADDRESS_SPACE_IO, uhci_map);
 948 }