1 /* 2 * Copyright (c) 2023 Qualcomm Innovation Center, Inc. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for any 5 * purpose with or without fee is hereby granted, provided that the above 6 * copyright notice and this permission notice appear in all copies. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 15 */ 16 #ifndef HAL_HWIO_H 17 #define HAL_HWIO_H 18 19 /* 20 * Common types. 21 */ 22 #include "HALcomdef.h" 23 24 25 26 /* ----------------------------------------------------------------------- 27 ** Macros 28 ** ----------------------------------------------------------------------- */ 29 30 /** 31 @addtogroup macros 32 @{ 33 */ 34 35 /** 36 * Map a base name to the pointer to access the base. 37 * 38 * This macro maps a base name to the pointer to access the base. 39 * This is generally just used internally. 40 * 41 */ 42 #define HWIO_BASE_PTR(base) base##_BASE_PTR 43 44 45 /** 46 * Declare a HWIO base pointer. 47 * 48 * This macro will declare a HWIO base pointer data structure. The pointer 49 * will always be declared as a weak symbol so multiple declarations will 50 * resolve correctly to the same data at link-time. 51 */ 52 #ifdef __ARMCC_VERSION 53 #define DECLARE_HWIO_BASE_PTR(base) __weak uint8 *HWIO_BASE_PTR(base) 54 #else 55 #define DECLARE_HWIO_BASE_PTR(base) uint8 *HWIO_BASE_PTR(base) 56 #endif 57 58 /** 59 @} 60 */ 61 62 #ifdef CONFIG_WHAL_MM 63 #define SEQ_WCSS_WCMN_OFFSET SEQ_WCSS_TOP_CMN_OFFSET 64 #define SEQ_WCSS_PMM_OFFSET SEQ_WCSS_PMM_TOP_OFFSET 65 #endif 66 67 68 /** 69 @addtogroup hwio_macros 70 @{ 71 */ 72 73 /** 74 * @name Address Macros 75 * 76 * Macros for getting register addresses. 77 * These macros are used for retrieving the address of a register. 78 * HWIO_ADDR* will return the directly accessible address (virtual or physical based 79 * on environment), HWIO_PHYS* will always return the physical address. 80 * The offset from the base region can be retrieved using HWIO_OFFS*. 81 * The "X" extension is used for explicit addressing where the base address of 82 * the module in question is provided as an argument to the macro. 83 * 84 * @{ 85 */ 86 #define HWIO_ADDR(hwiosym) __msmhwio_addr(hwiosym) 87 #define HWIO_ADDRI(hwiosym, index) __msmhwio_addri(hwiosym, index) 88 #define HWIO_ADDRI2(hwiosym, index1, index2) __msmhwio_addri2(hwiosym, index1, index2) 89 #define HWIO_ADDRI3(hwiosym, index1, index2, index3) __msmhwio_addri3(hwiosym, index1, index2, index3) 90 91 #define HWIO_ADDRX(base, hwiosym) __msmhwio_addrx(base, hwiosym) 92 #define HWIO_ADDRXI(base, hwiosym, index) __msmhwio_addrxi(base, hwiosym, index) 93 #define HWIO_ADDRXI2(base, hwiosym, index1, index2) __msmhwio_addrxi2(base, hwiosym, index1, index2) 94 #define HWIO_ADDRXI3(base, hwiosym, index1, index2, index3) __msmhwio_addrxi3(base, hwiosym, index1, index2, index3) 95 96 #define HWIO_PHYS(hwiosym) __msmhwio_phys(hwiosym) 97 #define HWIO_PHYSI(hwiosym, index) __msmhwio_physi(hwiosym, index) 98 #define HWIO_PHYSI2(hwiosym, index1, index2) __msmhwio_physi2(hwiosym, index1, index2) 99 #define HWIO_PHYSI3(hwiosym, index1, index2, index3) __msmhwio_physi3(hwiosym, index1, index2, index3) 100 101 #define HWIO_PHYSX(base, hwiosym) __msmhwio_physx(base, hwiosym) 102 #define HWIO_PHYSXI(base, hwiosym, index) __msmhwio_physxi(base, hwiosym, index) 103 #define HWIO_PHYSXI2(base, hwiosym, index1, index2) __msmhwio_physxi2(base, hwiosym, index1, index2) 104 #define HWIO_PHYSXI3(base, hwiosym, index1, index2, index3) __msmhwio_physxi3(base, hwiosym, index1, index2, index3) 105 106 #define HWIO_OFFS(hwiosym) __msmhwio_offs(hwiosym) 107 #define HWIO_OFFSI(hwiosym, index) __msmhwio_offsi(hwiosym, index) 108 #define HWIO_OFFSI2(hwiosym, index1, index2) __msmhwio_offsi2(hwiosym, index1, index2) 109 #define HWIO_OFFSI3(hwiosym, index1, index2, index3) __msmhwio_offsi3(hwiosym, index1, index2, index3) 110 /** @} */ 111 112 /** 113 * @name Input Macros 114 * 115 * These macros are used for reading from a named hardware register. Register 116 * arrays ("indexed") use the macros with the "I" suffix. The "M" suffix 117 * indicates that the input will be masked with the supplied mask. The HWIO_INF* 118 * macros take a field name and will do the appropriate masking and shifting 119 * to return just the value of that field. 120 * The "X" extension is used for explicit addressing where the base address of 121 * the module in question is provided as an argument to the macro. 122 * 123 * Generally you want to use either HWIO_IN or HWIO_INF (with required indexing). 124 * 125 * @{ 126 */ 127 #define HWIO_IN(hwiosym) __msmhwio_in(hwiosym) 128 #define HWIO_INI(hwiosym, index) __msmhwio_ini(hwiosym, index) 129 #define HWIO_INI2(hwiosym, index1, index2) __msmhwio_ini2(hwiosym, index1, index2) 130 #define HWIO_INI3(hwiosym, index1, index2, index3) __msmhwio_ini3(hwiosym, index1, index2, index3) 131 132 #define HWIO_INM(hwiosym, mask) __msmhwio_inm(hwiosym, mask) 133 #define HWIO_INMI(hwiosym, index, mask) __msmhwio_inmi(hwiosym, index, mask) 134 #define HWIO_INMI2(hwiosym, index1, index2, mask) __msmhwio_inmi2(hwiosym, index1, index2, mask) 135 #define HWIO_INMI3(hwiosym, index1, index2, index3, mask) __msmhwio_inmi3(hwiosym, index1, index2, index3, mask) 136 137 #define HWIO_INF(io, field) (HWIO_INM(io, HWIO_FMSK(io, field)) >> HWIO_SHFT(io, field)) 138 #define HWIO_INFI(io, index, field) (HWIO_INMI(io, index, HWIO_FMSK(io, field)) >> HWIO_SHFT(io, field)) 139 #define HWIO_INFI2(io, index1, index2, field) (HWIO_INMI2(io, index1, index2, HWIO_FMSK(io, field)) >> HWIO_SHFT(io, field)) 140 #define HWIO_INFI3(io, index1, index2, index3, field) (HWIO_INMI3(io, index1, index2, index3, HWIO_FMSK(io, field)) >> HWIO_SHFT(io, field)) 141 142 #define HWIO_INX(base, hwiosym) __msmhwio_inx(base, hwiosym) 143 #define HWIO_INXI(base, hwiosym, index) __msmhwio_inxi(base, hwiosym, index) 144 #define HWIO_INXI2(base, hwiosym, index1, index2) __msmhwio_inxi2(base, hwiosym, index1, index2) 145 #define HWIO_INXI3(base, hwiosym, index1, index2, index3) __msmhwio_inxi3(base, hwiosym, index1, index2, index3) 146 147 #define HWIO_INXM(base, hwiosym, mask) __msmhwio_inxm(base, hwiosym, mask) 148 #define HWIO_INXMI(base, hwiosym, index, mask) __msmhwio_inxmi(base, hwiosym, index, mask) 149 #define HWIO_INXMI2(base, hwiosym, index1, index2, mask) __msmhwio_inxmi2(base, hwiosym, index1, index2, mask) 150 #define HWIO_INXMI3(base, hwiosym, index1, index2, index3, mask) __msmhwio_inxmi3(base, hwiosym, index1, index2, index3, mask) 151 152 #define HWIO_INXF(base, io, field) (HWIO_INXM(base, io, HWIO_FMSK(io, field)) >> HWIO_SHFT(io, field)) 153 #define HWIO_INXFI(base, io, index, field) (HWIO_INXMI(base, io, index, HWIO_FMSK(io, field)) >> HWIO_SHFT(io, field)) 154 #define HWIO_INXFI2(base, io, index1, index2, field) (HWIO_INXMI2(base, io, index1, index2, HWIO_FMSK(io, field)) >> HWIO_SHFT(io, field)) 155 #define HWIO_INXFI3(base, io, index1, index2, index3, field) (HWIO_INXMI3(base, io, index1, index2, index3, HWIO_FMSK(io, field)) >> HWIO_SHFT(io, field)) 156 /** @} */ 157 158 /** 159 * @name Output Macros 160 * 161 * These macros are used for writing to a named hardware register. Register 162 * arrays ("indexed") use the macros with the "I" suffix. The "M" suffix 163 * indicates that the output will be masked with the supplied mask (meaning these 164 * macros do a read first, mask in the supplied data, then write it back). 165 * The "X" extension is used for explicit addressing where the base address of 166 * the module in question is provided as an argument to the macro. 167 * The HWIO_OUTF* macros take a field name and will do the appropriate masking 168 * and shifting to output just the value of that field. 169 * HWIO_OUTV* registers take a named value instead of a numeric value and 170 * do the same masking/shifting as HWIO_OUTF. 171 * 172 * Generally you want to use either HWIO_OUT or HWIO_OUTF (with required indexing). 173 * 174 * @{ 175 */ 176 #define HWIO_OUT(hwiosym, val) __msmhwio_out(hwiosym, val) 177 #define HWIO_OUTI(hwiosym, index, val) __msmhwio_outi(hwiosym, index, val) 178 #define HWIO_OUTI2(hwiosym, index1, index2, val) __msmhwio_outi2(hwiosym, index1, index2, val) 179 #define HWIO_OUTI3(hwiosym, index1, index2, index3, val) __msmhwio_outi3(hwiosym, index1, index2, index3, val) 180 181 #define HWIO_OUTM(hwiosym, mask, val) __msmhwio_outm(hwiosym, mask, val) 182 #define HWIO_OUTMI(hwiosym, index, mask, val) __msmhwio_outmi(hwiosym, index, mask, val) 183 #define HWIO_OUTMI2(hwiosym, index1, index2, mask, val) __msmhwio_outmi2(hwiosym, index1, index2, mask, val) 184 #define HWIO_OUTMI3(hwiosym, index1, index2, index3, mask, val) __msmhwio_outmi3(hwiosym, index1, index2, index3, mask, val) 185 186 #define HWIO_OUTF(io, field, val) HWIO_OUTM(io, HWIO_FMSK(io, field), (uint32)(val) << HWIO_SHFT(io, field)) 187 #define HWIO_OUTFI(io, index, field, val) HWIO_OUTMI(io, index, HWIO_FMSK(io, field), (uint32)(val) << HWIO_SHFT(io, field)) 188 #define HWIO_OUTFI2(io, index1, index2, field, val) HWIO_OUTMI2(io, index1, index2, HWIO_FMSK(io, field), (uint32)(val) << HWIO_SHFT(io, field)) 189 #define HWIO_OUTFI3(io, index1, index2, index3, field, val) HWIO_OUTMI3(io, index1, index2, index3, HWIO_FMSK(io, field), (uint32)(val) << HWIO_SHFT(io, field)) 190 191 #define HWIO_OUTV(io, field, val) HWIO_OUTM(io, HWIO_FMSK(io, field), (uint32)(HWIO_VAL(io, field, val)) << HWIO_SHFT(io, field)) 192 #define HWIO_OUTVI(io, index, field, val) HWIO_OUTMI(io, index, HWIO_FMSK(io, field), (uint32)(HWIO_VAL(io, field, val)) << HWIO_SHFT(io, field)) 193 #define HWIO_OUTVI2(io, index1, index2, field, val) HWIO_OUTMI2(io, index1, index2, HWIO_FMSK(io, field), (uint32)(HWIO_VAL(io, field, val)) << HWIO_SHFT(io, field)) 194 #define HWIO_OUTVI3(io, index1, index2, index3, field, val) HWIO_OUTMI3(io, index1, index2, index3, HWIO_FMSK(io, field), (uint32)(HWIO_VAL(io, field, val)) << HWIO_SHFT(io, field)) 195 196 #define HWIO_OUTX(base, hwiosym, val) __msmhwio_outx(base, hwiosym, val) 197 #define HWIO_OUTXI(base, hwiosym, index, val) __msmhwio_outxi(base, hwiosym, index, val) 198 #define HWIO_OUTXI2(base, hwiosym, index1, index2, val) __msmhwio_outxi2(base, hwiosym, index1, index2, val) 199 #define HWIO_OUTXI3(base, hwiosym, index1, index2, index3, val) __msmhwio_outxi3(base, hwiosym, index1, index2, index3, val) 200 201 #define HWIO_OUTXM(base, hwiosym, mask, val) __msmhwio_outxm(base, hwiosym, mask, val) 202 #define HWIO_OUTXM2(base, hwiosym, mask1, mask2, val1, val2) __msmhwio_outxm2(base, hwiosym, mask1, mask2, val1, val2) 203 #define HWIO_OUTXM3(base, hwiosym, mask1, mask2, mask3, val1, val2, val3) __msmhwio_outxm3(base, hwiosym, mask1, mask2, mask3, val1, val2, val3) 204 #define HWIO_OUTXM4(base, hwiosym, mask1, mask2, mask3, mask4, val1, val2, val3, val4) __msmhwio_outxm4(base, hwiosym, mask1, mask2, mask3, mask4, val1, val2, val3, val4) 205 #define HWIO_OUTXMI(base, hwiosym, index, mask, val) __msmhwio_outxmi(base, hwiosym, index, mask, val) 206 #define HWIO_OUTXMI2(base, hwiosym, index1, index2, mask, val) __msmhwio_outxmi2(base, hwiosym, index1, index2, mask, val) 207 #define HWIO_OUTXMI3(base, hwiosym, index1, index2, index3, mask, val) __msmhwio_outxmi3(base, hwiosym, index1, index2, index3, mask, val) 208 209 #define HWIO_OUTXF(base, io, field, val) HWIO_OUTXM(base, io, HWIO_FMSK(io, field), (uint32)(val) << HWIO_SHFT(io, field)) 210 #define HWIO_OUTX2F(base, io, field1, field2, val1, val2) HWIO_OUTXM2(base, io, HWIO_FMSK(io, field1), HWIO_FMSK(io, field2), (uint32)(val1) << HWIO_SHFT(io, field1), (uint32)(val2) << HWIO_SHFT(io, field2)) 211 #define HWIO_OUTX3F(base, io, field1, field2, field3, val1, val2, val3) HWIO_OUTXM3(base, io, HWIO_FMSK(io, field1), HWIO_FMSK(io, field2), HWIO_FMSK(io, field3),(uint32)(val1) << HWIO_SHFT(io, field1), (uint32)(val2) << HWIO_SHFT(io, field2), (uint32)(val3) << HWIO_SHFT(io, field3) ) 212 #define HWIO_OUTX4F(base, io, field1, field2, field3, field4, val1, val2, val3, val4) HWIO_OUTXM4(base, io, HWIO_FMSK(io, field1), HWIO_FMSK(io, field2), HWIO_FMSK(io, field3), HWIO_FMSK(io, field4), (uint32)(val1) << HWIO_SHFT(io, field1) , (uint32)(val2) << HWIO_SHFT(io, field2), (uint32)(val3) << HWIO_SHFT(io, field3), (uint32)(val4) << HWIO_SHFT(io, field4) ) 213 214 #define HWIO_OUTXFI(base, io, index, field, val) HWIO_OUTXMI(base, io, index, HWIO_FMSK(io, field), (uint32)(val) << HWIO_SHFT(io, field)) 215 #define HWIO_OUTXFI2(base, io, index1, index2, field, val) HWIO_OUTXMI2(base, io, index1, index2, HWIO_FMSK(io, field), (uint32)(val) << HWIO_SHFT(io, field)) 216 #define HWIO_OUTXFI3(base, io, index1, index2, index3, field, val) HWIO_OUTXMI3(base, io, index1, index2, index3, HWIO_FMSK(io, field), (uint32)(val) << HWIO_SHFT(io, field)) 217 218 #define HWIO_OUTXV(base, io, field, val) HWIO_OUTXM(base, io, HWIO_FMSK(io, field), (uint32)(HWIO_VAL(io, field, val)) << HWIO_SHFT(io, field)) 219 #define HWIO_OUTXVI(base, io, index, field, val) HWIO_OUTXMI(base, io, index, HWIO_FMSK(io, field), (uint32)(HWIO_VAL(io, field, val)) << HWIO_SHFT(io, field)) 220 #define HWIO_OUTXVI2(base, io, index1, index2, field, val) HWIO_OUTXMI2(base, io, index1, index2, HWIO_FMSK(io, field), (uint32)(HWIO_VAL(io, field, val)) << HWIO_SHFT(io, field)) 221 #define HWIO_OUTXVI3(base, io, index1, index2, index3, field, val) HWIO_OUTXMI3(base, io, index1, index2, index3, HWIO_FMSK(io, field), (uint32)(HWIO_VAL(io, field, val)) << HWIO_SHFT(io, field)) 222 /** @} */ 223 224 /** 225 * @name Shift and Mask Macros 226 * 227 * Macros for getting shift and mask values for fields and registers. 228 * HWIO_RMSK: The mask value for accessing an entire register. For example: 229 * @code 230 * HWIO_RMSK(REG) -> 0xFFFFFFFF 231 * @endcode 232 * HWIO_RSHFT: The right-shift value for an entire register (rarely necessary).\n 233 * HWIO_SHFT: The right-shift value for accessing a field in a register. For example: 234 * @code 235 * HWIO_SHFT(REG, FLD) -> 8 236 * @endcode 237 * HWIO_FMSK: The mask value for accessing a field in a register. For example: 238 * @code 239 * HWIO_FMSK(REG, FLD) -> 0xFF00 240 * @endcode 241 * HWIO_VAL: The value for a field in a register. For example: 242 * @code 243 * HWIO_VAL(REG, FLD, ON) -> 0x1 244 * @endcode 245 * HWIO_FVAL: This macro takes a numerical value and will shift and mask it into 246 * the given field position. For example: 247 * @code 248 * HWIO_FVAL(REG, FLD, 0x1) -> 0x100 249 * @endcode 250 * HWIO_FVALV: This macro takes a logical (named) value and will shift and mask it 251 * into the given field position. For example: 252 * @code 253 * HWIO_FVALV(REG, FLD, ON) -> 0x100 254 * @endcode 255 * 256 * @{ 257 */ 258 #define HWIO_RMSK(hwiosym) __msmhwio_rmsk(hwiosym) 259 #define HWIO_RMSKI(hwiosym, index) __msmhwio_rmski(hwiosym, index) 260 #define HWIO_RSHFT(hwiosym) __msmhwio_rshft(hwiosym) 261 #define HWIO_SHFT(hwio_regsym, hwio_fldsym) __msmhwio_shft(hwio_regsym, hwio_fldsym) 262 #define HWIO_FMSK(hwio_regsym, hwio_fldsym) __msmhwio_fmsk(hwio_regsym, hwio_fldsym) 263 #define HWIO_VAL(io, field, val) __msmhwio_val(io, field, val) 264 #define HWIO_FVAL(io, field, val) (((uint32)(val) << HWIO_SHFT(io, field)) & HWIO_FMSK(io, field)) 265 #define HWIO_FVALV(io, field, val) (((uint32)(HWIO_VAL(io, field, val)) << HWIO_SHFT(io, field)) & HWIO_FMSK(io, field)) 266 /** @} */ 267 268 /** 269 * @name Shadow Register Macros 270 * 271 * These macros are used for directly reading the value stored in a 272 * shadow register. 273 * Shadow registers are defined for write-only registers. Generally these 274 * macros should not be necessary as HWIO_OUTM* macros will automatically use 275 * the shadow values internally. 276 * 277 * @{ 278 */ 279 #define HWIO_SHDW(hwiosym) __msmhwio_shdw(hwiosym) 280 #define HWIO_SHDWI(hwiosym, index) __msmhwio_shdwi(hwiosym, index) 281 /** @} */ 282 283 /** 284 @} 285 */ /* end_group */ 286 287 288 /** @cond */ 289 290 /* 291 * Map to final symbols. This remapping is done to allow register 292 * redefinitions. If we just define HWIO_IN(xreg) as HWIO_##xreg##_IN 293 * then remappings like "#define xreg xregnew" do not work as expected. 294 */ 295 #define __msmhwio_in(hwiosym) HWIO_##hwiosym##_IN 296 #define __msmhwio_ini(hwiosym, index) HWIO_##hwiosym##_INI(index) 297 #define __msmhwio_ini2(hwiosym, index1, index2) HWIO_##hwiosym##_INI2(index1, index2) 298 #define __msmhwio_ini3(hwiosym, index1, index2, index3) HWIO_##hwiosym##_INI3(index1, index2, index3) 299 #define __msmhwio_inm(hwiosym, mask) HWIO_##hwiosym##_INM(mask) 300 #define __msmhwio_inmi(hwiosym, index, mask) HWIO_##hwiosym##_INMI(index, mask) 301 #define __msmhwio_inmi2(hwiosym, index1, index2, mask) HWIO_##hwiosym##_INMI2(index1, index2, mask) 302 #define __msmhwio_inmi3(hwiosym, index1, index2, index3, mask) HWIO_##hwiosym##_INMI3(index1, index2, index3, mask) 303 #define __msmhwio_out(hwiosym, val) HWIO_##hwiosym##_OUT(val) 304 #define __msmhwio_outi(hwiosym, index, val) HWIO_##hwiosym##_OUTI(index,val) 305 #define __msmhwio_outi2(hwiosym, index1, index2, val) HWIO_##hwiosym##_OUTI2(index1, index2, val) 306 #define __msmhwio_outi3(hwiosym, index1, index2, index3, val) HWIO_##hwiosym##_OUTI2(index1, index2, index3, val) 307 #define __msmhwio_outm(hwiosym, mask, val) HWIO_##hwiosym##_OUTM(mask, val) 308 #define __msmhwio_outmi(hwiosym, index, mask, val) HWIO_##hwiosym##_OUTMI(index, mask, val) 309 #define __msmhwio_outmi2(hwiosym, idx1, idx2, mask, val) HWIO_##hwiosym##_OUTMI2(idx1, idx2, mask, val) 310 #define __msmhwio_outmi3(hwiosym, idx1, idx2, idx3, mask, val) HWIO_##hwiosym##_OUTMI3(idx1, idx2, idx3, mask, val) 311 #define __msmhwio_addr(hwiosym) HWIO_##hwiosym##_ADDR 312 #define __msmhwio_addri(hwiosym, index) HWIO_##hwiosym##_ADDR(index) 313 #define __msmhwio_addri2(hwiosym, idx1, idx2) HWIO_##hwiosym##_ADDR(idx1, idx2) 314 #define __msmhwio_addri3(hwiosym, idx1, idx2, idx3) HWIO_##hwiosym##_ADDR(idx1, idx2, idx3) 315 #define __msmhwio_phys(hwiosym) HWIO_##hwiosym##_PHYS 316 #define __msmhwio_physi(hwiosym, index) HWIO_##hwiosym##_PHYS(index) 317 #define __msmhwio_physi2(hwiosym, idx1, idx2) HWIO_##hwiosym##_PHYS(idx1, idx2) 318 #define __msmhwio_physi3(hwiosym, idx1, idx2, idx3) HWIO_##hwiosym##_PHYS(idx1, idx2, idx3) 319 #define __msmhwio_offs(hwiosym) HWIO_##hwiosym##_OFFS 320 #define __msmhwio_offsi(hwiosym, index) HWIO_##hwiosym##_OFFS(index) 321 #define __msmhwio_offsi2(hwiosym, idx1, idx2) HWIO_##hwiosym##_OFFS(idx1, idx2) 322 #define __msmhwio_offsi3(hwiosym, idx1, idx2, idx3) HWIO_##hwiosym##_OFFS(idx1, idx2, idx3) 323 #define __msmhwio_rmsk(hwiosym) HWIO_##hwiosym##_RMSK 324 #define __msmhwio_rmski(hwiosym, index) HWIO_##hwiosym##_RMSK(index) 325 #define __msmhwio_fmsk(hwiosym, hwiofldsym) HWIO_##hwiosym##_##hwiofldsym##_BMSK 326 #define __msmhwio_rshft(hwiosym) HWIO_##hwiosym##_SHFT 327 #define __msmhwio_shft(hwiosym, hwiofldsym) HWIO_##hwiosym##_##hwiofldsym##_SHFT 328 #define __msmhwio_shdw(hwiosym) HWIO_##hwiosym##_shadow 329 #define __msmhwio_shdwi(hwiosym, index) HWIO_##hwiosym##_SHDW(index) 330 #define __msmhwio_val(hwiosym, hwiofld, hwioval) HWIO_##hwiosym##_##hwiofld##_##hwioval##_FVAL 331 332 #define __msmhwio_inx(base, hwiosym) HWIO_##hwiosym##_IN(base) 333 #define __msmhwio_inxi(base, hwiosym, index) HWIO_##hwiosym##_INI(base, index) 334 #define __msmhwio_inxi2(base, hwiosym, index1, index2) HWIO_##hwiosym##_INI2(base, index1, index2) 335 #define __msmhwio_inxi3(base, hwiosym, index1, index2, index3) HWIO_##hwiosym##_INI3(base, index1, index2, index3) 336 #define __msmhwio_inxm(base, hwiosym, mask) HWIO_##hwiosym##_INM(base, mask) 337 #define __msmhwio_inxmi(base, hwiosym, index, mask) HWIO_##hwiosym##_INMI(base, index, mask) 338 #define __msmhwio_inxmi2(base, hwiosym, index1, index2, mask) HWIO_##hwiosym##_INMI2(base, index1, index2, mask) 339 #define __msmhwio_inxmi3(base, hwiosym, index1, index2, index3, mask) HWIO_##hwiosym##_INMI3(base, index1, index2, index3, mask) 340 #define __msmhwio_outx(base, hwiosym, val) HWIO_##hwiosym##_OUT(base, val) 341 #define __msmhwio_outxi(base, hwiosym, index, val) HWIO_##hwiosym##_OUTI(base, index,val) 342 #define __msmhwio_outxi2(base, hwiosym, index1, index2, val) HWIO_##hwiosym##_OUTI2(base, index1, index2, val) 343 #define __msmhwio_outxi3(base, hwiosym, index1, index2, index3, val) HWIO_##hwiosym##_OUTI2(base, index1, index2, index3, val) 344 #define __msmhwio_outxm(base, hwiosym, mask, val) HWIO_##hwiosym##_OUTM(base, mask, val) 345 #define __msmhwio_outxm2(base, hwiosym, mask1, mask2, val1, val2) { \ 346 HWIO_##hwiosym##_OUTM(base, mask1, val1); \ 347 HWIO_##hwiosym##_OUTM(base, mask2, val2); \ 348 } 349 #define __msmhwio_outxm3(base, hwiosym, mask1, mask2, mask3, val1, val2, val3) { \ 350 HWIO_##hwiosym##_OUTM(base, mask1, val1); \ 351 HWIO_##hwiosym##_OUTM(base, mask2, val2); \ 352 HWIO_##hwiosym##_OUTM(base, mask3, val3); \ 353 } 354 #define __msmhwio_outxm4(base, hwiosym, mask1, mask2, mask3, mask4, val1, val2, val3, val4) { \ 355 HWIO_##hwiosym##_OUTM(base, mask1, val1); \ 356 HWIO_##hwiosym##_OUTM(base, mask2, val2); \ 357 HWIO_##hwiosym##_OUTM(base, mask3, val3); \ 358 HWIO_##hwiosym##_OUTM(base, mask4, val4); \ 359 } 360 361 362 #define __msmhwio_outxmi(base, hwiosym, index, mask, val) HWIO_##hwiosym##_OUTMI(base, index, mask, val) 363 #define __msmhwio_outxmi2(base, hwiosym, idx1, idx2, mask, val) HWIO_##hwiosym##_OUTMI2(base, idx1, idx2, mask, val) 364 #define __msmhwio_outxmi3(base, hwiosym, idx1, idx2, idx3, mask, val) HWIO_##hwiosym##_OUTMI3(base, idx1, idx2, idx3, mask, val) 365 #define __msmhwio_addrx(base, hwiosym) HWIO_##hwiosym##_ADDR(base) 366 #define __msmhwio_addrxi(base, hwiosym, index) HWIO_##hwiosym##_ADDR(base, index) 367 #define __msmhwio_addrxi2(base, hwiosym, idx1, idx2) HWIO_##hwiosym##_ADDR(base, idx1, idx2) 368 #define __msmhwio_addrxi3(base, hwiosym, idx1, idx2, idx3) HWIO_##hwiosym##_ADDR(base, idx1, idx2, idx3) 369 #define __msmhwio_physx(base, hwiosym) HWIO_##hwiosym##_PHYS(base) 370 #define __msmhwio_physxi(base, hwiosym, index) HWIO_##hwiosym##_PHYS(base, index) 371 #define __msmhwio_physxi2(base, hwiosym, idx1, idx2) HWIO_##hwiosym##_PHYS(base, idx1, idx2) 372 #define __msmhwio_physxi3(base, hwiosym, idx1, idx2, idx3) HWIO_##hwiosym##_PHYS(base, idx1, idx2, idx3) 373 374 375 /* 376 * HWIO_INTLOCK 377 * 378 * Macro used by autogenerated code for mutual exclusion around 379 * read-mask-write operations. This is not supported in HAL 380 * code but can be overridden by non-HAL code. 381 */ 382 #define HWIO_INTLOCK() 383 #define HWIO_INTFREE() 384 385 386 /* 387 * Input/output port macros for memory mapped IO. 388 */ 389 #define __inp(port) (*((volatile uint8 *) (port))) 390 #define __inpw(port) (*((volatile uint16 *) (port))) 391 #define __inpdw(port) (*((volatile uint32 *) (port))) 392 #define __outp(port, val) (*((volatile uint8 *) (port)) = ((uint8) (val))) 393 #define __outpw(port, val) (*((volatile uint16 *) (port)) = ((uint16) (val))) 394 #define __outpdw(port, val) (*((volatile uint32 *) (port)) = ((uint32) (val))) 395 396 397 #ifdef HAL_HWIO_EXTERNAL 398 399 /* 400 * Replace macros with externally supplied functions. 401 */ 402 #undef __inp 403 #undef __inpw 404 #undef __inpdw 405 #undef __outp 406 #undef __outpw 407 #undef __outpdw 408 409 #ifdef WCSS_IE_EN 410 extern uint32 registerRead(unsigned long addr); 411 extern void registerWrite(unsigned long addr, uint32 value); 412 #define __inp(port) registerRead(port) 413 #define __inpw(port) registerRead(port) 414 #define __inpdw(port) registerRead(port) 415 #define __outp(port, val) registerWrite(port, val) 416 #define __outpw(port, val) registerWrite(port, val) 417 #define __outpdw(port, val) registerWrite(port, val) 418 #else 419 #define __inp(port) __inp_extern((uint32) (port)) 420 #define __inpw(port) __inpw_extern((uint32) (port)) 421 #define __inpdw(port) __inpdw_extern((uint32) (port)) 422 #define __outp(port, val) __outp_extern((uint32) (port), val) 423 #define __outpw(port, val) __outpw_extern((uint32) (port), val) 424 #define __outpdw(port, val) __outpdw_extern((uint32) (port), val) 425 426 extern uint8 __inp_extern ( uint32 nAddr ); 427 extern uint16 __inpw_extern ( uint32 nAddr ); 428 extern uint32 __inpdw_extern ( uint32 nAddr ); 429 extern void __outp_extern ( uint32 nAddr, uint8 nData ); 430 extern void __outpw_extern ( uint32 nAddr, uint16 nData ); 431 extern void __outpdw_extern ( uint32 nAddr, uint32 nData ); 432 #endif 433 434 435 #endif /* HAL_HWIO_EXTERNAL */ 436 437 438 /* 439 * Base 8-bit byte accessing macros. 440 */ 441 #define in_byte(addr) (__inp(addr)) 442 #define in_byte_masked(addr, mask) (__inp(addr) & (mask)) 443 #define out_byte(addr, val) __outp(addr,val) 444 #define out_byte_masked(io, mask, val, shadow) \ 445 HWIO_INTLOCK(); \ 446 out_byte( io, shadow); \ 447 shadow = (shadow & (uint16)(~(mask))) | ((uint16)((val) & (mask))); \ 448 HWIO_INTFREE() 449 #define out_byte_masked_ns(io, mask, val, current_reg_content) \ 450 out_byte( io, ((current_reg_content & (uint16)(~(mask))) | \ 451 ((uint16)((val) & (mask)))) ) 452 453 454 /* 455 * Base 16-bit word accessing macros. 456 */ 457 #define in_word(addr) (__inpw(addr)) 458 #define in_word_masked(addr, mask) (__inpw(addr) & (mask)) 459 #define out_word(addr, val) __outpw(addr,val) 460 #define out_word_masked(io, mask, val, shadow) \ 461 HWIO_INTLOCK( ); \ 462 shadow = (shadow & (uint16)(~(mask))) | ((uint16)((val) & (mask))); \ 463 out_word( io, shadow); \ 464 HWIO_INTFREE( ) 465 #define out_word_masked_ns(io, mask, val, current_reg_content) \ 466 out_word( io, ((current_reg_content & (uint16)(~(mask))) | \ 467 ((uint16)((val) & (mask)))) ) 468 469 470 /* 471 * Base 32-bit double-word accessing macros. 472 */ 473 #define in_dword(addr) (__inpdw(addr)) 474 #define in_dword_masked(addr, mask) (__inpdw(addr) & (mask)) 475 #define out_dword(addr, val) __outpdw(addr,val) 476 #define out_dword_masked(io, mask, val, shadow) \ 477 HWIO_INTLOCK(); \ 478 shadow = (shadow & (uint32)(~(mask))) | ((uint32)((val) & (mask))); \ 479 out_dword( io, shadow); \ 480 HWIO_INTFREE() 481 #define out_dword_masked_ns(io, mask, val, current_reg_content) \ 482 out_dword( io, ((current_reg_content & (uint32)(~(mask))) | \ 483 ((uint32)((val) & (mask)))) ) 484 485 /** @endcond */ 486 487 #endif /* HAL_HWIO_H */ 488 489