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