aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless/iwlwifi/iwl-io.h
diff options
context:
space:
mode:
authorChristoph Hellwig <hch@lst.de>2007-10-25 05:15:50 -0400
committerDavid S. Miller <davem@davemloft.net>2008-01-28 18:03:24 -0500
commit5d08cd1dfdc57dc834c47eb9f023fcf861f3d6bf (patch)
treeabac0496b2ab958970c58c459070a8ca5f5fdde7 /drivers/net/wireless/iwlwifi/iwl-io.h
parent416e1438d5a921046fda6fc5673d5f2c69841c06 (diff)
iwlwifi: keep 3945 and 4965 headers separate
The iwl3945 and iwl4965 devices share some common structure, but with a lot of difference split all over. Currently the two drivers share a lot of headers and use ugly preprocessor magic to manage the difference. This patch keeps two entirely separate copies of the headers to get rid of these hacks an ease future development. Signed-off-by: Christoph Hellwig <hch@lst.de> Signed-off-by: Zhu Yi <yi.zhu@intel.com> Signed-off-by: John W. Linville <linville@tuxdriver.com>
Diffstat (limited to 'drivers/net/wireless/iwlwifi/iwl-io.h')
-rw-r--r--drivers/net/wireless/iwlwifi/iwl-io.h431
1 files changed, 0 insertions, 431 deletions
diff --git a/drivers/net/wireless/iwlwifi/iwl-io.h b/drivers/net/wireless/iwlwifi/iwl-io.h
deleted file mode 100644
index 43afcda6f73e..000000000000
--- a/drivers/net/wireless/iwlwifi/iwl-io.h
+++ /dev/null
@@ -1,431 +0,0 @@
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 __iwl_io_h__
30#define __iwl_io_h__
31
32#include <linux/io.h>
33
34#include "iwl-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 _iwl_read_direct32 calls the non-check version of
53 * _iwl_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 _iwl_write32(iwl, ofs, val) writel((val), (iwl)->hw_base + (ofs))
63#ifdef CONFIG_IWLWIFI_DEBUG
64static inline void __iwl_write32(const char *f, u32 l, struct iwl_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 _iwl_write32(iwl, ofs, val);
69}
70#define iwl_write32(iwl, ofs, val) \
71 __iwl_write32(__FILE__, __LINE__, iwl, ofs, val)
72#else
73#define iwl_write32(iwl, ofs, val) _iwl_write32(iwl, ofs, val)
74#endif
75
76#define _iwl_read32(iwl, ofs) readl((iwl)->hw_base + (ofs))
77#ifdef CONFIG_IWLWIFI_DEBUG
78static inline u32 __iwl_read32(char *f, u32 l, struct iwl_priv *iwl, u32 ofs)
79{
80 IWL_DEBUG_IO("read_direct32(0x%08X) - %s %d\n", ofs, f, l);
81 return _iwl_read32(iwl, ofs);
82}
83#define iwl_read32(iwl, ofs) __iwl_read32(__FILE__, __LINE__, iwl, ofs)
84#else
85#define iwl_read32(p, o) _iwl_read32(p, o)
86#endif
87
88static inline int _iwl_poll_bit(struct iwl_priv *priv, u32 addr,
89 u32 bits, u32 mask, int timeout)
90{
91 int i = 0;
92
93 do {
94 if ((_iwl_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_IWLWIFI_DEBUG
103static inline int __iwl_poll_bit(const char *f, u32 l,
104 struct iwl_priv *priv, u32 addr,
105 u32 bits, u32 mask, int timeout)
106{
107 int ret = _iwl_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 iwl_poll_bit(iwl, addr, bits, mask, timeout) \
119 __iwl_poll_bit(__FILE__, __LINE__, iwl, addr, bits, mask, timeout)
120#else
121#define iwl_poll_bit(p, a, b, m, t) _iwl_poll_bit(p, a, b, m, t)
122#endif
123
124static inline void _iwl_set_bit(struct iwl_priv *priv, u32 reg, u32 mask)
125{
126 _iwl_write32(priv, reg, _iwl_read32(priv, reg) | mask);
127}
128#ifdef CONFIG_IWLWIFI_DEBUG
129static inline void __iwl_set_bit(const char *f, u32 l,
130 struct iwl_priv *priv, u32 reg, u32 mask)
131{
132 u32 val = _iwl_read32(priv, reg) | mask;
133 IWL_DEBUG_IO("set_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val);
134 _iwl_write32(priv, reg, val);
135}
136#define iwl_set_bit(p, r, m) __iwl_set_bit(__FILE__, __LINE__, p, r, m)
137#else
138#define iwl_set_bit(p, r, m) _iwl_set_bit(p, r, m)
139#endif
140
141static inline void _iwl_clear_bit(struct iwl_priv *priv, u32 reg, u32 mask)
142{
143 _iwl_write32(priv, reg, _iwl_read32(priv, reg) & ~mask);
144}
145#ifdef CONFIG_IWLWIFI_DEBUG
146static inline void __iwl_clear_bit(const char *f, u32 l,
147 struct iwl_priv *priv, u32 reg, u32 mask)
148{
149 u32 val = _iwl_read32(priv, reg) & ~mask;
150 IWL_DEBUG_IO("clear_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val);
151 _iwl_write32(priv, reg, val);
152}
153#define iwl_clear_bit(p, r, m) __iwl_clear_bit(__FILE__, __LINE__, p, r, m)
154#else
155#define iwl_clear_bit(p, r, m) _iwl_clear_bit(p, r, m)
156#endif
157
158static inline int _iwl_grab_nic_access(struct iwl_priv *priv)
159{
160 int ret;
161 u32 gp_ctl;
162
163#ifdef CONFIG_IWLWIFI_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 = _iwl_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 _iwl_set_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
185 ret = _iwl_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_IWLWIFI_DEBUG
195 atomic_inc(&priv->restrict_refcnt);
196#endif
197 return 0;
198}
199
200#ifdef CONFIG_IWLWIFI_DEBUG
201static inline int __iwl_grab_nic_access(const char *f, u32 l,
202 struct iwl_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 _iwl_grab_nic_access(priv);
210}
211#define iwl_grab_nic_access(priv) \
212 __iwl_grab_nic_access(__FILE__, __LINE__, priv)
213#else
214#define iwl_grab_nic_access(priv) \
215 _iwl_grab_nic_access(priv)
216#endif
217
218static inline void _iwl_release_nic_access(struct iwl_priv *priv)
219{
220#ifdef CONFIG_IWLWIFI_DEBUG
221 if (atomic_dec_and_test(&priv->restrict_refcnt))
222#endif
223 _iwl_clear_bit(priv, CSR_GP_CNTRL,
224 CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
225}
226#ifdef CONFIG_IWLWIFI_DEBUG
227static inline void __iwl_release_nic_access(const char *f, u32 l,
228 struct iwl_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 _iwl_release_nic_access(priv);
235}
236#define iwl_release_nic_access(priv) \
237 __iwl_release_nic_access(__FILE__, __LINE__, priv)
238#else
239#define iwl_release_nic_access(priv) \
240 _iwl_release_nic_access(priv)
241#endif
242
243static inline u32 _iwl_read_direct32(struct iwl_priv *priv, u32 reg)
244{
245 return _iwl_read32(priv, reg);
246}
247#ifdef CONFIG_IWLWIFI_DEBUG
248static inline u32 __iwl_read_direct32(const char *f, u32 l,
249 struct iwl_priv *priv, u32 reg)
250{
251 u32 value = _iwl_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 iwl_read_direct32(priv, reg) \
259 __iwl_read_direct32(__FILE__, __LINE__, priv, reg)
260#else
261#define iwl_read_direct32 _iwl_read_direct32
262#endif
263
264static inline void _iwl_write_direct32(struct iwl_priv *priv,
265 u32 reg, u32 value)
266{
267 _iwl_write32(priv, reg, value);
268}
269#ifdef CONFIG_IWLWIFI_DEBUG
270static void __iwl_write_direct32(u32 line,
271 struct iwl_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 _iwl_write_direct32(priv, reg, value);
276}
277#define iwl_write_direct32(priv, reg, value) \
278 __iwl_write_direct32(__LINE__, priv, reg, value)
279#else
280#define iwl_write_direct32 _iwl_write_direct32
281#endif
282
283static inline void iwl_write_reg_buf(struct iwl_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 _iwl_write_direct32(priv, reg, *values);
291 }
292}
293
294static inline int _iwl_poll_direct_bit(struct iwl_priv *priv,
295 u32 addr, u32 mask, int timeout)
296{
297 int i = 0;
298
299 do {
300 if ((_iwl_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_IWLWIFI_DEBUG
310static inline int __iwl_poll_direct_bit(const char *f, u32 l,
311 struct iwl_priv *priv,
312 u32 addr, u32 mask, int timeout)
313{
314 int ret = _iwl_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 iwl_poll_direct_bit(iwl, addr, mask, timeout) \
325 __iwl_poll_direct_bit(__FILE__, __LINE__, iwl, addr, mask, timeout)
326#else
327#define iwl_poll_direct_bit _iwl_poll_direct_bit
328#endif
329
330static inline u32 _iwl_read_prph(struct iwl_priv *priv, u32 reg)
331{
332 _iwl_write_direct32(priv, HBUS_TARG_PRPH_RADDR, reg | (3 << 24));
333 return _iwl_read_direct32(priv, HBUS_TARG_PRPH_RDAT);
334}
335#ifdef CONFIG_IWLWIFI_DEBUG
336static inline u32 __iwl_read_prph(u32 line, struct iwl_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 _iwl_read_prph(priv, reg);
341}
342
343#define iwl_read_prph(priv, reg) \
344 __iwl_read_prph(__LINE__, priv, reg)
345#else
346#define iwl_read_prph _iwl_read_prph
347#endif
348
349static inline void _iwl_write_prph(struct iwl_priv *priv,
350 u32 addr, u32 val)
351{
352 _iwl_write_direct32(priv, HBUS_TARG_PRPH_WADDR,
353 ((addr & 0x0000FFFF) | (3 << 24)));
354 _iwl_write_direct32(priv, HBUS_TARG_PRPH_WDAT, val);
355}
356#ifdef CONFIG_IWLWIFI_DEBUG
357static inline void __iwl_write_prph(u32 line, struct iwl_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 _iwl_write_prph(priv, addr, val);
363}
364
365#define iwl_write_prph(priv, addr, val) \
366 __iwl_write_prph(__LINE__, priv, addr, val);
367#else
368#define iwl_write_prph _iwl_write_prph
369#endif
370
371#define _iwl_set_bits_prph(priv, reg, mask) \
372 _iwl_write_prph(priv, reg, (_iwl_read_prph(priv, reg) | mask))
373#ifdef CONFIG_IWLWIFI_DEBUG
374static inline void __iwl_set_bits_prph(u32 line, struct iwl_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 _iwl_set_bits_prph(priv, reg, mask);
381}
382#define iwl_set_bits_prph(priv, reg, mask) \
383 __iwl_set_bits_prph(__LINE__, priv, reg, mask)
384#else
385#define iwl_set_bits_prph _iwl_set_bits_prph
386#endif
387
388#define _iwl_set_bits_mask_prph(priv, reg, bits, mask) \
389 _iwl_write_prph(priv, reg, ((_iwl_read_prph(priv, reg) & mask) | bits))
390
391#ifdef CONFIG_IWLWIFI_DEBUG
392static inline void __iwl_set_bits_mask_prph(u32 line,
393 struct iwl_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 _iwl_set_bits_mask_prph(priv, reg, bits, mask);
398}
399#define iwl_set_bits_mask_prph(priv, reg, bits, mask) \
400 __iwl_set_bits_mask_prph(__LINE__, priv, reg, bits, mask)
401#else
402#define iwl_set_bits_mask_prph _iwl_set_bits_mask_prph
403#endif
404
405static inline void iwl_clear_bits_prph(struct iwl_priv
406 *priv, u32 reg, u32 mask)
407{
408 u32 val = _iwl_read_prph(priv, reg);
409 _iwl_write_prph(priv, reg, (val & ~mask));
410}
411
412static inline u32 iwl_read_targ_mem(struct iwl_priv *priv, u32 addr)
413{
414 iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR, addr);
415 return iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
416}
417
418static inline void iwl_write_targ_mem(struct iwl_priv *priv, u32 addr, u32 val)
419{
420 iwl_write_direct32(priv, HBUS_TARG_MEM_WADDR, addr);
421 iwl_write_direct32(priv, HBUS_TARG_MEM_WDAT, val);
422}
423
424static inline void iwl_write_targ_mem_buf(struct iwl_priv *priv, u32 addr,
425 u32 len, u32 *values)
426{
427 iwl_write_direct32(priv, HBUS_TARG_MEM_WADDR, addr);
428 for (; 0 < len; len -= sizeof(u32), values++)
429 iwl_write_direct32(priv, HBUS_TARG_MEM_WDAT, *values);
430}
431#endif
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-29 10:40:46 -0500