VirtualBox

Changeset 65111 in vbox


Ignore:
Timestamp:
Jan 4, 2017 2:07:58 PM (8 years ago)
Author:
vboxsync
Message:

Storage/Devices/VSCSI: Make use of the new SCSI inline helpers and remove the the local inlines

Location:
trunk/src/VBox/Devices/Storage/VSCSI
Files:
1 deleted
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Storage/VSCSI/VSCSIDevice.cpp

    r64654 r65111  
    6767                SCSIINQUIRYDATA ScsiInquiryReply;
    6868
    69                 vscsiReqSetXferSize(pVScsiReq, vscsiBE2HU16(&pVScsiReq->pbCDB[3]));
     69                vscsiReqSetXferSize(pVScsiReq, scsiBE2H_U16(&pVScsiReq->pbCDB[3]));
    7070                memset(&ScsiInquiryReply, 0, sizeof(ScsiInquiryReply));
    7171                ScsiInquiryReply.cbAdditional = 31;
    … …  
    8686             * to return an error.
    8787             */
    88             vscsiReqSetXferSize(pVScsiReq, vscsiBE2HU32(&pVScsiReq->pbCDB[6]));
     88            vscsiReqSetXferSize(pVScsiReq, scsiBE2H_U32(&pVScsiReq->pbCDB[6]));
    8989            if (pVScsiReq->cbXfer < 16)
    9090                *prcReq = vscsiReqSenseErrorSet(&pVScsiDevice->VScsiSense, pVScsiReq, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET, 0x00);
    … …  
    9595
    9696                memset(aReply, 0, sizeof(aReply));
    97                 vscsiH2BEU32(&aReply[0], 8); /* List length starts at position 0. */
     97                scsiH2BE_U32(&aReply[0], 8); /* List length starts at position 0. */
    9898                cbData = RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, aReply, sizeof(aReply));
    9999                if (cbData < 16)
    … …  
    141141                        uint8_t u8ReportMode = pVScsiReq->pbCDB[2] & 0x7;
    142142                        uint8_t u8Opc = pVScsiReq->pbCDB[3];
    143                         uint16_t u16SvcAction = vscsiBE2HU16(&pVScsiReq->pbCDB[4]);
    144                         uint16_t cbData = vscsiBE2HU16(&pVScsiReq->pbCDB[6]);
     143                        uint16_t u16SvcAction = scsiBE2H_U16(&pVScsiReq->pbCDB[4]);
     144                        uint16_t cbData = scsiBE2H_U16(&pVScsiReq->pbCDB[6]);
    145145
    146146                        switch (u8ReportMode)

  • trunk/src/VBox/Devices/Storage/VSCSI/VSCSIInternal.h

    r64654 r65111  
    2020#include <VBox/vscsi.h>
    2121#include <VBox/scsi.h>
     22#include <VBox/scsiinline.h>
    2223#include <iprt/memcache.h>
    2324#include <iprt/sg.h>
    2425#include <iprt/list.h>
    2526
    26 #include "VSCSIInline.h"
    2727#include "VSCSIVpdPages.h"
    2828

  • trunk/src/VBox/Devices/Storage/VSCSI/VSCSILunMmc.cpp

    r64654 r65111  
    8080
    8181
    82 DECLINLINE(void) mmcLBA2MSF(uint8_t *pbBuf, uint32_t iLBA)
    83 {
    84     iLBA += 150;
    85     pbBuf[0] = (iLBA / 75) / 60;
    86     pbBuf[1] = (iLBA / 75) % 60;
    87     pbBuf[2] = iLBA % 75;
    88 }
    89 
    90 #if 0 /* unused */
    91 DECLINLINE(uint32_t) mmcMSF2LBA(const uint8_t *pbBuf)
    92 {
    93     return (pbBuf[0] * 60 + pbBuf[1]) * 75 + pbBuf[2];
    94 }
    95 #endif
    96 
    97 
    9882/* Fabricate normal TOC information. */
    9983static int mmcReadTOCNormal(PVSCSILUNINT pVScsiLun, PVSCSIREQINT pVScsiReq, uint16_t cbMaxTransfer, bool fMSF)
    … …  
    123107        {
    124108            *q++ = 0;   /* reserved */
    125             mmcLBA2MSF(q, 0);
     109            scsiLBA2MSF(q, 0);
    126110            q += 3;
    127111        }
    … …  
    129113        {
    130114            /* sector 0 */
    131             vscsiH2BEU32(q, 0);
     115            scsiH2BE_U32(q, 0);
    132116            q += 4;
    133117        }
    … …  
    141125    {
    142126        *q++ = 0;   /* reserved */
    143         mmcLBA2MSF(q, pVScsiLunMmc->cSectors);
     127        scsiLBA2MSF(q, pVScsiLunMmc->cSectors);
    144128        q += 3;
    145129    }
    146130    else
    147131    {
    148         vscsiH2BEU32(q, pVScsiLunMmc->cSectors);
     132        scsiH2BE_U32(q, pVScsiLunMmc->cSectors);
    149133        q += 4;
    150134    }
    151135    cbSize = q - pbBuf;
    152136    Assert(cbSize <= sizeof(aReply));
    153     vscsiH2BEU16(pbBuf, cbSize - 2);
     137    scsiH2BE_U16(pbBuf, cbSize - 2);
    154138    if (cbSize < cbMaxTransfer)
    155139        cbMaxTransfer = cbSize;
    … …  
    178162    {
    179163        pbBuf[8] = 0;   /* reserved */
    180         mmcLBA2MSF(pbBuf + 8, 0);
     164        scsiLBA2MSF(pbBuf + 8, 0);
    181165    }
    182166    else
    183167    {
    184168        /* sector 0 */
    185         vscsiH2BEU32(pbBuf + 8, 0);
     169        scsiH2BE_U32(pbBuf + 8, 0);
    186170    }
    187171
    … …  
    244228    {
    245229        *pbBuf++ = 0; /* reserved */
    246         mmcLBA2MSF(pbBuf, pVScsiLunMmc->cSectors);
     230        scsiLBA2MSF(pbBuf, pVScsiLunMmc->cSectors);
    247231        pbBuf += 3;
    248232    }
    249233    else
    250234    {
    251         vscsiH2BEU32(pbBuf, pVScsiLunMmc->cSectors);
     235        scsiH2BE_U32(pbBuf, pVScsiLunMmc->cSectors);
    252236        pbBuf += 4;
    253237    }
    … …  
    263247    {
    264248        *pbBuf++ = 0; /* reserved */
    265         mmcLBA2MSF(pbBuf, 0);
     249        scsiLBA2MSF(pbBuf, 0);
    266250        pbBuf += 3;
    267251    }
    … …  
    269253    {
    270254        /* sector 0 */
    271         vscsiH2BEU32(pbBuf, 0);
     255        scsiH2BE_U32(pbBuf, 0);
    272256        pbBuf += 4;
    273257    }
    274258
    275259    cbSize = pbBuf - aReply;
    276     vscsiH2BEU16(&aReply[0], cbSize - 2);
     260    scsiH2BE_U16(&aReply[0], cbSize - 2);
    277261
    278262    RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, aReply, RT_MIN(cbMaxTransfer, cbSize));
    … …  
    285269        return 0;
    286270
    287     vscsiH2BEU16(pbBuf, 0x0); /* feature 0: list of profiles supported */
     271    scsiH2BE_U16(pbBuf, 0x0); /* feature 0: list of profiles supported */
    288272    pbBuf[2] = (0 << 2) | (1 << 1) | (1 << 0); /* version 0, persistent, current */
    289273    pbBuf[3] = 8; /* additional bytes for profiles */
    290274    /* The MMC-3 spec says that DVD-ROM read capability should be reported
    291275     * before CD-ROM read capability. */
    292     vscsiH2BEU16(pbBuf + 4, 0x10); /* profile: read-only DVD */
     276    scsiH2BE_U16(pbBuf + 4, 0x10); /* profile: read-only DVD */
    293277    pbBuf[6] = (0 << 0); /* NOT current profile */
    294     vscsiH2BEU16(pbBuf + 8, 0x08); /* profile: read only CD */
     278    scsiH2BE_U16(pbBuf + 8, 0x08); /* profile: read only CD */
    295279    pbBuf[10] = (1 << 0); /* current profile */
    296280
    … …  
    303287        return 0;
    304288
    305     vscsiH2BEU16(pbBuf, 0x1); /* feature 0001h: Core Feature */
     289    scsiH2BE_U16(pbBuf, 0x1); /* feature 0001h: Core Feature */
    306290    pbBuf[2] = (0x2 << 2) | RT_BIT(1) | RT_BIT(0); /* Version | Persistent | Current */
    307291    pbBuf[3] = 8; /* Additional length */
    308     vscsiH2BEU16(pbBuf + 4, 0x00000002); /* Physical interface ATAPI. */
     292    scsiH2BE_U16(pbBuf + 4, 0x00000002); /* Physical interface ATAPI. */
    309293    pbBuf[8] = RT_BIT(0); /* DBE */
    310294    /* Rest is reserved. */
    … …  
    318302        return 0;
    319303
    320     vscsiH2BEU16(pbBuf, 0x2); /* feature 0002h: Morphing Feature */
     304    scsiH2BE_U16(pbBuf, 0x2); /* feature 0002h: Morphing Feature */
    321305    pbBuf[2] = (0x1 << 2) | RT_BIT(1) | RT_BIT(0); /* Version | Persistent | Current */
    322306    pbBuf[3] = 4; /* Additional length */
    … …  
    332316        return 0;
    333317
    334     vscsiH2BEU16(pbBuf, 0x3); /* feature 0003h: Removable Medium Feature */
     318    scsiH2BE_U16(pbBuf, 0x3); /* feature 0003h: Removable Medium Feature */
    335319    pbBuf[2] = (0x2 << 2) | RT_BIT(1) | RT_BIT(0); /* Version | Persistent | Current */
    336320    pbBuf[3] = 4; /* Additional length */
    … …  
    347331        return 0;
    348332
    349     vscsiH2BEU16(pbBuf, 0x10); /* feature 0010h: Random Readable Feature */
     333    scsiH2BE_U16(pbBuf, 0x10); /* feature 0010h: Random Readable Feature */
    350334    pbBuf[2] = (0x0 << 2) | RT_BIT(1) | RT_BIT(0); /* Version | Persistent | Current */
    351335    pbBuf[3] = 8; /* Additional length */
    352     vscsiH2BEU32(pbBuf + 4, 2048); /* Logical block size. */
    353     vscsiH2BEU16(pbBuf + 8, 0x10); /* Blocking (0x10 for DVD, CD is not defined). */
     336    scsiH2BE_U32(pbBuf + 4, 2048); /* Logical block size. */
     337    scsiH2BE_U16(pbBuf + 8, 0x10); /* Blocking (0x10 for DVD, CD is not defined). */
    354338    pbBuf[10] = 0; /* PP not present */
    355339    /* Rest is reserved. */
    … …  
    363347        return 0;
    364348
    365     vscsiH2BEU16(pbBuf, 0x1e); /* feature 001Eh: CD Read Feature */
     349    scsiH2BE_U16(pbBuf, 0x1e); /* feature 001Eh: CD Read Feature */
    366350    pbBuf[2] = (0x2 << 2) | RT_BIT(1) | RT_BIT(0); /* Version | Persistent | Current */
    367351    pbBuf[3] = 0; /* Additional length */
    … …  
    377361        return 0;
    378362
    379     vscsiH2BEU16(pbBuf, 0x100); /* feature 0100h: Power Management Feature */
     363    scsiH2BE_U16(pbBuf, 0x100); /* feature 0100h: Power Management Feature */
    380364    pbBuf[2] = (0x0 << 2) | RT_BIT(1) | RT_BIT(0); /* Version | Persistent | Current */
    381365    pbBuf[3] = 0; /* Additional length */
    … …  
    389373        return 0;
    390374
    391     vscsiH2BEU16(pbBuf, 0x105); /* feature 0105h: Timeout Feature */
     375    scsiH2BE_U16(pbBuf, 0x105); /* feature 0105h: Timeout Feature */
    392376    pbBuf[2] = (0x0 << 2) | RT_BIT(1) | RT_BIT(0); /* Version | Persistent | Current */
    393377    pbBuf[3] = 4; /* Additional length */
    … …  
    413397
    414398    /* Accept valid request types only, and only starting feature 0. */
    415     if ((pVScsiReq->pbCDB[1] & 0x03) == 3 || vscsiBE2HU16(&pVScsiReq->pbCDB[2]) != 0)
     399    if ((pVScsiReq->pbCDB[1] & 0x03) == 3 || scsiBE2H_U16(&pVScsiReq->pbCDB[2]) != 0)
    416400        return vscsiLunReqSenseErrorSet(&pVScsiLunMmc->Core, pVScsiReq, SCSI_SENSE_ILLEGAL_REQUEST,
    417401                                        SCSI_ASC_INV_FIELD_IN_CMD_PACKET, 0x00);
    … …  
    420404     * way to differentiate them right now is based on the image size). */
    421405    if (pVScsiLunMmc->cSectors)
    422         vscsiH2BEU16(pbBuf + 6, 0x08); /* current profile: read-only CD */
     406        scsiH2BE_U16(pbBuf + 6, 0x08); /* current profile: read-only CD */
    423407    else
    424         vscsiH2BEU16(pbBuf + 6, 0x00); /* current profile: none -> no media */
     408        scsiH2BE_U16(pbBuf + 6, 0x00); /* current profile: none -> no media */
    425409    cbBuf    -= 8;
    426410    pbBuf    += 8;
    … …  
    459443
    460444    /* Set data length now. */
    461     vscsiH2BEU32(&aReply[0], (uint32_t)(sizeof(aReply) - cbBuf));
     445    scsiH2BE_U32(&aReply[0], (uint32_t)(sizeof(aReply) - cbBuf));
    462446
    463447    RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, aReply, RT_MIN(cbMaxTransfer, sizeof(aReply) - cbBuf));
    … …  
    534518
    535519                        /* FIXME: 0x30000 per spec? */
    536                         vscsiH2BEU32(&aReply[8], 0); /* start sector */
    537                         vscsiH2BEU32(&aReply[12], cTotalSectors - 1); /* end sector */
    538                         vscsiH2BEU32(&aReply[16], cTotalSectors - 1); /* l0 end sector */
     520                        scsiH2BE_U32(&aReply[8], 0); /* start sector */
     521                        scsiH2BE_U32(&aReply[12], cTotalSectors - 1); /* end sector */
     522                        scsiH2BE_U32(&aReply[16], cTotalSectors - 1); /* l0 end sector */
    539523
    540524                        /* Size of buffer, not including 2 byte size field */
    541                         vscsiH2BEU32(&aReply[0], 2048 + 2);
     525                        scsiH2BE_U32(&aReply[0], 2048 + 2);
    542526
    543527                        /* 2k data + 4 byte header */
    … …  
    550534
    551535                        /* Size of buffer, not including 2 byte size field */
    552                         vscsiH2BEU16(&aReply[0], 4 + 2);
     536                        scsiH2BE_U16(&aReply[0], 4 + 2);
    553537
    554538                        /* 4 byte header + 4 byte data */
    … …  
    562546                    case 0x04: /* DVD disc manufacturing information */
    563547                        /* Size of buffer, not including 2 byte size field */
    564                         vscsiH2BEU16(&aReply[0], 2048 + 2);
     548                        scsiH2BE_U16(&aReply[0], 2048 + 2);
    565549
    566550                        /* 2k data + 4 byte header */
    … …  
    575559                        aReply[4] = 0x00; /* Physical format */
    576560                        aReply[5] = 0x40; /* Not writable, is readable */
    577                         vscsiH2BEU16(&aReply[6], 2048 + 4);
     561                        scsiH2BE_U16(&aReply[6], 2048 + 4);
    578562
    579563                        aReply[8] = 0x01; /* Copyright info */
    580564                        aReply[9] = 0x40; /* Not writable, is readable */
    581                         vscsiH2BEU16(&aReply[10], 4 + 4);
     565                        scsiH2BE_U16(&aReply[10], 4 + 4);
    582566
    583567                        aReply[12] = 0x03; /* BCA info */
    584568                        aReply[13] = 0x40; /* Not writable, is readable */
    585                         vscsiH2BEU16(&aReply[14], 188 + 4);
     569                        scsiH2BE_U16(&aReply[14], 188 + 4);
    586570
    587571                        aReply[16] = 0x04; /* Manufacturing info */
    588572                        aReply[17] = 0x40; /* Not writable, is readable */
    589                         vscsiH2BEU16(&aReply[18], 2048 + 4);
     573                        scsiH2BE_U16(&aReply[18], 2048 + 4);
    590574
    591575                        /* Size of buffer, not including 2 byte size field */
    592                         vscsiH2BEU16(&aReply[0], 16 + 2);
     576                        scsiH2BE_U16(&aReply[0], 16 + 2);
    593577
    594578                        /* data written + 4 byte header */
    … …  
    645629                    uint8_t aReply[16];
    646630
    647                     vscsiH2BEU16(&aReply[0], 16 + 6);
     631                    scsiH2BE_U16(&aReply[0], 16 + 6);
    648632                    aReply[2] = (uint8_t)pVScsiLunMmc->u32MediaTrackType;
    649633                    aReply[3] = 0;
    … …  
    669653                    uint8_t aReply[40];
    670654
    671                     vscsiH2BEU16(&aReply[0], 38);
     655                    scsiH2BE_U16(&aReply[0], 38);
    672656                    aReply[2] = (uint8_t)pVScsiLunMmc->u32MediaTrackType;
    673657                    aReply[3] = 0;
    … …  
    690674                        aReply[14] |= 1 << 1; /* report lock state */
    691675                    aReply[15] = 0; /* no subchannel reads supported, no separate audio volume control, no changer etc. */
    692                     vscsiH2BEU16(&aReply[16], 5632); /* (obsolete) claim 32x speed support */
    693                     vscsiH2BEU16(&aReply[18], 2); /* number of audio volume levels */
    694                     vscsiH2BEU16(&aReply[20], 128); /* buffer size supported in Kbyte - We don't have a buffer because we write directly into guest memory.
     676                    scsiH2BE_U16(&aReply[16], 5632); /* (obsolete) claim 32x speed support */
     677                    scsiH2BE_U16(&aReply[18], 2); /* number of audio volume levels */
     678                    scsiH2BE_U16(&aReply[20], 128); /* buffer size supported in Kbyte - We don't have a buffer because we write directly into guest memory.
    695679                                                       Just write some dummy value. */
    696                     vscsiH2BEU16(&aReply[22], 5632); /* (obsolete) current read speed 32x */
     680                    scsiH2BE_U16(&aReply[22], 5632); /* (obsolete) current read speed 32x */
    697681                    aReply[24] = 0; /* reserved */
    698682                    aReply[25] = 0; /* reserved for digital audio (see idx 15) */
    699                     vscsiH2BEU16(&aReply[26], 0); /* (obsolete) maximum write speed */
    700                     vscsiH2BEU16(&aReply[28], 0); /* (obsolete) current write speed */
    701                     vscsiH2BEU16(&aReply[30], 0); /* copy management revision supported 0=no CSS */
     683                    scsiH2BE_U16(&aReply[26], 0); /* (obsolete) maximum write speed */
     684                    scsiH2BE_U16(&aReply[28], 0); /* (obsolete) current write speed */
     685                    scsiH2BE_U16(&aReply[30], 0); /* copy management revision supported 0=no CSS */
    702686                    aReply[32] = 0; /* reserved */
    703687                    aReply[33] = 0; /* reserved */
    704688                    aReply[34] = 0; /* reserved */
    705689                    aReply[35] = 1; /* rotation control CAV */
    706                     vscsiH2BEU16(&aReply[36], 0); /* current write speed */
    707                     vscsiH2BEU16(&aReply[38], 0); /* number of write speed performance descriptors */
     690                    scsiH2BE_U16(&aReply[36], 0); /* current write speed */
     691                    scsiH2BE_U16(&aReply[38], 0); /* number of write speed performance descriptors */
    708692                    RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, aReply, RT_MIN(cbMaxTransfer, sizeof(aReply)));
    709693                    rcReq = vscsiLunReqSenseOkSet(&pVScsiLunMmc->Core, pVScsiReq);
    … …  
    759743            case MMCEVENTSTATUSTYPE_MEDIA_NEW:
    760744                /* mount */
    761                 vscsiH2BEU16(&aReply[0], 6);
     745                scsiH2BE_U16(&aReply[0], 6);
    762746                aReply[2] = 0x04; /* media */
    763747                aReply[3] = 0x5e; /* supported = busy|media|external|power|operational */
    … …  
    772756            case MMCEVENTSTATUSTYPE_MEDIA_REMOVED:
    773757                /* umount */
    774                 vscsiH2BEU16(&aReply[0], 6);
     758                scsiH2BE_U16(&aReply[0], 6);
    775759                aReply[2] = 0x04; /* media */
    776760                aReply[3] = 0x5e; /* supported = busy|media|external|power|operational */
    … …  
    784768
    785769            case MMCEVENTSTATUSTYPE_MEDIA_EJECT_REQUESTED: /* currently unused */
    786                 vscsiH2BEU16(&aReply[0], 6);
     770                scsiH2BE_U16(&aReply[0], 6);
    787771                aReply[2] = 0x04; /* media */
    788772                aReply[3] = 0x5e; /* supported = busy|media|external|power|operational */
    … …  
    795779            case MMCEVENTSTATUSTYPE_UNCHANGED:
    796780            default:
    797                 vscsiH2BEU16(&aReply[0], 6);
     781                scsiH2BE_U16(&aReply[0], 6);
    798782                aReply[2] = 0x01; /* operational change request / notification */
    799783                aReply[3] = 0x5e; /* supported = busy|media|external|power|operational */
    … …  
    887871                SCSIINQUIRYDATA ScsiInquiryReply;
    888872
    889                 vscsiReqSetXferSize(pVScsiReq, vscsiBE2HU16(&pVScsiReq->pbCDB[3]));
     873                vscsiReqSetXferSize(pVScsiReq, scsiBE2H_U16(&pVScsiReq->pbCDB[3]));
    890874                memset(&ScsiInquiryReply, 0, sizeof(ScsiInquiryReply));
    891875
    … …  
    897881                ScsiInquiryReply.fCmdQue                = 1;    /* Command queuing supported. */
    898882                ScsiInquiryReply.fWBus16                = 1;
    899                 vscsiPadStr(ScsiInquiryReply.achVendorId, "VBOX", 8);
    900                 vscsiPadStr(ScsiInquiryReply.achProductId, "CD-ROM", 16);
    901                 vscsiPadStr(ScsiInquiryReply.achProductLevel, "1.0", 4);
     883                scsiPadStrS(ScsiInquiryReply.achVendorId, "VBOX", 8);
     884                scsiPadStrS(ScsiInquiryReply.achProductId, "CD-ROM", 16);
     885                scsiPadStrS(ScsiInquiryReply.achProductLevel, "1.0", 4);
    902886
    903887                RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, (uint8_t *)&ScsiInquiryReply, sizeof(SCSIINQUIRYDATA));
    … …  
    916900                 */
    917901                if (pVScsiLunMmc->cSectors > UINT32_C(0xffffffff))
    918                     vscsiH2BEU32(aReply, UINT32_C(0xffffffff));
     902                    scsiH2BE_U32(aReply, UINT32_C(0xffffffff));
    919903                else
    920                     vscsiH2BEU32(aReply, pVScsiLunMmc->cSectors - 1);
    921                 vscsiH2BEU32(&aReply[4], pVScsiLunMmc->cbSector);
     904                    scsiH2BE_U32(aReply, pVScsiLunMmc->cSectors - 1);
     905                scsiH2BE_U32(&aReply[4], pVScsiLunMmc->cbSector);
    922906                RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, aReply, sizeof(aReply));
    923907                rcReq = vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
    … …  
    962946            case SCSI_MODE_SENSE_10:
    963947            {
    964                 size_t cbMax = vscsiBE2HU16(&pVScsiReq->pbCDB[7]);
     948                size_t cbMax = scsiBE2H_U16(&pVScsiReq->pbCDB[7]);
    965949                vscsiReqSetXferSize(pVScsiReq, cbMax);
    966950                rcReq = vscsiLunMmcModeSense10(pVScsiLunMmc, pVScsiReq, cbMax);
    … …  
    969953            case SCSI_SEEK_10:
    970954            {
    971                 uint32_t uLba = vscsiBE2HU32(&pVScsiReq->pbCDB[2]);
     955                uint32_t uLba = scsiBE2H_U32(&pVScsiReq->pbCDB[2]);
    972956                if (uLba > pVScsiLunMmc->cSectors)
    973957                    rcReq = vscsiLunReqSenseErrorSet(pVScsiLun, pVScsiReq, SCSI_SENSE_ILLEGAL_REQUEST,
    … …  
    996980            {
    997981                enmTxDir        = VSCSIIOREQTXDIR_READ;
    998                 uLbaStart       = vscsiBE2HU32(&pVScsiReq->pbCDB[2]);
    999                 cSectorTransfer = vscsiBE2HU16(&pVScsiReq->pbCDB[7]);
     982                uLbaStart       = scsiBE2H_U32(&pVScsiReq->pbCDB[2]);
     983                cSectorTransfer = scsiBE2H_U16(&pVScsiReq->pbCDB[7]);
    1000984                break;
    1001985            }
    … …  
    1003987            {
    1004988                enmTxDir        = VSCSIIOREQTXDIR_READ;
    1005                 uLbaStart       = vscsiBE2HU32(&pVScsiReq->pbCDB[2]);
    1006                 cSectorTransfer = vscsiBE2HU32(&pVScsiReq->pbCDB[6]);
     989                uLbaStart       = scsiBE2H_U32(&pVScsiReq->pbCDB[2]);
     990                cSectorTransfer = scsiBE2H_U32(&pVScsiReq->pbCDB[6]);
    1007991                break;
    1008992            }
    … …  
    1010994            {
    1011995                enmTxDir        = VSCSIIOREQTXDIR_READ;
    1012                 uLbaStart       = vscsiBE2HU64(&pVScsiReq->pbCDB[2]);
    1013                 cSectorTransfer = vscsiBE2HU32(&pVScsiReq->pbCDB[10]);
     996                uLbaStart       = scsiBE2H_U64(&pVScsiReq->pbCDB[2]);
     997                cSectorTransfer = scsiBE2H_U32(&pVScsiReq->pbCDB[10]);
    1014998                break;
    1015999            }
    … …  
    10181002                uint8_t uDataMode = pVScsiReq->pbCDB[1] & 0x1f;
    10191003
    1020                 vscsiReqSetXferSize(pVScsiReq, vscsiBE2HU16(&pVScsiReq->pbCDB[6]));
     1004                vscsiReqSetXferSize(pVScsiReq, scsiBE2H_U16(&pVScsiReq->pbCDB[6]));
    10211005
    10221006                switch (uDataMode)
    … …  
    10721056                uint8_t uSubPageCode = pVScsiReq->pbCDB[3];
    10731057
    1074                 vscsiReqSetXferSize(pVScsiReq, vscsiBE2HU16(&pVScsiReq->pbCDB[7]));
     1058                vscsiReqSetXferSize(pVScsiReq, scsiBE2H_U16(&pVScsiReq->pbCDB[7]));
    10751059
    10761060                switch (uPageCode)
    … …  
    11061090
    11071091                        memset(aReply, 0, sizeof(aReply));
    1108                         vscsiH2BEU64(aReply, pVScsiLunMmc->cSectors - 1);
    1109                         vscsiH2BEU32(&aReply[8], pVScsiLunMmc->cbSector);
     1092                        scsiH2BE_U64(aReply, pVScsiLunMmc->cSectors - 1);
     1093                        scsiH2BE_U32(&aReply[8], pVScsiLunMmc->cbSector);
    11101094                        /* Leave the rest 0 */
    11111095
    … …  
    11351119
    11361120                format = pVScsiReq->pbCDB[2] & 0x0f;
    1137                 cbMax  = vscsiBE2HU16(&pVScsiReq->pbCDB[7]);
     1121                cbMax  = scsiBE2H_U16(&pVScsiReq->pbCDB[7]);
    11381122                fMSF   = (pVScsiReq->pbCDB[1] >> 1) & 1;
    11391123
    … …  
    11581142            {
    11591143                /* Only supporting polled mode at the moment. */
    1160                 size_t cbMax = vscsiBE2HU16(&pVScsiReq->pbCDB[7]);
     1144                size_t cbMax = scsiBE2H_U16(&pVScsiReq->pbCDB[7]);
    11611145
    11621146                vscsiReqSetXferSize(pVScsiReq, cbMax);
    … …  
    11691153            case SCSI_MECHANISM_STATUS:
    11701154            {
    1171                 size_t cbMax = vscsiBE2HU16(&pVScsiReq->pbCDB[8]);
     1155                size_t cbMax = scsiBE2H_U16(&pVScsiReq->pbCDB[8]);
    11721156                uint8_t aReply[8];
    11731157
    11741158                vscsiReqSetXferSize(pVScsiReq, cbMax);
    1175                 vscsiH2BEU16(&aReply[0], 0);
     1159                scsiH2BE_U16(&aReply[0], 0);
    11761160                /* no current LBA */
    11771161                aReply[2] = 0;
    … …  
    11791163                aReply[4] = 0;
    11801164                aReply[5] = 1;
    1181                 vscsiH2BEU16(&aReply[6], 0);
     1165                scsiH2BE_U16(&aReply[6], 0);
    11821166                RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, aReply, RT_MIN(sizeof(aReply), cbMax));
    11831167                rcReq = vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
    … …  
    11871171            {
    11881172                uint8_t aReply[34];
    1189                 size_t cbMax = vscsiBE2HU16(&pVScsiReq->pbCDB[7]);
     1173                size_t cbMax = scsiBE2H_U16(&pVScsiReq->pbCDB[7]);
    11901174
    11911175                vscsiReqSetXferSize(pVScsiReq, cbMax);
    11921176                memset(aReply, '\0', sizeof(aReply));
    1193                 vscsiH2BEU16(&aReply[0], 32);
     1177                scsiH2BE_U16(&aReply[0], 32);
    11941178                aReply[2] = (0 << 4) | (3 << 2) | (2 << 0); /* not erasable, complete session, complete disc */
    11951179                aReply[3] = 1; /* number of first track */
    … …  
    12021186                aReply[10] = 0; /* number of sessions (MSB) */
    12031187                aReply[11] = 0; /* number of sessions (MSB) */
    1204                 vscsiH2BEU32(&aReply[16], 0x00ffffff); /* last session lead-in start time is not available */
    1205                 vscsiH2BEU32(&aReply[20], 0x00ffffff); /* last possible start time for lead-out is not available */
     1188                scsiH2BE_U32(&aReply[16], 0x00ffffff); /* last session lead-in start time is not available */
     1189                scsiH2BE_U32(&aReply[20], 0x00ffffff); /* last possible start time for lead-out is not available */
    12061190                RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, aReply, RT_MIN(sizeof(aReply), cbMax));
    12071191                rcReq = vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
    … …  
    12101194            case SCSI_READ_TRACK_INFORMATION:
    12111195            {
    1212                 size_t cbMax = vscsiBE2HU16(&pVScsiReq->pbCDB[7]);
     1196                size_t cbMax = scsiBE2H_U16(&pVScsiReq->pbCDB[7]);
    12131197
    12141198                vscsiReqSetXferSize(pVScsiReq, cbMax);
    12151199                /* Accept address/number type of 1 only, and only track 1 exists. */
    1216                 if ((pVScsiReq->pbCDB[1] & 0x03) != 1 || vscsiBE2HU32(&pVScsiReq->pbCDB[2]) != 1)
     1200                if ((pVScsiReq->pbCDB[1] & 0x03) != 1 || scsiBE2H_U32(&pVScsiReq->pbCDB[2]) != 1)
    12171201                    rcReq = vscsiLunReqSenseErrorSet(pVScsiLun, pVScsiReq, SCSI_SENSE_ILLEGAL_REQUEST,
    12181202                                                     SCSI_ASC_INV_FIELD_IN_CMD_PACKET, 0x00);
    … …  
    12221206                    RT_ZERO(aReply);
    12231207
    1224                     vscsiH2BEU16(&aReply[0], 34);
     1208                    scsiH2BE_U16(&aReply[0], 34);
    12251209                    aReply[2] = 1; /* track number (LSB) */
    12261210                    aReply[3] = 1; /* session number (LSB) */
    … …  
    12281212                    aReply[6] = (0 << 7) | (0 << 6) | (0 << 5) | (0 << 6) | (1 << 0); /* not reserved track, not blank, not packet writing, not fixed packet, data mode 1 */
    12291213                    aReply[7] = (0 << 1) | (0 << 0); /* last recorded address not valid, next recordable address not valid */
    1230                     vscsiH2BEU32(&aReply[8], 0); /* track start address is 0 */
    1231                     vscsiH2BEU32(&aReply[24], pVScsiLunMmc->cSectors); /* track size */
     1214                    scsiH2BE_U32(&aReply[8], 0); /* track start address is 0 */
     1215                    scsiH2BE_U32(&aReply[24], pVScsiLunMmc->cSectors); /* track size */
    12321216                    aReply[32] = 0; /* track number (MSB) */
    12331217                    aReply[33] = 0; /* session number (MSB) */
    … …  
    12401224            case SCSI_GET_CONFIGURATION:
    12411225            {
    1242                 size_t cbMax = vscsiBE2HU16(&pVScsiReq->pbCDB[7]);
     1226                size_t cbMax = scsiBE2H_U16(&pVScsiReq->pbCDB[7]);
    12431227                vscsiReqSetXferSize(pVScsiReq, cbMax);
    12441228                rcReq = vscsiLunMmcGetConfiguration(pVScsiLunMmc, pVScsiReq, cbMax);
    … …  
    12471231            case SCSI_READ_DVD_STRUCTURE:
    12481232            {
    1249                 size_t cbMax = vscsiBE2HU16(&pVScsiReq->pbCDB[8]);
     1233                size_t cbMax = scsiBE2H_U16(&pVScsiReq->pbCDB[8]);
    12501234                vscsiReqSetXferSize(pVScsiReq, cbMax);
    12511235                rcReq = vscsiLunMmcReadDvdStructure(pVScsiLunMmc, pVScsiReq, cbMax);

  • trunk/src/VBox/Devices/Storage/VSCSI/VSCSILunSbc.cpp

    r64654 r65111  
    203203        case SCSI_INQUIRY:
    204204        {
    205             vscsiReqSetXferSize(pVScsiReq, vscsiBE2HU16(&pVScsiReq->pbCDB[3]));
     205            vscsiReqSetXferSize(pVScsiReq, scsiBE2H_U16(&pVScsiReq->pbCDB[3]));
    206206
    207207            /* Check for EVPD bit. */
    … …  
    233233                ScsiInquiryReply.fCmdQue                = 1;    /* Command queuing supported. */
    234234                ScsiInquiryReply.fWBus16                = 1;
    235                 vscsiPadStr(ScsiInquiryReply.achVendorId, "VBOX", 8);
    236                 vscsiPadStr(ScsiInquiryReply.achProductId, "HARDDISK", 16);
    237                 vscsiPadStr(ScsiInquiryReply.achProductLevel, "1.0", 4);
     235                scsiPadStrS(ScsiInquiryReply.achVendorId, "VBOX", 8);
     236                scsiPadStrS(ScsiInquiryReply.achProductId, "HARDDISK", 16);
     237                scsiPadStrS(ScsiInquiryReply.achProductLevel, "1.0", 4);
    238238
    239239                RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, (uint8_t *)&ScsiInquiryReply, sizeof(SCSIINQUIRYDATA));
    … …  
    254254             */
    255255            if (pVScsiLunSbc->cSectors > UINT32_C(0xffffffff))
    256                 vscsiH2BEU32(aReply, UINT32_C(0xffffffff));
     256                scsiH2BE_U32(aReply, UINT32_C(0xffffffff));
    257257            else
    258                 vscsiH2BEU32(aReply, pVScsiLunSbc->cSectors - 1);
    259             vscsiH2BEU32(&aReply[4], pVScsiLunSbc->cbSector);
     258                scsiH2BE_U32(aReply, pVScsiLunSbc->cSectors - 1);
     259            scsiH2BE_U32(&aReply[4], pVScsiLunSbc->cbSector);
    260260            RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, aReply, sizeof(aReply));
    261261            rcReq = vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
    … …  
    320320                uint32_t    cbBlock;
    321321
    322                 cbBlock = vscsiBE2HU24(&abParms[4 + 5]);
     322                cbBlock = scsiBE2H_U24(&abParms[4 + 5]);
    323323                Log2(("SBC: set LOGICAL BLOCK LENGTH to %u\n", cbBlock));
    324324                if (cbBlock == 512) /* Fixed block size. */
    … …  
    344344        {
    345345            enmTxDir        = VSCSIIOREQTXDIR_READ;
    346             uLbaStart       = vscsiBE2HU32(&pVScsiReq->pbCDB[2]);
    347             cSectorTransfer = vscsiBE2HU16(&pVScsiReq->pbCDB[7]);
     346            uLbaStart       = scsiBE2H_U32(&pVScsiReq->pbCDB[2]);
     347            cSectorTransfer = scsiBE2H_U16(&pVScsiReq->pbCDB[7]);
    348348            break;
    349349        }
    … …  
    351351        {
    352352            enmTxDir        = VSCSIIOREQTXDIR_READ;
    353             uLbaStart       = vscsiBE2HU32(&pVScsiReq->pbCDB[2]);
    354             cSectorTransfer = vscsiBE2HU32(&pVScsiReq->pbCDB[6]);
     353            uLbaStart       = scsiBE2H_U32(&pVScsiReq->pbCDB[2]);
     354            cSectorTransfer = scsiBE2H_U32(&pVScsiReq->pbCDB[6]);
    355355            break;
    356356        }
    … …  
    358358        {
    359359            enmTxDir        = VSCSIIOREQTXDIR_READ;
    360             uLbaStart       = vscsiBE2HU64(&pVScsiReq->pbCDB[2]);
    361             cSectorTransfer = vscsiBE2HU32(&pVScsiReq->pbCDB[10]);
     360            uLbaStart       = scsiBE2H_U64(&pVScsiReq->pbCDB[2]);
     361            cSectorTransfer = scsiBE2H_U32(&pVScsiReq->pbCDB[10]);
    362362            break;
    363363        }
    … …  
    374374        {
    375375            enmTxDir        = VSCSIIOREQTXDIR_WRITE;
    376             uLbaStart       = vscsiBE2HU32(&pVScsiReq->pbCDB[2]);
    377             cSectorTransfer = vscsiBE2HU16(&pVScsiReq->pbCDB[7]);
     376            uLbaStart       = scsiBE2H_U32(&pVScsiReq->pbCDB[2]);
     377            cSectorTransfer = scsiBE2H_U16(&pVScsiReq->pbCDB[7]);
    378378            break;
    379379        }
    … …  
    381381        {
    382382            enmTxDir        = VSCSIIOREQTXDIR_WRITE;
    383             uLbaStart       = vscsiBE2HU32(&pVScsiReq->pbCDB[2]);
    384             cSectorTransfer = vscsiBE2HU32(&pVScsiReq->pbCDB[6]);
     383            uLbaStart       = scsiBE2H_U32(&pVScsiReq->pbCDB[2]);
     384            cSectorTransfer = scsiBE2H_U32(&pVScsiReq->pbCDB[6]);
    385385            break;
    386386        }
    … …  
    388388        {
    389389            enmTxDir        = VSCSIIOREQTXDIR_WRITE;
    390             uLbaStart       = vscsiBE2HU64(&pVScsiReq->pbCDB[2]);
    391             cSectorTransfer = vscsiBE2HU32(&pVScsiReq->pbCDB[10]);
     390            uLbaStart       = scsiBE2H_U64(&pVScsiReq->pbCDB[2]);
     391            cSectorTransfer = scsiBE2H_U32(&pVScsiReq->pbCDB[10]);
    392392            break;
    393393        }
    … …  
    400400            uint8_t uDataMode = pVScsiReq->pbCDB[1] & 0x1f;
    401401
    402             vscsiReqSetXferSize(pVScsiReq, vscsiBE2HU16(&pVScsiReq->pbCDB[6]));
     402            vscsiReqSetXferSize(pVScsiReq, scsiBE2H_U16(&pVScsiReq->pbCDB[6]));
    403403
    404404            switch (uDataMode)
    … …  
    441441            uint8_t uSubPageCode = pVScsiReq->pbCDB[3];
    442442
    443             vscsiReqSetXferSize(pVScsiReq, vscsiBE2HU16(&pVScsiReq->pbCDB[7]));
     443            vscsiReqSetXferSize(pVScsiReq, scsiBE2H_U16(&pVScsiReq->pbCDB[7]));
    444444
    445445            switch (uPageCode)
    … …  
    474474
    475475                    memset(aReply, 0, sizeof(aReply));
    476                     vscsiH2BEU64(aReply, pVScsiLunSbc->cSectors - 1);
    477                     vscsiH2BEU32(&aReply[8], 512);
     476                    scsiH2BE_U64(aReply, pVScsiLunSbc->cSectors - 1);
     477                    scsiH2BE_U32(&aReply[8], 512);
    478478                    if (pVScsiLun->fFeatures & VSCSI_LUN_FEATURE_UNMAP)
    479479                        aReply[14] = 0x80; /* LPME enabled */
    … …  
    496496                uint8_t abHdr[8];
    497497                size_t cbCopied;
    498                 size_t cbList = vscsiBE2HU16(&pVScsiReq->pbCDB[7]);
     498                size_t cbList = scsiBE2H_U16(&pVScsiReq->pbCDB[7]);
    499499
    500500                /* Copy the header. */
    … …  
    507507                    && cbList >= 8)
    508508                {
    509                     uint32_t    cBlkDesc = vscsiBE2HU16(&abHdr[2]) / 16;
     509                    uint32_t    cBlkDesc = scsiBE2H_U16(&abHdr[2]) / 16;
    510510
    511511                    if (cBlkDesc)
    … …  
    525525                                }
    526526
    527                                 paRanges[i].offStart = vscsiBE2HU64(&abBlkDesc[0]) * 512;
    528                                 paRanges[i].cbRange = vscsiBE2HU32(&abBlkDesc[8]) * 512;
     527                                paRanges[i].offStart = scsiBE2H_U64(&abBlkDesc[0]) * 512;
     528                                paRanges[i].cbRange = scsiBE2H_U32(&abBlkDesc[8]) * 512;
    529529                            }
    530530

  • trunk/src/VBox/Devices/Storage/VSCSI/VSCSISense.cpp

    r62506 r65111  
    6969    pVScsiSense->abSenseBuf[0] = RT_BIT(7) | SCSI_SENSE_RESPONSE_CODE_CURR_FIXED; /* Fixed format */
    7070    pVScsiSense->abSenseBuf[2] = uSCSISenseKey;
    71     vscsiH2BEU32(&pVScsiSense->abSenseBuf[3], uInfo);
     71    scsiH2BE_U32(&pVScsiSense->abSenseBuf[3], uInfo);
    7272    pVScsiSense->abSenseBuf[7]  = 10;
    7373    pVScsiSense->abSenseBuf[12] = uSCSIASC;
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