sys/contrib/dev/iwlwifi/mvm/fw.c

   1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
   2 /*
   3  * Copyright (C) 2012-2014, 2018-2022 Intel Corporation
   4  * Copyright (C) 2013-2015 Intel Mobile Communications GmbH
   5  * Copyright (C) 2016-2017 Intel Deutschland GmbH
   6  */
   7 #include <net/mac80211.h>
   8 #include <linux/netdevice.h>
   9 #include <linux/dmi.h>
  10
  11 #include "iwl-trans.h"
  12 #include "iwl-op-mode.h"
  13 #include "fw/img.h"
  14 #include "iwl-debug.h"
  15 #include "iwl-prph.h"
  16 #include "fw/acpi.h"
  17 #include "fw/pnvm.h"
  18
  19 #include "mvm.h"
  20 #include "fw/dbg.h"
  21 #include "iwl-phy-db.h"
  22 #include "iwl-modparams.h"
  23 #include "iwl-nvm-parse.h"
  24
  25 #define MVM_UCODE_ALIVE_TIMEOUT (HZ)
  26 #define MVM_UCODE_CALIB_TIMEOUT (2 * HZ)
  27
  28 #define IWL_PPAG_MASK 3
  29 #define IWL_PPAG_ETSI_MASK BIT(0)
  30
  31 #define IWL_TAS_US_MCC 0x5553
  32 #define IWL_TAS_CANADA_MCC 0x4341
  33
  34 struct iwl_mvm_alive_data {
  35         bool valid;
  36         u32 scd_base_addr;
  37 };
  38
  39 static int iwl_send_tx_ant_cfg(struct iwl_mvm *mvm, u8 valid_tx_ant)
  40 {
  41         struct iwl_tx_ant_cfg_cmd tx_ant_cmd = {
  42                 .valid = cpu_to_le32(valid_tx_ant),
  43         };
  44
  45         IWL_DEBUG_FW(mvm, "select valid tx ant: %u\n", valid_tx_ant);
  46         return iwl_mvm_send_cmd_pdu(mvm, TX_ANT_CONFIGURATION_CMD, 0,
  47                                     sizeof(tx_ant_cmd), &tx_ant_cmd);
  48 }
  49
  50 static int iwl_send_rss_cfg_cmd(struct iwl_mvm *mvm)
  51 {
  52         int i;
  53         struct iwl_rss_config_cmd cmd = {
  54                 .flags = cpu_to_le32(IWL_RSS_ENABLE),
  55                 .hash_mask = BIT(IWL_RSS_HASH_TYPE_IPV4_TCP) |
  56                              BIT(IWL_RSS_HASH_TYPE_IPV4_UDP) |
  57                              BIT(IWL_RSS_HASH_TYPE_IPV4_PAYLOAD) |
  58                              BIT(IWL_RSS_HASH_TYPE_IPV6_TCP) |
  59                              BIT(IWL_RSS_HASH_TYPE_IPV6_UDP) |
  60                              BIT(IWL_RSS_HASH_TYPE_IPV6_PAYLOAD),
  61         };
  62
  63         if (mvm->trans->num_rx_queues == 1)
  64                 return 0;
  65
  66         /* Do not direct RSS traffic to Q 0 which is our fallback queue */
  67         for (i = 0; i < ARRAY_SIZE(cmd.indirection_table); i++)
  68                 cmd.indirection_table[i] =
  69                         1 + (i % (mvm->trans->num_rx_queues - 1));
  70         netdev_rss_key_fill(cmd.secret_key, sizeof(cmd.secret_key));
  71
  72         return iwl_mvm_send_cmd_pdu(mvm, RSS_CONFIG_CMD, 0, sizeof(cmd), &cmd);
  73 }
  74
  75 static int iwl_mvm_send_dqa_cmd(struct iwl_mvm *mvm)
  76 {
  77         struct iwl_dqa_enable_cmd dqa_cmd = {
  78                 .cmd_queue = cpu_to_le32(IWL_MVM_DQA_CMD_QUEUE),
  79         };
  80         u32 cmd_id = WIDE_ID(DATA_PATH_GROUP, DQA_ENABLE_CMD);
  81         int ret;
  82
  83         ret = iwl_mvm_send_cmd_pdu(mvm, cmd_id, 0, sizeof(dqa_cmd), &dqa_cmd);
  84         if (ret)
  85                 IWL_ERR(mvm, "Failed to send DQA enabling command: %d\n", ret);
  86         else
  87                 IWL_DEBUG_FW(mvm, "Working in DQA mode\n");
  88
  89         return ret;
  90 }
  91
  92 void iwl_mvm_mfu_assert_dump_notif(struct iwl_mvm *mvm,
  93                                    struct iwl_rx_cmd_buffer *rxb)
  94 {
  95         struct iwl_rx_packet *pkt = rxb_addr(rxb);
  96         struct iwl_mfu_assert_dump_notif *mfu_dump_notif = (void *)pkt->data;
  97         __le32 *dump_data = mfu_dump_notif->data;
  98         int n_words = le32_to_cpu(mfu_dump_notif->data_size) / sizeof(__le32);
  99         int i;
 100
 101         if (mfu_dump_notif->index_num == 0)
 102                 IWL_INFO(mvm, "MFUART assert id 0x%x occurred\n",
 103                          le32_to_cpu(mfu_dump_notif->assert_id));
 104
 105         for (i = 0; i < n_words; i++)
 106                 IWL_DEBUG_INFO(mvm,
 107                                "MFUART assert dump, dword %u: 0x%08x\n",
 108                                le16_to_cpu(mfu_dump_notif->index_num) *
 109                                n_words + i,
 110                                le32_to_cpu(dump_data[i]));
 111 }
 112
 113 static bool iwl_alive_fn(struct iwl_notif_wait_data *notif_wait,
 114                          struct iwl_rx_packet *pkt, void *data)
 115 {
 116         unsigned int pkt_len = iwl_rx_packet_payload_len(pkt);
 117         struct iwl_mvm *mvm =
 118                 container_of(notif_wait, struct iwl_mvm, notif_wait);
 119         struct iwl_mvm_alive_data *alive_data = data;
 120         struct iwl_umac_alive *umac;
 121         struct iwl_lmac_alive *lmac1;
 122         struct iwl_lmac_alive *lmac2 = NULL;
 123         u16 status;
 124         u32 lmac_error_event_table, umac_error_table;
 125         u32 version = iwl_fw_lookup_notif_ver(mvm->fw, LEGACY_GROUP,
 126                                               UCODE_ALIVE_NTFY, 0);
 127
 128         if (version == 6) {
 129                 struct iwl_alive_ntf_v6 *palive;
 130
 131                 if (pkt_len < sizeof(*palive))
 132                         return false;
 133
 134                 palive = (void *)pkt->data;
 135                 mvm->trans->dbg.imr_data.imr_enable =
 136                         le32_to_cpu(palive->imr.enabled);
 137                 mvm->trans->dbg.imr_data.imr_size =
 138                         le32_to_cpu(palive->imr.size);
 139                 mvm->trans->dbg.imr_data.imr2sram_remainbyte =
 140                         mvm->trans->dbg.imr_data.imr_size;
 141                 mvm->trans->dbg.imr_data.imr_base_addr =
 142                         palive->imr.base_addr;
 143                 mvm->trans->dbg.imr_data.imr_curr_addr =
 144                         le64_to_cpu(mvm->trans->dbg.imr_data.imr_base_addr);
 145                 IWL_DEBUG_FW(mvm, "IMR Enabled: 0x0%x  size 0x0%x Address 0x%016llx\n",
 146                              mvm->trans->dbg.imr_data.imr_enable,
 147                              mvm->trans->dbg.imr_data.imr_size,
 148                              le64_to_cpu(mvm->trans->dbg.imr_data.imr_base_addr));
 149         }
 150
 151         if (version >= 5) {
 152                 struct iwl_alive_ntf_v5 *palive;
 153
 154                 if (pkt_len < sizeof(*palive))
 155                         return false;
 156
 157                 palive = (void *)pkt->data;
 158                 umac = &palive->umac_data;
 159                 lmac1 = &palive->lmac_data[0];
 160                 lmac2 = &palive->lmac_data[1];
 161                 status = le16_to_cpu(palive->status);
 162
 163                 mvm->trans->sku_id[0] = le32_to_cpu(palive->sku_id.data[0]);
 164                 mvm->trans->sku_id[1] = le32_to_cpu(palive->sku_id.data[1]);
 165                 mvm->trans->sku_id[2] = le32_to_cpu(palive->sku_id.data[2]);
 166
 167                 IWL_DEBUG_FW(mvm, "Got sku_id: 0x0%x 0x0%x 0x0%x\n",
 168                              mvm->trans->sku_id[0],
 169                              mvm->trans->sku_id[1],
 170                              mvm->trans->sku_id[2]);
 171         } else if (iwl_rx_packet_payload_len(pkt) == sizeof(struct iwl_alive_ntf_v4)) {
 172                 struct iwl_alive_ntf_v4 *palive;
 173
 174                 if (pkt_len < sizeof(*palive))
 175                         return false;
 176
 177                 palive = (void *)pkt->data;
 178                 umac = &palive->umac_data;
 179                 lmac1 = &palive->lmac_data[0];
 180                 lmac2 = &palive->lmac_data[1];
 181                 status = le16_to_cpu(palive->status);
 182         } else if (iwl_rx_packet_payload_len(pkt) ==
 183                    sizeof(struct iwl_alive_ntf_v3)) {
 184                 struct iwl_alive_ntf_v3 *palive3;
 185
 186                 if (pkt_len < sizeof(*palive3))
 187                         return false;
 188
 189                 palive3 = (void *)pkt->data;
 190                 umac = &palive3->umac_data;
 191                 lmac1 = &palive3->lmac_data;
 192                 status = le16_to_cpu(palive3->status);
 193         } else {
 194                 WARN(1, "unsupported alive notification (size %d)\n",
 195                      iwl_rx_packet_payload_len(pkt));
 196                 /* get timeout later */
 197                 return false;
 198         }
 199
 200         lmac_error_event_table =
 201                 le32_to_cpu(lmac1->dbg_ptrs.error_event_table_ptr);
 202         iwl_fw_lmac1_set_alive_err_table(mvm->trans, lmac_error_event_table);
 203
 204         if (lmac2)
 205                 mvm->trans->dbg.lmac_error_event_table[1] =
 206                         le32_to_cpu(lmac2->dbg_ptrs.error_event_table_ptr);
 207
 208         umac_error_table = le32_to_cpu(umac->dbg_ptrs.error_info_addr) &
 209                                                         ~FW_ADDR_CACHE_CONTROL;
 210
 211         if (umac_error_table) {
 212                 if (umac_error_table >=
 213                     mvm->trans->cfg->min_umac_error_event_table) {
 214                         iwl_fw_umac_set_alive_err_table(mvm->trans,
 215                                                         umac_error_table);
 216                 } else {
 217                         IWL_ERR(mvm,
 218                                 "Not valid error log pointer 0x%08X for %s uCode\n",
 219                                 umac_error_table,
 220                                 (mvm->fwrt.cur_fw_img == IWL_UCODE_INIT) ?
 221                                 "Init" : "RT");
 222                 }
 223         }
 224
 225         alive_data->scd_base_addr = le32_to_cpu(lmac1->dbg_ptrs.scd_base_ptr);
 226         alive_data->valid = status == IWL_ALIVE_STATUS_OK;
 227
 228         IWL_DEBUG_FW(mvm,
 229                      "Alive ucode status 0x%04x revision 0x%01X 0x%01X\n",
 230                      status, lmac1->ver_type, lmac1->ver_subtype);
 231
 232         if (lmac2)
 233                 IWL_DEBUG_FW(mvm, "Alive ucode CDB\n");
 234
 235         IWL_DEBUG_FW(mvm,
 236                      "UMAC version: Major - 0x%x, Minor - 0x%x\n",
 237                      le32_to_cpu(umac->umac_major),
 238                      le32_to_cpu(umac->umac_minor));
 239
 240         iwl_fwrt_update_fw_versions(&mvm->fwrt, lmac1, umac);
 241
 242         return true;
 243 }
 244
 245 static bool iwl_wait_init_complete(struct iwl_notif_wait_data *notif_wait,
 246                                    struct iwl_rx_packet *pkt, void *data)
 247 {
 248         WARN_ON(pkt->hdr.cmd != INIT_COMPLETE_NOTIF);
 249
 250         return true;
 251 }
 252
 253 static bool iwl_wait_phy_db_entry(struct iwl_notif_wait_data *notif_wait,
 254                                   struct iwl_rx_packet *pkt, void *data)
 255 {
 256         struct iwl_phy_db *phy_db = data;
 257
 258         if (pkt->hdr.cmd != CALIB_RES_NOTIF_PHY_DB) {
 259                 WARN_ON(pkt->hdr.cmd != INIT_COMPLETE_NOTIF);
 260                 return true;
 261         }
 262
 263         WARN_ON(iwl_phy_db_set_section(phy_db, pkt));
 264
 265         return false;
 266 }
 267
 268 static void iwl_mvm_print_pd_notification(struct iwl_mvm *mvm)
 269 {
 270         struct iwl_trans *trans = mvm->trans;
 271         enum iwl_device_family device_family = trans->trans_cfg->device_family;
 272
 273         if (device_family < IWL_DEVICE_FAMILY_8000)
 274                 return;
 275
 276         if (device_family <= IWL_DEVICE_FAMILY_9000)
 277                 IWL_ERR(mvm, "WFPM_ARC1_PD_NOTIFICATION: 0x%x\n",
 278                         iwl_read_umac_prph(trans, WFPM_ARC1_PD_NOTIFICATION));
 279         else
 280                 IWL_ERR(mvm, "WFPM_LMAC1_PD_NOTIFICATION: 0x%x\n",
 281                         iwl_read_umac_prph(trans, WFPM_LMAC1_PD_NOTIFICATION));
 282
 283         IWL_ERR(mvm, "HPM_SECONDARY_DEVICE_STATE: 0x%x\n",
 284                 iwl_read_umac_prph(trans, HPM_SECONDARY_DEVICE_STATE));
 285
 286 }
 287
 288 static int iwl_mvm_load_ucode_wait_alive(struct iwl_mvm *mvm,
 289                                          enum iwl_ucode_type ucode_type)
 290 {
 291         struct iwl_notification_wait alive_wait;
 292         struct iwl_mvm_alive_data alive_data = {};
 293         const struct fw_img *fw;
 294         int ret;
 295         enum iwl_ucode_type old_type = mvm->fwrt.cur_fw_img;
 296         static const u16 alive_cmd[] = { UCODE_ALIVE_NTFY };
 297         bool run_in_rfkill =
 298                 ucode_type == IWL_UCODE_INIT || iwl_mvm_has_unified_ucode(mvm);
 299
 300         if (ucode_type == IWL_UCODE_REGULAR &&
 301             iwl_fw_dbg_conf_usniffer(mvm->fw, FW_DBG_START_FROM_ALIVE) &&
 302             !(fw_has_capa(&mvm->fw->ucode_capa,
 303                           IWL_UCODE_TLV_CAPA_USNIFFER_UNIFIED)))
 304                 fw = iwl_get_ucode_image(mvm->fw, IWL_UCODE_REGULAR_USNIFFER);
 305         else
 306                 fw = iwl_get_ucode_image(mvm->fw, ucode_type);
 307         if (WARN_ON(!fw))
 308                 return -EINVAL;
 309         iwl_fw_set_current_image(&mvm->fwrt, ucode_type);
 310         clear_bit(IWL_MVM_STATUS_FIRMWARE_RUNNING, &mvm->status);
 311
 312         iwl_init_notification_wait(&mvm->notif_wait, &alive_wait,
 313                                    alive_cmd, ARRAY_SIZE(alive_cmd),
 314                                    iwl_alive_fn, &alive_data);
 315
 316         /*
 317          * We want to load the INIT firmware even in RFKILL
 318          * For the unified firmware case, the ucode_type is not
 319          * INIT, but we still need to run it.
 320          */
 321         ret = iwl_trans_start_fw(mvm->trans, fw, run_in_rfkill);
 322         if (ret) {
 323                 iwl_fw_set_current_image(&mvm->fwrt, old_type);
 324                 iwl_remove_notification(&mvm->notif_wait, &alive_wait);
 325                 return ret;
 326         }
 327
 328         /*
 329          * Some things may run in the background now, but we
 330          * just wait for the ALIVE notification here.
 331          */
 332         ret = iwl_wait_notification(&mvm->notif_wait, &alive_wait,
 333                                     MVM_UCODE_ALIVE_TIMEOUT);
 334         if (ret) {
 335                 struct iwl_trans *trans = mvm->trans;
 336
 337                 /* SecBoot info */
 338                 if (trans->trans_cfg->device_family >=
 339                                         IWL_DEVICE_FAMILY_22000) {
 340                         IWL_ERR(mvm,
 341                                 "SecBoot CPU1 Status: 0x%x, CPU2 Status: 0x%x\n",
 342                                 iwl_read_umac_prph(trans, UMAG_SB_CPU_1_STATUS),
 343                                 iwl_read_umac_prph(trans,
 344                                                    UMAG_SB_CPU_2_STATUS));
 345                 } else if (trans->trans_cfg->device_family >=
 346                            IWL_DEVICE_FAMILY_8000) {
 347                         IWL_ERR(mvm,
 348                                 "SecBoot CPU1 Status: 0x%x, CPU2 Status: 0x%x\n",
 349                                 iwl_read_prph(trans, SB_CPU_1_STATUS),
 350                                 iwl_read_prph(trans, SB_CPU_2_STATUS));
 351                 }
 352
 353                 iwl_mvm_print_pd_notification(mvm);
 354
 355                 /* LMAC/UMAC PC info */
 356                 if (trans->trans_cfg->device_family >=
 357                                         IWL_DEVICE_FAMILY_9000) {
 358                         IWL_ERR(mvm, "UMAC PC: 0x%x\n",
 359                                 iwl_read_umac_prph(trans,
 360                                                    UREG_UMAC_CURRENT_PC));
 361                         IWL_ERR(mvm, "LMAC PC: 0x%x\n",
 362                                 iwl_read_umac_prph(trans,
 363                                                    UREG_LMAC1_CURRENT_PC));
 364                         if (iwl_mvm_is_cdb_supported(mvm))
 365                                 IWL_ERR(mvm, "LMAC2 PC: 0x%x\n",
 366                                         iwl_read_umac_prph(trans,
 367                                                 UREG_LMAC2_CURRENT_PC));
 368                 }
 369
 370                 if (ret == -ETIMEDOUT)
 371                         iwl_fw_dbg_error_collect(&mvm->fwrt,
 372                                                  FW_DBG_TRIGGER_ALIVE_TIMEOUT);
 373
 374                 iwl_fw_set_current_image(&mvm->fwrt, old_type);
 375                 return ret;
 376         }
 377
 378         if (!alive_data.valid) {
 379                 IWL_ERR(mvm, "Loaded ucode is not valid!\n");
 380                 iwl_fw_set_current_image(&mvm->fwrt, old_type);
 381                 return -EIO;
 382         }
 383
 384         ret = iwl_pnvm_load(mvm->trans, &mvm->notif_wait);
 385         if (ret) {
 386                 IWL_ERR(mvm, "Timeout waiting for PNVM load!\n");
 387                 iwl_fw_set_current_image(&mvm->fwrt, old_type);
 388                 return ret;
 389         }
 390
 391         iwl_trans_fw_alive(mvm->trans, alive_data.scd_base_addr);
 392
 393         /*
 394          * Note: all the queues are enabled as part of the interface
 395          * initialization, but in firmware restart scenarios they
 396          * could be stopped, so wake them up. In firmware restart,
 397          * mac80211 will have the queues stopped as well until the
 398          * reconfiguration completes. During normal startup, they
 399          * will be empty.
 400          */
 401
 402         memset(&mvm->queue_info, 0, sizeof(mvm->queue_info));
 403         /*
 404          * Set a 'fake' TID for the command queue, since we use the
 405          * hweight() of the tid_bitmap as a refcount now. Not that
 406          * we ever even consider the command queue as one we might
 407          * want to reuse, but be safe nevertheless.
 408          */
 409         mvm->queue_info[IWL_MVM_DQA_CMD_QUEUE].tid_bitmap =
 410                 BIT(IWL_MAX_TID_COUNT + 2);
 411
 412         set_bit(IWL_MVM_STATUS_FIRMWARE_RUNNING, &mvm->status);
 413 #ifdef CONFIG_IWLWIFI_DEBUGFS
 414         iwl_fw_set_dbg_rec_on(&mvm->fwrt);
 415 #endif
 416
 417         /*
 418          * All the BSSes in the BSS table include the GP2 in the system
 419          * at the beacon Rx time, this is of course no longer relevant
 420          * since we are resetting the firmware.
 421          * Purge all the BSS table.
 422          */
 423         cfg80211_bss_flush(mvm->hw->wiphy);
 424
 425         return 0;
 426 }
 427
 428 static int iwl_run_unified_mvm_ucode(struct iwl_mvm *mvm)
 429 {
 430         struct iwl_notification_wait init_wait;
 431         struct iwl_nvm_access_complete_cmd nvm_complete = {};
 432         struct iwl_init_extended_cfg_cmd init_cfg = {
 433                 .init_flags = cpu_to_le32(BIT(IWL_INIT_NVM)),
 434         };
 435         static const u16 init_complete[] = {
 436                 INIT_COMPLETE_NOTIF,
 437         };
 438         int ret;
 439
 440         if (mvm->trans->cfg->tx_with_siso_diversity)
 441                 init_cfg.init_flags |= cpu_to_le32(BIT(IWL_INIT_PHY));
 442
 443         lockdep_assert_held(&mvm->mutex);
 444
 445         mvm->rfkill_safe_init_done = false;
 446
 447         iwl_init_notification_wait(&mvm->notif_wait,
 448                                    &init_wait,
 449                                    init_complete,
 450                                    ARRAY_SIZE(init_complete),
 451                                    iwl_wait_init_complete,
 452                                    NULL);
 453
 454         iwl_dbg_tlv_time_point(&mvm->fwrt, IWL_FW_INI_TIME_POINT_EARLY, NULL);
 455
 456         /* Will also start the device */
 457         ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_REGULAR);
 458         if (ret) {
 459                 IWL_ERR(mvm, "Failed to start RT ucode: %d\n", ret);
 460                 goto error;
 461         }
 462         iwl_dbg_tlv_time_point(&mvm->fwrt, IWL_FW_INI_TIME_POINT_AFTER_ALIVE,
 463                                NULL);
 464
 465         /* Send init config command to mark that we are sending NVM access
 466          * commands
 467          */
 468         ret = iwl_mvm_send_cmd_pdu(mvm, WIDE_ID(SYSTEM_GROUP,
 469                                                 INIT_EXTENDED_CFG_CMD),
 470                                    CMD_SEND_IN_RFKILL,
 471                                    sizeof(init_cfg), &init_cfg);
 472         if (ret) {
 473                 IWL_ERR(mvm, "Failed to run init config command: %d\n",
 474                         ret);
 475                 goto error;
 476         }
 477
 478         /* Load NVM to NIC if needed */
 479         if (mvm->nvm_file_name) {
 480                 ret = iwl_read_external_nvm(mvm->trans, mvm->nvm_file_name,
 481                                             mvm->nvm_sections);
 482                 if (ret)
 483                         goto error;
 484                 ret = iwl_mvm_load_nvm_to_nic(mvm);
 485                 if (ret)
 486                         goto error;
 487         }
 488
 489         if (IWL_MVM_PARSE_NVM && !mvm->nvm_data) {
 490                 ret = iwl_nvm_init(mvm);
 491                 if (ret) {
 492                         IWL_ERR(mvm, "Failed to read NVM: %d\n", ret);
 493                         goto error;
 494                 }
 495         }
 496
 497         ret = iwl_mvm_send_cmd_pdu(mvm, WIDE_ID(REGULATORY_AND_NVM_GROUP,
 498                                                 NVM_ACCESS_COMPLETE),
 499                                    CMD_SEND_IN_RFKILL,
 500                                    sizeof(nvm_complete), &nvm_complete);
 501         if (ret) {
 502                 IWL_ERR(mvm, "Failed to run complete NVM access: %d\n",
 503                         ret);
 504                 goto error;
 505         }
 506
 507         /* We wait for the INIT complete notification */
 508         ret = iwl_wait_notification(&mvm->notif_wait, &init_wait,
 509                                     MVM_UCODE_ALIVE_TIMEOUT);
 510         if (ret)
 511                 return ret;
 512
 513         /* Read the NVM only at driver load time, no need to do this twice */
 514         if (!IWL_MVM_PARSE_NVM && !mvm->nvm_data) {
 515                 mvm->nvm_data = iwl_get_nvm(mvm->trans, mvm->fw);
 516                 if (IS_ERR(mvm->nvm_data)) {
 517                         ret = PTR_ERR(mvm->nvm_data);
 518                         mvm->nvm_data = NULL;
 519                         IWL_ERR(mvm, "Failed to read NVM: %d\n", ret);
 520                         return ret;
 521                 }
 522         }
 523
 524         mvm->rfkill_safe_init_done = true;
 525
 526         return 0;
 527
 528 error:
 529         iwl_remove_notification(&mvm->notif_wait, &init_wait);
 530         return ret;
 531 }
 532
 533 #ifdef CONFIG_ACPI
 534 static void iwl_mvm_phy_filter_init(struct iwl_mvm *mvm,
 535                                     struct iwl_phy_specific_cfg *phy_filters)
 536 {
 537         /*
 538          * TODO: read specific phy config from BIOS
 539          * ACPI table for this feature has not been defined yet,
 540          * so for now we use hardcoded values.
 541          */
 542
 543         if (IWL_MVM_PHY_FILTER_CHAIN_A) {
 544                 phy_filters->filter_cfg_chain_a =
 545                         cpu_to_le32(IWL_MVM_PHY_FILTER_CHAIN_A);
 546         }
 547         if (IWL_MVM_PHY_FILTER_CHAIN_B) {
 548                 phy_filters->filter_cfg_chain_b =
 549                         cpu_to_le32(IWL_MVM_PHY_FILTER_CHAIN_B);
 550         }
 551         if (IWL_MVM_PHY_FILTER_CHAIN_C) {
 552                 phy_filters->filter_cfg_chain_c =
 553                         cpu_to_le32(IWL_MVM_PHY_FILTER_CHAIN_C);
 554         }
 555         if (IWL_MVM_PHY_FILTER_CHAIN_D) {
 556                 phy_filters->filter_cfg_chain_d =
 557                         cpu_to_le32(IWL_MVM_PHY_FILTER_CHAIN_D);
 558         }
 559 }
 560 #else /* CONFIG_ACPI */
 561
 562 static void iwl_mvm_phy_filter_init(struct iwl_mvm *mvm,
 563                                     struct iwl_phy_specific_cfg *phy_filters)
 564 {
 565 }
 566 #endif /* CONFIG_ACPI */
 567
 568 #if defined(CONFIG_ACPI) && defined(CONFIG_EFI)
 569 static int iwl_mvm_sgom_init(struct iwl_mvm *mvm)
 570 {
 571         u8 cmd_ver;
 572         int ret;
 573         struct iwl_host_cmd cmd = {
 574                 .id = WIDE_ID(REGULATORY_AND_NVM_GROUP,
 575                               SAR_OFFSET_MAPPING_TABLE_CMD),
 576                 .flags = 0,
 577                 .data[0] = &mvm->fwrt.sgom_table,
 578                 .len[0] =  sizeof(mvm->fwrt.sgom_table),
 579                 .dataflags[0] = IWL_HCMD_DFL_NOCOPY,
 580         };
 581
 582         if (!mvm->fwrt.sgom_enabled) {
 583                 IWL_DEBUG_RADIO(mvm, "SGOM table is disabled\n");
 584                 return 0;
 585         }
 586
 587         cmd_ver = iwl_fw_lookup_cmd_ver(mvm->fw, cmd.id,
 588                                         IWL_FW_CMD_VER_UNKNOWN);
 589
 590         if (cmd_ver != 2) {
 591                 IWL_DEBUG_RADIO(mvm, "command version is unsupported. version = %d\n",
 592                                 cmd_ver);
 593                 return 0;
 594         }
 595
 596         ret = iwl_mvm_send_cmd(mvm, &cmd);
 597         if (ret < 0)
 598                 IWL_ERR(mvm, "failed to send SAR_OFFSET_MAPPING_CMD (%d)\n", ret);
 599
 600         return ret;
 601 }
 602 #else
 603
 604 static int iwl_mvm_sgom_init(struct iwl_mvm *mvm)
 605 {
 606         return 0;
 607 }
 608 #endif
 609
 610 static int iwl_send_phy_cfg_cmd(struct iwl_mvm *mvm)
 611 {
 612         u32 cmd_id = PHY_CONFIGURATION_CMD;
 613         struct iwl_phy_cfg_cmd_v3 phy_cfg_cmd;
 614         enum iwl_ucode_type ucode_type = mvm->fwrt.cur_fw_img;
 615         struct iwl_phy_specific_cfg phy_filters = {};
 616         u8 cmd_ver;
 617         size_t cmd_size;
 618
 619         if (iwl_mvm_has_unified_ucode(mvm) &&
 620             !mvm->trans->cfg->tx_with_siso_diversity)
 621                 return 0;
 622
 623         if (mvm->trans->cfg->tx_with_siso_diversity) {
 624                 /*
 625                  * TODO: currently we don't set the antenna but letting the NIC
 626                  * to decide which antenna to use. This should come from BIOS.
 627                  */
 628                 phy_cfg_cmd.phy_cfg =
 629                         cpu_to_le32(FW_PHY_CFG_CHAIN_SAD_ENABLED);
 630         }
 631
 632         /* Set parameters */
 633         phy_cfg_cmd.phy_cfg = cpu_to_le32(iwl_mvm_get_phy_config(mvm));
 634
 635         /* set flags extra PHY configuration flags from the device's cfg */
 636         phy_cfg_cmd.phy_cfg |=
 637                 cpu_to_le32(mvm->trans->trans_cfg->extra_phy_cfg_flags);
 638
 639         phy_cfg_cmd.calib_control.event_trigger =
 640                 mvm->fw->default_calib[ucode_type].event_trigger;
 641         phy_cfg_cmd.calib_control.flow_trigger =
 642                 mvm->fw->default_calib[ucode_type].flow_trigger;
 643
 644         cmd_ver = iwl_fw_lookup_cmd_ver(mvm->fw, cmd_id,
 645                                         IWL_FW_CMD_VER_UNKNOWN);
 646         if (cmd_ver == 3) {
 647                 iwl_mvm_phy_filter_init(mvm, &phy_filters);
 648                 memcpy(&phy_cfg_cmd.phy_specific_cfg, &phy_filters,
 649                        sizeof(struct iwl_phy_specific_cfg));
 650         }
 651
 652         IWL_DEBUG_INFO(mvm, "Sending Phy CFG command: 0x%x\n",
 653                        phy_cfg_cmd.phy_cfg);
 654         cmd_size = (cmd_ver == 3) ? sizeof(struct iwl_phy_cfg_cmd_v3) :
 655                                     sizeof(struct iwl_phy_cfg_cmd_v1);
 656         return iwl_mvm_send_cmd_pdu(mvm, cmd_id, 0, cmd_size, &phy_cfg_cmd);
 657 }
 658
 659 int iwl_run_init_mvm_ucode(struct iwl_mvm *mvm)
 660 {
 661         struct iwl_notification_wait calib_wait;
 662         static const u16 init_complete[] = {
 663                 INIT_COMPLETE_NOTIF,
 664                 CALIB_RES_NOTIF_PHY_DB
 665         };
 666         int ret;
 667
 668         if (iwl_mvm_has_unified_ucode(mvm))
 669                 return iwl_run_unified_mvm_ucode(mvm);
 670
 671         lockdep_assert_held(&mvm->mutex);
 672
 673         mvm->rfkill_safe_init_done = false;
 674
 675         iwl_init_notification_wait(&mvm->notif_wait,
 676                                    &calib_wait,
 677                                    init_complete,
 678                                    ARRAY_SIZE(init_complete),
 679                                    iwl_wait_phy_db_entry,
 680                                    mvm->phy_db);
 681
 682         iwl_dbg_tlv_time_point(&mvm->fwrt, IWL_FW_INI_TIME_POINT_EARLY, NULL);
 683
 684         /* Will also start the device */
 685         ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_INIT);
 686         if (ret) {
 687                 IWL_ERR(mvm, "Failed to start INIT ucode: %d\n", ret);
 688                 goto remove_notif;
 689         }
 690
 691         if (mvm->trans->trans_cfg->device_family < IWL_DEVICE_FAMILY_8000) {
 692                 ret = iwl_mvm_send_bt_init_conf(mvm);
 693                 if (ret)
 694                         goto remove_notif;
 695         }
 696
 697         /* Read the NVM only at driver load time, no need to do this twice */
 698         if (!mvm->nvm_data) {
 699                 ret = iwl_nvm_init(mvm);
 700                 if (ret) {
 701                         IWL_ERR(mvm, "Failed to read NVM: %d\n", ret);
 702                         goto remove_notif;
 703                 }
 704         }
 705
 706         /* In case we read the NVM from external file, load it to the NIC */
 707         if (mvm->nvm_file_name) {
 708                 ret = iwl_mvm_load_nvm_to_nic(mvm);
 709                 if (ret)
 710                         goto remove_notif;
 711         }
 712
 713         WARN_ONCE(mvm->nvm_data->nvm_version < mvm->trans->cfg->nvm_ver,
 714                   "Too old NVM version (0x%0x, required = 0x%0x)",
 715                   mvm->nvm_data->nvm_version, mvm->trans->cfg->nvm_ver);
 716
 717         /*
 718          * abort after reading the nvm in case RF Kill is on, we will complete
 719          * the init seq later when RF kill will switch to off
 720          */
 721         if (iwl_mvm_is_radio_hw_killed(mvm)) {
 722                 IWL_DEBUG_RF_KILL(mvm,
 723                                   "jump over all phy activities due to RF kill\n");
 724                 goto remove_notif;
 725         }
 726
 727         mvm->rfkill_safe_init_done = true;
 728
 729         /* Send TX valid antennas before triggering calibrations */
 730         ret = iwl_send_tx_ant_cfg(mvm, iwl_mvm_get_valid_tx_ant(mvm));
 731         if (ret)
 732                 goto remove_notif;
 733
 734         ret = iwl_send_phy_cfg_cmd(mvm);
 735         if (ret) {
 736                 IWL_ERR(mvm, "Failed to run INIT calibrations: %d\n",
 737                         ret);
 738                 goto remove_notif;
 739         }
 740
 741         /*
 742          * Some things may run in the background now, but we
 743          * just wait for the calibration complete notification.
 744          */
 745         ret = iwl_wait_notification(&mvm->notif_wait, &calib_wait,
 746                                     MVM_UCODE_CALIB_TIMEOUT);
 747         if (!ret)
 748                 goto out;
 749
 750         if (iwl_mvm_is_radio_hw_killed(mvm)) {
 751                 IWL_DEBUG_RF_KILL(mvm, "RFKILL while calibrating.\n");
 752                 ret = 0;
 753         } else {
 754                 IWL_ERR(mvm, "Failed to run INIT calibrations: %d\n",
 755                         ret);
 756         }
 757
 758         goto out;
 759
 760 remove_notif:
 761         iwl_remove_notification(&mvm->notif_wait, &calib_wait);
 762 out:
 763         mvm->rfkill_safe_init_done = false;
 764         if (iwlmvm_mod_params.init_dbg && !mvm->nvm_data) {
 765                 /* we want to debug INIT and we have no NVM - fake */
 766                 mvm->nvm_data = kzalloc(sizeof(struct iwl_nvm_data) +
 767                                         sizeof(struct ieee80211_channel) +
 768                                         sizeof(struct ieee80211_rate),
 769                                         GFP_KERNEL);
 770                 if (!mvm->nvm_data)
 771                         return -ENOMEM;
 772                 mvm->nvm_data->bands[0].channels = mvm->nvm_data->channels;
 773                 mvm->nvm_data->bands[0].n_channels = 1;
 774                 mvm->nvm_data->bands[0].n_bitrates = 1;
 775                 mvm->nvm_data->bands[0].bitrates =
 776                         (void *)(mvm->nvm_data->channels + 1);
 777                 mvm->nvm_data->bands[0].bitrates->hw_value = 10;
 778         }
 779
 780         return ret;
 781 }
 782
 783 static int iwl_mvm_config_ltr(struct iwl_mvm *mvm)
 784 {
 785         struct iwl_ltr_config_cmd cmd = {
 786                 .flags = cpu_to_le32(LTR_CFG_FLAG_FEATURE_ENABLE),
 787         };
 788
 789         if (!mvm->trans->ltr_enabled)
 790                 return 0;
 791
 792         return iwl_mvm_send_cmd_pdu(mvm, LTR_CONFIG, 0,
 793                                     sizeof(cmd), &cmd);
 794 }
 795
 796 #ifdef CONFIG_ACPI
 797 int iwl_mvm_sar_select_profile(struct iwl_mvm *mvm, int prof_a, int prof_b)
 798 {
 799         u32 cmd_id = REDUCE_TX_POWER_CMD;
 800         struct iwl_dev_tx_power_cmd cmd = {
 801                 .common.set_mode = cpu_to_le32(IWL_TX_POWER_MODE_SET_CHAINS),
 802         };
 803         __le16 *per_chain;
 804         int ret;
 805         u16 len = 0;
 806         u32 n_subbands;
 807         u8 cmd_ver = iwl_fw_lookup_cmd_ver(mvm->fw, cmd_id,
 808                                            IWL_FW_CMD_VER_UNKNOWN);
 809
 810         if (cmd_ver == 6) {
 811                 len = sizeof(cmd.v6);
 812                 n_subbands = IWL_NUM_SUB_BANDS_V2;
 813                 per_chain = cmd.v6.per_chain[0][0];
 814         } else if (fw_has_api(&mvm->fw->ucode_capa,
 815                               IWL_UCODE_TLV_API_REDUCE_TX_POWER)) {
 816                 len = sizeof(cmd.v5);
 817                 n_subbands = IWL_NUM_SUB_BANDS_V1;
 818                 per_chain = cmd.v5.per_chain[0][0];
 819         } else if (fw_has_capa(&mvm->fw->ucode_capa,
 820                                IWL_UCODE_TLV_CAPA_TX_POWER_ACK)) {
 821                 len = sizeof(cmd.v4);
 822                 n_subbands = IWL_NUM_SUB_BANDS_V1;
 823                 per_chain = cmd.v4.per_chain[0][0];
 824         } else {
 825                 len = sizeof(cmd.v3);
 826                 n_subbands = IWL_NUM_SUB_BANDS_V1;
 827                 per_chain = cmd.v3.per_chain[0][0];
 828         }
 829
 830         /* all structs have the same common part, add it */
 831         len += sizeof(cmd.common);
 832
 833         ret = iwl_sar_select_profile(&mvm->fwrt, per_chain,
 834                                      IWL_NUM_CHAIN_TABLES,
 835                                      n_subbands, prof_a, prof_b);
 836
 837         /* return on error or if the profile is disabled (positive number) */
 838         if (ret)
 839                 return ret;
 840
 841         iwl_mei_set_power_limit(per_chain);
 842
 843         IWL_DEBUG_RADIO(mvm, "Sending REDUCE_TX_POWER_CMD per chain\n");
 844         return iwl_mvm_send_cmd_pdu(mvm, cmd_id, 0, len, &cmd);
 845 }
 846
 847 int iwl_mvm_get_sar_geo_profile(struct iwl_mvm *mvm)
 848 {
 849         union iwl_geo_tx_power_profiles_cmd geo_tx_cmd;
 850         struct iwl_geo_tx_power_profiles_resp *resp;
 851         u16 len;
 852         int ret;
 853         struct iwl_host_cmd cmd = {
 854                 .id = WIDE_ID(PHY_OPS_GROUP, PER_CHAIN_LIMIT_OFFSET_CMD),
 855                 .flags = CMD_WANT_SKB,
 856                 .data = { &geo_tx_cmd },
 857         };
 858         u8 cmd_ver = iwl_fw_lookup_cmd_ver(mvm->fw, cmd.id,
 859                                            IWL_FW_CMD_VER_UNKNOWN);
 860
 861         /* the ops field is at the same spot for all versions, so set in v1 */
 862         geo_tx_cmd.v1.ops =
 863                 cpu_to_le32(IWL_PER_CHAIN_OFFSET_GET_CURRENT_TABLE);
 864
 865         if (cmd_ver == 5)
 866                 len = sizeof(geo_tx_cmd.v5);
 867         else if (cmd_ver == 4)
 868                 len = sizeof(geo_tx_cmd.v4);
 869         else if (cmd_ver == 3)
 870                 len = sizeof(geo_tx_cmd.v3);
 871         else if (fw_has_api(&mvm->fwrt.fw->ucode_capa,
 872                             IWL_UCODE_TLV_API_SAR_TABLE_VER))
 873                 len = sizeof(geo_tx_cmd.v2);
 874         else
 875                 len = sizeof(geo_tx_cmd.v1);
 876
 877         if (!iwl_sar_geo_support(&mvm->fwrt))
 878                 return -EOPNOTSUPP;
 879
 880         cmd.len[0] = len;
 881
 882         ret = iwl_mvm_send_cmd(mvm, &cmd);
 883         if (ret) {
 884                 IWL_ERR(mvm, "Failed to get geographic profile info %d\n", ret);
 885                 return ret;
 886         }
 887
 888         resp = (void *)cmd.resp_pkt->data;
 889         ret = le32_to_cpu(resp->profile_idx);
 890
 891         if (WARN_ON(ret > ACPI_NUM_GEO_PROFILES_REV3))
 892                 ret = -EIO;
 893
 894         iwl_free_resp(&cmd);
 895         return ret;
 896 }
 897
 898 static int iwl_mvm_sar_geo_init(struct iwl_mvm *mvm)
 899 {
 900         u32 cmd_id = WIDE_ID(PHY_OPS_GROUP, PER_CHAIN_LIMIT_OFFSET_CMD);
 901         union iwl_geo_tx_power_profiles_cmd cmd;
 902         u16 len;
 903         u32 n_bands;
 904         u32 n_profiles;
 905         u32 sk = 0;
 906         int ret;
 907         u8 cmd_ver = iwl_fw_lookup_cmd_ver(mvm->fw, cmd_id,
 908                                            IWL_FW_CMD_VER_UNKNOWN);
 909
 910         BUILD_BUG_ON(offsetof(struct iwl_geo_tx_power_profiles_cmd_v1, ops) !=
 911                      offsetof(struct iwl_geo_tx_power_profiles_cmd_v2, ops) ||
 912                      offsetof(struct iwl_geo_tx_power_profiles_cmd_v2, ops) !=
 913                      offsetof(struct iwl_geo_tx_power_profiles_cmd_v3, ops) ||
 914                      offsetof(struct iwl_geo_tx_power_profiles_cmd_v3, ops) !=
 915                      offsetof(struct iwl_geo_tx_power_profiles_cmd_v4, ops) ||
 916                      offsetof(struct iwl_geo_tx_power_profiles_cmd_v4, ops) !=
 917                      offsetof(struct iwl_geo_tx_power_profiles_cmd_v5, ops));
 918
 919         /* the ops field is at the same spot for all versions, so set in v1 */
 920         cmd.v1.ops = cpu_to_le32(IWL_PER_CHAIN_OFFSET_SET_TABLES);
 921
 922         if (cmd_ver == 5) {
 923                 len = sizeof(cmd.v5);
 924                 n_bands = ARRAY_SIZE(cmd.v5.table[0]);
 925                 n_profiles = ACPI_NUM_GEO_PROFILES_REV3;
 926         } else if (cmd_ver == 4) {
 927                 len = sizeof(cmd.v4);
 928                 n_bands = ARRAY_SIZE(cmd.v4.table[0]);
 929                 n_profiles = ACPI_NUM_GEO_PROFILES_REV3;
 930         } else if (cmd_ver == 3) {
 931                 len = sizeof(cmd.v3);
 932                 n_bands = ARRAY_SIZE(cmd.v3.table[0]);
 933                 n_profiles = ACPI_NUM_GEO_PROFILES;
 934         } else if (fw_has_api(&mvm->fwrt.fw->ucode_capa,
 935                               IWL_UCODE_TLV_API_SAR_TABLE_VER)) {
 936                 len = sizeof(cmd.v2);
 937                 n_bands = ARRAY_SIZE(cmd.v2.table[0]);
 938                 n_profiles = ACPI_NUM_GEO_PROFILES;
 939         } else {
 940                 len = sizeof(cmd.v1);
 941                 n_bands = ARRAY_SIZE(cmd.v1.table[0]);
 942                 n_profiles = ACPI_NUM_GEO_PROFILES;
 943         }
 944
 945         BUILD_BUG_ON(offsetof(struct iwl_geo_tx_power_profiles_cmd_v1, table) !=
 946                      offsetof(struct iwl_geo_tx_power_profiles_cmd_v2, table) ||
 947                      offsetof(struct iwl_geo_tx_power_profiles_cmd_v2, table) !=
 948                      offsetof(struct iwl_geo_tx_power_profiles_cmd_v3, table) ||
 949                      offsetof(struct iwl_geo_tx_power_profiles_cmd_v3, table) !=
 950                      offsetof(struct iwl_geo_tx_power_profiles_cmd_v4, table) ||
 951                      offsetof(struct iwl_geo_tx_power_profiles_cmd_v4, table) !=
 952                      offsetof(struct iwl_geo_tx_power_profiles_cmd_v5, table));
 953         /* the table is at the same position for all versions, so set use v1 */
 954         ret = iwl_sar_geo_init(&mvm->fwrt, &cmd.v1.table[0][0],
 955                                n_bands, n_profiles);
 956
 957         /*
 958          * It is a valid scenario to not support SAR, or miss wgds table,
 959          * but in that case there is no need to send the command.
 960          */
 961         if (ret)
 962                 return 0;
 963
 964         /* Only set to South Korea if the table revision is 1 */
 965         if (mvm->fwrt.geo_rev == 1)
 966                 sk = 1;
 967
 968         /*
 969          * Set the table_revision to South Korea (1) or not (0).  The
 970          * element name is misleading, as it doesn't contain the table
 971          * revision number, but whether the South Korea variation
 972          * should be used.
 973          * This must be done after calling iwl_sar_geo_init().
 974          */
 975         if (cmd_ver == 5)
 976                 cmd.v5.table_revision = cpu_to_le32(sk);
 977         else if (cmd_ver == 4)
 978                 cmd.v4.table_revision = cpu_to_le32(sk);
 979         else if (cmd_ver == 3)
 980                 cmd.v3.table_revision = cpu_to_le32(sk);
 981         else if (fw_has_api(&mvm->fwrt.fw->ucode_capa,
 982                             IWL_UCODE_TLV_API_SAR_TABLE_VER))
 983                 cmd.v2.table_revision = cpu_to_le32(sk);
 984
 985         return iwl_mvm_send_cmd_pdu(mvm, cmd_id, 0, len, &cmd);
 986 }
 987
 988 static int iwl_mvm_get_ppag_table(struct iwl_mvm *mvm)
 989 {
 990         union acpi_object *wifi_pkg, *data, *flags;
 991         int i, j, ret, tbl_rev, num_sub_bands;
 992         int idx = 2;
 993
 994         mvm->fwrt.ppag_flags = 0;
 995
 996         data = iwl_acpi_get_object(mvm->dev, ACPI_PPAG_METHOD);
 997         if (IS_ERR(data))
 998                 return PTR_ERR(data);
 999
1000         /* try to read ppag table rev 2 or 1 (both have the same data size) */
1001         wifi_pkg = iwl_acpi_get_wifi_pkg(mvm->dev, data,
1002                                          ACPI_PPAG_WIFI_DATA_SIZE_V2, &tbl_rev);
1003         if (!IS_ERR(wifi_pkg)) {
1004                 if (tbl_rev == 1 || tbl_rev == 2) {
1005                         num_sub_bands = IWL_NUM_SUB_BANDS_V2;
1006                         IWL_DEBUG_RADIO(mvm,
1007                                         "Reading PPAG table v2 (tbl_rev=%d)\n",
1008                                         tbl_rev);
1009                         goto read_table;
1010                 } else {
1011                         ret = -EINVAL;
1012                         goto out_free;
1013                 }
1014         }
1015
1016         /* try to read ppag table revision 0 */
1017         wifi_pkg = iwl_acpi_get_wifi_pkg(mvm->dev, data,
1018                                          ACPI_PPAG_WIFI_DATA_SIZE_V1, &tbl_rev);
1019         if (!IS_ERR(wifi_pkg)) {
1020                 if (tbl_rev != 0) {
1021                         ret = -EINVAL;
1022                         goto out_free;
1023                 }
1024                 num_sub_bands = IWL_NUM_SUB_BANDS_V1;
1025                 IWL_DEBUG_RADIO(mvm, "Reading PPAG table v1 (tbl_rev=0)\n");
1026                 goto read_table;
1027         }
1028         ret = PTR_ERR(wifi_pkg);
1029         goto out_free;
1030
1031 read_table:
1032         mvm->fwrt.ppag_ver = tbl_rev;
1033         flags = &wifi_pkg->package.elements[1];
1034
1035         if (flags->type != ACPI_TYPE_INTEGER) {
1036                 ret = -EINVAL;
1037                 goto out_free;
1038         }
1039
1040         mvm->fwrt.ppag_flags = flags->integer.value & IWL_PPAG_MASK;
1041
1042         if (!mvm->fwrt.ppag_flags) {
1043                 ret = 0;
1044                 goto out_free;
1045         }
1046
1047         /*
1048          * read, verify gain values and save them into the PPAG table.
1049          * first sub-band (j=0) corresponds to Low-Band (2.4GHz), and the
1050          * following sub-bands to High-Band (5GHz).
1051          */
1052         for (i = 0; i < IWL_NUM_CHAIN_LIMITS; i++) {
1053                 for (j = 0; j < num_sub_bands; j++) {
1054                         union acpi_object *ent;
1055
1056                         ent = &wifi_pkg->package.elements[idx++];
1057                         if (ent->type != ACPI_TYPE_INTEGER) {
1058                                 ret = -EINVAL;
1059                                 goto out_free;
1060                         }
1061
1062                         mvm->fwrt.ppag_chains[i].subbands[j] = ent->integer.value;
1063
1064                         if ((j == 0 &&
1065                              (mvm->fwrt.ppag_chains[i].subbands[j] > ACPI_PPAG_MAX_LB ||
1066                               mvm->fwrt.ppag_chains[i].subbands[j] < ACPI_PPAG_MIN_LB)) ||
1067                             (j != 0 &&
1068                              (mvm->fwrt.ppag_chains[i].subbands[j] > ACPI_PPAG_MAX_HB ||
1069                               mvm->fwrt.ppag_chains[i].subbands[j] < ACPI_PPAG_MIN_HB))) {
1070                                 mvm->fwrt.ppag_flags = 0;
1071                                 ret = -EINVAL;
1072                                 goto out_free;
1073                         }
1074                 }
1075         }
1076
1077         ret = 0;
1078 out_free:
1079         kfree(data);
1080         return ret;
1081 }
1082
1083 int iwl_mvm_ppag_send_cmd(struct iwl_mvm *mvm)
1084 {
1085         union iwl_ppag_table_cmd cmd;
1086         u8 cmd_ver;
1087         int i, j, ret, num_sub_bands, cmd_size;
1088         s8 *gain;
1089
1090         if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_SET_PPAG)) {
1091                 IWL_DEBUG_RADIO(mvm,
1092                                 "PPAG capability not supported by FW, command not sent.\n");
1093                 return 0;
1094         }
1095         if (!mvm->fwrt.ppag_flags) {
1096                 IWL_DEBUG_RADIO(mvm, "PPAG not enabled, command not sent.\n");
1097                 return 0;
1098         }
1099
1100         /* The 'flags' field is the same in v1 and in v2 so we can just
1101          * use v1 to access it.
1102          */
1103         cmd.v1.flags = cpu_to_le32(mvm->fwrt.ppag_flags);
1104         cmd_ver = iwl_fw_lookup_cmd_ver(mvm->fw,
1105                                         WIDE_ID(PHY_OPS_GROUP, PER_PLATFORM_ANT_GAIN_CMD),
1106                                         IWL_FW_CMD_VER_UNKNOWN);
1107         if (cmd_ver == 1) {
1108                 num_sub_bands = IWL_NUM_SUB_BANDS_V1;
1109                 gain = cmd.v1.gain[0];
1110                 cmd_size = sizeof(cmd.v1);
1111                 if (mvm->fwrt.ppag_ver == 1 || mvm->fwrt.ppag_ver == 2) {
1112                         IWL_DEBUG_RADIO(mvm,
1113                                         "PPAG table rev is %d but FW supports v1, sending truncated table\n",
1114                                         mvm->fwrt.ppag_ver);
1115                         cmd.v1.flags &= cpu_to_le32(IWL_PPAG_ETSI_MASK);
1116                 }
1117         } else if (cmd_ver == 2 || cmd_ver == 3) {
1118                 num_sub_bands = IWL_NUM_SUB_BANDS_V2;
1119                 gain = cmd.v2.gain[0];
1120                 cmd_size = sizeof(cmd.v2);
1121                 if (mvm->fwrt.ppag_ver == 0) {
1122                         IWL_DEBUG_RADIO(mvm,
1123                                         "PPAG table is v1 but FW supports v2, sending padded table\n");
1124                 } else if (cmd_ver == 2 && mvm->fwrt.ppag_ver == 2) {
1125                         IWL_DEBUG_RADIO(mvm,
1126                                         "PPAG table is v3 but FW supports v2, sending partial bitmap.\n");
1127                         cmd.v1.flags &= cpu_to_le32(IWL_PPAG_ETSI_MASK);
1128                 }
1129         } else {
1130                 IWL_DEBUG_RADIO(mvm, "Unsupported PPAG command version\n");
1131                 return 0;
1132         }
1133
1134         for (i = 0; i < IWL_NUM_CHAIN_LIMITS; i++) {
1135                 for (j = 0; j < num_sub_bands; j++) {
1136                         gain[i * num_sub_bands + j] =
1137                                 mvm->fwrt.ppag_chains[i].subbands[j];
1138                         IWL_DEBUG_RADIO(mvm,
1139                                         "PPAG table: chain[%d] band[%d]: gain = %d\n",
1140                                         i, j, gain[i * num_sub_bands + j]);
1141                 }
1142         }
1143         IWL_DEBUG_RADIO(mvm, "Sending PER_PLATFORM_ANT_GAIN_CMD\n");
1144         ret = iwl_mvm_send_cmd_pdu(mvm, WIDE_ID(PHY_OPS_GROUP,
1145                                                 PER_PLATFORM_ANT_GAIN_CMD),
1146                                    0, cmd_size, &cmd);
1147         if (ret < 0)
1148                 IWL_ERR(mvm, "failed to send PER_PLATFORM_ANT_GAIN_CMD (%d)\n",
1149                         ret);
1150
1151         return ret;
1152 }
1153
1154 static const struct dmi_system_id dmi_ppag_approved_list[] = {
1155         { .ident = "HP",
1156           .matches = {
1157                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
1158                 },
1159         },
1160         { .ident = "SAMSUNG",
1161           .matches = {
1162                         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD"),
1163                 },
1164         },
1165         { .ident = "MSFT",
1166           .matches = {
1167                         DMI_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"),
1168                 },
1169         },
1170         { .ident = "ASUS",
1171           .matches = {
1172                         DMI_MATCH(DMI_SYS_VENDOR, "ASUSTek COMPUTER INC."),
1173                 },
1174         },
1175         {}
1176 };
1177
1178 static int iwl_mvm_ppag_init(struct iwl_mvm *mvm)
1179 {
1180         /* no need to read the table, done in INIT stage */
1181         if (!dmi_check_system(dmi_ppag_approved_list)) {
1182                 IWL_DEBUG_RADIO(mvm,
1183                                 "System vendor '%s' is not in the approved list, disabling PPAG.\n",
1184                                 dmi_get_system_info(DMI_SYS_VENDOR));
1185                 mvm->fwrt.ppag_flags = 0;
1186                 return 0;
1187         }
1188
1189         return iwl_mvm_ppag_send_cmd(mvm);
1190 }
1191
1192 static const struct dmi_system_id dmi_tas_approved_list[] = {
1193         { .ident = "HP",
1194           .matches = {
1195                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
1196                 },
1197         },
1198         { .ident = "SAMSUNG",
1199           .matches = {
1200                         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD"),
1201                 },
1202         },
1203                 { .ident = "LENOVO",
1204           .matches = {
1205                         DMI_MATCH(DMI_SYS_VENDOR, "Lenovo"),
1206                 },
1207         },
1208         { .ident = "DELL",
1209           .matches = {
1210                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1211                 },
1212         },
1213
1214         /* keep last */
1215         {}
1216 };
1217
1218 static bool iwl_mvm_add_to_tas_block_list(__le32 *list, __le32 *le_size, unsigned int mcc)
1219 {
1220         int i;
1221         u32 size = le32_to_cpu(*le_size);
1222
1223         /* Verify that there is room for another country */
1224         if (size >= IWL_TAS_BLOCK_LIST_MAX)
1225                 return false;
1226
1227         for (i = 0; i < size; i++) {
1228                 if (list[i] == cpu_to_le32(mcc))
1229                         return true;
1230         }
1231
1232         list[size++] = cpu_to_le32(mcc);
1233         *le_size = cpu_to_le32(size);
1234         return true;
1235 }
1236
1237 static void iwl_mvm_tas_init(struct iwl_mvm *mvm)
1238 {
1239         u32 cmd_id = WIDE_ID(REGULATORY_AND_NVM_GROUP, TAS_CONFIG);
1240         int ret;
1241         union iwl_tas_config_cmd cmd = {};
1242         int cmd_size, fw_ver;
1243
1244         BUILD_BUG_ON(ARRAY_SIZE(cmd.v3.block_list_array) <
1245                      APCI_WTAS_BLACK_LIST_MAX);
1246
1247         if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TAS_CFG)) {
1248                 IWL_DEBUG_RADIO(mvm, "TAS not enabled in FW\n");
1249                 return;
1250         }
1251
1252         fw_ver = iwl_fw_lookup_cmd_ver(mvm->fw, cmd_id,
1253                                        IWL_FW_CMD_VER_UNKNOWN);
1254
1255         ret = iwl_acpi_get_tas(&mvm->fwrt, &cmd, fw_ver);
1256         if (ret < 0) {
1257                 IWL_DEBUG_RADIO(mvm,
1258                                 "TAS table invalid or unavailable. (%d)\n",
1259                                 ret);
1260                 return;
1261         }
1262
1263         if (ret == 0)
1264                 return;
1265
1266         if (!dmi_check_system(dmi_tas_approved_list)) {
1267                 IWL_DEBUG_RADIO(mvm,
1268                                 "System vendor '%s' is not in the approved list, disabling TAS in US and Canada.\n",
1269                                 dmi_get_system_info(DMI_SYS_VENDOR));
1270                 if ((!iwl_mvm_add_to_tas_block_list(cmd.v4.block_list_array,
1271                                                     &cmd.v4.block_list_size,
1272                                                         IWL_TAS_US_MCC)) ||
1273                     (!iwl_mvm_add_to_tas_block_list(cmd.v4.block_list_array,
1274                                                     &cmd.v4.block_list_size,
1275                                                         IWL_TAS_CANADA_MCC))) {
1276                         IWL_DEBUG_RADIO(mvm,
1277                                         "Unable to add US/Canada to TAS block list, disabling TAS\n");
1278                         return;
1279                 }
1280         }
1281
1282         /* v4 is the same size as v3, so no need to differentiate here */
1283         cmd_size = fw_ver < 3 ?
1284                 sizeof(struct iwl_tas_config_cmd_v2) :
1285                 sizeof(struct iwl_tas_config_cmd_v3);
1286
1287         ret = iwl_mvm_send_cmd_pdu(mvm, cmd_id, 0, cmd_size, &cmd);
1288         if (ret < 0)
1289                 IWL_DEBUG_RADIO(mvm, "failed to send TAS_CONFIG (%d)\n", ret);
1290 }
1291
1292 static u8 iwl_mvm_eval_dsm_rfi(struct iwl_mvm *mvm)
1293 {
1294         u8 value;
1295         int ret = iwl_acpi_get_dsm_u8(mvm->fwrt.dev, 0, DSM_RFI_FUNC_ENABLE,
1296                                       &iwl_rfi_guid, &value);
1297
1298         if (ret < 0) {
1299                 IWL_DEBUG_RADIO(mvm, "Failed to get DSM RFI, ret=%d\n", ret);
1300
1301         } else if (value >= DSM_VALUE_RFI_MAX) {
1302                 IWL_DEBUG_RADIO(mvm, "DSM RFI got invalid value, ret=%d\n",
1303                                 value);
1304
1305         } else if (value == DSM_VALUE_RFI_ENABLE) {
1306                 IWL_DEBUG_RADIO(mvm, "DSM RFI is evaluated to enable\n");
1307                 return DSM_VALUE_RFI_ENABLE;
1308         }
1309
1310         IWL_DEBUG_RADIO(mvm, "DSM RFI is disabled\n");
1311
1312         /* default behaviour is disabled */
1313         return DSM_VALUE_RFI_DISABLE;
1314 }
1315
1316 static void iwl_mvm_lari_cfg(struct iwl_mvm *mvm)
1317 {
1318         int ret;
1319         u32 value;
1320         struct iwl_lari_config_change_cmd_v6 cmd = {};
1321
1322         cmd.config_bitmap = iwl_acpi_get_lari_config_bitmap(&mvm->fwrt);
1323
1324         ret = iwl_acpi_get_dsm_u32(mvm->fwrt.dev, 0, DSM_FUNC_11AX_ENABLEMENT,
1325                                    &iwl_guid, &value);
1326         if (!ret)
1327                 cmd.oem_11ax_allow_bitmap = cpu_to_le32(value);
1328
1329         ret = iwl_acpi_get_dsm_u32(mvm->fwrt.dev, 0,
1330                                    DSM_FUNC_ENABLE_UNII4_CHAN,
1331                                    &iwl_guid, &value);
1332         if (!ret)
1333                 cmd.oem_unii4_allow_bitmap = cpu_to_le32(value);
1334
1335         ret = iwl_acpi_get_dsm_u32(mvm->fwrt.dev, 0,
1336                                    DSM_FUNC_ACTIVATE_CHANNEL,
1337                                    &iwl_guid, &value);
1338         if (!ret)
1339                 cmd.chan_state_active_bitmap = cpu_to_le32(value);
1340
1341         ret = iwl_acpi_get_dsm_u32(mvm->fwrt.dev, 0,
1342                                    DSM_FUNC_ENABLE_6E,
1343                                    &iwl_guid, &value);
1344         if (!ret)
1345                 cmd.oem_uhb_allow_bitmap = cpu_to_le32(value);
1346
1347         ret = iwl_acpi_get_dsm_u32(mvm->fwrt.dev, 0,
1348                                    DSM_FUNC_FORCE_DISABLE_CHANNELS,
1349                                    &iwl_guid, &value);
1350         if (!ret)
1351                 cmd.force_disable_channels_bitmap = cpu_to_le32(value);
1352
1353         if (cmd.config_bitmap ||
1354             cmd.oem_uhb_allow_bitmap ||
1355             cmd.oem_11ax_allow_bitmap ||
1356             cmd.oem_unii4_allow_bitmap ||
1357             cmd.chan_state_active_bitmap ||
1358             cmd.force_disable_channels_bitmap) {
1359                 size_t cmd_size;
1360                 u8 cmd_ver = iwl_fw_lookup_cmd_ver(mvm->fw,
1361                                                    WIDE_ID(REGULATORY_AND_NVM_GROUP,
1362                                                            LARI_CONFIG_CHANGE),
1363                                                    1);
1364                 switch (cmd_ver) {
1365                 case 6:
1366                         cmd_size = sizeof(struct iwl_lari_config_change_cmd_v6);
1367                         break;
1368                 case 5:
1369                         cmd_size = sizeof(struct iwl_lari_config_change_cmd_v5);
1370                         break;
1371                 case 4:
1372                         cmd_size = sizeof(struct iwl_lari_config_change_cmd_v4);
1373                         break;
1374                 case 3:
1375                         cmd_size = sizeof(struct iwl_lari_config_change_cmd_v3);
1376                         break;
1377                 case 2:
1378                         cmd_size = sizeof(struct iwl_lari_config_change_cmd_v2);
1379                         break;
1380                 default:
1381                         cmd_size = sizeof(struct iwl_lari_config_change_cmd_v1);
1382                         break;
1383                 }
1384
1385                 IWL_DEBUG_RADIO(mvm,
1386                                 "sending LARI_CONFIG_CHANGE, config_bitmap=0x%x, oem_11ax_allow_bitmap=0x%x\n",
1387                                 le32_to_cpu(cmd.config_bitmap),
1388                                 le32_to_cpu(cmd.oem_11ax_allow_bitmap));
1389                 IWL_DEBUG_RADIO(mvm,
1390                                 "sending LARI_CONFIG_CHANGE, oem_unii4_allow_bitmap=0x%x, chan_state_active_bitmap=0x%x, cmd_ver=%d\n",
1391                                 le32_to_cpu(cmd.oem_unii4_allow_bitmap),
1392                                 le32_to_cpu(cmd.chan_state_active_bitmap),
1393                                 cmd_ver);
1394                 IWL_DEBUG_RADIO(mvm,
1395                                 "sending LARI_CONFIG_CHANGE, oem_uhb_allow_bitmap=0x%x, force_disable_channels_bitmap=0x%x\n",
1396                                 le32_to_cpu(cmd.oem_uhb_allow_bitmap),
1397                                 le32_to_cpu(cmd.force_disable_channels_bitmap));
1398                 ret = iwl_mvm_send_cmd_pdu(mvm,
1399                                            WIDE_ID(REGULATORY_AND_NVM_GROUP,
1400                                                    LARI_CONFIG_CHANGE),
1401                                            0, cmd_size, &cmd);
1402                 if (ret < 0)
1403                         IWL_DEBUG_RADIO(mvm,
1404                                         "Failed to send LARI_CONFIG_CHANGE (%d)\n",
1405                                         ret);
1406         }
1407 }
1408
1409 void iwl_mvm_get_acpi_tables(struct iwl_mvm *mvm)
1410 {
1411         int ret;
1412
1413         /* read PPAG table */
1414         ret = iwl_mvm_get_ppag_table(mvm);
1415         if (ret < 0) {
1416                 IWL_DEBUG_RADIO(mvm,
1417                                 "PPAG BIOS table invalid or unavailable. (%d)\n",
1418                                 ret);
1419         }
1420
1421         /* read SAR tables */
1422         ret = iwl_sar_get_wrds_table(&mvm->fwrt);
1423         if (ret < 0) {
1424                 IWL_DEBUG_RADIO(mvm,
1425                                 "WRDS SAR BIOS table invalid or unavailable. (%d)\n",
1426                                 ret);
1427                 /*
1428                  * If not available, don't fail and don't bother with EWRD and
1429                  * WGDS */
1430
1431                 if (!iwl_sar_get_wgds_table(&mvm->fwrt)) {
1432                         /*
1433                          * If basic SAR is not available, we check for WGDS,
1434                          * which should *not* be available either.  If it is
1435                          * available, issue an error, because we can't use SAR
1436                          * Geo without basic SAR.
1437                          */
1438                         IWL_ERR(mvm, "BIOS contains WGDS but no WRDS\n");
1439                 }
1440
1441         } else {
1442                 ret = iwl_sar_get_ewrd_table(&mvm->fwrt);
1443                 /* if EWRD is not available, we can still use
1444                 * WRDS, so don't fail */
1445                 if (ret < 0)
1446                         IWL_DEBUG_RADIO(mvm,
1447                                         "EWRD SAR BIOS table invalid or unavailable. (%d)\n",
1448                                         ret);
1449
1450                 /* read geo SAR table */
1451                 if (iwl_sar_geo_support(&mvm->fwrt)) {
1452                         ret = iwl_sar_get_wgds_table(&mvm->fwrt);
1453                         if (ret < 0)
1454                                 IWL_DEBUG_RADIO(mvm,
1455                                                 "Geo SAR BIOS table invalid or unavailable. (%d)\n",
1456                                                 ret);
1457                                 /* we don't fail if the table is not available */
1458                 }
1459         }
1460 }
1461 #else /* CONFIG_ACPI */
1462
1463 inline int iwl_mvm_sar_select_profile(struct iwl_mvm *mvm,
1464                                       int prof_a, int prof_b)
1465 {
1466         return 1;
1467 }
1468
1469 inline int iwl_mvm_get_sar_geo_profile(struct iwl_mvm *mvm)
1470 {
1471         return -ENOENT;
1472 }
1473
1474 static int iwl_mvm_sar_geo_init(struct iwl_mvm *mvm)
1475 {
1476         return 0;
1477 }
1478
1479 int iwl_mvm_ppag_send_cmd(struct iwl_mvm *mvm)
1480 {
1481         return -ENOENT;
1482 }
1483
1484 static int iwl_mvm_ppag_init(struct iwl_mvm *mvm)
1485 {
1486         return 0;
1487 }
1488
1489 static void iwl_mvm_tas_init(struct iwl_mvm *mvm)
1490 {
1491 }
1492
1493 static void iwl_mvm_lari_cfg(struct iwl_mvm *mvm)
1494 {
1495 }
1496
1497 static u8 iwl_mvm_eval_dsm_rfi(struct iwl_mvm *mvm)
1498 {
1499         return DSM_VALUE_RFI_DISABLE;
1500 }
1501
1502 void iwl_mvm_get_acpi_tables(struct iwl_mvm *mvm)
1503 {
1504 }
1505
1506 #endif /* CONFIG_ACPI */
1507
1508 void iwl_mvm_send_recovery_cmd(struct iwl_mvm *mvm, u32 flags)
1509 {
1510         u32 error_log_size = mvm->fw->ucode_capa.error_log_size;
1511         int ret;
1512         u32 resp;
1513
1514         struct iwl_fw_error_recovery_cmd recovery_cmd = {
1515                 .flags = cpu_to_le32(flags),
1516                 .buf_size = 0,
1517         };
1518         struct iwl_host_cmd host_cmd = {
1519                 .id = WIDE_ID(SYSTEM_GROUP, FW_ERROR_RECOVERY_CMD),
1520                 .flags = CMD_WANT_SKB,
1521                 .data = {&recovery_cmd, },
1522                 .len = {sizeof(recovery_cmd), },
1523         };
1524
1525         /* no error log was defined in TLV */
1526         if (!error_log_size)
1527                 return;
1528
1529         if (flags & ERROR_RECOVERY_UPDATE_DB) {
1530                 /* no buf was allocated while HW reset */
1531                 if (!mvm->error_recovery_buf)
1532                         return;
1533
1534                 host_cmd.data[1] = mvm->error_recovery_buf;
1535                 host_cmd.len[1] =  error_log_size;
1536                 host_cmd.dataflags[1] = IWL_HCMD_DFL_NOCOPY;
1537                 recovery_cmd.buf_size = cpu_to_le32(error_log_size);
1538         }
1539
1540         ret = iwl_mvm_send_cmd(mvm, &host_cmd);
1541         kfree(mvm->error_recovery_buf);
1542         mvm->error_recovery_buf = NULL;
1543
1544         if (ret) {
1545                 IWL_ERR(mvm, "Failed to send recovery cmd %d\n", ret);
1546                 return;
1547         }
1548
1549         /* skb respond is only relevant in ERROR_RECOVERY_UPDATE_DB */
1550         if (flags & ERROR_RECOVERY_UPDATE_DB) {
1551                 resp = le32_to_cpu(*(__le32 *)host_cmd.resp_pkt->data);
1552                 if (resp)
1553                         IWL_ERR(mvm,
1554                                 "Failed to send recovery cmd blob was invalid %d\n",
1555                                 resp);
1556         }
1557 }
1558
1559 static int iwl_mvm_sar_init(struct iwl_mvm *mvm)
1560 {
1561         return iwl_mvm_sar_select_profile(mvm, 1, 1);
1562 }
1563
1564 static int iwl_mvm_load_rt_fw(struct iwl_mvm *mvm)
1565 {
1566         int ret;
1567
1568         if (iwl_mvm_has_unified_ucode(mvm))
1569                 return iwl_run_unified_mvm_ucode(mvm);
1570
1571         ret = iwl_run_init_mvm_ucode(mvm);
1572
1573         if (ret) {
1574                 IWL_ERR(mvm, "Failed to run INIT ucode: %d\n", ret);
1575
1576                 if (iwlmvm_mod_params.init_dbg)
1577                         return 0;
1578                 return ret;
1579         }
1580
1581         iwl_fw_dbg_stop_sync(&mvm->fwrt);
1582         iwl_trans_stop_device(mvm->trans);
1583         ret = iwl_trans_start_hw(mvm->trans);
1584         if (ret)
1585                 return ret;
1586
1587         mvm->rfkill_safe_init_done = false;
1588         ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_REGULAR);
1589         if (ret)
1590                 return ret;
1591
1592         mvm->rfkill_safe_init_done = true;
1593
1594         iwl_dbg_tlv_time_point(&mvm->fwrt, IWL_FW_INI_TIME_POINT_AFTER_ALIVE,
1595                                NULL);
1596
1597         return iwl_init_paging(&mvm->fwrt, mvm->fwrt.cur_fw_img);
1598 }
1599
1600 int iwl_mvm_up(struct iwl_mvm *mvm)
1601 {
1602         int ret, i;
1603         struct ieee80211_channel *chan;
1604         struct cfg80211_chan_def chandef;
1605         struct ieee80211_supported_band *sband = NULL;
1606
1607         lockdep_assert_held(&mvm->mutex);
1608
1609         ret = iwl_trans_start_hw(mvm->trans);
1610         if (ret)
1611                 return ret;
1612
1613         ret = iwl_mvm_load_rt_fw(mvm);
1614         if (ret) {
1615                 IWL_ERR(mvm, "Failed to start RT ucode: %d\n", ret);
1616                 if (ret != -ERFKILL)
1617                         iwl_fw_dbg_error_collect(&mvm->fwrt,
1618                                                  FW_DBG_TRIGGER_DRIVER);
1619                 goto error;
1620         }
1621
1622         iwl_get_shared_mem_conf(&mvm->fwrt);
1623
1624         ret = iwl_mvm_sf_update(mvm, NULL, false);
1625         if (ret)
1626                 IWL_ERR(mvm, "Failed to initialize Smart Fifo\n");
1627
1628         if (!iwl_trans_dbg_ini_valid(mvm->trans)) {
1629                 mvm->fwrt.dump.conf = FW_DBG_INVALID;
1630                 /* if we have a destination, assume EARLY START */
1631                 if (mvm->fw->dbg.dest_tlv)
1632                         mvm->fwrt.dump.conf = FW_DBG_START_FROM_ALIVE;
1633                 iwl_fw_start_dbg_conf(&mvm->fwrt, FW_DBG_START_FROM_ALIVE);
1634         }
1635
1636         ret = iwl_send_tx_ant_cfg(mvm, iwl_mvm_get_valid_tx_ant(mvm));
1637         if (ret)
1638                 goto error;
1639
1640         if (!iwl_mvm_has_unified_ucode(mvm)) {
1641                 /* Send phy db control command and then phy db calibration */
1642                 ret = iwl_send_phy_db_data(mvm->phy_db);
1643                 if (ret)
1644                         goto error;
1645         }
1646
1647         ret = iwl_send_phy_cfg_cmd(mvm);
1648         if (ret)
1649                 goto error;
1650
1651         ret = iwl_mvm_send_bt_init_conf(mvm);
1652         if (ret)
1653                 goto error;
1654
1655         if (fw_has_capa(&mvm->fw->ucode_capa,
1656                         IWL_UCODE_TLV_CAPA_SOC_LATENCY_SUPPORT)) {
1657                 ret = iwl_set_soc_latency(&mvm->fwrt);
1658                 if (ret)
1659                         goto error;
1660         }
1661
1662         /* Init RSS configuration */
1663         ret = iwl_configure_rxq(&mvm->fwrt);
1664         if (ret)
1665                 goto error;
1666
1667         if (iwl_mvm_has_new_rx_api(mvm)) {
1668                 ret = iwl_send_rss_cfg_cmd(mvm);
1669                 if (ret) {
1670                         IWL_ERR(mvm, "Failed to configure RSS queues: %d\n",
1671                                 ret);
1672                         goto error;
1673                 }
1674         }
1675
1676         /* init the fw <-> mac80211 STA mapping */
1677         for (i = 0; i < mvm->fw->ucode_capa.num_stations; i++)
1678                 RCU_INIT_POINTER(mvm->fw_id_to_mac_id[i], NULL);
1679
1680         mvm->tdls_cs.peer.sta_id = IWL_MVM_INVALID_STA;
1681
1682         /* reset quota debouncing buffer - 0xff will yield invalid data */
1683         memset(&mvm->last_quota_cmd, 0xff, sizeof(mvm->last_quota_cmd));
1684
1685         if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_DQA_SUPPORT)) {
1686                 ret = iwl_mvm_send_dqa_cmd(mvm);
1687                 if (ret)
1688                         goto error;
1689         }
1690
1691         /*
1692          * Add auxiliary station for scanning.
1693          * Newer versions of this command implies that the fw uses
1694          * internal aux station for all aux activities that don't
1695          * requires a dedicated data queue.
1696          */
1697         if (iwl_fw_lookup_cmd_ver(mvm->fw, ADD_STA, 0) < 12) {
1698                  /*
1699                   * In old version the aux station uses mac id like other
1700                   * station and not lmac id
1701                   */
1702                 ret = iwl_mvm_add_aux_sta(mvm, MAC_INDEX_AUX);
1703                 if (ret)
1704                         goto error;
1705         }
1706
1707         /* Add all the PHY contexts */
1708         i = 0;
1709         while (!sband && i < NUM_NL80211_BANDS)
1710                 sband = mvm->hw->wiphy->bands[i++];
1711
1712         if (WARN_ON_ONCE(!sband)) {
1713                 ret = -ENODEV;
1714                 goto error;
1715         }
1716
1717         chan = &sband->channels[0];
1718
1719         cfg80211_chandef_create(&chandef, chan, NL80211_CHAN_NO_HT);
1720         for (i = 0; i < NUM_PHY_CTX; i++) {
1721                 /*
1722                  * The channel used here isn't relevant as it's
1723                  * going to be overwritten in the other flows.
1724                  * For now use the first channel we have.
1725                  */
1726                 ret = iwl_mvm_phy_ctxt_add(mvm, &mvm->phy_ctxts[i],
1727                                            &chandef, 1, 1);
1728                 if (ret)
1729                         goto error;
1730         }
1731
1732         if (iwl_mvm_is_tt_in_fw(mvm)) {
1733                 /* in order to give the responsibility of ct-kill and
1734                  * TX backoff to FW we need to send empty temperature reporting
1735                  * cmd during init time
1736                  */
1737                 iwl_mvm_send_temp_report_ths_cmd(mvm);
1738         } else {
1739                 /* Initialize tx backoffs to the minimal possible */
1740                 iwl_mvm_tt_tx_backoff(mvm, 0);
1741         }
1742
1743 #ifdef CONFIG_THERMAL
1744         /* TODO: read the budget from BIOS / Platform NVM */
1745
1746         /*
1747          * In case there is no budget from BIOS / Platform NVM the default
1748          * budget should be 2000mW (cooling state 0).
1749          */
1750         if (iwl_mvm_is_ctdp_supported(mvm)) {
1751                 ret = iwl_mvm_ctdp_command(mvm, CTDP_CMD_OPERATION_START,
1752                                            mvm->cooling_dev.cur_state);
1753                 if (ret)
1754                         goto error;
1755         }
1756 #endif
1757
1758         if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_SET_LTR_GEN2))
1759                 WARN_ON(iwl_mvm_config_ltr(mvm));
1760
1761         ret = iwl_mvm_power_update_device(mvm);
1762         if (ret)
1763                 goto error;
1764
1765         iwl_mvm_lari_cfg(mvm);
1766         /*
1767          * RTNL is not taken during Ct-kill, but we don't need to scan/Tx
1768          * anyway, so don't init MCC.
1769          */
1770         if (!test_bit(IWL_MVM_STATUS_HW_CTKILL, &mvm->status)) {
1771                 ret = iwl_mvm_init_mcc(mvm);
1772                 if (ret)
1773                         goto error;
1774         }
1775
1776         if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
1777                 mvm->scan_type = IWL_SCAN_TYPE_NOT_SET;
1778                 mvm->hb_scan_type = IWL_SCAN_TYPE_NOT_SET;
1779                 ret = iwl_mvm_config_scan(mvm);
1780                 if (ret)
1781                         goto error;
1782         }
1783
1784         if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
1785                 iwl_mvm_send_recovery_cmd(mvm, ERROR_RECOVERY_UPDATE_DB);
1786
1787         if (iwl_acpi_get_eckv(mvm->dev, &mvm->ext_clock_valid))
1788                 IWL_DEBUG_INFO(mvm, "ECKV table doesn't exist in BIOS\n");
1789
1790         ret = iwl_mvm_ppag_init(mvm);
1791         if (ret)
1792                 goto error;
1793
1794         ret = iwl_mvm_sar_init(mvm);
1795         if (ret == 0)
1796                 ret = iwl_mvm_sar_geo_init(mvm);
1797         else if (ret < 0)
1798                 goto error;
1799
1800         ret = iwl_mvm_sgom_init(mvm);
1801         if (ret)
1802                 goto error;
1803
1804         iwl_mvm_tas_init(mvm);
1805         iwl_mvm_leds_sync(mvm);
1806
1807         iwl_mvm_ftm_initiator_smooth_config(mvm);
1808
1809         if (fw_has_capa(&mvm->fw->ucode_capa,
1810                         IWL_UCODE_TLV_CAPA_RFIM_SUPPORT)) {
1811                 if (iwl_mvm_eval_dsm_rfi(mvm) == DSM_VALUE_RFI_ENABLE)
1812                         iwl_rfi_send_config_cmd(mvm, NULL);
1813         }
1814
1815         IWL_DEBUG_INFO(mvm, "RT uCode started.\n");
1816         return 0;
1817  error:
1818         if (!iwlmvm_mod_params.init_dbg || !ret)
1819                 iwl_mvm_stop_device(mvm);
1820         return ret;
1821 }
1822
1823 int iwl_mvm_load_d3_fw(struct iwl_mvm *mvm)
1824 {
1825         int ret, i;
1826
1827         lockdep_assert_held(&mvm->mutex);
1828
1829         ret = iwl_trans_start_hw(mvm->trans);
1830         if (ret)
1831                 return ret;
1832
1833         ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_WOWLAN);
1834         if (ret) {
1835                 IWL_ERR(mvm, "Failed to start WoWLAN firmware: %d\n", ret);
1836                 goto error;
1837         }
1838
1839         ret = iwl_send_tx_ant_cfg(mvm, iwl_mvm_get_valid_tx_ant(mvm));
1840         if (ret)
1841                 goto error;
1842
1843         /* Send phy db control command and then phy db calibration*/
1844         ret = iwl_send_phy_db_data(mvm->phy_db);
1845         if (ret)
1846                 goto error;
1847
1848         ret = iwl_send_phy_cfg_cmd(mvm);
1849         if (ret)
1850                 goto error;
1851
1852         /* init the fw <-> mac80211 STA mapping */
1853         for (i = 0; i < mvm->fw->ucode_capa.num_stations; i++)
1854                 RCU_INIT_POINTER(mvm->fw_id_to_mac_id[i], NULL);
1855
1856         if (iwl_fw_lookup_cmd_ver(mvm->fw, ADD_STA, 0) < 12) {
1857                 /*
1858                  * Add auxiliary station for scanning.
1859                  * Newer versions of this command implies that the fw uses
1860                  * internal aux station for all aux activities that don't
1861                  * requires a dedicated data queue.
1862                  * In old version the aux station uses mac id like other
1863                  * station and not lmac id
1864                  */
1865                 ret = iwl_mvm_add_aux_sta(mvm, MAC_INDEX_AUX);
1866                 if (ret)
1867                         goto error;
1868         }
1869
1870         return 0;
1871  error:
1872         iwl_mvm_stop_device(mvm);
1873         return ret;
1874 }
1875
1876 void iwl_mvm_rx_mfuart_notif(struct iwl_mvm *mvm,
1877                              struct iwl_rx_cmd_buffer *rxb)
1878 {
1879         struct iwl_rx_packet *pkt = rxb_addr(rxb);
1880         struct iwl_mfuart_load_notif *mfuart_notif = (void *)pkt->data;
1881
1882         IWL_DEBUG_INFO(mvm,
1883                        "MFUART: installed ver: 0x%08x, external ver: 0x%08x, status: 0x%08x, duration: 0x%08x\n",
1884                        le32_to_cpu(mfuart_notif->installed_ver),
1885                        le32_to_cpu(mfuart_notif->external_ver),
1886                        le32_to_cpu(mfuart_notif->status),
1887                        le32_to_cpu(mfuart_notif->duration));
1888
1889         if (iwl_rx_packet_payload_len(pkt) == sizeof(*mfuart_notif))
1890                 IWL_DEBUG_INFO(mvm,
1891                                "MFUART: image size: 0x%08x\n",
1892                                le32_to_cpu(mfuart_notif->image_size));
1893 }