VirtualBox

Ignore:
Timestamp:
Mar 12, 2025 10:28:14 AM (6 weeks ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
167923
Message:

VMM/GIC: bugref:10404 Cleanup.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/VMMAll/GICAll.cpp

    r108529 r108533  
    18131813{
    18141814    VMCPU_ASSERT_EMT(pVCpu); RT_NOREF(pVCpu);
    1815     PGICDEV  pGicDev     = PDMDEVINS_2_DATA(pDevIns, PGICDEV);
    1816     uint16_t const cbReg = sizeof(uint32_t);
     1815    PGICDEV pGicDev = PDMDEVINS_2_DATA(pDevIns, PGICDEV);
    18171816
    18181817    /*
    1819      * GICD_IGROUPR<n> and GICD_IGROUPR<n>E.
     1818     * 64-bit registers.
    18201819     */
    18211820    {
     1821        /*
     1822         * GICD_IROUTER<n> and GICD_IROUTER<n>E.
     1823         */
     1824        uint16_t const cbReg = sizeof(uint64_t);
     1825        if (offReg - GIC_DIST_REG_IROUTERn_OFF_START < GIC_DIST_REG_IROUTERn_RANGE_SIZE)
     1826        {
     1827            /* Hardware does not map the first 32 registers (corresponding to SGIs and PPIs). */
     1828            uint16_t const idxExt = GIC_INTID_RANGE_SPI_START;
     1829            uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_IROUTERn_OFF_START) / cbReg;
     1830            return gicDistReadIntrRoutingReg(pGicDev, idxReg, puValue);
     1831        }
     1832        if (offReg - GIC_DIST_REG_IROUTERnE_OFF_START < GIC_DIST_REG_IROUTERnE_RANGE_SIZE)
     1833        {
     1834            uint16_t const idxExt = RT_ELEMENTS(pGicDev->au32IntrRouting) / 2;
     1835            uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_IROUTERnE_OFF_START) / cbReg;
     1836            return gicDistReadIntrRoutingReg(pGicDev, idxReg, puValue);
     1837        }
     1838    }
     1839
     1840    /*
     1841     * 32-bit registers.
     1842     */
     1843    {
     1844        /*
     1845         * GICD_IGROUPR<n> and GICD_IGROUPR<n>E.
     1846         */
     1847        uint16_t const cbReg = sizeof(uint32_t);
    18221848        if (offReg - GIC_DIST_REG_IGROUPRn_OFF_START < GIC_DIST_REG_IGROUPRn_RANGE_SIZE)
    18231849        {
    … …  
    18311857            return gicDistReadIntrGroupReg(pGicDev, idxReg, puValue);
    18321858        }
    1833     }
    1834 
    1835     /*
    1836      * GICD_IROUTER<n> and GICD_IROUTER<n>E.
    1837      */
    1838     {
    1839         if (offReg - GIC_DIST_REG_IROUTERn_OFF_START < GIC_DIST_REG_IROUTERn_RANGE_SIZE)
    1840         {
    1841             /* Hardware does not map the first 32 registers (corresponding to SGIs and PPIs). */
    1842             uint16_t const idxExt = GIC_INTID_RANGE_SPI_START;
    1843             uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_IROUTERn_OFF_START) / sizeof(uint64_t);
    1844             return gicDistReadIntrRoutingReg(pGicDev, idxReg, puValue);
    1845         }
    1846         if (offReg - GIC_DIST_REG_IROUTERnE_OFF_START < GIC_DIST_REG_IROUTERnE_RANGE_SIZE)
    1847         {
    1848             uint16_t const idxExt = RT_ELEMENTS(pGicDev->au32IntrRouting) / 2;
    1849             uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_IROUTERnE_OFF_START) / sizeof(uint64_t);
    1850             return gicDistReadIntrRoutingReg(pGicDev, idxReg, puValue);
    1851         }
    1852     }
    1853 
    1854     /*
    1855      * GICD_ISENABLER<n> and GICD_ISENABLER<n>E.
    1856      * GICD_ICENABLER<n> and GICD_ICENABLER<n>E.
    1857      */
    1858     {
     1859
     1860        /*
     1861         * GICD_ISENABLER<n> and GICD_ISENABLER<n>E.
     1862         * GICD_ICENABLER<n> and GICD_ICENABLER<n>E.
     1863         */
    18591864        if (offReg - GIC_DIST_REG_ISENABLERn_OFF_START  < GIC_DIST_REG_ISENABLERn_RANGE_SIZE)
    18601865        {
    … …  
    18681873            return gicDistReadIntrEnableReg(pGicDev, idxReg, puValue);
    18691874        }
    1870 
    18711875        if (offReg - GIC_DIST_REG_ICENABLERn_OFF_START  < GIC_DIST_REG_ICENABLERn_RANGE_SIZE)
    18721876        {
    … …  
    18801884            return gicDistReadIntrEnableReg(pGicDev, idxReg, puValue);
    18811885        }
    1882     }
    1883 
    1884     /*
    1885      * GICD_ISACTIVER<n> and GICD_ISACTIVER<n>E.
    1886      * GICD_ICACTIVER<n> and GICD_ICACTIVER<n>E.
    1887      */
    1888     {
     1886
     1887        /*
     1888         * GICD_ISACTIVER<n> and GICD_ISACTIVER<n>E.
     1889         * GICD_ICACTIVER<n> and GICD_ICACTIVER<n>E.
     1890         */
    18891891        if (offReg - GIC_DIST_REG_ISACTIVERn_OFF_START < GIC_DIST_REG_ISACTIVERn_RANGE_SIZE)
    18901892        {
    … …  
    18981900            return gicDistReadIntrActiveReg(pGicDev, idxReg, puValue);
    18991901        }
    1900 
    19011902        if (offReg - GIC_DIST_REG_ICACTIVERn_OFF_START < GIC_DIST_REG_ICACTIVERn_RANGE_SIZE)
    19021903        {
    … …  
    19101911            return gicDistReadIntrActiveReg(pGicDev, idxReg, puValue);
    19111912        }
    1912     }
    1913 
    1914     /*
    1915      * GICD_IPRIORITYR<n> and GICD_IPRIORITYR<n>E.
    1916      */
    1917     {
     1913
     1914        /*
     1915         * GICD_IPRIORITYR<n> and GICD_IPRIORITYR<n>E.
     1916         */
    19181917        if (offReg - GIC_DIST_REG_IPRIORITYRn_OFF_START < GIC_DIST_REG_IPRIORITYRn_RANGE_SIZE)
    19191918        {
    … …  
    19271926            return gicDistReadIntrPriorityReg(pGicDev, idxReg, puValue);
    19281927        }
    1929     }
    1930 
    1931     /*
    1932      * GICD_ISPENDR<n> and GICD_ISPENDR<n>E.
    1933      * GICD_ICPENDR<n> and GICD_ICPENDR<n>E.
    1934      */
    1935     {
     1928
     1929        /*
     1930         * GICD_ISPENDR<n> and GICD_ISPENDR<n>E.
     1931         * GICD_ICPENDR<n> and GICD_ICPENDR<n>E.
     1932         */
    19361933        if (offReg - GIC_DIST_REG_ISPENDRn_OFF_START < GIC_DIST_REG_ISPENDRn_RANGE_SIZE)
    19371934        {
    … …  
    19451942            return gicDistReadIntrPendingReg(pGicDev, idxReg, puValue);
    19461943        }
    1947 
    19481944        if (offReg - GIC_DIST_REG_ICPENDRn_OFF_START < GIC_DIST_REG_ICPENDRn_RANGE_SIZE)
    19491945        {
    … …  
    19571953            return gicDistReadIntrPendingReg(pGicDev, idxReg, puValue);
    19581954        }
    1959     }
    1960 
    1961     /*
    1962      * GICD_ICFGR<n> and GICD_ICFGR<n>E.
    1963      */
    1964     {
     1955
     1956        /*
     1957         * GICD_ICFGR<n> and GICD_ICFGR<n>E.
     1958         */
    19651959        if (offReg - GIC_DIST_REG_ICFGRn_OFF_START < GIC_DIST_REG_ICFGRn_RANGE_SIZE)
    19661960        {
    … …  
    20562050{
    20572051    VMCPU_ASSERT_EMT(pVCpu); RT_NOREF(pVCpu);
    2058     PGICDEV        pGicDev = PDMDEVINS_2_DATA(pDevIns, PGICDEV);
    2059     PVMCC          pVM     = PDMDevHlpGetVM(pDevIns);
    2060     uint16_t const cbReg   = sizeof(uint32_t);
     2052    PGICDEV pGicDev = PDMDEVINS_2_DATA(pDevIns, PGICDEV);
     2053    PVMCC   pVM     = PDMDevHlpGetVM(pDevIns);
    20612054
    20622055    /*
    2063      * GICD_IGROUPR<n> and GICD_IGROUPR<n>E.
     2056     * 64-bit registers.
    20642057     */
    2065     if (offReg - GIC_DIST_REG_IGROUPRn_OFF_START < GIC_DIST_REG_IGROUPRn_RANGE_SIZE)
    2066     {
    2067         uint16_t const idxReg = (offReg - GIC_DIST_REG_IGROUPRn_OFF_START) / cbReg;
    2068         return gicDistWriteIntrGroupReg(pVM, pGicDev, idxReg, uValue);
    2069     }
    2070     if (offReg - GIC_DIST_REG_IGROUPRnE_OFF_START < GIC_DIST_REG_IGROUPRnE_RANGE_SIZE)
    2071     {
    2072         uint16_t const idxExt = RT_ELEMENTS(pGicDev->bmIntrGroup) / 2;
    2073         uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_IGROUPRnE_OFF_START) / cbReg;
    2074         return gicDistWriteIntrGroupReg(pVM, pGicDev, idxReg, uValue);
     2058    {
     2059        /*
     2060         * GICD_IROUTER<n> and GICD_IROUTER<n>E.
     2061         */
     2062        uint16_t const cbReg = sizeof(uint64_t);
     2063        if (offReg - GIC_DIST_REG_IROUTERn_OFF_START < GIC_DIST_REG_IROUTERn_RANGE_SIZE)
     2064        {
     2065            /* Hardware does not map the first 32 registers (corresponding to SGIs and PPIs). */
     2066            uint16_t const idxExt = GIC_INTID_RANGE_SPI_START;
     2067            uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_IROUTERn_OFF_START) / cbReg;
     2068            return gicDistWriteIntrRoutingReg(pGicDev, idxReg, uValue);
     2069        }
     2070        if (offReg - GIC_DIST_REG_IROUTERnE_OFF_START < GIC_DIST_REG_IROUTERnE_RANGE_SIZE)
     2071        {
     2072            uint16_t const idxExt = RT_ELEMENTS(pGicDev->au32IntrRouting) / 2;
     2073            uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_IROUTERnE_OFF_START) / cbReg;
     2074            return gicDistWriteIntrRoutingReg(pGicDev, idxReg, uValue);
     2075        }
     2076
    20752077    }
    20762078
    20772079    /*
    2078      * GICD_IROUTER<n> and GICD_IROUTER<n>E.
     2080     * 32-bit registers.
    20792081     */
    2080     if (offReg - GIC_DIST_REG_IROUTERn_OFF_START < GIC_DIST_REG_IROUTERn_RANGE_SIZE)
    2081     {
    2082         /* Hardware does not map the first 32 registers (corresponding to SGIs and PPIs). */
    2083         uint16_t const idxExt = GIC_INTID_RANGE_SPI_START;
    2084         uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_IROUTERn_OFF_START) / sizeof(uint64_t);
    2085         return gicDistWriteIntrRoutingReg(pGicDev, idxReg, uValue);
    2086     }
    2087     if (offReg - GIC_DIST_REG_IROUTERnE_OFF_START < GIC_DIST_REG_IROUTERnE_RANGE_SIZE)
    2088     {
    2089         uint16_t const idxExt = RT_ELEMENTS(pGicDev->au32IntrRouting) / 2;
    2090         uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_IROUTERnE_OFF_START) / sizeof(uint64_t);
    2091         return gicDistWriteIntrRoutingReg(pGicDev, idxReg, uValue);
    2092     }
    2093 
    2094     /*
    2095      * GICD_ISENABLER<n> and GICD_ISENABLER<n>E.
    2096      * GICD_ICENABLER<n> and GICD_ICENABLER<n>E.
    2097      */
    2098     if (offReg - GIC_DIST_REG_ISENABLERn_OFF_START  < GIC_DIST_REG_ISENABLERn_RANGE_SIZE)
    2099     {
    2100         uint16_t const idxReg = (offReg - GIC_DIST_REG_ISENABLERn_OFF_START) / cbReg;
    2101         return gicDistWriteIntrSetEnableReg(pVM, pGicDev, idxReg, uValue);
    2102     }
    2103     if (offReg - GIC_DIST_REG_ISENABLERnE_OFF_START < GIC_DIST_REG_ISENABLERnE_RANGE_SIZE)
    2104     {
    2105         uint16_t const idxExt = RT_ELEMENTS(pGicDev->bmIntrEnabled) / 2;
    2106         uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_ISENABLERnE_OFF_START) / cbReg;
    2107         return gicDistWriteIntrSetEnableReg(pVM, pGicDev, idxReg, uValue);
    2108     }
    2109 
    2110     if (offReg - GIC_DIST_REG_ICENABLERn_OFF_START  < GIC_DIST_REG_ICENABLERn_RANGE_SIZE)
    2111     {
    2112         uint16_t const idxReg = (offReg - GIC_DIST_REG_ICENABLERn_OFF_START) / cbReg;
    2113         return gicDistWriteIntrClearEnableReg(pVM, pGicDev, idxReg, uValue);
    2114     }
    2115     if (offReg - GIC_DIST_REG_ICENABLERnE_OFF_START < GIC_DIST_REG_ICENABLERnE_RANGE_SIZE)
    2116     {
    2117         uint16_t const idxExt = RT_ELEMENTS(pGicDev->bmIntrEnabled) / 2;
    2118         uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_ICENABLERnE_OFF_START) / cbReg;
    2119         return gicDistWriteIntrClearEnableReg(pVM, pGicDev, idxReg, uValue);
    2120     }
    2121 
    2122     /*
    2123      * GICD_ISACTIVER<n> and GICD_ISACTIVER<n>E.
    2124      * GICD_ICACTIVER<n> and GICD_ICACTIVER<n>E.
    2125      */
    2126     if (offReg - GIC_DIST_REG_ISACTIVERn_OFF_START < GIC_DIST_REG_ISACTIVERn_RANGE_SIZE)
    2127     {
    2128         uint16_t const idxReg = (offReg - GIC_DIST_REG_ISACTIVERn_OFF_START) / cbReg;
    2129         return gicDistWriteIntrSetActiveReg(pVM, pGicDev, idxReg, uValue);
    2130     }
    2131     if (offReg - GIC_DIST_REG_ISACTIVERnE_OFF_START < GIC_DIST_REG_ISACTIVERnE_RANGE_SIZE)
    2132     {
    2133         uint16_t const idxExt = RT_ELEMENTS(pGicDev->bmIntrActive) / 2;
    2134         uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_ISACTIVERnE_OFF_START) / cbReg;
    2135         return gicDistWriteIntrSetActiveReg(pVM, pGicDev, idxReg, uValue);
    2136     }
    2137 
    2138     if (offReg - GIC_DIST_REG_ICACTIVERn_OFF_START < GIC_DIST_REG_ICACTIVERn_RANGE_SIZE)
    2139     {
    2140         uint16_t const idxReg = (offReg - GIC_DIST_REG_ICACTIVERn_OFF_START) / cbReg;
    2141         return gicDistWriteIntrClearActiveReg(pVM, pGicDev, idxReg, uValue);
    2142     }
    2143     if (offReg - GIC_DIST_REG_ICACTIVERnE_OFF_START < GIC_DIST_REG_ICACTIVERnE_RANGE_SIZE)
    2144     {
    2145         uint16_t const idxExt = RT_ELEMENTS(pGicDev->bmIntrActive) / 2;
    2146         uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_ICACTIVERnE_OFF_START) / cbReg;
    2147         return gicDistWriteIntrClearActiveReg(pVM, pGicDev, idxReg, uValue);
    2148     }
    2149 
    2150     /*
    2151      * GICD_IPRIORITYR<n> and GICD_IPRIORITYR<n>E.
    2152      */
    2153     if (offReg - GIC_DIST_REG_IPRIORITYRn_OFF_START < GIC_DIST_REG_IPRIORITYRn_RANGE_SIZE)
    2154     {
    2155         uint16_t const idxReg = (offReg - GIC_DIST_REG_IPRIORITYRn_OFF_START) / cbReg;
    2156         return gicDistWriteIntrPriorityReg(pGicDev, idxReg, uValue);
    2157     }
    2158     if (offReg - GIC_DIST_REG_IPRIORITYRnE_OFF_START < GIC_DIST_REG_IPRIORITYRnE_RANGE_SIZE)
    2159     {
    2160         uint16_t const idxExt = RT_ELEMENTS(pGicDev->abIntrPriority) / (2 * sizeof(uint32_t));
    2161         uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_IPRIORITYRnE_OFF_START) / cbReg;
    2162         return gicDistWriteIntrPriorityReg(pGicDev, idxReg, uValue);
    2163     }
    2164 
    2165     /*
    2166      * GICD_ISPENDR<n> and GICD_ISPENDR<n>E.
    2167      * GICD_ICPENDR<n> and GICD_ICPENDR<n>E.
    2168      */
    2169     if (offReg - GIC_DIST_REG_ISPENDRn_OFF_START < GIC_DIST_REG_ISPENDRn_RANGE_SIZE)
    2170     {
    2171         uint16_t const idxReg = (offReg - GIC_DIST_REG_ISPENDRn_OFF_START) / cbReg;
    2172         return gicDistWriteIntrSetPendingReg(pVM, pGicDev, idxReg, uValue);
    2173     }
    2174     if (offReg - GIC_DIST_REG_ISPENDRnE_OFF_START < GIC_DIST_REG_ISPENDRnE_RANGE_SIZE)
    2175     {
    2176         uint16_t const idxExt = RT_ELEMENTS(pGicDev->bmIntrPending) / 2;
    2177         uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_ISPENDRnE_OFF_START) / cbReg;
    2178         return gicDistWriteIntrSetPendingReg(pVM, pGicDev, idxReg, uValue);
    2179     }
    2180 
    2181     if (offReg - GIC_DIST_REG_ICPENDRn_OFF_START < GIC_DIST_REG_ICPENDRn_RANGE_SIZE)
    2182     {
    2183         uint16_t const idxReg = (offReg - GIC_DIST_REG_ICPENDRn_OFF_START) / cbReg;
    2184         return gicDistWriteIntrClearPendingReg(pVM, pGicDev, idxReg, uValue);
    2185     }
    2186     if (offReg - GIC_DIST_REG_ICPENDRnE_OFF_START < GIC_DIST_REG_ICPENDRnE_RANGE_SIZE)
    2187     {
    2188         uint16_t const idxExt = RT_ELEMENTS(pGicDev->bmIntrPending) / 2;
    2189         uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_ICPENDRnE_OFF_START) / cbReg;
    2190         return gicDistWriteIntrClearPendingReg(pVM, pGicDev, idxReg, uValue);
    2191     }
    2192 
    2193     /*
    2194      * GICD_ICFGR<n> and GICD_ICFGR<n>E.
    2195      */
    2196     if (offReg - GIC_DIST_REG_ICFGRn_OFF_START < GIC_DIST_REG_ICFGRn_RANGE_SIZE)
    2197     {
    2198         uint16_t const idxReg = (offReg - GIC_DIST_REG_ICFGRn_OFF_START) / cbReg;
    2199         return gicDistWriteIntrConfigReg(pGicDev, idxReg, uValue);
    2200     }
    2201     if (offReg - GIC_DIST_REG_ICFGRnE_OFF_START < GIC_DIST_REG_ICFGRnE_RANGE_SIZE)
    2202     {
    2203         uint16_t const idxExt = RT_ELEMENTS(pGicDev->bmIntrConfig) / 2;
    2204         uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_ICFGRnE_OFF_START) / cbReg;
    2205         return gicDistWriteIntrConfigReg(pGicDev, idxReg, uValue);
     2082    {
     2083        /*
     2084         * GICD_IGROUPR<n> and GICD_IGROUPR<n>E.
     2085         */
     2086        uint16_t const cbReg = sizeof(uint32_t);
     2087        if (offReg - GIC_DIST_REG_IGROUPRn_OFF_START < GIC_DIST_REG_IGROUPRn_RANGE_SIZE)
     2088        {
     2089            uint16_t const idxReg = (offReg - GIC_DIST_REG_IGROUPRn_OFF_START) / cbReg;
     2090            return gicDistWriteIntrGroupReg(pVM, pGicDev, idxReg, uValue);
     2091        }
     2092        if (offReg - GIC_DIST_REG_IGROUPRnE_OFF_START < GIC_DIST_REG_IGROUPRnE_RANGE_SIZE)
     2093        {
     2094            uint16_t const idxExt = RT_ELEMENTS(pGicDev->bmIntrGroup) / 2;
     2095            uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_IGROUPRnE_OFF_START) / cbReg;
     2096            return gicDistWriteIntrGroupReg(pVM, pGicDev, idxReg, uValue);
     2097        }
     2098
     2099        /*
     2100         * GICD_ISENABLER<n> and GICD_ISENABLER<n>E.
     2101         * GICD_ICENABLER<n> and GICD_ICENABLER<n>E.
     2102         */
     2103        if (offReg - GIC_DIST_REG_ISENABLERn_OFF_START  < GIC_DIST_REG_ISENABLERn_RANGE_SIZE)
     2104        {
     2105            uint16_t const idxReg = (offReg - GIC_DIST_REG_ISENABLERn_OFF_START) / cbReg;
     2106            return gicDistWriteIntrSetEnableReg(pVM, pGicDev, idxReg, uValue);
     2107        }
     2108        if (offReg - GIC_DIST_REG_ISENABLERnE_OFF_START < GIC_DIST_REG_ISENABLERnE_RANGE_SIZE)
     2109        {
     2110            uint16_t const idxExt = RT_ELEMENTS(pGicDev->bmIntrEnabled) / 2;
     2111            uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_ISENABLERnE_OFF_START) / cbReg;
     2112            return gicDistWriteIntrSetEnableReg(pVM, pGicDev, idxReg, uValue);
     2113        }
     2114        if (offReg - GIC_DIST_REG_ICENABLERn_OFF_START  < GIC_DIST_REG_ICENABLERn_RANGE_SIZE)
     2115        {
     2116            uint16_t const idxReg = (offReg - GIC_DIST_REG_ICENABLERn_OFF_START) / cbReg;
     2117            return gicDistWriteIntrClearEnableReg(pVM, pGicDev, idxReg, uValue);
     2118        }
     2119        if (offReg - GIC_DIST_REG_ICENABLERnE_OFF_START < GIC_DIST_REG_ICENABLERnE_RANGE_SIZE)
     2120        {
     2121            uint16_t const idxExt = RT_ELEMENTS(pGicDev->bmIntrEnabled) / 2;
     2122            uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_ICENABLERnE_OFF_START) / cbReg;
     2123            return gicDistWriteIntrClearEnableReg(pVM, pGicDev, idxReg, uValue);
     2124        }
     2125
     2126        /*
     2127         * GICD_ISACTIVER<n> and GICD_ISACTIVER<n>E.
     2128         * GICD_ICACTIVER<n> and GICD_ICACTIVER<n>E.
     2129         */
     2130        if (offReg - GIC_DIST_REG_ISACTIVERn_OFF_START < GIC_DIST_REG_ISACTIVERn_RANGE_SIZE)
     2131        {
     2132            uint16_t const idxReg = (offReg - GIC_DIST_REG_ISACTIVERn_OFF_START) / cbReg;
     2133            return gicDistWriteIntrSetActiveReg(pVM, pGicDev, idxReg, uValue);
     2134        }
     2135        if (offReg - GIC_DIST_REG_ISACTIVERnE_OFF_START < GIC_DIST_REG_ISACTIVERnE_RANGE_SIZE)
     2136        {
     2137            uint16_t const idxExt = RT_ELEMENTS(pGicDev->bmIntrActive) / 2;
     2138            uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_ISACTIVERnE_OFF_START) / cbReg;
     2139            return gicDistWriteIntrSetActiveReg(pVM, pGicDev, idxReg, uValue);
     2140        }
     2141        if (offReg - GIC_DIST_REG_ICACTIVERn_OFF_START < GIC_DIST_REG_ICACTIVERn_RANGE_SIZE)
     2142        {
     2143            uint16_t const idxReg = (offReg - GIC_DIST_REG_ICACTIVERn_OFF_START) / cbReg;
     2144            return gicDistWriteIntrClearActiveReg(pVM, pGicDev, idxReg, uValue);
     2145        }
     2146        if (offReg - GIC_DIST_REG_ICACTIVERnE_OFF_START < GIC_DIST_REG_ICACTIVERnE_RANGE_SIZE)
     2147        {
     2148            uint16_t const idxExt = RT_ELEMENTS(pGicDev->bmIntrActive) / 2;
     2149            uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_ICACTIVERnE_OFF_START) / cbReg;
     2150            return gicDistWriteIntrClearActiveReg(pVM, pGicDev, idxReg, uValue);
     2151        }
     2152
     2153        /*
     2154         * GICD_IPRIORITYR<n> and GICD_IPRIORITYR<n>E.
     2155         */
     2156        if (offReg - GIC_DIST_REG_IPRIORITYRn_OFF_START < GIC_DIST_REG_IPRIORITYRn_RANGE_SIZE)
     2157        {
     2158            uint16_t const idxReg = (offReg - GIC_DIST_REG_IPRIORITYRn_OFF_START) / cbReg;
     2159            return gicDistWriteIntrPriorityReg(pGicDev, idxReg, uValue);
     2160        }
     2161        if (offReg - GIC_DIST_REG_IPRIORITYRnE_OFF_START < GIC_DIST_REG_IPRIORITYRnE_RANGE_SIZE)
     2162        {
     2163            uint16_t const idxExt = RT_ELEMENTS(pGicDev->abIntrPriority) / (2 * sizeof(uint32_t));
     2164            uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_IPRIORITYRnE_OFF_START) / cbReg;
     2165            return gicDistWriteIntrPriorityReg(pGicDev, idxReg, uValue);
     2166        }
     2167
     2168        /*
     2169         * GICD_ISPENDR<n> and GICD_ISPENDR<n>E.
     2170         * GICD_ICPENDR<n> and GICD_ICPENDR<n>E.
     2171         */
     2172        if (offReg - GIC_DIST_REG_ISPENDRn_OFF_START < GIC_DIST_REG_ISPENDRn_RANGE_SIZE)
     2173        {
     2174            uint16_t const idxReg = (offReg - GIC_DIST_REG_ISPENDRn_OFF_START) / cbReg;
     2175            return gicDistWriteIntrSetPendingReg(pVM, pGicDev, idxReg, uValue);
     2176        }
     2177        if (offReg - GIC_DIST_REG_ISPENDRnE_OFF_START < GIC_DIST_REG_ISPENDRnE_RANGE_SIZE)
     2178        {
     2179            uint16_t const idxExt = RT_ELEMENTS(pGicDev->bmIntrPending) / 2;
     2180            uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_ISPENDRnE_OFF_START) / cbReg;
     2181            return gicDistWriteIntrSetPendingReg(pVM, pGicDev, idxReg, uValue);
     2182        }
     2183        if (offReg - GIC_DIST_REG_ICPENDRn_OFF_START < GIC_DIST_REG_ICPENDRn_RANGE_SIZE)
     2184        {
     2185            uint16_t const idxReg = (offReg - GIC_DIST_REG_ICPENDRn_OFF_START) / cbReg;
     2186            return gicDistWriteIntrClearPendingReg(pVM, pGicDev, idxReg, uValue);
     2187        }
     2188        if (offReg - GIC_DIST_REG_ICPENDRnE_OFF_START < GIC_DIST_REG_ICPENDRnE_RANGE_SIZE)
     2189        {
     2190            uint16_t const idxExt = RT_ELEMENTS(pGicDev->bmIntrPending) / 2;
     2191            uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_ICPENDRnE_OFF_START) / cbReg;
     2192            return gicDistWriteIntrClearPendingReg(pVM, pGicDev, idxReg, uValue);
     2193        }
     2194
     2195        /*
     2196         * GICD_ICFGR<n> and GICD_ICFGR<n>E.
     2197         */
     2198        if (offReg - GIC_DIST_REG_ICFGRn_OFF_START < GIC_DIST_REG_ICFGRn_RANGE_SIZE)
     2199        {
     2200            uint16_t const idxReg = (offReg - GIC_DIST_REG_ICFGRn_OFF_START) / cbReg;
     2201            return gicDistWriteIntrConfigReg(pGicDev, idxReg, uValue);
     2202        }
     2203        if (offReg - GIC_DIST_REG_ICFGRnE_OFF_START < GIC_DIST_REG_ICFGRnE_RANGE_SIZE)
     2204        {
     2205            uint16_t const idxExt = RT_ELEMENTS(pGicDev->bmIntrConfig) / 2;
     2206            uint16_t const idxReg = idxExt + (offReg - GIC_DIST_REG_ICFGRnE_OFF_START) / cbReg;
     2207            return gicDistWriteIntrConfigReg(pGicDev, idxReg, uValue);
     2208        }
    22062209    }
    22072210
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