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 Intel Deutschland GmbH
  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  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  24  * USA
  25  *
  26  * The full GNU General Public License is included in this distribution
  27  * in the file called COPYING.
  28  *
  29  * Contact Information:
  30  *  Intel Linux Wireless <linuxwifi@intel.com>
  31  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  32  *
  33  * BSD LICENSE
  34  *
  35  * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
  36  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  37  * All rights reserved.
  38  *
  39  * Redistribution and use in source and binary forms, with or without
  40  * modification, are permitted provided that the following conditions
  41  * are met:
  42  *
  43  *  * Redistributions of source code must retain the above copyright
  44  *    notice, this list of conditions and the following disclaimer.
  45  *  * Redistributions in binary form must reproduce the above copyright
  46  *    notice, this list of conditions and the following disclaimer in
  47  *    the documentation and/or other materials provided with the
  48  *    distribution.
  49  *  * Neither the name Intel Corporation nor the names of its
  50  *    contributors may be used to endorse or promote products derived
  51  *    from this software without specific prior written permission.
  52  *
  53  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  54  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  55  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  56  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  57  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  58  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  59  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  60  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  61  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  62  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  63  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  64  *
  65  *****************************************************************************/
  66 #include <net/mac80211.h>
  67 #include <linux/netdevice.h>
  68 #include <linux/acpi.h>
  69
  70 #include "iwl-trans.h"
  71 #include "iwl-op-mode.h"
  72 #include "iwl-fw.h"
  73 #include "iwl-debug.h"
  74 #include "iwl-csr.h" /* for iwl_mvm_rx_card_state_notif */
  75 #include "iwl-io.h" /* for iwl_mvm_rx_card_state_notif */
  76 #include "iwl-prph.h"
  77 #include "iwl-eeprom-parse.h"
  78
  79 #include "mvm.h"
  80 #include "fw-dbg.h"
  81 #include "iwl-phy-db.h"
  82
  83 #define MVM_UCODE_ALIVE_TIMEOUT HZ
  84 #define MVM_UCODE_CALIB_TIMEOUT (2*HZ)
  85
  86 #define UCODE_VALID_OK  cpu_to_le32(0x1)
  87
  88 struct iwl_mvm_alive_data {
  89         bool valid;
  90         u32 scd_base_addr;
  91 };
  92
  93 static int iwl_send_tx_ant_cfg(struct iwl_mvm *mvm, u8 valid_tx_ant)
  94 {
  95         struct iwl_tx_ant_cfg_cmd tx_ant_cmd = {
  96                 .valid = cpu_to_le32(valid_tx_ant),
  97         };
  98
  99         IWL_DEBUG_FW(mvm, "select valid tx ant: %u\n", valid_tx_ant);
 100         return iwl_mvm_send_cmd_pdu(mvm, TX_ANT_CONFIGURATION_CMD, 0,
 101                                     sizeof(tx_ant_cmd), &tx_ant_cmd);
 102 }
 103
 104 static int iwl_send_rss_cfg_cmd(struct iwl_mvm *mvm)
 105 {
 106         int i;
 107         struct iwl_rss_config_cmd cmd = {
 108                 .flags = cpu_to_le32(IWL_RSS_ENABLE),
 109                 .hash_mask = BIT(IWL_RSS_HASH_TYPE_IPV4_TCP) |
 110                              BIT(IWL_RSS_HASH_TYPE_IPV4_UDP) |
 111                              BIT(IWL_RSS_HASH_TYPE_IPV4_PAYLOAD) |
 112                              BIT(IWL_RSS_HASH_TYPE_IPV6_TCP) |
 113                              BIT(IWL_RSS_HASH_TYPE_IPV6_UDP) |
 114                              BIT(IWL_RSS_HASH_TYPE_IPV6_PAYLOAD),
 115         };
 116
 117         if (mvm->trans->num_rx_queues == 1)
 118                 return 0;
 119
 120         /* Do not direct RSS traffic to Q 0 which is our fallback queue */
 121         for (i = 0; i < ARRAY_SIZE(cmd.indirection_table); i++)
 122                 cmd.indirection_table[i] =
 123                         1 + (i % (mvm->trans->num_rx_queues - 1));
 124         netdev_rss_key_fill(cmd.secret_key, sizeof(cmd.secret_key));
 125
 126         return iwl_mvm_send_cmd_pdu(mvm, RSS_CONFIG_CMD, 0, sizeof(cmd), &cmd);
 127 }
 128
 129 static int iwl_mvm_send_dqa_cmd(struct iwl_mvm *mvm)
 130 {
 131         struct iwl_dqa_enable_cmd dqa_cmd = {
 132                 .cmd_queue = cpu_to_le32(IWL_MVM_DQA_CMD_QUEUE),
 133         };
 134         u32 cmd_id = iwl_cmd_id(DQA_ENABLE_CMD, DATA_PATH_GROUP, 0);
 135         int ret;
 136
 137         ret = iwl_mvm_send_cmd_pdu(mvm, cmd_id, 0, sizeof(dqa_cmd), &dqa_cmd);
 138         if (ret)
 139                 IWL_ERR(mvm, "Failed to send DQA enabling command: %d\n", ret);
 140         else
 141                 IWL_DEBUG_FW(mvm, "Working in DQA mode\n");
 142
 143         return ret;
 144 }
 145
 146 void iwl_free_fw_paging(struct iwl_mvm *mvm)
 147 {
 148         int i;
 149
 150         if (!mvm->fw_paging_db[0].fw_paging_block)
 151                 return;
 152
 153         for (i = 0; i < NUM_OF_FW_PAGING_BLOCKS; i++) {
 154                 struct iwl_fw_paging *paging = &mvm->fw_paging_db[i];
 155
 156                 if (!paging->fw_paging_block) {
 157                         IWL_DEBUG_FW(mvm,
 158                                      "Paging: block %d already freed, continue to next page\n",
 159                                      i);
 160
 161                         continue;
 162                 }
 163                 dma_unmap_page(mvm->trans->dev, paging->fw_paging_phys,
 164                                paging->fw_paging_size, DMA_BIDIRECTIONAL);
 165
 166                 __free_pages(paging->fw_paging_block,
 167                              get_order(paging->fw_paging_size));
 168                 paging->fw_paging_block = NULL;
 169         }
 170         kfree(mvm->trans->paging_download_buf);
 171         mvm->trans->paging_download_buf = NULL;
 172         mvm->trans->paging_db = NULL;
 173
 174         memset(mvm->fw_paging_db, 0, sizeof(mvm->fw_paging_db));
 175 }
 176
 177 static int iwl_fill_paging_mem(struct iwl_mvm *mvm, const struct fw_img *image)
 178 {
 179         int sec_idx, idx;
 180         u32 offset = 0;
 181
 182         /*
 183          * find where is the paging image start point:
 184          * if CPU2 exist and it's in paging format, then the image looks like:
 185          * CPU1 sections (2 or more)
 186          * CPU1_CPU2_SEPARATOR_SECTION delimiter - separate between CPU1 to CPU2
 187          * CPU2 sections (not paged)
 188          * PAGING_SEPARATOR_SECTION delimiter - separate between CPU2
 189          * non paged to CPU2 paging sec
 190          * CPU2 paging CSS
 191          * CPU2 paging image (including instruction and data)
 192          */
 193         for (sec_idx = 0; sec_idx < IWL_UCODE_SECTION_MAX; sec_idx++) {
 194                 if (image->sec[sec_idx].offset == PAGING_SEPARATOR_SECTION) {
 195                         sec_idx++;
 196                         break;
 197                 }
 198         }
 199
 200         /*
 201          * If paging is enabled there should be at least 2 more sections left
 202          * (one for CSS and one for Paging data)
 203          */
 204         if (sec_idx >= ARRAY_SIZE(image->sec) - 1) {
 205                 IWL_ERR(mvm, "Paging: Missing CSS and/or paging sections\n");
 206                 iwl_free_fw_paging(mvm);
 207                 return -EINVAL;
 208         }
 209
 210         /* copy the CSS block to the dram */
 211         IWL_DEBUG_FW(mvm, "Paging: load paging CSS to FW, sec = %d\n",
 212                      sec_idx);
 213
 214         memcpy(page_address(mvm->fw_paging_db[0].fw_paging_block),
 215                image->sec[sec_idx].data,
 216                mvm->fw_paging_db[0].fw_paging_size);
 217         dma_sync_single_for_device(mvm->trans->dev,
 218                                    mvm->fw_paging_db[0].fw_paging_phys,
 219                                    mvm->fw_paging_db[0].fw_paging_size,
 220                                    DMA_BIDIRECTIONAL);
 221
 222         IWL_DEBUG_FW(mvm,
 223                      "Paging: copied %d CSS bytes to first block\n",
 224                      mvm->fw_paging_db[0].fw_paging_size);
 225
 226         sec_idx++;
 227
 228         /*
 229          * copy the paging blocks to the dram
 230          * loop index start from 1 since that CSS block already copied to dram
 231          * and CSS index is 0.
 232          * loop stop at num_of_paging_blk since that last block is not full.
 233          */
 234         for (idx = 1; idx < mvm->num_of_paging_blk; idx++) {
 235                 struct iwl_fw_paging *block = &mvm->fw_paging_db[idx];
 236
 237                 memcpy(page_address(block->fw_paging_block),
 238                        image->sec[sec_idx].data + offset,
 239                        block->fw_paging_size);
 240                 dma_sync_single_for_device(mvm->trans->dev,
 241                                            block->fw_paging_phys,
 242                                            block->fw_paging_size,
 243                                            DMA_BIDIRECTIONAL);
 244
 245
 246                 IWL_DEBUG_FW(mvm,
 247                              "Paging: copied %d paging bytes to block %d\n",
 248                              mvm->fw_paging_db[idx].fw_paging_size,
 249                              idx);
 250
 251                 offset += mvm->fw_paging_db[idx].fw_paging_size;
 252         }
 253
 254         /* copy the last paging block */
 255         if (mvm->num_of_pages_in_last_blk > 0) {
 256                 struct iwl_fw_paging *block = &mvm->fw_paging_db[idx];
 257
 258                 memcpy(page_address(block->fw_paging_block),
 259                        image->sec[sec_idx].data + offset,
 260                        FW_PAGING_SIZE * mvm->num_of_pages_in_last_blk);
 261                 dma_sync_single_for_device(mvm->trans->dev,
 262                                            block->fw_paging_phys,
 263                                            block->fw_paging_size,
 264                                            DMA_BIDIRECTIONAL);
 265
 266                 IWL_DEBUG_FW(mvm,
 267                              "Paging: copied %d pages in the last block %d\n",
 268                              mvm->num_of_pages_in_last_blk, idx);
 269         }
 270
 271         return 0;
 272 }
 273
 274 static int iwl_alloc_fw_paging_mem(struct iwl_mvm *mvm,
 275                                    const struct fw_img *image)
 276 {
 277         struct page *block;
 278         dma_addr_t phys = 0;
 279         int blk_idx = 0;
 280         int order, num_of_pages;
 281         int dma_enabled;
 282
 283         if (mvm->fw_paging_db[0].fw_paging_block)
 284                 return 0;
 285
 286         dma_enabled = is_device_dma_capable(mvm->trans->dev);
 287
 288         /* ensure BLOCK_2_EXP_SIZE is power of 2 of PAGING_BLOCK_SIZE */
 289         BUILD_BUG_ON(BIT(BLOCK_2_EXP_SIZE) != PAGING_BLOCK_SIZE);
 290
 291         num_of_pages = image->paging_mem_size / FW_PAGING_SIZE;
 292         mvm->num_of_paging_blk = ((num_of_pages - 1) /
 293                                     NUM_OF_PAGE_PER_GROUP) + 1;
 294
 295         mvm->num_of_pages_in_last_blk =
 296                 num_of_pages -
 297                 NUM_OF_PAGE_PER_GROUP * (mvm->num_of_paging_blk - 1);
 298
 299         IWL_DEBUG_FW(mvm,
 300                      "Paging: allocating mem for %d paging blocks, each block holds 8 pages, last block holds %d pages\n",
 301                      mvm->num_of_paging_blk,
 302                      mvm->num_of_pages_in_last_blk);
 303
 304         /* allocate block of 4Kbytes for paging CSS */
 305         order = get_order(FW_PAGING_SIZE);
 306         block = alloc_pages(GFP_KERNEL, order);
 307         if (!block) {
 308                 /* free all the previous pages since we failed */
 309                 iwl_free_fw_paging(mvm);
 310                 return -ENOMEM;
 311         }
 312
 313         mvm->fw_paging_db[blk_idx].fw_paging_block = block;
 314         mvm->fw_paging_db[blk_idx].fw_paging_size = FW_PAGING_SIZE;
 315
 316         if (dma_enabled) {
 317                 phys = dma_map_page(mvm->trans->dev, block, 0,
 318                                     PAGE_SIZE << order, DMA_BIDIRECTIONAL);
 319                 if (dma_mapping_error(mvm->trans->dev, phys)) {
 320                         /*
 321                          * free the previous pages and the current one since
 322                          * we failed to map_page.
 323                          */
 324                         iwl_free_fw_paging(mvm);
 325                         return -ENOMEM;
 326                 }
 327                 mvm->fw_paging_db[blk_idx].fw_paging_phys = phys;
 328         } else {
 329                 mvm->fw_paging_db[blk_idx].fw_paging_phys = PAGING_ADDR_SIG |
 330                         blk_idx << BLOCK_2_EXP_SIZE;
 331         }
 332
 333         IWL_DEBUG_FW(mvm,
 334                      "Paging: allocated 4K(CSS) bytes (order %d) for firmware paging.\n",
 335                      order);
 336
 337         /*
 338          * allocate blocks in dram.
 339          * since that CSS allocated in fw_paging_db[0] loop start from index 1
 340          */
 341         for (blk_idx = 1; blk_idx < mvm->num_of_paging_blk + 1; blk_idx++) {
 342                 /* allocate block of PAGING_BLOCK_SIZE (32K) */
 343                 order = get_order(PAGING_BLOCK_SIZE);
 344                 block = alloc_pages(GFP_KERNEL, order);
 345                 if (!block) {
 346                         /* free all the previous pages since we failed */
 347                         iwl_free_fw_paging(mvm);
 348                         return -ENOMEM;
 349                 }
 350
 351                 mvm->fw_paging_db[blk_idx].fw_paging_block = block;
 352                 mvm->fw_paging_db[blk_idx].fw_paging_size = PAGING_BLOCK_SIZE;
 353
 354                 if (dma_enabled) {
 355                         phys = dma_map_page(mvm->trans->dev, block, 0,
 356                                             PAGE_SIZE << order,
 357                                             DMA_BIDIRECTIONAL);
 358                         if (dma_mapping_error(mvm->trans->dev, phys)) {
 359                                 /*
 360                                  * free the previous pages and the current one
 361                                  * since we failed to map_page.
 362                                  */
 363                                 iwl_free_fw_paging(mvm);
 364                                 return -ENOMEM;
 365                         }
 366                         mvm->fw_paging_db[blk_idx].fw_paging_phys = phys;
 367                 } else {
 368                         mvm->fw_paging_db[blk_idx].fw_paging_phys =
 369                                 PAGING_ADDR_SIG |
 370                                 blk_idx << BLOCK_2_EXP_SIZE;
 371                 }
 372
 373                 IWL_DEBUG_FW(mvm,
 374                              "Paging: allocated 32K bytes (order %d) for firmware paging.\n",
 375                              order);
 376         }
 377
 378         return 0;
 379 }
 380
 381 static int iwl_save_fw_paging(struct iwl_mvm *mvm,
 382                               const struct fw_img *fw)
 383 {
 384         int ret;
 385
 386         ret = iwl_alloc_fw_paging_mem(mvm, fw);
 387         if (ret)
 388                 return ret;
 389
 390         return iwl_fill_paging_mem(mvm, fw);
 391 }
 392
 393 /* send paging cmd to FW in case CPU2 has paging image */
 394 static int iwl_send_paging_cmd(struct iwl_mvm *mvm, const struct fw_img *fw)
 395 {
 396         struct iwl_fw_paging_cmd paging_cmd = {
 397                 .flags =
 398                         cpu_to_le32(PAGING_CMD_IS_SECURED |
 399                                     PAGING_CMD_IS_ENABLED |
 400                                     (mvm->num_of_pages_in_last_blk <<
 401                                     PAGING_CMD_NUM_OF_PAGES_IN_LAST_GRP_POS)),
 402                 .block_size = cpu_to_le32(BLOCK_2_EXP_SIZE),
 403                 .block_num = cpu_to_le32(mvm->num_of_paging_blk),
 404         };
 405         int blk_idx, size = sizeof(paging_cmd);
 406
 407         /* A bit hard coded - but this is the old API and will be deprecated */
 408         if (!iwl_mvm_has_new_tx_api(mvm))
 409                 size -= NUM_OF_FW_PAGING_BLOCKS * 4;
 410
 411         /* loop for for all paging blocks + CSS block */
 412         for (blk_idx = 0; blk_idx < mvm->num_of_paging_blk + 1; blk_idx++) {
 413                 dma_addr_t addr = mvm->fw_paging_db[blk_idx].fw_paging_phys;
 414
 415                 addr = addr >> PAGE_2_EXP_SIZE;
 416
 417                 if (iwl_mvm_has_new_tx_api(mvm)) {
 418                         __le64 phy_addr = cpu_to_le64(addr);
 419
 420                         paging_cmd.device_phy_addr.addr64[blk_idx] = phy_addr;
 421                 } else {
 422                         __le32 phy_addr = cpu_to_le32(addr);
 423
 424                         paging_cmd.device_phy_addr.addr32[blk_idx] = phy_addr;
 425                 }
 426         }
 427
 428         return iwl_mvm_send_cmd_pdu(mvm, iwl_cmd_id(FW_PAGING_BLOCK_CMD,
 429                                                     IWL_ALWAYS_LONG_GROUP, 0),
 430                                     0, size, &paging_cmd);
 431 }
 432
 433 /*
 434  * Send paging item cmd to FW in case CPU2 has paging image
 435  */
 436 static int iwl_trans_get_paging_item(struct iwl_mvm *mvm)
 437 {
 438         int ret;
 439         struct iwl_fw_get_item_cmd fw_get_item_cmd = {
 440                 .item_id = cpu_to_le32(IWL_FW_ITEM_ID_PAGING),
 441         };
 442
 443         struct iwl_fw_get_item_resp *item_resp;
 444         struct iwl_host_cmd cmd = {
 445                 .id = iwl_cmd_id(FW_GET_ITEM_CMD, IWL_ALWAYS_LONG_GROUP, 0),
 446                 .flags = CMD_WANT_SKB | CMD_SEND_IN_RFKILL,
 447                 .data = { &fw_get_item_cmd, },
 448         };
 449
 450         cmd.len[0] = sizeof(struct iwl_fw_get_item_cmd);
 451
 452         ret = iwl_mvm_send_cmd(mvm, &cmd);
 453         if (ret) {
 454                 IWL_ERR(mvm,
 455                         "Paging: Failed to send FW_GET_ITEM_CMD cmd (err = %d)\n",
 456                         ret);
 457                 return ret;
 458         }
 459
 460         item_resp = (void *)((struct iwl_rx_packet *)cmd.resp_pkt)->data;
 461         if (item_resp->item_id != cpu_to_le32(IWL_FW_ITEM_ID_PAGING)) {
 462                 IWL_ERR(mvm,
 463                         "Paging: got wrong item in FW_GET_ITEM_CMD resp (item_id = %u)\n",
 464                         le32_to_cpu(item_resp->item_id));
 465                 ret = -EIO;
 466                 goto exit;
 467         }
 468
 469         /* Add an extra page for headers */
 470         mvm->trans->paging_download_buf = kzalloc(PAGING_BLOCK_SIZE +
 471                                                   FW_PAGING_SIZE,
 472                                                   GFP_KERNEL);
 473         if (!mvm->trans->paging_download_buf) {
 474                 ret = -ENOMEM;
 475                 goto exit;
 476         }
 477         mvm->trans->paging_req_addr = le32_to_cpu(item_resp->item_val);
 478         mvm->trans->paging_db = mvm->fw_paging_db;
 479         IWL_DEBUG_FW(mvm,
 480                      "Paging: got paging request address (paging_req_addr 0x%08x)\n",
 481                      mvm->trans->paging_req_addr);
 482
 483 exit:
 484         iwl_free_resp(&cmd);
 485
 486         return ret;
 487 }
 488
 489 static bool iwl_alive_fn(struct iwl_notif_wait_data *notif_wait,
 490                          struct iwl_rx_packet *pkt, void *data)
 491 {
 492         struct iwl_mvm *mvm =
 493                 container_of(notif_wait, struct iwl_mvm, notif_wait);
 494         struct iwl_mvm_alive_data *alive_data = data;
 495         struct mvm_alive_resp_ver1 *palive1;
 496         struct mvm_alive_resp_ver2 *palive2;
 497         struct mvm_alive_resp *palive;
 498
 499         if (iwl_rx_packet_payload_len(pkt) == sizeof(*palive1)) {
 500                 palive1 = (void *)pkt->data;
 501
 502                 mvm->support_umac_log = false;
 503                 mvm->error_event_table =
 504                         le32_to_cpu(palive1->error_event_table_ptr);
 505                 mvm->log_event_table =
 506                         le32_to_cpu(palive1->log_event_table_ptr);
 507                 alive_data->scd_base_addr = le32_to_cpu(palive1->scd_base_ptr);
 508
 509                 alive_data->valid = le16_to_cpu(palive1->status) ==
 510                                     IWL_ALIVE_STATUS_OK;
 511                 IWL_DEBUG_FW(mvm,
 512                              "Alive VER1 ucode status 0x%04x revision 0x%01X 0x%01X flags 0x%01X\n",
 513                              le16_to_cpu(palive1->status), palive1->ver_type,
 514                              palive1->ver_subtype, palive1->flags);
 515         } else if (iwl_rx_packet_payload_len(pkt) == sizeof(*palive2)) {
 516                 palive2 = (void *)pkt->data;
 517
 518                 mvm->error_event_table =
 519                         le32_to_cpu(palive2->error_event_table_ptr);
 520                 mvm->log_event_table =
 521                         le32_to_cpu(palive2->log_event_table_ptr);
 522                 alive_data->scd_base_addr = le32_to_cpu(palive2->scd_base_ptr);
 523                 mvm->umac_error_event_table =
 524                         le32_to_cpu(palive2->error_info_addr);
 525                 mvm->sf_space.addr = le32_to_cpu(palive2->st_fwrd_addr);
 526                 mvm->sf_space.size = le32_to_cpu(palive2->st_fwrd_size);
 527
 528                 alive_data->valid = le16_to_cpu(palive2->status) ==
 529                                     IWL_ALIVE_STATUS_OK;
 530                 if (mvm->umac_error_event_table)
 531                         mvm->support_umac_log = true;
 532
 533                 IWL_DEBUG_FW(mvm,
 534                              "Alive VER2 ucode status 0x%04x revision 0x%01X 0x%01X flags 0x%01X\n",
 535                              le16_to_cpu(palive2->status), palive2->ver_type,
 536                              palive2->ver_subtype, palive2->flags);
 537
 538                 IWL_DEBUG_FW(mvm,
 539                              "UMAC version: Major - 0x%x, Minor - 0x%x\n",
 540                              palive2->umac_major, palive2->umac_minor);
 541         } else if (iwl_rx_packet_payload_len(pkt) == sizeof(*palive)) {
 542                 palive = (void *)pkt->data;
 543
 544                 mvm->error_event_table =
 545                         le32_to_cpu(palive->error_event_table_ptr);
 546                 mvm->log_event_table =
 547                         le32_to_cpu(palive->log_event_table_ptr);
 548                 alive_data->scd_base_addr = le32_to_cpu(palive->scd_base_ptr);
 549                 mvm->umac_error_event_table =
 550                         le32_to_cpu(palive->error_info_addr);
 551                 mvm->sf_space.addr = le32_to_cpu(palive->st_fwrd_addr);
 552                 mvm->sf_space.size = le32_to_cpu(palive->st_fwrd_size);
 553
 554                 alive_data->valid = le16_to_cpu(palive->status) ==
 555                                     IWL_ALIVE_STATUS_OK;
 556                 if (mvm->umac_error_event_table)
 557                         mvm->support_umac_log = true;
 558
 559                 IWL_DEBUG_FW(mvm,
 560                              "Alive VER3 ucode status 0x%04x revision 0x%01X 0x%01X flags 0x%01X\n",
 561                              le16_to_cpu(palive->status), palive->ver_type,
 562                              palive->ver_subtype, palive->flags);
 563
 564                 IWL_DEBUG_FW(mvm,
 565                              "UMAC version: Major - 0x%x, Minor - 0x%x\n",
 566                              le32_to_cpu(palive->umac_major),
 567                              le32_to_cpu(palive->umac_minor));
 568         }
 569
 570         return true;
 571 }
 572
 573 static bool iwl_wait_phy_db_entry(struct iwl_notif_wait_data *notif_wait,
 574                                   struct iwl_rx_packet *pkt, void *data)
 575 {
 576         struct iwl_phy_db *phy_db = data;
 577
 578         if (pkt->hdr.cmd != CALIB_RES_NOTIF_PHY_DB) {
 579                 WARN_ON(pkt->hdr.cmd != INIT_COMPLETE_NOTIF);
 580                 return true;
 581         }
 582
 583         WARN_ON(iwl_phy_db_set_section(phy_db, pkt));
 584
 585         return false;
 586 }
 587
 588 static int iwl_mvm_load_ucode_wait_alive(struct iwl_mvm *mvm,
 589                                          enum iwl_ucode_type ucode_type)
 590 {
 591         struct iwl_notification_wait alive_wait;
 592         struct iwl_mvm_alive_data alive_data;
 593         const struct fw_img *fw;
 594         int ret, i;
 595         enum iwl_ucode_type old_type = mvm->cur_ucode;
 596         static const u16 alive_cmd[] = { MVM_ALIVE };
 597         struct iwl_sf_region st_fwrd_space;
 598
 599         if (ucode_type == IWL_UCODE_REGULAR &&
 600             iwl_fw_dbg_conf_usniffer(mvm->fw, FW_DBG_START_FROM_ALIVE) &&
 601             !(fw_has_capa(&mvm->fw->ucode_capa,
 602                           IWL_UCODE_TLV_CAPA_USNIFFER_UNIFIED)))
 603                 fw = iwl_get_ucode_image(mvm->fw, IWL_UCODE_REGULAR_USNIFFER);
 604         else
 605                 fw = iwl_get_ucode_image(mvm->fw, ucode_type);
 606         if (WARN_ON(!fw))
 607                 return -EINVAL;
 608         mvm->cur_ucode = ucode_type;
 609         mvm->ucode_loaded = false;
 610
 611         iwl_init_notification_wait(&mvm->notif_wait, &alive_wait,
 612                                    alive_cmd, ARRAY_SIZE(alive_cmd),
 613                                    iwl_alive_fn, &alive_data);
 614
 615         ret = iwl_trans_start_fw(mvm->trans, fw, ucode_type == IWL_UCODE_INIT);
 616         if (ret) {
 617                 mvm->cur_ucode = old_type;
 618                 iwl_remove_notification(&mvm->notif_wait, &alive_wait);
 619                 return ret;
 620         }
 621
 622         /*
 623          * Some things may run in the background now, but we
 624          * just wait for the ALIVE notification here.
 625          */
 626         ret = iwl_wait_notification(&mvm->notif_wait, &alive_wait,
 627                                     MVM_UCODE_ALIVE_TIMEOUT);
 628         if (ret) {
 629                 if (mvm->trans->cfg->device_family == IWL_DEVICE_FAMILY_8000)
 630                         IWL_ERR(mvm,
 631                                 "SecBoot CPU1 Status: 0x%x, CPU2 Status: 0x%x\n",
 632                                 iwl_read_prph(mvm->trans, SB_CPU_1_STATUS),
 633                                 iwl_read_prph(mvm->trans, SB_CPU_2_STATUS));
 634                 mvm->cur_ucode = old_type;
 635                 return ret;
 636         }
 637
 638         if (!alive_data.valid) {
 639                 IWL_ERR(mvm, "Loaded ucode is not valid!\n");
 640                 mvm->cur_ucode = old_type;
 641                 return -EIO;
 642         }
 643
 644         /*
 645          * update the sdio allocation according to the pointer we get in the
 646          * alive notification.
 647          */
 648         st_fwrd_space.addr = mvm->sf_space.addr;
 649         st_fwrd_space.size = mvm->sf_space.size;
 650         ret = iwl_trans_update_sf(mvm->trans, &st_fwrd_space);
 651         if (ret) {
 652                 IWL_ERR(mvm, "Failed to update SF size. ret %d\n", ret);
 653                 return ret;
 654         }
 655
 656         iwl_trans_fw_alive(mvm->trans, alive_data.scd_base_addr);
 657
 658         /*
 659          * configure and operate fw paging mechanism.
 660          * driver configures the paging flow only once, CPU2 paging image
 661          * included in the IWL_UCODE_INIT image.
 662          */
 663         if (fw->paging_mem_size) {
 664                 /*
 665                  * When dma is not enabled, the driver needs to copy / write
 666                  * the downloaded / uploaded page to / from the smem.
 667                  * This gets the location of the place were the pages are
 668                  * stored.
 669                  */
 670                 if (!is_device_dma_capable(mvm->trans->dev)) {
 671                         ret = iwl_trans_get_paging_item(mvm);
 672                         if (ret) {
 673                                 IWL_ERR(mvm, "failed to get FW paging item\n");
 674                                 return ret;
 675                         }
 676                 }
 677
 678                 ret = iwl_save_fw_paging(mvm, fw);
 679                 if (ret) {
 680                         IWL_ERR(mvm, "failed to save the FW paging image\n");
 681                         return ret;
 682                 }
 683
 684                 ret = iwl_send_paging_cmd(mvm, fw);
 685                 if (ret) {
 686                         IWL_ERR(mvm, "failed to send the paging cmd\n");
 687                         iwl_free_fw_paging(mvm);
 688                         return ret;
 689                 }
 690         }
 691
 692         /*
 693          * Note: all the queues are enabled as part of the interface
 694          * initialization, but in firmware restart scenarios they
 695          * could be stopped, so wake them up. In firmware restart,
 696          * mac80211 will have the queues stopped as well until the
 697          * reconfiguration completes. During normal startup, they
 698          * will be empty.
 699          */
 700
 701         memset(&mvm->queue_info, 0, sizeof(mvm->queue_info));
 702         if (iwl_mvm_is_dqa_supported(mvm))
 703                 mvm->queue_info[IWL_MVM_DQA_CMD_QUEUE].hw_queue_refcount = 1;
 704         else
 705                 mvm->queue_info[IWL_MVM_CMD_QUEUE].hw_queue_refcount = 1;
 706
 707         for (i = 0; i < IEEE80211_MAX_QUEUES; i++)
 708                 atomic_set(&mvm->mac80211_queue_stop_count[i], 0);
 709
 710         mvm->ucode_loaded = true;
 711
 712         return 0;
 713 }
 714
 715 static int iwl_send_phy_cfg_cmd(struct iwl_mvm *mvm)
 716 {
 717         struct iwl_phy_cfg_cmd phy_cfg_cmd;
 718         enum iwl_ucode_type ucode_type = mvm->cur_ucode;
 719
 720         /* Set parameters */
 721         phy_cfg_cmd.phy_cfg = cpu_to_le32(iwl_mvm_get_phy_config(mvm));
 722         phy_cfg_cmd.calib_control.event_trigger =
 723                 mvm->fw->default_calib[ucode_type].event_trigger;
 724         phy_cfg_cmd.calib_control.flow_trigger =
 725                 mvm->fw->default_calib[ucode_type].flow_trigger;
 726
 727         IWL_DEBUG_INFO(mvm, "Sending Phy CFG command: 0x%x\n",
 728                        phy_cfg_cmd.phy_cfg);
 729
 730         return iwl_mvm_send_cmd_pdu(mvm, PHY_CONFIGURATION_CMD, 0,
 731                                     sizeof(phy_cfg_cmd), &phy_cfg_cmd);
 732 }
 733
 734 int iwl_run_init_mvm_ucode(struct iwl_mvm *mvm, bool read_nvm)
 735 {
 736         struct iwl_notification_wait calib_wait;
 737         static const u16 init_complete[] = {
 738                 INIT_COMPLETE_NOTIF,
 739                 CALIB_RES_NOTIF_PHY_DB
 740         };
 741         int ret;
 742
 743         lockdep_assert_held(&mvm->mutex);
 744
 745         if (WARN_ON_ONCE(mvm->calibrating))
 746                 return 0;
 747
 748         iwl_init_notification_wait(&mvm->notif_wait,
 749                                    &calib_wait,
 750                                    init_complete,
 751                                    ARRAY_SIZE(init_complete),
 752                                    iwl_wait_phy_db_entry,
 753                                    mvm->phy_db);
 754
 755         /* Will also start the device */
 756         ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_INIT);
 757         if (ret) {
 758                 IWL_ERR(mvm, "Failed to start INIT ucode: %d\n", ret);
 759                 goto error;
 760         }
 761
 762         ret = iwl_send_bt_init_conf(mvm);
 763         if (ret)
 764                 goto error;
 765
 766         /* Read the NVM only at driver load time, no need to do this twice */
 767         if (read_nvm) {
 768                 /* Read nvm */
 769                 ret = iwl_nvm_init(mvm, true);
 770                 if (ret) {
 771                         IWL_ERR(mvm, "Failed to read NVM: %d\n", ret);
 772                         goto error;
 773                 }
 774         }
 775
 776         /* In case we read the NVM from external file, load it to the NIC */
 777         if (mvm->nvm_file_name)
 778                 iwl_mvm_load_nvm_to_nic(mvm);
 779
 780         ret = iwl_nvm_check_version(mvm->nvm_data, mvm->trans);
 781         WARN_ON(ret);
 782
 783         /*
 784          * abort after reading the nvm in case RF Kill is on, we will complete
 785          * the init seq later when RF kill will switch to off
 786          */
 787         if (iwl_mvm_is_radio_hw_killed(mvm)) {
 788                 IWL_DEBUG_RF_KILL(mvm,
 789                                   "jump over all phy activities due to RF kill\n");
 790                 iwl_remove_notification(&mvm->notif_wait, &calib_wait);
 791                 ret = 1;
 792                 goto out;
 793         }
 794
 795         mvm->calibrating = true;
 796
 797         /* Send TX valid antennas before triggering calibrations */
 798         ret = iwl_send_tx_ant_cfg(mvm, iwl_mvm_get_valid_tx_ant(mvm));
 799         if (ret)
 800                 goto error;
 801
 802         /*
 803          * Send phy configurations command to init uCode
 804          * to start the 16.0 uCode init image internal calibrations.
 805          */
 806         ret = iwl_send_phy_cfg_cmd(mvm);
 807         if (ret) {
 808                 IWL_ERR(mvm, "Failed to run INIT calibrations: %d\n",
 809                         ret);
 810                 goto error;
 811         }
 812
 813         /*
 814          * Some things may run in the background now, but we
 815          * just wait for the calibration complete notification.
 816          */
 817         ret = iwl_wait_notification(&mvm->notif_wait, &calib_wait,
 818                         MVM_UCODE_CALIB_TIMEOUT);
 819
 820         if (ret && iwl_mvm_is_radio_hw_killed(mvm)) {
 821                 IWL_DEBUG_RF_KILL(mvm, "RFKILL while calibrating.\n");
 822                 ret = 1;
 823         }
 824         goto out;
 825
 826 error:
 827         iwl_remove_notification(&mvm->notif_wait, &calib_wait);
 828 out:
 829         mvm->calibrating = false;
 830         if (iwlmvm_mod_params.init_dbg && !mvm->nvm_data) {
 831                 /* we want to debug INIT and we have no NVM - fake */
 832                 mvm->nvm_data = kzalloc(sizeof(struct iwl_nvm_data) +
 833                                         sizeof(struct ieee80211_channel) +
 834                                         sizeof(struct ieee80211_rate),
 835                                         GFP_KERNEL);
 836                 if (!mvm->nvm_data)
 837                         return -ENOMEM;
 838                 mvm->nvm_data->bands[0].channels = mvm->nvm_data->channels;
 839                 mvm->nvm_data->bands[0].n_channels = 1;
 840                 mvm->nvm_data->bands[0].n_bitrates = 1;
 841                 mvm->nvm_data->bands[0].bitrates =
 842                         (void *)mvm->nvm_data->channels + 1;
 843                 mvm->nvm_data->bands[0].bitrates->hw_value = 10;
 844         }
 845
 846         return ret;
 847 }
 848
 849 static void iwl_mvm_parse_shared_mem_a000(struct iwl_mvm *mvm,
 850                                           struct iwl_rx_packet *pkt)
 851 {
 852         struct iwl_shared_mem_cfg *mem_cfg = (void *)pkt->data;
 853         int i;
 854
 855         mvm->shared_mem_cfg.num_txfifo_entries =
 856                 ARRAY_SIZE(mvm->shared_mem_cfg.txfifo_size);
 857         for (i = 0; i < ARRAY_SIZE(mem_cfg->txfifo_size); i++)
 858                 mvm->shared_mem_cfg.txfifo_size[i] =
 859                         le32_to_cpu(mem_cfg->txfifo_size[i]);
 860         for (i = 0; i < ARRAY_SIZE(mvm->shared_mem_cfg.rxfifo_size); i++)
 861                 mvm->shared_mem_cfg.rxfifo_size[i] =
 862                         le32_to_cpu(mem_cfg->rxfifo_size[i]);
 863
 864         BUILD_BUG_ON(sizeof(mvm->shared_mem_cfg.internal_txfifo_size) !=
 865                      sizeof(mem_cfg->internal_txfifo_size));
 866
 867         for (i = 0; i < ARRAY_SIZE(mvm->shared_mem_cfg.internal_txfifo_size);
 868              i++)
 869                 mvm->shared_mem_cfg.internal_txfifo_size[i] =
 870                         le32_to_cpu(mem_cfg->internal_txfifo_size[i]);
 871 }
 872
 873 static void iwl_mvm_parse_shared_mem(struct iwl_mvm *mvm,
 874                                      struct iwl_rx_packet *pkt)
 875 {
 876         struct iwl_shared_mem_cfg_v1 *mem_cfg = (void *)pkt->data;
 877         int i;
 878
 879         mvm->shared_mem_cfg.num_txfifo_entries =
 880                 ARRAY_SIZE(mvm->shared_mem_cfg.txfifo_size);
 881         for (i = 0; i < ARRAY_SIZE(mem_cfg->txfifo_size); i++)
 882                 mvm->shared_mem_cfg.txfifo_size[i] =
 883                         le32_to_cpu(mem_cfg->txfifo_size[i]);
 884         for (i = 0; i < ARRAY_SIZE(mvm->shared_mem_cfg.rxfifo_size); i++)
 885                 mvm->shared_mem_cfg.rxfifo_size[i] =
 886                         le32_to_cpu(mem_cfg->rxfifo_size[i]);
 887
 888         /* new API has more data, from rxfifo_addr field and on */
 889         if (fw_has_capa(&mvm->fw->ucode_capa,
 890                         IWL_UCODE_TLV_CAPA_EXTEND_SHARED_MEM_CFG)) {
 891                 BUILD_BUG_ON(sizeof(mvm->shared_mem_cfg.internal_txfifo_size) !=
 892                              sizeof(mem_cfg->internal_txfifo_size));
 893
 894                 for (i = 0;
 895                      i < ARRAY_SIZE(mvm->shared_mem_cfg.internal_txfifo_size);
 896                      i++)
 897                         mvm->shared_mem_cfg.internal_txfifo_size[i] =
 898                                 le32_to_cpu(mem_cfg->internal_txfifo_size[i]);
 899         }
 900 }
 901
 902 static void iwl_mvm_get_shared_mem_conf(struct iwl_mvm *mvm)
 903 {
 904         struct iwl_host_cmd cmd = {
 905                 .flags = CMD_WANT_SKB,
 906                 .data = { NULL, },
 907                 .len = { 0, },
 908         };
 909         struct iwl_rx_packet *pkt;
 910
 911         lockdep_assert_held(&mvm->mutex);
 912
 913         if (fw_has_capa(&mvm->fw->ucode_capa,
 914                         IWL_UCODE_TLV_CAPA_EXTEND_SHARED_MEM_CFG))
 915                 cmd.id = iwl_cmd_id(SHARED_MEM_CFG_CMD, SYSTEM_GROUP, 0);
 916         else
 917                 cmd.id = SHARED_MEM_CFG;
 918
 919         if (WARN_ON(iwl_mvm_send_cmd(mvm, &cmd)))
 920                 return;
 921
 922         pkt = cmd.resp_pkt;
 923         if (iwl_mvm_has_new_tx_api(mvm))
 924                 iwl_mvm_parse_shared_mem_a000(mvm, pkt);
 925         else
 926                 iwl_mvm_parse_shared_mem(mvm, pkt);
 927
 928         IWL_DEBUG_INFO(mvm, "SHARED MEM CFG: got memory offsets/sizes\n");
 929
 930         iwl_free_resp(&cmd);
 931 }
 932
 933 static int iwl_mvm_config_ltr(struct iwl_mvm *mvm)
 934 {
 935         struct iwl_ltr_config_cmd cmd = {
 936                 .flags = cpu_to_le32(LTR_CFG_FLAG_FEATURE_ENABLE),
 937         };
 938
 939         if (!mvm->trans->ltr_enabled)
 940                 return 0;
 941
 942         return iwl_mvm_send_cmd_pdu(mvm, LTR_CONFIG, 0,
 943                                     sizeof(cmd), &cmd);
 944 }
 945
 946 #define ACPI_WRDS_METHOD        "WRDS"
 947 #define ACPI_WRDS_WIFI          (0x07)
 948 #define ACPI_WRDS_TABLE_SIZE    10
 949
 950 struct iwl_mvm_sar_table {
 951         bool enabled;
 952         u8 values[ACPI_WRDS_TABLE_SIZE];
 953 };
 954
 955 #ifdef CONFIG_ACPI
 956 static int iwl_mvm_sar_get_wrds(struct iwl_mvm *mvm, union acpi_object *wrds,
 957                                 struct iwl_mvm_sar_table *sar_table)
 958 {
 959         union acpi_object *data_pkg;
 960         u32 i;
 961
 962         /* We need at least two packages, one for the revision and one
 963          * for the data itself.  Also check that the revision is valid
 964          * (i.e. it is an integer set to 0).
 965         */
 966         if (wrds->type != ACPI_TYPE_PACKAGE ||
 967             wrds->package.count < 2 ||
 968             wrds->package.elements[0].type != ACPI_TYPE_INTEGER ||
 969             wrds->package.elements[0].integer.value != 0) {
 970                 IWL_DEBUG_RADIO(mvm, "Unsupported wrds structure\n");
 971                 return -EINVAL;
 972         }
 973
 974         /* loop through all the packages to find the one for WiFi */
 975         for (i = 1; i < wrds->package.count; i++) {
 976                 union acpi_object *domain;
 977
 978                 data_pkg = &wrds->package.elements[i];
 979
 980                 /* Skip anything that is not a package with the right
 981                  * amount of elements (i.e. domain_type,
 982                  * enabled/disabled plus the sar table size.
 983                  */
 984                 if (data_pkg->type != ACPI_TYPE_PACKAGE ||
 985                     data_pkg->package.count != ACPI_WRDS_TABLE_SIZE + 2)
 986                         continue;
 987
 988                 domain = &data_pkg->package.elements[0];
 989                 if (domain->type == ACPI_TYPE_INTEGER &&
 990                     domain->integer.value == ACPI_WRDS_WIFI)
 991                         break;
 992
 993                 data_pkg = NULL;
 994         }
 995
 996         if (!data_pkg)
 997                 return -ENOENT;
 998
 999         if (data_pkg->package.elements[1].type != ACPI_TYPE_INTEGER)
1000                 return -EINVAL;
1001
1002         sar_table->enabled = !!(data_pkg->package.elements[1].integer.value);
1003
1004         for (i = 0; i < ACPI_WRDS_TABLE_SIZE; i++) {
1005                 union acpi_object *entry;
1006
1007                 entry = &data_pkg->package.elements[i + 2];
1008                 if ((entry->type != ACPI_TYPE_INTEGER) ||
1009                     (entry->integer.value > U8_MAX))
1010                         return -EINVAL;
1011
1012                 sar_table->values[i] = entry->integer.value;
1013         }
1014
1015         return 0;
1016 }
1017
1018 static int iwl_mvm_sar_get_table(struct iwl_mvm *mvm,
1019                                  struct iwl_mvm_sar_table *sar_table)
1020 {
1021         acpi_handle root_handle;
1022         acpi_handle handle;
1023         struct acpi_buffer wrds = {ACPI_ALLOCATE_BUFFER, NULL};
1024         acpi_status status;
1025         int ret;
1026
1027         root_handle = ACPI_HANDLE(mvm->dev);
1028         if (!root_handle) {
1029                 IWL_DEBUG_RADIO(mvm,
1030                                 "Could not retrieve root port ACPI handle\n");
1031                 return -ENOENT;
1032         }
1033
1034         /* Get the method's handle */
1035         status = acpi_get_handle(root_handle, (acpi_string)ACPI_WRDS_METHOD,
1036                                  &handle);
1037         if (ACPI_FAILURE(status)) {
1038                 IWL_DEBUG_RADIO(mvm, "WRDS method not found\n");
1039                 return -ENOENT;
1040         }
1041
1042         /* Call WRDS with no arguments */
1043         status = acpi_evaluate_object(handle, NULL, NULL, &wrds);
1044         if (ACPI_FAILURE(status)) {
1045                 IWL_DEBUG_RADIO(mvm, "WRDS invocation failed (0x%x)\n", status);
1046                 return -ENOENT;
1047         }
1048
1049         ret = iwl_mvm_sar_get_wrds(mvm, wrds.pointer, sar_table);
1050         kfree(wrds.pointer);
1051
1052         return ret;
1053 }
1054 #else /* CONFIG_ACPI */
1055 static int iwl_mvm_sar_get_table(struct iwl_mvm *mvm,
1056                                  struct iwl_mvm_sar_table *sar_table)
1057 {
1058         return -ENOENT;
1059 }
1060 #endif /* CONFIG_ACPI */
1061
1062 static int iwl_mvm_sar_init(struct iwl_mvm *mvm)
1063 {
1064         struct iwl_mvm_sar_table sar_table;
1065         struct iwl_dev_tx_power_cmd cmd = {
1066                 .v3.set_mode = cpu_to_le32(IWL_TX_POWER_MODE_SET_CHAINS),
1067         };
1068         int ret, i, j, idx;
1069         int len = sizeof(cmd);
1070
1071         if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TX_POWER_ACK))
1072                 len = sizeof(cmd.v3);
1073
1074         ret = iwl_mvm_sar_get_table(mvm, &sar_table);
1075         if (ret < 0) {
1076                 IWL_DEBUG_RADIO(mvm,
1077                                 "SAR BIOS table invalid or unavailable. (%d)\n",
1078                                 ret);
1079                 /* we don't fail if the table is not available */
1080                 return 0;
1081         }
1082
1083         if (!sar_table.enabled)
1084                 return 0;
1085
1086         IWL_DEBUG_RADIO(mvm, "Sending REDUCE_TX_POWER_CMD per chain\n");
1087
1088         BUILD_BUG_ON(IWL_NUM_CHAIN_LIMITS * IWL_NUM_SUB_BANDS !=
1089                      ACPI_WRDS_TABLE_SIZE);
1090
1091         for (i = 0; i < IWL_NUM_CHAIN_LIMITS; i++) {
1092                 IWL_DEBUG_RADIO(mvm, "  Chain[%d]:\n", i);
1093                 for (j = 0; j < IWL_NUM_SUB_BANDS; j++) {
1094                         idx = (i * IWL_NUM_SUB_BANDS) + j;
1095                         cmd.v3.per_chain_restriction[i][j] =
1096                                 cpu_to_le16(sar_table.values[idx]);
1097                         IWL_DEBUG_RADIO(mvm, "    Band[%d] = %d * .125dBm\n",
1098                                         j, sar_table.values[idx]);
1099                 }
1100         }
1101
1102         ret = iwl_mvm_send_cmd_pdu(mvm, REDUCE_TX_POWER_CMD, 0, len, &cmd);
1103         if (ret)
1104                 IWL_ERR(mvm, "failed to set per-chain TX power: %d\n", ret);
1105
1106         return ret;
1107 }
1108
1109 int iwl_mvm_up(struct iwl_mvm *mvm)
1110 {
1111         int ret, i;
1112         struct ieee80211_channel *chan;
1113         struct cfg80211_chan_def chandef;
1114
1115         lockdep_assert_held(&mvm->mutex);
1116
1117         ret = iwl_trans_start_hw(mvm->trans);
1118         if (ret)
1119                 return ret;
1120
1121         /*
1122          * If we haven't completed the run of the init ucode during
1123          * module loading, load init ucode now
1124          * (for example, if we were in RFKILL)
1125          */
1126         ret = iwl_run_init_mvm_ucode(mvm, false);
1127
1128         if (iwlmvm_mod_params.init_dbg)
1129                 return 0;
1130
1131         if (ret) {
1132                 IWL_ERR(mvm, "Failed to run INIT ucode: %d\n", ret);
1133                 /* this can't happen */
1134                 if (WARN_ON(ret > 0))
1135                         ret = -ERFKILL;
1136                 goto error;
1137         }
1138
1139         /*
1140          * Stop and start the transport without entering low power
1141          * mode. This will save the state of other components on the
1142          * device that are triggered by the INIT firwmare (MFUART).
1143          */
1144         _iwl_trans_stop_device(mvm->trans, false);
1145         ret = _iwl_trans_start_hw(mvm->trans, false);
1146         if (ret)
1147                 goto error;
1148
1149         ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_REGULAR);
1150         if (ret) {
1151                 IWL_ERR(mvm, "Failed to start RT ucode: %d\n", ret);
1152                 goto error;
1153         }
1154
1155         iwl_mvm_get_shared_mem_conf(mvm);
1156
1157         ret = iwl_mvm_sf_update(mvm, NULL, false);
1158         if (ret)
1159                 IWL_ERR(mvm, "Failed to initialize Smart Fifo\n");
1160
1161         mvm->fw_dbg_conf = FW_DBG_INVALID;
1162         /* if we have a destination, assume EARLY START */
1163         if (mvm->fw->dbg_dest_tlv)
1164                 mvm->fw_dbg_conf = FW_DBG_START_FROM_ALIVE;
1165         iwl_mvm_start_fw_dbg_conf(mvm, FW_DBG_START_FROM_ALIVE);
1166
1167         ret = iwl_send_tx_ant_cfg(mvm, iwl_mvm_get_valid_tx_ant(mvm));
1168         if (ret)
1169                 goto error;
1170
1171         ret = iwl_send_bt_init_conf(mvm);
1172         if (ret)
1173                 goto error;
1174
1175         /* Send phy db control command and then phy db calibration*/
1176         ret = iwl_send_phy_db_data(mvm->phy_db);
1177         if (ret)
1178                 goto error;
1179
1180         ret = iwl_send_phy_cfg_cmd(mvm);
1181         if (ret)
1182                 goto error;
1183
1184         /* Init RSS configuration */
1185         if (iwl_mvm_has_new_rx_api(mvm)) {
1186                 ret = iwl_send_rss_cfg_cmd(mvm);
1187                 if (ret) {
1188                         IWL_ERR(mvm, "Failed to configure RSS queues: %d\n",
1189                                 ret);
1190                         goto error;
1191                 }
1192         }
1193
1194         /* init the fw <-> mac80211 STA mapping */
1195         for (i = 0; i < IWL_MVM_STATION_COUNT; i++)
1196                 RCU_INIT_POINTER(mvm->fw_id_to_mac_id[i], NULL);
1197
1198         mvm->tdls_cs.peer.sta_id = IWL_MVM_STATION_COUNT;
1199
1200         /* reset quota debouncing buffer - 0xff will yield invalid data */
1201         memset(&mvm->last_quota_cmd, 0xff, sizeof(mvm->last_quota_cmd));
1202
1203         /* Enable DQA-mode if required */
1204         if (iwl_mvm_is_dqa_supported(mvm)) {
1205                 ret = iwl_mvm_send_dqa_cmd(mvm);
1206                 if (ret)
1207                         goto error;
1208         } else {
1209                 IWL_DEBUG_FW(mvm, "Working in non-DQA mode\n");
1210         }
1211
1212         /* Add auxiliary station for scanning */
1213         ret = iwl_mvm_add_aux_sta(mvm);
1214         if (ret)
1215                 goto error;
1216
1217         /* Add all the PHY contexts */
1218         chan = &mvm->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels[0];
1219         cfg80211_chandef_create(&chandef, chan, NL80211_CHAN_NO_HT);
1220         for (i = 0; i < NUM_PHY_CTX; i++) {
1221                 /*
1222                  * The channel used here isn't relevant as it's
1223                  * going to be overwritten in the other flows.
1224                  * For now use the first channel we have.
1225                  */
1226                 ret = iwl_mvm_phy_ctxt_add(mvm, &mvm->phy_ctxts[i],
1227                                            &chandef, 1, 1);
1228                 if (ret)
1229                         goto error;
1230         }
1231
1232 #ifdef CONFIG_THERMAL
1233         if (iwl_mvm_is_tt_in_fw(mvm)) {
1234                 /* in order to give the responsibility of ct-kill and
1235                  * TX backoff to FW we need to send empty temperature reporting
1236                  * cmd during init time
1237                  */
1238                 iwl_mvm_send_temp_report_ths_cmd(mvm);
1239         } else {
1240                 /* Initialize tx backoffs to the minimal possible */
1241                 iwl_mvm_tt_tx_backoff(mvm, 0);
1242         }
1243
1244         /* TODO: read the budget from BIOS / Platform NVM */
1245         if (iwl_mvm_is_ctdp_supported(mvm) && mvm->cooling_dev.cur_state > 0) {
1246                 ret = iwl_mvm_ctdp_command(mvm, CTDP_CMD_OPERATION_START,
1247                                            mvm->cooling_dev.cur_state);
1248                 if (ret)
1249                         goto error;
1250         }
1251 #else
1252         /* Initialize tx backoffs to the minimal possible */
1253         iwl_mvm_tt_tx_backoff(mvm, 0);
1254 #endif
1255
1256         WARN_ON(iwl_mvm_config_ltr(mvm));
1257
1258         ret = iwl_mvm_power_update_device(mvm);
1259         if (ret)
1260                 goto error;
1261
1262         /*
1263          * RTNL is not taken during Ct-kill, but we don't need to scan/Tx
1264          * anyway, so don't init MCC.
1265          */
1266         if (!test_bit(IWL_MVM_STATUS_HW_CTKILL, &mvm->status)) {
1267                 ret = iwl_mvm_init_mcc(mvm);
1268                 if (ret)
1269                         goto error;
1270         }
1271
1272         if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
1273                 mvm->scan_type = IWL_SCAN_TYPE_NOT_SET;
1274                 ret = iwl_mvm_config_scan(mvm);
1275                 if (ret)
1276                         goto error;
1277         }
1278
1279         if (iwl_mvm_is_csum_supported(mvm) &&
1280             mvm->cfg->features & NETIF_F_RXCSUM)
1281                 iwl_trans_write_prph(mvm->trans, RX_EN_CSUM, 0x3);
1282
1283         /* allow FW/transport low power modes if not during restart */
1284         if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
1285                 iwl_mvm_unref(mvm, IWL_MVM_REF_UCODE_DOWN);
1286
1287         ret = iwl_mvm_sar_init(mvm);
1288         if (ret)
1289                 goto error;
1290
1291         IWL_DEBUG_INFO(mvm, "RT uCode started.\n");
1292         return 0;
1293  error:
1294         iwl_mvm_stop_device(mvm);
1295         return ret;
1296 }
1297
1298 int iwl_mvm_load_d3_fw(struct iwl_mvm *mvm)
1299 {
1300         int ret, i;
1301
1302         lockdep_assert_held(&mvm->mutex);
1303
1304         ret = iwl_trans_start_hw(mvm->trans);
1305         if (ret)
1306                 return ret;
1307
1308         ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_WOWLAN);
1309         if (ret) {
1310                 IWL_ERR(mvm, "Failed to start WoWLAN firmware: %d\n", ret);
1311                 goto error;
1312         }
1313
1314         ret = iwl_send_tx_ant_cfg(mvm, iwl_mvm_get_valid_tx_ant(mvm));
1315         if (ret)
1316                 goto error;
1317
1318         /* Send phy db control command and then phy db calibration*/
1319         ret = iwl_send_phy_db_data(mvm->phy_db);
1320         if (ret)
1321                 goto error;
1322
1323         ret = iwl_send_phy_cfg_cmd(mvm);
1324         if (ret)
1325                 goto error;
1326
1327         /* init the fw <-> mac80211 STA mapping */
1328         for (i = 0; i < IWL_MVM_STATION_COUNT; i++)
1329                 RCU_INIT_POINTER(mvm->fw_id_to_mac_id[i], NULL);
1330
1331         /* Add auxiliary station for scanning */
1332         ret = iwl_mvm_add_aux_sta(mvm);
1333         if (ret)
1334                 goto error;
1335
1336         return 0;
1337  error:
1338         iwl_mvm_stop_device(mvm);
1339         return ret;
1340 }
1341
1342 void iwl_mvm_rx_card_state_notif(struct iwl_mvm *mvm,
1343                                  struct iwl_rx_cmd_buffer *rxb)
1344 {
1345         struct iwl_rx_packet *pkt = rxb_addr(rxb);
1346         struct iwl_card_state_notif *card_state_notif = (void *)pkt->data;
1347         u32 flags = le32_to_cpu(card_state_notif->flags);
1348
1349         IWL_DEBUG_RF_KILL(mvm, "Card state received: HW:%s SW:%s CT:%s\n",
1350                           (flags & HW_CARD_DISABLED) ? "Kill" : "On",
1351                           (flags & SW_CARD_DISABLED) ? "Kill" : "On",
1352                           (flags & CT_KILL_CARD_DISABLED) ?
1353                           "Reached" : "Not reached");
1354 }
1355
1356 void iwl_mvm_rx_mfuart_notif(struct iwl_mvm *mvm,
1357                              struct iwl_rx_cmd_buffer *rxb)
1358 {
1359         struct iwl_rx_packet *pkt = rxb_addr(rxb);
1360         struct iwl_mfuart_load_notif *mfuart_notif = (void *)pkt->data;
1361
1362         IWL_DEBUG_INFO(mvm,
1363                        "MFUART: installed ver: 0x%08x, external ver: 0x%08x, status: 0x%08x, duration: 0x%08x\n",
1364                        le32_to_cpu(mfuart_notif->installed_ver),
1365                        le32_to_cpu(mfuart_notif->external_ver),
1366                        le32_to_cpu(mfuart_notif->status),
1367                        le32_to_cpu(mfuart_notif->duration));
1368 }