VirtualBox

Changeset 109033 in vbox


Ignore:
Timestamp:
Apr 21, 2025 7:01:04 AM (13 days ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
168562
Message:

VMM/GIC: bugref:10877 Some GIC, ITS cleanup.

Location:
trunk/src/VBox/VMM
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/VMM/VMMAll/GICAll.cpp

    r109021 r109033  
    8282#define GIC_IS_INTR_EXT_PPI(a_uIntId)       (a_uIntId - GIC_INTID_RANGE_EXT_PPI_START < GIC_INTID_EXT_PPI_RANGE_SIZE)
    8383#define GIC_IS_INTR_EXT_SPI(a_uIntId)       (a_uIntId - GIC_INTID_RANGE_EXT_SPI_START < GIC_INTID_EXT_SPI_RANGE_SIZE)
    84 #define GIC_IS_REG_IN_RANGE(a_offReg, a_offFirst, a_cbRegion)    ((uint32_t)(a_offReg) - (a_offFirst) < (a_cbRegion))
    8584
    8685
  • trunk/src/VBox/VMM/VMMAll/GITSAll.cpp

    r109021 r109033  
    4848#define GITS_SAVED_STATE_VERSION                        1
    4949
    50 /** Gets whether the given register offset is within the specified range. */
    51 #define GITS_IS_REG_IN_RANGE(a_offReg, a_offFirst, a_cbRegion)    ((uint32_t)(a_offReg) - (a_offFirst) < (a_cbRegion))
    52 
    5350/** GITS diagnostic enum description expansion.
    5451 * The below construct ensures typos in the input to this macro are caught
    5552 * during compile time. */
    5653#define GITSDIAG_DESC(a_Name)                       RT_CONCAT(kGitsDiag_, a_Name) < kGitsDiag_End ? RT_STR(a_Name) : "Ignored"
    57 
    58 /** @def GITS_SET_REG_U64_FULL
    59  * Sets a 64-bit GITS register.
    60  * @param   a_uReg      The 64-bit register to set.
    61  * @param   a_uValue    The 64-bit value being written.
    62  * @param   a_fRwMask   The 64-bit mask of valid read-write bits.
    63  */
    64 #define GITS_SET_REG_U64_FULL(a_uReg, a_uValue, a_fRwMask) \
    65     do \
    66     { \
    67         AssertCompile(sizeof(a_uReg) == sizeof(uint64_t)); \
    68         AssertCompile(sizeof(a_fRwMask) == sizeof(uint64_t)); \
    69         (a_uReg) = ((a_uReg) & ~(a_fRwMask)) | ((a_uValue) & (a_fRwMask)); \
    70     } while (0)
    71 
    72 /** @def GITS_SET_REG_U64_LO
    73  * Sets the lower half of a 64-bit GITS register.
    74  * @param   a_uReg      The lower half of a 64-bit register to set.
    75  * @param   a_uValue    The value being written (only lower 32-bits are used).
    76  * @param   a_fRwMask   The 64-bit mask of valid read-write bits.
    77  */
    78 #define GITS_SET_REG_U64_LO(a_uReg, a_uValue, a_fRwMask) \
    79     do \
    80     { \
    81         AssertCompile(sizeof(a_uReg) == sizeof(uint32_t)); \
    82         AssertCompile(sizeof(a_fRwMask) == sizeof(uint64_t)); \
    83         (a_uReg) = ((a_uReg) & ~(RT_LO_U32(a_fRwMask))) | ((uint32_t)(a_uValue) & (RT_LO_U32(a_fRwMask))); \
    84     } while (0)
    85 
    86 /** @def GITS_SET_REG_U64_HI
    87  * Sets the upper half of a 64-bit GITS register.
    88  * @param   a_uReg      The upper half of the 64-bit register to set.
    89  * @param   a_uValue    The value being written (only lower 32-bits are used).
    90  * @param   a_fRwMask   The 64-bit mask of valid read-write bits.
    91  */
    92 #define GITS_SET_REG_U64_HI(a_uReg, a_uValue, a_fRwMask) \
    93     do \
    94     { \
    95         AssertCompile(sizeof(a_uReg) == sizeof(uint32_t)); \
    96         AssertCompile(sizeof(a_fRwMask) == sizeof(uint64_t)); \
    97         (a_uReg) = ((a_uReg) & ~(RT_HI_U32(a_fRwMask))) | ((uint32_t)(a_uValue) & (RT_HI_U32(a_fRwMask))); \
    98     } while (0)
    99 
    100 /** @def GITS_SET_REG_U32
    101  * Sets a 32-bit GITS register.
    102  * @param   a_uReg      The 32-bit register to set.
    103  * @param   a_uValue    The 32-bit value being written (only lower 32-bits are
    104  *                      used).
    105  * @param   a_fRwMask   The mask of valid read-write bits (only lower 32-bits are
    106  *                      used).
    107  */
    108 #define GITS_SET_REG_U32(a_uReg, a_uValue, a_fRwMask) \
    109     do \
    110     { \
    111         AssertCompile(sizeof(a_uReg) == sizeof(uint32_t)); \
    112         (a_uReg) = ((a_uReg) & ~(a_fRwMask)) | ((uint32_t)(a_uValue) & (uint32_t)(a_fRwMask)); \
    113     } while (0)
    11454
    11555
     
    13575DECL_HIDDEN_CALLBACK(const char *) gitsGetCtrlRegDescription(uint16_t offReg)
    13676{
    137     if (GITS_IS_REG_IN_RANGE(offReg, GITS_CTRL_REG_BASER_OFF_FIRST, GITS_CTRL_REG_BASER_RANGE_SIZE))
     77    if (GIC_IS_REG_IN_RANGE(offReg, GITS_CTRL_REG_BASER_OFF_FIRST, GITS_CTRL_REG_BASER_RANGE_SIZE))
    13878        return "GITS_BASER<n>";
    13979    switch (offReg)
     
    304244     */
    305245    uint64_t uReg;
    306     if (GITS_IS_REG_IN_RANGE(offReg, GITS_CTRL_REG_BASER_OFF_FIRST, GITS_CTRL_REG_BASER_RANGE_SIZE))
     246    if (GIC_IS_REG_IN_RANGE(offReg, GITS_CTRL_REG_BASER_OFF_FIRST, GITS_CTRL_REG_BASER_RANGE_SIZE))
    307247    {
    308248        uint16_t const cbReg  = sizeof(uint64_t);
     
    387327     * GITS_BASER<n>.
    388328     */
    389     if (GITS_IS_REG_IN_RANGE(offReg, GITS_CTRL_REG_BASER_OFF_FIRST, GITS_CTRL_REG_BASER_RANGE_SIZE))
     329    if (GIC_IS_REG_IN_RANGE(offReg, GITS_CTRL_REG_BASER_OFF_FIRST, GITS_CTRL_REG_BASER_RANGE_SIZE))
    390330    {
    391331        uint16_t const cbReg   = sizeof(uint64_t);
     
    395335        {
    396336            if (cb == 8)
    397                 GITS_SET_REG_U64_FULL(pGitsDev->aItsTableRegs[idxReg].u, uValue, fRwMask);
     337                GIC_SET_REG_U64_FULL(pGitsDev->aItsTableRegs[idxReg].u, uValue, fRwMask);
    398338            else
    399                 GITS_SET_REG_U64_LO(pGitsDev->aItsTableRegs[idxReg].s.Lo, uValue, fRwMask);
     339                GIC_SET_REG_U64_LO(pGitsDev->aItsTableRegs[idxReg].s.Lo, uValue, fRwMask);
    400340        }
    401341        else
    402342        {
    403343            Assert(cb == 4);
    404             GITS_SET_REG_U64_HI(pGitsDev->aItsTableRegs[idxReg].s.Hi, uValue, fRwMask);
     344            GIC_SET_REG_U64_HI(pGitsDev->aItsTableRegs[idxReg].s.Hi, uValue, fRwMask);
    405345        }
    406346        return;
     
    412352            Assert(cb == 4);
    413353            Assert(!(pGitsDev->uTypeReg.u & GITS_BF_CTRL_REG_TYPER_UMSI_IRQ_MASK));
    414             GITS_SET_REG_U32(pGitsDev->uCtrlReg, uValue, GITS_BF_CTRL_REG_CTLR_RW_MASK);
     354            GIC_SET_REG_U32(pGitsDev->uCtrlReg, uValue, GITS_BF_CTRL_REG_CTLR_RW_MASK);
    415355            if (RT_BF_GET(uValue, GITS_BF_CTRL_REG_CTLR_ENABLED))
    416356                pGitsDev->uCtrlReg &= GITS_BF_CTRL_REG_CTLR_QUIESCENT_MASK;
     
    420360        case GITS_CTRL_REG_CBASER_OFF:
    421361            if (cb == 8)
    422                 GITS_SET_REG_U64_FULL(pGitsDev->uCmdBaseReg.u, uValue, GITS_CTRL_REG_CBASER_RW_MASK);
     362                GIC_SET_REG_U64_FULL(pGitsDev->uCmdBaseReg.u, uValue, GITS_CTRL_REG_CBASER_RW_MASK);
    423363            else
    424                 GITS_SET_REG_U64_LO(pGitsDev->uCmdBaseReg.s.Lo, uValue, GITS_CTRL_REG_CBASER_RW_MASK);
     364                GIC_SET_REG_U64_LO(pGitsDev->uCmdBaseReg.s.Lo, uValue, GITS_CTRL_REG_CBASER_RW_MASK);
    425365            gitsCmdQueueThreadWakeUpIfNeeded(pDevIns, pGitsDev);
    426366            break;
     
    428368        case GITS_CTRL_REG_CBASER_OFF + 4:
    429369            Assert(cb == 4);
    430             GITS_SET_REG_U64_HI(pGitsDev->uCmdBaseReg.s.Hi, uValue, GITS_CTRL_REG_CBASER_RW_MASK);
     370            GIC_SET_REG_U64_HI(pGitsDev->uCmdBaseReg.s.Hi, uValue, GITS_CTRL_REG_CBASER_RW_MASK);
    431371            gitsCmdQueueThreadWakeUpIfNeeded(pDevIns, pGitsDev);
    432372            break;
    433373
    434374        case GITS_CTRL_REG_CWRITER_OFF:
    435             GITS_SET_REG_U32(pGitsDev->uCmdWriteReg, uValue, GITS_CTRL_REG_CWRITER_RW_MASK);
     375            GIC_SET_REG_U32(pGitsDev->uCmdWriteReg, uValue, GITS_CTRL_REG_CWRITER_RW_MASK);
    436376            gitsCmdQueueThreadWakeUpIfNeeded(pDevIns, pGitsDev);
    437377            break;
  • trunk/src/VBox/VMM/VMMR3/GICR3.cpp

    r109021 r109033  
    341341        uint8_t const cIdBits = RT_BF_GET(uReg, GIC_BF_REDIST_REG_PROPBASER_ID_BITS);
    342342        pHlp->pfnPrintf(pHlp, "  uLpiConfigBaseReg  = %#RX64\n", uReg);
    343         pHlp->pfnPrintf(pHlp, "    ID bits            = %#x (%u bits)\n", cIdBits, cIdBits + 1);
     343        pHlp->pfnPrintf(pHlp, "    ID bits            = %#x (%u bits)\n", cIdBits, cIdBits > 0 ? cIdBits + 1 : 0);
    344344        pHlp->pfnPrintf(pHlp, "    Inner cache        = %#x\n",    RT_BF_GET(uReg, GIC_BF_REDIST_REG_PROPBASER_INNER_CACHE));
    345345        pHlp->pfnPrintf(pHlp, "    Shareability       = %#x\n",    RT_BF_GET(uReg, GIC_BF_REDIST_REG_PROPBASER_SHAREABILITY));
  • trunk/src/VBox/VMM/include/GICInternal.h

    r109021 r109033  
    7474    do \
    7575    { \
    76         int const rcLock = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VINF_SUCCESS); \
    77         PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock); \
     76        int const rcLock_ = PDMDevHlpCritSectEnter((a_pDevIns), (a_pDevIns)->pCritSectRoR3, VINF_SUCCESS); \
     77        PDM_CRITSECT_RELEASE_ASSERT_RC_DEV((a_pDevIns), (a_pDevIns)->pCritSectRoR3, rcLock_); \
    7878    } while(0)
    7979
     
    8383/** Returns whether the critical section is held. */
    8484#define GIC_CRIT_SECT_IS_OWNER(a_pDevIns)       PDMDevHlpCritSectIsOwner((a_pDevIns), (a_pDevIns)->CTX_SUFF(pCritSectRo))
     85
     86/** Returns whether the given register offset is within the specified range. */
     87#define GIC_IS_REG_IN_RANGE(a_offReg, a_offFirst, a_cbRegion)    ((uint32_t)(a_offReg) - (a_offFirst) < (a_cbRegion))
     88
     89/** @def GIC_SET_REG_U64_FULL
     90 * Sets a 64-bit GIC register.
     91 * @param   a_uReg      The 64-bit register to set.
     92 * @param   a_uValue    The 64-bit value being written.
     93 * @param   a_fRwMask   The 64-bit mask of valid read-write bits.
     94 */
     95#define GIC_SET_REG_U64_FULL(a_uReg, a_uValue, a_fRwMask) \
     96    do \
     97    { \
     98        AssertCompile(sizeof(a_uReg) == sizeof(uint64_t)); \
     99        AssertCompile(sizeof(a_fRwMask) == sizeof(uint64_t)); \
     100        (a_uReg) = ((a_uReg) & ~(a_fRwMask)) | ((a_uValue) & (a_fRwMask)); \
     101    } while (0)
     102
     103/** @def GIC_SET_REG_U64_LO
     104 * Sets the lower half of a 64-bit GIC register.
     105 * @param   a_uReg      The lower half of a 64-bit register to set.
     106 * @param   a_uValue    The value being written (only lower 32-bits are used).
     107 * @param   a_fRwMask   The 64-bit mask of valid read-write bits.
     108 */
     109#define GIC_SET_REG_U64_LO(a_uReg, a_uValue, a_fRwMask) \
     110    do \
     111    { \
     112        AssertCompile(sizeof(a_uReg) == sizeof(uint32_t)); \
     113        AssertCompile(sizeof(a_fRwMask) == sizeof(uint64_t)); \
     114        (a_uReg) = ((a_uReg) & ~(RT_LO_U32(a_fRwMask))) | ((uint32_t)(a_uValue) & (RT_LO_U32(a_fRwMask))); \
     115    } while (0)
     116
     117/** @def GIC_SET_REG_U64_HI
     118 * Sets the upper half of a 64-bit GIC register.
     119 * @param   a_uReg      The upper half of the 64-bit register to set.
     120 * @param   a_uValue    The value being written (only lower 32-bits are used).
     121 * @param   a_fRwMask   The 64-bit mask of valid read-write bits.
     122 */
     123#define GIC_SET_REG_U64_HI(a_uReg, a_uValue, a_fRwMask) \
     124    do \
     125    { \
     126        AssertCompile(sizeof(a_uReg) == sizeof(uint32_t)); \
     127        AssertCompile(sizeof(a_fRwMask) == sizeof(uint64_t)); \
     128        (a_uReg) = ((a_uReg) & ~(RT_HI_U32(a_fRwMask))) | ((uint32_t)(a_uValue) & (RT_HI_U32(a_fRwMask))); \
     129    } while (0)
     130
     131/** @def GIC_SET_REG_U32
     132 * Sets a 32-bit GIC register.
     133 * @param   a_uReg      The 32-bit register to set.
     134 * @param   a_uValue    The 32-bit value being written (only lower 32-bits are
     135 *                      used).
     136 * @param   a_fRwMask   The mask of valid read-write bits (only lower 32-bits are
     137 *                      used).
     138 */
     139#define GIC_SET_REG_U32(a_uReg, a_uValue, a_fRwMask) \
     140    do \
     141    { \
     142        AssertCompile(sizeof(a_uReg) == sizeof(uint32_t)); \
     143        (a_uReg) = ((a_uReg) & ~(a_fRwMask)) | ((uint32_t)(a_uValue) & (uint32_t)(a_fRwMask)); \
     144    } while (0)
     145
    85146
    86147/**
     
    114175    /** Flag whether affinity routing is enabled. */
    115176    bool                        fAffRoutingEnabled;
    116     /** Alignment. */
    117     bool                        fPadding0;
    118177    /** @} */
    119178
     
    147206    /** The maximum LPI supported (GICD_TYPER.num_LPI). */
    148207    uint8_t                     uMaxLpi;
     208    /** @} */
     209
     210    /** @name GITS device data and LPIs.
     211     * @{ */
     212    /** Whether LPIs are enabled (GICR_CTLR.EnableLpis of all redistributors). */
     213    bool                        fEnableLpis;
    149214    /** Padding. */
    150     bool                        afPadding0[3];
    151     /** @} */
    152 
    153     /** @name GITS device data and LPIs.
    154      * @{ */
     215    bool                        afPadding1[3];
    155216    /** ITS device state. */
    156217    GITSDEV                     Gits;
     
    161222    /** The LPI pending table base register (GICR_PENDBASER). */
    162223    RTUINT64U                   uLpiPendingBaseReg;
    163     /** Whether LPIs are enabled (GICR_CTLR.EnableLpis of all redistributors). */
    164     bool                        fEnableLpis;
    165     /** Padding. */
    166     bool                        afPadding1[7];
    167224    /** @} */
    168225
Note: See TracChangeset for help on using the changeset viewer.

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