drivers/net/wireless/intel/iwlwifi/mvm/fw.c

   1 /******************************************************************************
   2  *
   3  * This file is provided under a dual BSD/GPLv2 license.  When using or
   4  * redistributing this file, you may do so under either license.
   5  *
   6  * GPL LICENSE SUMMARY
   7  *
   8  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
   9  * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
  10  * Copyright(c) 2012 - 2014, 2018 - 2020 Intel Corporation
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of version 2 of the GNU General Public License as
  14  * published by the Free Software Foundation.
  15  *
  16  * This program is distributed in the hope that it will be useful, but
  17  * WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * General Public License for more details.
  20  *
  21  * The full GNU General Public License is included in this distribution
  22  * in the file called COPYING.
  23  *
  24  * Contact Information:
  25  *  Intel Linux Wireless <linuxwifi@intel.com>
  26  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  27  *
  28  * BSD LICENSE
  29  *
  30  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  31  * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
  32  * Copyright(c) 2012 - 2014, 2018 - 2020 Intel Corporation
  33  * All rights reserved.
  34  *
  35  * Redistribution and use in source and binary forms, with or without
  36  * modification, are permitted provided that the following conditions
  37  * are met:
  38  *
  39  *  * Redistributions of source code must retain the above copyright
  40  *    notice, this list of conditions and the following disclaimer.
  41  *  * Redistributions in binary form must reproduce the above copyright
  42  *    notice, this list of conditions and the following disclaimer in
  43  *    the documentation and/or other materials provided with the
  44  *    distribution.
  45  *  * Neither the name Intel Corporation nor the names of its
  46  *    contributors may be used to endorse or promote products derived
  47  *    from this software without specific prior written permission.
  48  *
  49  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  50  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  51  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  52  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  53  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  54  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  55  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  56  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  57  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  58  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  59  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  60  *
  61  *****************************************************************************/
  62 #include <net/mac80211.h>
  63 #include <linux/netdevice.h>
  64
  65 #include "iwl-trans.h"
  66 #include "iwl-op-mode.h"
  67 #include "fw/img.h"
  68 #include "iwl-debug.h"
  69 #include "iwl-csr.h" /* for iwl_mvm_rx_card_state_notif */
  70 #include "iwl-io.h" /* for iwl_mvm_rx_card_state_notif */
  71 #include "iwl-prph.h"
  72 #include "fw/acpi.h"
  73
  74 #include "mvm.h"
  75 #include "fw/dbg.h"
  76 #include "iwl-phy-db.h"
  77 #include "iwl-modparams.h"
  78 #include "iwl-nvm-parse.h"
  79
  80 #define MVM_UCODE_ALIVE_TIMEOUT HZ
  81 #define MVM_UCODE_CALIB_TIMEOUT (2*HZ)
  82
  83 #define UCODE_VALID_OK  cpu_to_le32(0x1)
  84
  85 struct iwl_mvm_alive_data {
  86         bool valid;
  87         u32 scd_base_addr;
  88 };
  89
  90 /* set device type and latency */
  91 static int iwl_set_soc_latency(struct iwl_mvm *mvm)
  92 {
  93         struct iwl_soc_configuration_cmd cmd;
  94         int ret;
  95
  96         cmd.device_type = (mvm->trans->trans_cfg->integrated) ?
  97                 cpu_to_le32(SOC_CONFIG_CMD_INTEGRATED) :
  98                 cpu_to_le32(SOC_CONFIG_CMD_DISCRETE);
  99         cmd.soc_latency = cpu_to_le32(mvm->trans->trans_cfg->xtal_latency);
 100
 101         ret = iwl_mvm_send_cmd_pdu(mvm, iwl_cmd_id(SOC_CONFIGURATION_CMD,
 102                                                    SYSTEM_GROUP, 0), 0,
 103                                    sizeof(cmd), &cmd);
 104         if (ret)
 105                 IWL_ERR(mvm, "Failed to set soc latency: %d\n", ret);
 106         return ret;
 107 }
 108
 109 static int iwl_send_tx_ant_cfg(struct iwl_mvm *mvm, u8 valid_tx_ant)
 110 {
 111         struct iwl_tx_ant_cfg_cmd tx_ant_cmd = {
 112                 .valid = cpu_to_le32(valid_tx_ant),
 113         };
 114
 115         IWL_DEBUG_FW(mvm, "select valid tx ant: %u\n", valid_tx_ant);
 116         return iwl_mvm_send_cmd_pdu(mvm, TX_ANT_CONFIGURATION_CMD, 0,
 117                                     sizeof(tx_ant_cmd), &tx_ant_cmd);
 118 }
 119
 120 static int iwl_send_rss_cfg_cmd(struct iwl_mvm *mvm)
 121 {
 122         int i;
 123         struct iwl_rss_config_cmd cmd = {
 124                 .flags = cpu_to_le32(IWL_RSS_ENABLE),
 125                 .hash_mask = BIT(IWL_RSS_HASH_TYPE_IPV4_TCP) |
 126                              BIT(IWL_RSS_HASH_TYPE_IPV4_UDP) |
 127                              BIT(IWL_RSS_HASH_TYPE_IPV4_PAYLOAD) |
 128                              BIT(IWL_RSS_HASH_TYPE_IPV6_TCP) |
 129                              BIT(IWL_RSS_HASH_TYPE_IPV6_UDP) |
 130                              BIT(IWL_RSS_HASH_TYPE_IPV6_PAYLOAD),
 131         };
 132
 133         if (mvm->trans->num_rx_queues == 1)
 134                 return 0;
 135
 136         /* Do not direct RSS traffic to Q 0 which is our fallback queue */
 137         for (i = 0; i < ARRAY_SIZE(cmd.indirection_table); i++)
 138                 cmd.indirection_table[i] =
 139                         1 + (i % (mvm->trans->num_rx_queues - 1));
 140         netdev_rss_key_fill(cmd.secret_key, sizeof(cmd.secret_key));
 141
 142         return iwl_mvm_send_cmd_pdu(mvm, RSS_CONFIG_CMD, 0, sizeof(cmd), &cmd);
 143 }
 144
 145 static int iwl_configure_rxq(struct iwl_mvm *mvm)
 146 {
 147         int i, num_queues, size, ret;
 148         struct iwl_rfh_queue_config *cmd;
 149         struct iwl_host_cmd hcmd = {
 150                 .id = WIDE_ID(DATA_PATH_GROUP, RFH_QUEUE_CONFIG_CMD),
 151                 .dataflags[0] = IWL_HCMD_DFL_NOCOPY,
 152         };
 153
 154         /* Do not configure default queue, it is configured via context info */
 155         num_queues = mvm->trans->num_rx_queues - 1;
 156
 157         size = struct_size(cmd, data, num_queues);
 158
 159         cmd = kzalloc(size, GFP_KERNEL);
 160         if (!cmd)
 161                 return -ENOMEM;
 162
 163         cmd->num_queues = num_queues;
 164
 165         for (i = 0; i < num_queues; i++) {
 166                 struct iwl_trans_rxq_dma_data data;
 167
 168                 cmd->data[i].q_num = i + 1;
 169                 iwl_trans_get_rxq_dma_data(mvm->trans, i + 1, &data);
 170
 171                 cmd->data[i].fr_bd_cb = cpu_to_le64(data.fr_bd_cb);
 172                 cmd->data[i].urbd_stts_wrptr =
 173                         cpu_to_le64(data.urbd_stts_wrptr);
 174                 cmd->data[i].ur_bd_cb = cpu_to_le64(data.ur_bd_cb);
 175                 cmd->data[i].fr_bd_wid = cpu_to_le32(data.fr_bd_wid);
 176         }
 177
 178         hcmd.data[0] = cmd;
 179         hcmd.len[0] = size;
 180
 181         ret = iwl_mvm_send_cmd(mvm, &hcmd);
 182
 183         kfree(cmd);
 184
 185         return ret;
 186 }
 187
 188 static int iwl_mvm_send_dqa_cmd(struct iwl_mvm *mvm)
 189 {
 190         struct iwl_dqa_enable_cmd dqa_cmd = {
 191                 .cmd_queue = cpu_to_le32(IWL_MVM_DQA_CMD_QUEUE),
 192         };
 193         u32 cmd_id = iwl_cmd_id(DQA_ENABLE_CMD, DATA_PATH_GROUP, 0);
 194         int ret;
 195
 196         ret = iwl_mvm_send_cmd_pdu(mvm, cmd_id, 0, sizeof(dqa_cmd), &dqa_cmd);
 197         if (ret)
 198                 IWL_ERR(mvm, "Failed to send DQA enabling command: %d\n", ret);
 199         else
 200                 IWL_DEBUG_FW(mvm, "Working in DQA mode\n");
 201
 202         return ret;
 203 }
 204
 205 void iwl_mvm_mfu_assert_dump_notif(struct iwl_mvm *mvm,
 206                                    struct iwl_rx_cmd_buffer *rxb)
 207 {
 208         struct iwl_rx_packet *pkt = rxb_addr(rxb);
 209         struct iwl_mfu_assert_dump_notif *mfu_dump_notif = (void *)pkt->data;
 210         __le32 *dump_data = mfu_dump_notif->data;
 211         int n_words = le32_to_cpu(mfu_dump_notif->data_size) / sizeof(__le32);
 212         int i;
 213
 214         if (mfu_dump_notif->index_num == 0)
 215                 IWL_INFO(mvm, "MFUART assert id 0x%x occurred\n",
 216                          le32_to_cpu(mfu_dump_notif->assert_id));
 217
 218         for (i = 0; i < n_words; i++)
 219                 IWL_DEBUG_INFO(mvm,
 220                                "MFUART assert dump, dword %u: 0x%08x\n",
 221                                le16_to_cpu(mfu_dump_notif->index_num) *
 222                                n_words + i,
 223                                le32_to_cpu(dump_data[i]));
 224 }
 225
 226 static bool iwl_alive_fn(struct iwl_notif_wait_data *notif_wait,
 227                          struct iwl_rx_packet *pkt, void *data)
 228 {
 229         struct iwl_mvm *mvm =
 230                 container_of(notif_wait, struct iwl_mvm, notif_wait);
 231         struct iwl_mvm_alive_data *alive_data = data;
 232         struct mvm_alive_resp_v3 *palive3;
 233         struct mvm_alive_resp *palive;
 234         struct iwl_umac_alive *umac;
 235         struct iwl_lmac_alive *lmac1;
 236         struct iwl_lmac_alive *lmac2 = NULL;
 237         u16 status;
 238         u32 lmac_error_event_table, umac_error_event_table;
 239
 240         if (iwl_rx_packet_payload_len(pkt) == sizeof(*palive)) {
 241                 palive = (void *)pkt->data;
 242                 umac = &palive->umac_data;
 243                 lmac1 = &palive->lmac_data[0];
 244                 lmac2 = &palive->lmac_data[1];
 245                 status = le16_to_cpu(palive->status);
 246         } else {
 247                 palive3 = (void *)pkt->data;
 248                 umac = &palive3->umac_data;
 249                 lmac1 = &palive3->lmac_data;
 250                 status = le16_to_cpu(palive3->status);
 251         }
 252
 253         lmac_error_event_table =
 254                 le32_to_cpu(lmac1->dbg_ptrs.error_event_table_ptr);
 255         iwl_fw_lmac1_set_alive_err_table(mvm->trans, lmac_error_event_table);
 256
 257         if (lmac2)
 258                 mvm->trans->dbg.lmac_error_event_table[1] =
 259                         le32_to_cpu(lmac2->dbg_ptrs.error_event_table_ptr);
 260
 261         umac_error_event_table = le32_to_cpu(umac->dbg_ptrs.error_info_addr);
 262
 263         if (!umac_error_event_table) {
 264                 mvm->support_umac_log = false;
 265         } else if (umac_error_event_table >=
 266                    mvm->trans->cfg->min_umac_error_event_table) {
 267                 mvm->support_umac_log = true;
 268         } else {
 269                 IWL_ERR(mvm,
 270                         "Not valid error log pointer 0x%08X for %s uCode\n",
 271                         umac_error_event_table,
 272                         (mvm->fwrt.cur_fw_img == IWL_UCODE_INIT) ?
 273                         "Init" : "RT");
 274                 mvm->support_umac_log = false;
 275         }
 276
 277         if (mvm->support_umac_log)
 278                 iwl_fw_umac_set_alive_err_table(mvm->trans,
 279                                                 umac_error_event_table);
 280
 281         alive_data->scd_base_addr = le32_to_cpu(lmac1->dbg_ptrs.scd_base_ptr);
 282         alive_data->valid = status == IWL_ALIVE_STATUS_OK;
 283
 284         IWL_DEBUG_FW(mvm,
 285                      "Alive ucode status 0x%04x revision 0x%01X 0x%01X\n",
 286                      status, lmac1->ver_type, lmac1->ver_subtype);
 287
 288         if (lmac2)
 289                 IWL_DEBUG_FW(mvm, "Alive ucode CDB\n");
 290
 291         IWL_DEBUG_FW(mvm,
 292                      "UMAC version: Major - 0x%x, Minor - 0x%x\n",
 293                      le32_to_cpu(umac->umac_major),
 294                      le32_to_cpu(umac->umac_minor));
 295
 296         iwl_fwrt_update_fw_versions(&mvm->fwrt, lmac1, umac);
 297
 298         return true;
 299 }
 300
 301 static bool iwl_wait_init_complete(struct iwl_notif_wait_data *notif_wait,
 302                                    struct iwl_rx_packet *pkt, void *data)
 303 {
 304         WARN_ON(pkt->hdr.cmd != INIT_COMPLETE_NOTIF);
 305
 306         return true;
 307 }
 308
 309 static bool iwl_wait_phy_db_entry(struct iwl_notif_wait_data *notif_wait,
 310                                   struct iwl_rx_packet *pkt, void *data)
 311 {
 312         struct iwl_phy_db *phy_db = data;
 313
 314         if (pkt->hdr.cmd != CALIB_RES_NOTIF_PHY_DB) {
 315                 WARN_ON(pkt->hdr.cmd != INIT_COMPLETE_NOTIF);
 316                 return true;
 317         }
 318
 319         WARN_ON(iwl_phy_db_set_section(phy_db, pkt));
 320
 321         return false;
 322 }
 323
 324 static int iwl_mvm_load_ucode_wait_alive(struct iwl_mvm *mvm,
 325                                          enum iwl_ucode_type ucode_type)
 326 {
 327         struct iwl_notification_wait alive_wait;
 328         struct iwl_mvm_alive_data alive_data = {};
 329         const struct fw_img *fw;
 330         int ret;
 331         enum iwl_ucode_type old_type = mvm->fwrt.cur_fw_img;
 332         static const u16 alive_cmd[] = { MVM_ALIVE };
 333         bool run_in_rfkill =
 334                 ucode_type == IWL_UCODE_INIT || iwl_mvm_has_unified_ucode(mvm);
 335
 336         if (ucode_type == IWL_UCODE_REGULAR &&
 337             iwl_fw_dbg_conf_usniffer(mvm->fw, FW_DBG_START_FROM_ALIVE) &&
 338             !(fw_has_capa(&mvm->fw->ucode_capa,
 339                           IWL_UCODE_TLV_CAPA_USNIFFER_UNIFIED)))
 340                 fw = iwl_get_ucode_image(mvm->fw, IWL_UCODE_REGULAR_USNIFFER);
 341         else
 342                 fw = iwl_get_ucode_image(mvm->fw, ucode_type);
 343         if (WARN_ON(!fw))
 344                 return -EINVAL;
 345         iwl_fw_set_current_image(&mvm->fwrt, ucode_type);
 346         clear_bit(IWL_MVM_STATUS_FIRMWARE_RUNNING, &mvm->status);
 347
 348         iwl_init_notification_wait(&mvm->notif_wait, &alive_wait,
 349                                    alive_cmd, ARRAY_SIZE(alive_cmd),
 350                                    iwl_alive_fn, &alive_data);
 351
 352         /*
 353          * We want to load the INIT firmware even in RFKILL
 354          * For the unified firmware case, the ucode_type is not
 355          * INIT, but we still need to run it.
 356          */
 357         ret = iwl_trans_start_fw(mvm->trans, fw, run_in_rfkill);
 358         if (ret) {
 359                 iwl_fw_set_current_image(&mvm->fwrt, old_type);
 360                 iwl_remove_notification(&mvm->notif_wait, &alive_wait);
 361                 return ret;
 362         }
 363
 364         /*
 365          * Some things may run in the background now, but we
 366          * just wait for the ALIVE notification here.
 367          */
 368         ret = iwl_wait_notification(&mvm->notif_wait, &alive_wait,
 369                                     MVM_UCODE_ALIVE_TIMEOUT);
 370         if (ret) {
 371                 struct iwl_trans *trans = mvm->trans;
 372
 373                 if (trans->trans_cfg->device_family >=
 374                                         IWL_DEVICE_FAMILY_22000) {
 375                         IWL_ERR(mvm,
 376                                 "SecBoot CPU1 Status: 0x%x, CPU2 Status: 0x%x\n",
 377                                 iwl_read_umac_prph(trans, UMAG_SB_CPU_1_STATUS),
 378                                 iwl_read_umac_prph(trans,
 379                                                    UMAG_SB_CPU_2_STATUS));
 380                         IWL_ERR(mvm, "UMAC PC: 0x%x\n",
 381                                 iwl_read_umac_prph(trans,
 382                                                    UREG_UMAC_CURRENT_PC));
 383                         IWL_ERR(mvm, "LMAC PC: 0x%x\n",
 384                                 iwl_read_umac_prph(trans,
 385                                                    UREG_LMAC1_CURRENT_PC));
 386                         if (iwl_mvm_is_cdb_supported(mvm))
 387                                 IWL_ERR(mvm, "LMAC2 PC: 0x%x\n",
 388                                         iwl_read_umac_prph(trans,
 389                                                 UREG_LMAC2_CURRENT_PC));
 390                 } else if (trans->trans_cfg->device_family >=
 391                            IWL_DEVICE_FAMILY_8000) {
 392                         IWL_ERR(mvm,
 393                                 "SecBoot CPU1 Status: 0x%x, CPU2 Status: 0x%x\n",
 394                                 iwl_read_prph(trans, SB_CPU_1_STATUS),
 395                                 iwl_read_prph(trans, SB_CPU_2_STATUS));
 396                 }
 397
 398                 if (ret == -ETIMEDOUT)
 399                         iwl_fw_dbg_error_collect(&mvm->fwrt,
 400                                                  FW_DBG_TRIGGER_ALIVE_TIMEOUT);
 401
 402                 iwl_fw_set_current_image(&mvm->fwrt, old_type);
 403                 return ret;
 404         }
 405
 406         if (!alive_data.valid) {
 407                 IWL_ERR(mvm, "Loaded ucode is not valid!\n");
 408                 iwl_fw_set_current_image(&mvm->fwrt, old_type);
 409                 return -EIO;
 410         }
 411
 412         iwl_trans_fw_alive(mvm->trans, alive_data.scd_base_addr);
 413
 414         /*
 415          * Note: all the queues are enabled as part of the interface
 416          * initialization, but in firmware restart scenarios they
 417          * could be stopped, so wake them up. In firmware restart,
 418          * mac80211 will have the queues stopped as well until the
 419          * reconfiguration completes. During normal startup, they
 420          * will be empty.
 421          */
 422
 423         memset(&mvm->queue_info, 0, sizeof(mvm->queue_info));
 424         /*
 425          * Set a 'fake' TID for the command queue, since we use the
 426          * hweight() of the tid_bitmap as a refcount now. Not that
 427          * we ever even consider the command queue as one we might
 428          * want to reuse, but be safe nevertheless.
 429          */
 430         mvm->queue_info[IWL_MVM_DQA_CMD_QUEUE].tid_bitmap =
 431                 BIT(IWL_MAX_TID_COUNT + 2);
 432
 433         set_bit(IWL_MVM_STATUS_FIRMWARE_RUNNING, &mvm->status);
 434 #ifdef CONFIG_IWLWIFI_DEBUGFS
 435         iwl_fw_set_dbg_rec_on(&mvm->fwrt);
 436 #endif
 437
 438         return 0;
 439 }
 440
 441 static int iwl_run_unified_mvm_ucode(struct iwl_mvm *mvm, bool read_nvm)
 442 {
 443         struct iwl_notification_wait init_wait;
 444         struct iwl_nvm_access_complete_cmd nvm_complete = {};
 445         struct iwl_init_extended_cfg_cmd init_cfg = {
 446                 .init_flags = cpu_to_le32(BIT(IWL_INIT_NVM)),
 447         };
 448         static const u16 init_complete[] = {
 449                 INIT_COMPLETE_NOTIF,
 450         };
 451         int ret;
 452
 453         if (mvm->trans->cfg->tx_with_siso_diversity)
 454                 init_cfg.init_flags |= cpu_to_le32(BIT(IWL_INIT_PHY));
 455
 456         lockdep_assert_held(&mvm->mutex);
 457
 458         mvm->rfkill_safe_init_done = false;
 459
 460         iwl_init_notification_wait(&mvm->notif_wait,
 461                                    &init_wait,
 462                                    init_complete,
 463                                    ARRAY_SIZE(init_complete),
 464                                    iwl_wait_init_complete,
 465                                    NULL);
 466
 467         iwl_dbg_tlv_time_point(&mvm->fwrt, IWL_FW_INI_TIME_POINT_EARLY, NULL);
 468
 469         /* Will also start the device */
 470         ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_REGULAR);
 471         if (ret) {
 472                 IWL_ERR(mvm, "Failed to start RT ucode: %d\n", ret);
 473                 goto error;
 474         }
 475         iwl_dbg_tlv_time_point(&mvm->fwrt, IWL_FW_INI_TIME_POINT_AFTER_ALIVE,
 476                                NULL);
 477
 478         /* Send init config command to mark that we are sending NVM access
 479          * commands
 480          */
 481         ret = iwl_mvm_send_cmd_pdu(mvm, WIDE_ID(SYSTEM_GROUP,
 482                                                 INIT_EXTENDED_CFG_CMD),
 483                                    CMD_SEND_IN_RFKILL,
 484                                    sizeof(init_cfg), &init_cfg);
 485         if (ret) {
 486                 IWL_ERR(mvm, "Failed to run init config command: %d\n",
 487                         ret);
 488                 goto error;
 489         }
 490
 491         /* Load NVM to NIC if needed */
 492         if (mvm->nvm_file_name) {
 493                 iwl_read_external_nvm(mvm->trans, mvm->nvm_file_name,
 494                                       mvm->nvm_sections);
 495                 iwl_mvm_load_nvm_to_nic(mvm);
 496         }
 497
 498         if (IWL_MVM_PARSE_NVM && read_nvm) {
 499                 ret = iwl_nvm_init(mvm);
 500                 if (ret) {
 501                         IWL_ERR(mvm, "Failed to read NVM: %d\n", ret);
 502                         goto error;
 503                 }
 504         }
 505
 506         ret = iwl_mvm_send_cmd_pdu(mvm, WIDE_ID(REGULATORY_AND_NVM_GROUP,
 507                                                 NVM_ACCESS_COMPLETE),
 508                                    CMD_SEND_IN_RFKILL,
 509                                    sizeof(nvm_complete), &nvm_complete);
 510         if (ret) {
 511                 IWL_ERR(mvm, "Failed to run complete NVM access: %d\n",
 512                         ret);
 513                 goto error;
 514         }
 515
 516         /* We wait for the INIT complete notification */
 517         ret = iwl_wait_notification(&mvm->notif_wait, &init_wait,
 518                                     MVM_UCODE_ALIVE_TIMEOUT);
 519         if (ret)
 520                 return ret;
 521
 522         /* Read the NVM only at driver load time, no need to do this twice */
 523         if (!IWL_MVM_PARSE_NVM && read_nvm) {
 524                 mvm->nvm_data = iwl_get_nvm(mvm->trans, mvm->fw);
 525                 if (IS_ERR(mvm->nvm_data)) {
 526                         ret = PTR_ERR(mvm->nvm_data);
 527                         mvm->nvm_data = NULL;
 528                         IWL_ERR(mvm, "Failed to read NVM: %d\n", ret);
 529                         return ret;
 530                 }
 531         }
 532
 533         mvm->rfkill_safe_init_done = true;
 534
 535         return 0;
 536
 537 error:
 538         iwl_remove_notification(&mvm->notif_wait, &init_wait);
 539         return ret;
 540 }
 541
 542 static int iwl_send_phy_cfg_cmd(struct iwl_mvm *mvm)
 543 {
 544         struct iwl_phy_cfg_cmd phy_cfg_cmd;
 545         enum iwl_ucode_type ucode_type = mvm->fwrt.cur_fw_img;
 546
 547         if (iwl_mvm_has_unified_ucode(mvm) &&
 548             !mvm->trans->cfg->tx_with_siso_diversity)
 549                 return 0;
 550
 551         if (mvm->trans->cfg->tx_with_siso_diversity) {
 552                 /*
 553                  * TODO: currently we don't set the antenna but letting the NIC
 554                  * to decide which antenna to use. This should come from BIOS.
 555                  */
 556                 phy_cfg_cmd.phy_cfg =
 557                         cpu_to_le32(FW_PHY_CFG_CHAIN_SAD_ENABLED);
 558         }
 559
 560         /* Set parameters */
 561         phy_cfg_cmd.phy_cfg = cpu_to_le32(iwl_mvm_get_phy_config(mvm));
 562
 563         /* set flags extra PHY configuration flags from the device's cfg */
 564         phy_cfg_cmd.phy_cfg |=
 565                 cpu_to_le32(mvm->trans->trans_cfg->extra_phy_cfg_flags);
 566
 567         phy_cfg_cmd.calib_control.event_trigger =
 568                 mvm->fw->default_calib[ucode_type].event_trigger;
 569         phy_cfg_cmd.calib_control.flow_trigger =
 570                 mvm->fw->default_calib[ucode_type].flow_trigger;
 571
 572         IWL_DEBUG_INFO(mvm, "Sending Phy CFG command: 0x%x\n",
 573                        phy_cfg_cmd.phy_cfg);
 574
 575         return iwl_mvm_send_cmd_pdu(mvm, PHY_CONFIGURATION_CMD, 0,
 576                                     sizeof(phy_cfg_cmd), &phy_cfg_cmd);
 577 }
 578
 579 int iwl_run_init_mvm_ucode(struct iwl_mvm *mvm, bool read_nvm)
 580 {
 581         struct iwl_notification_wait calib_wait;
 582         static const u16 init_complete[] = {
 583                 INIT_COMPLETE_NOTIF,
 584                 CALIB_RES_NOTIF_PHY_DB
 585         };
 586         int ret;
 587
 588         if (iwl_mvm_has_unified_ucode(mvm))
 589                 return iwl_run_unified_mvm_ucode(mvm, true);
 590
 591         lockdep_assert_held(&mvm->mutex);
 592
 593         mvm->rfkill_safe_init_done = false;
 594
 595         iwl_init_notification_wait(&mvm->notif_wait,
 596                                    &calib_wait,
 597                                    init_complete,
 598                                    ARRAY_SIZE(init_complete),
 599                                    iwl_wait_phy_db_entry,
 600                                    mvm->phy_db);
 601
 602         /* Will also start the device */
 603         ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_INIT);
 604         if (ret) {
 605                 IWL_ERR(mvm, "Failed to start INIT ucode: %d\n", ret);
 606                 goto remove_notif;
 607         }
 608
 609         if (mvm->trans->trans_cfg->device_family < IWL_DEVICE_FAMILY_8000) {
 610                 ret = iwl_mvm_send_bt_init_conf(mvm);
 611                 if (ret)
 612                         goto remove_notif;
 613         }
 614
 615         /* Read the NVM only at driver load time, no need to do this twice */
 616         if (read_nvm) {
 617                 ret = iwl_nvm_init(mvm);
 618                 if (ret) {
 619                         IWL_ERR(mvm, "Failed to read NVM: %d\n", ret);
 620                         goto remove_notif;
 621                 }
 622         }
 623
 624         /* In case we read the NVM from external file, load it to the NIC */
 625         if (mvm->nvm_file_name)
 626                 iwl_mvm_load_nvm_to_nic(mvm);
 627
 628         WARN_ONCE(mvm->nvm_data->nvm_version < mvm->trans->cfg->nvm_ver,
 629                   "Too old NVM version (0x%0x, required = 0x%0x)",
 630                   mvm->nvm_data->nvm_version, mvm->trans->cfg->nvm_ver);
 631
 632         /*
 633          * abort after reading the nvm in case RF Kill is on, we will complete
 634          * the init seq later when RF kill will switch to off
 635          */
 636         if (iwl_mvm_is_radio_hw_killed(mvm)) {
 637                 IWL_DEBUG_RF_KILL(mvm,
 638                                   "jump over all phy activities due to RF kill\n");
 639                 goto remove_notif;
 640         }
 641
 642         mvm->rfkill_safe_init_done = true;
 643
 644         /* Send TX valid antennas before triggering calibrations */
 645         ret = iwl_send_tx_ant_cfg(mvm, iwl_mvm_get_valid_tx_ant(mvm));
 646         if (ret)
 647                 goto remove_notif;
 648
 649         ret = iwl_send_phy_cfg_cmd(mvm);
 650         if (ret) {
 651                 IWL_ERR(mvm, "Failed to run INIT calibrations: %d\n",
 652                         ret);
 653                 goto remove_notif;
 654         }
 655
 656         /*
 657          * Some things may run in the background now, but we
 658          * just wait for the calibration complete notification.
 659          */
 660         ret = iwl_wait_notification(&mvm->notif_wait, &calib_wait,
 661                                     MVM_UCODE_CALIB_TIMEOUT);
 662         if (!ret)
 663                 goto out;
 664
 665         if (iwl_mvm_is_radio_hw_killed(mvm)) {
 666                 IWL_DEBUG_RF_KILL(mvm, "RFKILL while calibrating.\n");
 667                 ret = 0;
 668         } else {
 669                 IWL_ERR(mvm, "Failed to run INIT calibrations: %d\n",
 670                         ret);
 671         }
 672
 673         goto out;
 674
 675 remove_notif:
 676         iwl_remove_notification(&mvm->notif_wait, &calib_wait);
 677 out:
 678         mvm->rfkill_safe_init_done = false;
 679         if (iwlmvm_mod_params.init_dbg && !mvm->nvm_data) {
 680                 /* we want to debug INIT and we have no NVM - fake */
 681                 mvm->nvm_data = kzalloc(sizeof(struct iwl_nvm_data) +
 682                                         sizeof(struct ieee80211_channel) +
 683                                         sizeof(struct ieee80211_rate),
 684                                         GFP_KERNEL);
 685                 if (!mvm->nvm_data)
 686                         return -ENOMEM;
 687                 mvm->nvm_data->bands[0].channels = mvm->nvm_data->channels;
 688                 mvm->nvm_data->bands[0].n_channels = 1;
 689                 mvm->nvm_data->bands[0].n_bitrates = 1;
 690                 mvm->nvm_data->bands[0].bitrates =
 691                         (void *)mvm->nvm_data->channels + 1;
 692                 mvm->nvm_data->bands[0].bitrates->hw_value = 10;
 693         }
 694
 695         return ret;
 696 }
 697
 698 static int iwl_mvm_config_ltr(struct iwl_mvm *mvm)
 699 {
 700         struct iwl_ltr_config_cmd cmd = {
 701                 .flags = cpu_to_le32(LTR_CFG_FLAG_FEATURE_ENABLE),
 702         };
 703
 704         if (!mvm->trans->ltr_enabled)
 705                 return 0;
 706
 707         return iwl_mvm_send_cmd_pdu(mvm, LTR_CONFIG, 0,
 708                                     sizeof(cmd), &cmd);
 709 }
 710
 711 #ifdef CONFIG_ACPI
 712 int iwl_mvm_sar_select_profile(struct iwl_mvm *mvm, int prof_a, int prof_b)
 713 {
 714         union {
 715                 struct iwl_dev_tx_power_cmd v5;
 716                 struct iwl_dev_tx_power_cmd_v4 v4;
 717         } cmd;
 718
 719         u16 len = 0;
 720
 721         cmd.v5.v3.set_mode = cpu_to_le32(IWL_TX_POWER_MODE_SET_CHAINS);
 722
 723         if (fw_has_api(&mvm->fw->ucode_capa,
 724                        IWL_UCODE_TLV_API_REDUCE_TX_POWER))
 725                 len = sizeof(cmd.v5);
 726         else if (fw_has_capa(&mvm->fw->ucode_capa,
 727                              IWL_UCODE_TLV_CAPA_TX_POWER_ACK))
 728                 len = sizeof(struct iwl_dev_tx_power_cmd_v4);
 729         else
 730                 len = sizeof(cmd.v4.v3);
 731
 732
 733         if (iwl_sar_select_profile(&mvm->fwrt, cmd.v5.v3.per_chain_restriction,
 734                                    prof_a, prof_b))
 735                 return -ENOENT;
 736         IWL_DEBUG_RADIO(mvm, "Sending REDUCE_TX_POWER_CMD per chain\n");
 737         return iwl_mvm_send_cmd_pdu(mvm, REDUCE_TX_POWER_CMD, 0, len, &cmd);
 738 }
 739
 740 int iwl_mvm_get_sar_geo_profile(struct iwl_mvm *mvm)
 741 {
 742         union geo_tx_power_profiles_cmd geo_tx_cmd;
 743         u16 len;
 744         int ret;
 745         struct iwl_host_cmd cmd;
 746
 747         if (fw_has_api(&mvm->fwrt.fw->ucode_capa,
 748                        IWL_UCODE_TLV_API_SAR_TABLE_VER)) {
 749                 geo_tx_cmd.geo_cmd.ops =
 750                         cpu_to_le32(IWL_PER_CHAIN_OFFSET_GET_CURRENT_TABLE);
 751                 len = sizeof(geo_tx_cmd.geo_cmd);
 752         } else {
 753                 geo_tx_cmd.geo_cmd_v1.ops =
 754                         cpu_to_le32(IWL_PER_CHAIN_OFFSET_GET_CURRENT_TABLE);
 755                 len = sizeof(geo_tx_cmd.geo_cmd_v1);
 756         }
 757
 758         if (!iwl_sar_geo_support(&mvm->fwrt))
 759                 return -EOPNOTSUPP;
 760
 761         cmd = (struct iwl_host_cmd){
 762                 .id =  WIDE_ID(PHY_OPS_GROUP, GEO_TX_POWER_LIMIT),
 763                 .len = { len, },
 764                 .flags = CMD_WANT_SKB,
 765                 .data = { &geo_tx_cmd },
 766         };
 767
 768         ret = iwl_mvm_send_cmd(mvm, &cmd);
 769         if (ret) {
 770                 IWL_ERR(mvm, "Failed to get geographic profile info %d\n", ret);
 771                 return ret;
 772         }
 773         ret = iwl_validate_sar_geo_profile(&mvm->fwrt, &cmd);
 774         iwl_free_resp(&cmd);
 775         return ret;
 776 }
 777
 778 static int iwl_mvm_sar_geo_init(struct iwl_mvm *mvm)
 779 {
 780         u16 cmd_wide_id =  WIDE_ID(PHY_OPS_GROUP, GEO_TX_POWER_LIMIT);
 781         union geo_tx_power_profiles_cmd cmd;
 782         u16 len;
 783
 784         cmd.geo_cmd.ops = cpu_to_le32(IWL_PER_CHAIN_OFFSET_SET_TABLES);
 785
 786         iwl_sar_geo_init(&mvm->fwrt, cmd.geo_cmd.table);
 787
 788         cmd.geo_cmd.table_revision = cpu_to_le32(mvm->fwrt.geo_rev);
 789
 790         if (!fw_has_api(&mvm->fwrt.fw->ucode_capa,
 791                         IWL_UCODE_TLV_API_SAR_TABLE_VER)) {
 792                 len = sizeof(struct iwl_geo_tx_power_profiles_cmd_v1);
 793         } else {
 794                 len =  sizeof(cmd.geo_cmd);
 795         }
 796
 797         return iwl_mvm_send_cmd_pdu(mvm, cmd_wide_id, 0, len, &cmd);
 798 }
 799
 800 static int iwl_mvm_get_ppag_table(struct iwl_mvm *mvm)
 801 {
 802         union acpi_object *wifi_pkg, *data, *enabled;
 803         int i, j, ret, tbl_rev;
 804         int idx = 2;
 805
 806         mvm->fwrt.ppag_table.enabled = cpu_to_le32(0);
 807         data = iwl_acpi_get_object(mvm->dev, ACPI_PPAG_METHOD);
 808         if (IS_ERR(data))
 809                 return PTR_ERR(data);
 810
 811         wifi_pkg = iwl_acpi_get_wifi_pkg(mvm->dev, data,
 812                                          ACPI_PPAG_WIFI_DATA_SIZE, &tbl_rev);
 813
 814         if (IS_ERR(wifi_pkg)) {
 815                 ret = PTR_ERR(wifi_pkg);
 816                 goto out_free;
 817         }
 818
 819         if (tbl_rev != 0) {
 820                 ret = -EINVAL;
 821                 goto out_free;
 822         }
 823
 824         enabled = &wifi_pkg->package.elements[1];
 825         if (enabled->type != ACPI_TYPE_INTEGER ||
 826             (enabled->integer.value != 0 && enabled->integer.value != 1)) {
 827                 ret = -EINVAL;
 828                 goto out_free;
 829         }
 830
 831         mvm->fwrt.ppag_table.enabled = cpu_to_le32(enabled->integer.value);
 832         if (!mvm->fwrt.ppag_table.enabled) {
 833                 ret = 0;
 834                 goto out_free;
 835         }
 836
 837         /*
 838          * read, verify gain values and save them into the PPAG table.
 839          * first sub-band (j=0) corresponds to Low-Band (2.4GHz), and the
 840          * following sub-bands to High-Band (5GHz).
 841          */
 842         for (i = 0; i < ACPI_PPAG_NUM_CHAINS; i++) {
 843                 for (j = 0; j < ACPI_PPAG_NUM_SUB_BANDS; j++) {
 844                         union acpi_object *ent;
 845
 846                         ent = &wifi_pkg->package.elements[idx++];
 847                         if (ent->type != ACPI_TYPE_INTEGER ||
 848                             (j == 0 && ent->integer.value > ACPI_PPAG_MAX_LB) ||
 849                             (j == 0 && ent->integer.value < ACPI_PPAG_MIN_LB) ||
 850                             (j != 0 && ent->integer.value > ACPI_PPAG_MAX_HB) ||
 851                             (j != 0 && ent->integer.value < ACPI_PPAG_MIN_HB)) {
 852                                 mvm->fwrt.ppag_table.enabled = cpu_to_le32(0);
 853                                 ret = -EINVAL;
 854                                 goto out_free;
 855                         }
 856                         mvm->fwrt.ppag_table.gain[i][j] = ent->integer.value;
 857                 }
 858         }
 859         ret = 0;
 860 out_free:
 861         kfree(data);
 862         return ret;
 863 }
 864
 865 int iwl_mvm_ppag_send_cmd(struct iwl_mvm *mvm)
 866 {
 867         int i, j, ret;
 868
 869         if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_SET_PPAG)) {
 870                 IWL_DEBUG_RADIO(mvm,
 871                                 "PPAG capability not supported by FW, command not sent.\n");
 872                 return 0;
 873         }
 874
 875         if (!mvm->fwrt.ppag_table.enabled) {
 876                 IWL_DEBUG_RADIO(mvm,
 877                                 "PPAG not enabled, command not sent.\n");
 878                 return 0;
 879         }
 880
 881         IWL_DEBUG_RADIO(mvm, "Sending PER_PLATFORM_ANT_GAIN_CMD\n");
 882
 883         for (i = 0; i < ACPI_PPAG_NUM_CHAINS; i++) {
 884                 for (j = 0; j < ACPI_PPAG_NUM_SUB_BANDS; j++) {
 885                         IWL_DEBUG_RADIO(mvm,
 886                                         "PPAG table: chain[%d] band[%d]: gain = %d\n",
 887                                         i, j, mvm->fwrt.ppag_table.gain[i][j]);
 888                 }
 889         }
 890
 891         ret = iwl_mvm_send_cmd_pdu(mvm, WIDE_ID(PHY_OPS_GROUP,
 892                                                 PER_PLATFORM_ANT_GAIN_CMD),
 893                                    0, sizeof(mvm->fwrt.ppag_table),
 894                                    &mvm->fwrt.ppag_table);
 895         if (ret < 0)
 896                 IWL_ERR(mvm, "failed to send PER_PLATFORM_ANT_GAIN_CMD (%d)\n",
 897                         ret);
 898
 899         return ret;
 900 }
 901
 902 static int iwl_mvm_ppag_init(struct iwl_mvm *mvm)
 903 {
 904         int ret;
 905
 906         ret = iwl_mvm_get_ppag_table(mvm);
 907         if (ret < 0) {
 908                 IWL_DEBUG_RADIO(mvm,
 909                                 "PPAG BIOS table invalid or unavailable. (%d)\n",
 910                                 ret);
 911                 return 0;
 912         }
 913         return iwl_mvm_ppag_send_cmd(mvm);
 914 }
 915
 916 #else /* CONFIG_ACPI */
 917
 918 inline int iwl_mvm_sar_select_profile(struct iwl_mvm *mvm,
 919                                       int prof_a, int prof_b)
 920 {
 921         return -ENOENT;
 922 }
 923
 924 inline int iwl_mvm_get_sar_geo_profile(struct iwl_mvm *mvm)
 925 {
 926         return -ENOENT;
 927 }
 928
 929 static int iwl_mvm_sar_geo_init(struct iwl_mvm *mvm)
 930 {
 931         return 0;
 932 }
 933
 934 int iwl_mvm_ppag_send_cmd(struct iwl_mvm *mvm)
 935 {
 936         return -ENOENT;
 937 }
 938
 939 static int iwl_mvm_ppag_init(struct iwl_mvm *mvm)
 940 {
 941         return 0;
 942 }
 943 #endif /* CONFIG_ACPI */
 944
 945 void iwl_mvm_send_recovery_cmd(struct iwl_mvm *mvm, u32 flags)
 946 {
 947         u32 error_log_size = mvm->fw->ucode_capa.error_log_size;
 948         int ret;
 949         u32 resp;
 950
 951         struct iwl_fw_error_recovery_cmd recovery_cmd = {
 952                 .flags = cpu_to_le32(flags),
 953                 .buf_size = 0,
 954         };
 955         struct iwl_host_cmd host_cmd = {
 956                 .id = WIDE_ID(SYSTEM_GROUP, FW_ERROR_RECOVERY_CMD),
 957                 .flags = CMD_WANT_SKB,
 958                 .data = {&recovery_cmd, },
 959                 .len = {sizeof(recovery_cmd), },
 960         };
 961
 962         /* no error log was defined in TLV */
 963         if (!error_log_size)
 964                 return;
 965
 966         if (flags & ERROR_RECOVERY_UPDATE_DB) {
 967                 /* no buf was allocated while HW reset */
 968                 if (!mvm->error_recovery_buf)
 969                         return;
 970
 971                 host_cmd.data[1] = mvm->error_recovery_buf;
 972                 host_cmd.len[1] =  error_log_size;
 973                 host_cmd.dataflags[1] = IWL_HCMD_DFL_NOCOPY;
 974                 recovery_cmd.buf_size = cpu_to_le32(error_log_size);
 975         }
 976
 977         ret = iwl_mvm_send_cmd(mvm, &host_cmd);
 978         kfree(mvm->error_recovery_buf);
 979         mvm->error_recovery_buf = NULL;
 980
 981         if (ret) {
 982                 IWL_ERR(mvm, "Failed to send recovery cmd %d\n", ret);
 983                 return;
 984         }
 985
 986         /* skb respond is only relevant in ERROR_RECOVERY_UPDATE_DB */
 987         if (flags & ERROR_RECOVERY_UPDATE_DB) {
 988                 resp = le32_to_cpu(*(__le32 *)host_cmd.resp_pkt->data);
 989                 if (resp)
 990                         IWL_ERR(mvm,
 991                                 "Failed to send recovery cmd blob was invalid %d\n",
 992                                 resp);
 993         }
 994 }
 995
 996 static int iwl_mvm_sar_init(struct iwl_mvm *mvm)
 997 {
 998         int ret;
 999
1000         ret = iwl_sar_get_wrds_table(&mvm->fwrt);
1001         if (ret < 0) {
1002                 IWL_DEBUG_RADIO(mvm,
1003                                 "WRDS SAR BIOS table invalid or unavailable. (%d)\n",
1004                                 ret);
1005                 /*
1006                  * If not available, don't fail and don't bother with EWRD.
1007                  * Return 1 to tell that we can't use WGDS either.
1008                  */
1009                 return 1;
1010         }
1011
1012         ret = iwl_sar_get_ewrd_table(&mvm->fwrt);
1013         /* if EWRD is not available, we can still use WRDS, so don't fail */
1014         if (ret < 0)
1015                 IWL_DEBUG_RADIO(mvm,
1016                                 "EWRD SAR BIOS table invalid or unavailable. (%d)\n",
1017                                 ret);
1018
1019         ret = iwl_mvm_sar_select_profile(mvm, 1, 1);
1020         /*
1021          * If we don't have profile 0 from BIOS, just skip it.  This
1022          * means that SAR Geo will not be enabled either, even if we
1023          * have other valid profiles.
1024          */
1025         if (ret == -ENOENT)
1026                 return 1;
1027
1028         return ret;
1029 }
1030
1031 static int iwl_mvm_load_rt_fw(struct iwl_mvm *mvm)
1032 {
1033         int ret;
1034
1035         if (iwl_mvm_has_unified_ucode(mvm))
1036                 return iwl_run_unified_mvm_ucode(mvm, false);
1037
1038         ret = iwl_run_init_mvm_ucode(mvm, false);
1039
1040         if (ret) {
1041                 IWL_ERR(mvm, "Failed to run INIT ucode: %d\n", ret);
1042
1043                 if (iwlmvm_mod_params.init_dbg)
1044                         return 0;
1045                 return ret;
1046         }
1047
1048         iwl_fw_dbg_stop_sync(&mvm->fwrt);
1049         iwl_trans_stop_device(mvm->trans);
1050         ret = iwl_trans_start_hw(mvm->trans);
1051         if (ret)
1052                 return ret;
1053
1054         iwl_dbg_tlv_time_point(&mvm->fwrt, IWL_FW_INI_TIME_POINT_EARLY, NULL);
1055
1056         mvm->rfkill_safe_init_done = false;
1057         ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_REGULAR);
1058         if (ret)
1059                 return ret;
1060
1061         mvm->rfkill_safe_init_done = true;
1062
1063         iwl_dbg_tlv_time_point(&mvm->fwrt, IWL_FW_INI_TIME_POINT_AFTER_ALIVE,
1064                                NULL);
1065
1066         return iwl_init_paging(&mvm->fwrt, mvm->fwrt.cur_fw_img);
1067 }
1068
1069 int iwl_mvm_up(struct iwl_mvm *mvm)
1070 {
1071         int ret, i;
1072         struct ieee80211_channel *chan;
1073         struct cfg80211_chan_def chandef;
1074         struct ieee80211_supported_band *sband = NULL;
1075
1076         lockdep_assert_held(&mvm->mutex);
1077
1078         ret = iwl_trans_start_hw(mvm->trans);
1079         if (ret)
1080                 return ret;
1081
1082         ret = iwl_mvm_load_rt_fw(mvm);
1083         if (ret) {
1084                 IWL_ERR(mvm, "Failed to start RT ucode: %d\n", ret);
1085                 if (ret != -ERFKILL)
1086                         iwl_fw_dbg_error_collect(&mvm->fwrt,
1087                                                  FW_DBG_TRIGGER_DRIVER);
1088                 goto error;
1089         }
1090
1091         iwl_get_shared_mem_conf(&mvm->fwrt);
1092
1093         ret = iwl_mvm_sf_update(mvm, NULL, false);
1094         if (ret)
1095                 IWL_ERR(mvm, "Failed to initialize Smart Fifo\n");
1096
1097         if (!iwl_trans_dbg_ini_valid(mvm->trans)) {
1098                 mvm->fwrt.dump.conf = FW_DBG_INVALID;
1099                 /* if we have a destination, assume EARLY START */
1100                 if (mvm->fw->dbg.dest_tlv)
1101                         mvm->fwrt.dump.conf = FW_DBG_START_FROM_ALIVE;
1102                 iwl_fw_start_dbg_conf(&mvm->fwrt, FW_DBG_START_FROM_ALIVE);
1103         }
1104
1105         ret = iwl_send_tx_ant_cfg(mvm, iwl_mvm_get_valid_tx_ant(mvm));
1106         if (ret)
1107                 goto error;
1108
1109         if (!iwl_mvm_has_unified_ucode(mvm)) {
1110                 /* Send phy db control command and then phy db calibration */
1111                 ret = iwl_send_phy_db_data(mvm->phy_db);
1112                 if (ret)
1113                         goto error;
1114         }
1115
1116         ret = iwl_send_phy_cfg_cmd(mvm);
1117         if (ret)
1118                 goto error;
1119
1120         ret = iwl_mvm_send_bt_init_conf(mvm);
1121         if (ret)
1122                 goto error;
1123
1124         if (fw_has_capa(&mvm->fw->ucode_capa,
1125                         IWL_UCODE_TLV_CAPA_SOC_LATENCY_SUPPORT)) {
1126                 ret = iwl_set_soc_latency(mvm);
1127                 if (ret)
1128                         goto error;
1129         }
1130
1131         /* Init RSS configuration */
1132         if (mvm->trans->trans_cfg->device_family >= IWL_DEVICE_FAMILY_22000) {
1133                 ret = iwl_configure_rxq(mvm);
1134                 if (ret) {
1135                         IWL_ERR(mvm, "Failed to configure RX queues: %d\n",
1136                                 ret);
1137                         goto error;
1138                 }
1139         }
1140
1141         if (iwl_mvm_has_new_rx_api(mvm)) {
1142                 ret = iwl_send_rss_cfg_cmd(mvm);
1143                 if (ret) {
1144                         IWL_ERR(mvm, "Failed to configure RSS queues: %d\n",
1145                                 ret);
1146                         goto error;
1147                 }
1148         }
1149
1150         /* init the fw <-> mac80211 STA mapping */
1151         for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++)
1152                 RCU_INIT_POINTER(mvm->fw_id_to_mac_id[i], NULL);
1153
1154         mvm->tdls_cs.peer.sta_id = IWL_MVM_INVALID_STA;
1155
1156         /* reset quota debouncing buffer - 0xff will yield invalid data */
1157         memset(&mvm->last_quota_cmd, 0xff, sizeof(mvm->last_quota_cmd));
1158
1159         if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_DQA_SUPPORT)) {
1160                 ret = iwl_mvm_send_dqa_cmd(mvm);
1161                 if (ret)
1162                         goto error;
1163         }
1164
1165         /* Add auxiliary station for scanning */
1166         ret = iwl_mvm_add_aux_sta(mvm);
1167         if (ret)
1168                 goto error;
1169
1170         /* Add all the PHY contexts */
1171         i = 0;
1172         while (!sband && i < NUM_NL80211_BANDS)
1173                 sband = mvm->hw->wiphy->bands[i++];
1174
1175         if (WARN_ON_ONCE(!sband))
1176                 goto error;
1177
1178         chan = &sband->channels[0];
1179
1180         cfg80211_chandef_create(&chandef, chan, NL80211_CHAN_NO_HT);
1181         for (i = 0; i < NUM_PHY_CTX; i++) {
1182                 /*
1183                  * The channel used here isn't relevant as it's
1184                  * going to be overwritten in the other flows.
1185                  * For now use the first channel we have.
1186                  */
1187                 ret = iwl_mvm_phy_ctxt_add(mvm, &mvm->phy_ctxts[i],
1188                                            &chandef, 1, 1);
1189                 if (ret)
1190                         goto error;
1191         }
1192
1193         if (iwl_mvm_is_tt_in_fw(mvm)) {
1194                 /* in order to give the responsibility of ct-kill and
1195                  * TX backoff to FW we need to send empty temperature reporting
1196                  * cmd during init time
1197                  */
1198                 iwl_mvm_send_temp_report_ths_cmd(mvm);
1199         } else {
1200                 /* Initialize tx backoffs to the minimal possible */
1201                 iwl_mvm_tt_tx_backoff(mvm, 0);
1202         }
1203
1204 #ifdef CONFIG_THERMAL
1205         /* TODO: read the budget from BIOS / Platform NVM */
1206
1207         /*
1208          * In case there is no budget from BIOS / Platform NVM the default
1209          * budget should be 2000mW (cooling state 0).
1210          */
1211         if (iwl_mvm_is_ctdp_supported(mvm)) {
1212                 ret = iwl_mvm_ctdp_command(mvm, CTDP_CMD_OPERATION_START,
1213                                            mvm->cooling_dev.cur_state);
1214                 if (ret)
1215                         goto error;
1216         }
1217 #endif
1218
1219         if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_SET_LTR_GEN2))
1220                 WARN_ON(iwl_mvm_config_ltr(mvm));
1221
1222         ret = iwl_mvm_power_update_device(mvm);
1223         if (ret)
1224                 goto error;
1225
1226         /*
1227          * RTNL is not taken during Ct-kill, but we don't need to scan/Tx
1228          * anyway, so don't init MCC.
1229          */
1230         if (!test_bit(IWL_MVM_STATUS_HW_CTKILL, &mvm->status)) {
1231                 ret = iwl_mvm_init_mcc(mvm);
1232                 if (ret)
1233                         goto error;
1234         }
1235
1236         if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
1237                 mvm->scan_type = IWL_SCAN_TYPE_NOT_SET;
1238                 mvm->hb_scan_type = IWL_SCAN_TYPE_NOT_SET;
1239                 ret = iwl_mvm_config_scan(mvm);
1240                 if (ret)
1241                         goto error;
1242         }
1243
1244         if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
1245                 iwl_mvm_send_recovery_cmd(mvm, ERROR_RECOVERY_UPDATE_DB);
1246
1247         if (iwl_acpi_get_eckv(mvm->dev, &mvm->ext_clock_valid))
1248                 IWL_DEBUG_INFO(mvm, "ECKV table doesn't exist in BIOS\n");
1249
1250         ret = iwl_mvm_ppag_init(mvm);
1251         if (ret)
1252                 goto error;
1253
1254         ret = iwl_mvm_sar_init(mvm);
1255         if (ret == 0) {
1256                 ret = iwl_mvm_sar_geo_init(mvm);
1257         } else if (ret > 0 && !iwl_sar_get_wgds_table(&mvm->fwrt)) {
1258                 /*
1259                  * If basic SAR is not available, we check for WGDS,
1260                  * which should *not* be available either.  If it is
1261                  * available, issue an error, because we can't use SAR
1262                  * Geo without basic SAR.
1263                  */
1264                 IWL_ERR(mvm, "BIOS contains WGDS but no WRDS\n");
1265         }
1266
1267         if (ret < 0)
1268                 goto error;
1269
1270         iwl_mvm_leds_sync(mvm);
1271
1272         IWL_DEBUG_INFO(mvm, "RT uCode started.\n");
1273         return 0;
1274  error:
1275         if (!iwlmvm_mod_params.init_dbg || !ret)
1276                 iwl_mvm_stop_device(mvm);
1277         return ret;
1278 }
1279
1280 int iwl_mvm_load_d3_fw(struct iwl_mvm *mvm)
1281 {
1282         int ret, i;
1283
1284         lockdep_assert_held(&mvm->mutex);
1285
1286         ret = iwl_trans_start_hw(mvm->trans);
1287         if (ret)
1288                 return ret;
1289
1290         ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_WOWLAN);
1291         if (ret) {
1292                 IWL_ERR(mvm, "Failed to start WoWLAN firmware: %d\n", ret);
1293                 goto error;
1294         }
1295
1296         ret = iwl_send_tx_ant_cfg(mvm, iwl_mvm_get_valid_tx_ant(mvm));
1297         if (ret)
1298                 goto error;
1299
1300         /* Send phy db control command and then phy db calibration*/
1301         ret = iwl_send_phy_db_data(mvm->phy_db);
1302         if (ret)
1303                 goto error;
1304
1305         ret = iwl_send_phy_cfg_cmd(mvm);
1306         if (ret)
1307                 goto error;
1308
1309         /* init the fw <-> mac80211 STA mapping */
1310         for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++)
1311                 RCU_INIT_POINTER(mvm->fw_id_to_mac_id[i], NULL);
1312
1313         /* Add auxiliary station for scanning */
1314         ret = iwl_mvm_add_aux_sta(mvm);
1315         if (ret)
1316                 goto error;
1317
1318         return 0;
1319  error:
1320         iwl_mvm_stop_device(mvm);
1321         return ret;
1322 }
1323
1324 void iwl_mvm_rx_card_state_notif(struct iwl_mvm *mvm,
1325                                  struct iwl_rx_cmd_buffer *rxb)
1326 {
1327         struct iwl_rx_packet *pkt = rxb_addr(rxb);
1328         struct iwl_card_state_notif *card_state_notif = (void *)pkt->data;
1329         u32 flags = le32_to_cpu(card_state_notif->flags);
1330
1331         IWL_DEBUG_RF_KILL(mvm, "Card state received: HW:%s SW:%s CT:%s\n",
1332                           (flags & HW_CARD_DISABLED) ? "Kill" : "On",
1333                           (flags & SW_CARD_DISABLED) ? "Kill" : "On",
1334                           (flags & CT_KILL_CARD_DISABLED) ?
1335                           "Reached" : "Not reached");
1336 }
1337
1338 void iwl_mvm_rx_mfuart_notif(struct iwl_mvm *mvm,
1339                              struct iwl_rx_cmd_buffer *rxb)
1340 {
1341         struct iwl_rx_packet *pkt = rxb_addr(rxb);
1342         struct iwl_mfuart_load_notif *mfuart_notif = (void *)pkt->data;
1343
1344         IWL_DEBUG_INFO(mvm,
1345                        "MFUART: installed ver: 0x%08x, external ver: 0x%08x, status: 0x%08x, duration: 0x%08x\n",
1346                        le32_to_cpu(mfuart_notif->installed_ver),
1347                        le32_to_cpu(mfuart_notif->external_ver),
1348                        le32_to_cpu(mfuart_notif->status),
1349                        le32_to_cpu(mfuart_notif->duration));
1350
1351         if (iwl_rx_packet_payload_len(pkt) == sizeof(*mfuart_notif))
1352                 IWL_DEBUG_INFO(mvm,
1353                                "MFUART: image size: 0x%08x\n",
1354                                le32_to_cpu(mfuart_notif->image_size));
1355 }