projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'hwmon-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jdelv...
[deliverable/linux.git] / drivers / net / wireless / iwlwifi / iwl-io.h
CommitLineData
b481de9c
ZY		 1/******************************************************************************
2 *
01f8162a 3 * Copyright(c) 2003 - 2009 Intel Corporation. All rights reserved.
b481de9c
ZY		 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:
759ef89f 24 * Intel Linux Wireless <ilw@linux.intel.com>
b481de9c
ZY		 25 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
26 *
27 *****************************************************************************/
28
3395f6e9
TW		 29#ifndef __iwl_io_h__
30#define __iwl_io_h__
b481de9c
ZY		 31
32#include <linux/io.h>
33
0a6857e7 34#include "iwl-debug.h"
b481de9c
ZY		 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
775ea378
TW		 45 * and the current line number and caller function name are printed in addition
46 * to any other debug output.
b481de9c
ZY		 47 *
48 * The non-prefixed name is the #define that maps the caller into a
775ea378
TW		 49 * #define that provides the caller's name and __LINE__ to the double
50 * prefix version.
b481de9c
ZY		 51 *
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
3395f6e9
TW		 54 * routines, for example _iwl_read_direct32 calls the non-check version of
55 * _iwl_read32.)
b481de9c
ZY		 56 *
57 * These declarations are *extremely* useful in quickly isolating code deltas
a96a27f9 58 * which result in misconfiguration of the hardware I/O. In combination with
b481de9c
ZY		 59 * git-bisect and the IO debug level you can quickly determine the specific
60 * commit which breaks the IO sequence to the hardware.
61 *
62 */
63
f5efde3b 64#define _iwl_write32(priv, ofs, val) iowrite32((val), (priv)->hw_base + (ofs))
0a6857e7 65#ifdef CONFIG_IWLWIFI_DEBUG
3395f6e9 66static inline void __iwl_write32(const char *f, u32 l, struct iwl_priv *priv,
b481de9c
ZY		 67 u32 ofs, u32 val)
68{
e1623446 69 IWL_DEBUG_IO(priv, "write32(0x%08X, 0x%08X) - %s %d\n", ofs, val, f, l);
3395f6e9 70 _iwl_write32(priv, ofs, val);
b481de9c 71}
3395f6e9
TW		 72#define iwl_write32(priv, ofs, val) \
73 __iwl_write32(__FILE__, __LINE__, priv, ofs, val)
b481de9c 74#else
3395f6e9 75#define iwl_write32(priv, ofs, val) _iwl_write32(priv, ofs, val)
b481de9c
ZY		 76#endif
77
f5efde3b 78#define _iwl_read32(priv, ofs) ioread32((priv)->hw_base + (ofs))
0a6857e7 79#ifdef CONFIG_IWLWIFI_DEBUG
3395f6e9 80static inline u32 __iwl_read32(char *f, u32 l, struct iwl_priv *priv, u32 ofs)
b481de9c 81{
e1623446 82 IWL_DEBUG_IO(priv, "read_direct32(0x%08X) - %s %d\n", ofs, f, l);
3395f6e9 83 return _iwl_read32(priv, ofs);
b481de9c 84}
3395f6e9 85#define iwl_read32(priv, ofs) __iwl_read32(__FILE__, __LINE__, priv, ofs)
b481de9c 86#else
3395f6e9 87#define iwl_read32(p, o) _iwl_read32(p, o)
b481de9c
ZY		 88#endif
89
4087f6f6 90#define IWL_POLL_INTERVAL 10 /* microseconds */
3395f6e9 91static inline int _iwl_poll_bit(struct iwl_priv *priv, u32 addr,
b481de9c
ZY		 92 u32 bits, u32 mask, int timeout)
93{
4087f6f6 94 int t = 0;
b481de9c
ZY		 95
96 do {
3395f6e9 97 if ((_iwl_read32(priv, addr) & mask) == (bits & mask))
4087f6f6
WF		 98 return t;
99 udelay(IWL_POLL_INTERVAL);
100 t += IWL_POLL_INTERVAL;
101 } while (t < timeout);
b481de9c
ZY		 102
103 return -ETIMEDOUT;
104}
0a6857e7 105#ifdef CONFIG_IWLWIFI_DEBUG
3395f6e9 106static inline int __iwl_poll_bit(const char *f, u32 l,
c79dd5b5 107 struct iwl_priv *priv, u32 addr,
b481de9c
ZY		 108 u32 bits, u32 mask, int timeout)
109{
3395f6e9 110 int ret = _iwl_poll_bit(priv, addr, bits, mask, timeout);
e1623446 111 IWL_DEBUG_IO(priv, "poll_bit(0x%08X, 0x%08X, 0x%08X) - %s- %s %d\n",
5c1b0958 112 addr, bits, mask,
c3056065 113 unlikely(ret == -ETIMEDOUT) ? "timeout" : "", f, l);
ac17a947 114 return ret;
b481de9c 115}
3395f6e9
TW		 116#define iwl_poll_bit(priv, addr, bits, mask, timeout) \
117 __iwl_poll_bit(__FILE__, __LINE__, priv, addr, bits, mask, timeout)
b481de9c 118#else
3395f6e9 119#define iwl_poll_bit(p, a, b, m, t) _iwl_poll_bit(p, a, b, m, t)
b481de9c
ZY		 120#endif
121
3395f6e9 122static inline void _iwl_set_bit(struct iwl_priv *priv, u32 reg, u32 mask)
b481de9c 123{
3395f6e9 124 _iwl_write32(priv, reg, _iwl_read32(priv, reg) | mask);
b481de9c 125}
0a6857e7 126#ifdef CONFIG_IWLWIFI_DEBUG
3395f6e9 127static inline void __iwl_set_bit(const char *f, u32 l,
c79dd5b5 128 struct iwl_priv *priv, u32 reg, u32 mask)
b481de9c 129{
3395f6e9 130 u32 val = _iwl_read32(priv, reg) | mask;
e1623446 131 IWL_DEBUG_IO(priv, "set_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val);
3395f6e9 132 _iwl_write32(priv, reg, val);
b481de9c 133}
a8b50a0a
MA		 134static inline void iwl_set_bit(struct iwl_priv *p, u32 r, u32 m)
135{
136 unsigned long reg_flags;
137
138 spin_lock_irqsave(&p->reg_lock, reg_flags);
139 __iwl_set_bit(__FILE__, __LINE__, p, r, m);
140 spin_unlock_irqrestore(&p->reg_lock, reg_flags);
141}
b481de9c 142#else
a8b50a0a
MA		 143static inline void iwl_set_bit(struct iwl_priv *p, u32 r, u32 m)
144{
145 unsigned long reg_flags;
146
147 spin_lock_irqsave(&p->reg_lock, reg_flags);
148 _iwl_set_bit(p, r, m);
149 spin_unlock_irqrestore(&p->reg_lock, reg_flags);
150}
b481de9c
ZY		 151#endif
152
3395f6e9 153static inline void _iwl_clear_bit(struct iwl_priv *priv, u32 reg, u32 mask)
b481de9c 154{
3395f6e9 155 _iwl_write32(priv, reg, _iwl_read32(priv, reg) & ~mask);
b481de9c 156}
0a6857e7 157#ifdef CONFIG_IWLWIFI_DEBUG
3395f6e9 158static inline void __iwl_clear_bit(const char *f, u32 l,
c79dd5b5 159 struct iwl_priv *priv, u32 reg, u32 mask)
b481de9c 160{
3395f6e9 161 u32 val = _iwl_read32(priv, reg) & ~mask;
e1623446 162 IWL_DEBUG_IO(priv, "clear_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val);
3395f6e9 163 _iwl_write32(priv, reg, val);
b481de9c 164}
a8b50a0a
MA		 165static inline void iwl_clear_bit(struct iwl_priv *p, u32 r, u32 m)
166{
167 unsigned long reg_flags;
168
169 spin_lock_irqsave(&p->reg_lock, reg_flags);
170 __iwl_clear_bit(__FILE__, __LINE__, p, r, m);
171 spin_unlock_irqrestore(&p->reg_lock, reg_flags);
172}
b481de9c 173#else
a8b50a0a
MA		 174static inline void iwl_clear_bit(struct iwl_priv *p, u32 r, u32 m)
175{
176 unsigned long reg_flags;
177
178 spin_lock_irqsave(&p->reg_lock, reg_flags);
179 _iwl_clear_bit(p, r, m);
180 spin_unlock_irqrestore(&p->reg_lock, reg_flags);
181}
b481de9c
ZY		 182#endif
183
3395f6e9 184static inline int _iwl_grab_nic_access(struct iwl_priv *priv)
b481de9c 185{
ac17a947 186 int ret;
18d426c4 187 u32 val;
a8b50a0a 188
b481de9c 189 /* this bit wakes up the NIC */
3395f6e9
TW		 190 _iwl_set_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
191 ret = _iwl_poll_bit(priv, CSR_GP_CNTRL,
b481de9c
ZY		 192 CSR_GP_CNTRL_REG_VAL_MAC_ACCESS_EN,
193 (CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY |
e9414b6b 194 CSR_GP_CNTRL_REG_FLAG_GOING_TO_SLEEP), 15000);
ac17a947 195 if (ret < 0) {
18d426c4
RC		 196 val = _iwl_read32(priv, CSR_GP_CNTRL);
197 IWL_ERR(priv, "MAC is in deep sleep!. CSR_GP_CNTRL = 0x%08X\n", val);
a8b50a0a 198 _iwl_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_FORCE_NMI);
b481de9c
ZY		 199 return -EIO;
200 }
201
b481de9c
ZY		 202 return 0;
203}
204
0a6857e7 205#ifdef CONFIG_IWLWIFI_DEBUG
3395f6e9 206static inline int __iwl_grab_nic_access(const char *f, u32 l,
c79dd5b5 207 struct iwl_priv *priv)
b481de9c 208{
e1623446 209 IWL_DEBUG_IO(priv, "grabbing nic access - %s %d\n", f, l);
3395f6e9 210 return _iwl_grab_nic_access(priv);
b481de9c 211}
3395f6e9
TW		 212#define iwl_grab_nic_access(priv) \
213 __iwl_grab_nic_access(__FILE__, __LINE__, priv)
b481de9c 214#else
3395f6e9
TW		 215#define iwl_grab_nic_access(priv) \
216 _iwl_grab_nic_access(priv)
b481de9c
ZY		 217#endif
218
3395f6e9 219static inline void _iwl_release_nic_access(struct iwl_priv *priv)
b481de9c 220{
a8b50a0a
MA		 221 _iwl_clear_bit(priv, CSR_GP_CNTRL,
222 CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
b481de9c 223}
0a6857e7 224#ifdef CONFIG_IWLWIFI_DEBUG
3395f6e9 225static inline void __iwl_release_nic_access(const char *f, u32 l,
c79dd5b5 226 struct iwl_priv *priv)
b481de9c 227{
b481de9c 228
e1623446 229 IWL_DEBUG_IO(priv, "releasing nic access - %s %d\n", f, l);
3395f6e9 230 _iwl_release_nic_access(priv);
b481de9c 231}
3395f6e9
TW		 232#define iwl_release_nic_access(priv) \
233 __iwl_release_nic_access(__FILE__, __LINE__, priv)
b481de9c 234#else
3395f6e9
TW		 235#define iwl_release_nic_access(priv) \
236 _iwl_release_nic_access(priv)
b481de9c
ZY		 237#endif
238
3395f6e9 239static inline u32 _iwl_read_direct32(struct iwl_priv *priv, u32 reg)
b481de9c 240{
3395f6e9 241 return _iwl_read32(priv, reg);
b481de9c 242}
0a6857e7 243#ifdef CONFIG_IWLWIFI_DEBUG
3395f6e9 244static inline u32 __iwl_read_direct32(const char *f, u32 l,
c79dd5b5 245 struct iwl_priv *priv, u32 reg)
b481de9c 246{
3395f6e9 247 u32 value = _iwl_read_direct32(priv, reg);
e1623446 248 IWL_DEBUG_IO(priv, "read_direct32(0x%4X) = 0x%08x - %s %d \n", reg, value,
b481de9c
ZY		 249 f, l);
250 return value;
251}
a8b50a0a
MA		 252static inline u32 iwl_read_direct32(struct iwl_priv *priv, u32 reg)
253{
254 u32 value;
255 unsigned long reg_flags;
256
257 spin_lock_irqsave(&priv->reg_lock, reg_flags);
258 iwl_grab_nic_access(priv);
259 value = __iwl_read_direct32(__FILE__, __LINE__, priv, reg);
260 iwl_release_nic_access(priv);
261 spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
262 return value;
263}
264
b481de9c 265#else
a8b50a0a
MA		 266static inline u32 iwl_read_direct32(struct iwl_priv *priv, u32 reg)
267{
268 u32 value;
269 unsigned long reg_flags;
270
271 spin_lock_irqsave(&priv->reg_lock, reg_flags);
272 iwl_grab_nic_access(priv);
273 value = _iwl_read_direct32(priv, reg);
274 iwl_release_nic_access(priv);
275 spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
276 return value;
277
278}
b481de9c
ZY		 279#endif
280
3395f6e9 281static inline void _iwl_write_direct32(struct iwl_priv *priv,
b481de9c
ZY		 282 u32 reg, u32 value)
283{
3395f6e9 284 _iwl_write32(priv, reg, value);
b481de9c 285}
a8b50a0a 286static inline void iwl_write_direct32(struct iwl_priv *priv, u32 reg, u32 value)
b481de9c 287{
a8b50a0a
MA		 288 unsigned long reg_flags;
289
290 spin_lock_irqsave(&priv->reg_lock, reg_flags);
291 if (!iwl_grab_nic_access(priv)) {
292 _iwl_write_direct32(priv, reg, value);
293 iwl_release_nic_access(priv);
294 }
295 spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
b481de9c 296}
b481de9c 297
3395f6e9 298static inline void iwl_write_reg_buf(struct iwl_priv *priv,
b481de9c
ZY		 299 u32 reg, u32 len, u32 *values)
300{
301 u32 count = sizeof(u32);
302
303 if ((priv != NULL) && (values != NULL)) {
304 for (; 0 < len; len -= count, reg += count, values++)
a8b50a0a 305 iwl_write_direct32(priv, reg, *values);
b481de9c
ZY		 306 }
307}
308
73d7b5ac
ZY		 309static inline int _iwl_poll_direct_bit(struct iwl_priv *priv, u32 addr,
310 u32 mask, int timeout)
b481de9c 311{
a8b50a0a
MA		 312 int t = 0;
313
314 do {
315 if ((iwl_read_direct32(priv, addr) & mask) == mask)
316 return t;
317 udelay(IWL_POLL_INTERVAL);
318 t += IWL_POLL_INTERVAL;
319 } while (t < timeout);
320
321 return -ETIMEDOUT;
b481de9c
ZY		 322}
323
0a6857e7 324#ifdef CONFIG_IWLWIFI_DEBUG
3395f6e9 325static inline int __iwl_poll_direct_bit(const char *f, u32 l,
c79dd5b5 326 struct iwl_priv *priv,
b481de9c
ZY		 327 u32 addr, u32 mask, int timeout)
328{
3395f6e9 329 int ret = _iwl_poll_direct_bit(priv, addr, mask, timeout);
b481de9c 330
ac17a947 331 if (unlikely(ret == -ETIMEDOUT))
e1623446 332 IWL_DEBUG_IO(priv, "poll_direct_bit(0x%08X, 0x%08X) - "
b481de9c
ZY		 333 "timedout - %s %d\n", addr, mask, f, l);
334 else
e1623446 335 IWL_DEBUG_IO(priv, "poll_direct_bit(0x%08X, 0x%08X) = 0x%08X "
ac17a947
TW		 336 "- %s %d\n", addr, mask, ret, f, l);
337 return ret;
b481de9c 338}
3395f6e9
TW		 339#define iwl_poll_direct_bit(priv, addr, mask, timeout) \
340 __iwl_poll_direct_bit(__FILE__, __LINE__, priv, addr, mask, timeout)
b481de9c 341#else
3395f6e9 342#define iwl_poll_direct_bit _iwl_poll_direct_bit
b481de9c
ZY		 343#endif
344
3395f6e9 345static inline u32 _iwl_read_prph(struct iwl_priv *priv, u32 reg)
b481de9c 346{
3395f6e9 347 _iwl_write_direct32(priv, HBUS_TARG_PRPH_RADDR, reg | (3 << 24));
a8ec42c1 348 rmb();
3395f6e9 349 return _iwl_read_direct32(priv, HBUS_TARG_PRPH_RDAT);
b481de9c 350}
a8b50a0a 351static inline u32 iwl_read_prph(struct iwl_priv *priv, u32 reg)
b481de9c 352{
a8b50a0a
MA		 353 unsigned long reg_flags;
354 u32 val;
b481de9c 355
a8b50a0a
MA		 356 spin_lock_irqsave(&priv->reg_lock, reg_flags);
357 iwl_grab_nic_access(priv);
358 val = _iwl_read_prph(priv, reg);
359 iwl_release_nic_access(priv);
360 spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
361 return val;
362}
b481de9c 363
3395f6e9 364static inline void _iwl_write_prph(struct iwl_priv *priv,
b481de9c
ZY		 365 u32 addr, u32 val)
366{
3395f6e9 367 _iwl_write_direct32(priv, HBUS_TARG_PRPH_WADDR,
b481de9c 368 ((addr & 0x0000FFFF) | (3 << 24)));
a8ec42c1 369 wmb();
3395f6e9 370 _iwl_write_direct32(priv, HBUS_TARG_PRPH_WDAT, val);
b481de9c 371}
a8b50a0a
MA		 372
373static inline void iwl_write_prph(struct iwl_priv *priv, u32 addr, u32 val)
b481de9c 374{
a8b50a0a 375 unsigned long reg_flags;
b481de9c 376
a8b50a0a
MA		 377 spin_lock_irqsave(&priv->reg_lock, reg_flags);
378 if (!iwl_grab_nic_access(priv)) {
379 _iwl_write_prph(priv, addr, val);
380 iwl_release_nic_access(priv);
381 }
382 spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
383}
b481de9c 384
3395f6e9
TW		 385#define _iwl_set_bits_prph(priv, reg, mask) \
386 _iwl_write_prph(priv, reg, (_iwl_read_prph(priv, reg) | mask))
a8b50a0a
MA		 387
388static inline void iwl_set_bits_prph(struct iwl_priv *priv, u32 reg, u32 mask)
b481de9c 389{
a8b50a0a 390 unsigned long reg_flags;
ac17a947 391
a8b50a0a
MA		 392 spin_lock_irqsave(&priv->reg_lock, reg_flags);
393 iwl_grab_nic_access(priv);
3395f6e9 394 _iwl_set_bits_prph(priv, reg, mask);
a8b50a0a
MA		 395 iwl_release_nic_access(priv);
396 spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
b481de9c 397}
b481de9c 398
3395f6e9
TW		 399#define _iwl_set_bits_mask_prph(priv, reg, bits, mask) \
400 _iwl_write_prph(priv, reg, ((_iwl_read_prph(priv, reg) & mask) | bits))
d8609652 401
a8b50a0a
MA		 402static inline void iwl_set_bits_mask_prph(struct iwl_priv *priv, u32 reg,
403 u32 bits, u32 mask)
b481de9c 404{
a8b50a0a
MA		 405 unsigned long reg_flags;
406
407 spin_lock_irqsave(&priv->reg_lock, reg_flags);
408 iwl_grab_nic_access(priv);
3395f6e9 409 _iwl_set_bits_mask_prph(priv, reg, bits, mask);
a8b50a0a
MA		 410 iwl_release_nic_access(priv);
411 spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
b481de9c 412}
b481de9c 413
3395f6e9 414static inline void iwl_clear_bits_prph(struct iwl_priv
b481de9c
ZY		 415 *priv, u32 reg, u32 mask)
416{
a8b50a0a
MA		 417 unsigned long reg_flags;
418 u32 val;
419
420 spin_lock_irqsave(&priv->reg_lock, reg_flags);
421 iwl_grab_nic_access(priv);
422 val = _iwl_read_prph(priv, reg);
3395f6e9 423 _iwl_write_prph(priv, reg, (val & ~mask));
a8b50a0a
MA		 424 iwl_release_nic_access(priv);
425 spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
b481de9c
ZY		 426}
427
3395f6e9 428static inline u32 iwl_read_targ_mem(struct iwl_priv *priv, u32 addr)
b481de9c 429{
a8b50a0a
MA		 430 unsigned long reg_flags;
431 u32 value;
432
433 spin_lock_irqsave(&priv->reg_lock, reg_flags);
434 iwl_grab_nic_access(priv);
435
436 _iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR, addr);
a8ec42c1 437 rmb();
a8b50a0a
MA		 438 value = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
439
440 iwl_release_nic_access(priv);
441 spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
442 return value;
b481de9c
ZY		 443}
444
3395f6e9 445static inline void iwl_write_targ_mem(struct iwl_priv *priv, u32 addr, u32 val)
b481de9c 446{
a8b50a0a
MA		 447 unsigned long reg_flags;
448
449 spin_lock_irqsave(&priv->reg_lock, reg_flags);
450 if (!iwl_grab_nic_access(priv)) {
451 _iwl_write_direct32(priv, HBUS_TARG_MEM_WADDR, addr);
452 wmb();
453 _iwl_write_direct32(priv, HBUS_TARG_MEM_WDAT, val);
454 iwl_release_nic_access(priv);
455 }
456 spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
b481de9c
ZY		 457}
458
3395f6e9 459static inline void iwl_write_targ_mem_buf(struct iwl_priv *priv, u32 addr,
af7cca2a 460 u32 len, u32 *values)
b481de9c 461{
a8b50a0a
MA		 462 unsigned long reg_flags;
463
464 spin_lock_irqsave(&priv->reg_lock, reg_flags);
465 if (!iwl_grab_nic_access(priv)) {
466 _iwl_write_direct32(priv, HBUS_TARG_MEM_WADDR, addr);
467 wmb();
468 for (; 0 < len; len -= sizeof(u32), values++)
469 _iwl_write_direct32(priv, HBUS_TARG_MEM_WDAT, *values);
470
471 iwl_release_nic_access(priv);
472 }
473 spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
b481de9c 474}
b481de9c 475#endif
Linux kernel - Deliverables
This page took 0.357463 seconds and 5 git commands to generate.