VirtualBox

Changeset 56400 in vbox for trunk/src/VBox/Devices/Storage


Ignore:
Timestamp:
Jun 13, 2015 12:23:15 AM (10 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
101000
Message:

DevATA: Use the R3 infix to clarify in which context things are executed.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Storage/DevATA.cpp

    r56399 r56400  
    574574typedef bool (*PSourceSinkFunc)(ATADevState *);
    575575
    576 static void ataReadWriteSectorsBT(ATADevState *);
    577 static void ataPacketBT(ATADevState *);
    578 static void atapiCmdBT(ATADevState *);
    579 static void atapiPassthroughCmdBT(ATADevState *);
    580 
    581 static bool ataIdentifySS(ATADevState *);
    582 static bool ataFlushSS(ATADevState *);
    583 static bool ataReadSectorsSS(ATADevState *);
    584 static bool ataWriteSectorsSS(ATADevState *);
    585 static bool ataExecuteDeviceDiagnosticSS(ATADevState *);
    586 static bool ataTrimSS(ATADevState *);
    587 static bool ataPacketSS(ATADevState *);
    588 static bool atapiGetConfigurationSS(ATADevState *);
    589 static bool atapiGetEventStatusNotificationSS(ATADevState *);
    590 static bool atapiIdentifySS(ATADevState *);
    591 static bool atapiInquirySS(ATADevState *);
    592 static bool atapiMechanismStatusSS(ATADevState *);
    593 static bool atapiModeSenseErrorRecoverySS(ATADevState *);
    594 static bool atapiModeSenseCDStatusSS(ATADevState *);
    595 static bool atapiReadSS(ATADevState *);
    596 static bool atapiReadCapacitySS(ATADevState *);
    597 static bool atapiReadDiscInformationSS(ATADevState *);
    598 static bool atapiReadTOCNormalSS(ATADevState *);
    599 static bool atapiReadTOCMultiSS(ATADevState *);
    600 static bool atapiReadTOCRawSS(ATADevState *);
    601 static bool atapiReadTrackInformationSS(ATADevState *);
    602 static bool atapiRequestSenseSS(ATADevState *);
    603 static bool atapiPassthroughSS(ATADevState *);
    604 static bool atapiReadDVDStructureSS(ATADevState *);
     576static void ataR3ReadWriteSectorsBT(ATADevState *);
     577static void ataR3PacketBT(ATADevState *);
     578static void atapiR3CmdBT(ATADevState *);
     579static void atapiR3PassthroughCmdBT(ATADevState *);
     580
     581static bool ataR3IdentifySS(ATADevState *);
     582static bool ataR3FlushSS(ATADevState *);
     583static bool ataR3ReadSectorsSS(ATADevState *);
     584static bool ataR3WriteSectorsSS(ATADevState *);
     585static bool ataR3ExecuteDeviceDiagnosticSS(ATADevState *);
     586static bool ataR3TrimSS(ATADevState *);
     587static bool ataR3PacketSS(ATADevState *);
     588static bool atapiR3GetConfigurationSS(ATADevState *);
     589static bool atapiR3GetEventStatusNotificationSS(ATADevState *);
     590static bool atapiR3IdentifySS(ATADevState *);
     591static bool atapiR3InquirySS(ATADevState *);
     592static bool atapiR3MechanismStatusSS(ATADevState *);
     593static bool atapiR3ModeSenseErrorRecoverySS(ATADevState *);
     594static bool atapiR3ModeSenseCDStatusSS(ATADevState *);
     595static bool atapiR3ReadSS(ATADevState *);
     596static bool atapiR3ReadCapacitySS(ATADevState *);
     597static bool atapiR3ReadDiscInformationSS(ATADevState *);
     598static bool atapiR3ReadTOCNormalSS(ATADevState *);
     599static bool atapiR3ReadTOCMultiSS(ATADevState *);
     600static bool atapiR3ReadTOCRawSS(ATADevState *);
     601static bool atapiR3ReadTrackInformationSS(ATADevState *);
     602static bool atapiR3RequestSenseSS(ATADevState *);
     603static bool atapiR3PassthroughSS(ATADevState *);
     604static bool atapiR3ReadDVDStructureSS(ATADevState *);
    605605
    606606/**
    … …  
    624624{
    625625    NULL,
    626     ataReadWriteSectorsBT,
    627     ataPacketBT,
    628     atapiCmdBT,
    629     atapiPassthroughCmdBT,
     626    ataR3ReadWriteSectorsBT,
     627    ataR3PacketBT,
     628    atapiR3CmdBT,
     629    atapiR3PassthroughCmdBT,
    630630};
    631631
    … …  
    670670{
    671671    NULL,
    672     ataIdentifySS,
    673     ataFlushSS,
    674     ataReadSectorsSS,
    675     ataWriteSectorsSS,
    676     ataExecuteDeviceDiagnosticSS,
    677     ataTrimSS,
    678     ataPacketSS,
    679     atapiGetConfigurationSS,
    680     atapiGetEventStatusNotificationSS,
    681     atapiIdentifySS,
    682     atapiInquirySS,
    683     atapiMechanismStatusSS,
    684     atapiModeSenseErrorRecoverySS,
    685     atapiModeSenseCDStatusSS,
    686     atapiReadSS,
    687     atapiReadCapacitySS,
    688     atapiReadDiscInformationSS,
    689     atapiReadTOCNormalSS,
    690     atapiReadTOCMultiSS,
    691     atapiReadTOCRawSS,
    692     atapiReadTrackInformationSS,
    693     atapiRequestSenseSS,
    694     atapiPassthroughSS,
    695     atapiReadDVDStructureSS
     672    ataR3IdentifySS,
     673    ataR3FlushSS,
     674    ataR3ReadSectorsSS,
     675    ataR3WriteSectorsSS,
     676    ataR3ExecuteDeviceDiagnosticSS,
     677    ataR3TrimSS,
     678    ataR3PacketSS,
     679    atapiR3GetConfigurationSS,
     680    atapiR3GetEventStatusNotificationSS,
     681    atapiR3IdentifySS,
     682    atapiR3InquirySS,
     683    atapiR3MechanismStatusSS,
     684    atapiR3ModeSenseErrorRecoverySS,
     685    atapiR3ModeSenseCDStatusSS,
     686    atapiR3ReadSS,
     687    atapiR3ReadCapacitySS,
     688    atapiR3ReadDiscInformationSS,
     689    atapiR3ReadTOCNormalSS,
     690    atapiR3ReadTOCMultiSS,
     691    atapiR3ReadTOCRawSS,
     692    atapiR3ReadTrackInformationSS,
     693    atapiR3RequestSenseSS,
     694    atapiR3PassthroughSS,
     695    atapiR3ReadDVDStructureSS
    696696};
    697697
    … …  
    702702static const ATARequest g_ataResetCRequest = { ATA_AIO_RESET_CLEARED,  { { 0, 0, 0, 0, 0 } } };
    703703
    704 static void ataAsyncIOClearRequests(PATACONTROLLER pCtl)
     704static void ataR3AsyncIOClearRequests(PATACONTROLLER pCtl)
    705705{
    706706    int rc = PDMCritSectEnter(&pCtl->AsyncIORequestLock, VINF_SUCCESS);
    … …  
    715715
    716716
    717 static void ataAsyncIOPutRequest(PATACONTROLLER pCtl, const ATARequest *pReq)
     717static void ataR3AsyncIOPutRequest(PATACONTROLLER pCtl, const ATARequest *pReq)
    718718{
    719719    int rc = PDMCritSectEnter(&pCtl->AsyncIORequestLock, VINF_SUCCESS);
    … …  
    737737
    738738
    739 static const ATARequest *ataAsyncIOGetCurrentRequest(PATACONTROLLER pCtl)
     739static const ATARequest *ataR3AsyncIOGetCurrentRequest(PATACONTROLLER pCtl)
    740740{
    741741    const ATARequest *pReq;
    … …  
    763763 * @param ReqType   Type of the request to remove.
    764764 */
    765 static void ataAsyncIORemoveCurrentRequest(PATACONTROLLER pCtl, ATAAIO ReqType)
     765static void ataR3AsyncIORemoveCurrentRequest(PATACONTROLLER pCtl, ATAAIO ReqType)
    766766{
    767767    int rc = PDMCritSectEnter(&pCtl->AsyncIORequestLock, VINF_SUCCESS);
    … …  
    786786 * @param pCtl      Controller for which to dump the queue.
    787787 */
    788 static void ataAsyncIODumpRequests(PATACONTROLLER pCtl)
     788static void ataR3AsyncIODumpRequests(PATACONTROLLER pCtl)
    789789{
    790790    int rc = PDMCritSectEnter(&pCtl->AsyncIORequestLock, VINF_SUCCESS);
    … …  
    835835 * @param fStrict   If set then the controller is checked to be idle.
    836836 */
    837 static bool ataAsyncIOIsIdle(PATACONTROLLER pCtl, bool fStrict)
     837static bool ataR3AsyncIOIsIdle(PATACONTROLLER pCtl, bool fStrict)
    838838{
    839839    int rc = PDMCritSectEnter(&pCtl->AsyncIORequestLock, VINF_SUCCESS);
    … …  
    862862 * @param   fChainedTransfer    Whether this is a transfer that is part of the previous command/transfer.
    863863 */
    864 static void ataStartTransfer(ATADevState *s, uint32_t cbTotalTransfer, uint8_t uTxDir, ATAFNBT iBeginTransfer, ATAFNSS iSourceSink, bool fChainedTransfer)
     864static void ataR3StartTransfer(ATADevState *s, uint32_t cbTotalTransfer, uint8_t uTxDir, ATAFNBT iBeginTransfer,
     865                               ATAFNSS iSourceSink, bool fChainedTransfer)
    865866{
    866867    PATACONTROLLER pCtl = ATADEVSTATE_2_CONTROLLER(s);
    … …  
    879880     * the command that is being submitted. Some broken guests issue commands
    880881     * twice (e.g. the Linux kernel that comes with Acronis True Image 8). */
    881     if (!fChainedTransfer && !ataAsyncIOIsIdle(pCtl, true /*fStrict*/))
     882    if (!fChainedTransfer && !ataR3AsyncIOIsIdle(pCtl, true /*fStrict*/))
    882883    {
    883884        Log(("%s: Ctl#%d: ignored command %#04x, controller state %d\n", __FUNCTION__, ATACONTROLLER_IDX(pCtl), s->uATARegCommand, pCtl->uAsyncIOState));
    … …  
    902903     */
    903904    Log2(("%s: Ctl#%d: message to async I/O thread, new request\n", __FUNCTION__, ATACONTROLLER_IDX(pCtl)));
    904     ataAsyncIOPutRequest(pCtl, &Req);
     905    ataR3AsyncIOPutRequest(pCtl, &Req);
    905906}
    906907
    … …  
    912913 * @param   fResetDrive Whether to reset the drive or just abort a command.
    913914 */
    914 static void ataAbortCurrentCommand(ATADevState *s, bool fResetDrive)
     915static void ataR3AbortCurrentCommand(ATADevState *s, bool fResetDrive)
    915916{
    916917    PATACONTROLLER pCtl = ATADEVSTATE_2_CONTROLLER(s);
    … …  
    931932    ataSetStatus(s, ATA_STAT_BUSY);
    932933    Log2(("%s: Ctl#%d: message to async I/O thread, abort command on LUN#%d\n", __FUNCTION__, ATACONTROLLER_IDX(pCtl), s->iLUN));
    933     ataAsyncIOPutRequest(pCtl, &Req);
    934 }
    935 
    936 
    937 static void ataSetIRQ(ATADevState *s)
     934    ataR3AsyncIOPutRequest(pCtl, &Req);
     935}
     936
     937
     938static void ataR3SetIRQ(ATADevState *s)
    938939{
    939940    PATACONTROLLER pCtl = ATADEVSTATE_2_CONTROLLER(s);
    … …  
    985986#ifdef IN_RING3
    986987
    987 static void ataPIOTransferStart(ATADevState *s, uint32_t start, uint32_t size)
     988static void ataR3PIOTransferStart(ATADevState *s, uint32_t start, uint32_t size)
    988989{
    989990    Log2(("%s: LUN#%d start %d size %d\n", __FUNCTION__, s->iLUN, start, size));
    … …  
    995996
    996997
    997 static void ataPIOTransferStop(ATADevState *s)
     998static void ataR3PIOTransferStop(ATADevState *s)
    998999{
    9991000    Log2(("%s: LUN#%d\n", __FUNCTION__, s->iLUN));
    … …  
    10021003        s->uATARegNSector = (s->uATARegNSector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
    10031004        Log2(("%s: interrupt reason %#04x\n", __FUNCTION__, s->uATARegNSector));
    1004         ataSetIRQ(s);
     1005        ataR3SetIRQ(s);
    10051006        s->fATAPITransfer = false;
    10061007    }
    … …  
    10141015
    10151016
    1016 static void ataPIOTransferLimitATAPI(ATADevState *s)
     1017static void ataR3PIOTransferLimitATAPI(ATADevState *s)
    10171018{
    10181019    uint32_t cbLimit, cbTransfer;
    … …  
    10391040
    10401041
    1041 static uint32_t ataGetNSectors(ATADevState *s)
     1042static uint32_t ataR3GetNSectors(ATADevState *s)
    10421043{
    10431044    /* 0 means either 256 (LBA28) or 65536 (LBA48) sectors. */
    … …  
    10591060
    10601061
    1061 static void ataPadString(uint8_t *pbDst, const char *pbSrc, uint32_t cbSize)
     1062static void ataR3PadString(uint8_t *pbDst, const char *pbSrc, uint32_t cbSize)
    10621063{
    10631064    for (uint32_t i = 0; i < cbSize; i++)
    … …  
    10711072
    10721073
    1073 static void ataSCSIPadStr(uint8_t *pbDst, const char *pbSrc, uint32_t cbSize)
     1074static void ataR3SCSIPadStr(uint8_t *pbDst, const char *pbSrc, uint32_t cbSize)
    10741075{
    10751076    for (uint32_t i = 0; i < cbSize; i++)
    … …  
    11671168}
    11681169
    1169 static void ataCmdOK(ATADevState *s, uint8_t status)
     1170static void ataR3CmdOK(ATADevState *s, uint8_t status)
    11701171{
    11711172    s->uATARegError = 0; /* Not needed by ATA spec, but cannot hurt. */
    … …  
    11741175
    11751176
    1176 static void ataCmdError(ATADevState *s, uint8_t uErrorCode)
     1177static void ataR3CmdError(ATADevState *s, uint8_t uErrorCode)
    11771178{
    11781179    Log(("%s: code=%#x\n", __FUNCTION__, uErrorCode));
    … …  
    11891190}
    11901191
    1191 static uint32_t ataChecksum(void* ptr, size_t count)
     1192static uint32_t ataR3Checksum(void* ptr, size_t count)
    11921193{
    11931194    uint8_t u8Sum = 0xa5, *p = (uint8_t*)ptr;
    … …  
    12021203}
    12031204
    1204 static bool ataIdentifySS(ATADevState *s)
     1205static bool ataR3IdentifySS(ATADevState *s)
    12051206{
    12061207    uint16_t *p;
    … …  
    12171218    p[5] = RT_H2LE_U16(s->cbSector);
    12181219    p[6] = RT_H2LE_U16(s->PCHSGeometry.cSectors);
    1219     ataPadString((uint8_t *)(p + 10), s->szSerialNumber, ATA_SERIAL_NUMBER_LENGTH); /* serial number */
     1220    ataR3PadString((uint8_t *)(p + 10), s->szSerialNumber, ATA_SERIAL_NUMBER_LENGTH); /* serial number */
    12201221    p[20] = RT_H2LE_U16(3); /* XXX: retired, cache type */
    12211222    p[21] = RT_H2LE_U16(512); /* XXX: retired, cache size in sectors */
    12221223    p[22] = RT_H2LE_U16(0); /* ECC bytes per sector */
    1223     ataPadString((uint8_t *)(p + 23), s->szFirmwareRevision, ATA_FIRMWARE_REVISION_LENGTH); /* firmware version */
    1224     ataPadString((uint8_t *)(p + 27), s->szModelNumber, ATA_MODEL_NUMBER_LENGTH); /* model */
    1225 #if ATA_MAX_MULT_SECTORS > 1
     1224    ataR3PadString((uint8_t *)(p + 23), s->szFirmwareRevision, ATA_FIRMWARE_REVISION_LENGTH); /* firmware version */
     1225    ataR3PadString((uint8_t *)(p + 27), s->szModelNumber, ATA_MODEL_NUMBER_LENGTH); /* model */
     1226# if ATA_MAX_MULT_SECTORS > 1
    12261227    p[47] = RT_H2LE_U16(0x8000 | ATA_MAX_MULT_SECTORS);
    1227 #endif
     1228# endif
    12281229    p[48] = RT_H2LE_U16(1); /* dword I/O, used by the BIOS */
    12291230    p[49] = RT_H2LE_U16(1 << 11 | 1 << 9 | 1 << 8); /* DMA and LBA supported */
    … …  
    13071308    if (s->fNonRotational)
    13081309        p[217] = RT_H2LE_U16(1); /* Non-rotational medium */
    1309     uint32_t uCsum = ataChecksum(p, 510);
     1310    uint32_t uCsum = ataR3Checksum(p, 510);
    13101311    p[255] = RT_H2LE_U16(0xa5 | (uCsum << 8)); /* Integrity word */
    13111312    s->iSourceSink = ATAFN_SS_NULL;
    1312     ataCmdOK(s, ATA_STAT_SEEK);
     1313    ataR3CmdOK(s, ATA_STAT_SEEK);
    13131314    return false;
    13141315}
    13151316
    13161317
    1317 static bool ataFlushSS(ATADevState *s)
     1318static bool ataR3FlushSS(ATADevState *s)
    13181319{
    13191320    PATACONTROLLER pCtl = ATADEVSTATE_2_CONTROLLER(s);
    … …  
    13331334    PDMCritSectEnter(&pCtl->lock, VINF_SUCCESS);
    13341335    STAM_PROFILE_STOP(&pCtl->StatLockWait, a);
    1335     ataCmdOK(s, 0);
     1336    ataR3CmdOK(s, 0);
    13361337    return false;
    13371338}
    13381339
    1339 static bool atapiIdentifySS(ATADevState *s)
     1340static bool atapiR3IdentifySS(ATADevState *s)
    13401341{
    13411342    uint16_t *p;
    … …  
    13481349    /* Removable CDROM, 3ms response, 12 byte packets */
    13491350    p[0] = RT_H2LE_U16(2 << 14 | 5 << 8 | 1 << 7 | 0 << 5 | 0 << 0);
    1350     ataPadString((uint8_t *)(p + 10), s->szSerialNumber, ATA_SERIAL_NUMBER_LENGTH); /* serial number */
     1351    ataR3PadString((uint8_t *)(p + 10), s->szSerialNumber, ATA_SERIAL_NUMBER_LENGTH); /* serial number */
    13511352    p[20] = RT_H2LE_U16(3); /* XXX: retired, cache type */
    13521353    p[21] = RT_H2LE_U16(512); /* XXX: retired, cache size in sectors */
    1353     ataPadString((uint8_t *)(p + 23), s->szFirmwareRevision, ATA_FIRMWARE_REVISION_LENGTH); /* firmware version */
    1354     ataPadString((uint8_t *)(p + 27), s->szModelNumber, ATA_MODEL_NUMBER_LENGTH); /* model */
     1354    ataR3PadString((uint8_t *)(p + 23), s->szFirmwareRevision, ATA_FIRMWARE_REVISION_LENGTH); /* firmware version */
     1355    ataR3PadString((uint8_t *)(p + 27), s->szModelNumber, ATA_MODEL_NUMBER_LENGTH); /* model */
    13551356    p[49] = RT_H2LE_U16(1 << 11 | 1 << 9 | 1 << 8); /* DMA and LBA supported */
    13561357    p[50] = RT_H2LE_U16(1 << 14);  /* No drive specific standby timer minimum */
    … …  
    13901391     * The sum of all 512 bytes is zero when the checksum is correct.
    13911392     */
    1392     uint32_t uCsum = ataChecksum(p, 510);
     1393    uint32_t uCsum = ataR3Checksum(p, 510);
    13931394    p[255] = RT_H2LE_U16(0xa5 | (uCsum << 8)); /* Integrity word */
    13941395
    13951396    s->iSourceSink = ATAFN_SS_NULL;
    1396     ataCmdOK(s, ATA_STAT_SEEK);
     1397    ataR3CmdOK(s, ATA_STAT_SEEK);
    13971398    return false;
    13981399}
    13991400
    14001401
    1401 static void ataSetSignature(ATADevState *s)
     1402static void ataR3SetSignature(ATADevState *s)
    14021403{
    14031404    s->uATARegSelect &= 0xf0; /* clear head */
    … …  
    14231424
    14241425
    1425 static uint64_t ataGetSector(ATADevState *s)
     1426static uint64_t ataR3GetSector(ATADevState *s)
    14261427{
    14271428    uint64_t iLBA;
    … …  
    14561457}
    14571458
    1458 static void ataSetSector(ATADevState *s, uint64_t iLBA)
     1459static void ataR3SetSector(ATADevState *s, uint64_t iLBA)
    14591460{
    14601461    uint32_t cyl, r;
    … …  
    14941495
    14951496
    1496 static void ataWarningDiskFull(PPDMDEVINS pDevIns)
     1497static void ataR3WarningDiskFull(PPDMDEVINS pDevIns)
    14971498{
    14981499    int rc;
    … …  
    15031504}
    15041505
    1505 static void ataWarningFileTooBig(PPDMDEVINS pDevIns)
     1506static void ataR3WarningFileTooBig(PPDMDEVINS pDevIns)
    15061507{
    15071508    int rc;
    … …  
    15121513}
    15131514
    1514 static void ataWarningISCSI(PPDMDEVINS pDevIns)
     1515static void ataR3WarningISCSI(PPDMDEVINS pDevIns)
    15151516{
    15161517    int rc;
    … …  
    15211522}
    15221523
    1523 static bool ataIsRedoSetWarning(ATADevState *s, int rc)
     1524static bool ataR3IsRedoSetWarning(ATADevState *s, int rc)
    15241525{
    15251526    PATACONTROLLER pCtl = ATADEVSTATE_2_CONTROLLER(s);
    … …  
    15281529    {
    15291530        pCtl->fRedoIdle = true;
    1530         ataWarningDiskFull(ATADEVSTATE_2_DEVINS(s));
     1531        ataR3WarningDiskFull(ATADEVSTATE_2_DEVINS(s));
    15311532        return true;
    15321533    }
    … …  
    15341535    {
    15351536        pCtl->fRedoIdle = true;
    1536         ataWarningFileTooBig(ATADEVSTATE_2_DEVINS(s));
     1537        ataR3WarningFileTooBig(ATADEVSTATE_2_DEVINS(s));
    15371538        return true;
    15381539    }
    … …  
    15421543        /* iSCSI connection abort (first error) or failure to reestablish
    15431544         * connection (second error). Pause VM. On resume we'll retry. */
    1544         ataWarningISCSI(ATADEVSTATE_2_DEVINS(s));
     1545        ataR3WarningISCSI(ATADEVSTATE_2_DEVINS(s));
    15451546        return true;
    15461547    }
    … …  
    15561557
    15571558
    1558 static int ataReadSectors(ATADevState *s, uint64_t u64Sector, void *pvBuf,
    1559                           uint32_t cSectors, bool *pfRedo)
     1559static int ataR3ReadSectors(ATADevState *s, uint64_t u64Sector, void *pvBuf,
     1560                            uint32_t cSectors, bool *pfRedo)
    15601561{
    15611562    PATACONTROLLER pCtl = ATADEVSTATE_2_CONTROLLER(s);
    … …  
    15691570    s->Led.Actual.s.fReading = 0;
    15701571    STAM_PROFILE_ADV_STOP(&s->StatReads, r);
    1571     Log4(("ataReadSectors: rc=%Rrc cSectors=%#x u64Sector=%llu\n%.*Rhxd\n",
     1572    Log4(("ataR3ReadSectors: rc=%Rrc cSectors=%#x u64Sector=%llu\n%.*Rhxd\n",
    15721573          rc, cSectors, u64Sector, cSectors * s->cbSector, pvBuf));
    15731574
    … …  
    15771578        *pfRedo = false;
    15781579    else
    1579         *pfRedo = ataIsRedoSetWarning(s, rc);
     1580        *pfRedo = ataR3IsRedoSetWarning(s, rc);
    15801581
    15811582    STAM_PROFILE_START(&pCtl->StatLockWait, a);
    … …  
    15861587
    15871588
    1588 static int ataWriteSectors(ATADevState *s, uint64_t u64Sector,
    1589                            const void *pvBuf, uint32_t cSectors, bool *pfRedo)
     1589static int ataR3WriteSectors(ATADevState *s, uint64_t u64Sector,
     1590                             const void *pvBuf, uint32_t cSectors, bool *pfRedo)
    15901591{
    15911592    PATACONTROLLER pCtl = ATADEVSTATE_2_CONTROLLER(s);
    … …  
    15961597    STAM_PROFILE_ADV_START(&s->StatWrites, w);
    15971598    s->Led.Asserted.s.fWriting = s->Led.Actual.s.fWriting = 1;
    1598 #ifdef VBOX_INSTRUMENT_DMA_WRITES
     1599# ifdef VBOX_INSTRUMENT_DMA_WRITES
    15991600    if (s->fDMA)
    16001601        STAM_PROFILE_ADV_START(&s->StatInstrVDWrites, vw);
    1601 #endif
     1602# endif
    16021603    rc = s->pDrvBlock->pfnWrite(s->pDrvBlock, u64Sector * s->cbSector, pvBuf, cSectors * s->cbSector);
    1603 #ifdef VBOX_INSTRUMENT_DMA_WRITES
     1604# ifdef VBOX_INSTRUMENT_DMA_WRITES
    16041605    if (s->fDMA)
    16051606        STAM_PROFILE_ADV_STOP(&s->StatInstrVDWrites, vw);
    1606 #endif
     1607# endif
    16071608    s->Led.Actual.s.fWriting = 0;
    16081609    STAM_PROFILE_ADV_STOP(&s->StatWrites, w);
    1609     Log4(("ataWriteSectors: rc=%Rrc cSectors=%#x u64Sector=%llu\n%.*Rhxd\n",
     1610    Log4(("ataR3WriteSectors: rc=%Rrc cSectors=%#x u64Sector=%llu\n%.*Rhxd\n",
    16101611          rc, cSectors, u64Sector, cSectors * s->cbSector, pvBuf));
    16111612
    … …  
    16151616        *pfRedo = false;
    16161617    else
    1617         *pfRedo = ataIsRedoSetWarning(s, rc);
     1618        *pfRedo = ataR3IsRedoSetWarning(s, rc);
    16181619
    16191620    STAM_PROFILE_START(&pCtl->StatLockWait, a);
    … …  
    16241625
    16251626
    1626 static void ataReadWriteSectorsBT(ATADevState *s)
     1627static void ataR3ReadWriteSectorsBT(ATADevState *s)
    16271628{
    16281629    uint32_t cSectors;
    … …  
    16341635        s->cbElementaryTransfer = cSectors * s->cbSector;
    16351636    if (s->uTxDir == PDMBLOCKTXDIR_TO_DEVICE)
    1636         ataCmdOK(s, 0);
    1637 }
    1638 
    1639 
    1640 static bool ataReadSectorsSS(ATADevState *s)
     1637        ataR3CmdOK(s, 0);
     1638}
     1639
     1640
     1641static bool ataR3ReadSectorsSS(ATADevState *s)
    16411642{
    16421643    int rc;
    … …  
    16471648    cSectors = s->cbElementaryTransfer / s->cbSector;
    16481649    Assert(cSectors);
    1649     iLBA = ataGetSector(s);
     1650    iLBA = ataR3GetSector(s);
    16501651    Log(("%s: %d sectors at LBA %d\n", __FUNCTION__, cSectors, iLBA));
    1651     rc = ataReadSectors(s, iLBA, s->CTX_SUFF(pbIOBuffer), cSectors, &fRedo);
     1652    rc = ataR3ReadSectors(s, iLBA, s->CTX_SUFF(pbIOBuffer), cSectors, &fRedo);
    16521653    if (RT_SUCCESS(rc))
    16531654    {
    1654         ataSetSector(s, iLBA + cSectors);
     1655        ataR3SetSector(s, iLBA + cSectors);
    16551656        if (s->cbElementaryTransfer == s->cbTotalTransfer)
    16561657            s->iSourceSink = ATAFN_SS_NULL;
    1657         ataCmdOK(s, ATA_STAT_SEEK);
     1658        ataR3CmdOK(s, ATA_STAT_SEEK);
    16581659    }
    16591660    else
    … …  
    16701671         */
    16711672        if (rc != VERR_INTERRUPTED)
    1672             ataCmdError(s, ID_ERR);
     1673            ataR3CmdError(s, ID_ERR);
    16731674    }
    16741675    return false;
    … …  
    16761677
    16771678
    1678 static bool ataWriteSectorsSS(ATADevState *s)
     1679static bool ataR3WriteSectorsSS(ATADevState *s)
    16791680{
    16801681    int rc;
    … …  
    16851686    cSectors = s->cbElementaryTransfer / s->cbSector;
    16861687    Assert(cSectors);
    1687     iLBA = ataGetSector(s);
     1688    iLBA = ataR3GetSector(s);
    16881689    Log(("%s: %d sectors at LBA %d\n", __FUNCTION__, cSectors, iLBA));
    1689     rc = ataWriteSectors(s, iLBA, s->CTX_SUFF(pbIOBuffer), cSectors, &fRedo);
     1690    rc = ataR3WriteSectors(s, iLBA, s->CTX_SUFF(pbIOBuffer), cSectors, &fRedo);
    16901691    if (RT_SUCCESS(rc))
    16911692    {
    1692         ataSetSector(s, iLBA + cSectors);
     1693        ataR3SetSector(s, iLBA + cSectors);
    16931694        if (!s->cbTotalTransfer)
    16941695            s->iSourceSink = ATAFN_SS_NULL;
    1695         ataCmdOK(s, ATA_STAT_SEEK);
     1696        ataR3CmdOK(s, ATA_STAT_SEEK);
    16961697    }
    16971698    else
    … …  
    17081709         */
    17091710        if (rc != VERR_INTERRUPTED)
    1710             ataCmdError(s, ID_ERR);
     1711            ataR3CmdError(s, ID_ERR);
    17111712    }
    17121713    return false;
    … …  
    17141715
    17151716
    1716 static void atapiCmdOK(ATADevState *s)
     1717static void atapiR3CmdOK(ATADevState *s)
    17171718{
    17181719    s->uATARegError = 0;
    … …  
    17291730
    17301731
    1731 static void atapiCmdError(ATADevState *s, const uint8_t *pabATAPISense, size_t cbATAPISense)
     1732static void atapiR3CmdError(ATADevState *s, const uint8_t *pabATAPISense, size_t cbATAPISense)
    17321733{
    17331734    Log(("%s: sense=%#x (%s) asc=%#x ascq=%#x (%s)\n", __FUNCTION__, pabATAPISense[2] & 0x0f, SCSISenseText(pabATAPISense[2] & 0x0f),
    … …  
    17511752
    17521753/** @todo deprecated function - doesn't provide enough info. Replace by direct
    1753  * calls to atapiCmdError()  with full data. */
    1754 static void atapiCmdErrorSimple(ATADevState *s, uint8_t uATAPISenseKey, uint8_t uATAPIASC)
     1754 * calls to atapiR3CmdError()  with full data. */
     1755static void atapiR3CmdErrorSimple(ATADevState *s, uint8_t uATAPISenseKey, uint8_t uATAPIASC)
    17551756{
    17561757    uint8_t abATAPISense[ATAPI_SENSE_SIZE];
    … …  
    17601761    abATAPISense[7] = 10;
    17611762    abATAPISense[12] = uATAPIASC;
    1762     atapiCmdError(s, abATAPISense, sizeof(abATAPISense));
    1763 }
    1764 
    1765 
    1766 static void atapiCmdBT(ATADevState *s)
     1763    atapiR3CmdError(s, abATAPISense, sizeof(abATAPISense));
     1764}
     1765
     1766
     1767static void atapiR3CmdBT(ATADevState *s)
    17671768{
    17681769    s->fATAPITransfer = true;
    … …  
    17711772    s->cbPIOTransferLimit = s->uATARegLCyl | (s->uATARegHCyl << 8);
    17721773    if (s->uTxDir == PDMBLOCKTXDIR_TO_DEVICE)
    1773         atapiCmdOK(s);
    1774 }
    1775 
    1776 
    1777 static void atapiPassthroughCmdBT(ATADevState *s)
    1778 {
    1779     /* @todo implement an algorithm for correctly determining the read and
     1774        atapiR3CmdOK(s);
     1775}
     1776
     1777
     1778static void atapiR3PassthroughCmdBT(ATADevState *s)
     1779{
     1780    /** @todo implement an algorithm for correctly determining the read and
    17801781     * write sector size without sending additional commands to the drive.
    17811782     * This should be doable by saving processing the configuration requests
    17821783     * and replies. */
    1783 #if 0
     1784# if 0
    17841785    if (s->uTxDir == PDMBLOCKTXDIR_TO_DEVICE)
    17851786    {
    … …  
    18071808            if (RT_FAILURE(rc))
    18081809            {
    1809                 atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_NONE);
     1810                atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_NONE);
    18101811                return;
    18111812            }
    … …  
    18481849        }
    18491850    }
    1850 #endif
    1851     atapiCmdBT(s);
    1852 }
    1853 
    1854 
    1855 static bool atapiReadSS(ATADevState *s)
     1851# endif
     1852    atapiR3CmdBT(s);
     1853}
     1854
     1855static bool atapiR3ReadSS(ATADevState *s)
    18561856{
    18571857    PATACONTROLLER pCtl = ATADEVSTATE_2_CONTROLLER(s);
    … …  
    19251925        if (cbTransfer >= s->cbTotalTransfer)
    19261926            s->iSourceSink = ATAFN_SS_NULL;
    1927         atapiCmdOK(s);
     1927        atapiR3CmdOK(s);
    19281928        s->iATAPILBA += cSectors;
    19291929    }
    … …  
    19381938         */
    19391939        if (rc != VERR_INTERRUPTED)
    1940             atapiCmdErrorSimple(s, SCSI_SENSE_MEDIUM_ERROR, SCSI_ASC_READ_ERROR);
     1940            atapiR3CmdErrorSimple(s, SCSI_SENSE_MEDIUM_ERROR, SCSI_ASC_READ_ERROR);
    19411941    }
    19421942    return false;
    … …  
    19461946 * Sets the given media track type.
    19471947 */
    1948 static uint32_t ataMediumTypeSet(ATADevState *s, uint32_t MediaTrackType)
     1948static uint32_t ataR3MediumTypeSet(ATADevState *s, uint32_t MediaTrackType)
    19491949{
    19501950    return ASMAtomicXchgU32(&s->MediaTrackType, MediaTrackType);
    19511951}
    19521952
    1953 static bool atapiPassthroughSS(ATADevState *s)
     1953static bool atapiR3PassthroughSS(ATADevState *s)
    19541954{
    19551955    PATACONTROLLER pCtl = ATADEVSTATE_2_CONTROLLER(s);
    … …  
    19821982    PDMCritSectLeave(&pCtl->lock);
    19831983
    1984 #if defined(LOG_ENABLED)
     1984# if defined(LOG_ENABLED)
    19851985    char szBuf[1024];
    19861986
    … …  
    20092009
    20102010    Log2(("%s\n", szBuf));
    2011 #endif
     2011# endif
    20122012
    20132013    if (pProf) { STAM_PROFILE_ADV_START(pProf, b); }
    … …  
    20522052                if (s->cErrors++ < MAX_LOG_REL_ERRORS)
    20532053                    LogRel(("PIIX3 ATA: LUN#%d: CD-ROM passthrough split error\n", s->iLUN));
    2054                 atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_ILLEGAL_OPCODE);
     2054                atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_ILLEGAL_OPCODE);
    20552055                {
    20562056                STAM_PROFILE_START(&pCtl->StatLockWait, a);
    … …  
    21272127                    if (s->cErrors++ < MAX_LOG_REL_ERRORS)
    21282128                        LogRel(("PIIX3 ATA: LUN#%d: CD-ROM passthrough split error\n", s->iLUN));
    2129                     atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_ILLEGAL_OPCODE);
     2129                    atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_ILLEGAL_OPCODE);
    21302130                    return false;
    21312131            }
    … …  
    21902190             * but only if the command wasn't split.
    21912191             */
    2192 #if 0   //@todo: This destroys commands where cbTotalTransfer > cbIOBuffer
     2192# if 0  /// @todo This destroys commands where cbTotalTransfer > cbIOBuffer
    21932193            if (s->cbElementaryTransfer < s->cbIOBuffer)
    21942194                s->cbTotalTransfer = cbTransfer;
    2195 #endif
     2195# endif
    21962196
    21972197            if (   s->aATAPICmd[0] == SCSI_INQUIRY
    … …  
    22022202                 *             invisible as possible to the guest. */
    22032203                Log3(("ATAPI PT inquiry data before (%d): %.*Rhxs\n", cbTransfer, cbTransfer, s->CTX_SUFF(pbIOBuffer)));
    2204                 ataSCSIPadStr(s->CTX_SUFF(pbIOBuffer) + 8, "VBOX", 8);
    2205                 ataSCSIPadStr(s->CTX_SUFF(pbIOBuffer) + 16, "CD-ROM", 16);
    2206                 ataSCSIPadStr(s->CTX_SUFF(pbIOBuffer) + 32, "1.0", 4);
     2204                ataR3PadString(s->CTX_SUFF(pbIOBuffer) + 8, "VBOX", 8);
     2205                ataR3PadString(s->CTX_SUFF(pbIOBuffer) + 16, "CD-ROM", 16);
     2206                ataR3PadString(s->CTX_SUFF(pbIOBuffer) + 32, "1.0", 4);
    22072207            }
    22082208
    … …  
    22182218        {
    22192219            s->iSourceSink = ATAFN_SS_NULL;
    2220             atapiCmdOK(s);
     2220            atapiR3CmdOK(s);
    22212221        }
    22222222    }
    … …  
    22402240            } while (0);
    22412241        }
    2242         atapiCmdError(s, abATAPISense, sizeof(abATAPISense));
     2242        atapiR3CmdError(s, abATAPISense, sizeof(abATAPISense));
    22432243    }
    22442244    return false;
    22452245}
    22462246
    2247 /** @todo: Revise ASAP. */
    2248 static bool atapiReadDVDStructureSS(ATADevState *s)
     2247/** @todo Revise ASAP. */
     2248static bool atapiR3ReadDVDStructureSS(ATADevState *s)
    22492249{
    22502250    uint8_t *buf = s->CTX_SUFF(pbIOBuffer);
    … …  
    23772377                {
    23782378                    s->iSourceSink = ATAFN_SS_NULL;
    2379                     atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, -uASC);
     2379                    atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, -uASC);
    23802380                    return false;
    23812381                }
    … …  
    23932393        default:
    23942394            s->iSourceSink = ATAFN_SS_NULL;
    2395             atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST,
     2395            atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST,
    23962396                                SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
    23972397            return false;
    … …  
    23992399
    24002400    s->iSourceSink = ATAFN_SS_NULL;
    2401     atapiCmdOK(s);
     2401    atapiR3CmdOK(s);
    24022402    return false;
    24032403}
    24042404
    2405 static bool atapiReadSectors(ATADevState *s, uint32_t iATAPILBA, uint32_t cSectors, uint32_t cbSector)
     2405static bool atapiR3ReadSectors(ATADevState *s, uint32_t iATAPILBA, uint32_t cSectors, uint32_t cbSector)
    24062406{
    24072407    Assert(cSectors > 0);
    24082408    s->iATAPILBA = iATAPILBA;
    24092409    s->cbATAPISector = cbSector;
    2410     ataStartTransfer(s, cSectors * cbSector, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_READ, true);
     2410    ataR3StartTransfer(s, cSectors * cbSector, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_READ, true);
    24112411    return false;
    24122412}
    24132413
    24142414
    2415 static bool atapiReadCapacitySS(ATADevState *s)
     2415static bool atapiR3ReadCapacitySS(ATADevState *s)
    24162416{
    24172417    uint8_t *pbBuf = s->CTX_SUFF(pbIOBuffer);
    … …  
    24222422    ataH2BE_U32(pbBuf + 4, 2048);
    24232423    s->iSourceSink = ATAFN_SS_NULL;
    2424     atapiCmdOK(s);
     2424    atapiR3CmdOK(s);
    24252425    return false;
    24262426}
    24272427
    24282428
    2429 static bool atapiReadDiscInformationSS(ATADevState *s)
     2429static bool atapiR3ReadDiscInformationSS(ATADevState *s)
    24302430{
    24312431    uint8_t *pbBuf = s->CTX_SUFF(pbIOBuffer);
    … …  
    24482448    ataH2BE_U32(pbBuf + 20, 0x00ffffff); /* last possible start time for lead-out is not available */
    24492449    s->iSourceSink = ATAFN_SS_NULL;
    2450     atapiCmdOK(s);
     2450    atapiR3CmdOK(s);
    24512451    return false;
    24522452}
    24532453
    24542454
    2455 static bool atapiReadTrackInformationSS(ATADevState *s)
     2455static bool atapiR3ReadTrackInformationSS(ATADevState *s)
    24562456{
    24572457    uint8_t *pbBuf = s->CTX_SUFF(pbIOBuffer);
    … …  
    24622462    if ((s->aATAPICmd[1] & 0x03) != 1 || ataBE2H_U32(&s->aATAPICmd[2]) != 1)
    24632463    {
    2464         atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
     2464        atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
    24652465        return false;
    24662466    }
    … …  
    24772477    pbBuf[33] = 0; /* session number (MSB) */
    24782478    s->iSourceSink = ATAFN_SS_NULL;
    2479     atapiCmdOK(s);
     2479    atapiR3CmdOK(s);
    24802480    return false;
    24812481}
    24822482
    2483 static uint32_t atapiGetConfigurationFillFeatureListProfiles(ATADevState *s, uint8_t *pbBuf, size_t cbBuf)
     2483static uint32_t atapiR3GetConfigurationFillFeatureListProfiles(ATADevState *s, uint8_t *pbBuf, size_t cbBuf)
    24842484{
    24852485    if (cbBuf < 3*4)
    … …  
    24992499}
    25002500
    2501 static uint32_t atapiGetConfigurationFillFeatureCore(ATADevState *s, uint8_t *pbBuf, size_t cbBuf)
     2501static uint32_t atapiR3GetConfigurationFillFeatureCore(ATADevState *s, uint8_t *pbBuf, size_t cbBuf)
    25022502{
    25032503    if (cbBuf < 12)
    … …  
    25142514}
    25152515
    2516 static uint32_t atapiGetConfigurationFillFeatureMorphing(ATADevState *s, uint8_t *pbBuf, size_t cbBuf)
     2516static uint32_t atapiR3GetConfigurationFillFeatureMorphing(ATADevState *s, uint8_t *pbBuf, size_t cbBuf)
    25172517{
    25182518    if (cbBuf < 8)
    … …  
    25282528}
    25292529
    2530 static uint32_t atapiGetConfigurationFillFeatureRemovableMedium(ATADevState *s, uint8_t *pbBuf, size_t cbBuf)
     2530static uint32_t atapiR3GetConfigurationFillFeatureRemovableMedium(ATADevState *s, uint8_t *pbBuf, size_t cbBuf)
    25312531{
    25322532    if (cbBuf < 8)
    … …  
    25432543}
    25442544
    2545 static uint32_t atapiGetConfigurationFillFeatureRandomReadable(ATADevState *s, uint8_t *pbBuf, size_t cbBuf)
     2545static uint32_t atapiR3GetConfigurationFillFeatureRandomReadable (ATADevState *s, uint8_t *pbBuf, size_t cbBuf)
    25462546{
    25472547    if (cbBuf < 12)
    … …  
    25592559}
    25602560
    2561 static uint32_t atapiGetConfigurationFillFeatureCDRead(ATADevState *s, uint8_t *pbBuf, size_t cbBuf)
     2561static uint32_t atapiR3GetConfigurationFillFeatureCDRead(ATADevState *s, uint8_t *pbBuf, size_t cbBuf)
    25622562{
    25632563    if (cbBuf < 8)
    … …  
    25732573}
    25742574
    2575 static uint32_t atapiGetConfigurationFillFeaturePowerManagement(ATADevState *s, uint8_t *pbBuf, size_t cbBuf)
     2575static uint32_t atapiR3GetConfigurationFillFeaturePowerManagement(ATADevState *s, uint8_t *pbBuf, size_t cbBuf)
    25762576{
    25772577    if (cbBuf < 4)
    … …  
    25852585}
    25862586
    2587 static uint32_t atapiGetConfigurationFillFeatureTimeout(ATADevState *s, uint8_t *pbBuf, size_t cbBuf)
     2587static uint32_t atapiR3GetConfigurationFillFeatureTimeout(ATADevState *s, uint8_t *pbBuf, size_t cbBuf)
    25882588{
    25892589    if (cbBuf < 8)
    … …  
    25982598}
    25992599
    2600 static bool atapiGetConfigurationSS(ATADevState *s)
     2600static bool atapiR3GetConfigurationSS(ATADevState *s)
    26012601{
    26022602    uint8_t *pbBuf = s->CTX_SUFF(pbIOBuffer);
    … …  
    26102610    if ((s->aATAPICmd[1] & 0x03) == 3 || u16Sfn != 0)
    26112611    {
    2612         atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
     2612        atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
    26132613        return false;
    26142614    }
    … …  
    26232623    pbBuf    += 8;
    26242624
    2625     cbCopied = atapiGetConfigurationFillFeatureListProfiles(s, pbBuf, cbBuf);
     2625    cbCopied = atapiR3GetConfigurationFillFeatureListProfiles(s, pbBuf, cbBuf);
    26262626    cbBuf -= cbCopied;
    26272627    pbBuf += cbCopied;
    26282628
    2629     cbCopied = atapiGetConfigurationFillFeatureCore(s, pbBuf, cbBuf);
     2629    cbCopied = atapiR3GetConfigurationFillFeatureCore(s, pbBuf, cbBuf);
    26302630    cbBuf -= cbCopied;
    26312631    pbBuf += cbCopied;
    26322632
    2633     cbCopied = atapiGetConfigurationFillFeatureMorphing(s, pbBuf, cbBuf);
     2633    cbCopied = atapiR3GetConfigurationFillFeatureMorphing(s, pbBuf, cbBuf);
    26342634    cbBuf -= cbCopied;
    26352635    pbBuf += cbCopied;
    26362636
    2637     cbCopied = atapiGetConfigurationFillFeatureRemovableMedium(s, pbBuf, cbBuf);
     2637    cbCopied = atapiR3GetConfigurationFillFeatureRemovableMedium(s, pbBuf, cbBuf);
    26382638    cbBuf -= cbCopied;
    26392639    pbBuf += cbCopied;
    26402640
    2641     cbCopied = atapiGetConfigurationFillFeatureRandomReadable(s, pbBuf, cbBuf);
     2641    cbCopied = atapiR3GetConfigurationFillFeatureRandomReadable (s, pbBuf, cbBuf);
    26422642    cbBuf -= cbCopied;
    26432643    pbBuf += cbCopied;
    26442644
    2645     cbCopied = atapiGetConfigurationFillFeatureCDRead(s, pbBuf, cbBuf);
     2645    cbCopied = atapiR3GetConfigurationFillFeatureCDRead(s, pbBuf, cbBuf);
    26462646    cbBuf -= cbCopied;
    26472647    pbBuf += cbCopied;
    26482648
    2649     cbCopied = atapiGetConfigurationFillFeaturePowerManagement(s, pbBuf, cbBuf);
     2649    cbCopied = atapiR3GetConfigurationFillFeaturePowerManagement(s, pbBuf, cbBuf);
    26502650    cbBuf -= cbCopied;
    26512651    pbBuf += cbCopied;
    26522652
    2653     cbCopied = atapiGetConfigurationFillFeatureTimeout(s, pbBuf, cbBuf);
     2653    cbCopied = atapiR3GetConfigurationFillFeatureTimeout(s, pbBuf, cbBuf);
    26542654    cbBuf -= cbCopied;
    26552655    pbBuf += cbCopied;
    … …  
    26602660    /* Other profiles we might want to add in the future: 0x40 (BD-ROM) and 0x50 (HDDVD-ROM) */
    26612661    s->iSourceSink = ATAFN_SS_NULL;
    2662     atapiCmdOK(s);
     2662    atapiR3CmdOK(s);
    26632663    return false;
    26642664}
    26652665
    26662666
    2667 static bool atapiGetEventStatusNotificationSS(ATADevState *s)
     2667static bool atapiR3GetEventStatusNotificationSS(ATADevState *s)
    26682668{
    26692669    uint8_t *pbBuf = s->CTX_SUFF(pbIOBuffer);
    … …  
    26752675    {
    26762676        /* no asynchronous operation supported */
    2677         atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
     2677        atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
    26782678        return false;
    26792679    }
    … …  
    27352735
    27362736    s->iSourceSink = ATAFN_SS_NULL;
    2737     atapiCmdOK(s);
     2737    atapiR3CmdOK(s);
    27382738    return false;
    27392739}
    27402740
    27412741
    2742 static bool atapiInquirySS(ATADevState *s)
     2742static bool atapiR3InquirySS(ATADevState *s)
    27432743{
    27442744    uint8_t *pbBuf = s->CTX_SUFF(pbIOBuffer);
    … …  
    27482748    pbBuf[0] = 0x05; /* CD-ROM */
    27492749    pbBuf[1] = 0x80; /* removable */
    2750 #if 1/*ndef VBOX*/  /** @todo implement MESN + AENC. (async notification on removal and stuff.) */
     2750# if 1/*ndef VBOX*/  /** @todo implement MESN + AENC. (async notification on removal and stuff.) */
    27512751    pbBuf[2] = 0x00; /* ISO */
    27522752    pbBuf[3] = 0x21; /* ATAPI-2 (XXX: put ATAPI-4 ?) */
    2753 #else
     2753# else
    27542754    pbBuf[2] = 0x00; /* ISO */
    27552755    pbBuf[3] = 0x91; /* format 1, MESN=1, AENC=9 ??? */
    2756 #endif
     2756# endif
    27572757    pbBuf[4] = 31; /* additional length */
    27582758    pbBuf[5] = 0; /* reserved */
    27592759    pbBuf[6] = 0; /* reserved */
    27602760    pbBuf[7] = 0; /* reserved */
    2761     ataSCSIPadStr(pbBuf + 8, s->szInquiryVendorId, 8);
    2762     ataSCSIPadStr(pbBuf + 16, s->szInquiryProductId, 16);
    2763     ataSCSIPadStr(pbBuf + 32, s->szInquiryRevision, 4);
     2761    ataR3PadString(pbBuf + 8, s->szInquiryVendorId, 8);
     2762    ataR3PadString(pbBuf + 16, s->szInquiryProductId, 16);
     2763    ataR3PadString(pbBuf + 32, s->szInquiryRevision, 4);
    27642764    s->iSourceSink = ATAFN_SS_NULL;
    2765     atapiCmdOK(s);
     2765    atapiR3CmdOK(s);
    27662766    return false;
    27672767}
    27682768
    27692769
    2770 static bool atapiModeSenseErrorRecoverySS(ATADevState *s)
     2770static bool atapiR3ModeSenseErrorRecoverySS(ATADevState *s)
    27712771{
    27722772    uint8_t *pbBuf = s->CTX_SUFF(pbIOBuffer);
    … …  
    27912791    pbBuf[15] = 0x00;
    27922792    s->iSourceSink = ATAFN_SS_NULL;
    2793     atapiCmdOK(s);
     2793    atapiR3CmdOK(s);
    27942794    return false;
    27952795}
    27962796
    27972797
    2798 static bool atapiModeSenseCDStatusSS(ATADevState *s)
     2798static bool atapiR3ModeSenseCDStatusSS(ATADevState *s)
    27992799{
    28002800    uint8_t *pbBuf = s->CTX_SUFF(pbIOBuffer);
    … …  
    28392839    ataH2BE_U16(&pbBuf[38], 0); /* number of write speed performance descriptors */
    28402840    s->iSourceSink = ATAFN_SS_NULL;
    2841     atapiCmdOK(s);
     2841    atapiR3CmdOK(s);
    28422842    return false;
    28432843}
    28442844
    28452845
    2846 static bool atapiRequestSenseSS(ATADevState *s)
     2846static bool atapiR3RequestSenseSS(ATADevState *s)
    28472847{
    28482848    uint8_t *pbBuf = s->CTX_SUFF(pbIOBuffer);
    … …  
    28522852    memcpy(pbBuf, s->abATAPISense, RT_MIN(s->cbElementaryTransfer, sizeof(s->abATAPISense)));
    28532853    s->iSourceSink = ATAFN_SS_NULL;
    2854     atapiCmdOK(s);
     2854    atapiR3CmdOK(s);
    28552855    return false;
    28562856}
    28572857
    28582858
    2859 static bool atapiMechanismStatusSS(ATADevState *s)
     2859static bool atapiR3MechanismStatusSS(ATADevState *s)
    28602860{
    28612861    uint8_t *pbBuf = s->CTX_SUFF(pbIOBuffer);
    … …  
    28712871    ataH2BE_U16(pbBuf + 6, 0);
    28722872    s->iSourceSink = ATAFN_SS_NULL;
    2873     atapiCmdOK(s);
     2873    atapiR3CmdOK(s);
    28742874    return false;
    28752875}
    28762876
    28772877
    2878 static bool atapiReadTOCNormalSS(ATADevState *s)
     2878static bool atapiR3ReadTOCNormalSS(ATADevState *s)
    28792879{
    28802880    uint8_t *pbBuf = s->CTX_SUFF(pbIOBuffer), *q, iStartTrack;
    … …  
    28872887    if (iStartTrack > 1 && iStartTrack != 0xaa)
    28882888    {
    2889         atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
     2889        atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
    28902890        return false;
    28912891    }
    … …  
    29332933        s->cbTotalTransfer = cbSize;
    29342934    s->iSourceSink = ATAFN_SS_NULL;
    2935     atapiCmdOK(s);
     2935    atapiR3CmdOK(s);
    29362936    return false;
    29372937}
    29382938
    29392939
    2940 static bool atapiReadTOCMultiSS(ATADevState *s)
     2940static bool atapiR3ReadTOCMultiSS(ATADevState *s)
    29412941{
    29422942    uint8_t *pbBuf = s->CTX_SUFF(pbIOBuffer);
    … …  
    29652965    }
    29662966    s->iSourceSink = ATAFN_SS_NULL;
    2967     atapiCmdOK(s);
     2967    atapiR3CmdOK(s);
    29682968    return false;
    29692969}
    29702970
    29712971
    2972 static bool atapiReadTOCRawSS(ATADevState *s)
     2972static bool atapiR3ReadTOCRawSS(ATADevState *s)
    29732973{
    29742974    uint8_t *pbBuf = s->CTX_SUFF(pbIOBuffer), *q, iStartTrack;
    … …  
    30523052        s->cbTotalTransfer = cbSize;
    30533053    s->iSourceSink = ATAFN_SS_NULL;
    3054     atapiCmdOK(s);
     3054    atapiR3CmdOK(s);
    30553055    return false;
    30563056}
    30573057
    30583058
    3059 static void atapiParseCmdVirtualATAPI(ATADevState *s)
     3059static void atapiR3ParseCmdVirtualATAPI(ATADevState *s)
    30603060{
    30613061    const uint8_t *pbPacket;
    … …  
    30713071            {
    30723072                if (s->cNotifiedMediaChange-- > 2)
    3073                     atapiCmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
     3073                    atapiR3CmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
    30743074                else
    3075                     atapiCmdErrorSimple(s, SCSI_SENSE_UNIT_ATTENTION, SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED); /* media changed */
     3075                    atapiR3CmdErrorSimple(s, SCSI_SENSE_UNIT_ATTENTION, SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED); /* media changed */
    30763076            }
    30773077            else if (s->pDrvMount->pfnIsMounted(s->pDrvMount))
    3078                 atapiCmdOK(s);
     3078                atapiR3CmdOK(s);
    30793079            else
    3080                 atapiCmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
     3080                atapiR3CmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
    30813081            break;
    30823082        case SCSI_GET_EVENT_STATUS_NOTIFICATION:
    30833083            cbMax = ataBE2H_U16(pbPacket + 7);
    3084             ataStartTransfer(s, RT_MIN(cbMax, 8), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_GET_EVENT_STATUS_NOTIFICATION, true);
     3084            ataR3StartTransfer(s, RT_MIN(cbMax, 8), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_GET_EVENT_STATUS_NOTIFICATION, true);
    30853085            break;
    30863086        case SCSI_MODE_SENSE_10:
    … …  
    30963096                    {
    30973097                        case SCSI_MODEPAGE_ERROR_RECOVERY:
    3098                             ataStartTransfer(s, RT_MIN(cbMax, 16), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_MODE_SENSE_ERROR_RECOVERY, true);
     3098                            ataR3StartTransfer(s, RT_MIN(cbMax, 16), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_MODE_SENSE_ERROR_RECOVERY, true);
    30993099                            break;
    31003100                        case SCSI_MODEPAGE_CD_STATUS:
    3101                             ataStartTransfer(s, RT_MIN(cbMax, 40), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_MODE_SENSE_CD_STATUS, true);
     3101                            ataR3StartTransfer(s, RT_MIN(cbMax, 40), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_MODE_SENSE_CD_STATUS, true);
    31023102                            break;
    31033103                        default:
    … …  
    31113111                default:
    31123112                case SCSI_PAGECONTROL_SAVED:
    3113                     atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_SAVING_PARAMETERS_NOT_SUPPORTED);
     3113                    atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_SAVING_PARAMETERS_NOT_SUPPORTED);
    31143114                    break;
    31153115            }
    … …  
    31183118        case SCSI_REQUEST_SENSE:
    31193119            cbMax = pbPacket[4];
    3120             ataStartTransfer(s, RT_MIN(cbMax, 18), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_REQUEST_SENSE, true);
     3120            ataR3StartTransfer(s, RT_MIN(cbMax, 18), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_REQUEST_SENSE, true);
    31213121            break;
    31223122        case SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL:
    … …  
    31273127                else
    31283128                    s->pDrvMount->pfnUnlock(s->pDrvMount);
    3129                 atapiCmdOK(s);
     3129                atapiR3CmdOK(s);
    31303130            }
    31313131            else
    3132                 atapiCmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
     3132                atapiR3CmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
    31333133            break;
    31343134        case SCSI_READ_10:
    … …  
    31403140            {
    31413141                s->cNotifiedMediaChange-- ;
    3142                 atapiCmdErrorSimple(s, SCSI_SENSE_UNIT_ATTENTION, SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED); /* media changed */
     3142                atapiR3CmdErrorSimple(s, SCSI_SENSE_UNIT_ATTENTION, SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED); /* media changed */
    31433143                break;
    31443144            }
    31453145            else if (!s->pDrvMount->pfnIsMounted(s->pDrvMount))
    31463146            {
    3147                 atapiCmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
     3147                atapiR3CmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
    31483148                break;
    31493149            }
    … …  
    31553155            if (cSectors == 0)
    31563156            {
    3157                 atapiCmdOK(s);
     3157                atapiR3CmdOK(s);
    31583158                break;
    31593159            }
    … …  
    31703170                    uLastLogTS = RTTimeMilliTS();
    31713171                }
    3172                 atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_LOGICAL_BLOCK_OOR);
     3172                atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_LOGICAL_BLOCK_OOR);
    31733173                break;
    31743174            }
    3175             atapiReadSectors(s, iATAPILBA, cSectors, 2048);
     3175            atapiR3ReadSectors(s, iATAPILBA, cSectors, 2048);
    31763176            break;
    31773177        }
    … …  
    31833183            {
    31843184                s->cNotifiedMediaChange-- ;
    3185                 atapiCmdErrorSimple(s, SCSI_SENSE_UNIT_ATTENTION, SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED); /* media changed */
     3185                atapiR3CmdErrorSimple(s, SCSI_SENSE_UNIT_ATTENTION, SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED); /* media changed */
    31863186                break;
    31873187            }
    31883188            else if (!s->pDrvMount->pfnIsMounted(s->pDrvMount))
    31893189            {
    3190                 atapiCmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
     3190                atapiR3CmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
    31913191                break;
    31923192            }
    … …  
    31953195            if (cSectors == 0)
    31963196            {
    3197                 atapiCmdOK(s);
     3197                atapiR3CmdOK(s);
    31983198                break;
    31993199            }
    … …  
    32103210                    uLastLogTS = RTTimeMilliTS();
    32113211                }
    3212                 atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_LOGICAL_BLOCK_OOR);
     3212                atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_LOGICAL_BLOCK_OOR);
    32133213                break;
    32143214            }
    … …  
    32173217                case 0x00:
    32183218                    /* nothing */
    3219                     atapiCmdOK(s);
     3219                    atapiR3CmdOK(s);
    32203220                    break;
    32213221                case 0x10:
    32223222                    /* normal read */
    3223                     atapiReadSectors(s, iATAPILBA, cSectors, 2048);
     3223                    atapiR3ReadSectors(s, iATAPILBA, cSectors, 2048);
    32243224                    break;
    32253225                case 0xf8:
    32263226                    /* read all data */
    3227                     atapiReadSectors(s, iATAPILBA, cSectors, 2352);
     3227                    atapiR3ReadSectors(s, iATAPILBA, cSectors, 2352);
    32283228                    break;
    32293229                default:
    32303230                    LogRel(("PIIX3 ATA: LUN#%d: CD-ROM sector format not supported (%#x)\n", s->iLUN, pbPacket[9] & 0xf8));
    3231                     atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
     3231                    atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
    32323232                    break;
    32333233            }
    … …  
    32403240            {
    32413241                s->cNotifiedMediaChange-- ;
    3242                 atapiCmdErrorSimple(s, SCSI_SENSE_UNIT_ATTENTION, SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED); /* media changed */
     3242                atapiR3CmdErrorSimple(s, SCSI_SENSE_UNIT_ATTENTION, SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED); /* media changed */
    32433243                break;
    32443244            }
    32453245            else if (!s->pDrvMount->pfnIsMounted(s->pDrvMount))
    32463246            {
    3247                 atapiCmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
     3247                atapiR3CmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
    32483248                break;
    32493249            }
    … …  
    32613261                    uLastLogTS = RTTimeMilliTS();
    32623262                }
    3263                 atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_LOGICAL_BLOCK_OOR);
     3263                atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_LOGICAL_BLOCK_OOR);
    32643264                break;
    32653265            }
    3266             atapiCmdOK(s);
     3266            atapiR3CmdOK(s);
    32673267            ataSetStatus(s, ATA_STAT_SEEK); /* Linux expects this. */
    32683268            break;
    … …  
    33073307            }
    33083308            if (RT_SUCCESS(rc))
    3309                 atapiCmdOK(s);
     3309                atapiR3CmdOK(s);
    33103310            else
    3311                 atapiCmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIA_LOAD_OR_EJECT_FAILED);
     3311                atapiR3CmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIA_LOAD_OR_EJECT_FAILED);
    33123312            break;
    33133313        }
    … …  
    33153315        {
    33163316            cbMax = ataBE2H_U16(pbPacket + 8);
    3317             ataStartTransfer(s, RT_MIN(cbMax, 8), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_MECHANISM_STATUS, true);
     3317            ataR3StartTransfer(s, RT_MIN(cbMax, 8), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_MECHANISM_STATUS, true);
    33183318            break;
    33193319        }
    … …  
    33253325            {
    33263326                s->cNotifiedMediaChange-- ;
    3327                 atapiCmdErrorSimple(s, SCSI_SENSE_UNIT_ATTENTION, SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED); /* media changed */
     3327                atapiR3CmdErrorSimple(s, SCSI_SENSE_UNIT_ATTENTION, SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED); /* media changed */
    33283328                break;
    33293329            }
    33303330            else if (!s->pDrvMount->pfnIsMounted(s->pDrvMount))
    33313331            {
    3332                 atapiCmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
     3332                atapiR3CmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
    33333333                break;
    33343334            }
    … …  
    33413341            {
    33423342                case 0:
    3343                     ataStartTransfer(s, cbMax, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_READ_TOC_NORMAL, true);
     3343                    ataR3StartTransfer(s, cbMax, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_READ_TOC_NORMAL, true);
    33443344                    break;
    33453345                case 1:
    3346                     ataStartTransfer(s, RT_MIN(cbMax, 12), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_READ_TOC_MULTI, true);
     3346                    ataR3StartTransfer(s, RT_MIN(cbMax, 12), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_READ_TOC_MULTI, true);
    33473347                    break;
    33483348                case 2:
    3349                     ataStartTransfer(s, cbMax, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_READ_TOC_RAW, true);
     3349                    ataR3StartTransfer(s, cbMax, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_READ_TOC_RAW, true);
    33503350                    break;
    33513351                default:
    33523352                  error_cmd:
    3353                     atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
     3353                    atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
    33543354                    break;
    33553355            }
    … …  
    33603360            {
    33613361                s->cNotifiedMediaChange-- ;
    3362                 atapiCmdErrorSimple(s, SCSI_SENSE_UNIT_ATTENTION, SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED); /* media changed */
     3362                atapiR3CmdErrorSimple(s, SCSI_SENSE_UNIT_ATTENTION, SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED); /* media changed */
    33633363                break;
    33643364            }
    33653365            else if (!s->pDrvMount->pfnIsMounted(s->pDrvMount))
    33663366            {
    3367                 atapiCmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
     3367                atapiR3CmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
    33683368                break;
    33693369            }
    3370             ataStartTransfer(s, 8, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_READ_CAPACITY, true);
     3370            ataR3StartTransfer(s, 8, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_READ_CAPACITY, true);
    33713371            break;
    33723372        case SCSI_READ_DISC_INFORMATION:
    … …  
    33743374            {
    33753375                s->cNotifiedMediaChange-- ;
    3376                 atapiCmdErrorSimple(s, SCSI_SENSE_UNIT_ATTENTION, SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED); /* media changed */
     3376                atapiR3CmdErrorSimple(s, SCSI_SENSE_UNIT_ATTENTION, SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED); /* media changed */
    33773377                break;
    33783378            }
    33793379            else if (!s->pDrvMount->pfnIsMounted(s->pDrvMount))
    33803380            {
    3381                 atapiCmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
     3381                atapiR3CmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
    33823382                break;
    33833383            }
    33843384            cbMax = ataBE2H_U16(pbPacket + 7);
    3385             ataStartTransfer(s, RT_MIN(cbMax, 34), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_READ_DISC_INFORMATION, true);
     3385            ataR3StartTransfer(s, RT_MIN(cbMax, 34), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_READ_DISC_INFORMATION, true);
    33863386            break;
    33873387        case SCSI_READ_TRACK_INFORMATION:
    … …  
    33893389            {
    33903390                s->cNotifiedMediaChange-- ;
    3391                 atapiCmdErrorSimple(s, SCSI_SENSE_UNIT_ATTENTION, SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED); /* media changed */
     3391                atapiR3CmdErrorSimple(s, SCSI_SENSE_UNIT_ATTENTION, SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED); /* media changed */
    33923392                break;
    33933393            }
    33943394            else if (!s->pDrvMount->pfnIsMounted(s->pDrvMount))
    33953395            {
    3396                 atapiCmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
     3396                atapiR3CmdErrorSimple(s, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT);
    33973397                break;
    33983398            }
    33993399            cbMax = ataBE2H_U16(pbPacket + 7);
    3400             ataStartTransfer(s, RT_MIN(cbMax, 36), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_READ_TRACK_INFORMATION, true);
     3400            ataR3StartTransfer(s, RT_MIN(cbMax, 36), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_READ_TRACK_INFORMATION, true);
    34013401            break;
    34023402        case SCSI_GET_CONFIGURATION:
    34033403            /* No media change stuff here, it can confuse Linux guests. */
    34043404            cbMax = ataBE2H_U16(pbPacket + 7);
    3405             ataStartTransfer(s, RT_MIN(cbMax, 80), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_GET_CONFIGURATION, true);
     3405            ataR3StartTransfer(s, RT_MIN(cbMax, 80), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_GET_CONFIGURATION, true);
    34063406            break;
    34073407        case SCSI_INQUIRY:
    34083408            cbMax = ataBE2H_U16(pbPacket + 3);
    3409             ataStartTransfer(s, RT_MIN(cbMax, 36), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_INQUIRY, true);
     3409            ataR3StartTransfer(s, RT_MIN(cbMax, 36), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_INQUIRY, true);
    34103410            break;
    34113411        case SCSI_READ_DVD_STRUCTURE:
    34123412        {
    34133413            cbMax = ataBE2H_U16(pbPacket + 8);
    3414             ataStartTransfer(s, RT_MIN(cbMax, 4), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_READ_DVD_STRUCTURE, true);
     3414            ataR3StartTransfer(s, RT_MIN(cbMax, 4), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_READ_DVD_STRUCTURE, true);
    34153415            break;
    34163416        }
    34173417        default:
    3418             atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_ILLEGAL_OPCODE);
     3418            atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_ILLEGAL_OPCODE);
    34193419            break;
    34203420    }
    … …  
    34253425 * Parse ATAPI commands, passing them directly to the CD/DVD drive.
    34263426 */
    3427 static void atapiParseCmdPassthrough(ATADevState *s)
     3427static void atapiR3ParseCmdPassthrough(ATADevState *s)
    34283428{
    34293429    const uint8_t *pbPacket;
    … …  
    34593459            if (ASMAtomicReadU32(&s->MediaEventStatus) != ATA_EVENT_STATUS_UNCHANGED)
    34603460            {
    3461                 ataStartTransfer(s, RT_MIN(cbTransfer, 8), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_GET_EVENT_STATUS_NOTIFICATION, true);
     3461                ataR3StartTransfer(s, RT_MIN(cbTransfer, 8), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_GET_EVENT_STATUS_NOTIFICATION, true);
    34623462                break;
    34633463            }
    … …  
    36123612            if ((s->abATAPISense[2] & 0x0f) != SCSI_SENSE_NONE)
    36133613            {
    3614                 ataStartTransfer(s, RT_MIN(cbTransfer, 18), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_REQUEST_SENSE, true);
     3614                ataR3StartTransfer(s, RT_MIN(cbTransfer, 18), PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_ATAPI_CMD, ATAFN_SS_ATAPI_REQUEST_SENSE, true);
    36153615                break;
    36163616            }
    … …  
    36943694                case 0x0f: /* activate deferred microcode */
    36953695                    LogRel(("PIIX3 ATA: LUN#%d: CD-ROM passthrough command attempted to update firmware, blocked\n", s->iLUN));
    3696                     atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
     3696                    atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
    36973697                    break;
    36983698                default:
    … …  
    37123712             * opcode 0x01" in syslog) and replies with a sense code of 0,
    37133713             * which sends cdrecord to an endless loop. */
    3714             atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_ILLEGAL_OPCODE);
     3714            atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_ILLEGAL_OPCODE);
    37153715            break;
    37163716        default:
    37173717            LogRel(("PIIX3 ATA: LUN#%d: passthrough unimplemented for command %#x\n", s->iLUN, pbPacket[0]));
    3718             atapiCmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_ILLEGAL_OPCODE);
     3718            atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_ILLEGAL_OPCODE);
    37193719            break;
    37203720        sendcmd:
    … …  
    37273727            if (cbTransfer == 0)
    37283728                uTxDir = PDMBLOCKTXDIR_NONE;
    3729             ataStartTransfer(s, cbTransfer, uTxDir, ATAFN_BT_ATAPI_PASSTHROUGH_CMD, ATAFN_SS_ATAPI_PASSTHROUGH, true);
    3730     }
    3731 }
    3732 
    3733 
    3734 static void atapiParseCmd(ATADevState *s)
     3729            ataR3StartTransfer(s, cbTransfer, uTxDir, ATAFN_BT_ATAPI_PASSTHROUGH_CMD, ATAFN_SS_ATAPI_PASSTHROUGH, true);
     3730    }
     3731}
     3732
     3733
     3734static void atapiR3ParseCmd(ATADevState *s)
    37353735{
    37363736    const uint8_t *pbPacket;
    37373737
    37383738    pbPacket = s->aATAPICmd;
    3739 #ifdef DEBUG
     3739# ifdef DEBUG
    37403740    Log(("%s: LUN#%d DMA=%d CMD=%#04x \"%s\"\n", __FUNCTION__, s->iLUN, s->fDMA, pbPacket[0], SCSICmdText(pbPacket[0])));
    3741 #else /* !DEBUG */
     3741# else /* !DEBUG */
    37423742    Log(("%s: LUN#%d DMA=%d CMD=%#04x\n", __FUNCTION__, s->iLUN, s->fDMA, pbPacket[0]));
    3743 #endif /* !DEBUG */
     3743# endif /* !DEBUG */
    37443744    Log2(("%s: limit=%#x packet: %.*Rhxs\n", __FUNCTION__, s->uATARegLCyl | (s->uATARegHCyl << 8), ATAPI_PACKET_SIZE, pbPacket));
    37453745
    37463746    if (s->fATAPIPassthrough)
    3747         atapiParseCmdPassthrough(s);
     3747        atapiR3ParseCmdPassthrough(s);
    37483748    else
    3749         atapiParseCmdVirtualATAPI(s);
    3750 }
    3751 
    3752 
    3753 static bool ataPacketSS(ATADevState *s)
     3749        atapiR3ParseCmdVirtualATAPI(s);
     3750}
     3751
     3752
     3753static bool ataR3PacketSS(ATADevState *s)
    37543754{
    37553755    s->fDMA = !!(s->uATARegFeature & 1);
    … …  
    37593759    s->cbElementaryTransfer = 0;
    37603760    s->cbAtapiPassthroughTransfer = 0;
    3761     atapiParseCmd(s);
     3761    atapiR3ParseCmd(s);
    37623762    return false;
    37633763}
    … …  
    37683768 * from now on, regardless if there was a medium inserted or not.
    37693769 */
    3770 static void ataMediumRemoved(ATADevState *s)
     3770static void ataR3MediumRemoved(ATADevState *s)
    37713771{
    37723772    ASMAtomicWriteU32(&s->MediaEventStatus, ATA_EVENT_STATUS_MEDIA_REMOVED);
    … …  
    37793779 * removed" event first.
    37803780 */
    3781 static void ataMediumInserted(ATADevState *s)
     3781static void ataR3MediumInserted(ATADevState *s)
    37823782{
    37833783    uint32_t OldStatus, NewStatus;
    … …  
    37993799}
    38003800
     3801
    38013802/**
    3802  * Called when a media is mounted.
    3803  *
    3804  * @param   pInterface      Pointer to the interface structure containing the called function pointer.
     3803 * @interface_method_impl{PDMIMOUNTNOTIFY, pfnMountNotify}
    38053804 */
    3806 static DECLCALLBACK(void) ataMountNotify(PPDMIMOUNTNOTIFY pInterface)
     3805static DECLCALLBACK(void) ataR3MountNotify(PPDMIMOUNTNOTIFY pInterface)
    38073806{
    38083807    ATADevState *pIf = PDMIMOUNTNOTIFY_2_ATASTATE(pInterface);
    … …  
    38233822    if (pIf->cNotifiedMediaChange < 2)
    38243823        pIf->cNotifiedMediaChange = 1;
    3825     ataMediumInserted(pIf);
    3826     ataMediumTypeSet(pIf, ATA_MEDIA_TYPE_UNKNOWN);
     3824    ataR3MediumInserted(pIf);
     3825    ataR3MediumTypeSet(pIf, ATA_MEDIA_TYPE_UNKNOWN);
    38273826}
    38283827
    38293828/**
    3830  * Called when a media is unmounted
    3831  * @param   pInterface      Pointer to the interface structure containing the called function pointer.
     3829 * @interface_method_impl{PDMIMOUNTNOTIFY, pfnUnmountNotify}
    38323830 */
    3833 static DECLCALLBACK(void) ataUnmountNotify(PPDMIMOUNTNOTIFY pInterface)
     3831static DECLCALLBACK(void) ataR3UnmountNotify(PPDMIMOUNTNOTIFY pInterface)
    38343832{
    38353833    ATADevState *pIf = PDMIMOUNTNOTIFY_2_ATASTATE(pInterface);
    … …  
    38443842     */
    38453843    pIf->cNotifiedMediaChange = 1;
    3846     ataMediumRemoved(pIf);
    3847     ataMediumTypeSet(pIf, ATA_MEDIA_NO_DISC);
    3848 }
    3849 
    3850 static void ataPacketBT(ATADevState *s)
     3844    ataR3MediumRemoved(pIf);
     3845    ataR3MediumTypeSet(pIf, ATA_MEDIA_NO_DISC);
     3846}
     3847
     3848static void ataR3PacketBT(ATADevState *s)
    38513849{
    38523850    s->cbElementaryTransfer = s->cbTotalTransfer;
    … …  
    38583856
    38593857
    3860 static void ataResetDevice(ATADevState *s)
     3858static void ataR3ResetDevice(ATADevState *s)
    38613859{
    38623860    s->cMultSectors = ATA_MAX_MULT_SECTORS;
    … …  
    38683866    s->uATARegSelect = 0x20;
    38693867    ataSetStatusValue(s, ATA_STAT_READY);
    3870     ataSetSignature(s);
     3868    ataR3SetSignature(s);
    38713869    s->cbTotalTransfer = 0;
    38723870    s->cbElementaryTransfer = 0;
    … …  
    38843882
    38853883
    3886 static bool ataExecuteDeviceDiagnosticSS(ATADevState *s)
    3887 {
    3888     ataSetSignature(s);
     3884static bool ataR3ExecuteDeviceDiagnosticSS(ATADevState *s)
     3885{
     3886    ataR3SetSignature(s);
    38893887    if (s->fATAPI)
    38903888        ataSetStatusValue(s, 0); /* NOTE: READY is _not_ set */
    … …  
    38963894
    38973895
    3898 static int ataTrimSectors(ATADevState *s, uint64_t u64Sector, uint32_t cSectors,
    3899                           bool *pfRedo)
     3896static int ataR3TrimSectors(ATADevState *s, uint64_t u64Sector, uint32_t cSectors,
     3897                            bool *pfRedo)
    39003898{
    39013899    RTRANGE TrimRange;
    … …  
    39153913        *pfRedo = false;
    39163914    else
    3917         *pfRedo = ataIsRedoSetWarning(s, rc);
     3915        *pfRedo = ataR3IsRedoSetWarning(s, rc);
    39183916
    39193917    STAM_PROFILE_START(&pCtl->StatLockWait, a);
    … …  
    39243922
    39253923
    3926 static bool ataTrimSS(ATADevState *s)
     3924static bool ataR3TrimSS(ATADevState *s)
    39273925{
    39283926    int rc = VERR_GENERAL_FAILURE;
    … …  
    39393937            break;
    39403938
    3941         rc = ataTrimSectors(s, *pu64Range & ATA_RANGE_LBA_MASK,
     3939        rc = ataR3TrimSectors(s, *pu64Range & ATA_RANGE_LBA_MASK,
    39423940                            ATA_RANGE_LENGTH_GET(*pu64Range), &fRedo);
    39433941        if (RT_FAILURE(rc))
    … …  
    39503948    {
    39513949        s->iSourceSink = ATAFN_SS_NULL;
    3952         ataCmdOK(s, ATA_STAT_SEEK);
     3950        ataR3CmdOK(s, ATA_STAT_SEEK);
    39533951    }
    39543952    else
    … …  
    39653963         */
    39663964        if (rc != VERR_INTERRUPTED)
    3967             ataCmdError(s, ID_ERR);
     3965            ataR3CmdError(s, ID_ERR);
    39683966    }
    39693967
    … …  
    39723970
    39733971
    3974 static void ataParseCmd(ATADevState *s, uint8_t cmd)
    3975 {
    3976 #ifdef DEBUG
     3972static void ataR3ParseCmd(ATADevState *s, uint8_t cmd)
     3973{
     3974# ifdef DEBUG
    39773975    Log(("%s: LUN#%d CMD=%#04x \"%s\"\n", __FUNCTION__, s->iLUN, cmd, ATACmdText(cmd)));
    3978 #else /* !DEBUG */
     3976# else /* !DEBUG */
    39793977    Log(("%s: LUN#%d CMD=%#04x\n", __FUNCTION__, s->iLUN, cmd));
    3980 #endif /* !DEBUG */
     3978# endif /* !DEBUG */
    39813979    s->fLBA48 = false;
    39823980    s->fDMA = false;
    … …  
    39973995        case ATA_IDENTIFY_DEVICE:
    39983996            if (s->pDrvBlock && !s->fATAPI)
    3999                 ataStartTransfer(s, 512, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_NULL, ATAFN_SS_IDENTIFY, false);
     3997                ataR3StartTransfer(s, 512, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_NULL, ATAFN_SS_IDENTIFY, false);
    40003998            else
    40013999            {
    40024000                if (s->fATAPI)
    4003                     ataSetSignature(s);
    4004                 ataCmdError(s, ABRT_ERR);
     4001                    ataR3SetSignature(s);
     4002                ataR3CmdError(s, ABRT_ERR);
    40054003                ataUnsetStatus(s, ATA_STAT_READY);
    4006                 ataSetIRQ(s); /* Shortcut, do not use AIO thread. */
     4004                ataR3SetIRQ(s); /* Shortcut, do not use AIO thread. */
    40074005            }
    40084006            break;
    … …  
    40124010            /* fall through */
    40134011        case ATA_INITIALIZE_DEVICE_PARAMETERS:
    4014             ataCmdOK(s, ATA_STAT_SEEK);
    4015             ataSetIRQ(s); /* Shortcut, do not use AIO thread. */
     4012            ataR3CmdOK(s, ATA_STAT_SEEK);
     4013            ataR3SetIRQ(s); /* Shortcut, do not use AIO thread. */
    40164014            break;
    40174015        case ATA_SET_MULTIPLE_MODE:
    … …  
    40204018                     || (s->uATARegNSector & (s->uATARegNSector - 1)) != 0))
    40214019            {
    4022                 ataCmdError(s, ABRT_ERR);
     4020                ataR3CmdError(s, ABRT_ERR);
    40234021            }
    40244022            else
    … …  
    40264024                Log2(("%s: set multi sector count to %d\n", __FUNCTION__, s->uATARegNSector));
    40274025                s->cMultSectors = s->uATARegNSector;
    4028                 ataCmdOK(s, 0);
     4026                ataR3CmdOK(s, 0);
    40294027            }
    4030             ataSetIRQ(s); /* Shortcut, do not use AIO thread. */
     4028            ataR3SetIRQ(s); /* Shortcut, do not use AIO thread. */
    40314029            break;
    40324030        case ATA_READ_VERIFY_SECTORS_EXT:
    … …  
    40354033        case ATA_READ_VERIFY_SECTORS_WITHOUT_RETRIES:
    40364034            /* do sector number check ? */
    4037             ataCmdOK(s, ATA_STAT_SEEK);
    4038             ataSetIRQ(s); /* Shortcut, do not use AIO thread. */
     4035            ataR3CmdOK(s, ATA_STAT_SEEK);
     4036            ataR3SetIRQ(s); /* Shortcut, do not use AIO thread. */
    40394037            break;
    40404038        case ATA_READ_SECTORS_EXT:
    … …  
    40454043                goto abort_cmd;
    40464044            s->cSectorsPerIRQ = 1;
    4047             ataStartTransfer(s, ataGetNSectors(s) * s->cbSector, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_READ_WRITE_SECTORS, ATAFN_SS_READ_SECTORS, false);
     4045            ataR3StartTransfer(s, ataR3GetNSectors(s) * s->cbSector, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_READ_WRITE_SECTORS, ATAFN_SS_READ_SECTORS, false);
    40484046            break;
    40494047        case ATA_WRITE_SECTORS_EXT:
    … …  
    40544052                goto abort_cmd;
    40554053            s->cSectorsPerIRQ = 1;
    4056             ataStartTransfer(s, ataGetNSectors(s) * s->cbSector, PDMBLOCKTXDIR_TO_DEVICE, ATAFN_BT_READ_WRITE_SECTORS, ATAFN_SS_WRITE_SECTORS, false);
     4054            ataR3StartTransfer(s, ataR3GetNSectors(s) * s->cbSector, PDMBLOCKTXDIR_TO_DEVICE, ATAFN_BT_READ_WRITE_SECTORS, ATAFN_SS_WRITE_SECTORS, false);
    40574055            break;
    40584056        case ATA_READ_MULTIPLE_EXT:
    … …  
    40624060                goto abort_cmd;
    40634061            s->cSectorsPerIRQ = s->cMultSectors;
    4064             ataStartTransfer(s, ataGetNSectors(s) * s->cbSector, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_READ_WRITE_SECTORS, ATAFN_SS_READ_SECTORS, false);
     4062            ataR3StartTransfer(s, ataR3GetNSectors(s) * s->cbSector, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_READ_WRITE_SECTORS, ATAFN_SS_READ_SECTORS, false);
    40654063            break;
    40664064        case ATA_WRITE_MULTIPLE_EXT:
    … …  
    40704068                goto abort_cmd;
    40714069            s->cSectorsPerIRQ = s->cMultSectors;
    4072             ataStartTransfer(s, ataGetNSectors(s) * s->cbSector, PDMBLOCKTXDIR_TO_DEVICE, ATAFN_BT_READ_WRITE_SECTORS, ATAFN_SS_WRITE_SECTORS, false);
     4070            ataR3StartTransfer(s, ataR3GetNSectors(s) * s->cbSector, PDMBLOCKTXDIR_TO_DEVICE, ATAFN_BT_READ_WRITE_SECTORS, ATAFN_SS_WRITE_SECTORS, false);
    40734071            break;
    40744072        case ATA_READ_DMA_EXT:
    … …  
    40804078            s->cSectorsPerIRQ = ATA_MAX_MULT_SECTORS;
    40814079            s->fDMA = true;
    4082             ataStartTransfer(s, ataGetNSectors(s) * s->cbSector, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_READ_WRITE_SECTORS, ATAFN_SS_READ_SECTORS, false);
     4080            ataR3StartTransfer(s, ataR3GetNSectors(s) * s->cbSector, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_READ_WRITE_SECTORS, ATAFN_SS_READ_SECTORS, false);
    40834081            break;
    40844082        case ATA_WRITE_DMA_EXT:
    … …  
    40904088            s->cSectorsPerIRQ = ATA_MAX_MULT_SECTORS;
    40914089            s->fDMA = true;
    4092             ataStartTransfer(s, ataGetNSectors(s) * s->cbSector, PDMBLOCKTXDIR_TO_DEVICE, ATAFN_BT_READ_WRITE_SECTORS, ATAFN_SS_WRITE_SECTORS, false);
     4090            ataR3StartTransfer(s, ataR3GetNSectors(s) * s->cbSector, PDMBLOCKTXDIR_TO_DEVICE, ATAFN_BT_READ_WRITE_SECTORS, ATAFN_SS_WRITE_SECTORS, false);
    40934091            break;
    40944092        case ATA_READ_NATIVE_MAX_ADDRESS_EXT:
    40954093            s->fLBA48 = true;
    4096             ataSetSector(s, s->cTotalSectors - 1);
    4097             ataCmdOK(s, 0);
    4098             ataSetIRQ(s); /* Shortcut, do not use AIO thread. */
     4094            ataR3SetSector(s, s->cTotalSectors - 1);
     4095            ataR3CmdOK(s, 0);
     4096            ataR3SetIRQ(s); /* Shortcut, do not use AIO thread. */
    40994097            break;
    41004098        case ATA_SEEK: /* Used by the SCO OpenServer. Command is marked as obsolete */
    4101             ataCmdOK(s, 0);
    4102             ataSetIRQ(s); /* Shortcut, do not use AIO thread. */
     4099            ataR3CmdOK(s, 0);
     4100            ataR3SetIRQ(s); /* Shortcut, do not use AIO thread. */
    41034101            break;
    41044102        case ATA_READ_NATIVE_MAX_ADDRESS:
    4105             ataSetSector(s, RT_MIN(s->cTotalSectors, 1 << 28) - 1);
    4106             ataCmdOK(s, 0);
    4107             ataSetIRQ(s); /* Shortcut, do not use AIO thread. */
     4103            ataR3SetSector(s, RT_MIN(s->cTotalSectors, 1 << 28) - 1);
     4104            ataR3CmdOK(s, 0);
     4105            ataR3SetIRQ(s); /* Shortcut, do not use AIO thread. */
    41084106            break;
    41094107        case ATA_CHECK_POWER_MODE:
    41104108            s->uATARegNSector = 0xff; /* drive active or idle */
    4111             ataCmdOK(s, 0);
    4112             ataSetIRQ(s); /* Shortcut, do not use AIO thread. */
     4109            ataR3CmdOK(s, 0);
     4110            ataR3SetIRQ(s); /* Shortcut, do not use AIO thread. */
    41134111            break;
    41144112        case ATA_SET_FEATURES:
    … …  
    41204118                case 0x02: /* write cache enable */
    41214119                    Log2(("%s: write cache enable\n", __FUNCTION__));
    4122                     ataCmdOK(s, ATA_STAT_SEEK);
    4123                     ataSetIRQ(s); /* Shortcut, do not use AIO thread. */
     4120                    ataR3CmdOK(s, ATA_STAT_SEEK);
     4121                    ataR3SetIRQ(s); /* Shortcut, do not use AIO thread. */
    41244122                    break;
    41254123                case 0xaa: /* read look-ahead enable */
    41264124                    Log2(("%s: read look-ahead enable\n", __FUNCTION__));
    4127                     ataCmdOK(s, ATA_STAT_SEEK);
    4128                     ataSetIRQ(s); /* Shortcut, do not use AIO thread. */
     4125                    ataR3CmdOK(s, ATA_STAT_SEEK);
     4126                    ataR3SetIRQ(s); /* Shortcut, do not use AIO thread. */
    41294127                    break;
    41304128                case 0x55: /* read look-ahead disable */
    41314129                    Log2(("%s: read look-ahead disable\n", __FUNCTION__));
    4132                     ataCmdOK(s, ATA_STAT_SEEK);
    4133                     ataSetIRQ(s); /* Shortcut, do not use AIO thread. */
     4130                    ataR3CmdOK(s, ATA_STAT_SEEK);
     4131                    ataR3SetIRQ(s); /* Shortcut, do not use AIO thread. */
    41344132                    break;
    41354133                case 0xcc: /* reverting to power-on defaults enable */
    41364134                    Log2(("%s: revert to power-on defaults enable\n", __FUNCTION__));
    4137                     ataCmdOK(s, ATA_STAT_SEEK);
    4138                     ataSetIRQ(s); /* Shortcut, do not use AIO thread. */
     4135                    ataR3CmdOK(s, ATA_STAT_SEEK);
     4136                    ataR3SetIRQ(s); /* Shortcut, do not use AIO thread. */
    41394137                    break;
    41404138                case 0x66: /* reverting to power-on defaults disable */
    41414139                    Log2(("%s: revert to power-on defaults disable\n", __FUNCTION__));
    4142                     ataCmdOK(s, ATA_STAT_SEEK);
    4143                     ataSetIRQ(s); /* Shortcut, do not use AIO thread. */
     4140                    ataR3CmdOK(s, ATA_STAT_SEEK);
     4141                    ataR3SetIRQ(s); /* Shortcut, do not use AIO thread. */
    41444142                    break;
    41454143                case 0x82: /* write cache disable */
    … …  
    41474145                    /* As per the ATA/ATAPI-6 specs, a write cache disable
    41484146                     * command MUST flush the write buffers to disc. */
    4149                     ataStartTransfer(s, 0, PDMBLOCKTXDIR_NONE, ATAFN_BT_NULL, ATAFN_SS_FLUSH, false);
     4147                    ataR3StartTransfer(s, 0, PDMBLOCKTXDIR_NONE, ATAFN_BT_NULL, ATAFN_SS_FLUSH, false);
    41504148                    break;
    41514149                case 0x03: { /* set transfer mode */
    … …  
    41654163                            goto abort_cmd;
    41664164                    }
    4167                     ataCmdOK(s, ATA_STAT_SEEK);
    4168                     ataSetIRQ(s); /* Shortcut, do not use AIO thread. */
     4165                    ataR3CmdOK(s, ATA_STAT_SEEK);
     4166                    ataR3SetIRQ(s); /* Shortcut, do not use AIO thread. */
    41694167                    break;
    41704168                }
    … …  
    41844182            if (!s->pDrvBlock || s->fATAPI)
    41854183                goto abort_cmd;
    4186             ataStartTransfer(s, 0, PDMBLOCKTXDIR_NONE, ATAFN_BT_NULL, ATAFN_SS_FLUSH, false);
     4184            ataR3StartTransfer(s, 0, PDMBLOCKTXDIR_NONE, ATAFN_BT_NULL, ATAFN_SS_FLUSH, false);
    41874185            break;
    41884186        case ATA_STANDBY_IMMEDIATE:
    4189             ataCmdOK(s, 0);
    4190             ataSetIRQ(s); /* Shortcut, do not use AIO thread. */
     4187            ataR3CmdOK(s, 0);
     4188            ataR3SetIRQ(s); /* Shortcut, do not use AIO thread. */
    41914189            break;
    41924190        case ATA_IDLE_IMMEDIATE:
    41934191            LogRel(("PIIX3 ATA: LUN#%d: aborting current command\n", s->iLUN));
    4194             ataAbortCurrentCommand(s, false);
     4192            ataR3AbortCurrentCommand(s, false);
    41954193            break;
    41964194        case ATA_SLEEP:
    4197             ataCmdOK(s, 0);
    4198             ataSetIRQ(s);
     4195            ataR3CmdOK(s, 0);
     4196            ataR3SetIRQ(s);
    41994197            break;
    42004198            /* ATAPI commands */
    42014199        case ATA_IDENTIFY_PACKET_DEVICE:
    42024200            if (s->fATAPI)
    4203                 ataStartTransfer(s, 512, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_NULL, ATAFN_SS_ATAPI_IDENTIFY, false);
     4201                ataR3StartTransfer(s, 512, PDMBLOCKTXDIR_FROM_DEVICE, ATAFN_BT_NULL, ATAFN_SS_ATAPI_IDENTIFY, false);
    42044202            else
    42054203            {
    4206                 ataCmdError(s, ABRT_ERR);
    4207                 ataSetIRQ(s); /* Shortcut, do not use AIO thread. */
     4204                ataR3CmdError(s, ABRT_ERR);
     4205                ataR3SetIRQ(s); /* Shortcut, do not use AIO thread. */
    42084206            }
    42094207            break;
    42104208        case ATA_EXECUTE_DEVICE_DIAGNOSTIC:
    4211             ataStartTransfer(s, 0, PDMBLOCKTXDIR_NONE, ATAFN_BT_NULL, ATAFN_SS_EXECUTE_DEVICE_DIAGNOSTIC, false);
     4209            ataR3StartTransfer(s, 0, PDMBLOCKTXDIR_NONE, ATAFN_BT_NULL, ATAFN_SS_EXECUTE_DEVICE_DIAGNOSTIC, false);
    42124210            break;
    42134211        case ATA_DEVICE_RESET:
    … …  
    42154213                goto abort_cmd;
    42164214            LogRel(("PIIX3 ATA: LUN#%d: performing device RESET\n", s->iLUN));
    4217             ataAbortCurrentCommand(s, true);
     4215            ataR3AbortCurrentCommand(s, true);
    42184216            break;
    42194217        case ATA_PACKET:
    … …  
    42234221            if (s->uATARegFeature & 0x02)
    42244222                goto abort_cmd;
    4225             ataStartTransfer(s, ATAPI_PACKET_SIZE, PDMBLOCKTXDIR_TO_DEVICE, ATAFN_BT_PACKET, ATAFN_SS_PACKET, false);
     4223            ataR3StartTransfer(s, ATAPI_PACKET_SIZE, PDMBLOCKTXDIR_TO_DEVICE, ATAFN_BT_PACKET, ATAFN_SS_PACKET, false);
    42264224            break;
    42274225        case ATA_DATA_SET_MANAGEMENT:
    … …  
    42324230                goto abort_cmd;
    42334231            s->fDMA = true;
    4234             ataStartTransfer(s, (s->uATARegNSectorHOB << 8 | s->uATARegNSector) * s->cbSector, PDMBLOCKTXDIR_TO_DEVICE, ATAFN_BT_NULL, ATAFN_SS_TRIM, false);
     4232            ataR3StartTransfer(s, (s->uATARegNSectorHOB << 8 | s->uATARegNSector) * s->cbSector, PDMBLOCKTXDIR_TO_DEVICE, ATAFN_BT_NULL, ATAFN_SS_TRIM, false);
    42354233            break;
    42364234        default:
    42374235        abort_cmd:
    4238             ataCmdError(s, ABRT_ERR);
     4236            ataR3CmdError(s, ABRT_ERR);
    42394237            if (s->fATAPI)
    42404238                ataUnsetStatus(s, ATA_STAT_READY);
    4241             ataSetIRQ(s); /* Shortcut, do not use AIO thread. */
     4239            ataR3SetIRQ(s); /* Shortcut, do not use AIO thread. */
    42424240            break;
    42434241    }
    … …  
    43674365            return VINF_IOM_R3_IOPORT_WRITE;
    43684366#else /* IN_RING3 */
    4369             ataParseCmd(&pCtl->aIfs[pCtl->iSelectedIf], val);
     4367            ataR3ParseCmd(&pCtl->aIfs[pCtl->iSelectedIf], val);
    43704368#endif /* !IN_RING3 */
    43714369    }
    … …  
    45874585        for (uint32_t i = 0; i < RT_ELEMENTS(pCtl->aIfs); i++)
    45884586        {
    4589             ataResetDevice(&pCtl->aIfs[i]);
     4587            ataR3ResetDevice(&pCtl->aIfs[i]);
    45904588            /* The following cannot be done using ataSetStatusValue() since the
    45914589             * reset flag is already set, which suppresses all status changes. */
    … …  
    45944592            pCtl->aIfs[i].uATARegError = 0x01;
    45954593        }
    4596         ataAsyncIOClearRequests(pCtl);
     4594        ataR3AsyncIOClearRequests(pCtl);
    45974595        Log2(("%s: Ctl#%d: message to async I/O thread, resetA\n", __FUNCTION__, ATACONTROLLER_IDX(pCtl)));
    45984596        if (val & ATA_DEVCTL_HOB)
    … …  
    46064604
    46074605        /* Issue the reset request now. */
    4608         ataAsyncIOPutRequest(pCtl, &g_ataResetARequest);
     4606        ataR3AsyncIOPutRequest(pCtl, &g_ataResetARequest);
    46094607#else /* !IN_RING3 */
    46104608        AssertMsgFailed(("RESET handling is too complicated for GC\n"));
    … …  
    46234621            Log2(("%s: ignored setting HOB\n", __FUNCTION__));
    46244622        }
    4625         ataAsyncIOPutRequest(pCtl, &g_ataResetCRequest);
     4623        ataR3AsyncIOPutRequest(pCtl, &g_ataResetCRequest);
    46264624#else /* !IN_RING3 */
    46274625        AssertMsgFailed(("RESET handling is too complicated for GC\n"));
    … …  
    46674665#ifdef IN_RING3
    46684666
    4669 static void ataPIOTransfer(PATACONTROLLER pCtl)
     4667static void ataR3PIOTransfer(PATACONTROLLER pCtl)
    46704668{
    46714669    ATADevState *s;
    … …  
    46994697    {
    47004698        if (s->fATAPITransfer)
    4701             ataPIOTransferLimitATAPI(s);
     4699            ataR3PIOTransferLimitATAPI(s);
    47024700
    47034701        if (s->uTxDir == PDMBLOCKTXDIR_TO_DEVICE && s->cbElementaryTransfer > s->cbTotalTransfer)
    … …  
    47084706             s->cbTotalTransfer, s->cbElementaryTransfer,
    47094707             s->iIOBufferCur, s->iIOBufferEnd));
    4710         ataPIOTransferStart(s, s->iIOBufferCur, s->cbElementaryTransfer);
     4708        ataR3PIOTransferStart(s, s->iIOBufferCur, s->cbElementaryTransfer);
    47114709        s->cbTotalTransfer -= s->cbElementaryTransfer;
    47124710        s->iIOBufferCur += s->cbElementaryTransfer;
    … …  
    47164714    }
    47174715    else
    4718         ataPIOTransferStop(s);
    4719 }
    4720 
    4721 
    4722 DECLINLINE(void) ataPIOTransferFinish(PATACONTROLLER pCtl, ATADevState *s)
     4716        ataR3PIOTransferStop(s);
     4717}
     4718
     4719
     4720DECLINLINE(void) ataR3PIOTransferFinish(PATACONTROLLER pCtl, ATADevState *s)
    47234721{
    47244722    /* Do not interfere with RESET processing if the PIO transfer finishes
    … …  
    47414739
    47424740        Log2(("%s: Ctl#%d: message to async I/O thread, continuing PIO transfer\n", __FUNCTION__, ATACONTROLLER_IDX(pCtl)));
    4743         ataAsyncIOPutRequest(pCtl, &g_ataPIORequest);
     4741        ataR3AsyncIOPutRequest(pCtl, &g_ataPIORequest);
    47444742    }
    47454743    else
    … …  
    47564754            /* There is more to transfer, happens usually for large ATAPI
    47574755             * reads - the protocol limits the chunk size to 65534 bytes. */
    4758             ataPIOTransfer(pCtl);
    4759             ataSetIRQ(s);
     4756            ataR3PIOTransfer(pCtl);
     4757            ataR3SetIRQ(s);
    47604758        }
    47614759        else
    … …  
    47634761            Log2(("%s: Ctl#%d: skipping message to async I/O thread, ending PIO transfer\n", __FUNCTION__, ATACONTROLLER_IDX(pCtl)));
    47644762            /* Finish PIO transfer. */
    4765             ataPIOTransfer(pCtl);
     4763            ataR3PIOTransfer(pCtl);
    47664764            Assert(!pCtl->fRedo);
    47674765        }
    … …  
    47944792        s->iIOBufferPIODataStart += cbSize;
    47954793        if (s->iIOBufferPIODataStart >= s->iIOBufferPIODataEnd)
    4796             ataPIOTransferFinish(pCtl, s);
     4794            ataR3PIOTransferFinish(pCtl, s);
    47974795#endif /* IN_RING3 */
    47984796    }
    … …  
    48264824        s->iIOBufferPIODataStart += cbSize;
    48274825        if (s->iIOBufferPIODataStart >= s->iIOBufferPIODataEnd)
    4828             ataPIOTransferFinish(pCtl, s);
     4826            ataR3PIOTransferFinish(pCtl, s);
    48294827#endif /* IN_RING3 */
    48304828    }
    … …  
    48404838#ifdef IN_RING3
    48414839
    4842 static void ataDMATransferStop(ATADevState *s)
     4840static void ataR3DMATransferStop(ATADevState *s)
    48434841{
    48444842    s->cbTotalTransfer = 0;
    … …  
    48564854 * @param pCtl      Controller for which to perform the transfer.
    48574855 */
    4858 static void ataDMATransfer(PATACONTROLLER pCtl)
     4856static void ataR3DMATransfer(PATACONTROLLER pCtl)
    48594857{
    48604858    PPDMDEVINS pDevIns = CONTROLLER_2_DEVINS(pCtl);
    … …  
    50055003            LogRel(("PIIX3 ATA: Ctl#%d: ABORT DMA%s\n", ATACONTROLLER_IDX(pCtl), pCtl->fReset ? " due to RESET" : ""));
    50065004            if (!pCtl->fReset)
    5007                 ataDMATransferStop(s);
     5005                ataR3DMATransferStop(s);
    50085006            /* This forces the loop to exit immediately. */
    50095007            pDesc = pCtl->pLastDMADesc + 1;
    … …  
    50455043
    50465044    if (    pCtl->fSignalIdle
    5047         &&  ataAsyncIOIsIdle(pCtl, false /*fStrict*/))
     5045        &&  ataR3AsyncIOIsIdle(pCtl, false /*fStrict*/))
    50485046    {
    50495047        PDMDevHlpAsyncNotificationCompleted(pCtl->pDevInsR3);
    … …  
    51075105                break;
    51085106
    5109             pReq = ataAsyncIOGetCurrentRequest(pCtl);
     5107            pReq = ataR3AsyncIOGetCurrentRequest(pCtl);
    51105108        }
    51115109
    … …  
    51285126            {
    51295127                /* Incorrect sequence of PIO/DMA states. Dump request queue. */
    5130                 ataAsyncIODumpRequests(pCtl);
     5128                ataR3AsyncIODumpRequests(pCtl);
    51315129            }
    51325130            AssertReleaseMsg(ReqType == ATA_AIO_RESET_ASSERTED || ReqType == ATA_AIO_RESET_CLEARED || ReqType == ATA_AIO_ABORT || pCtl->uAsyncIOState == ReqType, ("I/O state inconsistent: state=%d request=%d\n", pCtl->uAsyncIOState, ReqType));
    … …  
    52125210                             * request. Occurs very rarely, not worth optimizing. */
    52135211                            LogRel(("%s: Ctl#%d: redo entire operation\n", __FUNCTION__, ATACONTROLLER_IDX(pCtl)));
    5214                             ataAsyncIOPutRequest(pCtl, pReq);
     5212                            ataR3AsyncIOPutRequest(pCtl, pReq);
    52155213                            break;
    52165214                        }
    52175215                    }
    52185216                    else
    5219                         ataCmdOK(s, 0);
     5217                        ataR3CmdOK(s, 0);
    52205218                    s->iIOBufferEnd = s->cbElementaryTransfer;
    52215219
    … …  
    52405238                        {
    52415239                            Log2(("%s: Ctl#%d: message to async I/O thread, continuing DMA transfer immediately\n", __FUNCTION__, ATACONTROLLER_IDX(pCtl)));
    5242                             ataAsyncIOPutRequest(pCtl, &g_ataDMARequest);
     5240                            ataR3AsyncIOPutRequest(pCtl, &g_ataDMARequest);
    52435241                        }
    52445242                    }
    … …  
    52475245                        Assert(s->uTxDir == PDMBLOCKTXDIR_NONE); /* Any transfer which has an initial transfer size of 0 must be marked as such. */
    52485246                        /* Finish DMA transfer. */
    5249                         ataDMATransferStop(s);
    5250                         ataSetIRQ(s);
     5247                        ataR3DMATransferStop(s);
     5248                        ataR3SetIRQ(s);
    52515249                        pCtl->uAsyncIOState = ATA_AIO_NEW;
    52525250                    }
    … …  
    52565254                    if (s->cbTotalTransfer)
    52575255                    {
    5258                         ataPIOTransfer(pCtl);
     5256                        ataR3PIOTransfer(pCtl);
    52595257                        Assert(!pCtl->fRedo);
    52605258                        if (s->fATAPITransfer || s->uTxDir != PDMBLOCKTXDIR_TO_DEVICE)
    5261                             ataSetIRQ(s);
     5259                            ataR3SetIRQ(s);
    52625260
    52635261                        if (s->uTxDir == PDMBLOCKTXDIR_TO_DEVICE || s->iSourceSink != ATAFN_SS_NULL)
    … …  
    52845282                        Assert(s->uTxDir == PDMBLOCKTXDIR_NONE); /* Any transfer which has an initial transfer size of 0 must be marked as such. */
    52855283                        /* Finish PIO transfer. */
    5286                         ataPIOTransfer(pCtl);
     5284                        ataR3PIOTransfer(pCtl);
    52875285                        Assert(!pCtl->fRedo);
    52885286                        if (!s->fATAPITransfer)
    5289                             ataSetIRQ(s);
     5287                            ataR3SetIRQ(s);
    52905288                        pCtl->uAsyncIOState = ATA_AIO_NEW;
    52915289                    }
    … …  
    53115309                    pCtl->pLastDMADesc = RT_ALIGN_32(bm->pvAddr + 1, _4K) - sizeof(BMDMADesc);
    53125310                }
    5313                 ataDMATransfer(pCtl);
     5311                ataR3DMATransfer(pCtl);
    53145312
    53155313                if (RT_UNLIKELY(pCtl->fRedo && !pCtl->fReset))
    53165314                {
    53175315                    LogRel(("PIIX3 ATA: Ctl#%d: redo DMA operation\n", ATACONTROLLER_IDX(pCtl)));
    5318                     ataAsyncIOPutRequest(pCtl, &g_ataDMARequest);
     5316                    ataR3AsyncIOPutRequest(pCtl, &g_ataDMARequest);
    53195317                    break;
    53205318                }
    … …  
    53445342                    s->fATAPITransfer = false;
    53455343                }
    5346                 ataSetIRQ(s);
     5344                ataR3SetIRQ(s);
    53475345                pCtl->uAsyncIOState = ATA_AIO_NEW;
    53485346                break;
    … …  
    53615359                    {
    53625360                        LogRel(("PIIX3 ATA: Ctl#%d: redo PIO operation\n", ATACONTROLLER_IDX(pCtl)));
    5363                         ataAsyncIOPutRequest(pCtl, &g_ataPIORequest);
     5361                        ataR3AsyncIOPutRequest(pCtl, &g_ataPIORequest);
    53645362                        break;
    53655363                    }
    … …  
    53845382                if (s->cbTotalTransfer)
    53855383                {
    5386                     ataPIOTransfer(pCtl);
    5387                     ataSetIRQ(s);
     5384                    ataR3PIOTransfer(pCtl);
     5385                    ataR3SetIRQ(s);
    53885386
    53895387                    if (s->uTxDir == PDMBLOCKTXDIR_TO_DEVICE || s->iSourceSink != ATAFN_SS_NULL)
    … …  
    54095407                {
    54105408                    /* Finish PIO transfer. */
    5411                     ataPIOTransfer(pCtl);
     5409                    ataR3PIOTransfer(pCtl);
    54125410                    if (    !pCtl->fChainedTransfer
    54135411                        &&  !s->fATAPITransfer
    54145412                        &&  s->uTxDir != PDMBLOCKTXDIR_FROM_DEVICE)
    54155413                    {
    5416                             ataSetIRQ(s);
     5414                            ataR3SetIRQ(s);
    54175415                    }
    54185416                    pCtl->uAsyncIOState = ATA_AIO_NEW;
    … …  
    54225420            case ATA_AIO_RESET_ASSERTED:
    54235421                pCtl->uAsyncIOState = ATA_AIO_RESET_CLEARED;
    5424                 ataPIOTransferStop(&pCtl->aIfs[0]);
    5425                 ataPIOTransferStop(&pCtl->aIfs[1]);
     5422                ataR3PIOTransferStop(&pCtl->aIfs[0]);
     5423                ataR3PIOTransferStop(&pCtl->aIfs[1]);
    54265424                /* Do not change the DMA registers, they are not affected by the
    54275425                 * ATA controller reset logic. It should be sufficient to issue a
    … …  
    54445442                    else
    54455443                        ataSetStatusValue(&pCtl->aIfs[i], ATA_STAT_READY | ATA_STAT_SEEK);
    5446                     ataSetSignature(&pCtl->aIfs[i]);
     5444                    ataR3SetSignature(&pCtl->aIfs[i]);
    54475445                }
    54485446                break;
    … …  
    54605458                if (pReq->u.a.fResetDrive)
    54615459                {
    5462                     ataResetDevice(s);
    5463                     ataExecuteDeviceDiagnosticSS(s);
     5460                    ataR3ResetDevice(s);
     5461                    ataR3ExecuteDeviceDiagnosticSS(s);
    54645462                }
    54655463                else
    … …  
    54675465                    /* Stop any pending DMA transfer. */
    54685466                    s->fDMA = false;
    5469                     ataPIOTransferStop(s);
     5467                    ataR3PIOTransferStop(s);
    54705468                    ataUnsetStatus(s, ATA_STAT_BUSY | ATA_STAT_DRQ | ATA_STAT_SEEK | ATA_STAT_ERR);
    54715469                    ataSetStatus(s, ATA_STAT_READY);
    5472                     ataSetIRQ(s);
     5470                    ataR3SetIRQ(s);
    54735471                }
    54745472                break;
    … …  
    54785476        }
    54795477
    5480         ataAsyncIORemoveCurrentRequest(pCtl, ReqType);
    5481         pReq = ataAsyncIOGetCurrentRequest(pCtl);
     5478        ataR3AsyncIORemoveCurrentRequest(pCtl, ReqType);
     5479        pReq = ataR3AsyncIOGetCurrentRequest(pCtl);
    54825480
    54835481        if (pCtl->uAsyncIOState == ATA_AIO_NEW && !pCtl->fChainedTransfer)
    … …  
    55965594        {
    55975595            Log2(("%s: Ctl#%d: message to async I/O thread, continuing DMA transfer\n", __FUNCTION__, ATACONTROLLER_IDX(pCtl)));
    5598             ataAsyncIOPutRequest(pCtl, &g_ataDMARequest);
     5596            ataR3AsyncIOPutRequest(pCtl, &g_ataDMARequest);
    55995597        }
    56005598#else /* !IN_RING3 */
    … …  
    57305728 * @param   enmType         One of the PCI_ADDRESS_SPACE_* values.
    57315729 */
    5732 static DECLCALLBACK(int) ataBMDMAIORangeMap(PPCIDEVICE pPciDev, /*unsigned*/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
     5730static DECLCALLBACK(int) ataR3BMDMAIORangeMap(PPCIDEVICE pPciDev, /*unsigned*/ int iRegion,
     5731                                              RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
    57335732{
    57345733    PCIATAState *pThis = PCIDEV_2_PCIATASTATE(pPciDev);
    … …  
    57425741    {
    57435742        int rc2 = PDMDevHlpIOPortRegister(pPciDev->pDevIns, (RTIOPORT)GCPhysAddress + i * 8, 8,
    5744                                           (RTHCPTR)(uintptr_t)i, ataBMDMAIOPortWrite, ataBMDMAIOPortRead, NULL, NULL, "ATA Bus Master DMA");
     5743                                          (RTHCPTR)(uintptr_t)i, ataBMDMAIOPortWrite, ataBMDMAIOPortRead,
     5744                                          NULL, NULL, "ATA Bus Master DMA");
    57455745        AssertRC(rc2);
    57465746        if (rc2 < rc)
    … …  
    57505750        {
    57515751            rc2 = PDMDevHlpIOPortRegisterRC(pPciDev->pDevIns, (RTIOPORT)GCPhysAddress + i * 8, 8,
    5752                                             (RTGCPTR)i, "ataBMDMAIOPortWrite", "ataBMDMAIOPortRead", NULL, NULL, "ATA Bus Master DMA");
     5752                                            (RTGCPTR)i, "ataBMDMAIOPortWrite", "ataBMDMAIOPortRead",
     5753                                            NULL, NULL, "ATA Bus Master DMA");
    57535754            AssertRC(rc2);
    57545755            if (rc2 < rc)
    … …  
    57585759        {
    57595760            rc2 = PDMDevHlpIOPortRegisterR0(pPciDev->pDevIns, (RTIOPORT)GCPhysAddress + i * 8, 8,
    5760                                             (RTR0PTR)i, "ataBMDMAIOPortWrite", "ataBMDMAIOPortRead", NULL, NULL, "ATA Bus Master DMA");
     5761                                            (RTR0PTR)i, "ataBMDMAIOPortWrite", "ataBMDMAIOPortRead",
     5762                                            NULL, NULL, "ATA Bus Master DMA");
    57615763            AssertRC(rc2);
    57625764            if (rc2 < rc)
    … …  
    57735775 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
    57745776 */
    5775 static DECLCALLBACK(void *) ataStatus_QueryInterface(PPDMIBASE pInterface, const char *pszIID)
     5777static DECLCALLBACK(void *) ataR3Status_QueryInterface(PPDMIBASE pInterface, const char *pszIID)
    57765778{
    57775779    PCIATAState *pThis = PDMIBASE_2_PCIATASTATE(pInterface);
    … …  
    57925794 * @param   ppLed           Where to store the LED pointer.
    57935795 */
    5794 static DECLCALLBACK(int) ataStatus_QueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
     5796static DECLCALLBACK(int) ataR3Status_QueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
    57955797{
    57965798    PCIATAState *pThis = PDMILEDPORTS_2_PCIATASTATE(pInterface);
    … …  
    58165818 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
    58175819 */
    5818 static DECLCALLBACK(void *)  ataQueryInterface(PPDMIBASE pInterface, const char *pszIID)
     5820static DECLCALLBACK(void *) ataR3QueryInterface(PPDMIBASE pInterface, const char *pszIID)
    58195821{
    58205822    ATADevState *pIf = PDMIBASE_2_ATASTATE(pInterface);
    … …  
    58475849    return VINF_SUCCESS;
    58485850}
     5851
    58495852#endif /* IN_RING3 */
    5850 
    58515853
    58525854/* -=-=-=-=-=- Wrappers  -=-=-=-=-=- */
    … …  
    58615863    PCIATAState   *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
    58625864    PATACONTROLLER pCtl = &pThis->aCts[i];
    5863     int            rc = VINF_SUCCESS;
    58645865
    58655866    Assert(i < 2);
    58665867
    5867     rc = PDMCritSectEnter(&pCtl->lock, VINF_IOM_R3_IOPORT_WRITE);
    5868     if (rc != VINF_SUCCESS)
    5869         return rc;
    5870     if (Port == pCtl->IOPortBase1)
    5871     {
    5872         /* Writes to the data port may be 16-bit or 32-bit. */
    5873         Assert(cb == 2 || cb == 4);
    5874         rc = ataDataWrite(pCtl, Port, cb, (const uint8_t *)&u32);
    5875     }
    5876     else
    5877     {
    5878         /* Writes to the other command block ports should be 8-bit only. If they
    5879          * are not, the high bits are simply discarded. Undocumented, but observed
    5880          * on a real PIIX4 system.
    5881          */
    5882         if (cb > 1)
    5883             Log(("ataIOPortWrite1: suspect write to port %x val=%x size=%d\n", Port, u32, cb));
    5884 
    5885         rc = ataIOPortWriteU8(pCtl, Port, u32);
    5886     }
    5887     PDMCritSectLeave(&pCtl->lock);
     5868    int rc = PDMCritSectEnter(&pCtl->lock, VINF_IOM_R3_IOPORT_WRITE);
     5869    if (rc == VINF_SUCCESS)
     5870    {
     5871        if (Port == pCtl->IOPortBase1)
     5872        {
     5873            /* Writes to the data port may be 16-bit or 32-bit. */
     5874            Assert(cb == 2 || cb == 4);
     5875            rc = ataDataWrite(pCtl, Port, cb, (const uint8_t *)&u32);
     5876        }
     5877        else
     5878        {
     5879            /* Writes to the other command block ports should be 8-bit only. If they
     5880             * are not, the high bits are simply discarded. Undocumented, but observed
     5881             * on a real PIIX4 system.
     5882             */
     5883            if (cb > 1)
     5884                Log(("ataIOPortWrite1: suspect write to port %x val=%x size=%d\n", Port, u32, cb));
     5885
     5886            rc = ataIOPortWriteU8(pCtl, Port, u32);
     5887        }
     5888        PDMCritSectLeave(&pCtl->lock);
     5889    }
    58885890    return rc;
    58895891}
    … …  
    58995901    PCIATAState   *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
    59005902    PATACONTROLLER pCtl = &pThis->aCts[i];
    5901     int            rc = VINF_SUCCESS;
    59025903
    59035904    Assert(i < 2);
    59045905
    5905     rc = PDMCritSectEnter(&pCtl->lock, VINF_IOM_R3_IOPORT_READ);
    5906     if (rc != VINF_SUCCESS)
    5907         return rc;
    5908     if (Port == pCtl->IOPortBase1)
    5909     {
    5910         /* Reads from the data register may be 16-bit or 32-bit. */
    5911         Assert(cb == 1 || cb == 2 || cb == 4);
    5912         rc = ataDataRead(pCtl, Port, cb == 1 ? 2 : cb, (uint8_t *)pu32);
    5913         if (cb <= 2)
    5914             *pu32 &= 0xffff >> (16 - cb * 8);
    5915     }
    5916     else
    5917     {
    5918         /* Reads from the other command block registers should be 8-bit only.
    5919          * If they are not, the low byte is propagated to the high bits.
    5920          * Undocumented, but observed on a real PIIX4 system.
    5921          */
    5922         rc = ataIOPortReadU8(pCtl, Port, pu32);
    5923         if (cb > 1)
    5924         {
    5925             uint32_t    pad;
    5926 
    5927             /* Replicate the 8-bit result into the upper three bytes. */
    5928             pad = *pu32 & 0xff;
    5929             pad = pad | (pad << 8);
    5930             pad = pad | (pad << 16);
    5931             *pu32 = pad;
    5932             Log(("ataIOPortRead1: suspect read from port %x size=%d\n", Port, cb));
    5933         }
    5934     }
    5935     PDMCritSectLeave(&pCtl->lock);
     5906    int rc = PDMCritSectEnter(&pCtl->lock, VINF_IOM_R3_IOPORT_READ);
     5907    if (rc == VINF_SUCCESS)
     5908    {
     5909        if (Port == pCtl->IOPortBase1)
     5910        {
     5911            /* Reads from the data register may be 16-bit or 32-bit. */
     5912            Assert(cb == 1 || cb == 2 || cb == 4);
     5913            rc = ataDataRead(pCtl, Port, cb == 1 ? 2 : cb, (uint8_t *)pu32);
     5914            if (cb <= 2)
     5915                *pu32 &= 0xffff >> (16 - cb * 8);
     5916        }
     5917        else
     5918        {
     5919            /* Reads from the other command block registers should be 8-bit only.
     5920             * If they are not, the low byte is propagated to the high bits.
     5921             * Undocumented, but observed on a real PIIX4 system.
     5922             */
     5923            rc = ataIOPortReadU8(pCtl, Port, pu32);
     5924            if (cb > 1)
     5925            {
     5926                uint32_t    pad;
     5927
     5928                /* Replicate the 8-bit result into the upper three bytes. */
     5929                pad = *pu32 & 0xff;
     5930                pad = pad | (pad << 8);
     5931                pad = pad | (pad << 16);
     5932                *pu32 = pad;
     5933                Log(("ataIOPortRead1: suspect read from port %x size=%d\n", Port, cb));
     5934            }
     5935        }
     5936        PDMCritSectLeave(&pCtl->lock);
     5937    }
    59365938    return rc;
    59375939}
    59385940
    5939 #ifndef IN_RING0 /** @todo do this in ring-0 as well. */
     5941#ifndef IN_RING0 /** @todo do this in ring-0 as well - after IEM specific interface rewrite! */
     5942
    59405943/**
    59415944 * Port I/O Handler for primary port range IN string operations.
    … …  
    59625965
    59635966        cTransAvailable = (s->iIOBufferPIODataEnd - s->iIOBufferPIODataStart) / cb;
    5964 #ifndef IN_RING3
     5967# ifndef IN_RING3
    59655968        /* Deal with the unlikely case where no data (or not enough for the read length operation) is available; go back to ring 3. */
    59665969        if (!cTransAvailable)
    … …  
    59715974        /* The last transfer unit cannot be handled in GC, as it involves thread communication. */
    59725975        cTransAvailable--;
    5973 #endif /* !IN_RING3 */
     5976# endif /* !IN_RING3 */
    59745977        /* Do not handle the dummy transfer stuff here, leave it to the single-word transfers.
    59755978         * They are not performance-critical and generally shouldn't occur at all. */
    … …  
    59795982
    59805983        rc = PGMPhysSimpleDirtyWriteGCPtr(PDMDevHlpGetVMCPU(pDevIns), GCDst, s->CTX_SUFF(pbIOBuffer) + s->iIOBufferPIODataStart, cbTransfer);
    5981 #ifndef IN_RING3
     5984# ifndef IN_RING3
    59825985        /* Paranoia. */
    59835986        if (RT_FAILURE(rc))
    … …  
    59875990            return VINF_IOM_R3_IOPORT_READ;
    59885991        }
    5989 #else
     5992# else
    59905993        Assert(rc == VINF_SUCCESS);
    5991 #endif
     5994# endif
    59925995
    59935996        if (cbTransfer)
    … …  
    59965999        *pGCPtrDst = (RTGCPTR)((RTGCUINTPTR)GCDst + cbTransfer);
    59976000        *pcTransfer = cTransfer - cTransAvailable;
    5998 #ifdef IN_RING3
     6001# ifdef IN_RING3
    59996002        if (s->iIOBufferPIODataStart >= s->iIOBufferPIODataEnd)
    6000             ataPIOTransferFinish(pCtl, s);
    6001 #endif /* IN_RING3 */
     6003            ataR3PIOTransferFinish(pCtl, s);
     6004# endif /* IN_RING3 */
    60026005    }
    60036006    PDMCritSectLeave(&pCtl->lock);
    … …  
    60246027    if (Port == pCtl->IOPortBase1)
    60256028    {
    6026         uint32_t cTransAvailable, cTransfer = *pcTransfer, cbTransfer;
     6029        uint32_t cTransfer = *pcTransfer;
     6030        uint32_t cbTransfer;
    60276031        RTGCPTR GCSrc = *pGCPtrSrc;
    60286032        ATADevState *s = &pCtl->aIfs[pCtl->iSelectedIf];
    60296033        Assert(cb == 2 || cb == 4);
    60306034
    6031         cTransAvailable = (s->iIOBufferPIODataEnd - s->iIOBufferPIODataStart) / cb;
    6032 #ifndef IN_RING3
     6035        uint32_t cTransAvailable = (s->iIOBufferPIODataEnd - s->iIOBufferPIODataStart) / cb;
     6036# ifndef IN_RING3
    60336037        /* Deal with the unlikely case where no data (or not enough for the read length operation) is available; go back to ring 3. */
    60346038        if (!cTransAvailable)
    … …  
    60396043        /* The last transfer unit cannot be handled in GC, as it involves thread communication. */
    60406044        cTransAvailable--;
    6041 #endif /* !IN_RING3 */
     6045# endif /* !IN_RING3 */
    60426046        /* Do not handle the dummy transfer stuff here, leave it to the single-word transfers.
    60436047         * They are not performance-critical and generally shouldn't occur at all. */
    … …  
    60476051
    60486052        rc = PGMPhysSimpleReadGCPtr(PDMDevHlpGetVMCPU(pDevIns), s->CTX_SUFF(pbIOBuffer) + s->iIOBufferPIODataStart, GCSrc, cbTransfer);
    6049 #ifndef IN_RING3
     6053# ifndef IN_RING3
    60506054        /* Paranoia. */
    60516055        if (RT_FAILURE(rc))
    … …  
    60556059            return VINF_IOM_R3_IOPORT_WRITE;
    60566060        }
    6057 #else
     6061# else
    60586062        Assert(rc == VINF_SUCCESS);
    6059 #endif
     6063# endif
    60606064
    60616065        if (cbTransfer)
    … …  
    60646068        *pGCPtrSrc = (RTGCPTR)((RTGCUINTPTR)GCSrc + cbTransfer);
    60656069        *pcTransfer = cTransfer - cTransAvailable;
    6066 #ifdef IN_RING3
     6070# ifdef IN_RING3
    60676071        if (s->iIOBufferPIODataStart >= s->iIOBufferPIODataEnd)
    6068             ataPIOTransferFinish(pCtl, s);
    6069 #endif /* IN_RING3 */
     6072            ataR3PIOTransferFinish(pCtl, s);
     6073# endif /* IN_RING3 */
    60706074    }
    60716075    PDMCritSectLeave(&pCtl->lock);
    60726076    return rc;
    60736077}
     6078
    60746079#endif /* !IN_RING0 */
    60756080
    … …  
    60876092    Assert(i < 2);
    60886093
    6089     if (cb != 1)
    6090         return VINF_SUCCESS;
    6091     rc = PDMCritSectEnter(&pCtl->lock, VINF_IOM_R3_IOPORT_WRITE);
    6092     if (rc != VINF_SUCCESS)
    6093         return rc;
    6094     rc = ataControlWrite(pCtl, Port, u32);
    6095     PDMCritSectLeave(&pCtl->lock);
     6094    if (cb == 1)
     6095    {
     6096        rc = PDMCritSectEnter(&pCtl->lock, VINF_IOM_R3_IOPORT_WRITE);
     6097        if (rc == VINF_SUCCESS)
     6098        {
     6099            rc = ataControlWrite(pCtl, Port, u32);
     6100            PDMCritSectLeave(&pCtl->lock);
     6101        }
     6102    }
     6103    else
     6104        rc = VINF_SUCCESS;
    60966105    return rc;
    60976106}
    … …  
    61116120    Assert(i < 2);
    61126121
    6113     if (cb != 1)
    6114         return VERR_IOM_IOPORT_UNUSED;
    6115 
    6116     rc = PDMCritSectEnter(&pCtl->lock, VINF_IOM_R3_IOPORT_READ);
    6117     if (rc != VINF_SUCCESS)
    6118         return rc;
    6119     *pu32 = ataStatusRead(pCtl, Port);
    6120     PDMCritSectLeave(&pCtl->lock);
    6121     return VINF_SUCCESS;
     6122    if (cb == 1)
     6123    {
     6124        rc = PDMCritSectEnter(&pCtl->lock, VINF_IOM_R3_IOPORT_READ);
     6125        if (rc == VINF_SUCCESS)
     6126        {
     6127            *pu32 = ataStatusRead(pCtl, Port);
     6128            PDMCritSectLeave(&pCtl->lock);
     6129        }
     6130    }
     6131    else
     6132        rc = VERR_IOM_IOPORT_UNUSED;
     6133    return rc;
    61226134}
    61236135
    … …  
    61256137
    61266138
    6127 DECLINLINE(void) ataRelocBuffer(PPDMDEVINS pDevIns, ATADevState *s)
     6139DECLINLINE(void) ataR3RelocBuffer(PPDMDEVINS pDevIns, ATADevState *s)
    61286140{
    61296141    if (s->pbIOBufferR3)
    … …  
    61736185     * In case there was a medium inserted.
    61746186     */
    6175     ataMediumRemoved(pIf);
     6187    ataR3MediumRemoved(pIf);
    61766188}
    61776189
    … …  
    61846196 * @param   pIf         The ATA unit state.
    61856197 */
    6186 static int ataConfigLun(PPDMDEVINS pDevIns, ATADevState *pIf)
     6198static int ataR3ConfigLun(PPDMDEVINS pDevIns, ATADevState *pIf)
    61876199{
    61886200    int             rc = VINF_SUCCESS;
    … …  
    63626374    if (RT_SUCCESS(rc))
    63636375    {
    6364         rc = ataConfigLun(pDevIns, pIf);
     6376        rc = ataR3ConfigLun(pDevIns, pIf);
    63656377        /*
    63666378         * In case there is a medium inserted.
    63676379         */
    6368         ataMediumInserted(pIf);
    6369         ataMediumTypeSet(pIf, ATA_MEDIA_TYPE_UNKNOWN);
     6380        ataR3MediumInserted(pIf);
     6381        ataR3MediumTypeSet(pIf, ATA_MEDIA_TYPE_UNKNOWN);
    63706382    }
    63716383    else
    … …  
    64196431        if (pThis->aCts[i].AsyncIOThread != NIL_RTTHREAD)
    64206432        {
    6421             bool fRc = ataAsyncIOIsIdle(&pThis->aCts[i], false /*fStrict*/);
     6433            bool fRc = ataR3AsyncIOIsIdle(&pThis->aCts[i], false /*fStrict*/);
    64226434            if (!fRc)
    64236435            {
    … …  
    64276439                PDMCritSectLeave(&pThis->aCts[i].AsyncIORequestLock);
    64286440
    6429                 fRc = ataAsyncIOIsIdle(&pThis->aCts[i], false /*fStrict*/);
     6441                fRc = ataR3AsyncIOIsIdle(&pThis->aCts[i], false /*fStrict*/);
    64306442                if (!fRc)
    64316443                {
    … …  
    64506462 * @param   pSSM            SSM operation handle.
    64516463 */
    6452 static DECLCALLBACK(int) ataSaveLoadPrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
     6464static DECLCALLBACK(int) ataR3SaveLoadPrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    64536465{
    64546466    PCIATAState    *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
    … …  
    64566468    /* sanity - the suspend notification will wait on the async stuff. */
    64576469    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
    6458         AssertLogRelMsgReturn(ataAsyncIOIsIdle(&pThis->aCts[i], false /*fStrict*/),
     6470        AssertLogRelMsgReturn(ataR3AsyncIOIsIdle(&pThis->aCts[i], false /*fStrict*/),
    64596471                              ("i=%u\n", i),
    64606472                              VERR_SSM_IDE_ASYNC_TIMEOUT);
    … …  
    64656477 * @copydoc FNSSMDEVLIVEEXEC
    64666478 */
    6467 static DECLCALLBACK(int) ataLiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
     6479static DECLCALLBACK(int) ataR3LiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
    64686480{
    64696481    PCIATAState    *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
    … …  
    64886500 * @copydoc FNSSMDEVSAVEEXEC
    64896501 */
    6490 static DECLCALLBACK(int) ataSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
     6502static DECLCALLBACK(int) ataR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    64916503{
    64926504    PCIATAState    *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
    64936505
    6494     ataLiveExec(pDevIns, pSSM, SSM_PASS_FINAL);
     6506    ataR3LiveExec(pDevIns, pSSM, SSM_PASS_FINAL);
    64956507
    64966508    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
    … …  
    65696581 * Converts the LUN number into a message string.
    65706582 */
    6571 static const char *ataStringifyLun(unsigned iLun)
     6583static const char *ataR3StringifyLun(unsigned iLun)
    65726584{
    65736585    switch (iLun)
    … …  
    65846596 * FNSSMDEVLOADEXEC
    65856597 */
    6586 static DECLCALLBACK(int) ataLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
     6598static DECLCALLBACK(int) ataR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    65876599{
    65886600    PCIATAState    *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
    … …  
    66296641                    return SSMR3SetCfgError(pSSM, RT_SRC_POS,
    66306642                                            N_("The %s VM is missing a %s device. Please make sure the source and target VMs have compatible storage configurations"),
    6631                                             fInUse ? "target" : "source", ataStringifyLun(pIf->iLUN) );
     6643                                            fInUse ? "target" : "source", ataR3StringifyLun(pIf->iLUN) );
    66326644
    66336645                char szSerialNumber[ATA_SERIAL_NUMBER_LENGTH+1];
    … …  
    66636675    {
    66646676        /* integrity check */
    6665         if (!ataAsyncIOIsIdle(&pThis->aCts[i], false))
     6677        if (!ataR3AsyncIOIsIdle(&pThis->aCts[i], false))
    66666678        {
    66676679            AssertMsgFailed(("Async I/O for controller %d is active\n", i));
    … …  
    68566868        PDMCritSectEnter(&pThis->aCts[i].lock, VERR_INTERNAL_ERROR);
    68576869        for (uint32_t j = 0; j < RT_ELEMENTS(pThis->aCts[i].aIfs); j++)
    6858             ataResetDevice(&pThis->aCts[i].aIfs[j]);
     6870            ataR3ResetDevice(&pThis->aCts[i].aIfs[j]);
    68596871        PDMCritSectLeave(&pThis->aCts[i].lock);
    68606872    }
    … …  
    68916903        pThis->aCts[i].fRedo = false;
    68926904        pThis->aCts[i].fRedoIdle = false;
    6893         ataAsyncIOClearRequests(&pThis->aCts[i]);
     6905        ataR3AsyncIOClearRequests(&pThis->aCts[i]);
    68946906        Log2(("%s: Ctl#%d: message to async I/O thread, reset controller\n", __FUNCTION__, i));
    6895         ataAsyncIOPutRequest(&pThis->aCts[i], &g_ataResetARequest);
    6896         ataAsyncIOPutRequest(&pThis->aCts[i], &g_ataResetCRequest);
     6907        ataR3AsyncIOPutRequest(&pThis->aCts[i], &g_ataResetARequest);
     6908        ataR3AsyncIOPutRequest(&pThis->aCts[i], &g_ataResetCRequest);
    68976909
    68986910        PDMCritSectLeave(&pThis->aCts[i].lock);
    … …  
    69326944                AssertRC(rc);
    69336945
    6934                 if (!ataAsyncIOIsIdle(&pThis->aCts[i], false /*fStrict*/))
     6946                if (!ataR3AsyncIOIsIdle(&pThis->aCts[i], false /*fStrict*/))
    69356947                {
    69366948                    rc = RTThreadUserWait(pThis->aCts[i].AsyncIOThread,  30*1000 /*ms*/);
    … …  
    69776989        pThis->aCts[i].aIfs[0].pDevInsRC += offDelta;
    69786990        pThis->aCts[i].aIfs[0].pControllerRC += offDelta;
    6979         ataRelocBuffer(pDevIns, &pThis->aCts[i].aIfs[0]);
     6991        ataR3RelocBuffer(pDevIns, &pThis->aCts[i].aIfs[0]);
    69806992        pThis->aCts[i].aIfs[1].pDevInsRC += offDelta;
    69816993        pThis->aCts[i].aIfs[1].pControllerRC += offDelta;
    6982         ataRelocBuffer(pDevIns, &pThis->aCts[i].aIfs[1]);
     6994        ataR3RelocBuffer(pDevIns, &pThis->aCts[i].aIfs[1]);
    69836995    }
    69846996}
    … …  
    70827094 * @param   penmChipset Where to store the chipset type.
    70837095 */
    7084 static int ataControllerFromCfg(PPDMDEVINS pDevIns, PCFGMNODE pCfg, CHIPSET *penmChipset)
     7096static int ataR3ControllerFromCfg(PPDMDEVINS pDevIns, PCFGMNODE pCfg, CHIPSET *penmChipset)
    70857097{
    70867098    char szType[20];
    … …  
    71097121 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    71107122 */
    7111 static DECLCALLBACK(int)   ataR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
     7123static DECLCALLBACK(int) ataR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
    71127124{
    71137125    PCIATAState    *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
    … …  
    71637175
    71647176    CHIPSET enmChipset = CHIPSET_PIIX3;
    7165     rc = ataControllerFromCfg(pDevIns, pCfg, &enmChipset);
     7177    rc = ataR3ControllerFromCfg(pDevIns, pCfg, &enmChipset);
    71667178    if (RT_FAILURE(rc))
    71677179        return rc;
    … …  
    71727184     */
    71737185    /* Status LUN. */
    7174     pThis->IBase.pfnQueryInterface = ataStatus_QueryInterface;
    7175     pThis->ILeds.pfnQueryStatusLed = ataStatus_QueryStatusLed;
     7186    pThis->IBase.pfnQueryInterface = ataR3Status_QueryInterface;
     7187    pThis->ILeds.pfnQueryStatusLed = ataR3Status_QueryStatusLed;
    71767188
    71777189    /* PCI configuration space. */
    … …  
    72437255            pIf->pControllerR0 = MMHyperR3ToR0(PDMDevHlpGetVM(pDevIns), &pThis->aCts[i]);
    72447256            pIf->pControllerRC = MMHyperR3ToRC(PDMDevHlpGetVM(pDevIns), &pThis->aCts[i]);
    7245             pIf->IBase.pfnQueryInterface       = ataQueryInterface;
    7246             pIf->IMountNotify.pfnMountNotify   = ataMountNotify;
    7247             pIf->IMountNotify.pfnUnmountNotify = ataUnmountNotify;
     7257            pIf->IBase.pfnQueryInterface       = ataR3QueryInterface;
     7258            pIf->IMountNotify.pfnMountNotify   = ataR3MountNotify;
     7259            pIf->IMountNotify.pfnUnmountNotify = ataR3UnmountNotify;
    72487260            pIf->IPort.pfnQueryDeviceLocation  = ataR3QueryDeviceLocation;
    72497261            pIf->Led.u32Magic                  = PDMLED_MAGIC;
    … …  
    72757287                                N_("PIIX3 cannot register PCI device"));
    72767288    //AssertMsg(pThis->dev.devfn == 9 || iInstance != 0, ("pThis->dev.devfn=%d\n", pThis->dev.devfn));
    7277     rc = PDMDevHlpPCIIORegionRegister(pDevIns, 4, 0x10, PCI_ADDRESS_SPACE_IO, ataBMDMAIORangeMap);
     7289    rc = PDMDevHlpPCIIORegionRegister(pDevIns, 4, 0x10, PCI_ADDRESS_SPACE_IO, ataR3BMDMAIORangeMap);
    72787290    if (RT_FAILURE(rc))
    72797291        return PDMDEV_SET_ERROR(pDevIns, rc,
    … …  
    74217433        AssertLogRelRCReturn(rc, rc);
    74227434
    7423         ataAsyncIOClearRequests(pCtl);
     7435        ataR3AsyncIOClearRequests(pCtl);
    74247436        rc = RTThreadCreateF(&pCtl->AsyncIOThread, ataR3AsyncIOThread, (void *)pCtl, 128*1024 /*cbStack*/,
    74257437                             RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "ATA-%u", i);
    … …  
    74467458            if (RT_SUCCESS(rc))
    74477459            {
    7448                 rc = ataConfigLun(pDevIns, pIf);
     7460                rc = ataR3ConfigLun(pDevIns, pIf);
    74497461                if (RT_SUCCESS(rc))
    74507462                {
    … …  
    75887600
    75897601    rc = PDMDevHlpSSMRegisterEx(pDevIns, ATA_SAVED_STATE_VERSION, sizeof(*pThis) + cbTotalBuffer, NULL,
    7590                                 NULL,            ataLiveExec, NULL,
    7591                                 ataSaveLoadPrep, ataSaveExec, NULL,
    7592                                 ataSaveLoadPrep, ataLoadExec, NULL);
     7602                                NULL,            ataR3LiveExec, NULL,
     7603                                ataR3SaveLoadPrep, ataR3SaveExec, NULL,
     7604                                ataR3SaveLoadPrep, ataR3LoadExec, NULL);
    75937605    if (RT_FAILURE(rc))
    75947606        return PDMDEV_SET_ERROR(pDevIns, rc, N_("PIIX3 cannot register save state handlers"));
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette