Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 1 | /****************************************************************************** |
| 2 | * |
Wey-Yi Guy | 4e31826 | 2011-12-27 11:21:32 -0800 | [diff] [blame] | 3 | * Copyright(c) 2003 - 2012 Intel Corporation. All rights reserved. |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 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 | *****************************************************************************/ |
Emmanuel Grumbach | 83ed901 | 2011-08-25 23:11:14 -0700 | [diff] [blame] | 28 | #include <linux/delay.h> |
| 29 | #include <linux/device.h> |
Don Fry | cc5f7e3 | 2012-05-16 22:54:27 +0200 | [diff] [blame] | 30 | #include <linux/export.h> |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 31 | |
| 32 | #include "iwl-io.h" |
Paul Bolle | 6ac7d11 | 2012-06-06 14:17:46 +0200 | [diff] [blame] | 33 | #include "iwl-csr.h" |
Emmanuel Grumbach | 83ed901 | 2011-08-25 23:11:14 -0700 | [diff] [blame] | 34 | #include "iwl-debug.h" |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 35 | |
| 36 | #define IWL_POLL_INTERVAL 10 /* microseconds */ |
| 37 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 38 | static inline void __iwl_set_bit(struct iwl_trans *trans, u32 reg, u32 mask) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 39 | { |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 40 | iwl_write32(trans, reg, iwl_read32(trans, reg) | mask); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 41 | } |
| 42 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 43 | static inline void __iwl_clear_bit(struct iwl_trans *trans, u32 reg, u32 mask) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 44 | { |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 45 | iwl_write32(trans, reg, iwl_read32(trans, reg) & ~mask); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 46 | } |
| 47 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 48 | void iwl_set_bit(struct iwl_trans *trans, u32 reg, u32 mask) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 49 | { |
| 50 | unsigned long flags; |
| 51 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 52 | spin_lock_irqsave(&trans->reg_lock, flags); |
| 53 | __iwl_set_bit(trans, reg, mask); |
| 54 | spin_unlock_irqrestore(&trans->reg_lock, flags); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 55 | } |
Don Fry | cc5f7e3 | 2012-05-16 22:54:27 +0200 | [diff] [blame] | 56 | EXPORT_SYMBOL_GPL(iwl_set_bit); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 57 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 58 | void iwl_clear_bit(struct iwl_trans *trans, u32 reg, u32 mask) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 59 | { |
| 60 | unsigned long flags; |
| 61 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 62 | spin_lock_irqsave(&trans->reg_lock, flags); |
| 63 | __iwl_clear_bit(trans, reg, mask); |
| 64 | spin_unlock_irqrestore(&trans->reg_lock, flags); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 65 | } |
Don Fry | cc5f7e3 | 2012-05-16 22:54:27 +0200 | [diff] [blame] | 66 | EXPORT_SYMBOL_GPL(iwl_clear_bit); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 67 | |
Johannes Berg | 2baa2e57 | 2012-05-29 14:47:30 +0200 | [diff] [blame] | 68 | void iwl_set_bits_mask(struct iwl_trans *trans, u32 reg, u32 mask, u32 value) |
| 69 | { |
| 70 | unsigned long flags; |
| 71 | u32 v; |
| 72 | |
| 73 | #ifdef CONFIG_IWLWIFI_DEBUG |
| 74 | WARN_ON_ONCE(value & ~mask); |
| 75 | #endif |
| 76 | |
| 77 | spin_lock_irqsave(&trans->reg_lock, flags); |
| 78 | v = iwl_read32(trans, reg); |
| 79 | v &= ~mask; |
| 80 | v |= value; |
| 81 | iwl_write32(trans, reg, v); |
| 82 | spin_unlock_irqrestore(&trans->reg_lock, flags); |
| 83 | } |
| 84 | EXPORT_SYMBOL_GPL(iwl_set_bits_mask); |
| 85 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 86 | int iwl_poll_bit(struct iwl_trans *trans, u32 addr, |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 87 | u32 bits, u32 mask, int timeout) |
| 88 | { |
| 89 | int t = 0; |
| 90 | |
| 91 | do { |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 92 | if ((iwl_read32(trans, addr) & mask) == (bits & mask)) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 93 | return t; |
| 94 | udelay(IWL_POLL_INTERVAL); |
| 95 | t += IWL_POLL_INTERVAL; |
| 96 | } while (t < timeout); |
| 97 | |
| 98 | return -ETIMEDOUT; |
| 99 | } |
Don Fry | cc5f7e3 | 2012-05-16 22:54:27 +0200 | [diff] [blame] | 100 | EXPORT_SYMBOL_GPL(iwl_poll_bit); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 101 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 102 | int iwl_grab_nic_access_silent(struct iwl_trans *trans) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 103 | { |
| 104 | int ret; |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 105 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 106 | lockdep_assert_held(&trans->reg_lock); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 107 | |
| 108 | /* this bit wakes up the NIC */ |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 109 | __iwl_set_bit(trans, CSR_GP_CNTRL, |
| 110 | CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 111 | |
| 112 | /* |
| 113 | * These bits say the device is running, and should keep running for |
| 114 | * at least a short while (at least as long as MAC_ACCESS_REQ stays 1), |
| 115 | * but they do not indicate that embedded SRAM is restored yet; |
| 116 | * 3945 and 4965 have volatile SRAM, and must save/restore contents |
| 117 | * to/from host DRAM when sleeping/waking for power-saving. |
| 118 | * Each direction takes approximately 1/4 millisecond; with this |
| 119 | * overhead, it's a good idea to grab and hold MAC_ACCESS_REQUEST if a |
| 120 | * series of register accesses are expected (e.g. reading Event Log), |
| 121 | * to keep device from sleeping. |
| 122 | * |
| 123 | * CSR_UCODE_DRV_GP1 register bit MAC_SLEEP == 0 indicates that |
| 124 | * SRAM is okay/restored. We don't check that here because this call |
| 125 | * is just for hardware register access; but GP1 MAC_SLEEP check is a |
| 126 | * good idea before accessing 3945/4965 SRAM (e.g. reading Event Log). |
| 127 | * |
| 128 | * 5000 series and later (including 1000 series) have non-volatile SRAM, |
| 129 | * and do not save/restore SRAM when power cycling. |
| 130 | */ |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 131 | ret = iwl_poll_bit(trans, CSR_GP_CNTRL, |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 132 | CSR_GP_CNTRL_REG_VAL_MAC_ACCESS_EN, |
| 133 | (CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY | |
| 134 | CSR_GP_CNTRL_REG_FLAG_GOING_TO_SLEEP), 15000); |
| 135 | if (ret < 0) { |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 136 | iwl_write32(trans, CSR_RESET, CSR_RESET_REG_FLAG_FORCE_NMI); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 137 | return -EIO; |
| 138 | } |
| 139 | |
| 140 | return 0; |
| 141 | } |
Don Fry | cc5f7e3 | 2012-05-16 22:54:27 +0200 | [diff] [blame] | 142 | EXPORT_SYMBOL_GPL(iwl_grab_nic_access_silent); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 143 | |
Stanislaw Gruszka | bfe4b80 | 2012-03-07 09:52:24 -0800 | [diff] [blame] | 144 | bool iwl_grab_nic_access(struct iwl_trans *trans) |
Johannes Berg | 4119904 | 2011-04-19 07:42:03 -0700 | [diff] [blame] | 145 | { |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 146 | int ret = iwl_grab_nic_access_silent(trans); |
Stanislaw Gruszka | aa5affb | 2012-03-07 09:52:23 -0800 | [diff] [blame] | 147 | if (unlikely(ret)) { |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 148 | u32 val = iwl_read32(trans, CSR_GP_CNTRL); |
Stanislaw Gruszka | aa5affb | 2012-03-07 09:52:23 -0800 | [diff] [blame] | 149 | WARN_ONCE(1, "Timeout waiting for hardware access " |
| 150 | "(CSR_GP_CNTRL 0x%08x)\n", val); |
Stanislaw Gruszka | bfe4b80 | 2012-03-07 09:52:24 -0800 | [diff] [blame] | 151 | return false; |
Johannes Berg | 4119904 | 2011-04-19 07:42:03 -0700 | [diff] [blame] | 152 | } |
| 153 | |
Stanislaw Gruszka | bfe4b80 | 2012-03-07 09:52:24 -0800 | [diff] [blame] | 154 | return true; |
Johannes Berg | 4119904 | 2011-04-19 07:42:03 -0700 | [diff] [blame] | 155 | } |
Don Fry | cc5f7e3 | 2012-05-16 22:54:27 +0200 | [diff] [blame] | 156 | EXPORT_SYMBOL_GPL(iwl_grab_nic_access); |
Johannes Berg | 4119904 | 2011-04-19 07:42:03 -0700 | [diff] [blame] | 157 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 158 | void iwl_release_nic_access(struct iwl_trans *trans) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 159 | { |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 160 | lockdep_assert_held(&trans->reg_lock); |
| 161 | __iwl_clear_bit(trans, CSR_GP_CNTRL, |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 162 | CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ); |
Stanislaw Gruszka | 3a73a30 | 2012-03-07 09:52:25 -0800 | [diff] [blame] | 163 | /* |
| 164 | * Above we read the CSR_GP_CNTRL register, which will flush |
| 165 | * any previous writes, but we need the write that clears the |
| 166 | * MAC_ACCESS_REQ bit to be performed before any other writes |
| 167 | * scheduled on different CPUs (after we drop reg_lock). |
| 168 | */ |
| 169 | mmiowb(); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 170 | } |
Don Fry | cc5f7e3 | 2012-05-16 22:54:27 +0200 | [diff] [blame] | 171 | EXPORT_SYMBOL_GPL(iwl_release_nic_access); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 172 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 173 | u32 iwl_read_direct32(struct iwl_trans *trans, u32 reg) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 174 | { |
| 175 | u32 value; |
| 176 | unsigned long flags; |
| 177 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 178 | spin_lock_irqsave(&trans->reg_lock, flags); |
| 179 | iwl_grab_nic_access(trans); |
| 180 | value = iwl_read32(trans, reg); |
| 181 | iwl_release_nic_access(trans); |
| 182 | spin_unlock_irqrestore(&trans->reg_lock, flags); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 183 | |
| 184 | return value; |
| 185 | } |
Don Fry | cc5f7e3 | 2012-05-16 22:54:27 +0200 | [diff] [blame] | 186 | EXPORT_SYMBOL_GPL(iwl_read_direct32); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 187 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 188 | void iwl_write_direct32(struct iwl_trans *trans, u32 reg, u32 value) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 189 | { |
| 190 | unsigned long flags; |
| 191 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 192 | spin_lock_irqsave(&trans->reg_lock, flags); |
Stanislaw Gruszka | bfe4b80 | 2012-03-07 09:52:24 -0800 | [diff] [blame] | 193 | if (likely(iwl_grab_nic_access(trans))) { |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 194 | iwl_write32(trans, reg, value); |
| 195 | iwl_release_nic_access(trans); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 196 | } |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 197 | spin_unlock_irqrestore(&trans->reg_lock, flags); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 198 | } |
Don Fry | cc5f7e3 | 2012-05-16 22:54:27 +0200 | [diff] [blame] | 199 | EXPORT_SYMBOL_GPL(iwl_write_direct32); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 200 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 201 | int iwl_poll_direct_bit(struct iwl_trans *trans, u32 addr, u32 mask, |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 202 | int timeout) |
| 203 | { |
| 204 | int t = 0; |
| 205 | |
| 206 | do { |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 207 | if ((iwl_read_direct32(trans, addr) & mask) == mask) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 208 | return t; |
| 209 | udelay(IWL_POLL_INTERVAL); |
| 210 | t += IWL_POLL_INTERVAL; |
| 211 | } while (t < timeout); |
| 212 | |
| 213 | return -ETIMEDOUT; |
| 214 | } |
Don Fry | cc5f7e3 | 2012-05-16 22:54:27 +0200 | [diff] [blame] | 215 | EXPORT_SYMBOL_GPL(iwl_poll_direct_bit); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 216 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 217 | static inline u32 __iwl_read_prph(struct iwl_trans *trans, u32 reg) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 218 | { |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 219 | iwl_write32(trans, HBUS_TARG_PRPH_RADDR, reg | (3 << 24)); |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 220 | return iwl_read32(trans, HBUS_TARG_PRPH_RDAT); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 221 | } |
| 222 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 223 | static inline void __iwl_write_prph(struct iwl_trans *trans, u32 addr, u32 val) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 224 | { |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 225 | iwl_write32(trans, HBUS_TARG_PRPH_WADDR, |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 226 | ((addr & 0x0000FFFF) | (3 << 24))); |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 227 | iwl_write32(trans, HBUS_TARG_PRPH_WDAT, val); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 228 | } |
| 229 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 230 | u32 iwl_read_prph(struct iwl_trans *trans, u32 reg) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 231 | { |
| 232 | unsigned long flags; |
| 233 | u32 val; |
| 234 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 235 | spin_lock_irqsave(&trans->reg_lock, flags); |
| 236 | iwl_grab_nic_access(trans); |
| 237 | val = __iwl_read_prph(trans, reg); |
| 238 | iwl_release_nic_access(trans); |
| 239 | spin_unlock_irqrestore(&trans->reg_lock, flags); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 240 | return val; |
| 241 | } |
Don Fry | cc5f7e3 | 2012-05-16 22:54:27 +0200 | [diff] [blame] | 242 | EXPORT_SYMBOL_GPL(iwl_read_prph); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 243 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 244 | void iwl_write_prph(struct iwl_trans *trans, u32 addr, u32 val) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 245 | { |
| 246 | unsigned long flags; |
| 247 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 248 | spin_lock_irqsave(&trans->reg_lock, flags); |
Stanislaw Gruszka | bfe4b80 | 2012-03-07 09:52:24 -0800 | [diff] [blame] | 249 | if (likely(iwl_grab_nic_access(trans))) { |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 250 | __iwl_write_prph(trans, addr, val); |
| 251 | iwl_release_nic_access(trans); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 252 | } |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 253 | spin_unlock_irqrestore(&trans->reg_lock, flags); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 254 | } |
Don Fry | cc5f7e3 | 2012-05-16 22:54:27 +0200 | [diff] [blame] | 255 | EXPORT_SYMBOL_GPL(iwl_write_prph); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 256 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 257 | void iwl_set_bits_prph(struct iwl_trans *trans, u32 reg, u32 mask) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 258 | { |
| 259 | unsigned long flags; |
| 260 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 261 | spin_lock_irqsave(&trans->reg_lock, flags); |
Stanislaw Gruszka | bfe4b80 | 2012-03-07 09:52:24 -0800 | [diff] [blame] | 262 | if (likely(iwl_grab_nic_access(trans))) { |
| 263 | __iwl_write_prph(trans, reg, |
| 264 | __iwl_read_prph(trans, reg) | mask); |
| 265 | iwl_release_nic_access(trans); |
| 266 | } |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 267 | spin_unlock_irqrestore(&trans->reg_lock, flags); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 268 | } |
Don Fry | cc5f7e3 | 2012-05-16 22:54:27 +0200 | [diff] [blame] | 269 | EXPORT_SYMBOL_GPL(iwl_set_bits_prph); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 270 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 271 | void iwl_set_bits_mask_prph(struct iwl_trans *trans, u32 reg, |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 272 | u32 bits, u32 mask) |
| 273 | { |
| 274 | unsigned long flags; |
| 275 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 276 | spin_lock_irqsave(&trans->reg_lock, flags); |
Stanislaw Gruszka | bfe4b80 | 2012-03-07 09:52:24 -0800 | [diff] [blame] | 277 | if (likely(iwl_grab_nic_access(trans))) { |
| 278 | __iwl_write_prph(trans, reg, |
| 279 | (__iwl_read_prph(trans, reg) & mask) | bits); |
| 280 | iwl_release_nic_access(trans); |
| 281 | } |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 282 | spin_unlock_irqrestore(&trans->reg_lock, flags); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 283 | } |
Don Fry | cc5f7e3 | 2012-05-16 22:54:27 +0200 | [diff] [blame] | 284 | EXPORT_SYMBOL_GPL(iwl_set_bits_mask_prph); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 285 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 286 | void iwl_clear_bits_prph(struct iwl_trans *trans, u32 reg, u32 mask) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 287 | { |
| 288 | unsigned long flags; |
| 289 | u32 val; |
| 290 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 291 | spin_lock_irqsave(&trans->reg_lock, flags); |
Stanislaw Gruszka | bfe4b80 | 2012-03-07 09:52:24 -0800 | [diff] [blame] | 292 | if (likely(iwl_grab_nic_access(trans))) { |
| 293 | val = __iwl_read_prph(trans, reg); |
| 294 | __iwl_write_prph(trans, reg, (val & ~mask)); |
| 295 | iwl_release_nic_access(trans); |
| 296 | } |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 297 | spin_unlock_irqrestore(&trans->reg_lock, flags); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 298 | } |
Don Fry | cc5f7e3 | 2012-05-16 22:54:27 +0200 | [diff] [blame] | 299 | EXPORT_SYMBOL_GPL(iwl_clear_bits_prph); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 300 | |
Emmanuel Grumbach | e4b1681 | 2012-06-06 08:18:40 +0300 | [diff] [blame] | 301 | void _iwl_read_targ_mem_dwords(struct iwl_trans *trans, u32 addr, |
| 302 | void *buf, int dwords) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 303 | { |
| 304 | unsigned long flags; |
Johannes Berg | e46f653 | 2011-04-13 03:14:43 -0700 | [diff] [blame] | 305 | int offs; |
| 306 | u32 *vals = buf; |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 307 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 308 | spin_lock_irqsave(&trans->reg_lock, flags); |
Stanislaw Gruszka | bfe4b80 | 2012-03-07 09:52:24 -0800 | [diff] [blame] | 309 | if (likely(iwl_grab_nic_access(trans))) { |
| 310 | iwl_write32(trans, HBUS_TARG_MEM_RADDR, addr); |
Emmanuel Grumbach | e4b1681 | 2012-06-06 08:18:40 +0300 | [diff] [blame] | 311 | for (offs = 0; offs < dwords; offs++) |
Stanislaw Gruszka | bfe4b80 | 2012-03-07 09:52:24 -0800 | [diff] [blame] | 312 | vals[offs] = iwl_read32(trans, HBUS_TARG_MEM_RDAT); |
| 313 | iwl_release_nic_access(trans); |
| 314 | } |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 315 | spin_unlock_irqrestore(&trans->reg_lock, flags); |
Johannes Berg | e46f653 | 2011-04-13 03:14:43 -0700 | [diff] [blame] | 316 | } |
Emmanuel Grumbach | e4b1681 | 2012-06-06 08:18:40 +0300 | [diff] [blame] | 317 | EXPORT_SYMBOL_GPL(_iwl_read_targ_mem_dwords); |
Johannes Berg | e46f653 | 2011-04-13 03:14:43 -0700 | [diff] [blame] | 318 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 319 | u32 iwl_read_targ_mem(struct iwl_trans *trans, u32 addr) |
Johannes Berg | e46f653 | 2011-04-13 03:14:43 -0700 | [diff] [blame] | 320 | { |
| 321 | u32 value; |
| 322 | |
Emmanuel Grumbach | e4b1681 | 2012-06-06 08:18:40 +0300 | [diff] [blame] | 323 | _iwl_read_targ_mem_dwords(trans, addr, &value, 1); |
Johannes Berg | e46f653 | 2011-04-13 03:14:43 -0700 | [diff] [blame] | 324 | |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 325 | return value; |
| 326 | } |
Don Fry | cc5f7e3 | 2012-05-16 22:54:27 +0200 | [diff] [blame] | 327 | EXPORT_SYMBOL_GPL(iwl_read_targ_mem); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 328 | |
Emmanuel Grumbach | e4b1681 | 2012-06-06 08:18:40 +0300 | [diff] [blame] | 329 | int _iwl_write_targ_mem_dwords(struct iwl_trans *trans, u32 addr, |
| 330 | void *buf, int dwords) |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 331 | { |
| 332 | unsigned long flags; |
Hsu, Kenny | ee8ba88 | 2011-12-09 03:11:18 -0800 | [diff] [blame] | 333 | int offs, result = 0; |
| 334 | u32 *vals = buf; |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 335 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 336 | spin_lock_irqsave(&trans->reg_lock, flags); |
Stanislaw Gruszka | bfe4b80 | 2012-03-07 09:52:24 -0800 | [diff] [blame] | 337 | if (likely(iwl_grab_nic_access(trans))) { |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 338 | iwl_write32(trans, HBUS_TARG_MEM_WADDR, addr); |
Emmanuel Grumbach | e4b1681 | 2012-06-06 08:18:40 +0300 | [diff] [blame] | 339 | for (offs = 0; offs < dwords; offs++) |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 340 | iwl_write32(trans, HBUS_TARG_MEM_WDAT, vals[offs]); |
| 341 | iwl_release_nic_access(trans); |
Hsu, Kenny | ee8ba88 | 2011-12-09 03:11:18 -0800 | [diff] [blame] | 342 | } else |
| 343 | result = -EBUSY; |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 344 | spin_unlock_irqrestore(&trans->reg_lock, flags); |
Hsu, Kenny | ee8ba88 | 2011-12-09 03:11:18 -0800 | [diff] [blame] | 345 | |
| 346 | return result; |
| 347 | } |
Emmanuel Grumbach | e4b1681 | 2012-06-06 08:18:40 +0300 | [diff] [blame] | 348 | EXPORT_SYMBOL_GPL(_iwl_write_targ_mem_dwords); |
Hsu, Kenny | ee8ba88 | 2011-12-09 03:11:18 -0800 | [diff] [blame] | 349 | |
Emmanuel Grumbach | 1042db2 | 2012-01-03 16:56:15 +0200 | [diff] [blame] | 350 | int iwl_write_targ_mem(struct iwl_trans *trans, u32 addr, u32 val) |
Hsu, Kenny | ee8ba88 | 2011-12-09 03:11:18 -0800 | [diff] [blame] | 351 | { |
Emmanuel Grumbach | e4b1681 | 2012-06-06 08:18:40 +0300 | [diff] [blame] | 352 | return _iwl_write_targ_mem_dwords(trans, addr, &val, 1); |
Johannes Berg | 02a7fa0 | 2011-04-05 09:42:12 -0700 | [diff] [blame] | 353 | } |
Don Fry | cc5f7e3 | 2012-05-16 22:54:27 +0200 | [diff] [blame] | 354 | EXPORT_SYMBOL_GPL(iwl_write_targ_mem); |