hw/ide/ahci.c

   1 /*
   2  * QEMU AHCI Emulation
   3  *
   4  * Copyright (c) 2010 [email protected]
   5  * Copyright (c) 2010 Roland Elek <[email protected]>
   6  * Copyright (c) 2010 Sebastian Herbszt <[email protected]>
   7  * Copyright (c) 2010 Alexander Graf <[email protected]>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  21  *
  22  */
  23
  24 #include "qemu/osdep.h"
  25 #include "hw/hw.h"
  26 #include "hw/pci/msi.h"
  27 #include "hw/pci/pci.h"
  28
  29 #include "qemu/error-report.h"
  30 #include "qemu/log.h"
  31 #include "sysemu/block-backend.h"
  32 #include "sysemu/dma.h"
  33 #include "hw/ide/internal.h"
  34 #include "hw/ide/pci.h"
  35 #include "ahci_internal.h"
  36
  37 #include "trace.h"
  38
  39 static void check_cmd(AHCIState *s, int port);
  40 static int handle_cmd(AHCIState *s, int port, uint8_t slot);
  41 static void ahci_reset_port(AHCIState *s, int port);
  42 static bool ahci_write_fis_d2h(AHCIDevice *ad);
  43 static void ahci_init_d2h(AHCIDevice *ad);
  44 static int ahci_dma_prepare_buf(IDEDMA *dma, int32_t limit);
  45 static bool ahci_map_clb_address(AHCIDevice *ad);
  46 static bool ahci_map_fis_address(AHCIDevice *ad);
  47 static void ahci_unmap_clb_address(AHCIDevice *ad);
  48 static void ahci_unmap_fis_address(AHCIDevice *ad);
  49
  50 __attribute__((__unused__)) /* TODO */
  51 static const char *AHCIHostReg_lookup[AHCI_HOST_REG__COUNT] = {
  52     [AHCI_HOST_REG_CAP]        = "CAP",
  53     [AHCI_HOST_REG_CTL]        = "GHC",
  54     [AHCI_HOST_REG_IRQ_STAT]   = "IS",
  55     [AHCI_HOST_REG_PORTS_IMPL] = "PI",
  56     [AHCI_HOST_REG_VERSION]    = "VS",
  57     [AHCI_HOST_REG_CCC_CTL]    = "CCC_CTL",
  58     [AHCI_HOST_REG_CCC_PORTS]  = "CCC_PORTS",
  59     [AHCI_HOST_REG_EM_LOC]     = "EM_LOC",
  60     [AHCI_HOST_REG_EM_CTL]     = "EM_CTL",
  61     [AHCI_HOST_REG_CAP2]       = "CAP2",
  62     [AHCI_HOST_REG_BOHC]       = "BOHC",
  63 };
  64
  65 static const char *AHCIPortReg_lookup[AHCI_PORT_REG__COUNT] = {
  66     [AHCI_PORT_REG_LST_ADDR]    = "PxCLB",
  67     [AHCI_PORT_REG_LST_ADDR_HI] = "PxCLBU",
  68     [AHCI_PORT_REG_FIS_ADDR]    = "PxFB",
  69     [AHCI_PORT_REG_FIS_ADDR_HI] = "PxFBU",
  70     [AHCI_PORT_REG_IRQ_STAT]    = "PxIS",
  71     [AHCI_PORT_REG_IRQ_MASK]    = "PXIE",
  72     [AHCI_PORT_REG_CMD]         = "PxCMD",
  73     [7]                         = "Reserved",
  74     [AHCI_PORT_REG_TFDATA]      = "PxTFD",
  75     [AHCI_PORT_REG_SIG]         = "PxSIG",
  76     [AHCI_PORT_REG_SCR_STAT]    = "PxSSTS",
  77     [AHCI_PORT_REG_SCR_CTL]     = "PxSCTL",
  78     [AHCI_PORT_REG_SCR_ERR]     = "PxSERR",
  79     [AHCI_PORT_REG_SCR_ACT]     = "PxSACT",
  80     [AHCI_PORT_REG_CMD_ISSUE]   = "PxCI",
  81     [AHCI_PORT_REG_SCR_NOTIF]   = "PxSNTF",
  82     [AHCI_PORT_REG_FIS_CTL]     = "PxFBS",
  83     [AHCI_PORT_REG_DEV_SLEEP]   = "PxDEVSLP",
  84     [18 ... 27]                 = "Reserved",
  85     [AHCI_PORT_REG_VENDOR_1 ...
  86      AHCI_PORT_REG_VENDOR_4]    = "PxVS",
  87 };
  88
  89 static const char *AHCIPortIRQ_lookup[AHCI_PORT_IRQ__COUNT] = {
  90     [AHCI_PORT_IRQ_BIT_DHRS] = "DHRS",
  91     [AHCI_PORT_IRQ_BIT_PSS]  = "PSS",
  92     [AHCI_PORT_IRQ_BIT_DSS]  = "DSS",
  93     [AHCI_PORT_IRQ_BIT_SDBS] = "SDBS",
  94     [AHCI_PORT_IRQ_BIT_UFS]  = "UFS",
  95     [AHCI_PORT_IRQ_BIT_DPS]  = "DPS",
  96     [AHCI_PORT_IRQ_BIT_PCS]  = "PCS",
  97     [AHCI_PORT_IRQ_BIT_DMPS] = "DMPS",
  98     [8 ... 21]               = "RESERVED",
  99     [AHCI_PORT_IRQ_BIT_PRCS] = "PRCS",
 100     [AHCI_PORT_IRQ_BIT_IPMS] = "IPMS",
 101     [AHCI_PORT_IRQ_BIT_OFS]  = "OFS",
 102     [25]                     = "RESERVED",
 103     [AHCI_PORT_IRQ_BIT_INFS] = "INFS",
 104     [AHCI_PORT_IRQ_BIT_IFS]  = "IFS",
 105     [AHCI_PORT_IRQ_BIT_HBDS] = "HBDS",
 106     [AHCI_PORT_IRQ_BIT_HBFS] = "HBFS",
 107     [AHCI_PORT_IRQ_BIT_TFES] = "TFES",
 108     [AHCI_PORT_IRQ_BIT_CPDS] = "CPDS"
 109 };
 110
 111 static uint32_t ahci_port_read(AHCIState *s, int port, int offset)
 112 {
 113     uint32_t val;
 114     AHCIPortRegs *pr = &s->dev[port].port_regs;
 115     enum AHCIPortReg regnum = offset / sizeof(uint32_t);
 116     assert(regnum < (AHCI_PORT_ADDR_OFFSET_LEN / sizeof(uint32_t)));
 117
 118     switch (regnum) {
 119     case AHCI_PORT_REG_LST_ADDR:
 120         val = pr->lst_addr;
 121         break;
 122     case AHCI_PORT_REG_LST_ADDR_HI:
 123         val = pr->lst_addr_hi;
 124         break;
 125     case AHCI_PORT_REG_FIS_ADDR:
 126         val = pr->fis_addr;
 127         break;
 128     case AHCI_PORT_REG_FIS_ADDR_HI:
 129         val = pr->fis_addr_hi;
 130         break;
 131     case AHCI_PORT_REG_IRQ_STAT:
 132         val = pr->irq_stat;
 133         break;
 134     case AHCI_PORT_REG_IRQ_MASK:
 135         val = pr->irq_mask;
 136         break;
 137     case AHCI_PORT_REG_CMD:
 138         val = pr->cmd;
 139         break;
 140     case AHCI_PORT_REG_TFDATA:
 141         val = pr->tfdata;
 142         break;
 143     case AHCI_PORT_REG_SIG:
 144         val = pr->sig;
 145         break;
 146     case AHCI_PORT_REG_SCR_STAT:
 147         if (s->dev[port].port.ifs[0].blk) {
 148             val = SATA_SCR_SSTATUS_DET_DEV_PRESENT_PHY_UP |
 149                   SATA_SCR_SSTATUS_SPD_GEN1 | SATA_SCR_SSTATUS_IPM_ACTIVE;
 150         } else {
 151             val = SATA_SCR_SSTATUS_DET_NODEV;
 152         }
 153         break;
 154     case AHCI_PORT_REG_SCR_CTL:
 155         val = pr->scr_ctl;
 156         break;
 157     case AHCI_PORT_REG_SCR_ERR:
 158         val = pr->scr_err;
 159         break;
 160     case AHCI_PORT_REG_SCR_ACT:
 161         val = pr->scr_act;
 162         break;
 163     case AHCI_PORT_REG_CMD_ISSUE:
 164         val = pr->cmd_issue;
 165         break;
 166     default:
 167         trace_ahci_port_read_default(s, port, AHCIPortReg_lookup[regnum],
 168                                      offset);
 169         val = 0;
 170     }
 171
 172     trace_ahci_port_read(s, port, AHCIPortReg_lookup[regnum], offset, val);
 173     return val;
 174 }
 175
 176 static void ahci_irq_raise(AHCIState *s)
 177 {
 178     DeviceState *dev_state = s->container;
 179     PCIDevice *pci_dev = (PCIDevice *) object_dynamic_cast(OBJECT(dev_state),
 180                                                            TYPE_PCI_DEVICE);
 181
 182     trace_ahci_irq_raise(s);
 183
 184     if (pci_dev && msi_enabled(pci_dev)) {
 185         msi_notify(pci_dev, 0);
 186     } else {
 187         qemu_irq_raise(s->irq);
 188     }
 189 }
 190
 191 static void ahci_irq_lower(AHCIState *s)
 192 {
 193     DeviceState *dev_state = s->container;
 194     PCIDevice *pci_dev = (PCIDevice *) object_dynamic_cast(OBJECT(dev_state),
 195                                                            TYPE_PCI_DEVICE);
 196
 197     trace_ahci_irq_lower(s);
 198
 199     if (!pci_dev || !msi_enabled(pci_dev)) {
 200         qemu_irq_lower(s->irq);
 201     }
 202 }
 203
 204 static void ahci_check_irq(AHCIState *s)
 205 {
 206     int i;
 207     uint32_t old_irq = s->control_regs.irqstatus;
 208
 209     s->control_regs.irqstatus = 0;
 210     for (i = 0; i < s->ports; i++) {
 211         AHCIPortRegs *pr = &s->dev[i].port_regs;
 212         if (pr->irq_stat & pr->irq_mask) {
 213             s->control_regs.irqstatus |= (1 << i);
 214         }
 215     }
 216     trace_ahci_check_irq(s, old_irq, s->control_regs.irqstatus);
 217     if (s->control_regs.irqstatus &&
 218         (s->control_regs.ghc & HOST_CTL_IRQ_EN)) {
 219             ahci_irq_raise(s);
 220     } else {
 221         ahci_irq_lower(s);
 222     }
 223 }
 224
 225 static void ahci_trigger_irq(AHCIState *s, AHCIDevice *d,
 226                              enum AHCIPortIRQ irqbit)
 227 {
 228     g_assert((unsigned)irqbit < 32);
 229     uint32_t irq = 1U << irqbit;
 230     uint32_t irqstat = d->port_regs.irq_stat | irq;
 231
 232     trace_ahci_trigger_irq(s, d->port_no,
 233                            AHCIPortIRQ_lookup[irqbit], irq,
 234                            d->port_regs.irq_stat, irqstat,
 235                            irqstat & d->port_regs.irq_mask);
 236
 237     d->port_regs.irq_stat = irqstat;
 238     ahci_check_irq(s);
 239 }
 240
 241 static void map_page(AddressSpace *as, uint8_t **ptr, uint64_t addr,
 242                      uint32_t wanted)
 243 {
 244     hwaddr len = wanted;
 245
 246     if (*ptr) {
 247         dma_memory_unmap(as, *ptr, len, DMA_DIRECTION_FROM_DEVICE, len);
 248     }
 249
 250     *ptr = dma_memory_map(as, addr, &len, DMA_DIRECTION_FROM_DEVICE);
 251     if (len < wanted) {
 252         dma_memory_unmap(as, *ptr, len, DMA_DIRECTION_FROM_DEVICE, len);
 253         *ptr = NULL;
 254     }
 255 }
 256
 257 /**
 258  * Check the cmd register to see if we should start or stop
 259  * the DMA or FIS RX engines.
 260  *
 261  * @ad: Device to dis/engage.
 262  *
 263  * @return 0 on success, -1 on error.
 264  */
 265 static int ahci_cond_start_engines(AHCIDevice *ad)
 266 {
 267     AHCIPortRegs *pr = &ad->port_regs;
 268     bool cmd_start = pr->cmd & PORT_CMD_START;
 269     bool cmd_on    = pr->cmd & PORT_CMD_LIST_ON;
 270     bool fis_start = pr->cmd & PORT_CMD_FIS_RX;
 271     bool fis_on    = pr->cmd & PORT_CMD_FIS_ON;
 272
 273     if (cmd_start && !cmd_on) {
 274         if (!ahci_map_clb_address(ad)) {
 275             pr->cmd &= ~PORT_CMD_START;
 276             error_report("AHCI: Failed to start DMA engine: "
 277                          "bad command list buffer address");
 278             return -1;
 279         }
 280     } else if (!cmd_start && cmd_on) {
 281         ahci_unmap_clb_address(ad);
 282     }
 283
 284     if (fis_start && !fis_on) {
 285         if (!ahci_map_fis_address(ad)) {
 286             pr->cmd &= ~PORT_CMD_FIS_RX;
 287             error_report("AHCI: Failed to start FIS receive engine: "
 288                          "bad FIS receive buffer address");
 289             return -1;
 290         }
 291     } else if (!fis_start && fis_on) {
 292         ahci_unmap_fis_address(ad);
 293     }
 294
 295     return 0;
 296 }
 297
 298 static void ahci_port_write(AHCIState *s, int port, int offset, uint32_t val)
 299 {
 300     AHCIPortRegs *pr = &s->dev[port].port_regs;
 301     enum AHCIPortReg regnum = offset / sizeof(uint32_t);
 302     assert(regnum < (AHCI_PORT_ADDR_OFFSET_LEN / sizeof(uint32_t)));
 303     trace_ahci_port_write(s, port, AHCIPortReg_lookup[regnum], offset, val);
 304
 305     switch (regnum) {
 306     case AHCI_PORT_REG_LST_ADDR:
 307         pr->lst_addr = val;
 308         break;
 309     case AHCI_PORT_REG_LST_ADDR_HI:
 310         pr->lst_addr_hi = val;
 311         break;
 312     case AHCI_PORT_REG_FIS_ADDR:
 313         pr->fis_addr = val;
 314         break;
 315     case AHCI_PORT_REG_FIS_ADDR_HI:
 316         pr->fis_addr_hi = val;
 317         break;
 318     case AHCI_PORT_REG_IRQ_STAT:
 319         pr->irq_stat &= ~val;
 320         ahci_check_irq(s);
 321         break;
 322     case AHCI_PORT_REG_IRQ_MASK:
 323         pr->irq_mask = val & 0xfdc000ff;
 324         ahci_check_irq(s);
 325         break;
 326     case AHCI_PORT_REG_CMD:
 327         /* Block any Read-only fields from being set;
 328          * including LIST_ON and FIS_ON.
 329          * The spec requires to set ICC bits to zero after the ICC change
 330          * is done. We don't support ICC state changes, therefore always
 331          * force the ICC bits to zero.
 332          */
 333         pr->cmd = (pr->cmd & PORT_CMD_RO_MASK) |
 334             (val & ~(PORT_CMD_RO_MASK | PORT_CMD_ICC_MASK));
 335
 336         /* Check FIS RX and CLB engines */
 337         ahci_cond_start_engines(&s->dev[port]);
 338
 339         /* XXX usually the FIS would be pending on the bus here and
 340            issuing deferred until the OS enables FIS receival.
 341            Instead, we only submit it once - which works in most
 342            cases, but is a hack. */
 343         if ((pr->cmd & PORT_CMD_FIS_ON) &&
 344             !s->dev[port].init_d2h_sent) {
 345             ahci_init_d2h(&s->dev[port]);
 346         }
 347
 348         check_cmd(s, port);
 349         break;
 350     case AHCI_PORT_REG_TFDATA:
 351     case AHCI_PORT_REG_SIG:
 352     case AHCI_PORT_REG_SCR_STAT:
 353         /* Read Only */
 354         break;
 355     case AHCI_PORT_REG_SCR_CTL:
 356         if (((pr->scr_ctl & AHCI_SCR_SCTL_DET) == 1) &&
 357             ((val & AHCI_SCR_SCTL_DET) == 0)) {
 358             ahci_reset_port(s, port);
 359         }
 360         pr->scr_ctl = val;
 361         break;
 362     case AHCI_PORT_REG_SCR_ERR:
 363         pr->scr_err &= ~val;
 364         break;
 365     case AHCI_PORT_REG_SCR_ACT:
 366         /* RW1 */
 367         pr->scr_act |= val;
 368         break;
 369     case AHCI_PORT_REG_CMD_ISSUE:
 370         pr->cmd_issue |= val;
 371         check_cmd(s, port);
 372         break;
 373     default:
 374         trace_ahci_port_write_unimpl(s, port, AHCIPortReg_lookup[regnum],
 375                                      offset, val);
 376         qemu_log_mask(LOG_UNIMP, "Attempted write to unimplemented register: "
 377                       "AHCI port %d register %s, offset 0x%x: 0x%"PRIx32,
 378                       port, AHCIPortReg_lookup[regnum], offset, val);
 379         break;
 380     }
 381 }
 382
 383 static uint64_t ahci_mem_read_32(void *opaque, hwaddr addr)
 384 {
 385     AHCIState *s = opaque;
 386     uint32_t val = 0;
 387
 388     if (addr < AHCI_GENERIC_HOST_CONTROL_REGS_MAX_ADDR) {
 389         enum AHCIHostReg regnum = addr / 4;
 390         assert(regnum < AHCI_HOST_REG__COUNT);
 391
 392         switch (regnum) {
 393         case AHCI_HOST_REG_CAP:
 394             val = s->control_regs.cap;
 395             break;
 396         case AHCI_HOST_REG_CTL:
 397             val = s->control_regs.ghc;
 398             break;
 399         case AHCI_HOST_REG_IRQ_STAT:
 400             val = s->control_regs.irqstatus;
 401             break;
 402         case AHCI_HOST_REG_PORTS_IMPL:
 403             val = s->control_regs.impl;
 404             break;
 405         case AHCI_HOST_REG_VERSION:
 406             val = s->control_regs.version;
 407             break;
 408         default:
 409             break;
 410         }
 411     } else if ((addr >= AHCI_PORT_REGS_START_ADDR) &&
 412                (addr < (AHCI_PORT_REGS_START_ADDR +
 413                 (s->ports * AHCI_PORT_ADDR_OFFSET_LEN)))) {
 414         val = ahci_port_read(s, (addr - AHCI_PORT_REGS_START_ADDR) >> 7,
 415                              addr & AHCI_PORT_ADDR_OFFSET_MASK);
 416     }
 417
 418     trace_ahci_mem_read_32(s, addr, val);
 419     return val;
 420 }
 421
 422
 423 /**
 424  * AHCI 1.3 section 3 ("HBA Memory Registers")
 425  * Support unaligned 8/16/32 bit reads, and 64 bit aligned reads.
 426  * Caller is responsible for masking unwanted higher order bytes.
 427  */
 428 static uint64_t ahci_mem_read(void *opaque, hwaddr addr, unsigned size)
 429 {
 430     hwaddr aligned = addr & ~0x3;
 431     int ofst = addr - aligned;
 432     uint64_t lo = ahci_mem_read_32(opaque, aligned);
 433     uint64_t hi;
 434     uint64_t val;
 435
 436     /* if < 8 byte read does not cross 4 byte boundary */
 437     if (ofst + size <= 4) {
 438         val = lo >> (ofst * 8);
 439     } else {
 440         g_assert_cmpint(size, >, 1);
 441
 442         /* If the 64bit read is unaligned, we will produce undefined
 443          * results. AHCI does not support unaligned 64bit reads. */
 444         hi = ahci_mem_read_32(opaque, aligned + 4);
 445         val = (hi << 32 | lo) >> (ofst * 8);
 446     }
 447
 448     trace_ahci_mem_read(opaque, size, addr, val);
 449     return val;
 450 }
 451
 452
 453 static void ahci_mem_write(void *opaque, hwaddr addr,
 454                            uint64_t val, unsigned size)
 455 {
 456     AHCIState *s = opaque;
 457
 458     trace_ahci_mem_write(s, size, addr, val);
 459
 460     /* Only aligned reads are allowed on AHCI */
 461     if (addr & 3) {
 462         fprintf(stderr, "ahci: Mis-aligned write to addr 0x"
 463                 TARGET_FMT_plx "\n", addr);
 464         return;
 465     }
 466
 467     if (addr < AHCI_GENERIC_HOST_CONTROL_REGS_MAX_ADDR) {
 468         switch (addr) {
 469             case HOST_CAP: /* R/WO, RO */
 470                 /* FIXME handle R/WO */
 471                 break;
 472             case HOST_CTL: /* R/W */
 473                 if (val & HOST_CTL_RESET) {
 474                     ahci_reset(s);
 475                 } else {
 476                     s->control_regs.ghc = (val & 0x3) | HOST_CTL_AHCI_EN;
 477                     ahci_check_irq(s);
 478                 }
 479                 break;
 480             case HOST_IRQ_STAT: /* R/WC, RO */
 481                 s->control_regs.irqstatus &= ~val;
 482                 ahci_check_irq(s);
 483                 break;
 484             case HOST_PORTS_IMPL: /* R/WO, RO */
 485                 /* FIXME handle R/WO */
 486                 break;
 487             case HOST_VERSION: /* RO */
 488                 /* FIXME report write? */
 489                 break;
 490             default:
 491                 trace_ahci_mem_write_unknown(s, size, addr, val);
 492         }
 493     } else if ((addr >= AHCI_PORT_REGS_START_ADDR) &&
 494                (addr < (AHCI_PORT_REGS_START_ADDR +
 495                 (s->ports * AHCI_PORT_ADDR_OFFSET_LEN)))) {
 496         ahci_port_write(s, (addr - AHCI_PORT_REGS_START_ADDR) >> 7,
 497                         addr & AHCI_PORT_ADDR_OFFSET_MASK, val);
 498     }
 499
 500 }
 501
 502 static const MemoryRegionOps ahci_mem_ops = {
 503     .read = ahci_mem_read,
 504     .write = ahci_mem_write,
 505     .endianness = DEVICE_LITTLE_ENDIAN,
 506 };
 507
 508 static uint64_t ahci_idp_read(void *opaque, hwaddr addr,
 509                               unsigned size)
 510 {
 511     AHCIState *s = opaque;
 512
 513     if (addr == s->idp_offset) {
 514         /* index register */
 515         return s->idp_index;
 516     } else if (addr == s->idp_offset + 4) {
 517         /* data register - do memory read at location selected by index */
 518         return ahci_mem_read(opaque, s->idp_index, size);
 519     } else {
 520         return 0;
 521     }
 522 }
 523
 524 static void ahci_idp_write(void *opaque, hwaddr addr,
 525                            uint64_t val, unsigned size)
 526 {
 527     AHCIState *s = opaque;
 528
 529     if (addr == s->idp_offset) {
 530         /* index register - mask off reserved bits */
 531         s->idp_index = (uint32_t)val & ((AHCI_MEM_BAR_SIZE - 1) & ~3);
 532     } else if (addr == s->idp_offset + 4) {
 533         /* data register - do memory write at location selected by index */
 534         ahci_mem_write(opaque, s->idp_index, val, size);
 535     }
 536 }
 537
 538 static const MemoryRegionOps ahci_idp_ops = {
 539     .read = ahci_idp_read,
 540     .write = ahci_idp_write,
 541     .endianness = DEVICE_LITTLE_ENDIAN,
 542 };
 543
 544
 545 static void ahci_reg_init(AHCIState *s)
 546 {
 547     int i;
 548
 549     s->control_regs.cap = (s->ports - 1) |
 550                           (AHCI_NUM_COMMAND_SLOTS << 8) |
 551                           (AHCI_SUPPORTED_SPEED_GEN1 << AHCI_SUPPORTED_SPEED) |
 552                           HOST_CAP_NCQ | HOST_CAP_AHCI | HOST_CAP_64;
 553
 554     s->control_regs.impl = (1 << s->ports) - 1;
 555
 556     s->control_regs.version = AHCI_VERSION_1_0;
 557
 558     for (i = 0; i < s->ports; i++) {
 559         s->dev[i].port_state = STATE_RUN;
 560     }
 561 }
 562
 563 static void check_cmd(AHCIState *s, int port)
 564 {
 565     AHCIPortRegs *pr = &s->dev[port].port_regs;
 566     uint8_t slot;
 567
 568     if ((pr->cmd & PORT_CMD_START) && pr->cmd_issue) {
 569         for (slot = 0; (slot < 32) && pr->cmd_issue; slot++) {
 570             if ((pr->cmd_issue & (1U << slot)) &&
 571                 !handle_cmd(s, port, slot)) {
 572                 pr->cmd_issue &= ~(1U << slot);
 573             }
 574         }
 575     }
 576 }
 577
 578 static void ahci_check_cmd_bh(void *opaque)
 579 {
 580     AHCIDevice *ad = opaque;
 581
 582     qemu_bh_delete(ad->check_bh);
 583     ad->check_bh = NULL;
 584
 585     check_cmd(ad->hba, ad->port_no);
 586 }
 587
 588 static void ahci_init_d2h(AHCIDevice *ad)
 589 {
 590     IDEState *ide_state = &ad->port.ifs[0];
 591     AHCIPortRegs *pr = &ad->port_regs;
 592
 593     if (ad->init_d2h_sent) {
 594         return;
 595     }
 596
 597     if (ahci_write_fis_d2h(ad)) {
 598         ad->init_d2h_sent = true;
 599         /* We're emulating receiving the first Reg H2D Fis from the device;
 600          * Update the SIG register, but otherwise proceed as normal. */
 601         pr->sig = ((uint32_t)ide_state->hcyl << 24) |
 602             (ide_state->lcyl << 16) |
 603             (ide_state->sector << 8) |
 604             (ide_state->nsector & 0xFF);
 605     }
 606 }
 607
 608 static void ahci_set_signature(AHCIDevice *ad, uint32_t sig)
 609 {
 610     IDEState *s = &ad->port.ifs[0];
 611     s->hcyl = sig >> 24 & 0xFF;
 612     s->lcyl = sig >> 16 & 0xFF;
 613     s->sector = sig >> 8 & 0xFF;
 614     s->nsector = sig & 0xFF;
 615
 616     trace_ahci_set_signature(ad->hba, ad->port_no, s->nsector, s->sector,
 617                              s->lcyl, s->hcyl, sig);
 618 }
 619
 620 static void ahci_reset_port(AHCIState *s, int port)
 621 {
 622     AHCIDevice *d = &s->dev[port];
 623     AHCIPortRegs *pr = &d->port_regs;
 624     IDEState *ide_state = &d->port.ifs[0];
 625     int i;
 626
 627     trace_ahci_reset_port(s, port);
 628
 629     ide_bus_reset(&d->port);
 630     ide_state->ncq_queues = AHCI_MAX_CMDS;
 631
 632     pr->scr_stat = 0;
 633     pr->scr_err = 0;
 634     pr->scr_act = 0;
 635     pr->tfdata = 0x7F;
 636     pr->sig = 0xFFFFFFFF;
 637     d->busy_slot = -1;
 638     d->init_d2h_sent = false;
 639
 640     ide_state = &s->dev[port].port.ifs[0];
 641     if (!ide_state->blk) {
 642         return;
 643     }
 644
 645     /* reset ncq queue */
 646     for (i = 0; i < AHCI_MAX_CMDS; i++) {
 647         NCQTransferState *ncq_tfs = &s->dev[port].ncq_tfs[i];
 648         ncq_tfs->halt = false;
 649         if (!ncq_tfs->used) {
 650             continue;
 651         }
 652
 653         if (ncq_tfs->aiocb) {
 654             blk_aio_cancel(ncq_tfs->aiocb);
 655             ncq_tfs->aiocb = NULL;
 656         }
 657
 658         /* Maybe we just finished the request thanks to blk_aio_cancel() */
 659         if (!ncq_tfs->used) {
 660             continue;
 661         }
 662
 663         qemu_sglist_destroy(&ncq_tfs->sglist);
 664         ncq_tfs->used = 0;
 665     }
 666
 667     s->dev[port].port_state = STATE_RUN;
 668     if (ide_state->drive_kind == IDE_CD) {
 669         ahci_set_signature(d, SATA_SIGNATURE_CDROM);\
 670         ide_state->status = SEEK_STAT | WRERR_STAT | READY_STAT;
 671     } else {
 672         ahci_set_signature(d, SATA_SIGNATURE_DISK);
 673         ide_state->status = SEEK_STAT | WRERR_STAT;
 674     }
 675
 676     ide_state->error = 1;
 677     ahci_init_d2h(d);
 678 }
 679
 680 /* Buffer pretty output based on a raw FIS structure. */
 681 static char *ahci_pretty_buffer_fis(uint8_t *fis, int cmd_len)
 682 {
 683     int i;
 684     GString *s = g_string_new("FIS:");
 685
 686     for (i = 0; i < cmd_len; i++) {
 687         if ((i & 0xf) == 0) {
 688             g_string_append_printf(s, "\n0x%02x: ", i);
 689         }
 690         g_string_append_printf(s, "%02x ", fis[i]);
 691     }
 692     g_string_append_c(s, '\n');
 693
 694     return g_string_free(s, FALSE);
 695 }
 696
 697 static bool ahci_map_fis_address(AHCIDevice *ad)
 698 {
 699     AHCIPortRegs *pr = &ad->port_regs;
 700     map_page(ad->hba->as, &ad->res_fis,
 701              ((uint64_t)pr->fis_addr_hi << 32) | pr->fis_addr, 256);
 702     if (ad->res_fis != NULL) {
 703         pr->cmd |= PORT_CMD_FIS_ON;
 704         return true;
 705     }
 706
 707     pr->cmd &= ~PORT_CMD_FIS_ON;
 708     return false;
 709 }
 710
 711 static void ahci_unmap_fis_address(AHCIDevice *ad)
 712 {
 713     if (ad->res_fis == NULL) {
 714         trace_ahci_unmap_fis_address_null(ad->hba, ad->port_no);
 715         return;
 716     }
 717     ad->port_regs.cmd &= ~PORT_CMD_FIS_ON;
 718     dma_memory_unmap(ad->hba->as, ad->res_fis, 256,
 719                      DMA_DIRECTION_FROM_DEVICE, 256);
 720     ad->res_fis = NULL;
 721 }
 722
 723 static bool ahci_map_clb_address(AHCIDevice *ad)
 724 {
 725     AHCIPortRegs *pr = &ad->port_regs;
 726     ad->cur_cmd = NULL;
 727     map_page(ad->hba->as, &ad->lst,
 728              ((uint64_t)pr->lst_addr_hi << 32) | pr->lst_addr, 1024);
 729     if (ad->lst != NULL) {
 730         pr->cmd |= PORT_CMD_LIST_ON;
 731         return true;
 732     }
 733
 734     pr->cmd &= ~PORT_CMD_LIST_ON;
 735     return false;
 736 }
 737
 738 static void ahci_unmap_clb_address(AHCIDevice *ad)
 739 {
 740     if (ad->lst == NULL) {
 741         trace_ahci_unmap_clb_address_null(ad->hba, ad->port_no);
 742         return;
 743     }
 744     ad->port_regs.cmd &= ~PORT_CMD_LIST_ON;
 745     dma_memory_unmap(ad->hba->as, ad->lst, 1024,
 746                      DMA_DIRECTION_FROM_DEVICE, 1024);
 747     ad->lst = NULL;
 748 }
 749
 750 static void ahci_write_fis_sdb(AHCIState *s, NCQTransferState *ncq_tfs)
 751 {
 752     AHCIDevice *ad = ncq_tfs->drive;
 753     AHCIPortRegs *pr = &ad->port_regs;
 754     IDEState *ide_state;
 755     SDBFIS *sdb_fis;
 756
 757     if (!ad->res_fis ||
 758         !(pr->cmd & PORT_CMD_FIS_RX)) {
 759         return;
 760     }
 761
 762     sdb_fis = (SDBFIS *)&ad->res_fis[RES_FIS_SDBFIS];
 763     ide_state = &ad->port.ifs[0];
 764
 765     sdb_fis->type = SATA_FIS_TYPE_SDB;
 766     /* Interrupt pending & Notification bit */
 767     sdb_fis->flags = 0x40; /* Interrupt bit, always 1 for NCQ */
 768     sdb_fis->status = ide_state->status & 0x77;
 769     sdb_fis->error = ide_state->error;
 770     /* update SAct field in SDB_FIS */
 771     sdb_fis->payload = cpu_to_le32(ad->finished);
 772
 773     /* Update shadow registers (except BSY 0x80 and DRQ 0x08) */
 774     pr->tfdata = (ad->port.ifs[0].error << 8) |
 775         (ad->port.ifs[0].status & 0x77) |
 776         (pr->tfdata & 0x88);
 777     pr->scr_act &= ~ad->finished;
 778     ad->finished = 0;
 779
 780     /* Trigger IRQ if interrupt bit is set (which currently, it always is) */
 781     if (sdb_fis->flags & 0x40) {
 782         ahci_trigger_irq(s, ad, AHCI_PORT_IRQ_BIT_SDBS);
 783     }
 784 }
 785
 786 static void ahci_write_fis_pio(AHCIDevice *ad, uint16_t len)
 787 {
 788     AHCIPortRegs *pr = &ad->port_regs;
 789     uint8_t *pio_fis;
 790     IDEState *s = &ad->port.ifs[0];
 791
 792     if (!ad->res_fis || !(pr->cmd & PORT_CMD_FIS_RX)) {
 793         return;
 794     }
 795
 796     pio_fis = &ad->res_fis[RES_FIS_PSFIS];
 797
 798     pio_fis[0] = SATA_FIS_TYPE_PIO_SETUP;
 799     pio_fis[1] = (ad->hba->control_regs.irqstatus ? (1 << 6) : 0);
 800     pio_fis[2] = s->status;
 801     pio_fis[3] = s->error;
 802
 803     pio_fis[4] = s->sector;
 804     pio_fis[5] = s->lcyl;
 805     pio_fis[6] = s->hcyl;
 806     pio_fis[7] = s->select;
 807     pio_fis[8] = s->hob_sector;
 808     pio_fis[9] = s->hob_lcyl;
 809     pio_fis[10] = s->hob_hcyl;
 810     pio_fis[11] = 0;
 811     pio_fis[12] = s->nsector & 0xFF;
 812     pio_fis[13] = (s->nsector >> 8) & 0xFF;
 813     pio_fis[14] = 0;
 814     pio_fis[15] = s->status;
 815     pio_fis[16] = len & 255;
 816     pio_fis[17] = len >> 8;
 817     pio_fis[18] = 0;
 818     pio_fis[19] = 0;
 819
 820     /* Update shadow registers: */
 821     pr->tfdata = (ad->port.ifs[0].error << 8) |
 822         ad->port.ifs[0].status;
 823
 824     if (pio_fis[2] & ERR_STAT) {
 825         ahci_trigger_irq(ad->hba, ad, AHCI_PORT_IRQ_BIT_TFES);
 826     }
 827
 828     ahci_trigger_irq(ad->hba, ad, AHCI_PORT_IRQ_BIT_PSS);
 829 }
 830
 831 static bool ahci_write_fis_d2h(AHCIDevice *ad)
 832 {
 833     AHCIPortRegs *pr = &ad->port_regs;
 834     uint8_t *d2h_fis;
 835     int i;
 836     IDEState *s = &ad->port.ifs[0];
 837
 838     if (!ad->res_fis || !(pr->cmd & PORT_CMD_FIS_RX)) {
 839         return false;
 840     }
 841
 842     d2h_fis = &ad->res_fis[RES_FIS_RFIS];
 843
 844     d2h_fis[0] = SATA_FIS_TYPE_REGISTER_D2H;
 845     d2h_fis[1] = (ad->hba->control_regs.irqstatus ? (1 << 6) : 0);
 846     d2h_fis[2] = s->status;
 847     d2h_fis[3] = s->error;
 848
 849     d2h_fis[4] = s->sector;
 850     d2h_fis[5] = s->lcyl;
 851     d2h_fis[6] = s->hcyl;
 852     d2h_fis[7] = s->select;
 853     d2h_fis[8] = s->hob_sector;
 854     d2h_fis[9] = s->hob_lcyl;
 855     d2h_fis[10] = s->hob_hcyl;
 856     d2h_fis[11] = 0;
 857     d2h_fis[12] = s->nsector & 0xFF;
 858     d2h_fis[13] = (s->nsector >> 8) & 0xFF;
 859     for (i = 14; i < 20; i++) {
 860         d2h_fis[i] = 0;
 861     }
 862
 863     /* Update shadow registers: */
 864     pr->tfdata = (ad->port.ifs[0].error << 8) |
 865         ad->port.ifs[0].status;
 866
 867     if (d2h_fis[2] & ERR_STAT) {
 868         ahci_trigger_irq(ad->hba, ad, AHCI_PORT_IRQ_BIT_TFES);
 869     }
 870
 871     ahci_trigger_irq(ad->hba, ad, AHCI_PORT_IRQ_BIT_DHRS);
 872     return true;
 873 }
 874
 875 static int prdt_tbl_entry_size(const AHCI_SG *tbl)
 876 {
 877     /* flags_size is zero-based */
 878     return (le32_to_cpu(tbl->flags_size) & AHCI_PRDT_SIZE_MASK) + 1;
 879 }
 880
 881 /**
 882  * Fetch entries in a guest-provided PRDT and convert it into a QEMU SGlist.
 883  * @ad: The AHCIDevice for whom we are building the SGList.
 884  * @sglist: The SGList target to add PRD entries to.
 885  * @cmd: The AHCI Command Header that describes where the PRDT is.
 886  * @limit: The remaining size of the S/ATA transaction, in bytes.
 887  * @offset: The number of bytes already transferred, in bytes.
 888  *
 889  * The AHCI PRDT can describe up to 256GiB. S/ATA only support transactions of
 890  * up to 32MiB as of ATA8-ACS3 rev 1b, assuming a 512 byte sector size. We stop
 891  * building the sglist from the PRDT as soon as we hit @limit bytes,
 892  * which is <= INT32_MAX/2GiB.
 893  */
 894 static int ahci_populate_sglist(AHCIDevice *ad, QEMUSGList *sglist,
 895                                 AHCICmdHdr *cmd, int64_t limit, uint64_t offset)
 896 {
 897     uint16_t opts = le16_to_cpu(cmd->opts);
 898     uint16_t prdtl = le16_to_cpu(cmd->prdtl);
 899     uint64_t cfis_addr = le64_to_cpu(cmd->tbl_addr);
 900     uint64_t prdt_addr = cfis_addr + 0x80;
 901     dma_addr_t prdt_len = (prdtl * sizeof(AHCI_SG));
 902     dma_addr_t real_prdt_len = prdt_len;
 903     uint8_t *prdt;
 904     int i;
 905     int r = 0;
 906     uint64_t sum = 0;
 907     int off_idx = -1;
 908     int64_t off_pos = -1;
 909     int tbl_entry_size;
 910     IDEBus *bus = &ad->port;
 911     BusState *qbus = BUS(bus);
 912
 913     trace_ahci_populate_sglist(ad->hba, ad->port_no);
 914
 915     if (!prdtl) {
 916         trace_ahci_populate_sglist_no_prdtl(ad->hba, ad->port_no, opts);
 917         return -1;
 918     }
 919
 920     /* map PRDT */
 921     if (!(prdt = dma_memory_map(ad->hba->as, prdt_addr, &prdt_len,
 922                                 DMA_DIRECTION_TO_DEVICE))){
 923         trace_ahci_populate_sglist_no_map(ad->hba, ad->port_no);
 924         return -1;
 925     }
 926
 927     if (prdt_len < real_prdt_len) {
 928         trace_ahci_populate_sglist_short_map(ad->hba, ad->port_no);
 929         r = -1;
 930         goto out;
 931     }
 932
 933     /* Get entries in the PRDT, init a qemu sglist accordingly */
 934     if (prdtl > 0) {
 935         AHCI_SG *tbl = (AHCI_SG *)prdt;
 936         sum = 0;
 937         for (i = 0; i < prdtl; i++) {
 938             tbl_entry_size = prdt_tbl_entry_size(&tbl[i]);
 939             if (offset < (sum + tbl_entry_size)) {
 940                 off_idx = i;
 941                 off_pos = offset - sum;
 942                 break;
 943             }
 944             sum += tbl_entry_size;
 945         }
 946         if ((off_idx == -1) || (off_pos < 0) || (off_pos > tbl_entry_size)) {
 947             trace_ahci_populate_sglist_bad_offset(ad->hba, ad->port_no,
 948                                                   off_idx, off_pos);
 949             r = -1;
 950             goto out;
 951         }
 952
 953         qemu_sglist_init(sglist, qbus->parent, (prdtl - off_idx),
 954                          ad->hba->as);
 955         qemu_sglist_add(sglist, le64_to_cpu(tbl[off_idx].addr) + off_pos,
 956                         MIN(prdt_tbl_entry_size(&tbl[off_idx]) - off_pos,
 957                             limit));
 958
 959         for (i = off_idx + 1; i < prdtl && sglist->size < limit; i++) {
 960             qemu_sglist_add(sglist, le64_to_cpu(tbl[i].addr),
 961                             MIN(prdt_tbl_entry_size(&tbl[i]),
 962                                 limit - sglist->size));
 963         }
 964     }
 965
 966 out:
 967     dma_memory_unmap(ad->hba->as, prdt, prdt_len,
 968                      DMA_DIRECTION_TO_DEVICE, prdt_len);
 969     return r;
 970 }
 971
 972 static void ncq_err(NCQTransferState *ncq_tfs)
 973 {
 974     IDEState *ide_state = &ncq_tfs->drive->port.ifs[0];
 975
 976     ide_state->error = ABRT_ERR;
 977     ide_state->status = READY_STAT | ERR_STAT;
 978     ncq_tfs->drive->port_regs.scr_err |= (1 << ncq_tfs->tag);
 979     qemu_sglist_destroy(&ncq_tfs->sglist);
 980     ncq_tfs->used = 0;
 981 }
 982
 983 static void ncq_finish(NCQTransferState *ncq_tfs)
 984 {
 985     /* If we didn't error out, set our finished bit. Errored commands
 986      * do not get a bit set for the SDB FIS ACT register, nor do they
 987      * clear the outstanding bit in scr_act (PxSACT). */
 988     if (!(ncq_tfs->drive->port_regs.scr_err & (1 << ncq_tfs->tag))) {
 989         ncq_tfs->drive->finished |= (1 << ncq_tfs->tag);
 990     }
 991
 992     ahci_write_fis_sdb(ncq_tfs->drive->hba, ncq_tfs);
 993
 994     trace_ncq_finish(ncq_tfs->drive->hba, ncq_tfs->drive->port_no,
 995                      ncq_tfs->tag);
 996
 997     block_acct_done(blk_get_stats(ncq_tfs->drive->port.ifs[0].blk),
 998                     &ncq_tfs->acct);
 999     qemu_sglist_destroy(&ncq_tfs->sglist);
1000     ncq_tfs->used = 0;
1001 }
1002
1003 static void ncq_cb(void *opaque, int ret)
1004 {
1005     NCQTransferState *ncq_tfs = (NCQTransferState *)opaque;
1006     IDEState *ide_state = &ncq_tfs->drive->port.ifs[0];
1007
1008     ncq_tfs->aiocb = NULL;
1009     if (ret == -ECANCELED) {
1010         return;
1011     }
1012
1013     if (ret < 0) {
1014         bool is_read = ncq_tfs->cmd == READ_FPDMA_QUEUED;
1015         BlockErrorAction action = blk_get_error_action(ide_state->blk,
1016                                                        is_read, -ret);
1017         if (action == BLOCK_ERROR_ACTION_STOP) {
1018             ncq_tfs->halt = true;
1019             ide_state->bus->error_status = IDE_RETRY_HBA;
1020         } else if (action == BLOCK_ERROR_ACTION_REPORT) {
1021             ncq_err(ncq_tfs);
1022         }
1023         blk_error_action(ide_state->blk, action, is_read, -ret);
1024     } else {
1025         ide_state->status = READY_STAT | SEEK_STAT;
1026     }
1027
1028     if (!ncq_tfs->halt) {
1029         ncq_finish(ncq_tfs);
1030     }
1031 }
1032
1033 static int is_ncq(uint8_t ata_cmd)
1034 {
1035     /* Based on SATA 3.2 section 13.6.3.2 */
1036     switch (ata_cmd) {
1037     case READ_FPDMA_QUEUED:
1038     case WRITE_FPDMA_QUEUED:
1039     case NCQ_NON_DATA:
1040     case RECEIVE_FPDMA_QUEUED:
1041     case SEND_FPDMA_QUEUED:
1042         return 1;
1043     default:
1044         return 0;
1045     }
1046 }
1047
1048 static void execute_ncq_command(NCQTransferState *ncq_tfs)
1049 {
1050     AHCIDevice *ad = ncq_tfs->drive;
1051     IDEState *ide_state = &ad->port.ifs[0];
1052     int port = ad->port_no;
1053
1054     g_assert(is_ncq(ncq_tfs->cmd));
1055     ncq_tfs->halt = false;
1056
1057     switch (ncq_tfs->cmd) {
1058     case READ_FPDMA_QUEUED:
1059         trace_execute_ncq_command_read(ad->hba, port, ncq_tfs->tag,
1060                                        ncq_tfs->sector_count, ncq_tfs->lba);
1061         dma_acct_start(ide_state->blk, &ncq_tfs->acct,
1062                        &ncq_tfs->sglist, BLOCK_ACCT_READ);
1063         ncq_tfs->aiocb = dma_blk_read(ide_state->blk, &ncq_tfs->sglist,
1064                                       ncq_tfs->lba << BDRV_SECTOR_BITS,
1065                                       BDRV_SECTOR_SIZE,
1066                                       ncq_cb, ncq_tfs);
1067         break;
1068     case WRITE_FPDMA_QUEUED:
1069         trace_execute_ncq_command_read(ad->hba, port, ncq_tfs->tag,
1070                                        ncq_tfs->sector_count, ncq_tfs->lba);
1071         dma_acct_start(ide_state->blk, &ncq_tfs->acct,
1072                        &ncq_tfs->sglist, BLOCK_ACCT_WRITE);
1073         ncq_tfs->aiocb = dma_blk_write(ide_state->blk, &ncq_tfs->sglist,
1074                                        ncq_tfs->lba << BDRV_SECTOR_BITS,
1075                                        BDRV_SECTOR_SIZE,
1076                                        ncq_cb, ncq_tfs);
1077         break;
1078     default:
1079         trace_execute_ncq_command_unsup(ad->hba, port,
1080                                         ncq_tfs->tag, ncq_tfs->cmd);
1081         ncq_err(ncq_tfs);
1082     }
1083 }
1084
1085
1086 static void process_ncq_command(AHCIState *s, int port, uint8_t *cmd_fis,
1087                                 uint8_t slot)
1088 {
1089     AHCIDevice *ad = &s->dev[port];
1090     NCQFrame *ncq_fis = (NCQFrame*)cmd_fis;
1091     uint8_t tag = ncq_fis->tag >> 3;
1092     NCQTransferState *ncq_tfs = &ad->ncq_tfs[tag];
1093     size_t size;
1094
1095     g_assert(is_ncq(ncq_fis->command));
1096     if (ncq_tfs->used) {
1097         /* error - already in use */
1098         fprintf(stderr, "%s: tag %d already used\n", __func__, tag);
1099         return;
1100     }
1101
1102     ncq_tfs->used = 1;
1103     ncq_tfs->drive = ad;
1104     ncq_tfs->slot = slot;
1105     ncq_tfs->cmdh = &((AHCICmdHdr *)ad->lst)[slot];
1106     ncq_tfs->cmd = ncq_fis->command;
1107     ncq_tfs->lba = ((uint64_t)ncq_fis->lba5 << 40) |
1108                    ((uint64_t)ncq_fis->lba4 << 32) |
1109                    ((uint64_t)ncq_fis->lba3 << 24) |
1110                    ((uint64_t)ncq_fis->lba2 << 16) |
1111                    ((uint64_t)ncq_fis->lba1 << 8) |
1112                    (uint64_t)ncq_fis->lba0;
1113     ncq_tfs->tag = tag;
1114
1115     /* Sanity-check the NCQ packet */
1116     if (tag != slot) {
1117         trace_process_ncq_command_mismatch(s, port, tag, slot);
1118     }
1119
1120     if (ncq_fis->aux0 || ncq_fis->aux1 || ncq_fis->aux2 || ncq_fis->aux3) {
1121         trace_process_ncq_command_aux(s, port, tag);
1122     }
1123     if (ncq_fis->prio || ncq_fis->icc) {
1124         trace_process_ncq_command_prioicc(s, port, tag);
1125     }
1126     if (ncq_fis->fua & NCQ_FIS_FUA_MASK) {
1127         trace_process_ncq_command_fua(s, port, tag);
1128     }
1129     if (ncq_fis->tag & NCQ_FIS_RARC_MASK) {
1130         trace_process_ncq_command_rarc(s, port, tag);
1131     }
1132
1133     ncq_tfs->sector_count = ((ncq_fis->sector_count_high << 8) |
1134                              ncq_fis->sector_count_low);
1135     if (!ncq_tfs->sector_count) {
1136         ncq_tfs->sector_count = 0x10000;
1137     }
1138     size = ncq_tfs->sector_count * 512;
1139     ahci_populate_sglist(ad, &ncq_tfs->sglist, ncq_tfs->cmdh, size, 0);
1140
1141     if (ncq_tfs->sglist.size < size) {
1142         error_report("ahci: PRDT length for NCQ command (0x%zx) "
1143                      "is smaller than the requested size (0x%zx)",
1144                      ncq_tfs->sglist.size, size);
1145         ncq_err(ncq_tfs);
1146         ahci_trigger_irq(ad->hba, ad, AHCI_PORT_IRQ_BIT_OFS);
1147         return;
1148     } else if (ncq_tfs->sglist.size != size) {
1149         trace_process_ncq_command_large(s, port, tag,
1150                                         ncq_tfs->sglist.size, size);
1151     }
1152
1153     trace_process_ncq_command(s, port, tag,
1154                               ncq_fis->command,
1155                               ncq_tfs->lba,
1156                               ncq_tfs->lba + ncq_tfs->sector_count - 1);
1157     execute_ncq_command(ncq_tfs);
1158 }
1159
1160 static AHCICmdHdr *get_cmd_header(AHCIState *s, uint8_t port, uint8_t slot)
1161 {
1162     if (port >= s->ports || slot >= AHCI_MAX_CMDS) {
1163         return NULL;
1164     }
1165
1166     return s->dev[port].lst ? &((AHCICmdHdr *)s->dev[port].lst)[slot] : NULL;
1167 }
1168
1169 static void handle_reg_h2d_fis(AHCIState *s, int port,
1170                                uint8_t slot, uint8_t *cmd_fis)
1171 {
1172     IDEState *ide_state = &s->dev[port].port.ifs[0];
1173     AHCICmdHdr *cmd = get_cmd_header(s, port, slot);
1174     uint16_t opts = le16_to_cpu(cmd->opts);
1175
1176     if (cmd_fis[1] & 0x0F) {
1177         trace_handle_reg_h2d_fis_pmp(s, port, cmd_fis[1],
1178                                      cmd_fis[2], cmd_fis[3]);
1179         return;
1180     }
1181
1182     if (cmd_fis[1] & 0x70) {
1183         trace_handle_reg_h2d_fis_res(s, port, cmd_fis[1],
1184                                      cmd_fis[2], cmd_fis[3]);
1185         return;
1186     }
1187
1188     if (!(cmd_fis[1] & SATA_FIS_REG_H2D_UPDATE_COMMAND_REGISTER)) {
1189         switch (s->dev[port].port_state) {
1190         case STATE_RUN:
1191             if (cmd_fis[15] & ATA_SRST) {
1192                 s->dev[port].port_state = STATE_RESET;
1193             }
1194             break;
1195         case STATE_RESET:
1196             if (!(cmd_fis[15] & ATA_SRST)) {
1197                 ahci_reset_port(s, port);
1198             }
1199             break;
1200         }
1201         return;
1202     }
1203
1204     /* Check for NCQ command */
1205     if (is_ncq(cmd_fis[2])) {
1206         process_ncq_command(s, port, cmd_fis, slot);
1207         return;
1208     }
1209
1210     /* Decompose the FIS:
1211      * AHCI does not interpret FIS packets, it only forwards them.
1212      * SATA 1.0 describes how to decode LBA28 and CHS FIS packets.
1213      * Later specifications, e.g, SATA 3.2, describe LBA48 FIS packets.
1214      *
1215      * ATA4 describes sector number for LBA28/CHS commands.
1216      * ATA6 describes sector number for LBA48 commands.
1217      * ATA8 deprecates CHS fully, describing only LBA28/48.
1218      *
1219      * We dutifully convert the FIS into IDE registers, and allow the
1220      * core layer to interpret them as needed. */
1221     ide_state->feature = cmd_fis[3];
1222     ide_state->sector = cmd_fis[4];      /* LBA 7:0 */
1223     ide_state->lcyl = cmd_fis[5];        /* LBA 15:8  */
1224     ide_state->hcyl = cmd_fis[6];        /* LBA 23:16 */
1225     ide_state->select = cmd_fis[7];      /* LBA 27:24 (LBA28) */
1226     ide_state->hob_sector = cmd_fis[8];  /* LBA 31:24 */
1227     ide_state->hob_lcyl = cmd_fis[9];    /* LBA 39:32 */
1228     ide_state->hob_hcyl = cmd_fis[10];   /* LBA 47:40 */
1229     ide_state->hob_feature = cmd_fis[11];
1230     ide_state->nsector = (int64_t)((cmd_fis[13] << 8) | cmd_fis[12]);
1231     /* 14, 16, 17, 18, 19: Reserved (SATA 1.0) */
1232     /* 15: Only valid when UPDATE_COMMAND not set. */
1233
1234     /* Copy the ACMD field (ATAPI packet, if any) from the AHCI command
1235      * table to ide_state->io_buffer */
1236     if (opts & AHCI_CMD_ATAPI) {
1237         memcpy(ide_state->io_buffer, &cmd_fis[AHCI_COMMAND_TABLE_ACMD], 0x10);
1238         if (trace_event_get_state_backends(TRACE_HANDLE_REG_H2D_FIS_DUMP)) {
1239             char *pretty_fis = ahci_pretty_buffer_fis(ide_state->io_buffer, 0x10);
1240             trace_handle_reg_h2d_fis_dump(s, port, pretty_fis);
1241             g_free(pretty_fis);
1242         }
1243         s->dev[port].done_atapi_packet = false;
1244         /* XXX send PIO setup FIS */
1245     }
1246
1247     ide_state->error = 0;
1248
1249     /* Reset transferred byte counter */
1250     cmd->status = 0;
1251
1252     /* We're ready to process the command in FIS byte 2. */
1253     ide_exec_cmd(&s->dev[port].port, cmd_fis[2]);
1254 }
1255
1256 static int handle_cmd(AHCIState *s, int port, uint8_t slot)
1257 {
1258     IDEState *ide_state;
1259     uint64_t tbl_addr;
1260     AHCICmdHdr *cmd;
1261     uint8_t *cmd_fis;
1262     dma_addr_t cmd_len;
1263
1264     if (s->dev[port].port.ifs[0].status & (BUSY_STAT|DRQ_STAT)) {
1265         /* Engine currently busy, try again later */
1266         trace_handle_cmd_busy(s, port);
1267         return -1;
1268     }
1269
1270     if (!s->dev[port].lst) {
1271         trace_handle_cmd_nolist(s, port);
1272         return -1;
1273     }
1274     cmd = get_cmd_header(s, port, slot);
1275     /* remember current slot handle for later */
1276     s->dev[port].cur_cmd = cmd;
1277
1278     /* The device we are working for */
1279     ide_state = &s->dev[port].port.ifs[0];
1280     if (!ide_state->blk) {
1281         trace_handle_cmd_badport(s, port);
1282         return -1;
1283     }
1284
1285     tbl_addr = le64_to_cpu(cmd->tbl_addr);
1286     cmd_len = 0x80;
1287     cmd_fis = dma_memory_map(s->as, tbl_addr, &cmd_len,
1288                              DMA_DIRECTION_FROM_DEVICE);
1289     if (!cmd_fis) {
1290         trace_handle_cmd_badfis(s, port);
1291         return -1;
1292     } else if (cmd_len != 0x80) {
1293         ahci_trigger_irq(s, &s->dev[port], AHCI_PORT_IRQ_BIT_HBFS);
1294         trace_handle_cmd_badmap(s, port, cmd_len);
1295         goto out;
1296     }
1297     if (trace_event_get_state_backends(TRACE_HANDLE_CMD_FIS_DUMP)) {
1298         char *pretty_fis = ahci_pretty_buffer_fis(cmd_fis, 0x80);
1299         trace_handle_cmd_fis_dump(s, port, pretty_fis);
1300         g_free(pretty_fis);
1301     }
1302     switch (cmd_fis[0]) {
1303         case SATA_FIS_TYPE_REGISTER_H2D:
1304             handle_reg_h2d_fis(s, port, slot, cmd_fis);
1305             break;
1306         default:
1307             trace_handle_cmd_unhandled_fis(s, port,
1308                                            cmd_fis[0], cmd_fis[1], cmd_fis[2]);
1309             break;
1310     }
1311
1312 out:
1313     dma_memory_unmap(s->as, cmd_fis, cmd_len, DMA_DIRECTION_FROM_DEVICE,
1314                      cmd_len);
1315
1316     if (s->dev[port].port.ifs[0].status & (BUSY_STAT|DRQ_STAT)) {
1317         /* async command, complete later */
1318         s->dev[port].busy_slot = slot;
1319         return -1;
1320     }
1321
1322     /* done handling the command */
1323     return 0;
1324 }
1325
1326 /* DMA dev <-> ram */
1327 static void ahci_start_transfer(IDEDMA *dma)
1328 {
1329     AHCIDevice *ad = DO_UPCAST(AHCIDevice, dma, dma);
1330     IDEState *s = &ad->port.ifs[0];
1331     uint32_t size = (uint32_t)(s->data_end - s->data_ptr);
1332     /* write == ram -> device */
1333     uint16_t opts = le16_to_cpu(ad->cur_cmd->opts);
1334     int is_write = opts & AHCI_CMD_WRITE;
1335     int is_atapi = opts & AHCI_CMD_ATAPI;
1336     int has_sglist = 0;
1337
1338     if (is_atapi && !ad->done_atapi_packet) {
1339         /* already prepopulated iobuffer */
1340         ad->done_atapi_packet = true;
1341         size = 0;
1342         goto out;
1343     }
1344
1345     if (ahci_dma_prepare_buf(dma, size)) {
1346         has_sglist = 1;
1347     }
1348
1349     trace_ahci_start_transfer(ad->hba, ad->port_no, is_write ? "writ" : "read",
1350                               size, is_atapi ? "atapi" : "ata",
1351                               has_sglist ? "" : "o");
1352
1353     if (has_sglist && size) {
1354         if (is_write) {
1355             dma_buf_write(s->data_ptr, size, &s->sg);
1356         } else {
1357             dma_buf_read(s->data_ptr, size, &s->sg);
1358         }
1359     }
1360
1361 out:
1362     /* declare that we processed everything */
1363     s->data_ptr = s->data_end;
1364
1365     /* Update number of transferred bytes, destroy sglist */
1366     dma_buf_commit(s, size);
1367
1368     s->end_transfer_func(s);
1369
1370     if (!(s->status & DRQ_STAT)) {
1371         /* done with PIO send/receive */
1372         ahci_write_fis_pio(ad, le32_to_cpu(ad->cur_cmd->status));
1373     }
1374 }
1375
1376 static void ahci_start_dma(IDEDMA *dma, IDEState *s,
1377                            BlockCompletionFunc *dma_cb)
1378 {
1379     AHCIDevice *ad = DO_UPCAST(AHCIDevice, dma, dma);
1380     trace_ahci_start_dma(ad->hba, ad->port_no);
1381     s->io_buffer_offset = 0;
1382     dma_cb(s, 0);
1383 }
1384
1385 static void ahci_restart_dma(IDEDMA *dma)
1386 {
1387     /* Nothing to do, ahci_start_dma already resets s->io_buffer_offset.  */
1388 }
1389
1390 /**
1391  * IDE/PIO restarts are handled by the core layer, but NCQ commands
1392  * need an extra kick from the AHCI HBA.
1393  */
1394 static void ahci_restart(IDEDMA *dma)
1395 {
1396     AHCIDevice *ad = DO_UPCAST(AHCIDevice, dma, dma);
1397     int i;
1398
1399     for (i = 0; i < AHCI_MAX_CMDS; i++) {
1400         NCQTransferState *ncq_tfs = &ad->ncq_tfs[i];
1401         if (ncq_tfs->halt) {
1402             execute_ncq_command(ncq_tfs);
1403         }
1404     }
1405 }
1406
1407 /**
1408  * Called in DMA and PIO R/W chains to read the PRDT.
1409  * Not shared with NCQ pathways.
1410  */
1411 static int32_t ahci_dma_prepare_buf(IDEDMA *dma, int32_t limit)
1412 {
1413     AHCIDevice *ad = DO_UPCAST(AHCIDevice, dma, dma);
1414     IDEState *s = &ad->port.ifs[0];
1415
1416     if (ahci_populate_sglist(ad, &s->sg, ad->cur_cmd,
1417                              limit, s->io_buffer_offset) == -1) {
1418         trace_ahci_dma_prepare_buf_fail(ad->hba, ad->port_no);
1419         return -1;
1420     }
1421     s->io_buffer_size = s->sg.size;
1422
1423     trace_ahci_dma_prepare_buf(ad->hba, ad->port_no, limit, s->io_buffer_size);
1424     return s->io_buffer_size;
1425 }
1426
1427 /**
1428  * Updates the command header with a bytes-read value.
1429  * Called via dma_buf_commit, for both DMA and PIO paths.
1430  * sglist destruction is handled within dma_buf_commit.
1431  */
1432 static void ahci_commit_buf(IDEDMA *dma, uint32_t tx_bytes)
1433 {
1434     AHCIDevice *ad = DO_UPCAST(AHCIDevice, dma, dma);
1435
1436     tx_bytes += le32_to_cpu(ad->cur_cmd->status);
1437     ad->cur_cmd->status = cpu_to_le32(tx_bytes);
1438 }
1439
1440 static int ahci_dma_rw_buf(IDEDMA *dma, int is_write)
1441 {
1442     AHCIDevice *ad = DO_UPCAST(AHCIDevice, dma, dma);
1443     IDEState *s = &ad->port.ifs[0];
1444     uint8_t *p = s->io_buffer + s->io_buffer_index;
1445     int l = s->io_buffer_size - s->io_buffer_index;
1446
1447     if (ahci_populate_sglist(ad, &s->sg, ad->cur_cmd, l, s->io_buffer_offset)) {
1448         return 0;
1449     }
1450
1451     if (is_write) {
1452         dma_buf_read(p, l, &s->sg);
1453     } else {
1454         dma_buf_write(p, l, &s->sg);
1455     }
1456
1457     /* free sglist, update byte count */
1458     dma_buf_commit(s, l);
1459     s->io_buffer_index += l;
1460
1461     trace_ahci_dma_rw_buf(ad->hba, ad->port_no, l);
1462     return 1;
1463 }
1464
1465 static void ahci_cmd_done(IDEDMA *dma)
1466 {
1467     AHCIDevice *ad = DO_UPCAST(AHCIDevice, dma, dma);
1468
1469     trace_ahci_cmd_done(ad->hba, ad->port_no);
1470
1471     /* no longer busy */
1472     if (ad->busy_slot != -1) {
1473         ad->port_regs.cmd_issue &= ~(1 << ad->busy_slot);
1474         ad->busy_slot = -1;
1475     }
1476
1477     /* update d2h status */
1478     ahci_write_fis_d2h(ad);
1479
1480     if (ad->port_regs.cmd_issue && !ad->check_bh) {
1481         ad->check_bh = qemu_bh_new(ahci_check_cmd_bh, ad);
1482         qemu_bh_schedule(ad->check_bh);
1483     }
1484 }
1485
1486 static void ahci_irq_set(void *opaque, int n, int level)
1487 {
1488 }
1489
1490 static const IDEDMAOps ahci_dma_ops = {
1491     .start_dma = ahci_start_dma,
1492     .restart = ahci_restart,
1493     .restart_dma = ahci_restart_dma,
1494     .start_transfer = ahci_start_transfer,
1495     .prepare_buf = ahci_dma_prepare_buf,
1496     .commit_buf = ahci_commit_buf,
1497     .rw_buf = ahci_dma_rw_buf,
1498     .cmd_done = ahci_cmd_done,
1499 };
1500
1501 void ahci_init(AHCIState *s, DeviceState *qdev)
1502 {
1503     s->container = qdev;
1504     /* XXX BAR size should be 1k, but that breaks, so bump it to 4k for now */
1505     memory_region_init_io(&s->mem, OBJECT(qdev), &ahci_mem_ops, s,
1506                           "ahci", AHCI_MEM_BAR_SIZE);
1507     memory_region_init_io(&s->idp, OBJECT(qdev), &ahci_idp_ops, s,
1508                           "ahci-idp", 32);
1509 }
1510
1511 void ahci_realize(AHCIState *s, DeviceState *qdev, AddressSpace *as, int ports)
1512 {
1513     qemu_irq *irqs;
1514     int i;
1515
1516     s->as = as;
1517     s->ports = ports;
1518     s->dev = g_new0(AHCIDevice, ports);
1519     ahci_reg_init(s);
1520     irqs = qemu_allocate_irqs(ahci_irq_set, s, s->ports);
1521     for (i = 0; i < s->ports; i++) {
1522         AHCIDevice *ad = &s->dev[i];
1523
1524         ide_bus_new(&ad->port, sizeof(ad->port), qdev, i, 1);
1525         ide_init2(&ad->port, irqs[i]);
1526
1527         ad->hba = s;
1528         ad->port_no = i;
1529         ad->port.dma = &ad->dma;
1530         ad->port.dma->ops = &ahci_dma_ops;
1531         ide_register_restart_cb(&ad->port);
1532     }
1533     g_free(irqs);
1534 }
1535
1536 void ahci_uninit(AHCIState *s)
1537 {
1538     int i, j;
1539
1540     for (i = 0; i < s->ports; i++) {
1541         AHCIDevice *ad = &s->dev[i];
1542
1543         for (j = 0; j < 2; j++) {
1544             IDEState *s = &ad->port.ifs[j];
1545
1546             ide_exit(s);
1547         }
1548         object_unparent(OBJECT(&ad->port));
1549     }
1550
1551     g_free(s->dev);
1552 }
1553
1554 void ahci_reset(AHCIState *s)
1555 {
1556     AHCIPortRegs *pr;
1557     int i;
1558
1559     trace_ahci_reset(s);
1560
1561     s->control_regs.irqstatus = 0;
1562     /* AHCI Enable (AE)
1563      * The implementation of this bit is dependent upon the value of the
1564      * CAP.SAM bit. If CAP.SAM is '0', then GHC.AE shall be read-write and
1565      * shall have a reset value of '0'. If CAP.SAM is '1', then AE shall be
1566      * read-only and shall have a reset value of '1'.
1567      *
1568      * We set HOST_CAP_AHCI so we must enable AHCI at reset.
1569      */
1570     s->control_regs.ghc = HOST_CTL_AHCI_EN;
1571
1572     for (i = 0; i < s->ports; i++) {
1573         pr = &s->dev[i].port_regs;
1574         pr->irq_stat = 0;
1575         pr->irq_mask = 0;
1576         pr->scr_ctl = 0;
1577         pr->cmd = PORT_CMD_SPIN_UP | PORT_CMD_POWER_ON;
1578         ahci_reset_port(s, i);
1579     }
1580 }
1581
1582 static const VMStateDescription vmstate_ncq_tfs = {
1583     .name = "ncq state",
1584     .version_id = 1,
1585     .fields = (VMStateField[]) {
1586         VMSTATE_UINT32(sector_count, NCQTransferState),
1587         VMSTATE_UINT64(lba, NCQTransferState),
1588         VMSTATE_UINT8(tag, NCQTransferState),
1589         VMSTATE_UINT8(cmd, NCQTransferState),
1590         VMSTATE_UINT8(slot, NCQTransferState),
1591         VMSTATE_BOOL(used, NCQTransferState),
1592         VMSTATE_BOOL(halt, NCQTransferState),
1593         VMSTATE_END_OF_LIST()
1594     },
1595 };
1596
1597 static const VMStateDescription vmstate_ahci_device = {
1598     .name = "ahci port",
1599     .version_id = 1,
1600     .fields = (VMStateField[]) {
1601         VMSTATE_IDE_BUS(port, AHCIDevice),
1602         VMSTATE_IDE_DRIVE(port.ifs[0], AHCIDevice),
1603         VMSTATE_UINT32(port_state, AHCIDevice),
1604         VMSTATE_UINT32(finished, AHCIDevice),
1605         VMSTATE_UINT32(port_regs.lst_addr, AHCIDevice),
1606         VMSTATE_UINT32(port_regs.lst_addr_hi, AHCIDevice),
1607         VMSTATE_UINT32(port_regs.fis_addr, AHCIDevice),
1608         VMSTATE_UINT32(port_regs.fis_addr_hi, AHCIDevice),
1609         VMSTATE_UINT32(port_regs.irq_stat, AHCIDevice),
1610         VMSTATE_UINT32(port_regs.irq_mask, AHCIDevice),
1611         VMSTATE_UINT32(port_regs.cmd, AHCIDevice),
1612         VMSTATE_UINT32(port_regs.tfdata, AHCIDevice),
1613         VMSTATE_UINT32(port_regs.sig, AHCIDevice),
1614         VMSTATE_UINT32(port_regs.scr_stat, AHCIDevice),
1615         VMSTATE_UINT32(port_regs.scr_ctl, AHCIDevice),
1616         VMSTATE_UINT32(port_regs.scr_err, AHCIDevice),
1617         VMSTATE_UINT32(port_regs.scr_act, AHCIDevice),
1618         VMSTATE_UINT32(port_regs.cmd_issue, AHCIDevice),
1619         VMSTATE_BOOL(done_atapi_packet, AHCIDevice),
1620         VMSTATE_INT32(busy_slot, AHCIDevice),
1621         VMSTATE_BOOL(init_d2h_sent, AHCIDevice),
1622         VMSTATE_STRUCT_ARRAY(ncq_tfs, AHCIDevice, AHCI_MAX_CMDS,
1623                              1, vmstate_ncq_tfs, NCQTransferState),
1624         VMSTATE_END_OF_LIST()
1625     },
1626 };
1627
1628 static int ahci_state_post_load(void *opaque, int version_id)
1629 {
1630     int i, j;
1631     struct AHCIDevice *ad;
1632     NCQTransferState *ncq_tfs;
1633     AHCIPortRegs *pr;
1634     AHCIState *s = opaque;
1635
1636     for (i = 0; i < s->ports; i++) {
1637         ad = &s->dev[i];
1638         pr = &ad->port_regs;
1639
1640         if (!(pr->cmd & PORT_CMD_START) && (pr->cmd & PORT_CMD_LIST_ON)) {
1641             error_report("AHCI: DMA engine should be off, but status bit "
1642                          "indicates it is still running.");
1643             return -1;
1644         }
1645         if (!(pr->cmd & PORT_CMD_FIS_RX) && (pr->cmd & PORT_CMD_FIS_ON)) {
1646             error_report("AHCI: FIS RX engine should be off, but status bit "
1647                          "indicates it is still running.");
1648             return -1;
1649         }
1650
1651         /* After a migrate, the DMA/FIS engines are "off" and
1652          * need to be conditionally restarted */
1653         pr->cmd &= ~(PORT_CMD_LIST_ON | PORT_CMD_FIS_ON);
1654         if (ahci_cond_start_engines(ad) != 0) {
1655             return -1;
1656         }
1657
1658         for (j = 0; j < AHCI_MAX_CMDS; j++) {
1659             ncq_tfs = &ad->ncq_tfs[j];
1660             ncq_tfs->drive = ad;
1661
1662             if (ncq_tfs->used != ncq_tfs->halt) {
1663                 return -1;
1664             }
1665             if (!ncq_tfs->halt) {
1666                 continue;
1667             }
1668             if (!is_ncq(ncq_tfs->cmd)) {
1669                 return -1;
1670             }
1671             if (ncq_tfs->slot != ncq_tfs->tag) {
1672                 return -1;
1673             }
1674             /* If ncq_tfs->halt is justly set, the engine should be engaged,
1675              * and the command list buffer should be mapped. */
1676             ncq_tfs->cmdh = get_cmd_header(s, i, ncq_tfs->slot);
1677             if (!ncq_tfs->cmdh) {
1678                 return -1;
1679             }
1680             ahci_populate_sglist(ncq_tfs->drive, &ncq_tfs->sglist,
1681                                  ncq_tfs->cmdh, ncq_tfs->sector_count * 512,
1682                                  0);
1683             if (ncq_tfs->sector_count != ncq_tfs->sglist.size >> 9) {
1684                 return -1;
1685             }
1686         }
1687
1688
1689         /*
1690          * If an error is present, ad->busy_slot will be valid and not -1.
1691          * In this case, an operation is waiting to resume and will re-check
1692          * for additional AHCI commands to execute upon completion.
1693          *
1694          * In the case where no error was present, busy_slot will be -1,
1695          * and we should check to see if there are additional commands waiting.
1696          */
1697         if (ad->busy_slot == -1) {
1698             check_cmd(s, i);
1699         } else {
1700             /* We are in the middle of a command, and may need to access
1701              * the command header in guest memory again. */
1702             if (ad->busy_slot < 0 || ad->busy_slot >= AHCI_MAX_CMDS) {
1703                 return -1;
1704             }
1705             ad->cur_cmd = get_cmd_header(s, i, ad->busy_slot);
1706         }
1707     }
1708
1709     return 0;
1710 }
1711
1712 const VMStateDescription vmstate_ahci = {
1713     .name = "ahci",
1714     .version_id = 1,
1715     .post_load = ahci_state_post_load,
1716     .fields = (VMStateField[]) {
1717         VMSTATE_STRUCT_VARRAY_POINTER_INT32(dev, AHCIState, ports,
1718                                      vmstate_ahci_device, AHCIDevice),
1719         VMSTATE_UINT32(control_regs.cap, AHCIState),
1720         VMSTATE_UINT32(control_regs.ghc, AHCIState),
1721         VMSTATE_UINT32(control_regs.irqstatus, AHCIState),
1722         VMSTATE_UINT32(control_regs.impl, AHCIState),
1723         VMSTATE_UINT32(control_regs.version, AHCIState),
1724         VMSTATE_UINT32(idp_index, AHCIState),
1725         VMSTATE_INT32_EQUAL(ports, AHCIState, NULL),
1726         VMSTATE_END_OF_LIST()
1727     },
1728 };
1729
1730 static const VMStateDescription vmstate_sysbus_ahci = {
1731     .name = "sysbus-ahci",
1732     .fields = (VMStateField[]) {
1733         VMSTATE_AHCI(ahci, SysbusAHCIState),
1734         VMSTATE_END_OF_LIST()
1735     },
1736 };
1737
1738 static void sysbus_ahci_reset(DeviceState *dev)
1739 {
1740     SysbusAHCIState *s = SYSBUS_AHCI(dev);
1741
1742     ahci_reset(&s->ahci);
1743 }
1744
1745 static void sysbus_ahci_init(Object *obj)
1746 {
1747     SysbusAHCIState *s = SYSBUS_AHCI(obj);
1748     SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
1749
1750     ahci_init(&s->ahci, DEVICE(obj));
1751
1752     sysbus_init_mmio(sbd, &s->ahci.mem);
1753     sysbus_init_irq(sbd, &s->ahci.irq);
1754 }
1755
1756 static void sysbus_ahci_realize(DeviceState *dev, Error **errp)
1757 {
1758     SysbusAHCIState *s = SYSBUS_AHCI(dev);
1759
1760     ahci_realize(&s->ahci, dev, &address_space_memory, s->num_ports);
1761 }
1762
1763 static Property sysbus_ahci_properties[] = {
1764     DEFINE_PROP_UINT32("num-ports", SysbusAHCIState, num_ports, 1),
1765     DEFINE_PROP_END_OF_LIST(),
1766 };
1767
1768 static void sysbus_ahci_class_init(ObjectClass *klass, void *data)
1769 {
1770     DeviceClass *dc = DEVICE_CLASS(klass);
1771
1772     dc->realize = sysbus_ahci_realize;
1773     dc->vmsd = &vmstate_sysbus_ahci;
1774     dc->props = sysbus_ahci_properties;
1775     dc->reset = sysbus_ahci_reset;
1776     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
1777 }
1778
1779 static const TypeInfo sysbus_ahci_info = {
1780     .name          = TYPE_SYSBUS_AHCI,
1781     .parent        = TYPE_SYS_BUS_DEVICE,
1782     .instance_size = sizeof(SysbusAHCIState),
1783     .instance_init = sysbus_ahci_init,
1784     .class_init    = sysbus_ahci_class_init,
1785 };
1786
1787 static void sysbus_ahci_register_types(void)
1788 {
1789     type_register_static(&sysbus_ahci_info);
1790 }
1791
1792 type_init(sysbus_ahci_register_types)
1793
1794 int32_t ahci_get_num_ports(PCIDevice *dev)
1795 {
1796     AHCIPCIState *d = ICH_AHCI(dev);
1797     AHCIState *ahci = &d->ahci;
1798
1799     return ahci->ports;
1800 }
1801
1802 void ahci_ide_create_devs(PCIDevice *dev, DriveInfo **hd)
1803 {
1804     AHCIPCIState *d = ICH_AHCI(dev);
1805     AHCIState *ahci = &d->ahci;
1806     int i;
1807
1808     for (i = 0; i < ahci->ports; i++) {
1809         if (hd[i] == NULL) {
1810             continue;
1811         }
1812         ide_create_drive(&ahci->dev[i].port, 0, hd[i]);
1813     }
1814
1815 }