aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless/iwlwifi/iwl-3945-io.h
diff options
context:
space:
mode:
authorAbhijeet Kolekar <abhijeet.kolekar@intel.com>2008-12-18 21:37:29 -0500
committerJohn W. Linville <linville@tuxdriver.com>2009-01-29 15:59:14 -0500
commit5d49f498a29360592dea4693724fef242278e0d3 (patch)
tree0bc4b1c3623944a925e414c4858f2279c27d5a92 /drivers/net/wireless/iwlwifi/iwl-3945-io.h
parent4a8a43222db6f04c88def2160a95f978f704b515 (diff)
iwl3945: use iwl-io.h and delete iwl-3945-io.h
The patch deletes iwl-3945-io.h and uses iwl-io.h functions. Signed-off-by: Abhijeet Kolekar <abhijeet.kolekar@intel.com> 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-3945-io.h')
-rw-r--r--drivers/net/wireless/iwlwifi/iwl-3945-io.h404
1 files changed, 0 insertions, 404 deletions
diff --git a/drivers/net/wireless/iwlwifi/iwl-3945-io.h b/drivers/net/wireless/iwlwifi/iwl-3945-io.h
deleted file mode 100644
index 0b84815dd69b..000000000000
--- a/drivers/net/wireless/iwlwifi/iwl-3945-io.h
+++ /dev/null
@@ -1,404 +0,0 @@
1/******************************************************************************
2 *
3 * Copyright(c) 2003 - 2008 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 * Intel Linux Wireless <ilw@linux.intel.com>
25 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
26 *
27 *****************************************************************************/
28
29#ifndef __iwl3945_io_h__
30#define __iwl3945_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 _iwl3945_read_direct32 calls the non-check version of
53 * _iwl3945_read32.)
54 *
55 * These declarations are *extremely* useful in quickly isolating code deltas
56 * which result in misconfiguration 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 _iwl3945_write32(priv, ofs, val) iowrite32((val), (priv)->hw_base + (ofs))
63#ifdef CONFIG_IWL3945_DEBUG
64static inline void __iwl3945_write32(const char *f, u32 l, struct iwl_priv *priv,
65 u32 ofs, u32 val)
66{
67 IWL_DEBUG_IO("write32(0x%08X, 0x%08X) - %s %d\n", ofs, val, f, l);
68 _iwl3945_write32(priv, ofs, val);
69}
70#define iwl3945_write32(priv, ofs, val) \
71 __iwl3945_write32(__FILE__, __LINE__, priv, ofs, val)
72#else
73#define iwl3945_write32(priv, ofs, val) _iwl3945_write32(priv, ofs, val)
74#endif
75
76#define _iwl3945_read32(priv, ofs) ioread32((priv)->hw_base + (ofs))
77#ifdef CONFIG_IWL3945_DEBUG
78static inline u32 __iwl3945_read32(char *f, u32 l, struct iwl_priv *priv, u32 ofs)
79{
80 IWL_DEBUG_IO("read_direct32(0x%08X) - %s %d\n", ofs, f, l);
81 return _iwl3945_read32(priv, ofs);
82}
83#define iwl3945_read32(priv, ofs)__iwl3945_read32(__FILE__, __LINE__, priv, ofs)
84#else
85#define iwl3945_read32(p, o) _iwl3945_read32(p, o)
86#endif
87
88static inline int _iwl3945_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 ((_iwl3945_read32(priv, addr) & mask) == (bits & mask))
95 return i;
96 udelay(10);
97 i += 10;
98 } while (i < timeout);
99
100 return -ETIMEDOUT;
101}
102#ifdef CONFIG_IWL3945_DEBUG
103static inline int __iwl3945_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 = _iwl3945_poll_bit(priv, addr, bits, mask, timeout);
108 IWL_DEBUG_IO("poll_bit(0x%08X, 0x%08X, 0x%08X) - %s- %s %d\n",
109 addr, bits, mask,
110 unlikely(ret == -ETIMEDOUT) ? "timeout" : "", f, l);
111 return ret;
112}
113#define iwl3945_poll_bit(priv, addr, bits, mask, timeout) \
114 __iwl3945_poll_bit(__FILE__, __LINE__, priv, addr, bits, mask, timeout)
115#else
116#define iwl3945_poll_bit(p, a, b, m, t) _iwl3945_poll_bit(p, a, b, m, t)
117#endif
118
119static inline void _iwl3945_set_bit(struct iwl_priv *priv, u32 reg, u32 mask)
120{
121 _iwl3945_write32(priv, reg, _iwl3945_read32(priv, reg) | mask);
122}
123#ifdef CONFIG_IWL3945_DEBUG
124static inline void __iwl3945_set_bit(const char *f, u32 l,
125 struct iwl_priv *priv, u32 reg, u32 mask)
126{
127 u32 val = _iwl3945_read32(priv, reg) | mask;
128 IWL_DEBUG_IO("set_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val);
129 _iwl3945_write32(priv, reg, val);
130}
131#define iwl3945_set_bit(p, r, m) __iwl3945_set_bit(__FILE__, __LINE__, p, r, m)
132#else
133#define iwl3945_set_bit(p, r, m) _iwl3945_set_bit(p, r, m)
134#endif
135
136static inline void _iwl3945_clear_bit(struct iwl_priv *priv, u32 reg, u32 mask)
137{
138 _iwl3945_write32(priv, reg, _iwl3945_read32(priv, reg) & ~mask);
139}
140#ifdef CONFIG_IWL3945_DEBUG
141static inline void __iwl3945_clear_bit(const char *f, u32 l,
142 struct iwl_priv *priv, u32 reg, u32 mask)
143{
144 u32 val = _iwl3945_read32(priv, reg) & ~mask;
145 IWL_DEBUG_IO("clear_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val);
146 _iwl3945_write32(priv, reg, val);
147}
148#define iwl3945_clear_bit(p, r, m) __iwl3945_clear_bit(__FILE__, __LINE__, p, r, m)
149#else
150#define iwl3945_clear_bit(p, r, m) _iwl3945_clear_bit(p, r, m)
151#endif
152
153static inline int _iwl3945_grab_nic_access(struct iwl_priv *priv)
154{
155 int ret;
156#ifdef CONFIG_IWL3945_DEBUG
157 if (atomic_read(&priv->restrict_refcnt))
158 return 0;
159#endif
160 /* this bit wakes up the NIC */
161 _iwl3945_set_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
162 ret = _iwl3945_poll_bit(priv, CSR_GP_CNTRL,
163 CSR_GP_CNTRL_REG_VAL_MAC_ACCESS_EN,
164 (CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY |
165 CSR_GP_CNTRL_REG_FLAG_GOING_TO_SLEEP), 50);
166 if (ret < 0) {
167 IWL_ERROR("MAC is in deep sleep!\n");
168 return -EIO;
169 }
170
171#ifdef CONFIG_IWL3945_DEBUG
172 atomic_inc(&priv->restrict_refcnt);
173#endif
174 return 0;
175}
176
177#ifdef CONFIG_IWL3945_DEBUG
178static inline int __iwl3945_grab_nic_access(const char *f, u32 l,
179 struct iwl_priv *priv)
180{
181 if (atomic_read(&priv->restrict_refcnt))
182 IWL_DEBUG_INFO("Grabbing access while already held at "
183 "line %d.\n", l);
184
185 IWL_DEBUG_IO("grabbing nic access - %s %d\n", f, l);
186 return _iwl3945_grab_nic_access(priv);
187}
188#define iwl3945_grab_nic_access(priv) \
189 __iwl3945_grab_nic_access(__FILE__, __LINE__, priv)
190#else
191#define iwl3945_grab_nic_access(priv) \
192 _iwl3945_grab_nic_access(priv)
193#endif
194
195static inline void _iwl3945_release_nic_access(struct iwl_priv *priv)
196{
197#ifdef CONFIG_IWL3945_DEBUG
198 if (atomic_dec_and_test(&priv->restrict_refcnt))
199#endif
200 _iwl3945_clear_bit(priv, CSR_GP_CNTRL,
201 CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
202}
203#ifdef CONFIG_IWL3945_DEBUG
204static inline void __iwl3945_release_nic_access(const char *f, u32 l,
205 struct iwl_priv *priv)
206{
207 if (atomic_read(&priv->restrict_refcnt) <= 0)
208 IWL_ERROR("Release unheld nic access at line %d.\n", l);
209
210 IWL_DEBUG_IO("releasing nic access - %s %d\n", f, l);
211 _iwl3945_release_nic_access(priv);
212}
213#define iwl3945_release_nic_access(priv) \
214 __iwl3945_release_nic_access(__FILE__, __LINE__, priv)
215#else
216#define iwl3945_release_nic_access(priv) \
217 _iwl3945_release_nic_access(priv)
218#endif
219
220static inline u32 _iwl3945_read_direct32(struct iwl_priv *priv, u32 reg)
221{
222 return _iwl3945_read32(priv, reg);
223}
224#ifdef CONFIG_IWL3945_DEBUG
225static inline u32 __iwl3945_read_direct32(const char *f, u32 l,
226 struct iwl_priv *priv, u32 reg)
227{
228 u32 value = _iwl3945_read_direct32(priv, reg);
229 if (!atomic_read(&priv->restrict_refcnt))
230 IWL_ERROR("Nic access not held from %s %d\n", f, l);
231 IWL_DEBUG_IO("read_direct32(0x%4X) = 0x%08x - %s %d \n", reg, value,
232 f, l);
233 return value;
234}
235#define iwl3945_read_direct32(priv, reg) \
236 __iwl3945_read_direct32(__FILE__, __LINE__, priv, reg)
237#else
238#define iwl3945_read_direct32 _iwl3945_read_direct32
239#endif
240
241static inline void _iwl3945_write_direct32(struct iwl_priv *priv,
242 u32 reg, u32 value)
243{
244 _iwl3945_write32(priv, reg, value);
245}
246#ifdef CONFIG_IWL3945_DEBUG
247static void __iwl3945_write_direct32(u32 line,
248 struct iwl_priv *priv, u32 reg, u32 value)
249{
250 if (!atomic_read(&priv->restrict_refcnt))
251 IWL_ERROR("Nic access not held from line %d\n", line);
252 _iwl3945_write_direct32(priv, reg, value);
253}
254#define iwl3945_write_direct32(priv, reg, value) \
255 __iwl3945_write_direct32(__LINE__, priv, reg, value)
256#else
257#define iwl3945_write_direct32 _iwl3945_write_direct32
258#endif
259
260static inline void iwl3945_write_reg_buf(struct iwl_priv *priv,
261 u32 reg, u32 len, u32 *values)
262{
263 u32 count = sizeof(u32);
264
265 if ((priv != NULL) && (values != NULL)) {
266 for (; 0 < len; len -= count, reg += count, values++)
267 _iwl3945_write_direct32(priv, reg, *values);
268 }
269}
270
271static inline int _iwl3945_poll_direct_bit(struct iwl_priv *priv,
272 u32 addr, u32 mask, int timeout)
273{
274 return _iwl3945_poll_bit(priv, addr, mask, mask, timeout);
275}
276
277#ifdef CONFIG_IWL3945_DEBUG
278static inline int __iwl3945_poll_direct_bit(const char *f, u32 l,
279 struct iwl_priv *priv,
280 u32 addr, u32 mask, int timeout)
281{
282 int ret = _iwl3945_poll_direct_bit(priv, addr, mask, timeout);
283
284 if (unlikely(ret == -ETIMEDOUT))
285 IWL_DEBUG_IO("poll_direct_bit(0x%08X, 0x%08X) - "
286 "timedout - %s %d\n", addr, mask, f, l);
287 else
288 IWL_DEBUG_IO("poll_direct_bit(0x%08X, 0x%08X) = 0x%08X "
289 "- %s %d\n", addr, mask, ret, f, l);
290 return ret;
291}
292#define iwl3945_poll_direct_bit(priv, addr, mask, timeout) \
293 __iwl3945_poll_direct_bit(__FILE__, __LINE__, priv, addr, mask, timeout)
294#else
295#define iwl3945_poll_direct_bit _iwl3945_poll_direct_bit
296#endif
297
298static inline u32 _iwl3945_read_prph(struct iwl_priv *priv, u32 reg)
299{
300 _iwl3945_write_direct32(priv, HBUS_TARG_PRPH_RADDR, reg | (3 << 24));
301 rmb();
302 return _iwl3945_read_direct32(priv, HBUS_TARG_PRPH_RDAT);
303}
304#ifdef CONFIG_IWL3945_DEBUG
305static inline u32 __iwl3945_read_prph(u32 line, struct iwl_priv *priv, u32 reg)
306{
307 if (!atomic_read(&priv->restrict_refcnt))
308 IWL_ERROR("Nic access not held from line %d\n", line);
309 return _iwl3945_read_prph(priv, reg);
310}
311
312#define iwl3945_read_prph(priv, reg) \
313 __iwl3945_read_prph(__LINE__, priv, reg)
314#else
315#define iwl3945_read_prph _iwl3945_read_prph
316#endif
317
318static inline void _iwl3945_write_prph(struct iwl_priv *priv,
319 u32 addr, u32 val)
320{
321 _iwl3945_write_direct32(priv, HBUS_TARG_PRPH_WADDR,
322 ((addr & 0x0000FFFF) | (3 << 24)));
323 wmb();
324 _iwl3945_write_direct32(priv, HBUS_TARG_PRPH_WDAT, val);
325}
326#ifdef CONFIG_IWL3945_DEBUG
327static inline void __iwl3945_write_prph(u32 line, struct iwl_priv *priv,
328 u32 addr, u32 val)
329{
330 if (!atomic_read(&priv->restrict_refcnt))
331 IWL_ERROR("Nic access from line %d\n", line);
332 _iwl3945_write_prph(priv, addr, val);
333}
334
335#define iwl3945_write_prph(priv, addr, val) \
336 __iwl3945_write_prph(__LINE__, priv, addr, val);
337#else
338#define iwl3945_write_prph _iwl3945_write_prph
339#endif
340
341#define _iwl3945_set_bits_prph(priv, reg, mask) \
342 _iwl3945_write_prph(priv, reg, (_iwl3945_read_prph(priv, reg) | mask))
343#ifdef CONFIG_IWL3945_DEBUG
344static inline void __iwl3945_set_bits_prph(u32 line, struct iwl_priv *priv,
345 u32 reg, u32 mask)
346{
347 if (!atomic_read(&priv->restrict_refcnt))
348 IWL_ERROR("Nic access not held from line %d\n", line);
349
350 _iwl3945_set_bits_prph(priv, reg, mask);
351}
352#define iwl3945_set_bits_prph(priv, reg, mask) \
353 __iwl3945_set_bits_prph(__LINE__, priv, reg, mask)
354#else
355#define iwl3945_set_bits_prph _iwl3945_set_bits_prph
356#endif
357
358#define _iwl3945_set_bits_mask_prph(priv, reg, bits, mask) \
359 _iwl3945_write_prph(priv, reg, ((_iwl3945_read_prph(priv, reg) & mask) | bits))
360
361#ifdef CONFIG_IWL3945_DEBUG
362static inline void __iwl3945_set_bits_mask_prph(u32 line,
363 struct iwl_priv *priv, u32 reg, u32 bits, u32 mask)
364{
365 if (!atomic_read(&priv->restrict_refcnt))
366 IWL_ERROR("Nic access not held from line %d\n", line);
367 _iwl3945_set_bits_mask_prph(priv, reg, bits, mask);
368}
369#define iwl3945_set_bits_mask_prph(priv, reg, bits, mask) \
370 __iwl3945_set_bits_mask_prph(__LINE__, priv, reg, bits, mask)
371#else
372#define iwl3945_set_bits_mask_prph _iwl3945_set_bits_mask_prph
373#endif
374
375static inline void iwl3945_clear_bits_prph(struct iwl_priv
376 *priv, u32 reg, u32 mask)
377{
378 u32 val = _iwl3945_read_prph(priv, reg);
379 _iwl3945_write_prph(priv, reg, (val & ~mask));
380}
381
382static inline u32 iwl3945_read_targ_mem(struct iwl_priv *priv, u32 addr)
383{
384 iwl3945_write_direct32(priv, HBUS_TARG_MEM_RADDR, addr);
385 rmb();
386 return iwl3945_read_direct32(priv, HBUS_TARG_MEM_RDAT);
387}
388
389static inline void iwl3945_write_targ_mem(struct iwl_priv *priv, u32 addr, u32 val)
390{
391 iwl3945_write_direct32(priv, HBUS_TARG_MEM_WADDR, addr);
392 wmb();
393 iwl3945_write_direct32(priv, HBUS_TARG_MEM_WDAT, val);
394}
395
396static inline void iwl3945_write_targ_mem_buf(struct iwl_priv *priv, u32 addr,
397 u32 len, u32 *values)
398{
399 iwl3945_write_direct32(priv, HBUS_TARG_MEM_WADDR, addr);
400 wmb();
401 for (; 0 < len; len -= sizeof(u32), values++)
402 iwl3945_write_direct32(priv, HBUS_TARG_MEM_WDAT, *values);
403}
404#endif
generated by cgit v1.2.2 (git 2.25.0) at 2025-03-05 06:47:44 -0500