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 * James P. Ketrenos <ipw2100-admin@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 static inline int _iwl_poll_bit(struct iwl_priv *priv, u32 addr,
91 u32 bits, u32 mask, int timeout)
96 if ((_iwl_read32(priv, addr) & mask) == (bits & mask))
100 } while (i < timeout);
104 #ifdef CONFIG_IWLWIFI_DEBUG
105 static inline int __iwl_poll_bit(const char *f, u32 l,
106 struct iwl_priv *priv, u32 addr,
107 u32 bits, u32 mask, int timeout)
109 int ret = _iwl_poll_bit(priv, addr, bits, mask, timeout);
110 IWL_DEBUG_IO("poll_bit(0x%08X, 0x%08X, 0x%08X) - %s- %s %d\n",
112 unlikely(ret == -ETIMEDOUT) ? "timeout" : "", f, l);
115 #define iwl_poll_bit(priv, addr, bits, mask, timeout) \
116 __iwl_poll_bit(__FILE__, __LINE__, priv, addr, bits, mask, timeout)
118 #define iwl_poll_bit(p, a, b, m, t) _iwl_poll_bit(p, a, b, m, t)
121 static inline void _iwl_set_bit(struct iwl_priv *priv, u32 reg, u32 mask)
123 _iwl_write32(priv, reg, _iwl_read32(priv, reg) | mask);
125 #ifdef CONFIG_IWLWIFI_DEBUG
126 static inline void __iwl_set_bit(const char *f, u32 l,
127 struct iwl_priv *priv, u32 reg, u32 mask)
129 u32 val = _iwl_read32(priv, reg) | mask;
130 IWL_DEBUG_IO("set_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val);
131 _iwl_write32(priv, reg, val);
133 #define iwl_set_bit(p, r, m) __iwl_set_bit(__FILE__, __LINE__, p, r, m)
135 #define iwl_set_bit(p, r, m) _iwl_set_bit(p, r, m)
138 static inline void _iwl_clear_bit(struct iwl_priv *priv, u32 reg, u32 mask)
140 _iwl_write32(priv, reg, _iwl_read32(priv, reg) & ~mask);
142 #ifdef CONFIG_IWLWIFI_DEBUG
143 static inline void __iwl_clear_bit(const char *f, u32 l,
144 struct iwl_priv *priv, u32 reg, u32 mask)
146 u32 val = _iwl_read32(priv, reg) & ~mask;
147 IWL_DEBUG_IO("clear_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val);
148 _iwl_write32(priv, reg, val);
150 #define iwl_clear_bit(p, r, m) __iwl_clear_bit(__FILE__, __LINE__, p, r, m)
152 #define iwl_clear_bit(p, r, m) _iwl_clear_bit(p, r, m)
155 static inline int _iwl_grab_nic_access(struct iwl_priv *priv)
158 #ifdef CONFIG_IWLWIFI_DEBUG
159 if (atomic_read(&priv->restrict_refcnt))
162 /* this bit wakes up the NIC */
163 _iwl_set_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
164 ret = _iwl_poll_bit(priv, CSR_GP_CNTRL,
165 CSR_GP_CNTRL_REG_VAL_MAC_ACCESS_EN,
166 (CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY |
167 CSR_GP_CNTRL_REG_FLAG_GOING_TO_SLEEP), 50);
169 IWL_ERROR("MAC is in deep sleep!\n");
173 #ifdef CONFIG_IWLWIFI_DEBUG
174 atomic_inc(&priv->restrict_refcnt);
179 #ifdef CONFIG_IWLWIFI_DEBUG
180 static inline int __iwl_grab_nic_access(const char *f, u32 l,
181 struct iwl_priv *priv)
183 if (atomic_read(&priv->restrict_refcnt))
184 IWL_ERROR("Grabbing access while already held %s %d.\n", f, l);
186 IWL_DEBUG_IO("grabbing nic access - %s %d\n", f, l);
187 return _iwl_grab_nic_access(priv);
189 #define iwl_grab_nic_access(priv) \
190 __iwl_grab_nic_access(__FILE__, __LINE__, priv)
192 #define iwl_grab_nic_access(priv) \
193 _iwl_grab_nic_access(priv)
196 static inline void _iwl_release_nic_access(struct iwl_priv *priv)
198 #ifdef CONFIG_IWLWIFI_DEBUG
199 if (atomic_dec_and_test(&priv->restrict_refcnt))
201 _iwl_clear_bit(priv, CSR_GP_CNTRL,
202 CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
204 #ifdef CONFIG_IWLWIFI_DEBUG
205 static inline void __iwl_release_nic_access(const char *f, u32 l,
206 struct iwl_priv *priv)
208 if (atomic_read(&priv->restrict_refcnt) <= 0)
209 IWL_ERROR("Release unheld nic access at line %s %d.\n", f, l);
211 IWL_DEBUG_IO("releasing nic access - %s %d\n", f, l);
212 _iwl_release_nic_access(priv);
214 #define iwl_release_nic_access(priv) \
215 __iwl_release_nic_access(__FILE__, __LINE__, priv)
217 #define iwl_release_nic_access(priv) \
218 _iwl_release_nic_access(priv)
221 static inline u32 _iwl_read_direct32(struct iwl_priv *priv, u32 reg)
223 return _iwl_read32(priv, reg);
225 #ifdef CONFIG_IWLWIFI_DEBUG
226 static inline u32 __iwl_read_direct32(const char *f, u32 l,
227 struct iwl_priv *priv, u32 reg)
229 u32 value = _iwl_read_direct32(priv, reg);
230 if (!atomic_read(&priv->restrict_refcnt))
231 IWL_ERROR("Nic access not held from %s %d\n", f, l);
232 IWL_DEBUG_IO("read_direct32(0x%4X) = 0x%08x - %s %d \n", reg, value,
236 #define iwl_read_direct32(priv, reg) \
237 __iwl_read_direct32(__FILE__, __LINE__, priv, reg)
239 #define iwl_read_direct32 _iwl_read_direct32
242 static inline void _iwl_write_direct32(struct iwl_priv *priv,
245 _iwl_write32(priv, reg, value);
247 #ifdef CONFIG_IWLWIFI_DEBUG
248 static void __iwl_write_direct32(const char *f , u32 line,
249 struct iwl_priv *priv, u32 reg, u32 value)
251 if (!atomic_read(&priv->restrict_refcnt))
252 IWL_ERROR("Nic access not held from %s line %d\n", f, line);
253 _iwl_write_direct32(priv, reg, value);
255 #define iwl_write_direct32(priv, reg, value) \
256 __iwl_write_direct32(__func__, __LINE__, priv, reg, value)
258 #define iwl_write_direct32 _iwl_write_direct32
261 static inline void iwl_write_reg_buf(struct iwl_priv *priv,
262 u32 reg, u32 len, u32 *values)
264 u32 count = sizeof(u32);
266 if ((priv != NULL) && (values != NULL)) {
267 for (; 0 < len; len -= count, reg += count, values++)
268 _iwl_write_direct32(priv, reg, *values);
272 static inline int _iwl_poll_direct_bit(struct iwl_priv *priv, u32 addr,
273 u32 mask, int timeout)
275 return _iwl_poll_bit(priv, addr, mask, mask, timeout);
278 #ifdef CONFIG_IWLWIFI_DEBUG
279 static inline int __iwl_poll_direct_bit(const char *f, u32 l,
280 struct iwl_priv *priv,
281 u32 addr, u32 mask, int timeout)
283 int ret = _iwl_poll_direct_bit(priv, addr, mask, timeout);
285 if (unlikely(ret == -ETIMEDOUT))
286 IWL_DEBUG_IO("poll_direct_bit(0x%08X, 0x%08X) - "
287 "timedout - %s %d\n", addr, mask, f, l);
289 IWL_DEBUG_IO("poll_direct_bit(0x%08X, 0x%08X) = 0x%08X "
290 "- %s %d\n", addr, mask, ret, f, l);
293 #define iwl_poll_direct_bit(priv, addr, mask, timeout) \
294 __iwl_poll_direct_bit(__FILE__, __LINE__, priv, addr, mask, timeout)
296 #define iwl_poll_direct_bit _iwl_poll_direct_bit
299 static inline u32 _iwl_read_prph(struct iwl_priv *priv, u32 reg)
301 _iwl_write_direct32(priv, HBUS_TARG_PRPH_RADDR, reg | (3 << 24));
302 return _iwl_read_direct32(priv, HBUS_TARG_PRPH_RDAT);
304 #ifdef CONFIG_IWLWIFI_DEBUG
305 static inline u32 __iwl_read_prph(const char *f, u32 line,
306 struct iwl_priv *priv, u32 reg)
308 if (!atomic_read(&priv->restrict_refcnt))
309 IWL_ERROR("Nic access not held from %s line %d\n", f, line);
310 return _iwl_read_prph(priv, reg);
313 #define iwl_read_prph(priv, reg) \
314 __iwl_read_prph(__func__, __LINE__, priv, reg)
316 #define iwl_read_prph _iwl_read_prph
319 static inline void _iwl_write_prph(struct iwl_priv *priv,
322 _iwl_write_direct32(priv, HBUS_TARG_PRPH_WADDR,
323 ((addr & 0x0000FFFF) | (3 << 24)));
324 _iwl_write_direct32(priv, HBUS_TARG_PRPH_WDAT, val);
326 #ifdef CONFIG_IWLWIFI_DEBUG
327 static inline void __iwl_write_prph(const char *f, u32 line,
328 struct iwl_priv *priv, u32 addr, u32 val)
330 if (!atomic_read(&priv->restrict_refcnt))
331 IWL_ERROR("Nic access not held from %s line %d\n", f, line);
332 _iwl_write_prph(priv, addr, val);
335 #define iwl_write_prph(priv, addr, val) \
336 __iwl_write_prph(__func__, __LINE__, priv, addr, val);
338 #define iwl_write_prph _iwl_write_prph
341 #define _iwl_set_bits_prph(priv, reg, mask) \
342 _iwl_write_prph(priv, reg, (_iwl_read_prph(priv, reg) | mask))
343 #ifdef CONFIG_IWLWIFI_DEBUG
344 static inline void __iwl_set_bits_prph(const char *f, u32 line,
345 struct iwl_priv *priv,
348 if (!atomic_read(&priv->restrict_refcnt))
349 IWL_ERROR("Nic access not held from %s line %d\n", f, line);
351 _iwl_set_bits_prph(priv, reg, mask);
353 #define iwl_set_bits_prph(priv, reg, mask) \
354 __iwl_set_bits_prph(__func__, __LINE__, priv, reg, mask)
356 #define iwl_set_bits_prph _iwl_set_bits_prph
359 #define _iwl_set_bits_mask_prph(priv, reg, bits, mask) \
360 _iwl_write_prph(priv, reg, ((_iwl_read_prph(priv, reg) & mask) | bits))
362 #ifdef CONFIG_IWLWIFI_DEBUG
363 static inline void __iwl_set_bits_mask_prph(const char *f, u32 line,
364 struct iwl_priv *priv, u32 reg, u32 bits, u32 mask)
366 if (!atomic_read(&priv->restrict_refcnt))
367 IWL_ERROR("Nic access not held from %s line %d\n", f, line);
368 _iwl_set_bits_mask_prph(priv, reg, bits, mask);
370 #define iwl_set_bits_mask_prph(priv, reg, bits, mask) \
371 __iwl_set_bits_mask_prph(__func__, __LINE__, priv, reg, bits, mask)
373 #define iwl_set_bits_mask_prph _iwl_set_bits_mask_prph
376 static inline void iwl_clear_bits_prph(struct iwl_priv
377 *priv, u32 reg, u32 mask)
379 u32 val = _iwl_read_prph(priv, reg);
380 _iwl_write_prph(priv, reg, (val & ~mask));
383 static inline u32 iwl_read_targ_mem(struct iwl_priv *priv, u32 addr)
385 iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR, addr);
386 return iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
389 static inline void iwl_write_targ_mem(struct iwl_priv *priv, u32 addr, u32 val)
391 iwl_write_direct32(priv, HBUS_TARG_MEM_WADDR, addr);
392 iwl_write_direct32(priv, HBUS_TARG_MEM_WDAT, val);
395 static inline void iwl_write_targ_mem_buf(struct iwl_priv *priv, u32 addr,
396 u32 len, u32 *values)
398 iwl_write_direct32(priv, HBUS_TARG_MEM_WADDR, addr);
399 for (; 0 < len; len -= sizeof(u32), values++)
400 iwl_write_direct32(priv, HBUS_TARG_MEM_WDAT, *values);