iwlwifi: cleanup namespace
[linux-2.6.git] / drivers / net / wireless / iwlwifi / iwl-4965-io.h
1 /******************************************************************************
2  *
3  * Copyright(c) 2003 - 2007 Intel Corporation. All rights reserved.
4  *
5  * Portions of this file are derived from the ipw3945 project.
6  *
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.
10  *
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
14  * more details.
15  *
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
19  *
20  * The full GNU General Public License is included in this distribution in the
21  * file called LICENSE.
22  *
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
26  *
27  *****************************************************************************/
28
29 #ifndef __iwl4965_io_h__
30 #define __iwl4965_io_h__
31
32 #include <linux/io.h>
33
34 #include "iwl-4965-debug.h"
35
36 /*
37  * IO, register, and NIC memory access functions
38  *
39  * NOTE on naming convention and macro usage for these
40  *
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.
43  *
44  * A double __ prefix before an access function means that state is checked
45  * and the current line number is printed in addition to any other debug output.
46  *
47  * The non-prefixed name is the #define that maps the caller into a
48  * #define that provides the caller's __LINE__ to the double prefix version.
49  *
50  * If you wish to call the function without any debug or state checking,
51  * you should use the single _ prefix version (as is used by dependent IO
52  * routines, for example _iwl4965_read_direct32 calls the non-check version of
53  * _iwl4965_read32.)
54  *
55  * These declarations are *extremely* useful in quickly isolating code deltas
56  * which result in misconfiguring of the hardware I/O.  In combination with
57  * git-bisect and the IO debug level you can quickly determine the specific
58  * commit which breaks the IO sequence to the hardware.
59  *
60  */
61
62 #define _iwl4965_write32(iwl, ofs, val) writel((val), (iwl)->hw_base + (ofs))
63 #ifdef CONFIG_IWL4965_DEBUG
64 static inline void __iwl4965_write32(const char *f, u32 l, struct iwl4965_priv *iwl,
65                                  u32 ofs, u32 val)
66 {
67         IWL_DEBUG_IO("write32(0x%08X, 0x%08X) - %s %d\n", ofs, val, f, l);
68         _iwl4965_write32(iwl, ofs, val);
69 }
70 #define iwl4965_write32(iwl, ofs, val) \
71         __iwl4965_write32(__FILE__, __LINE__, iwl, ofs, val)
72 #else
73 #define iwl4965_write32(iwl, ofs, val) _iwl4965_write32(iwl, ofs, val)
74 #endif
75
76 #define _iwl4965_read32(iwl, ofs) readl((iwl)->hw_base + (ofs))
77 #ifdef CONFIG_IWL4965_DEBUG
78 static inline u32 __iwl4965_read32(char *f, u32 l, struct iwl4965_priv *iwl, u32 ofs)
79 {
80         IWL_DEBUG_IO("read_direct32(0x%08X) - %s %d\n", ofs, f, l);
81         return _iwl4965_read32(iwl, ofs);
82 }
83 #define iwl4965_read32(iwl, ofs) __iwl4965_read32(__FILE__, __LINE__, iwl, ofs)
84 #else
85 #define iwl4965_read32(p, o) _iwl4965_read32(p, o)
86 #endif
87
88 static inline int _iwl4965_poll_bit(struct iwl4965_priv *priv, u32 addr,
89                                 u32 bits, u32 mask, int timeout)
90 {
91         int i = 0;
92
93         do {
94                 if ((_iwl4965_read32(priv, addr) & mask) == (bits & mask))
95                         return i;
96                 mdelay(10);
97                 i += 10;
98         } while (i < timeout);
99
100         return -ETIMEDOUT;
101 }
102 #ifdef CONFIG_IWL4965_DEBUG
103 static inline int __iwl4965_poll_bit(const char *f, u32 l,
104                                  struct iwl4965_priv *priv, u32 addr,
105                                  u32 bits, u32 mask, int timeout)
106 {
107         int ret = _iwl4965_poll_bit(priv, addr, bits, mask, timeout);
108         if (unlikely(ret  == -ETIMEDOUT))
109                 IWL_DEBUG_IO
110                     ("poll_bit(0x%08X, 0x%08X, 0x%08X) - timedout - %s %d\n",
111                      addr, bits, mask, f, l);
112         else
113                 IWL_DEBUG_IO
114                     ("poll_bit(0x%08X, 0x%08X, 0x%08X) = 0x%08X - %s %d\n",
115                      addr, bits, mask, ret, f, l);
116         return ret;
117 }
118 #define iwl4965_poll_bit(iwl, addr, bits, mask, timeout) \
119         __iwl4965_poll_bit(__FILE__, __LINE__, iwl, addr, bits, mask, timeout)
120 #else
121 #define iwl4965_poll_bit(p, a, b, m, t) _iwl4965_poll_bit(p, a, b, m, t)
122 #endif
123
124 static inline void _iwl4965_set_bit(struct iwl4965_priv *priv, u32 reg, u32 mask)
125 {
126         _iwl4965_write32(priv, reg, _iwl4965_read32(priv, reg) | mask);
127 }
128 #ifdef CONFIG_IWL4965_DEBUG
129 static inline void __iwl4965_set_bit(const char *f, u32 l,
130                                  struct iwl4965_priv *priv, u32 reg, u32 mask)
131 {
132         u32 val = _iwl4965_read32(priv, reg) | mask;
133         IWL_DEBUG_IO("set_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val);
134         _iwl4965_write32(priv, reg, val);
135 }
136 #define iwl4965_set_bit(p, r, m) __iwl4965_set_bit(__FILE__, __LINE__, p, r, m)
137 #else
138 #define iwl4965_set_bit(p, r, m) _iwl4965_set_bit(p, r, m)
139 #endif
140
141 static inline void _iwl4965_clear_bit(struct iwl4965_priv *priv, u32 reg, u32 mask)
142 {
143         _iwl4965_write32(priv, reg, _iwl4965_read32(priv, reg) & ~mask);
144 }
145 #ifdef CONFIG_IWL4965_DEBUG
146 static inline void __iwl4965_clear_bit(const char *f, u32 l,
147                                    struct iwl4965_priv *priv, u32 reg, u32 mask)
148 {
149         u32 val = _iwl4965_read32(priv, reg) & ~mask;
150         IWL_DEBUG_IO("clear_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val);
151         _iwl4965_write32(priv, reg, val);
152 }
153 #define iwl4965_clear_bit(p, r, m) __iwl4965_clear_bit(__FILE__, __LINE__, p, r, m)
154 #else
155 #define iwl4965_clear_bit(p, r, m) _iwl4965_clear_bit(p, r, m)
156 #endif
157
158 static inline int _iwl4965_grab_nic_access(struct iwl4965_priv *priv)
159 {
160         int ret;
161         u32 gp_ctl;
162
163 #ifdef CONFIG_IWL4965_DEBUG
164         if (atomic_read(&priv->restrict_refcnt))
165                 return 0;
166 #endif
167         if (test_bit(STATUS_RF_KILL_HW, &priv->status) ||
168             test_bit(STATUS_RF_KILL_SW, &priv->status)) {
169                 IWL_WARNING("WARNING: Requesting MAC access during RFKILL "
170                         "wakes up NIC\n");
171
172                 /* 10 msec allows time for NIC to complete its data save */
173                 gp_ctl = _iwl4965_read32(priv, CSR_GP_CNTRL);
174                 if (gp_ctl & CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY) {
175                         IWL_DEBUG_RF_KILL("Wait for complete power-down, "
176                                 "gpctl = 0x%08x\n", gp_ctl);
177                         mdelay(10);
178                 } else
179                         IWL_DEBUG_RF_KILL("power-down complete, "
180                                           "gpctl = 0x%08x\n", gp_ctl);
181         }
182
183         /* this bit wakes up the NIC */
184         _iwl4965_set_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
185         ret = _iwl4965_poll_bit(priv, CSR_GP_CNTRL,
186                            CSR_GP_CNTRL_REG_VAL_MAC_ACCESS_EN,
187                            (CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY |
188                             CSR_GP_CNTRL_REG_FLAG_GOING_TO_SLEEP), 50);
189         if (ret < 0) {
190                 IWL_ERROR("MAC is in deep sleep!\n");
191                 return -EIO;
192         }
193
194 #ifdef CONFIG_IWL4965_DEBUG
195         atomic_inc(&priv->restrict_refcnt);
196 #endif
197         return 0;
198 }
199
200 #ifdef CONFIG_IWL4965_DEBUG
201 static inline int __iwl4965_grab_nic_access(const char *f, u32 l,
202                                                struct iwl4965_priv *priv)
203 {
204         if (atomic_read(&priv->restrict_refcnt))
205                 IWL_DEBUG_INFO("Grabbing access while already held at "
206                                "line %d.\n", l);
207
208         IWL_DEBUG_IO("grabbing nic access - %s %d\n", f, l);
209         return _iwl4965_grab_nic_access(priv);
210 }
211 #define iwl4965_grab_nic_access(priv) \
212         __iwl4965_grab_nic_access(__FILE__, __LINE__, priv)
213 #else
214 #define iwl4965_grab_nic_access(priv) \
215         _iwl4965_grab_nic_access(priv)
216 #endif
217
218 static inline void _iwl4965_release_nic_access(struct iwl4965_priv *priv)
219 {
220 #ifdef CONFIG_IWL4965_DEBUG
221         if (atomic_dec_and_test(&priv->restrict_refcnt))
222 #endif
223                 _iwl4965_clear_bit(priv, CSR_GP_CNTRL,
224                                CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
225 }
226 #ifdef CONFIG_IWL4965_DEBUG
227 static inline void __iwl4965_release_nic_access(const char *f, u32 l,
228                                             struct iwl4965_priv *priv)
229 {
230         if (atomic_read(&priv->restrict_refcnt) <= 0)
231                 IWL_ERROR("Release unheld nic access at line %d.\n", l);
232
233         IWL_DEBUG_IO("releasing nic access - %s %d\n", f, l);
234         _iwl4965_release_nic_access(priv);
235 }
236 #define iwl4965_release_nic_access(priv) \
237         __iwl4965_release_nic_access(__FILE__, __LINE__, priv)
238 #else
239 #define iwl4965_release_nic_access(priv) \
240         _iwl4965_release_nic_access(priv)
241 #endif
242
243 static inline u32 _iwl4965_read_direct32(struct iwl4965_priv *priv, u32 reg)
244 {
245         return _iwl4965_read32(priv, reg);
246 }
247 #ifdef CONFIG_IWL4965_DEBUG
248 static inline u32 __iwl4965_read_direct32(const char *f, u32 l,
249                                         struct iwl4965_priv *priv, u32 reg)
250 {
251         u32 value = _iwl4965_read_direct32(priv, reg);
252         if (!atomic_read(&priv->restrict_refcnt))
253                 IWL_ERROR("Nic access not held from %s %d\n", f, l);
254         IWL_DEBUG_IO("read_direct32(0x%4X) = 0x%08x - %s %d \n", reg, value,
255                      f, l);
256         return value;
257 }
258 #define iwl4965_read_direct32(priv, reg) \
259         __iwl4965_read_direct32(__FILE__, __LINE__, priv, reg)
260 #else
261 #define iwl4965_read_direct32 _iwl4965_read_direct32
262 #endif
263
264 static inline void _iwl4965_write_direct32(struct iwl4965_priv *priv,
265                                          u32 reg, u32 value)
266 {
267         _iwl4965_write32(priv, reg, value);
268 }
269 #ifdef CONFIG_IWL4965_DEBUG
270 static void __iwl4965_write_direct32(u32 line,
271                                    struct iwl4965_priv *priv, u32 reg, u32 value)
272 {
273         if (!atomic_read(&priv->restrict_refcnt))
274                 IWL_ERROR("Nic access not held from line %d\n", line);
275         _iwl4965_write_direct32(priv, reg, value);
276 }
277 #define iwl4965_write_direct32(priv, reg, value) \
278         __iwl4965_write_direct32(__LINE__, priv, reg, value)
279 #else
280 #define iwl4965_write_direct32 _iwl4965_write_direct32
281 #endif
282
283 static inline void iwl4965_write_reg_buf(struct iwl4965_priv *priv,
284                                                u32 reg, u32 len, u32 *values)
285 {
286         u32 count = sizeof(u32);
287
288         if ((priv != NULL) && (values != NULL)) {
289                 for (; 0 < len; len -= count, reg += count, values++)
290                         _iwl4965_write_direct32(priv, reg, *values);
291         }
292 }
293
294 static inline int _iwl4965_poll_direct_bit(struct iwl4965_priv *priv,
295                                            u32 addr, u32 mask, int timeout)
296 {
297         int i = 0;
298
299         do {
300                 if ((_iwl4965_read_direct32(priv, addr) & mask) == mask)
301                         return i;
302                 mdelay(10);
303                 i += 10;
304         } while (i < timeout);
305
306         return -ETIMEDOUT;
307 }
308
309 #ifdef CONFIG_IWL4965_DEBUG
310 static inline int __iwl4965_poll_direct_bit(const char *f, u32 l,
311                                             struct iwl4965_priv *priv,
312                                             u32 addr, u32 mask, int timeout)
313 {
314         int ret  = _iwl4965_poll_direct_bit(priv, addr, mask, timeout);
315
316         if (unlikely(ret == -ETIMEDOUT))
317                 IWL_DEBUG_IO("poll_direct_bit(0x%08X, 0x%08X) - "
318                              "timedout - %s %d\n", addr, mask, f, l);
319         else
320                 IWL_DEBUG_IO("poll_direct_bit(0x%08X, 0x%08X) = 0x%08X "
321                              "- %s %d\n", addr, mask, ret, f, l);
322         return ret;
323 }
324 #define iwl4965_poll_direct_bit(iwl, addr, mask, timeout) \
325         __iwl4965_poll_direct_bit(__FILE__, __LINE__, iwl, addr, mask, timeout)
326 #else
327 #define iwl4965_poll_direct_bit _iwl4965_poll_direct_bit
328 #endif
329
330 static inline u32 _iwl4965_read_prph(struct iwl4965_priv *priv, u32 reg)
331 {
332         _iwl4965_write_direct32(priv, HBUS_TARG_PRPH_RADDR, reg | (3 << 24));
333         return _iwl4965_read_direct32(priv, HBUS_TARG_PRPH_RDAT);
334 }
335 #ifdef CONFIG_IWL4965_DEBUG
336 static inline u32 __iwl4965_read_prph(u32 line, struct iwl4965_priv *priv, u32 reg)
337 {
338         if (!atomic_read(&priv->restrict_refcnt))
339                 IWL_ERROR("Nic access not held from line %d\n", line);
340         return _iwl4965_read_prph(priv, reg);
341 }
342
343 #define iwl4965_read_prph(priv, reg) \
344         __iwl4965_read_prph(__LINE__, priv, reg)
345 #else
346 #define iwl4965_read_prph _iwl4965_read_prph
347 #endif
348
349 static inline void _iwl4965_write_prph(struct iwl4965_priv *priv,
350                                              u32 addr, u32 val)
351 {
352         _iwl4965_write_direct32(priv, HBUS_TARG_PRPH_WADDR,
353                               ((addr & 0x0000FFFF) | (3 << 24)));
354         _iwl4965_write_direct32(priv, HBUS_TARG_PRPH_WDAT, val);
355 }
356 #ifdef CONFIG_IWL4965_DEBUG
357 static inline void __iwl4965_write_prph(u32 line, struct iwl4965_priv *priv,
358                                               u32 addr, u32 val)
359 {
360         if (!atomic_read(&priv->restrict_refcnt))
361                 IWL_ERROR("Nic access from line %d\n", line);
362         _iwl4965_write_prph(priv, addr, val);
363 }
364
365 #define iwl4965_write_prph(priv, addr, val) \
366         __iwl4965_write_prph(__LINE__, priv, addr, val);
367 #else
368 #define iwl4965_write_prph _iwl4965_write_prph
369 #endif
370
371 #define _iwl4965_set_bits_prph(priv, reg, mask) \
372         _iwl4965_write_prph(priv, reg, (_iwl4965_read_prph(priv, reg) | mask))
373 #ifdef CONFIG_IWL4965_DEBUG
374 static inline void __iwl4965_set_bits_prph(u32 line, struct iwl4965_priv *priv,
375                                         u32 reg, u32 mask)
376 {
377         if (!atomic_read(&priv->restrict_refcnt))
378                 IWL_ERROR("Nic access not held from line %d\n", line);
379
380         _iwl4965_set_bits_prph(priv, reg, mask);
381 }
382 #define iwl4965_set_bits_prph(priv, reg, mask) \
383         __iwl4965_set_bits_prph(__LINE__, priv, reg, mask)
384 #else
385 #define iwl4965_set_bits_prph _iwl4965_set_bits_prph
386 #endif
387
388 #define _iwl4965_set_bits_mask_prph(priv, reg, bits, mask) \
389         _iwl4965_write_prph(priv, reg, ((_iwl4965_read_prph(priv, reg) & mask) | bits))
390
391 #ifdef CONFIG_IWL4965_DEBUG
392 static inline void __iwl4965_set_bits_mask_prph(u32 line,
393                 struct iwl4965_priv *priv, u32 reg, u32 bits, u32 mask)
394 {
395         if (!atomic_read(&priv->restrict_refcnt))
396                 IWL_ERROR("Nic access not held from line %d\n", line);
397         _iwl4965_set_bits_mask_prph(priv, reg, bits, mask);
398 }
399 #define iwl4965_set_bits_mask_prph(priv, reg, bits, mask) \
400         __iwl4965_set_bits_mask_prph(__LINE__, priv, reg, bits, mask)
401 #else
402 #define iwl4965_set_bits_mask_prph _iwl4965_set_bits_mask_prph
403 #endif
404
405 static inline void iwl4965_clear_bits_prph(struct iwl4965_priv
406                                                  *priv, u32 reg, u32 mask)
407 {
408         u32 val = _iwl4965_read_prph(priv, reg);
409         _iwl4965_write_prph(priv, reg, (val & ~mask));
410 }
411
412 static inline u32 iwl4965_read_targ_mem(struct iwl4965_priv *priv, u32 addr)
413 {
414         iwl4965_write_direct32(priv, HBUS_TARG_MEM_RADDR, addr);
415         return iwl4965_read_direct32(priv, HBUS_TARG_MEM_RDAT);
416 }
417
418 static inline void iwl4965_write_targ_mem(struct iwl4965_priv *priv, u32 addr, u32 val)
419 {
420         iwl4965_write_direct32(priv, HBUS_TARG_MEM_WADDR, addr);
421         iwl4965_write_direct32(priv, HBUS_TARG_MEM_WDAT, val);
422 }
423
424 static inline void iwl4965_write_targ_mem_buf(struct iwl4965_priv *priv, u32 addr,
425                                           u32 len, u32 *values)
426 {
427         iwl4965_write_direct32(priv, HBUS_TARG_MEM_WADDR, addr);
428         for (; 0 < len; len -= sizeof(u32), values++)
429                 iwl4965_write_direct32(priv, HBUS_TARG_MEM_WDAT, *values);
430 }
431 #endif