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 __iwl_io_h__
  30 #define __iwl_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 _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
  64 static 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
  78 static 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
  88 static 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
 103 static 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
 124 static 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
 129 static 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
 141 static 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
 146 static 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
 158 static 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
 201 static 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
 218 static 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
 227 static 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
 243 static inline u32 _iwl_read_direct32(struct iwl_priv *priv, u32 reg)
 244 {
 245         return _iwl_read32(priv, reg);
 246 }
 247 #ifdef CONFIG_IWLWIFI_DEBUG
 248 static 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
 264 static 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
 270 static 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
 283 static 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
 294 static 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
 310 static 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
 330 static 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
 336 static 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
 349 static 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
 357 static 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
 374 static 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
 392 static 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
 405 static 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
 412 static 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
 418 static 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
 424 static 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