drivers/net/wireless/intel/iwlwifi/dvm/ucode.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /******************************************************************************
   3  *
   4  * Copyright(c) 2008 - 2014 Intel Corporation. All rights reserved.
   5  * Copyright(c) 2015 Intel Deutschland GmbH
   6  *****************************************************************************/
   7
   8 #include <linux/kernel.h>
   9
  10 #include "iwl-io.h"
  11 #include "iwl-agn-hw.h"
  12 #include "iwl-trans.h"
  13 #include "iwl-fh.h"
  14 #include "iwl-op-mode.h"
  15
  16 #include "dev.h"
  17 #include "agn.h"
  18 #include "calib.h"
  19
  20 /******************************************************************************
  21  *
  22  * uCode download functions
  23  *
  24  ******************************************************************************/
  25
  26 /*
  27  *  Calibration
  28  */
  29 static int iwl_set_Xtal_calib(struct iwl_priv *priv)
  30 {
  31         struct iwl_calib_xtal_freq_cmd cmd;
  32         __le16 *xtal_calib = priv->nvm_data->xtal_calib;
  33
  34         iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_CRYSTAL_FRQ_CMD);
  35         cmd.cap_pin1 = le16_to_cpu(xtal_calib[0]);
  36         cmd.cap_pin2 = le16_to_cpu(xtal_calib[1]);
  37         return iwl_calib_set(priv, (void *)&cmd, sizeof(cmd));
  38 }
  39
  40 static int iwl_set_temperature_offset_calib(struct iwl_priv *priv)
  41 {
  42         struct iwl_calib_temperature_offset_cmd cmd;
  43
  44         memset(&cmd, 0, sizeof(cmd));
  45         iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_TEMP_OFFSET_CMD);
  46         cmd.radio_sensor_offset = priv->nvm_data->raw_temperature;
  47         if (!(cmd.radio_sensor_offset))
  48                 cmd.radio_sensor_offset = DEFAULT_RADIO_SENSOR_OFFSET;
  49
  50         IWL_DEBUG_CALIB(priv, "Radio sensor offset: %d\n",
  51                         le16_to_cpu(cmd.radio_sensor_offset));
  52         return iwl_calib_set(priv, (void *)&cmd, sizeof(cmd));
  53 }
  54
  55 static int iwl_set_temperature_offset_calib_v2(struct iwl_priv *priv)
  56 {
  57         struct iwl_calib_temperature_offset_v2_cmd cmd;
  58
  59         memset(&cmd, 0, sizeof(cmd));
  60         iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_TEMP_OFFSET_CMD);
  61         cmd.radio_sensor_offset_high = priv->nvm_data->kelvin_temperature;
  62         cmd.radio_sensor_offset_low = priv->nvm_data->raw_temperature;
  63         if (!cmd.radio_sensor_offset_low) {
  64                 IWL_DEBUG_CALIB(priv, "no info in EEPROM, use default\n");
  65                 cmd.radio_sensor_offset_low = DEFAULT_RADIO_SENSOR_OFFSET;
  66                 cmd.radio_sensor_offset_high = DEFAULT_RADIO_SENSOR_OFFSET;
  67         }
  68         cmd.burntVoltageRef = priv->nvm_data->calib_voltage;
  69
  70         IWL_DEBUG_CALIB(priv, "Radio sensor offset high: %d\n",
  71                         le16_to_cpu(cmd.radio_sensor_offset_high));
  72         IWL_DEBUG_CALIB(priv, "Radio sensor offset low: %d\n",
  73                         le16_to_cpu(cmd.radio_sensor_offset_low));
  74         IWL_DEBUG_CALIB(priv, "Voltage Ref: %d\n",
  75                         le16_to_cpu(cmd.burntVoltageRef));
  76
  77         return iwl_calib_set(priv, (void *)&cmd, sizeof(cmd));
  78 }
  79
  80 static int iwl_send_calib_cfg(struct iwl_priv *priv)
  81 {
  82         struct iwl_calib_cfg_cmd calib_cfg_cmd;
  83         struct iwl_host_cmd cmd = {
  84                 .id = CALIBRATION_CFG_CMD,
  85                 .len = { sizeof(struct iwl_calib_cfg_cmd), },
  86                 .data = { &calib_cfg_cmd, },
  87         };
  88
  89         memset(&calib_cfg_cmd, 0, sizeof(calib_cfg_cmd));
  90         calib_cfg_cmd.ucd_calib_cfg.once.is_enable = IWL_CALIB_INIT_CFG_ALL;
  91         calib_cfg_cmd.ucd_calib_cfg.once.start = IWL_CALIB_INIT_CFG_ALL;
  92         calib_cfg_cmd.ucd_calib_cfg.once.send_res = IWL_CALIB_INIT_CFG_ALL;
  93         calib_cfg_cmd.ucd_calib_cfg.flags =
  94                 IWL_CALIB_CFG_FLAG_SEND_COMPLETE_NTFY_MSK;
  95
  96         return iwl_dvm_send_cmd(priv, &cmd);
  97 }
  98
  99 int iwl_init_alive_start(struct iwl_priv *priv)
 100 {
 101         int ret;
 102
 103         if (priv->lib->bt_params &&
 104             priv->lib->bt_params->advanced_bt_coexist) {
 105                 /*
 106                  * Tell uCode we are ready to perform calibration
 107                  * need to perform this before any calibration
 108                  * no need to close the envlope since we are going
 109                  * to load the runtime uCode later.
 110                  */
 111                 ret = iwl_send_bt_env(priv, IWL_BT_COEX_ENV_OPEN,
 112                         BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
 113                 if (ret)
 114                         return ret;
 115
 116         }
 117
 118         ret = iwl_send_calib_cfg(priv);
 119         if (ret)
 120                 return ret;
 121
 122         /**
 123          * temperature offset calibration is only needed for runtime ucode,
 124          * so prepare the value now.
 125          */
 126         if (priv->lib->need_temp_offset_calib) {
 127                 if (priv->lib->temp_offset_v2)
 128                         return iwl_set_temperature_offset_calib_v2(priv);
 129                 else
 130                         return iwl_set_temperature_offset_calib(priv);
 131         }
 132
 133         return 0;
 134 }
 135
 136 static int iwl_send_wimax_coex(struct iwl_priv *priv)
 137 {
 138         struct iwl_wimax_coex_cmd coex_cmd;
 139
 140         /* coexistence is disabled */
 141         memset(&coex_cmd, 0, sizeof(coex_cmd));
 142
 143         return iwl_dvm_send_cmd_pdu(priv,
 144                                 COEX_PRIORITY_TABLE_CMD, 0,
 145                                 sizeof(coex_cmd), &coex_cmd);
 146 }
 147
 148 static const u8 iwl_bt_prio_tbl[BT_COEX_PRIO_TBL_EVT_MAX] = {
 149         ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 150                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 151         ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 152                 (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 153         ((BT_COEX_PRIO_TBL_PRIO_LOW << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 154                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 155         ((BT_COEX_PRIO_TBL_PRIO_LOW << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 156                 (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 157         ((BT_COEX_PRIO_TBL_PRIO_HIGH << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 158                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 159         ((BT_COEX_PRIO_TBL_PRIO_HIGH << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 160                 (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 161         ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 162                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 163         ((BT_COEX_PRIO_TBL_PRIO_COEX_OFF << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 164                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 165         ((BT_COEX_PRIO_TBL_PRIO_COEX_ON << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 166                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 167         0, 0, 0, 0, 0, 0, 0
 168 };
 169
 170 void iwl_send_prio_tbl(struct iwl_priv *priv)
 171 {
 172         struct iwl_bt_coex_prio_table_cmd prio_tbl_cmd;
 173
 174         memcpy(prio_tbl_cmd.prio_tbl, iwl_bt_prio_tbl,
 175                 sizeof(iwl_bt_prio_tbl));
 176         if (iwl_dvm_send_cmd_pdu(priv,
 177                                 REPLY_BT_COEX_PRIO_TABLE, 0,
 178                                 sizeof(prio_tbl_cmd), &prio_tbl_cmd))
 179                 IWL_ERR(priv, "failed to send BT prio tbl command\n");
 180 }
 181
 182 int iwl_send_bt_env(struct iwl_priv *priv, u8 action, u8 type)
 183 {
 184         struct iwl_bt_coex_prot_env_cmd env_cmd;
 185         int ret;
 186
 187         env_cmd.action = action;
 188         env_cmd.type = type;
 189         ret = iwl_dvm_send_cmd_pdu(priv,
 190                                REPLY_BT_COEX_PROT_ENV, 0,
 191                                sizeof(env_cmd), &env_cmd);
 192         if (ret)
 193                 IWL_ERR(priv, "failed to send BT env command\n");
 194         return ret;
 195 }
 196
 197 static const u8 iwlagn_default_queue_to_tx_fifo[] = {
 198         IWL_TX_FIFO_VO,
 199         IWL_TX_FIFO_VI,
 200         IWL_TX_FIFO_BE,
 201         IWL_TX_FIFO_BK,
 202 };
 203
 204 static const u8 iwlagn_ipan_queue_to_tx_fifo[] = {
 205         IWL_TX_FIFO_VO,
 206         IWL_TX_FIFO_VI,
 207         IWL_TX_FIFO_BE,
 208         IWL_TX_FIFO_BK,
 209         IWL_TX_FIFO_BK_IPAN,
 210         IWL_TX_FIFO_BE_IPAN,
 211         IWL_TX_FIFO_VI_IPAN,
 212         IWL_TX_FIFO_VO_IPAN,
 213         IWL_TX_FIFO_BE_IPAN,
 214         IWL_TX_FIFO_UNUSED,
 215         IWL_TX_FIFO_AUX,
 216 };
 217
 218 static int iwl_alive_notify(struct iwl_priv *priv)
 219 {
 220         const u8 *queue_to_txf;
 221         u8 n_queues;
 222         int ret;
 223         int i;
 224
 225         iwl_trans_fw_alive(priv->trans, 0);
 226
 227         if (priv->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_PAN &&
 228             priv->nvm_data->sku_cap_ipan_enable) {
 229                 n_queues = ARRAY_SIZE(iwlagn_ipan_queue_to_tx_fifo);
 230                 queue_to_txf = iwlagn_ipan_queue_to_tx_fifo;
 231         } else {
 232                 n_queues = ARRAY_SIZE(iwlagn_default_queue_to_tx_fifo);
 233                 queue_to_txf = iwlagn_default_queue_to_tx_fifo;
 234         }
 235
 236         for (i = 0; i < n_queues; i++)
 237                 if (queue_to_txf[i] != IWL_TX_FIFO_UNUSED)
 238                         iwl_trans_ac_txq_enable(priv->trans, i,
 239                                                 queue_to_txf[i], 0);
 240
 241         priv->passive_no_rx = false;
 242         priv->transport_queue_stop = 0;
 243
 244         ret = iwl_send_wimax_coex(priv);
 245         if (ret)
 246                 return ret;
 247
 248         if (!priv->lib->no_xtal_calib) {
 249                 ret = iwl_set_Xtal_calib(priv);
 250                 if (ret)
 251                         return ret;
 252         }
 253
 254         return iwl_send_calib_results(priv);
 255 }
 256
 257 struct iwl_alive_data {
 258         bool valid;
 259         u8 subtype;
 260 };
 261
 262 static bool iwl_alive_fn(struct iwl_notif_wait_data *notif_wait,
 263                          struct iwl_rx_packet *pkt, void *data)
 264 {
 265         struct iwl_priv *priv =
 266                 container_of(notif_wait, struct iwl_priv, notif_wait);
 267         struct iwl_alive_data *alive_data = data;
 268         struct iwl_alive_resp *palive;
 269
 270         palive = (void *)pkt->data;
 271
 272         IWL_DEBUG_FW(priv, "Alive ucode status 0x%08X revision "
 273                        "0x%01X 0x%01X\n",
 274                        palive->is_valid, palive->ver_type,
 275                        palive->ver_subtype);
 276
 277         priv->device_pointers.error_event_table =
 278                 le32_to_cpu(palive->error_event_table_ptr);
 279         priv->device_pointers.log_event_table =
 280                 le32_to_cpu(palive->log_event_table_ptr);
 281
 282         alive_data->subtype = palive->ver_subtype;
 283         alive_data->valid = palive->is_valid == UCODE_VALID_OK;
 284
 285         return true;
 286 }
 287
 288 #define UCODE_ALIVE_TIMEOUT     HZ
 289 #define UCODE_CALIB_TIMEOUT     (2*HZ)
 290
 291 int iwl_load_ucode_wait_alive(struct iwl_priv *priv,
 292                                  enum iwl_ucode_type ucode_type)
 293 {
 294         struct iwl_notification_wait alive_wait;
 295         struct iwl_alive_data alive_data;
 296         const struct fw_img *fw;
 297         int ret;
 298         enum iwl_ucode_type old_type;
 299         static const u16 alive_cmd[] = { REPLY_ALIVE };
 300
 301         fw = iwl_get_ucode_image(priv->fw, ucode_type);
 302         if (WARN_ON(!fw))
 303                 return -EINVAL;
 304
 305         old_type = priv->cur_ucode;
 306         priv->cur_ucode = ucode_type;
 307         priv->ucode_loaded = false;
 308
 309         iwl_init_notification_wait(&priv->notif_wait, &alive_wait,
 310                                    alive_cmd, ARRAY_SIZE(alive_cmd),
 311                                    iwl_alive_fn, &alive_data);
 312
 313         ret = iwl_trans_start_fw(priv->trans, fw, false);
 314         if (ret) {
 315                 priv->cur_ucode = old_type;
 316                 iwl_remove_notification(&priv->notif_wait, &alive_wait);
 317                 return ret;
 318         }
 319
 320         /*
 321          * Some things may run in the background now, but we
 322          * just wait for the ALIVE notification here.
 323          */
 324         ret = iwl_wait_notification(&priv->notif_wait, &alive_wait,
 325                                         UCODE_ALIVE_TIMEOUT);
 326         if (ret) {
 327                 priv->cur_ucode = old_type;
 328                 return ret;
 329         }
 330
 331         if (!alive_data.valid) {
 332                 IWL_ERR(priv, "Loaded ucode is not valid!\n");
 333                 priv->cur_ucode = old_type;
 334                 return -EIO;
 335         }
 336
 337         priv->ucode_loaded = true;
 338
 339         if (ucode_type != IWL_UCODE_WOWLAN) {
 340                 /* delay a bit to give rfkill time to run */
 341                 msleep(5);
 342         }
 343
 344         ret = iwl_alive_notify(priv);
 345         if (ret) {
 346                 IWL_WARN(priv,
 347                         "Could not complete ALIVE transition: %d\n", ret);
 348                 priv->cur_ucode = old_type;
 349                 return ret;
 350         }
 351
 352         return 0;
 353 }
 354
 355 static bool iwlagn_wait_calib(struct iwl_notif_wait_data *notif_wait,
 356                               struct iwl_rx_packet *pkt, void *data)
 357 {
 358         struct iwl_priv *priv = data;
 359         struct iwl_calib_cmd *cmd;
 360
 361         if (pkt->hdr.cmd != CALIBRATION_RES_NOTIFICATION) {
 362                 WARN_ON(pkt->hdr.cmd != CALIBRATION_COMPLETE_NOTIFICATION);
 363                 return true;
 364         }
 365
 366         cmd = (struct iwl_calib_cmd *)pkt->data;
 367
 368         if (iwl_calib_set(priv, cmd, iwl_rx_packet_payload_len(pkt)))
 369                 IWL_ERR(priv, "Failed to record calibration data %d\n",
 370                         cmd->hdr.op_code);
 371
 372         return false;
 373 }
 374
 375 int iwl_run_init_ucode(struct iwl_priv *priv)
 376 {
 377         struct iwl_notification_wait calib_wait;
 378         static const u16 calib_complete[] = {
 379                 CALIBRATION_RES_NOTIFICATION,
 380                 CALIBRATION_COMPLETE_NOTIFICATION
 381         };
 382         int ret;
 383
 384         lockdep_assert_held(&priv->mutex);
 385
 386         /* No init ucode required? Curious, but maybe ok */
 387         if (!priv->fw->img[IWL_UCODE_INIT].num_sec)
 388                 return 0;
 389
 390         iwl_init_notification_wait(&priv->notif_wait, &calib_wait,
 391                                    calib_complete, ARRAY_SIZE(calib_complete),
 392                                    iwlagn_wait_calib, priv);
 393
 394         /* Will also start the device */
 395         ret = iwl_load_ucode_wait_alive(priv, IWL_UCODE_INIT);
 396         if (ret)
 397                 goto error;
 398
 399         ret = iwl_init_alive_start(priv);
 400         if (ret)
 401                 goto error;
 402
 403         /*
 404          * Some things may run in the background now, but we
 405          * just wait for the calibration complete notification.
 406          */
 407         ret = iwl_wait_notification(&priv->notif_wait, &calib_wait,
 408                                         UCODE_CALIB_TIMEOUT);
 409
 410         goto out;
 411
 412  error:
 413         iwl_remove_notification(&priv->notif_wait, &calib_wait);
 414  out:
 415         /* Whatever happened, stop the device */
 416         iwl_trans_stop_device(priv->trans);
 417         priv->ucode_loaded = false;
 418
 419         return ret;
 420 }