1 /******************************************************************************
3 * Copyright(c) 2003 - 2009 Intel Corporation. All rights reserved.
5 * Portions of this file are derived from the ipw3945 project.
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
20 * The full GNU General Public License is included in this distribution in the
21 * file called LICENSE.
23 * Contact Information:
24 * Intel Linux Wireless <ilw@linux.intel.com>
25 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27 *****************************************************************************/
34 #include "iwl-debug.h"
37 * IO, register, and NIC memory access functions
39 * NOTE on naming convention and macro usage for these
41 * A single _ prefix before a an access function means that no state
42 * check or debug information is printed when that function is called.
44 * A double __ prefix before an access function means that state is checked
45 * and the current line number and caller function name are printed in addition
46 * to any other debug output.
48 * The non-prefixed name is the #define that maps the caller into a
49 * #define that provides the caller's name and __LINE__ to the double
52 * If you wish to call the function without any debug or state checking,
53 * you should use the single _ prefix version (as is used by dependent IO
54 * routines, for example _iwl_read_direct32 calls the non-check version of
57 * These declarations are *extremely* useful in quickly isolating code deltas
58 * which result in misconfiguration of the hardware I/O. In combination with
59 * git-bisect and the IO debug level you can quickly determine the specific
60 * commit which breaks the IO sequence to the hardware.
64 #define _iwl_write32(priv, ofs, val) iowrite32((val), (priv)->hw_base + (ofs))
65 #ifdef CONFIG_IWLWIFI_DEBUG
66 static inline void __iwl_write32(const char *f
, u32 l
, struct iwl_priv
*priv
,
69 IWL_DEBUG_IO(priv
, "write32(0x%08X, 0x%08X) - %s %d\n", ofs
, val
, f
, l
);
70 _iwl_write32(priv
, ofs
, val
);
72 #define iwl_write32(priv, ofs, val) \
73 __iwl_write32(__FILE__, __LINE__, priv, ofs, val)
75 #define iwl_write32(priv, ofs, val) _iwl_write32(priv, ofs, val)
78 #define _iwl_read32(priv, ofs) ioread32((priv)->hw_base + (ofs))
79 #ifdef CONFIG_IWLWIFI_DEBUG
80 static inline u32
__iwl_read32(char *f
, u32 l
, struct iwl_priv
*priv
, u32 ofs
)
82 IWL_DEBUG_IO(priv
, "read_direct32(0x%08X) - %s %d\n", ofs
, f
, l
);
83 return _iwl_read32(priv
, ofs
);
85 #define iwl_read32(priv, ofs) __iwl_read32(__FILE__, __LINE__, priv, ofs)
87 #define iwl_read32(p, o) _iwl_read32(p, o)
90 #define IWL_POLL_INTERVAL 10 /* microseconds */
91 static inline int _iwl_poll_bit(struct iwl_priv
*priv
, u32 addr
,
92 u32 bits
, u32 mask
, int timeout
)
97 if ((_iwl_read32(priv
, addr
) & mask
) == (bits
& mask
))
99 udelay(IWL_POLL_INTERVAL
);
100 t
+= IWL_POLL_INTERVAL
;
101 } while (t
< timeout
);
105 #ifdef CONFIG_IWLWIFI_DEBUG
106 static inline int __iwl_poll_bit(const char *f
, u32 l
,
107 struct iwl_priv
*priv
, u32 addr
,
108 u32 bits
, u32 mask
, int timeout
)
110 int ret
= _iwl_poll_bit(priv
, addr
, bits
, mask
, timeout
);
111 IWL_DEBUG_IO(priv
, "poll_bit(0x%08X, 0x%08X, 0x%08X) - %s- %s %d\n",
113 unlikely(ret
== -ETIMEDOUT
) ? "timeout" : "", f
, l
);
116 #define iwl_poll_bit(priv, addr, bits, mask, timeout) \
117 __iwl_poll_bit(__FILE__, __LINE__, priv, addr, bits, mask, timeout)
119 #define iwl_poll_bit(p, a, b, m, t) _iwl_poll_bit(p, a, b, m, t)
122 static inline void _iwl_set_bit(struct iwl_priv
*priv
, u32 reg
, u32 mask
)
124 _iwl_write32(priv
, reg
, _iwl_read32(priv
, reg
) | mask
);
126 #ifdef CONFIG_IWLWIFI_DEBUG
127 static inline void __iwl_set_bit(const char *f
, u32 l
,
128 struct iwl_priv
*priv
, u32 reg
, u32 mask
)
130 u32 val
= _iwl_read32(priv
, reg
) | mask
;
131 IWL_DEBUG_IO(priv
, "set_bit(0x%08X, 0x%08X) = 0x%08X\n", reg
, mask
, val
);
132 _iwl_write32(priv
, reg
, val
);
134 #define iwl_set_bit(p, r, m) __iwl_set_bit(__FILE__, __LINE__, p, r, m)
136 #define iwl_set_bit(p, r, m) _iwl_set_bit(p, r, m)
139 static inline void _iwl_clear_bit(struct iwl_priv
*priv
, u32 reg
, u32 mask
)
141 _iwl_write32(priv
, reg
, _iwl_read32(priv
, reg
) & ~mask
);
143 #ifdef CONFIG_IWLWIFI_DEBUG
144 static inline void __iwl_clear_bit(const char *f
, u32 l
,
145 struct iwl_priv
*priv
, u32 reg
, u32 mask
)
147 u32 val
= _iwl_read32(priv
, reg
) & ~mask
;
148 IWL_DEBUG_IO(priv
, "clear_bit(0x%08X, 0x%08X) = 0x%08X\n", reg
, mask
, val
);
149 _iwl_write32(priv
, reg
, val
);
151 #define iwl_clear_bit(p, r, m) __iwl_clear_bit(__FILE__, __LINE__, p, r, m)
153 #define iwl_clear_bit(p, r, m) _iwl_clear_bit(p, r, m)
156 static inline int _iwl_grab_nic_access(struct iwl_priv
*priv
)
160 #ifdef CONFIG_IWLWIFI_DEBUG
161 if (atomic_read(&priv
->restrict_refcnt
))
164 /* this bit wakes up the NIC */
165 _iwl_set_bit(priv
, CSR_GP_CNTRL
, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ
);
166 ret
= _iwl_poll_bit(priv
, CSR_GP_CNTRL
,
167 CSR_GP_CNTRL_REG_VAL_MAC_ACCESS_EN
,
168 (CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY
|
169 CSR_GP_CNTRL_REG_FLAG_GOING_TO_SLEEP
), 15000);
171 val
= _iwl_read32(priv
, CSR_GP_CNTRL
);
172 IWL_ERR(priv
, "MAC is in deep sleep!. CSR_GP_CNTRL = 0x%08X\n", val
);
176 #ifdef CONFIG_IWLWIFI_DEBUG
177 atomic_inc(&priv
->restrict_refcnt
);
182 #ifdef CONFIG_IWLWIFI_DEBUG
183 static inline int __iwl_grab_nic_access(const char *f
, u32 l
,
184 struct iwl_priv
*priv
)
186 if (atomic_read(&priv
->restrict_refcnt
))
187 IWL_ERR(priv
, "Grabbing access while already held %s %d.\n", f
, l
);
189 IWL_DEBUG_IO(priv
, "grabbing nic access - %s %d\n", f
, l
);
190 return _iwl_grab_nic_access(priv
);
192 #define iwl_grab_nic_access(priv) \
193 __iwl_grab_nic_access(__FILE__, __LINE__, priv)
195 #define iwl_grab_nic_access(priv) \
196 _iwl_grab_nic_access(priv)
199 static inline void _iwl_release_nic_access(struct iwl_priv
*priv
)
201 #ifdef CONFIG_IWLWIFI_DEBUG
202 if (atomic_dec_and_test(&priv
->restrict_refcnt
))
204 _iwl_clear_bit(priv
, CSR_GP_CNTRL
,
205 CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ
);
207 #ifdef CONFIG_IWLWIFI_DEBUG
208 static inline void __iwl_release_nic_access(const char *f
, u32 l
,
209 struct iwl_priv
*priv
)
211 if (atomic_read(&priv
->restrict_refcnt
) <= 0)
212 IWL_ERR(priv
, "Release unheld nic access at line %s %d.\n", f
, l
);
214 IWL_DEBUG_IO(priv
, "releasing nic access - %s %d\n", f
, l
);
215 _iwl_release_nic_access(priv
);
217 #define iwl_release_nic_access(priv) \
218 __iwl_release_nic_access(__FILE__, __LINE__, priv)
220 #define iwl_release_nic_access(priv) \
221 _iwl_release_nic_access(priv)
224 static inline u32
_iwl_read_direct32(struct iwl_priv
*priv
, u32 reg
)
226 return _iwl_read32(priv
, reg
);
228 #ifdef CONFIG_IWLWIFI_DEBUG
229 static inline u32
__iwl_read_direct32(const char *f
, u32 l
,
230 struct iwl_priv
*priv
, u32 reg
)
232 u32 value
= _iwl_read_direct32(priv
, reg
);
233 if (!atomic_read(&priv
->restrict_refcnt
))
234 IWL_ERR(priv
, "Nic access not held from %s %d\n", f
, l
);
235 IWL_DEBUG_IO(priv
, "read_direct32(0x%4X) = 0x%08x - %s %d \n", reg
, value
,
239 #define iwl_read_direct32(priv, reg) \
240 __iwl_read_direct32(__FILE__, __LINE__, priv, reg)
242 #define iwl_read_direct32 _iwl_read_direct32
245 static inline void _iwl_write_direct32(struct iwl_priv
*priv
,
248 _iwl_write32(priv
, reg
, value
);
250 #ifdef CONFIG_IWLWIFI_DEBUG
251 static void __iwl_write_direct32(const char *f
, u32 line
,
252 struct iwl_priv
*priv
, u32 reg
, u32 value
)
254 if (!atomic_read(&priv
->restrict_refcnt
))
255 IWL_ERR(priv
, "Nic access not held from %s line %d\n", f
, line
);
256 _iwl_write_direct32(priv
, reg
, value
);
258 #define iwl_write_direct32(priv, reg, value) \
259 __iwl_write_direct32(__func__, __LINE__, priv, reg, value)
261 #define iwl_write_direct32 _iwl_write_direct32
264 static inline void iwl_write_reg_buf(struct iwl_priv
*priv
,
265 u32 reg
, u32 len
, u32
*values
)
267 u32 count
= sizeof(u32
);
269 if ((priv
!= NULL
) && (values
!= NULL
)) {
270 for (; 0 < len
; len
-= count
, reg
+= count
, values
++)
271 _iwl_write_direct32(priv
, reg
, *values
);
275 static inline int _iwl_poll_direct_bit(struct iwl_priv
*priv
, u32 addr
,
276 u32 mask
, int timeout
)
278 return _iwl_poll_bit(priv
, addr
, mask
, mask
, timeout
);
281 #ifdef CONFIG_IWLWIFI_DEBUG
282 static inline int __iwl_poll_direct_bit(const char *f
, u32 l
,
283 struct iwl_priv
*priv
,
284 u32 addr
, u32 mask
, int timeout
)
286 int ret
= _iwl_poll_direct_bit(priv
, addr
, mask
, timeout
);
288 if (unlikely(ret
== -ETIMEDOUT
))
289 IWL_DEBUG_IO(priv
, "poll_direct_bit(0x%08X, 0x%08X) - "
290 "timedout - %s %d\n", addr
, mask
, f
, l
);
292 IWL_DEBUG_IO(priv
, "poll_direct_bit(0x%08X, 0x%08X) = 0x%08X "
293 "- %s %d\n", addr
, mask
, ret
, f
, l
);
296 #define iwl_poll_direct_bit(priv, addr, mask, timeout) \
297 __iwl_poll_direct_bit(__FILE__, __LINE__, priv, addr, mask, timeout)
299 #define iwl_poll_direct_bit _iwl_poll_direct_bit
302 static inline u32
_iwl_read_prph(struct iwl_priv
*priv
, u32 reg
)
304 _iwl_write_direct32(priv
, HBUS_TARG_PRPH_RADDR
, reg
| (3 << 24));
306 return _iwl_read_direct32(priv
, HBUS_TARG_PRPH_RDAT
);
308 #ifdef CONFIG_IWLWIFI_DEBUG
309 static inline u32
__iwl_read_prph(const char *f
, u32 line
,
310 struct iwl_priv
*priv
, u32 reg
)
312 if (!atomic_read(&priv
->restrict_refcnt
))
313 IWL_ERR(priv
, "Nic access not held from %s line %d\n", f
, line
);
314 return _iwl_read_prph(priv
, reg
);
317 #define iwl_read_prph(priv, reg) \
318 __iwl_read_prph(__func__, __LINE__, priv, reg)
320 #define iwl_read_prph _iwl_read_prph
323 static inline void _iwl_write_prph(struct iwl_priv
*priv
,
326 _iwl_write_direct32(priv
, HBUS_TARG_PRPH_WADDR
,
327 ((addr
& 0x0000FFFF) | (3 << 24)));
329 _iwl_write_direct32(priv
, HBUS_TARG_PRPH_WDAT
, val
);
331 #ifdef CONFIG_IWLWIFI_DEBUG
332 static inline void __iwl_write_prph(const char *f
, u32 line
,
333 struct iwl_priv
*priv
, u32 addr
, u32 val
)
335 if (!atomic_read(&priv
->restrict_refcnt
))
336 IWL_ERR(priv
, "Nic access not held from %s line %d\n", f
, line
);
337 _iwl_write_prph(priv
, addr
, val
);
340 #define iwl_write_prph(priv, addr, val) \
341 __iwl_write_prph(__func__, __LINE__, priv, addr, val);
343 #define iwl_write_prph _iwl_write_prph
346 #define _iwl_set_bits_prph(priv, reg, mask) \
347 _iwl_write_prph(priv, reg, (_iwl_read_prph(priv, reg) | mask))
348 #ifdef CONFIG_IWLWIFI_DEBUG
349 static inline void __iwl_set_bits_prph(const char *f
, u32 line
,
350 struct iwl_priv
*priv
,
353 if (!atomic_read(&priv
->restrict_refcnt
))
354 IWL_ERR(priv
, "Nic access not held from %s line %d\n", f
, line
);
356 _iwl_set_bits_prph(priv
, reg
, mask
);
358 #define iwl_set_bits_prph(priv, reg, mask) \
359 __iwl_set_bits_prph(__func__, __LINE__, priv, reg, mask)
361 #define iwl_set_bits_prph _iwl_set_bits_prph
364 #define _iwl_set_bits_mask_prph(priv, reg, bits, mask) \
365 _iwl_write_prph(priv, reg, ((_iwl_read_prph(priv, reg) & mask) | bits))
367 #ifdef CONFIG_IWLWIFI_DEBUG
368 static inline void __iwl_set_bits_mask_prph(const char *f
, u32 line
,
369 struct iwl_priv
*priv
, u32 reg
, u32 bits
, u32 mask
)
371 if (!atomic_read(&priv
->restrict_refcnt
))
372 IWL_ERR(priv
, "Nic access not held from %s line %d\n", f
, line
);
373 _iwl_set_bits_mask_prph(priv
, reg
, bits
, mask
);
375 #define iwl_set_bits_mask_prph(priv, reg, bits, mask) \
376 __iwl_set_bits_mask_prph(__func__, __LINE__, priv, reg, bits, mask)
378 #define iwl_set_bits_mask_prph _iwl_set_bits_mask_prph
381 static inline void iwl_clear_bits_prph(struct iwl_priv
382 *priv
, u32 reg
, u32 mask
)
384 u32 val
= _iwl_read_prph(priv
, reg
);
385 _iwl_write_prph(priv
, reg
, (val
& ~mask
));
388 static inline u32
iwl_read_targ_mem(struct iwl_priv
*priv
, u32 addr
)
390 iwl_write_direct32(priv
, HBUS_TARG_MEM_RADDR
, addr
);
392 return iwl_read_direct32(priv
, HBUS_TARG_MEM_RDAT
);
395 static inline void iwl_write_targ_mem(struct iwl_priv
*priv
, u32 addr
, u32 val
)
397 iwl_write_direct32(priv
, HBUS_TARG_MEM_WADDR
, addr
);
399 iwl_write_direct32(priv
, HBUS_TARG_MEM_WDAT
, val
);
402 static inline void iwl_write_targ_mem_buf(struct iwl_priv
*priv
, u32 addr
,
403 u32 len
, u32
*values
)
405 iwl_write_direct32(priv
, HBUS_TARG_MEM_WADDR
, addr
);
407 for (; 0 < len
; len
-= sizeof(u32
), values
++)
408 iwl_write_direct32(priv
, HBUS_TARG_MEM_WDAT
, *values
);