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