1 /******************************************************************************
3 * Copyright(c) 2003 - 2008 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("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("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("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("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("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
)
159 #ifdef CONFIG_IWLWIFI_DEBUG
160 if (atomic_read(&priv
->restrict_refcnt
))
163 /* this bit wakes up the NIC */
164 _iwl_set_bit(priv
, CSR_GP_CNTRL
, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ
);
165 ret
= _iwl_poll_bit(priv
, CSR_GP_CNTRL
,
166 CSR_GP_CNTRL_REG_VAL_MAC_ACCESS_EN
,
167 (CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY
|
168 CSR_GP_CNTRL_REG_FLAG_GOING_TO_SLEEP
), 50);
170 IWL_ERR(priv
, "MAC is in deep sleep!\n");
174 #ifdef CONFIG_IWLWIFI_DEBUG
175 atomic_inc(&priv
->restrict_refcnt
);
180 #ifdef CONFIG_IWLWIFI_DEBUG
181 static inline int __iwl_grab_nic_access(const char *f
, u32 l
,
182 struct iwl_priv
*priv
)
184 if (atomic_read(&priv
->restrict_refcnt
))
185 IWL_ERR(priv
, "Grabbing access while already held %s %d.\n", f
, l
);
187 IWL_DEBUG_IO("grabbing nic access - %s %d\n", f
, l
);
188 return _iwl_grab_nic_access(priv
);
190 #define iwl_grab_nic_access(priv) \
191 __iwl_grab_nic_access(__FILE__, __LINE__, priv)
193 #define iwl_grab_nic_access(priv) \
194 _iwl_grab_nic_access(priv)
197 static inline void _iwl_release_nic_access(struct iwl_priv
*priv
)
199 #ifdef CONFIG_IWLWIFI_DEBUG
200 if (atomic_dec_and_test(&priv
->restrict_refcnt
))
202 _iwl_clear_bit(priv
, CSR_GP_CNTRL
,
203 CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ
);
205 #ifdef CONFIG_IWLWIFI_DEBUG
206 static inline void __iwl_release_nic_access(const char *f
, u32 l
,
207 struct iwl_priv
*priv
)
209 if (atomic_read(&priv
->restrict_refcnt
) <= 0)
210 IWL_ERR(priv
, "Release unheld nic access at line %s %d.\n", f
, l
);
212 IWL_DEBUG_IO("releasing nic access - %s %d\n", f
, l
);
213 _iwl_release_nic_access(priv
);
215 #define iwl_release_nic_access(priv) \
216 __iwl_release_nic_access(__FILE__, __LINE__, priv)
218 #define iwl_release_nic_access(priv) \
219 _iwl_release_nic_access(priv)
222 static inline u32
_iwl_read_direct32(struct iwl_priv
*priv
, u32 reg
)
224 return _iwl_read32(priv
, reg
);
226 #ifdef CONFIG_IWLWIFI_DEBUG
227 static inline u32
__iwl_read_direct32(const char *f
, u32 l
,
228 struct iwl_priv
*priv
, u32 reg
)
230 u32 value
= _iwl_read_direct32(priv
, reg
);
231 if (!atomic_read(&priv
->restrict_refcnt
))
232 IWL_ERR(priv
, "Nic access not held from %s %d\n", f
, l
);
233 IWL_DEBUG_IO("read_direct32(0x%4X) = 0x%08x - %s %d \n", reg
, value
,
237 #define iwl_read_direct32(priv, reg) \
238 __iwl_read_direct32(__FILE__, __LINE__, priv, reg)
240 #define iwl_read_direct32 _iwl_read_direct32
243 static inline void _iwl_write_direct32(struct iwl_priv
*priv
,
246 _iwl_write32(priv
, reg
, value
);
248 #ifdef CONFIG_IWLWIFI_DEBUG
249 static void __iwl_write_direct32(const char *f
, u32 line
,
250 struct iwl_priv
*priv
, u32 reg
, u32 value
)
252 if (!atomic_read(&priv
->restrict_refcnt
))
253 IWL_ERR(priv
, "Nic access not held from %s line %d\n", f
, line
);
254 _iwl_write_direct32(priv
, reg
, value
);
256 #define iwl_write_direct32(priv, reg, value) \
257 __iwl_write_direct32(__func__, __LINE__, priv, reg, value)
259 #define iwl_write_direct32 _iwl_write_direct32
262 static inline void iwl_write_reg_buf(struct iwl_priv
*priv
,
263 u32 reg
, u32 len
, u32
*values
)
265 u32 count
= sizeof(u32
);
267 if ((priv
!= NULL
) && (values
!= NULL
)) {
268 for (; 0 < len
; len
-= count
, reg
+= count
, values
++)
269 _iwl_write_direct32(priv
, reg
, *values
);
273 static inline int _iwl_poll_direct_bit(struct iwl_priv
*priv
, u32 addr
,
274 u32 mask
, int timeout
)
276 return _iwl_poll_bit(priv
, addr
, mask
, mask
, timeout
);
279 #ifdef CONFIG_IWLWIFI_DEBUG
280 static inline int __iwl_poll_direct_bit(const char *f
, u32 l
,
281 struct iwl_priv
*priv
,
282 u32 addr
, u32 mask
, int timeout
)
284 int ret
= _iwl_poll_direct_bit(priv
, addr
, mask
, timeout
);
286 if (unlikely(ret
== -ETIMEDOUT
))
287 IWL_DEBUG_IO("poll_direct_bit(0x%08X, 0x%08X) - "
288 "timedout - %s %d\n", addr
, mask
, f
, l
);
290 IWL_DEBUG_IO("poll_direct_bit(0x%08X, 0x%08X) = 0x%08X "
291 "- %s %d\n", addr
, mask
, ret
, f
, l
);
294 #define iwl_poll_direct_bit(priv, addr, mask, timeout) \
295 __iwl_poll_direct_bit(__FILE__, __LINE__, priv, addr, mask, timeout)
297 #define iwl_poll_direct_bit _iwl_poll_direct_bit
300 static inline u32
_iwl_read_prph(struct iwl_priv
*priv
, u32 reg
)
302 _iwl_write_direct32(priv
, HBUS_TARG_PRPH_RADDR
, reg
| (3 << 24));
304 return _iwl_read_direct32(priv
, HBUS_TARG_PRPH_RDAT
);
306 #ifdef CONFIG_IWLWIFI_DEBUG
307 static inline u32
__iwl_read_prph(const char *f
, u32 line
,
308 struct iwl_priv
*priv
, u32 reg
)
310 if (!atomic_read(&priv
->restrict_refcnt
))
311 IWL_ERR(priv
, "Nic access not held from %s line %d\n", f
, line
);
312 return _iwl_read_prph(priv
, reg
);
315 #define iwl_read_prph(priv, reg) \
316 __iwl_read_prph(__func__, __LINE__, priv, reg)
318 #define iwl_read_prph _iwl_read_prph
321 static inline void _iwl_write_prph(struct iwl_priv
*priv
,
324 _iwl_write_direct32(priv
, HBUS_TARG_PRPH_WADDR
,
325 ((addr
& 0x0000FFFF) | (3 << 24)));
327 _iwl_write_direct32(priv
, HBUS_TARG_PRPH_WDAT
, val
);
329 #ifdef CONFIG_IWLWIFI_DEBUG
330 static inline void __iwl_write_prph(const char *f
, u32 line
,
331 struct iwl_priv
*priv
, u32 addr
, u32 val
)
333 if (!atomic_read(&priv
->restrict_refcnt
))
334 IWL_ERR(priv
, "Nic access not held from %s line %d\n", f
, line
);
335 _iwl_write_prph(priv
, addr
, val
);
338 #define iwl_write_prph(priv, addr, val) \
339 __iwl_write_prph(__func__, __LINE__, priv, addr, val);
341 #define iwl_write_prph _iwl_write_prph
344 #define _iwl_set_bits_prph(priv, reg, mask) \
345 _iwl_write_prph(priv, reg, (_iwl_read_prph(priv, reg) | mask))
346 #ifdef CONFIG_IWLWIFI_DEBUG
347 static inline void __iwl_set_bits_prph(const char *f
, u32 line
,
348 struct iwl_priv
*priv
,
351 if (!atomic_read(&priv
->restrict_refcnt
))
352 IWL_ERR(priv
, "Nic access not held from %s line %d\n", f
, line
);
354 _iwl_set_bits_prph(priv
, reg
, mask
);
356 #define iwl_set_bits_prph(priv, reg, mask) \
357 __iwl_set_bits_prph(__func__, __LINE__, priv, reg, mask)
359 #define iwl_set_bits_prph _iwl_set_bits_prph
362 #define _iwl_set_bits_mask_prph(priv, reg, bits, mask) \
363 _iwl_write_prph(priv, reg, ((_iwl_read_prph(priv, reg) & mask) | bits))
365 #ifdef CONFIG_IWLWIFI_DEBUG
366 static inline void __iwl_set_bits_mask_prph(const char *f
, u32 line
,
367 struct iwl_priv
*priv
, u32 reg
, u32 bits
, u32 mask
)
369 if (!atomic_read(&priv
->restrict_refcnt
))
370 IWL_ERR(priv
, "Nic access not held from %s line %d\n", f
, line
);
371 _iwl_set_bits_mask_prph(priv
, reg
, bits
, mask
);
373 #define iwl_set_bits_mask_prph(priv, reg, bits, mask) \
374 __iwl_set_bits_mask_prph(__func__, __LINE__, priv, reg, bits, mask)
376 #define iwl_set_bits_mask_prph _iwl_set_bits_mask_prph
379 static inline void iwl_clear_bits_prph(struct iwl_priv
380 *priv
, u32 reg
, u32 mask
)
382 u32 val
= _iwl_read_prph(priv
, reg
);
383 _iwl_write_prph(priv
, reg
, (val
& ~mask
));
386 static inline u32
iwl_read_targ_mem(struct iwl_priv
*priv
, u32 addr
)
388 iwl_write_direct32(priv
, HBUS_TARG_MEM_RADDR
, addr
);
390 return iwl_read_direct32(priv
, HBUS_TARG_MEM_RDAT
);
393 static inline void iwl_write_targ_mem(struct iwl_priv
*priv
, u32 addr
, u32 val
)
395 iwl_write_direct32(priv
, HBUS_TARG_MEM_WADDR
, addr
);
397 iwl_write_direct32(priv
, HBUS_TARG_MEM_WDAT
, val
);
400 static inline void iwl_write_targ_mem_buf(struct iwl_priv
*priv
, u32 addr
,
401 u32 len
, u32
*values
)
403 iwl_write_direct32(priv
, HBUS_TARG_MEM_WADDR
, addr
);
405 for (; 0 < len
; len
-= sizeof(u32
), values
++)
406 iwl_write_direct32(priv
, HBUS_TARG_MEM_WDAT
, *values
);