Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 1 | /****************************************************************************** |
| 2 | * |
| 3 | * GPL LICENSE SUMMARY |
| 4 | * |
Wey-Yi Guy | 901069c | 2011-04-05 09:42:00 -0700 | [diff] [blame] | 5 | * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved. |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 6 | * |
| 7 | * This program is free software; you can redistribute it and/or modify |
| 8 | * it 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 |
| 12 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 14 | * General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU General Public License |
| 17 | * along with this program; if not, write to the Free Software |
| 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, |
| 19 | * USA |
| 20 | * |
| 21 | * The full GNU General Public License is included in this distribution |
| 22 | * in the file called LICENSE.GPL. |
| 23 | * |
| 24 | * Contact Information: |
| 25 | * Intel Linux Wireless <ilw@linux.intel.com> |
| 26 | * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 |
| 27 | * |
| 28 | *****************************************************************************/ |
| 29 | |
| 30 | #include <linux/kernel.h> |
| 31 | #include <linux/module.h> |
| 32 | #include <linux/init.h> |
| 33 | #include <linux/sched.h> |
| 34 | |
| 35 | #include "iwl-dev.h" |
| 36 | #include "iwl-core.h" |
| 37 | #include "iwl-io.h" |
Wey-Yi Guy | 510cb79 | 2010-03-16 12:37:28 -0700 | [diff] [blame] | 38 | #include "iwl-agn.h" |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 39 | |
Shanyu Zhao | 1808972 | 2010-05-06 10:15:21 -0700 | [diff] [blame] | 40 | int iwlagn_send_tx_ant_config(struct iwl_priv *priv, u8 valid_tx_ant) |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 41 | { |
| 42 | struct iwl_tx_ant_config_cmd tx_ant_cmd = { |
| 43 | .valid = cpu_to_le32(valid_tx_ant), |
| 44 | }; |
| 45 | |
| 46 | if (IWL_UCODE_API(priv->ucode_ver) > 1) { |
| 47 | IWL_DEBUG_HC(priv, "select valid tx ant: %u\n", valid_tx_ant); |
| 48 | return iwl_send_cmd_pdu(priv, TX_ANT_CONFIGURATION_CMD, |
| 49 | sizeof(struct iwl_tx_ant_config_cmd), |
| 50 | &tx_ant_cmd); |
| 51 | } else { |
| 52 | IWL_DEBUG_HC(priv, "TX_ANT_CONFIGURATION_CMD not supported\n"); |
| 53 | return -EOPNOTSUPP; |
| 54 | } |
| 55 | } |
| 56 | |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 57 | static u16 iwlagn_build_addsta_hcmd(const struct iwl_addsta_cmd *cmd, u8 *data) |
| 58 | { |
| 59 | u16 size = (u16)sizeof(struct iwl_addsta_cmd); |
| 60 | struct iwl_addsta_cmd *addsta = (struct iwl_addsta_cmd *)data; |
| 61 | memcpy(addsta, cmd, size); |
| 62 | /* resrved in 5000 */ |
| 63 | addsta->rate_n_flags = cpu_to_le16(0); |
| 64 | return size; |
| 65 | } |
| 66 | |
| 67 | static void iwlagn_gain_computation(struct iwl_priv *priv, |
| 68 | u32 average_noise[NUM_RX_CHAINS], |
| 69 | u16 min_average_noise_antenna_i, |
| 70 | u32 min_average_noise, |
| 71 | u8 default_chain) |
| 72 | { |
| 73 | int i; |
| 74 | s32 delta_g; |
| 75 | struct iwl_chain_noise_data *data = &priv->chain_noise_data; |
| 76 | |
| 77 | /* |
| 78 | * Find Gain Code for the chains based on "default chain" |
| 79 | */ |
| 80 | for (i = default_chain + 1; i < NUM_RX_CHAINS; i++) { |
| 81 | if ((data->disconn_array[i])) { |
| 82 | data->delta_gain_code[i] = 0; |
| 83 | continue; |
| 84 | } |
| 85 | |
Wey-Yi Guy | 7cb1b08 | 2010-10-06 08:10:00 -0700 | [diff] [blame] | 86 | delta_g = (priv->cfg->base_params->chain_noise_scale * |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 87 | ((s32)average_noise[default_chain] - |
| 88 | (s32)average_noise[i])) / 1500; |
| 89 | |
| 90 | /* bound gain by 2 bits value max, 3rd bit is sign */ |
| 91 | data->delta_gain_code[i] = |
| 92 | min(abs(delta_g), (long) CHAIN_NOISE_MAX_DELTA_GAIN_CODE); |
| 93 | |
| 94 | if (delta_g < 0) |
| 95 | /* |
| 96 | * set negative sign ... |
| 97 | * note to Intel developers: This is uCode API format, |
| 98 | * not the format of any internal device registers. |
| 99 | * Do not change this format for e.g. 6050 or similar |
| 100 | * devices. Change format only if more resolution |
| 101 | * (i.e. more than 2 bits magnitude) is needed. |
| 102 | */ |
| 103 | data->delta_gain_code[i] |= (1 << 2); |
| 104 | } |
| 105 | |
| 106 | IWL_DEBUG_CALIB(priv, "Delta gains: ANT_B = %d ANT_C = %d\n", |
| 107 | data->delta_gain_code[1], data->delta_gain_code[2]); |
| 108 | |
| 109 | if (!data->radio_write) { |
| 110 | struct iwl_calib_chain_noise_gain_cmd cmd; |
| 111 | |
| 112 | memset(&cmd, 0, sizeof(cmd)); |
| 113 | |
Wey-Yi Guy | 6a822d0 | 2010-07-13 17:13:15 -0700 | [diff] [blame] | 114 | cmd.hdr.op_code = priv->_agn.phy_calib_chain_noise_gain_cmd; |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 115 | cmd.hdr.first_group = 0; |
| 116 | cmd.hdr.groups_num = 1; |
| 117 | cmd.hdr.data_valid = 1; |
| 118 | cmd.delta_gain_1 = data->delta_gain_code[1]; |
| 119 | cmd.delta_gain_2 = data->delta_gain_code[2]; |
| 120 | iwl_send_cmd_pdu_async(priv, REPLY_PHY_CALIBRATION_CMD, |
| 121 | sizeof(cmd), &cmd, NULL); |
| 122 | |
| 123 | data->radio_write = 1; |
| 124 | data->state = IWL_CHAIN_NOISE_CALIBRATED; |
| 125 | } |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 126 | } |
| 127 | |
| 128 | static void iwlagn_chain_noise_reset(struct iwl_priv *priv) |
| 129 | { |
| 130 | struct iwl_chain_noise_data *data = &priv->chain_noise_data; |
| 131 | int ret; |
| 132 | |
Shanyu Zhao | f430844 | 2010-05-11 15:25:03 -0700 | [diff] [blame] | 133 | if ((data->state == IWL_CHAIN_NOISE_ALIVE) && |
Johannes Berg | 246ed35 | 2010-08-23 10:46:32 +0200 | [diff] [blame] | 134 | iwl_is_any_associated(priv)) { |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 135 | struct iwl_calib_chain_noise_reset_cmd cmd; |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 136 | |
Shanyu Zhao | f430844 | 2010-05-11 15:25:03 -0700 | [diff] [blame] | 137 | /* clear data for chain noise calibration algorithm */ |
| 138 | data->chain_noise_a = 0; |
| 139 | data->chain_noise_b = 0; |
| 140 | data->chain_noise_c = 0; |
| 141 | data->chain_signal_a = 0; |
| 142 | data->chain_signal_b = 0; |
| 143 | data->chain_signal_c = 0; |
| 144 | data->beacon_count = 0; |
| 145 | |
| 146 | memset(&cmd, 0, sizeof(cmd)); |
Wey-Yi Guy | 6a822d0 | 2010-07-13 17:13:15 -0700 | [diff] [blame] | 147 | cmd.hdr.op_code = priv->_agn.phy_calib_chain_noise_reset_cmd; |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 148 | cmd.hdr.first_group = 0; |
| 149 | cmd.hdr.groups_num = 1; |
| 150 | cmd.hdr.data_valid = 1; |
| 151 | ret = iwl_send_cmd_pdu(priv, REPLY_PHY_CALIBRATION_CMD, |
| 152 | sizeof(cmd), &cmd); |
| 153 | if (ret) |
| 154 | IWL_ERR(priv, |
| 155 | "Could not send REPLY_PHY_CALIBRATION_CMD\n"); |
| 156 | data->state = IWL_CHAIN_NOISE_ACCUMULATE; |
| 157 | IWL_DEBUG_CALIB(priv, "Run chain_noise_calibrate\n"); |
| 158 | } |
| 159 | } |
| 160 | |
Johannes Berg | 94597ab | 2010-08-09 10:57:02 -0700 | [diff] [blame] | 161 | static void iwlagn_tx_cmd_protection(struct iwl_priv *priv, |
| 162 | struct ieee80211_tx_info *info, |
| 163 | __le16 fc, __le32 *tx_flags) |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 164 | { |
Johannes Berg | 94597ab | 2010-08-09 10:57:02 -0700 | [diff] [blame] | 165 | if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS || |
Stanislaw Gruszka | 42b70a5 | 2011-05-26 17:14:22 +0200 | [diff] [blame] | 166 | info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT || |
| 167 | info->flags & IEEE80211_TX_CTL_AMPDU) |
Johannes Berg | 94597ab | 2010-08-09 10:57:02 -0700 | [diff] [blame] | 168 | *tx_flags |= TX_CMD_FLG_PROT_REQUIRE_MSK; |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 169 | } |
| 170 | |
| 171 | /* Calc max signal level (dBm) among 3 possible receivers */ |
| 172 | static int iwlagn_calc_rssi(struct iwl_priv *priv, |
| 173 | struct iwl_rx_phy_res *rx_resp) |
| 174 | { |
| 175 | /* data from PHY/DSP regarding signal strength, etc., |
| 176 | * contents are always there, not configurable by host |
| 177 | */ |
Wey-Yi Guy | 7ccc896 | 2010-08-04 08:42:17 -0700 | [diff] [blame] | 178 | struct iwlagn_non_cfg_phy *ncphy = |
| 179 | (struct iwlagn_non_cfg_phy *)rx_resp->non_cfg_phy_buf; |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 180 | u32 val, rssi_a, rssi_b, rssi_c, max_rssi; |
| 181 | u8 agc; |
| 182 | |
Wey-Yi Guy | 7ccc896 | 2010-08-04 08:42:17 -0700 | [diff] [blame] | 183 | val = le32_to_cpu(ncphy->non_cfg_phy[IWLAGN_RX_RES_AGC_IDX]); |
| 184 | agc = (val & IWLAGN_OFDM_AGC_MSK) >> IWLAGN_OFDM_AGC_BIT_POS; |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 185 | |
| 186 | /* Find max rssi among 3 possible receivers. |
| 187 | * These values are measured by the digital signal processor (DSP). |
| 188 | * They should stay fairly constant even as the signal strength varies, |
| 189 | * if the radio's automatic gain control (AGC) is working right. |
| 190 | * AGC value (see below) will provide the "interesting" info. |
| 191 | */ |
Wey-Yi Guy | 7ccc896 | 2010-08-04 08:42:17 -0700 | [diff] [blame] | 192 | val = le32_to_cpu(ncphy->non_cfg_phy[IWLAGN_RX_RES_RSSI_AB_IDX]); |
| 193 | rssi_a = (val & IWLAGN_OFDM_RSSI_INBAND_A_BITMSK) >> |
| 194 | IWLAGN_OFDM_RSSI_A_BIT_POS; |
| 195 | rssi_b = (val & IWLAGN_OFDM_RSSI_INBAND_B_BITMSK) >> |
| 196 | IWLAGN_OFDM_RSSI_B_BIT_POS; |
| 197 | val = le32_to_cpu(ncphy->non_cfg_phy[IWLAGN_RX_RES_RSSI_C_IDX]); |
| 198 | rssi_c = (val & IWLAGN_OFDM_RSSI_INBAND_C_BITMSK) >> |
| 199 | IWLAGN_OFDM_RSSI_C_BIT_POS; |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 200 | |
| 201 | max_rssi = max_t(u32, rssi_a, rssi_b); |
| 202 | max_rssi = max_t(u32, max_rssi, rssi_c); |
| 203 | |
| 204 | IWL_DEBUG_STATS(priv, "Rssi In A %d B %d C %d Max %d AGC dB %d\n", |
| 205 | rssi_a, rssi_b, rssi_c, max_rssi, agc); |
| 206 | |
| 207 | /* dBm = max_rssi dB - agc dB - constant. |
| 208 | * Higher AGC (higher radio gain) means lower signal. */ |
Wey-Yi Guy | b744cb7 | 2010-03-23 11:37:59 -0700 | [diff] [blame] | 209 | return max_rssi - agc - IWLAGN_RSSI_OFFSET; |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 210 | } |
| 211 | |
Johannes Berg | 52a02d1 | 2010-08-27 09:44:50 -0700 | [diff] [blame] | 212 | static int iwlagn_set_pan_params(struct iwl_priv *priv) |
| 213 | { |
| 214 | struct iwl_wipan_params_cmd cmd; |
| 215 | struct iwl_rxon_context *ctx_bss, *ctx_pan; |
| 216 | int slot0 = 300, slot1 = 0; |
| 217 | int ret; |
| 218 | |
| 219 | if (priv->valid_contexts == BIT(IWL_RXON_CTX_BSS)) |
| 220 | return 0; |
| 221 | |
| 222 | BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2); |
| 223 | |
| 224 | lockdep_assert_held(&priv->mutex); |
| 225 | |
| 226 | ctx_bss = &priv->contexts[IWL_RXON_CTX_BSS]; |
| 227 | ctx_pan = &priv->contexts[IWL_RXON_CTX_PAN]; |
| 228 | |
Johannes Berg | 763cc3b | 2010-09-03 06:32:21 -0700 | [diff] [blame] | 229 | /* |
| 230 | * If the PAN context is inactive, then we don't need |
| 231 | * to update the PAN parameters, the last thing we'll |
| 232 | * have done before it goes inactive is making the PAN |
| 233 | * parameters be WLAN-only. |
| 234 | */ |
| 235 | if (!ctx_pan->is_active) |
| 236 | return 0; |
| 237 | |
Johannes Berg | 52a02d1 | 2010-08-27 09:44:50 -0700 | [diff] [blame] | 238 | memset(&cmd, 0, sizeof(cmd)); |
| 239 | |
| 240 | /* only 2 slots are currently allowed */ |
| 241 | cmd.num_slots = 2; |
| 242 | |
| 243 | cmd.slots[0].type = 0; /* BSS */ |
| 244 | cmd.slots[1].type = 1; /* PAN */ |
| 245 | |
Johannes Berg | 9b9190d | 2011-01-06 08:07:10 -0800 | [diff] [blame] | 246 | if (priv->_agn.hw_roc_channel) { |
| 247 | /* both contexts must be used for this to happen */ |
| 248 | slot1 = priv->_agn.hw_roc_duration; |
Johannes Berg | 9407391 | 2011-01-06 08:07:11 -0800 | [diff] [blame] | 249 | slot0 = IWL_MIN_SLOT_TIME; |
Johannes Berg | 9b9190d | 2011-01-06 08:07:10 -0800 | [diff] [blame] | 250 | } else if (ctx_bss->vif && ctx_pan->vif) { |
Johannes Berg | 52a02d1 | 2010-08-27 09:44:50 -0700 | [diff] [blame] | 251 | int bcnint = ctx_pan->vif->bss_conf.beacon_int; |
Johannes Berg | efe54db | 2010-11-10 18:25:49 -0800 | [diff] [blame] | 252 | int dtim = ctx_pan->vif->bss_conf.dtim_period ?: 1; |
Johannes Berg | 52a02d1 | 2010-08-27 09:44:50 -0700 | [diff] [blame] | 253 | |
| 254 | /* should be set, but seems unused?? */ |
| 255 | cmd.flags |= cpu_to_le16(IWL_WIPAN_PARAMS_FLG_SLOTTED_MODE); |
| 256 | |
| 257 | if (ctx_pan->vif->type == NL80211_IFTYPE_AP && |
| 258 | bcnint && |
| 259 | bcnint != ctx_bss->vif->bss_conf.beacon_int) { |
| 260 | IWL_ERR(priv, |
| 261 | "beacon intervals don't match (%d, %d)\n", |
| 262 | ctx_bss->vif->bss_conf.beacon_int, |
| 263 | ctx_pan->vif->bss_conf.beacon_int); |
| 264 | } else |
| 265 | bcnint = max_t(int, bcnint, |
| 266 | ctx_bss->vif->bss_conf.beacon_int); |
| 267 | if (!bcnint) |
Johannes Berg | ea196fd | 2010-09-03 06:30:55 -0700 | [diff] [blame] | 268 | bcnint = DEFAULT_BEACON_INTERVAL; |
Johannes Berg | 52a02d1 | 2010-08-27 09:44:50 -0700 | [diff] [blame] | 269 | slot0 = bcnint / 2; |
| 270 | slot1 = bcnint - slot0; |
| 271 | |
| 272 | if (test_bit(STATUS_SCAN_HW, &priv->status) || |
| 273 | (!ctx_bss->vif->bss_conf.idle && |
| 274 | !ctx_bss->vif->bss_conf.assoc)) { |
Johannes Berg | 9407391 | 2011-01-06 08:07:11 -0800 | [diff] [blame] | 275 | slot0 = dtim * bcnint * 3 - IWL_MIN_SLOT_TIME; |
| 276 | slot1 = IWL_MIN_SLOT_TIME; |
Johannes Berg | 52a02d1 | 2010-08-27 09:44:50 -0700 | [diff] [blame] | 277 | } else if (!ctx_pan->vif->bss_conf.idle && |
Johannes Berg | efe54db | 2010-11-10 18:25:49 -0800 | [diff] [blame] | 278 | !ctx_pan->vif->bss_conf.assoc) { |
Johannes Berg | 9407391 | 2011-01-06 08:07:11 -0800 | [diff] [blame] | 279 | slot1 = bcnint * 3 - IWL_MIN_SLOT_TIME; |
| 280 | slot0 = IWL_MIN_SLOT_TIME; |
Johannes Berg | 52a02d1 | 2010-08-27 09:44:50 -0700 | [diff] [blame] | 281 | } |
| 282 | } else if (ctx_pan->vif) { |
| 283 | slot0 = 0; |
| 284 | slot1 = max_t(int, 1, ctx_pan->vif->bss_conf.dtim_period) * |
| 285 | ctx_pan->vif->bss_conf.beacon_int; |
Johannes Berg | ea196fd | 2010-09-03 06:30:55 -0700 | [diff] [blame] | 286 | slot1 = max_t(int, DEFAULT_BEACON_INTERVAL, slot1); |
Johannes Berg | 27eafdd | 2010-08-30 06:12:00 -0700 | [diff] [blame] | 287 | |
| 288 | if (test_bit(STATUS_SCAN_HW, &priv->status)) { |
Johannes Berg | 9407391 | 2011-01-06 08:07:11 -0800 | [diff] [blame] | 289 | slot0 = slot1 * 3 - IWL_MIN_SLOT_TIME; |
| 290 | slot1 = IWL_MIN_SLOT_TIME; |
Johannes Berg | 27eafdd | 2010-08-30 06:12:00 -0700 | [diff] [blame] | 291 | } |
Johannes Berg | 52a02d1 | 2010-08-27 09:44:50 -0700 | [diff] [blame] | 292 | } |
| 293 | |
| 294 | cmd.slots[0].width = cpu_to_le16(slot0); |
| 295 | cmd.slots[1].width = cpu_to_le16(slot1); |
| 296 | |
| 297 | ret = iwl_send_cmd_pdu(priv, REPLY_WIPAN_PARAMS, sizeof(cmd), &cmd); |
| 298 | if (ret) |
| 299 | IWL_ERR(priv, "Error setting PAN parameters (%d)\n", ret); |
| 300 | |
| 301 | return ret; |
| 302 | } |
| 303 | |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 304 | struct iwl_hcmd_ops iwlagn_hcmd = { |
Johannes Berg | 7314c2b | 2010-09-22 18:01:55 +0200 | [diff] [blame] | 305 | .commit_rxon = iwlagn_commit_rxon, |
Johannes Berg | 5de3306 | 2010-09-22 18:01:58 +0200 | [diff] [blame] | 306 | .set_rxon_chain = iwlagn_set_rxon_chain, |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 307 | .set_tx_ant = iwlagn_send_tx_ant_config, |
Johannes Berg | 65b52bd | 2010-04-13 01:04:31 -0700 | [diff] [blame] | 308 | .send_bt_config = iwl_send_bt_config, |
Johannes Berg | 52a02d1 | 2010-08-27 09:44:50 -0700 | [diff] [blame] | 309 | .set_pan_params = iwlagn_set_pan_params, |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 310 | }; |
| 311 | |
Wey-Yi Guy | b6e116e | 2010-08-23 07:57:14 -0700 | [diff] [blame] | 312 | struct iwl_hcmd_ops iwlagn_bt_hcmd = { |
Johannes Berg | 7314c2b | 2010-09-22 18:01:55 +0200 | [diff] [blame] | 313 | .commit_rxon = iwlagn_commit_rxon, |
Johannes Berg | 5de3306 | 2010-09-22 18:01:58 +0200 | [diff] [blame] | 314 | .set_rxon_chain = iwlagn_set_rxon_chain, |
Wey-Yi Guy | b6e116e | 2010-08-23 07:57:14 -0700 | [diff] [blame] | 315 | .set_tx_ant = iwlagn_send_tx_ant_config, |
| 316 | .send_bt_config = iwlagn_send_advance_bt_config, |
Johannes Berg | 52a02d1 | 2010-08-27 09:44:50 -0700 | [diff] [blame] | 317 | .set_pan_params = iwlagn_set_pan_params, |
Wey-Yi Guy | b6e116e | 2010-08-23 07:57:14 -0700 | [diff] [blame] | 318 | }; |
| 319 | |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 320 | struct iwl_hcmd_utils_ops iwlagn_hcmd_utils = { |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 321 | .build_addsta_hcmd = iwlagn_build_addsta_hcmd, |
| 322 | .gain_computation = iwlagn_gain_computation, |
| 323 | .chain_noise_reset = iwlagn_chain_noise_reset, |
Johannes Berg | 94597ab | 2010-08-09 10:57:02 -0700 | [diff] [blame] | 324 | .tx_cmd_protection = iwlagn_tx_cmd_protection, |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 325 | .calc_rssi = iwlagn_calc_rssi, |
Johannes Berg | b6e4c55 | 2010-04-06 04:12:42 -0700 | [diff] [blame] | 326 | .request_scan = iwlagn_request_scan, |
Johannes Berg | a77029e | 2010-09-22 18:01:56 +0200 | [diff] [blame] | 327 | .post_scan = iwlagn_post_scan, |
Wey-Yi Guy | 7dc77db | 2010-03-16 10:23:31 -0700 | [diff] [blame] | 328 | }; |