drivers/net/wireless/iwlwifi/iwl-agn-hcmd.c

   1 /******************************************************************************
   2  *
   3  * GPL LICENSE SUMMARY
   4  *
   5  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
   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"
  38 #include "iwl-agn.h"
  39
  40 int iwlagn_send_tx_ant_config(struct iwl_priv *priv, u8 valid_tx_ant)
  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
  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
  86                 delta_g = (priv->cfg->base_params->chain_noise_scale *
  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
 114                 cmd.hdr.op_code = priv->_agn.phy_calib_chain_noise_gain_cmd;
 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         }
 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
 133         if ((data->state == IWL_CHAIN_NOISE_ALIVE) &&
 134             iwl_is_any_associated(priv)) {
 135                 struct iwl_calib_chain_noise_reset_cmd cmd;
 136
 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));
 147                 cmd.hdr.op_code = priv->_agn.phy_calib_chain_noise_reset_cmd;
 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
 161 static void iwlagn_tx_cmd_protection(struct iwl_priv *priv,
 162                                      struct ieee80211_tx_info *info,
 163                                      __le16 fc, __le32 *tx_flags)
 164 {
 165         if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS ||
 166             info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT ||
 167             info->flags & IEEE80211_TX_CTL_AMPDU)
 168                 *tx_flags |= TX_CMD_FLG_PROT_REQUIRE_MSK;
 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          */
 178         struct iwlagn_non_cfg_phy *ncphy =
 179                 (struct iwlagn_non_cfg_phy *)rx_resp->non_cfg_phy_buf;
 180         u32 val, rssi_a, rssi_b, rssi_c, max_rssi;
 181         u8 agc;
 182
 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;
 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          */
 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;
 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. */
 209         return max_rssi - agc - IWLAGN_RSSI_OFFSET;
 210 }
 211
 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
 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
 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
 246         if (priv->_agn.hw_roc_channel) {
 247                 /* both contexts must be used for this to happen */
 248                 slot1 = priv->_agn.hw_roc_duration;
 249                 slot0 = IWL_MIN_SLOT_TIME;
 250         } else if (ctx_bss->vif && ctx_pan->vif) {
 251                 int bcnint = ctx_pan->vif->bss_conf.beacon_int;
 252                 int dtim = ctx_pan->vif->bss_conf.dtim_period ?: 1;
 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)
 268                         bcnint = DEFAULT_BEACON_INTERVAL;
 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)) {
 275                         slot0 = dtim * bcnint * 3 - IWL_MIN_SLOT_TIME;
 276                         slot1 = IWL_MIN_SLOT_TIME;
 277                 } else if (!ctx_pan->vif->bss_conf.idle &&
 278                            !ctx_pan->vif->bss_conf.assoc) {
 279                         slot1 = bcnint * 3 - IWL_MIN_SLOT_TIME;
 280                         slot0 = IWL_MIN_SLOT_TIME;
 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;
 286                 slot1 = max_t(int, DEFAULT_BEACON_INTERVAL, slot1);
 287
 288                 if (test_bit(STATUS_SCAN_HW, &priv->status)) {
 289                         slot0 = slot1 * 3 - IWL_MIN_SLOT_TIME;
 290                         slot1 = IWL_MIN_SLOT_TIME;
 291                 }
 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
 304 struct iwl_hcmd_ops iwlagn_hcmd = {
 305         .commit_rxon = iwlagn_commit_rxon,
 306         .set_rxon_chain = iwlagn_set_rxon_chain,
 307         .set_tx_ant = iwlagn_send_tx_ant_config,
 308         .send_bt_config = iwl_send_bt_config,
 309         .set_pan_params = iwlagn_set_pan_params,
 310 };
 311
 312 struct iwl_hcmd_ops iwlagn_bt_hcmd = {
 313         .commit_rxon = iwlagn_commit_rxon,
 314         .set_rxon_chain = iwlagn_set_rxon_chain,
 315         .set_tx_ant = iwlagn_send_tx_ant_config,
 316         .send_bt_config = iwlagn_send_advance_bt_config,
 317         .set_pan_params = iwlagn_set_pan_params,
 318 };
 319
 320 struct iwl_hcmd_utils_ops iwlagn_hcmd_utils = {
 321         .build_addsta_hcmd = iwlagn_build_addsta_hcmd,
 322         .gain_computation = iwlagn_gain_computation,
 323         .chain_noise_reset = iwlagn_chain_noise_reset,
 324         .tx_cmd_protection = iwlagn_tx_cmd_protection,
 325         .calc_rssi = iwlagn_calc_rssi,
 326         .request_scan = iwlagn_request_scan,
 327         .post_scan = iwlagn_post_scan,
 328 };