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

https://bitbucket.org/wisechild/galaxy-nexus · C · 328 lines · 219 code · 46 blank · 63 comment · 29 complexity · 629c0575ce6f6116d5a39074f7b4302b MD5 · raw file

  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. #include <linux/kernel.h>
  30. #include <linux/module.h>
  31. #include <linux/init.h>
  32. #include <linux/sched.h>
  33. #include "iwl-dev.h"
  34. #include "iwl-core.h"
  35. #include "iwl-io.h"
  36. #include "iwl-agn.h"
  37. int iwlagn_send_tx_ant_config(struct iwl_priv *priv, u8 valid_tx_ant)
  38. {
  39. struct iwl_tx_ant_config_cmd tx_ant_cmd = {
  40. .valid = cpu_to_le32(valid_tx_ant),
  41. };
  42. if (IWL_UCODE_API(priv->ucode_ver) > 1) {
  43. IWL_DEBUG_HC(priv, "select valid tx ant: %u\n", valid_tx_ant);
  44. return iwl_send_cmd_pdu(priv, TX_ANT_CONFIGURATION_CMD,
  45. sizeof(struct iwl_tx_ant_config_cmd),
  46. &tx_ant_cmd);
  47. } else {
  48. IWL_DEBUG_HC(priv, "TX_ANT_CONFIGURATION_CMD not supported\n");
  49. return -EOPNOTSUPP;
  50. }
  51. }
  52. static u16 iwlagn_build_addsta_hcmd(const struct iwl_addsta_cmd *cmd, u8 *data)
  53. {
  54. u16 size = (u16)sizeof(struct iwl_addsta_cmd);
  55. struct iwl_addsta_cmd *addsta = (struct iwl_addsta_cmd *)data;
  56. memcpy(addsta, cmd, size);
  57. /* resrved in 5000 */
  58. addsta->rate_n_flags = cpu_to_le16(0);
  59. return size;
  60. }
  61. static void iwlagn_gain_computation(struct iwl_priv *priv,
  62. u32 average_noise[NUM_RX_CHAINS],
  63. u16 min_average_noise_antenna_i,
  64. u32 min_average_noise,
  65. u8 default_chain)
  66. {
  67. int i;
  68. s32 delta_g;
  69. struct iwl_chain_noise_data *data = &priv->chain_noise_data;
  70. /*
  71. * Find Gain Code for the chains based on "default chain"
  72. */
  73. for (i = default_chain + 1; i < NUM_RX_CHAINS; i++) {
  74. if ((data->disconn_array[i])) {
  75. data->delta_gain_code[i] = 0;
  76. continue;
  77. }
  78. delta_g = (priv->cfg->base_params->chain_noise_scale *
  79. ((s32)average_noise[default_chain] -
  80. (s32)average_noise[i])) / 1500;
  81. /* bound gain by 2 bits value max, 3rd bit is sign */
  82. data->delta_gain_code[i] =
  83. min(abs(delta_g), (long) CHAIN_NOISE_MAX_DELTA_GAIN_CODE);
  84. if (delta_g < 0)
  85. /*
  86. * set negative sign ...
  87. * note to Intel developers: This is uCode API format,
  88. * not the format of any internal device registers.
  89. * Do not change this format for e.g. 6050 or similar
  90. * devices. Change format only if more resolution
  91. * (i.e. more than 2 bits magnitude) is needed.
  92. */
  93. data->delta_gain_code[i] |= (1 << 2);
  94. }
  95. IWL_DEBUG_CALIB(priv, "Delta gains: ANT_B = %d ANT_C = %d\n",
  96. data->delta_gain_code[1], data->delta_gain_code[2]);
  97. if (!data->radio_write) {
  98. struct iwl_calib_chain_noise_gain_cmd cmd;
  99. memset(&cmd, 0, sizeof(cmd));
  100. cmd.hdr.op_code = priv->_agn.phy_calib_chain_noise_gain_cmd;
  101. cmd.hdr.first_group = 0;
  102. cmd.hdr.groups_num = 1;
  103. cmd.hdr.data_valid = 1;
  104. cmd.delta_gain_1 = data->delta_gain_code[1];
  105. cmd.delta_gain_2 = data->delta_gain_code[2];
  106. iwl_send_cmd_pdu_async(priv, REPLY_PHY_CALIBRATION_CMD,
  107. sizeof(cmd), &cmd, NULL);
  108. data->radio_write = 1;
  109. data->state = IWL_CHAIN_NOISE_CALIBRATED;
  110. }
  111. }
  112. static void iwlagn_chain_noise_reset(struct iwl_priv *priv)
  113. {
  114. struct iwl_chain_noise_data *data = &priv->chain_noise_data;
  115. int ret;
  116. if ((data->state == IWL_CHAIN_NOISE_ALIVE) &&
  117. iwl_is_any_associated(priv)) {
  118. struct iwl_calib_chain_noise_reset_cmd cmd;
  119. /* clear data for chain noise calibration algorithm */
  120. data->chain_noise_a = 0;
  121. data->chain_noise_b = 0;
  122. data->chain_noise_c = 0;
  123. data->chain_signal_a = 0;
  124. data->chain_signal_b = 0;
  125. data->chain_signal_c = 0;
  126. data->beacon_count = 0;
  127. memset(&cmd, 0, sizeof(cmd));
  128. cmd.hdr.op_code = priv->_agn.phy_calib_chain_noise_reset_cmd;
  129. cmd.hdr.first_group = 0;
  130. cmd.hdr.groups_num = 1;
  131. cmd.hdr.data_valid = 1;
  132. ret = iwl_send_cmd_pdu(priv, REPLY_PHY_CALIBRATION_CMD,
  133. sizeof(cmd), &cmd);
  134. if (ret)
  135. IWL_ERR(priv,
  136. "Could not send REPLY_PHY_CALIBRATION_CMD\n");
  137. data->state = IWL_CHAIN_NOISE_ACCUMULATE;
  138. IWL_DEBUG_CALIB(priv, "Run chain_noise_calibrate\n");
  139. }
  140. }
  141. static void iwlagn_tx_cmd_protection(struct iwl_priv *priv,
  142. struct ieee80211_tx_info *info,
  143. __le16 fc, __le32 *tx_flags)
  144. {
  145. if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS ||
  146. info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT ||
  147. info->flags & IEEE80211_TX_CTL_AMPDU)
  148. *tx_flags |= TX_CMD_FLG_PROT_REQUIRE_MSK;
  149. }
  150. /* Calc max signal level (dBm) among 3 possible receivers */
  151. static int iwlagn_calc_rssi(struct iwl_priv *priv,
  152. struct iwl_rx_phy_res *rx_resp)
  153. {
  154. /* data from PHY/DSP regarding signal strength, etc.,
  155. * contents are always there, not configurable by host
  156. */
  157. struct iwlagn_non_cfg_phy *ncphy =
  158. (struct iwlagn_non_cfg_phy *)rx_resp->non_cfg_phy_buf;
  159. u32 val, rssi_a, rssi_b, rssi_c, max_rssi;
  160. u8 agc;
  161. val = le32_to_cpu(ncphy->non_cfg_phy[IWLAGN_RX_RES_AGC_IDX]);
  162. agc = (val & IWLAGN_OFDM_AGC_MSK) >> IWLAGN_OFDM_AGC_BIT_POS;
  163. /* Find max rssi among 3 possible receivers.
  164. * These values are measured by the digital signal processor (DSP).
  165. * They should stay fairly constant even as the signal strength varies,
  166. * if the radio's automatic gain control (AGC) is working right.
  167. * AGC value (see below) will provide the "interesting" info.
  168. */
  169. val = le32_to_cpu(ncphy->non_cfg_phy[IWLAGN_RX_RES_RSSI_AB_IDX]);
  170. rssi_a = (val & IWLAGN_OFDM_RSSI_INBAND_A_BITMSK) >>
  171. IWLAGN_OFDM_RSSI_A_BIT_POS;
  172. rssi_b = (val & IWLAGN_OFDM_RSSI_INBAND_B_BITMSK) >>
  173. IWLAGN_OFDM_RSSI_B_BIT_POS;
  174. val = le32_to_cpu(ncphy->non_cfg_phy[IWLAGN_RX_RES_RSSI_C_IDX]);
  175. rssi_c = (val & IWLAGN_OFDM_RSSI_INBAND_C_BITMSK) >>
  176. IWLAGN_OFDM_RSSI_C_BIT_POS;
  177. max_rssi = max_t(u32, rssi_a, rssi_b);
  178. max_rssi = max_t(u32, max_rssi, rssi_c);
  179. IWL_DEBUG_STATS(priv, "Rssi In A %d B %d C %d Max %d AGC dB %d\n",
  180. rssi_a, rssi_b, rssi_c, max_rssi, agc);
  181. /* dBm = max_rssi dB - agc dB - constant.
  182. * Higher AGC (higher radio gain) means lower signal. */
  183. return max_rssi - agc - IWLAGN_RSSI_OFFSET;
  184. }
  185. static int iwlagn_set_pan_params(struct iwl_priv *priv)
  186. {
  187. struct iwl_wipan_params_cmd cmd;
  188. struct iwl_rxon_context *ctx_bss, *ctx_pan;
  189. int slot0 = 300, slot1 = 0;
  190. int ret;
  191. if (priv->valid_contexts == BIT(IWL_RXON_CTX_BSS))
  192. return 0;
  193. BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
  194. lockdep_assert_held(&priv->mutex);
  195. ctx_bss = &priv->contexts[IWL_RXON_CTX_BSS];
  196. ctx_pan = &priv->contexts[IWL_RXON_CTX_PAN];
  197. /*
  198. * If the PAN context is inactive, then we don't need
  199. * to update the PAN parameters, the last thing we'll
  200. * have done before it goes inactive is making the PAN
  201. * parameters be WLAN-only.
  202. */
  203. if (!ctx_pan->is_active)
  204. return 0;
  205. memset(&cmd, 0, sizeof(cmd));
  206. /* only 2 slots are currently allowed */
  207. cmd.num_slots = 2;
  208. cmd.slots[0].type = 0; /* BSS */
  209. cmd.slots[1].type = 1; /* PAN */
  210. if (priv->_agn.hw_roc_channel) {
  211. /* both contexts must be used for this to happen */
  212. slot1 = priv->_agn.hw_roc_duration;
  213. slot0 = IWL_MIN_SLOT_TIME;
  214. } else if (ctx_bss->vif && ctx_pan->vif) {
  215. int bcnint = ctx_pan->vif->bss_conf.beacon_int;
  216. int dtim = ctx_pan->vif->bss_conf.dtim_period ?: 1;
  217. /* should be set, but seems unused?? */
  218. cmd.flags |= cpu_to_le16(IWL_WIPAN_PARAMS_FLG_SLOTTED_MODE);
  219. if (ctx_pan->vif->type == NL80211_IFTYPE_AP &&
  220. bcnint &&
  221. bcnint != ctx_bss->vif->bss_conf.beacon_int) {
  222. IWL_ERR(priv,
  223. "beacon intervals don't match (%d, %d)\n",
  224. ctx_bss->vif->bss_conf.beacon_int,
  225. ctx_pan->vif->bss_conf.beacon_int);
  226. } else
  227. bcnint = max_t(int, bcnint,
  228. ctx_bss->vif->bss_conf.beacon_int);
  229. if (!bcnint)
  230. bcnint = DEFAULT_BEACON_INTERVAL;
  231. slot0 = bcnint / 2;
  232. slot1 = bcnint - slot0;
  233. if (test_bit(STATUS_SCAN_HW, &priv->status) ||
  234. (!ctx_bss->vif->bss_conf.idle &&
  235. !ctx_bss->vif->bss_conf.assoc)) {
  236. slot0 = dtim * bcnint * 3 - IWL_MIN_SLOT_TIME;
  237. slot1 = IWL_MIN_SLOT_TIME;
  238. } else if (!ctx_pan->vif->bss_conf.idle &&
  239. !ctx_pan->vif->bss_conf.assoc) {
  240. slot1 = bcnint * 3 - IWL_MIN_SLOT_TIME;
  241. slot0 = IWL_MIN_SLOT_TIME;
  242. }
  243. } else if (ctx_pan->vif) {
  244. slot0 = 0;
  245. slot1 = max_t(int, 1, ctx_pan->vif->bss_conf.dtim_period) *
  246. ctx_pan->vif->bss_conf.beacon_int;
  247. slot1 = max_t(int, DEFAULT_BEACON_INTERVAL, slot1);
  248. if (test_bit(STATUS_SCAN_HW, &priv->status)) {
  249. slot0 = slot1 * 3 - IWL_MIN_SLOT_TIME;
  250. slot1 = IWL_MIN_SLOT_TIME;
  251. }
  252. }
  253. cmd.slots[0].width = cpu_to_le16(slot0);
  254. cmd.slots[1].width = cpu_to_le16(slot1);
  255. ret = iwl_send_cmd_pdu(priv, REPLY_WIPAN_PARAMS, sizeof(cmd), &cmd);
  256. if (ret)
  257. IWL_ERR(priv, "Error setting PAN parameters (%d)\n", ret);
  258. return ret;
  259. }
  260. struct iwl_hcmd_ops iwlagn_hcmd = {
  261. .commit_rxon = iwlagn_commit_rxon,
  262. .set_rxon_chain = iwlagn_set_rxon_chain,
  263. .set_tx_ant = iwlagn_send_tx_ant_config,
  264. .send_bt_config = iwl_send_bt_config,
  265. .set_pan_params = iwlagn_set_pan_params,
  266. };
  267. struct iwl_hcmd_ops iwlagn_bt_hcmd = {
  268. .commit_rxon = iwlagn_commit_rxon,
  269. .set_rxon_chain = iwlagn_set_rxon_chain,
  270. .set_tx_ant = iwlagn_send_tx_ant_config,
  271. .send_bt_config = iwlagn_send_advance_bt_config,
  272. .set_pan_params = iwlagn_set_pan_params,
  273. };
  274. struct iwl_hcmd_utils_ops iwlagn_hcmd_utils = {
  275. .build_addsta_hcmd = iwlagn_build_addsta_hcmd,
  276. .gain_computation = iwlagn_gain_computation,
  277. .chain_noise_reset = iwlagn_chain_noise_reset,
  278. .tx_cmd_protection = iwlagn_tx_cmd_protection,
  279. .calc_rssi = iwlagn_calc_rssi,
  280. .request_scan = iwlagn_request_scan,
  281. .post_scan = iwlagn_post_scan,
  282. };