blob: e481bb050c6e7357a59fa4a49d2bad62bdd977e3 [file] [log] [blame]
Johannes Berg8ca151b2013-01-24 14:25:36 +01001/******************************************************************************
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 *
Emmanuel Grumbach51368bf2013-12-30 13:15:54 +02008 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
Eran Harary8d193ca2015-04-27 10:29:31 +03009 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
Golan Ben-Amibdccdb82016-11-15 14:45:29 +020010 * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
Johannes Berg8ca151b2013-01-24 14:25:36 +010011 *
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
Emmanuel Grumbach410dc5a2013-02-18 09:22:28 +020027 * in the file called COPYING.
Johannes Berg8ca151b2013-01-24 14:25:36 +010028 *
29 * Contact Information:
Emmanuel Grumbachcb2f8272015-11-17 15:39:56 +020030 * Intel Linux Wireless <linuxwifi@intel.com>
Johannes Berg8ca151b2013-01-24 14:25:36 +010031 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
32 *
33 * BSD LICENSE
34 *
Emmanuel Grumbach51368bf2013-12-30 13:15:54 +020035 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
Eran Harary8d193ca2015-04-27 10:29:31 +030036 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
Golan Ben-Amibdccdb82016-11-15 14:45:29 +020037 * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
Johannes Berg8ca151b2013-01-24 14:25:36 +010038 * All rights reserved.
39 *
40 * Redistribution and use in source and binary forms, with or without
41 * modification, are permitted provided that the following conditions
42 * are met:
43 *
44 * * Redistributions of source code must retain the above copyright
45 * notice, this list of conditions and the following disclaimer.
46 * * Redistributions in binary form must reproduce the above copyright
47 * notice, this list of conditions and the following disclaimer in
48 * the documentation and/or other materials provided with the
49 * distribution.
50 * * Neither the name Intel Corporation nor the names of its
51 * contributors may be used to endorse or promote products derived
52 * from this software without specific prior written permission.
53 *
54 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
55 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
56 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
57 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
58 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
59 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
60 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
61 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
62 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
63 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
64 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
65 *
66 *****************************************************************************/
67#include <net/mac80211.h>
Sara Sharon854d7732016-03-22 15:55:58 +020068#include <linux/netdevice.h>
Luca Coelhoda2830a2016-05-30 13:00:44 +030069#include <linux/acpi.h>
Johannes Berg8ca151b2013-01-24 14:25:36 +010070
71#include "iwl-trans.h"
72#include "iwl-op-mode.h"
73#include "iwl-fw.h"
74#include "iwl-debug.h"
75#include "iwl-csr.h" /* for iwl_mvm_rx_card_state_notif */
76#include "iwl-io.h" /* for iwl_mvm_rx_card_state_notif */
Emmanuel Grumbach8c23f952014-12-04 10:07:47 +020077#include "iwl-prph.h"
Johannes Berg8ca151b2013-01-24 14:25:36 +010078#include "iwl-eeprom-parse.h"
79
80#include "mvm.h"
Golan Ben-Ami2f89a5d2015-10-27 19:17:14 +020081#include "fw-dbg.h"
Johannes Berg8ca151b2013-01-24 14:25:36 +010082#include "iwl-phy-db.h"
83
84#define MVM_UCODE_ALIVE_TIMEOUT HZ
85#define MVM_UCODE_CALIB_TIMEOUT (2*HZ)
86
87#define UCODE_VALID_OK cpu_to_le32(0x1)
88
Johannes Berg8ca151b2013-01-24 14:25:36 +010089struct iwl_mvm_alive_data {
90 bool valid;
91 u32 scd_base_addr;
92};
93
Johannes Berg8ca151b2013-01-24 14:25:36 +010094static int iwl_send_tx_ant_cfg(struct iwl_mvm *mvm, u8 valid_tx_ant)
95{
96 struct iwl_tx_ant_cfg_cmd tx_ant_cmd = {
97 .valid = cpu_to_le32(valid_tx_ant),
98 };
99
Emmanuel Grumbach33223542013-03-09 20:38:19 +0200100 IWL_DEBUG_FW(mvm, "select valid tx ant: %u\n", valid_tx_ant);
Emmanuel Grumbacha1022922014-05-12 11:36:41 +0300101 return iwl_mvm_send_cmd_pdu(mvm, TX_ANT_CONFIGURATION_CMD, 0,
Johannes Berg8ca151b2013-01-24 14:25:36 +0100102 sizeof(tx_ant_cmd), &tx_ant_cmd);
103}
104
Sara Sharon43413a92015-12-31 11:49:18 +0200105static int iwl_send_rss_cfg_cmd(struct iwl_mvm *mvm)
106{
107 int i;
108 struct iwl_rss_config_cmd cmd = {
109 .flags = cpu_to_le32(IWL_RSS_ENABLE),
110 .hash_mask = IWL_RSS_HASH_TYPE_IPV4_TCP |
Sara Sharon854d7732016-03-22 15:55:58 +0200111 IWL_RSS_HASH_TYPE_IPV4_UDP |
Sara Sharon43413a92015-12-31 11:49:18 +0200112 IWL_RSS_HASH_TYPE_IPV4_PAYLOAD |
113 IWL_RSS_HASH_TYPE_IPV6_TCP |
Sara Sharon854d7732016-03-22 15:55:58 +0200114 IWL_RSS_HASH_TYPE_IPV6_UDP |
Sara Sharon43413a92015-12-31 11:49:18 +0200115 IWL_RSS_HASH_TYPE_IPV6_PAYLOAD,
116 };
117
Sara Sharonf43495f2016-05-04 14:22:10 +0300118 if (mvm->trans->num_rx_queues == 1)
119 return 0;
120
Sara Sharon854d7732016-03-22 15:55:58 +0200121 /* Do not direct RSS traffic to Q 0 which is our fallback queue */
Sara Sharon43413a92015-12-31 11:49:18 +0200122 for (i = 0; i < ARRAY_SIZE(cmd.indirection_table); i++)
Sara Sharon854d7732016-03-22 15:55:58 +0200123 cmd.indirection_table[i] =
124 1 + (i % (mvm->trans->num_rx_queues - 1));
125 netdev_rss_key_fill(cmd.secret_key, sizeof(cmd.secret_key));
Sara Sharon43413a92015-12-31 11:49:18 +0200126
127 return iwl_mvm_send_cmd_pdu(mvm, RSS_CONFIG_CMD, 0, sizeof(cmd), &cmd);
128}
129
Liad Kaufman97d5be72015-08-31 14:33:23 +0300130static int iwl_mvm_send_dqa_cmd(struct iwl_mvm *mvm)
131{
132 struct iwl_dqa_enable_cmd dqa_cmd = {
133 .cmd_queue = cpu_to_le32(IWL_MVM_DQA_CMD_QUEUE),
134 };
135 u32 cmd_id = iwl_cmd_id(DQA_ENABLE_CMD, DATA_PATH_GROUP, 0);
136 int ret;
137
138 ret = iwl_mvm_send_cmd_pdu(mvm, cmd_id, 0, sizeof(dqa_cmd), &dqa_cmd);
139 if (ret)
140 IWL_ERR(mvm, "Failed to send DQA enabling command: %d\n", ret);
141 else
142 IWL_DEBUG_FW(mvm, "Working in DQA mode\n");
143
144 return ret;
145}
146
Matti Gottlieb905e36a2016-02-14 17:05:39 +0200147void iwl_free_fw_paging(struct iwl_mvm *mvm)
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300148{
149 int i;
150
151 if (!mvm->fw_paging_db[0].fw_paging_block)
152 return;
153
154 for (i = 0; i < NUM_OF_FW_PAGING_BLOCKS; i++) {
Emmanuel Grumbach3edbc7d2016-06-19 20:57:02 +0300155 struct iwl_fw_paging *paging = &mvm->fw_paging_db[i];
156
157 if (!paging->fw_paging_block) {
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300158 IWL_DEBUG_FW(mvm,
159 "Paging: block %d already freed, continue to next page\n",
160 i);
161
162 continue;
163 }
Emmanuel Grumbach3edbc7d2016-06-19 20:57:02 +0300164 dma_unmap_page(mvm->trans->dev, paging->fw_paging_phys,
165 paging->fw_paging_size, DMA_BIDIRECTIONAL);
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300166
Emmanuel Grumbach3edbc7d2016-06-19 20:57:02 +0300167 __free_pages(paging->fw_paging_block,
168 get_order(paging->fw_paging_size));
169 paging->fw_paging_block = NULL;
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300170 }
Matti Gottliebe1120182015-07-19 11:15:07 +0300171 kfree(mvm->trans->paging_download_buf);
Matti Gottlieb905e36a2016-02-14 17:05:39 +0200172 mvm->trans->paging_download_buf = NULL;
Matti Gottliebf742aaf2016-04-10 10:53:57 +0300173 mvm->trans->paging_db = NULL;
Matti Gottlieb905e36a2016-02-14 17:05:39 +0200174
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300175 memset(mvm->fw_paging_db, 0, sizeof(mvm->fw_paging_db));
176}
177
178static int iwl_fill_paging_mem(struct iwl_mvm *mvm, const struct fw_img *image)
179{
180 int sec_idx, idx;
181 u32 offset = 0;
182
183 /*
184 * find where is the paging image start point:
185 * if CPU2 exist and it's in paging format, then the image looks like:
186 * CPU1 sections (2 or more)
187 * CPU1_CPU2_SEPARATOR_SECTION delimiter - separate between CPU1 to CPU2
188 * CPU2 sections (not paged)
189 * PAGING_SEPARATOR_SECTION delimiter - separate between CPU2
190 * non paged to CPU2 paging sec
191 * CPU2 paging CSS
192 * CPU2 paging image (including instruction and data)
193 */
Sara Sharoneef187a2016-10-25 11:38:31 +0300194 for (sec_idx = 0; sec_idx < image->num_sec; sec_idx++) {
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300195 if (image->sec[sec_idx].offset == PAGING_SEPARATOR_SECTION) {
196 sec_idx++;
197 break;
198 }
199 }
200
Matti Gottliebcd47a3d2016-03-10 16:18:26 +0200201 /*
202 * If paging is enabled there should be at least 2 more sections left
203 * (one for CSS and one for Paging data)
204 */
Sara Sharoneef187a2016-10-25 11:38:31 +0300205 if (sec_idx >= image->num_sec - 1) {
Matti Gottliebcd47a3d2016-03-10 16:18:26 +0200206 IWL_ERR(mvm, "Paging: Missing CSS and/or paging sections\n");
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300207 iwl_free_fw_paging(mvm);
208 return -EINVAL;
209 }
210
211 /* copy the CSS block to the dram */
212 IWL_DEBUG_FW(mvm, "Paging: load paging CSS to FW, sec = %d\n",
213 sec_idx);
214
215 memcpy(page_address(mvm->fw_paging_db[0].fw_paging_block),
216 image->sec[sec_idx].data,
217 mvm->fw_paging_db[0].fw_paging_size);
Sara Sharon4b70f072016-11-30 16:49:11 +0200218 dma_sync_single_for_device(mvm->trans->dev,
219 mvm->fw_paging_db[0].fw_paging_phys,
220 mvm->fw_paging_db[0].fw_paging_size,
221 DMA_BIDIRECTIONAL);
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300222
223 IWL_DEBUG_FW(mvm,
224 "Paging: copied %d CSS bytes to first block\n",
225 mvm->fw_paging_db[0].fw_paging_size);
226
227 sec_idx++;
228
229 /*
230 * copy the paging blocks to the dram
231 * loop index start from 1 since that CSS block already copied to dram
232 * and CSS index is 0.
233 * loop stop at num_of_paging_blk since that last block is not full.
234 */
235 for (idx = 1; idx < mvm->num_of_paging_blk; idx++) {
Sara Sharon4b70f072016-11-30 16:49:11 +0200236 struct iwl_fw_paging *block = &mvm->fw_paging_db[idx];
237
238 memcpy(page_address(block->fw_paging_block),
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300239 image->sec[sec_idx].data + offset,
Sara Sharon4b70f072016-11-30 16:49:11 +0200240 block->fw_paging_size);
241 dma_sync_single_for_device(mvm->trans->dev,
242 block->fw_paging_phys,
243 block->fw_paging_size,
244 DMA_BIDIRECTIONAL);
245
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300246
247 IWL_DEBUG_FW(mvm,
248 "Paging: copied %d paging bytes to block %d\n",
249 mvm->fw_paging_db[idx].fw_paging_size,
250 idx);
251
252 offset += mvm->fw_paging_db[idx].fw_paging_size;
253 }
254
255 /* copy the last paging block */
256 if (mvm->num_of_pages_in_last_blk > 0) {
Sara Sharon4b70f072016-11-30 16:49:11 +0200257 struct iwl_fw_paging *block = &mvm->fw_paging_db[idx];
258
259 memcpy(page_address(block->fw_paging_block),
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300260 image->sec[sec_idx].data + offset,
261 FW_PAGING_SIZE * mvm->num_of_pages_in_last_blk);
Sara Sharon4b70f072016-11-30 16:49:11 +0200262 dma_sync_single_for_device(mvm->trans->dev,
263 block->fw_paging_phys,
264 block->fw_paging_size,
265 DMA_BIDIRECTIONAL);
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300266
267 IWL_DEBUG_FW(mvm,
268 "Paging: copied %d pages in the last block %d\n",
269 mvm->num_of_pages_in_last_blk, idx);
270 }
271
272 return 0;
273}
274
Golan Ben-Amibdccdb82016-11-15 14:45:29 +0200275void iwl_mvm_mfu_assert_dump_notif(struct iwl_mvm *mvm,
276 struct iwl_rx_cmd_buffer *rxb)
277{
278 struct iwl_rx_packet *pkt = rxb_addr(rxb);
279 struct iwl_mfu_assert_dump_notif *mfu_dump_notif = (void *)pkt->data;
280 __le32 *dump_data = mfu_dump_notif->data;
281 int n_words = le32_to_cpu(mfu_dump_notif->data_size) / sizeof(__le32);
282 int i;
283
284 if (mfu_dump_notif->index_num == 0)
285 IWL_INFO(mvm, "MFUART assert id 0x%x occurred\n",
286 le32_to_cpu(mfu_dump_notif->assert_id));
287
288 for (i = 0; i < n_words; i++)
289 IWL_DEBUG_INFO(mvm,
290 "MFUART assert dump, dword %u: 0x%08x\n",
291 le16_to_cpu(mfu_dump_notif->index_num) *
292 n_words + i,
293 le32_to_cpu(dump_data[i]));
294}
295
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300296static int iwl_alloc_fw_paging_mem(struct iwl_mvm *mvm,
297 const struct fw_img *image)
298{
299 struct page *block;
300 dma_addr_t phys = 0;
Sara Sharon08d785f2016-10-27 17:27:23 +0300301 int blk_idx, order, num_of_pages, size, dma_enabled;
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300302
303 if (mvm->fw_paging_db[0].fw_paging_block)
304 return 0;
305
306 dma_enabled = is_device_dma_capable(mvm->trans->dev);
307
308 /* ensure BLOCK_2_EXP_SIZE is power of 2 of PAGING_BLOCK_SIZE */
309 BUILD_BUG_ON(BIT(BLOCK_2_EXP_SIZE) != PAGING_BLOCK_SIZE);
310
311 num_of_pages = image->paging_mem_size / FW_PAGING_SIZE;
Sara Sharon850fe9a2016-10-27 17:58:27 +0300312 mvm->num_of_paging_blk =
313 DIV_ROUND_UP(num_of_pages, NUM_OF_PAGE_PER_GROUP);
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300314 mvm->num_of_pages_in_last_blk =
315 num_of_pages -
316 NUM_OF_PAGE_PER_GROUP * (mvm->num_of_paging_blk - 1);
317
318 IWL_DEBUG_FW(mvm,
319 "Paging: allocating mem for %d paging blocks, each block holds 8 pages, last block holds %d pages\n",
320 mvm->num_of_paging_blk,
321 mvm->num_of_pages_in_last_blk);
322
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300323 /*
Sara Sharon08d785f2016-10-27 17:27:23 +0300324 * Allocate CSS and paging blocks in dram.
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300325 */
Sara Sharon08d785f2016-10-27 17:27:23 +0300326 for (blk_idx = 0; blk_idx < mvm->num_of_paging_blk + 1; blk_idx++) {
327 /* For CSS allocate 4KB, for others PAGING_BLOCK_SIZE (32K) */
328 size = blk_idx ? PAGING_BLOCK_SIZE : FW_PAGING_SIZE;
329 order = get_order(size);
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300330 block = alloc_pages(GFP_KERNEL, order);
331 if (!block) {
332 /* free all the previous pages since we failed */
333 iwl_free_fw_paging(mvm);
334 return -ENOMEM;
335 }
336
337 mvm->fw_paging_db[blk_idx].fw_paging_block = block;
Sara Sharon08d785f2016-10-27 17:27:23 +0300338 mvm->fw_paging_db[blk_idx].fw_paging_size = size;
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300339
340 if (dma_enabled) {
341 phys = dma_map_page(mvm->trans->dev, block, 0,
342 PAGE_SIZE << order,
343 DMA_BIDIRECTIONAL);
344 if (dma_mapping_error(mvm->trans->dev, phys)) {
345 /*
346 * free the previous pages and the current one
347 * since we failed to map_page.
348 */
349 iwl_free_fw_paging(mvm);
350 return -ENOMEM;
351 }
352 mvm->fw_paging_db[blk_idx].fw_paging_phys = phys;
Matti Gottliebe1120182015-07-19 11:15:07 +0300353 } else {
354 mvm->fw_paging_db[blk_idx].fw_paging_phys =
355 PAGING_ADDR_SIG |
356 blk_idx << BLOCK_2_EXP_SIZE;
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300357 }
358
Sara Sharon08d785f2016-10-27 17:27:23 +0300359 if (!blk_idx)
360 IWL_DEBUG_FW(mvm,
361 "Paging: allocated 4K(CSS) bytes (order %d) for firmware paging.\n",
362 order);
363 else
364 IWL_DEBUG_FW(mvm,
365 "Paging: allocated 32K bytes (order %d) for firmware paging.\n",
366 order);
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300367 }
368
369 return 0;
370}
371
372static int iwl_save_fw_paging(struct iwl_mvm *mvm,
373 const struct fw_img *fw)
374{
375 int ret;
376
377 ret = iwl_alloc_fw_paging_mem(mvm, fw);
378 if (ret)
379 return ret;
380
381 return iwl_fill_paging_mem(mvm, fw);
382}
383
384/* send paging cmd to FW in case CPU2 has paging image */
385static int iwl_send_paging_cmd(struct iwl_mvm *mvm, const struct fw_img *fw)
386{
Sara Sharond975d722016-07-04 11:52:07 +0300387 struct iwl_fw_paging_cmd paging_cmd = {
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300388 .flags =
389 cpu_to_le32(PAGING_CMD_IS_SECURED |
390 PAGING_CMD_IS_ENABLED |
391 (mvm->num_of_pages_in_last_blk <<
392 PAGING_CMD_NUM_OF_PAGES_IN_LAST_GRP_POS)),
393 .block_size = cpu_to_le32(BLOCK_2_EXP_SIZE),
394 .block_num = cpu_to_le32(mvm->num_of_paging_blk),
395 };
Sara Sharond975d722016-07-04 11:52:07 +0300396 int blk_idx, size = sizeof(paging_cmd);
397
398 /* A bit hard coded - but this is the old API and will be deprecated */
399 if (!iwl_mvm_has_new_tx_api(mvm))
400 size -= NUM_OF_FW_PAGING_BLOCKS * 4;
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300401
402 /* loop for for all paging blocks + CSS block */
403 for (blk_idx = 0; blk_idx < mvm->num_of_paging_blk + 1; blk_idx++) {
Sara Sharond975d722016-07-04 11:52:07 +0300404 dma_addr_t addr = mvm->fw_paging_db[blk_idx].fw_paging_phys;
405
406 addr = addr >> PAGE_2_EXP_SIZE;
407
408 if (iwl_mvm_has_new_tx_api(mvm)) {
409 __le64 phy_addr = cpu_to_le64(addr);
410
411 paging_cmd.device_phy_addr.addr64[blk_idx] = phy_addr;
412 } else {
413 __le32 phy_addr = cpu_to_le32(addr);
414
415 paging_cmd.device_phy_addr.addr32[blk_idx] = phy_addr;
416 }
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300417 }
418
419 return iwl_mvm_send_cmd_pdu(mvm, iwl_cmd_id(FW_PAGING_BLOCK_CMD,
420 IWL_ALWAYS_LONG_GROUP, 0),
Sara Sharond975d722016-07-04 11:52:07 +0300421 0, size, &paging_cmd);
Matti Gottlieba6c4fb42015-07-15 16:19:29 +0300422}
423
Matti Gottliebe1120182015-07-19 11:15:07 +0300424/*
425 * Send paging item cmd to FW in case CPU2 has paging image
426 */
427static int iwl_trans_get_paging_item(struct iwl_mvm *mvm)
428{
429 int ret;
430 struct iwl_fw_get_item_cmd fw_get_item_cmd = {
431 .item_id = cpu_to_le32(IWL_FW_ITEM_ID_PAGING),
432 };
433
434 struct iwl_fw_get_item_resp *item_resp;
435 struct iwl_host_cmd cmd = {
436 .id = iwl_cmd_id(FW_GET_ITEM_CMD, IWL_ALWAYS_LONG_GROUP, 0),
437 .flags = CMD_WANT_SKB | CMD_SEND_IN_RFKILL,
438 .data = { &fw_get_item_cmd, },
439 };
440
441 cmd.len[0] = sizeof(struct iwl_fw_get_item_cmd);
442
443 ret = iwl_mvm_send_cmd(mvm, &cmd);
444 if (ret) {
445 IWL_ERR(mvm,
446 "Paging: Failed to send FW_GET_ITEM_CMD cmd (err = %d)\n",
447 ret);
448 return ret;
449 }
450
451 item_resp = (void *)((struct iwl_rx_packet *)cmd.resp_pkt)->data;
452 if (item_resp->item_id != cpu_to_le32(IWL_FW_ITEM_ID_PAGING)) {
453 IWL_ERR(mvm,
454 "Paging: got wrong item in FW_GET_ITEM_CMD resp (item_id = %u)\n",
455 le32_to_cpu(item_resp->item_id));
456 ret = -EIO;
457 goto exit;
458 }
459
Matti Gottliebc94d7992016-03-09 10:54:10 +0200460 /* Add an extra page for headers */
461 mvm->trans->paging_download_buf = kzalloc(PAGING_BLOCK_SIZE +
462 FW_PAGING_SIZE,
Matti Gottliebe1120182015-07-19 11:15:07 +0300463 GFP_KERNEL);
464 if (!mvm->trans->paging_download_buf) {
465 ret = -ENOMEM;
466 goto exit;
467 }
468 mvm->trans->paging_req_addr = le32_to_cpu(item_resp->item_val);
469 mvm->trans->paging_db = mvm->fw_paging_db;
470 IWL_DEBUG_FW(mvm,
471 "Paging: got paging request address (paging_req_addr 0x%08x)\n",
472 mvm->trans->paging_req_addr);
473
474exit:
475 iwl_free_resp(&cmd);
476
477 return ret;
478}
479
Johannes Berg8ca151b2013-01-24 14:25:36 +0100480static bool iwl_alive_fn(struct iwl_notif_wait_data *notif_wait,
481 struct iwl_rx_packet *pkt, void *data)
482{
483 struct iwl_mvm *mvm =
484 container_of(notif_wait, struct iwl_mvm, notif_wait);
485 struct iwl_mvm_alive_data *alive_data = data;
Sara Sharon5c228d62016-11-24 13:48:27 +0200486 struct mvm_alive_resp_v3 *palive3;
Emmanuel Grumbach7e1223b2015-02-03 20:11:48 +0200487 struct mvm_alive_resp *palive;
Sara Sharon5c228d62016-11-24 13:48:27 +0200488 struct iwl_umac_alive *umac;
489 struct iwl_lmac_alive *lmac1;
490 struct iwl_lmac_alive *lmac2 = NULL;
491 u16 status;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100492
Sara Sharon5c228d62016-11-24 13:48:27 +0200493 if (iwl_rx_packet_payload_len(pkt) == sizeof(*palive)) {
Emmanuel Grumbach7e1223b2015-02-03 20:11:48 +0200494 palive = (void *)pkt->data;
Sara Sharon5c228d62016-11-24 13:48:27 +0200495 umac = &palive->umac_data;
496 lmac1 = &palive->lmac_data[0];
497 lmac2 = &palive->lmac_data[1];
498 status = le16_to_cpu(palive->status);
499 } else {
500 palive3 = (void *)pkt->data;
501 umac = &palive3->umac_data;
502 lmac1 = &palive3->lmac_data;
503 status = le16_to_cpu(palive3->status);
Eran Harary01a9ca52014-02-03 09:29:57 +0200504 }
Johannes Berg8ca151b2013-01-24 14:25:36 +0100505
Sara Sharon5c228d62016-11-24 13:48:27 +0200506 mvm->error_event_table[0] = le32_to_cpu(lmac1->error_event_table_ptr);
507 if (lmac2)
508 mvm->error_event_table[1] =
509 le32_to_cpu(lmac2->error_event_table_ptr);
510 mvm->log_event_table = le32_to_cpu(lmac1->log_event_table_ptr);
511 mvm->sf_space.addr = le32_to_cpu(lmac1->st_fwrd_addr);
512 mvm->sf_space.size = le32_to_cpu(lmac1->st_fwrd_size);
513
514 mvm->umac_error_event_table = le32_to_cpu(umac->error_info_addr);
515
516 alive_data->scd_base_addr = le32_to_cpu(lmac1->scd_base_ptr);
517 alive_data->valid = status == IWL_ALIVE_STATUS_OK;
518 if (mvm->umac_error_event_table)
519 mvm->support_umac_log = true;
520
521 IWL_DEBUG_FW(mvm,
522 "Alive ucode status 0x%04x revision 0x%01X 0x%01X\n",
523 status, lmac1->ver_type, lmac1->ver_subtype);
524
525 if (lmac2)
526 IWL_DEBUG_FW(mvm, "Alive ucode CDB\n");
527
528 IWL_DEBUG_FW(mvm,
529 "UMAC version: Major - 0x%x, Minor - 0x%x\n",
530 le32_to_cpu(umac->umac_major),
531 le32_to_cpu(umac->umac_minor));
532
Johannes Berg8ca151b2013-01-24 14:25:36 +0100533 return true;
534}
535
Sara Sharon1f370652016-08-31 18:13:57 +0300536static bool iwl_wait_init_complete(struct iwl_notif_wait_data *notif_wait,
537 struct iwl_rx_packet *pkt, void *data)
538{
539 WARN_ON(pkt->hdr.cmd != INIT_COMPLETE_NOTIF);
540
541 return true;
542}
543
Johannes Berg8ca151b2013-01-24 14:25:36 +0100544static bool iwl_wait_phy_db_entry(struct iwl_notif_wait_data *notif_wait,
545 struct iwl_rx_packet *pkt, void *data)
546{
547 struct iwl_phy_db *phy_db = data;
548
549 if (pkt->hdr.cmd != CALIB_RES_NOTIF_PHY_DB) {
550 WARN_ON(pkt->hdr.cmd != INIT_COMPLETE_NOTIF);
551 return true;
552 }
553
Sara Sharonce1f2772016-04-10 16:02:12 +0300554 WARN_ON(iwl_phy_db_set_section(phy_db, pkt));
Johannes Berg8ca151b2013-01-24 14:25:36 +0100555
556 return false;
557}
558
Sara Sharon1f370652016-08-31 18:13:57 +0300559static int iwl_mvm_init_paging(struct iwl_mvm *mvm)
560{
561 const struct fw_img *fw = &mvm->fw->img[mvm->cur_ucode];
562 int ret;
563
564 /*
565 * Configure and operate fw paging mechanism.
566 * The driver configures the paging flow only once.
567 * The CPU2 paging image is included in the IWL_UCODE_INIT image.
568 */
569 if (!fw->paging_mem_size)
570 return 0;
571
572 /*
573 * When dma is not enabled, the driver needs to copy / write
574 * the downloaded / uploaded page to / from the smem.
575 * This gets the location of the place were the pages are
576 * stored.
577 */
578 if (!is_device_dma_capable(mvm->trans->dev)) {
579 ret = iwl_trans_get_paging_item(mvm);
580 if (ret) {
581 IWL_ERR(mvm, "failed to get FW paging item\n");
582 return ret;
583 }
584 }
585
586 ret = iwl_save_fw_paging(mvm, fw);
587 if (ret) {
588 IWL_ERR(mvm, "failed to save the FW paging image\n");
589 return ret;
590 }
591
592 ret = iwl_send_paging_cmd(mvm, fw);
593 if (ret) {
594 IWL_ERR(mvm, "failed to send the paging cmd\n");
595 iwl_free_fw_paging(mvm);
596 return ret;
597 }
598
599 return 0;
600}
Johannes Berg8ca151b2013-01-24 14:25:36 +0100601static int iwl_mvm_load_ucode_wait_alive(struct iwl_mvm *mvm,
602 enum iwl_ucode_type ucode_type)
603{
604 struct iwl_notification_wait alive_wait;
605 struct iwl_mvm_alive_data alive_data;
606 const struct fw_img *fw;
607 int ret, i;
608 enum iwl_ucode_type old_type = mvm->cur_ucode;
Sara Sharon6eb031d2015-07-13 14:50:47 +0300609 static const u16 alive_cmd[] = { MVM_ALIVE };
Eran Harary91479b62014-05-11 08:11:34 +0300610 struct iwl_sf_region st_fwrd_space;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100611
Eran Harary61df7502014-12-01 17:40:37 +0200612 if (ucode_type == IWL_UCODE_REGULAR &&
Golan Ben-Ami3d2d4422016-02-23 10:34:48 +0200613 iwl_fw_dbg_conf_usniffer(mvm->fw, FW_DBG_START_FROM_ALIVE) &&
614 !(fw_has_capa(&mvm->fw->ucode_capa,
615 IWL_UCODE_TLV_CAPA_USNIFFER_UNIFIED)))
Sharon Dvir612da1e2016-08-03 10:55:45 +0300616 fw = iwl_get_ucode_image(mvm->fw, IWL_UCODE_REGULAR_USNIFFER);
Eran Harary61df7502014-12-01 17:40:37 +0200617 else
Sharon Dvir612da1e2016-08-03 10:55:45 +0300618 fw = iwl_get_ucode_image(mvm->fw, ucode_type);
Johannes Bergbefe9b62013-10-25 12:32:51 +0200619 if (WARN_ON(!fw))
Johannes Berg8ca151b2013-01-24 14:25:36 +0100620 return -EINVAL;
Johannes Bergbefe9b62013-10-25 12:32:51 +0200621 mvm->cur_ucode = ucode_type;
622 mvm->ucode_loaded = false;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100623
624 iwl_init_notification_wait(&mvm->notif_wait, &alive_wait,
625 alive_cmd, ARRAY_SIZE(alive_cmd),
626 iwl_alive_fn, &alive_data);
627
628 ret = iwl_trans_start_fw(mvm->trans, fw, ucode_type == IWL_UCODE_INIT);
629 if (ret) {
630 mvm->cur_ucode = old_type;
631 iwl_remove_notification(&mvm->notif_wait, &alive_wait);
632 return ret;
633 }
634
635 /*
636 * Some things may run in the background now, but we
637 * just wait for the ALIVE notification here.
638 */
639 ret = iwl_wait_notification(&mvm->notif_wait, &alive_wait,
640 MVM_UCODE_ALIVE_TIMEOUT);
641 if (ret) {
Dor Shaish192de2b2015-07-15 11:41:21 +0300642 if (mvm->trans->cfg->device_family == IWL_DEVICE_FAMILY_8000)
643 IWL_ERR(mvm,
644 "SecBoot CPU1 Status: 0x%x, CPU2 Status: 0x%x\n",
645 iwl_read_prph(mvm->trans, SB_CPU_1_STATUS),
646 iwl_read_prph(mvm->trans, SB_CPU_2_STATUS));
Johannes Berg8ca151b2013-01-24 14:25:36 +0100647 mvm->cur_ucode = old_type;
648 return ret;
649 }
650
651 if (!alive_data.valid) {
652 IWL_ERR(mvm, "Loaded ucode is not valid!\n");
653 mvm->cur_ucode = old_type;
654 return -EIO;
655 }
656
Eran Harary91479b62014-05-11 08:11:34 +0300657 /*
658 * update the sdio allocation according to the pointer we get in the
659 * alive notification.
660 */
661 st_fwrd_space.addr = mvm->sf_space.addr;
662 st_fwrd_space.size = mvm->sf_space.size;
663 ret = iwl_trans_update_sf(mvm->trans, &st_fwrd_space);
Eyal Shapira82e8aea2014-10-19 14:56:40 +0300664 if (ret) {
665 IWL_ERR(mvm, "Failed to update SF size. ret %d\n", ret);
666 return ret;
667 }
Eran Harary91479b62014-05-11 08:11:34 +0300668
Johannes Berg8ca151b2013-01-24 14:25:36 +0100669 iwl_trans_fw_alive(mvm->trans, alive_data.scd_base_addr);
670
671 /*
672 * Note: all the queues are enabled as part of the interface
673 * initialization, but in firmware restart scenarios they
674 * could be stopped, so wake them up. In firmware restart,
675 * mac80211 will have the queues stopped as well until the
676 * reconfiguration completes. During normal startup, they
677 * will be empty.
678 */
679
Liad Kaufman4ecafae2015-07-14 13:36:18 +0300680 memset(&mvm->queue_info, 0, sizeof(mvm->queue_info));
Liad Kaufman097129c2015-08-09 18:28:43 +0300681 if (iwl_mvm_is_dqa_supported(mvm))
682 mvm->queue_info[IWL_MVM_DQA_CMD_QUEUE].hw_queue_refcount = 1;
683 else
684 mvm->queue_info[IWL_MVM_CMD_QUEUE].hw_queue_refcount = 1;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100685
Johannes Bergdf197c02014-08-01 18:14:45 +0200686 for (i = 0; i < IEEE80211_MAX_QUEUES; i++)
687 atomic_set(&mvm->mac80211_queue_stop_count[i], 0);
Johannes Berg8ca151b2013-01-24 14:25:36 +0100688
689 mvm->ucode_loaded = true;
690
691 return 0;
692}
Johannes Berg8ca151b2013-01-24 14:25:36 +0100693
694static int iwl_send_phy_cfg_cmd(struct iwl_mvm *mvm)
695{
696 struct iwl_phy_cfg_cmd phy_cfg_cmd;
697 enum iwl_ucode_type ucode_type = mvm->cur_ucode;
698
699 /* Set parameters */
Moshe Harela0544272014-12-08 21:13:14 +0200700 phy_cfg_cmd.phy_cfg = cpu_to_le32(iwl_mvm_get_phy_config(mvm));
Johannes Berg8ca151b2013-01-24 14:25:36 +0100701 phy_cfg_cmd.calib_control.event_trigger =
702 mvm->fw->default_calib[ucode_type].event_trigger;
703 phy_cfg_cmd.calib_control.flow_trigger =
704 mvm->fw->default_calib[ucode_type].flow_trigger;
705
706 IWL_DEBUG_INFO(mvm, "Sending Phy CFG command: 0x%x\n",
707 phy_cfg_cmd.phy_cfg);
708
Emmanuel Grumbacha1022922014-05-12 11:36:41 +0300709 return iwl_mvm_send_cmd_pdu(mvm, PHY_CONFIGURATION_CMD, 0,
Johannes Berg8ca151b2013-01-24 14:25:36 +0100710 sizeof(phy_cfg_cmd), &phy_cfg_cmd);
711}
712
Johannes Berg8ca151b2013-01-24 14:25:36 +0100713int iwl_run_init_mvm_ucode(struct iwl_mvm *mvm, bool read_nvm)
714{
715 struct iwl_notification_wait calib_wait;
Sara Sharon6eb031d2015-07-13 14:50:47 +0300716 static const u16 init_complete[] = {
Johannes Berg8ca151b2013-01-24 14:25:36 +0100717 INIT_COMPLETE_NOTIF,
718 CALIB_RES_NOTIF_PHY_DB
719 };
720 int ret;
721
722 lockdep_assert_held(&mvm->mutex);
723
Eran Harary8d193ca2015-04-27 10:29:31 +0300724 if (WARN_ON_ONCE(mvm->calibrating))
Johannes Berg8ca151b2013-01-24 14:25:36 +0100725 return 0;
726
727 iwl_init_notification_wait(&mvm->notif_wait,
728 &calib_wait,
729 init_complete,
730 ARRAY_SIZE(init_complete),
731 iwl_wait_phy_db_entry,
732 mvm->phy_db);
733
734 /* Will also start the device */
735 ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_INIT);
736 if (ret) {
737 IWL_ERR(mvm, "Failed to start INIT ucode: %d\n", ret);
738 goto error;
739 }
740
Emmanuel Grumbachae397472014-03-30 16:55:18 +0300741 ret = iwl_send_bt_init_conf(mvm);
Emmanuel Grumbach931d4162013-01-17 09:42:25 +0200742 if (ret)
743 goto error;
744
Eytan Lifshitz81a67e32013-09-11 12:39:18 +0200745 /* Read the NVM only at driver load time, no need to do this twice */
Johannes Berg8ca151b2013-01-24 14:25:36 +0100746 if (read_nvm) {
747 /* Read nvm */
Eran Harary14b485f2014-04-23 10:46:09 +0300748 ret = iwl_nvm_init(mvm, true);
Johannes Berg8ca151b2013-01-24 14:25:36 +0100749 if (ret) {
750 IWL_ERR(mvm, "Failed to read NVM: %d\n", ret);
751 goto error;
752 }
753 }
754
Eytan Lifshitz81a67e32013-09-11 12:39:18 +0200755 /* In case we read the NVM from external file, load it to the NIC */
Eran Hararye02a9d62014-05-07 12:27:10 +0300756 if (mvm->nvm_file_name)
Eytan Lifshitz81a67e32013-09-11 12:39:18 +0200757 iwl_mvm_load_nvm_to_nic(mvm);
758
Johannes Berg8ca151b2013-01-24 14:25:36 +0100759 ret = iwl_nvm_check_version(mvm->nvm_data, mvm->trans);
760 WARN_ON(ret);
761
Eran Harary4f593342013-05-13 07:53:26 +0300762 /*
763 * abort after reading the nvm in case RF Kill is on, we will complete
764 * the init seq later when RF kill will switch to off
765 */
Arik Nemtsov1a3fe0b2015-09-30 11:19:55 +0300766 if (iwl_mvm_is_radio_hw_killed(mvm)) {
Eran Harary4f593342013-05-13 07:53:26 +0300767 IWL_DEBUG_RF_KILL(mvm,
768 "jump over all phy activities due to RF kill\n");
769 iwl_remove_notification(&mvm->notif_wait, &calib_wait);
Arik Nemtsova4082842013-11-24 19:10:46 +0200770 ret = 1;
771 goto out;
Eran Harary4f593342013-05-13 07:53:26 +0300772 }
773
Emmanuel Grumbach31b8b342014-11-02 15:48:09 +0200774 mvm->calibrating = true;
775
Dor Shaishe07cbb52013-02-27 23:00:27 +0200776 /* Send TX valid antennas before triggering calibrations */
Moshe Harela0544272014-12-08 21:13:14 +0200777 ret = iwl_send_tx_ant_cfg(mvm, iwl_mvm_get_valid_tx_ant(mvm));
Dor Shaishe07cbb52013-02-27 23:00:27 +0200778 if (ret)
779 goto error;
780
Johannes Berg8ca151b2013-01-24 14:25:36 +0100781 /*
782 * Send phy configurations command to init uCode
783 * to start the 16.0 uCode init image internal calibrations.
784 */
785 ret = iwl_send_phy_cfg_cmd(mvm);
786 if (ret) {
787 IWL_ERR(mvm, "Failed to run INIT calibrations: %d\n",
788 ret);
789 goto error;
790 }
791
792 /*
793 * Some things may run in the background now, but we
794 * just wait for the calibration complete notification.
795 */
796 ret = iwl_wait_notification(&mvm->notif_wait, &calib_wait,
797 MVM_UCODE_CALIB_TIMEOUT);
Emmanuel Grumbach31b8b342014-11-02 15:48:09 +0200798
Arik Nemtsov1a3fe0b2015-09-30 11:19:55 +0300799 if (ret && iwl_mvm_is_radio_hw_killed(mvm)) {
Emmanuel Grumbach31b8b342014-11-02 15:48:09 +0200800 IWL_DEBUG_RF_KILL(mvm, "RFKILL while calibrating.\n");
801 ret = 1;
802 }
Johannes Berg8ca151b2013-01-24 14:25:36 +0100803 goto out;
804
805error:
806 iwl_remove_notification(&mvm->notif_wait, &calib_wait);
807out:
Emmanuel Grumbach31b8b342014-11-02 15:48:09 +0200808 mvm->calibrating = false;
Arik Nemtsova4082842013-11-24 19:10:46 +0200809 if (iwlmvm_mod_params.init_dbg && !mvm->nvm_data) {
Johannes Berg8ca151b2013-01-24 14:25:36 +0100810 /* we want to debug INIT and we have no NVM - fake */
811 mvm->nvm_data = kzalloc(sizeof(struct iwl_nvm_data) +
812 sizeof(struct ieee80211_channel) +
813 sizeof(struct ieee80211_rate),
814 GFP_KERNEL);
815 if (!mvm->nvm_data)
816 return -ENOMEM;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100817 mvm->nvm_data->bands[0].channels = mvm->nvm_data->channels;
818 mvm->nvm_data->bands[0].n_channels = 1;
819 mvm->nvm_data->bands[0].n_bitrates = 1;
820 mvm->nvm_data->bands[0].bitrates =
821 (void *)mvm->nvm_data->channels + 1;
822 mvm->nvm_data->bands[0].bitrates->hw_value = 10;
823 }
824
825 return ret;
826}
827
Sara Sharon1f370652016-08-31 18:13:57 +0300828int iwl_run_unified_mvm_ucode(struct iwl_mvm *mvm, bool read_nvm)
829{
830 struct iwl_notification_wait init_wait;
831 struct iwl_nvm_access_complete_cmd nvm_complete = {};
832 static const u16 init_complete[] = {
833 INIT_COMPLETE_NOTIF,
834 };
835 int ret;
836
837 lockdep_assert_held(&mvm->mutex);
838
839 iwl_init_notification_wait(&mvm->notif_wait,
840 &init_wait,
841 init_complete,
842 ARRAY_SIZE(init_complete),
843 iwl_wait_init_complete,
844 NULL);
845
846 /* Will also start the device */
847 ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_REGULAR);
848 if (ret) {
849 IWL_ERR(mvm, "Failed to start RT ucode: %d\n", ret);
850 goto error;
851 }
852
Sara Sharon1f370652016-08-31 18:13:57 +0300853 /* Read the NVM only at driver load time, no need to do this twice */
854 if (read_nvm) {
855 /* Read nvm */
856 ret = iwl_nvm_init(mvm, true);
857 if (ret) {
858 IWL_ERR(mvm, "Failed to read NVM: %d\n", ret);
859 goto error;
860 }
861 }
862
863 /* In case we read the NVM from external file, load it to the NIC */
864 if (mvm->nvm_file_name)
865 iwl_mvm_load_nvm_to_nic(mvm);
866
867 ret = iwl_nvm_check_version(mvm->nvm_data, mvm->trans);
868 if (WARN_ON(ret))
869 goto error;
870
871 ret = iwl_mvm_send_cmd_pdu(mvm, WIDE_ID(REGULATORY_AND_NVM_GROUP,
872 NVM_ACCESS_COMPLETE), 0,
873 sizeof(nvm_complete), &nvm_complete);
874 if (ret) {
875 IWL_ERR(mvm, "Failed to run complete NVM access: %d\n",
876 ret);
877 goto error;
878 }
879
880 /* We wait for the INIT complete notification */
881 return iwl_wait_notification(&mvm->notif_wait, &init_wait,
882 MVM_UCODE_ALIVE_TIMEOUT);
883
884error:
885 iwl_remove_notification(&mvm->notif_wait, &init_wait);
886 return ret;
887}
888
Sara Sharondb06f042016-07-05 17:37:58 +0300889static void iwl_mvm_parse_shared_mem_a000(struct iwl_mvm *mvm,
890 struct iwl_rx_packet *pkt)
891{
892 struct iwl_shared_mem_cfg *mem_cfg = (void *)pkt->data;
893 int i;
894
895 mvm->shared_mem_cfg.num_txfifo_entries =
896 ARRAY_SIZE(mvm->shared_mem_cfg.txfifo_size);
897 for (i = 0; i < ARRAY_SIZE(mem_cfg->txfifo_size); i++)
898 mvm->shared_mem_cfg.txfifo_size[i] =
899 le32_to_cpu(mem_cfg->txfifo_size[i]);
900 for (i = 0; i < ARRAY_SIZE(mvm->shared_mem_cfg.rxfifo_size); i++)
901 mvm->shared_mem_cfg.rxfifo_size[i] =
902 le32_to_cpu(mem_cfg->rxfifo_size[i]);
903
904 BUILD_BUG_ON(sizeof(mvm->shared_mem_cfg.internal_txfifo_size) !=
905 sizeof(mem_cfg->internal_txfifo_size));
906
907 for (i = 0; i < ARRAY_SIZE(mvm->shared_mem_cfg.internal_txfifo_size);
908 i++)
909 mvm->shared_mem_cfg.internal_txfifo_size[i] =
910 le32_to_cpu(mem_cfg->internal_txfifo_size[i]);
911}
912
913static void iwl_mvm_parse_shared_mem(struct iwl_mvm *mvm,
914 struct iwl_rx_packet *pkt)
915{
916 struct iwl_shared_mem_cfg_v1 *mem_cfg = (void *)pkt->data;
917 int i;
918
919 mvm->shared_mem_cfg.num_txfifo_entries =
920 ARRAY_SIZE(mvm->shared_mem_cfg.txfifo_size);
921 for (i = 0; i < ARRAY_SIZE(mem_cfg->txfifo_size); i++)
922 mvm->shared_mem_cfg.txfifo_size[i] =
923 le32_to_cpu(mem_cfg->txfifo_size[i]);
924 for (i = 0; i < ARRAY_SIZE(mvm->shared_mem_cfg.rxfifo_size); i++)
925 mvm->shared_mem_cfg.rxfifo_size[i] =
926 le32_to_cpu(mem_cfg->rxfifo_size[i]);
927
928 /* new API has more data, from rxfifo_addr field and on */
929 if (fw_has_capa(&mvm->fw->ucode_capa,
930 IWL_UCODE_TLV_CAPA_EXTEND_SHARED_MEM_CFG)) {
931 BUILD_BUG_ON(sizeof(mvm->shared_mem_cfg.internal_txfifo_size) !=
932 sizeof(mem_cfg->internal_txfifo_size));
933
934 for (i = 0;
935 i < ARRAY_SIZE(mvm->shared_mem_cfg.internal_txfifo_size);
936 i++)
937 mvm->shared_mem_cfg.internal_txfifo_size[i] =
938 le32_to_cpu(mem_cfg->internal_txfifo_size[i]);
939 }
940}
941
Liad Kaufman04fd2c22014-12-15 17:54:16 +0200942static void iwl_mvm_get_shared_mem_conf(struct iwl_mvm *mvm)
943{
944 struct iwl_host_cmd cmd = {
Liad Kaufman04fd2c22014-12-15 17:54:16 +0200945 .flags = CMD_WANT_SKB,
946 .data = { NULL, },
947 .len = { 0, },
948 };
Golan Ben-Ami5b086412016-02-09 12:57:16 +0200949 struct iwl_rx_packet *pkt;
Liad Kaufman04fd2c22014-12-15 17:54:16 +0200950
951 lockdep_assert_held(&mvm->mutex);
952
Golan Ben-Ami5b086412016-02-09 12:57:16 +0200953 if (fw_has_capa(&mvm->fw->ucode_capa,
954 IWL_UCODE_TLV_CAPA_EXTEND_SHARED_MEM_CFG))
955 cmd.id = iwl_cmd_id(SHARED_MEM_CFG_CMD, SYSTEM_GROUP, 0);
956 else
957 cmd.id = SHARED_MEM_CFG;
958
Liad Kaufman04fd2c22014-12-15 17:54:16 +0200959 if (WARN_ON(iwl_mvm_send_cmd(mvm, &cmd)))
960 return;
961
962 pkt = cmd.resp_pkt;
Sara Sharondb06f042016-07-05 17:37:58 +0300963 if (iwl_mvm_has_new_tx_api(mvm))
964 iwl_mvm_parse_shared_mem_a000(mvm, pkt);
965 else
966 iwl_mvm_parse_shared_mem(mvm, pkt);
Golan Ben-Ami5b086412016-02-09 12:57:16 +0200967
Liad Kaufman04fd2c22014-12-15 17:54:16 +0200968 IWL_DEBUG_INFO(mvm, "SHARED MEM CFG: got memory offsets/sizes\n");
969
Liad Kaufman04fd2c22014-12-15 17:54:16 +0200970 iwl_free_resp(&cmd);
971}
972
Emmanuel Grumbach84bfffa2015-01-13 10:16:30 +0200973static int iwl_mvm_config_ltr(struct iwl_mvm *mvm)
974{
975 struct iwl_ltr_config_cmd cmd = {
976 .flags = cpu_to_le32(LTR_CFG_FLAG_FEATURE_ENABLE),
977 };
978
979 if (!mvm->trans->ltr_enabled)
980 return 0;
981
Emmanuel Grumbach84bfffa2015-01-13 10:16:30 +0200982 return iwl_mvm_send_cmd_pdu(mvm, LTR_CONFIG, 0,
983 sizeof(cmd), &cmd);
984}
985
Luca Coelhoda2830a2016-05-30 13:00:44 +0300986#define ACPI_WRDS_METHOD "WRDS"
987#define ACPI_WRDS_WIFI (0x07)
988#define ACPI_WRDS_TABLE_SIZE 10
989
990struct iwl_mvm_sar_table {
991 bool enabled;
992 u8 values[ACPI_WRDS_TABLE_SIZE];
993};
994
995#ifdef CONFIG_ACPI
996static int iwl_mvm_sar_get_wrds(struct iwl_mvm *mvm, union acpi_object *wrds,
997 struct iwl_mvm_sar_table *sar_table)
998{
999 union acpi_object *data_pkg;
1000 u32 i;
1001
1002 /* We need at least two packages, one for the revision and one
1003 * for the data itself. Also check that the revision is valid
1004 * (i.e. it is an integer set to 0).
1005 */
1006 if (wrds->type != ACPI_TYPE_PACKAGE ||
1007 wrds->package.count < 2 ||
1008 wrds->package.elements[0].type != ACPI_TYPE_INTEGER ||
1009 wrds->package.elements[0].integer.value != 0) {
1010 IWL_DEBUG_RADIO(mvm, "Unsupported wrds structure\n");
1011 return -EINVAL;
1012 }
1013
1014 /* loop through all the packages to find the one for WiFi */
1015 for (i = 1; i < wrds->package.count; i++) {
1016 union acpi_object *domain;
1017
1018 data_pkg = &wrds->package.elements[i];
1019
1020 /* Skip anything that is not a package with the right
1021 * amount of elements (i.e. domain_type,
1022 * enabled/disabled plus the sar table size.
1023 */
1024 if (data_pkg->type != ACPI_TYPE_PACKAGE ||
1025 data_pkg->package.count != ACPI_WRDS_TABLE_SIZE + 2)
1026 continue;
1027
1028 domain = &data_pkg->package.elements[0];
1029 if (domain->type == ACPI_TYPE_INTEGER &&
1030 domain->integer.value == ACPI_WRDS_WIFI)
1031 break;
1032
1033 data_pkg = NULL;
1034 }
1035
1036 if (!data_pkg)
1037 return -ENOENT;
1038
1039 if (data_pkg->package.elements[1].type != ACPI_TYPE_INTEGER)
1040 return -EINVAL;
1041
1042 sar_table->enabled = !!(data_pkg->package.elements[1].integer.value);
1043
1044 for (i = 0; i < ACPI_WRDS_TABLE_SIZE; i++) {
1045 union acpi_object *entry;
1046
1047 entry = &data_pkg->package.elements[i + 2];
1048 if ((entry->type != ACPI_TYPE_INTEGER) ||
1049 (entry->integer.value > U8_MAX))
1050 return -EINVAL;
1051
1052 sar_table->values[i] = entry->integer.value;
1053 }
1054
1055 return 0;
1056}
1057
1058static int iwl_mvm_sar_get_table(struct iwl_mvm *mvm,
1059 struct iwl_mvm_sar_table *sar_table)
1060{
1061 acpi_handle root_handle;
1062 acpi_handle handle;
1063 struct acpi_buffer wrds = {ACPI_ALLOCATE_BUFFER, NULL};
1064 acpi_status status;
1065 int ret;
1066
1067 root_handle = ACPI_HANDLE(mvm->dev);
1068 if (!root_handle) {
1069 IWL_DEBUG_RADIO(mvm,
1070 "Could not retrieve root port ACPI handle\n");
1071 return -ENOENT;
1072 }
1073
1074 /* Get the method's handle */
1075 status = acpi_get_handle(root_handle, (acpi_string)ACPI_WRDS_METHOD,
1076 &handle);
1077 if (ACPI_FAILURE(status)) {
1078 IWL_DEBUG_RADIO(mvm, "WRDS method not found\n");
1079 return -ENOENT;
1080 }
1081
1082 /* Call WRDS with no arguments */
1083 status = acpi_evaluate_object(handle, NULL, NULL, &wrds);
1084 if (ACPI_FAILURE(status)) {
1085 IWL_DEBUG_RADIO(mvm, "WRDS invocation failed (0x%x)\n", status);
1086 return -ENOENT;
1087 }
1088
1089 ret = iwl_mvm_sar_get_wrds(mvm, wrds.pointer, sar_table);
1090 kfree(wrds.pointer);
1091
1092 return ret;
1093}
1094#else /* CONFIG_ACPI */
1095static int iwl_mvm_sar_get_table(struct iwl_mvm *mvm,
1096 struct iwl_mvm_sar_table *sar_table)
1097{
1098 return -ENOENT;
1099}
1100#endif /* CONFIG_ACPI */
1101
1102static int iwl_mvm_sar_init(struct iwl_mvm *mvm)
1103{
1104 struct iwl_mvm_sar_table sar_table;
1105 struct iwl_dev_tx_power_cmd cmd = {
Luca Coelho4b87e5a2016-09-12 16:03:30 +03001106 .v3.set_mode = cpu_to_le32(IWL_TX_POWER_MODE_SET_CHAINS),
Luca Coelhoda2830a2016-05-30 13:00:44 +03001107 };
1108 int ret, i, j, idx;
Luca Coelho55bfa4b2016-06-29 00:38:40 +03001109 int len = sizeof(cmd);
Luca Coelhoda2830a2016-05-30 13:00:44 +03001110
Luca Coelho55bfa4b2016-06-29 00:38:40 +03001111 if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TX_POWER_ACK))
1112 len = sizeof(cmd.v3);
1113
Luca Coelhoda2830a2016-05-30 13:00:44 +03001114 ret = iwl_mvm_sar_get_table(mvm, &sar_table);
1115 if (ret < 0) {
1116 IWL_DEBUG_RADIO(mvm,
1117 "SAR BIOS table invalid or unavailable. (%d)\n",
1118 ret);
1119 /* we don't fail if the table is not available */
1120 return 0;
1121 }
1122
1123 if (!sar_table.enabled)
1124 return 0;
1125
1126 IWL_DEBUG_RADIO(mvm, "Sending REDUCE_TX_POWER_CMD per chain\n");
1127
1128 BUILD_BUG_ON(IWL_NUM_CHAIN_LIMITS * IWL_NUM_SUB_BANDS !=
1129 ACPI_WRDS_TABLE_SIZE);
1130
1131 for (i = 0; i < IWL_NUM_CHAIN_LIMITS; i++) {
1132 IWL_DEBUG_RADIO(mvm, " Chain[%d]:\n", i);
1133 for (j = 0; j < IWL_NUM_SUB_BANDS; j++) {
1134 idx = (i * IWL_NUM_SUB_BANDS) + j;
Luca Coelho55bfa4b2016-06-29 00:38:40 +03001135 cmd.v3.per_chain_restriction[i][j] =
Luca Coelhoda2830a2016-05-30 13:00:44 +03001136 cpu_to_le16(sar_table.values[idx]);
1137 IWL_DEBUG_RADIO(mvm, " Band[%d] = %d * .125dBm\n",
1138 j, sar_table.values[idx]);
1139 }
1140 }
1141
Luca Coelho55bfa4b2016-06-29 00:38:40 +03001142 ret = iwl_mvm_send_cmd_pdu(mvm, REDUCE_TX_POWER_CMD, 0, len, &cmd);
Luca Coelhoda2830a2016-05-30 13:00:44 +03001143 if (ret)
1144 IWL_ERR(mvm, "failed to set per-chain TX power: %d\n", ret);
1145
1146 return ret;
1147}
1148
Sara Sharon1f370652016-08-31 18:13:57 +03001149static int iwl_mvm_load_rt_fw(struct iwl_mvm *mvm)
1150{
1151 int ret;
1152
1153 if (iwl_mvm_has_new_tx_api(mvm))
1154 return iwl_run_unified_mvm_ucode(mvm, false);
1155
1156 ret = iwl_run_init_mvm_ucode(mvm, false);
1157
1158 if (iwlmvm_mod_params.init_dbg)
1159 return 0;
1160
1161 if (ret) {
1162 IWL_ERR(mvm, "Failed to run INIT ucode: %d\n", ret);
1163 /* this can't happen */
1164 if (WARN_ON(ret > 0))
1165 ret = -ERFKILL;
1166 return ret;
1167 }
1168
1169 /*
1170 * Stop and start the transport without entering low power
1171 * mode. This will save the state of other components on the
1172 * device that are triggered by the INIT firwmare (MFUART).
1173 */
1174 _iwl_trans_stop_device(mvm->trans, false);
1175 ret = _iwl_trans_start_hw(mvm->trans, false);
1176 if (ret)
1177 return ret;
1178
1179 ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_REGULAR);
1180 if (ret)
1181 return ret;
1182
1183 return iwl_mvm_init_paging(mvm);
1184}
1185
Johannes Berg8ca151b2013-01-24 14:25:36 +01001186int iwl_mvm_up(struct iwl_mvm *mvm)
1187{
1188 int ret, i;
Ilan Peer53a9d612013-04-28 11:55:08 +03001189 struct ieee80211_channel *chan;
1190 struct cfg80211_chan_def chandef;
Johannes Berg8ca151b2013-01-24 14:25:36 +01001191
1192 lockdep_assert_held(&mvm->mutex);
1193
1194 ret = iwl_trans_start_hw(mvm->trans);
1195 if (ret)
1196 return ret;
1197
Sara Sharon1f370652016-08-31 18:13:57 +03001198 ret = iwl_mvm_load_rt_fw(mvm);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001199 if (ret) {
1200 IWL_ERR(mvm, "Failed to start RT ucode: %d\n", ret);
1201 goto error;
1202 }
1203
Sara Sharon6c7d32c2015-06-07 09:34:57 +03001204 iwl_mvm_get_shared_mem_conf(mvm);
Liad Kaufman04fd2c22014-12-15 17:54:16 +02001205
Lilach Edelstein1f3b0ff2013-10-06 13:03:32 +02001206 ret = iwl_mvm_sf_update(mvm, NULL, false);
1207 if (ret)
1208 IWL_ERR(mvm, "Failed to initialize Smart Fifo\n");
1209
Liad Kaufman6a951262014-11-17 11:36:21 +02001210 mvm->fw_dbg_conf = FW_DBG_INVALID;
Emmanuel Grumbach945d4202015-02-15 17:16:16 +02001211 /* if we have a destination, assume EARLY START */
1212 if (mvm->fw->dbg_dest_tlv)
1213 mvm->fw_dbg_conf = FW_DBG_START_FROM_ALIVE;
Emmanuel Grumbachd2709ad2015-01-29 14:58:06 +02001214 iwl_mvm_start_fw_dbg_conf(mvm, FW_DBG_START_FROM_ALIVE);
Liad Kaufman6a951262014-11-17 11:36:21 +02001215
Moshe Harela0544272014-12-08 21:13:14 +02001216 ret = iwl_send_tx_ant_cfg(mvm, iwl_mvm_get_valid_tx_ant(mvm));
Johannes Berg8ca151b2013-01-24 14:25:36 +01001217 if (ret)
1218 goto error;
1219
Emmanuel Grumbach931d4162013-01-17 09:42:25 +02001220 ret = iwl_send_bt_init_conf(mvm);
1221 if (ret)
1222 goto error;
1223
Johannes Berg8ca151b2013-01-24 14:25:36 +01001224 /* Send phy db control command and then phy db calibration*/
Sara Sharon1f370652016-08-31 18:13:57 +03001225 if (!iwl_mvm_has_new_tx_api(mvm)) {
1226 ret = iwl_send_phy_db_data(mvm->phy_db);
1227 if (ret)
1228 goto error;
Johannes Berg8ca151b2013-01-24 14:25:36 +01001229
Sara Sharon1f370652016-08-31 18:13:57 +03001230 ret = iwl_send_phy_cfg_cmd(mvm);
1231 if (ret)
1232 goto error;
1233 }
Johannes Berg8ca151b2013-01-24 14:25:36 +01001234
Sara Sharon43413a92015-12-31 11:49:18 +02001235 /* Init RSS configuration */
1236 if (iwl_mvm_has_new_rx_api(mvm)) {
1237 ret = iwl_send_rss_cfg_cmd(mvm);
1238 if (ret) {
1239 IWL_ERR(mvm, "Failed to configure RSS queues: %d\n",
1240 ret);
1241 goto error;
1242 }
1243 }
1244
Johannes Berg8ca151b2013-01-24 14:25:36 +01001245 /* init the fw <-> mac80211 STA mapping */
1246 for (i = 0; i < IWL_MVM_STATION_COUNT; i++)
1247 RCU_INIT_POINTER(mvm->fw_id_to_mac_id[i], NULL);
1248
Arik Nemtsov1d3c3f62014-10-23 18:03:10 +03001249 mvm->tdls_cs.peer.sta_id = IWL_MVM_STATION_COUNT;
1250
Johannes Bergb2b78752014-09-08 16:42:54 +02001251 /* reset quota debouncing buffer - 0xff will yield invalid data */
1252 memset(&mvm->last_quota_cmd, 0xff, sizeof(mvm->last_quota_cmd));
1253
Liad Kaufman97d5be72015-08-31 14:33:23 +03001254 /* Enable DQA-mode if required */
1255 if (iwl_mvm_is_dqa_supported(mvm)) {
1256 ret = iwl_mvm_send_dqa_cmd(mvm);
1257 if (ret)
1258 goto error;
1259 } else {
1260 IWL_DEBUG_FW(mvm, "Working in non-DQA mode\n");
1261 }
1262
Johannes Berg8ca151b2013-01-24 14:25:36 +01001263 /* Add auxiliary station for scanning */
1264 ret = iwl_mvm_add_aux_sta(mvm);
1265 if (ret)
1266 goto error;
1267
Ilan Peer53a9d612013-04-28 11:55:08 +03001268 /* Add all the PHY contexts */
Johannes Berg57fbcce2016-04-12 15:56:15 +02001269 chan = &mvm->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels[0];
Ilan Peer53a9d612013-04-28 11:55:08 +03001270 cfg80211_chandef_create(&chandef, chan, NL80211_CHAN_NO_HT);
1271 for (i = 0; i < NUM_PHY_CTX; i++) {
1272 /*
1273 * The channel used here isn't relevant as it's
1274 * going to be overwritten in the other flows.
1275 * For now use the first channel we have.
1276 */
1277 ret = iwl_mvm_phy_ctxt_add(mvm, &mvm->phy_ctxts[i],
1278 &chandef, 1, 1);
1279 if (ret)
1280 goto error;
1281 }
Johannes Berg8ca151b2013-01-24 14:25:36 +01001282
Chaya Rachel Ivgic221daf2015-12-29 09:54:49 +02001283#ifdef CONFIG_THERMAL
1284 if (iwl_mvm_is_tt_in_fw(mvm)) {
1285 /* in order to give the responsibility of ct-kill and
1286 * TX backoff to FW we need to send empty temperature reporting
1287 * cmd during init time
1288 */
1289 iwl_mvm_send_temp_report_ths_cmd(mvm);
1290 } else {
1291 /* Initialize tx backoffs to the minimal possible */
1292 iwl_mvm_tt_tx_backoff(mvm, 0);
1293 }
Chaya Rachel Ivgi5c89e7b2016-01-05 10:34:47 +02001294
1295 /* TODO: read the budget from BIOS / Platform NVM */
Luca Coelho75cfe332016-09-14 11:54:36 +03001296 if (iwl_mvm_is_ctdp_supported(mvm) && mvm->cooling_dev.cur_state > 0) {
Chaya Rachel Ivgi5c89e7b2016-01-05 10:34:47 +02001297 ret = iwl_mvm_ctdp_command(mvm, CTDP_CMD_OPERATION_START,
1298 mvm->cooling_dev.cur_state);
Luca Coelho75cfe332016-09-14 11:54:36 +03001299 if (ret)
1300 goto error;
1301 }
Chaya Rachel Ivgic221daf2015-12-29 09:54:49 +02001302#else
Ido Yariv0c0e2c72014-01-16 21:12:02 -05001303 /* Initialize tx backoffs to the minimal possible */
1304 iwl_mvm_tt_tx_backoff(mvm, 0);
Chaya Rachel Ivgic221daf2015-12-29 09:54:49 +02001305#endif
Ido Yariv0c0e2c72014-01-16 21:12:02 -05001306
Emmanuel Grumbach84bfffa2015-01-13 10:16:30 +02001307 WARN_ON(iwl_mvm_config_ltr(mvm));
Emmanuel Grumbach9180ac52014-09-23 23:02:41 +03001308
Emmanuel Grumbachc1cb92f2014-01-28 10:17:18 +02001309 ret = iwl_mvm_power_update_device(mvm);
Alexander Bondar64b928c2013-09-03 14:18:03 +03001310 if (ret)
1311 goto error;
1312
Arik Nemtsov35af15d2015-03-04 15:08:00 +02001313 /*
1314 * RTNL is not taken during Ct-kill, but we don't need to scan/Tx
1315 * anyway, so don't init MCC.
1316 */
1317 if (!test_bit(IWL_MVM_STATUS_HW_CTKILL, &mvm->status)) {
1318 ret = iwl_mvm_init_mcc(mvm);
1319 if (ret)
1320 goto error;
1321 }
Arik Nemtsov90d4f7d2014-03-04 19:58:46 +02001322
Johannes Berg859d9142015-06-01 17:11:11 +02001323 if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
Emmanuel Grumbach4ca87a52016-01-03 22:23:40 +02001324 mvm->scan_type = IWL_SCAN_TYPE_NOT_SET;
David Spinadeld2496222014-05-20 12:46:37 +03001325 ret = iwl_mvm_config_scan(mvm);
1326 if (ret)
1327 goto error;
1328 }
1329
Avri Altman93190fb2014-12-27 09:09:47 +02001330 if (iwl_mvm_is_csum_supported(mvm) &&
1331 mvm->cfg->features & NETIF_F_RXCSUM)
1332 iwl_trans_write_prph(mvm->trans, RX_EN_CSUM, 0x3);
1333
Eliad Peller7498cf42014-01-16 17:10:44 +02001334 /* allow FW/transport low power modes if not during restart */
1335 if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
1336 iwl_mvm_unref(mvm, IWL_MVM_REF_UCODE_DOWN);
1337
Luca Coelhoda2830a2016-05-30 13:00:44 +03001338 ret = iwl_mvm_sar_init(mvm);
1339 if (ret)
1340 goto error;
1341
Ilan Peer53a9d612013-04-28 11:55:08 +03001342 IWL_DEBUG_INFO(mvm, "RT uCode started.\n");
Johannes Berg8ca151b2013-01-24 14:25:36 +01001343 return 0;
1344 error:
Chaya Rachel Ivgifcb6b922016-02-22 10:21:41 +02001345 iwl_mvm_stop_device(mvm);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001346 return ret;
1347}
1348
1349int iwl_mvm_load_d3_fw(struct iwl_mvm *mvm)
1350{
1351 int ret, i;
1352
1353 lockdep_assert_held(&mvm->mutex);
1354
1355 ret = iwl_trans_start_hw(mvm->trans);
1356 if (ret)
1357 return ret;
1358
1359 ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_WOWLAN);
1360 if (ret) {
1361 IWL_ERR(mvm, "Failed to start WoWLAN firmware: %d\n", ret);
1362 goto error;
1363 }
1364
Moshe Harela0544272014-12-08 21:13:14 +02001365 ret = iwl_send_tx_ant_cfg(mvm, iwl_mvm_get_valid_tx_ant(mvm));
Johannes Berg8ca151b2013-01-24 14:25:36 +01001366 if (ret)
1367 goto error;
1368
1369 /* Send phy db control command and then phy db calibration*/
1370 ret = iwl_send_phy_db_data(mvm->phy_db);
1371 if (ret)
1372 goto error;
1373
1374 ret = iwl_send_phy_cfg_cmd(mvm);
1375 if (ret)
1376 goto error;
1377
1378 /* init the fw <-> mac80211 STA mapping */
1379 for (i = 0; i < IWL_MVM_STATION_COUNT; i++)
1380 RCU_INIT_POINTER(mvm->fw_id_to_mac_id[i], NULL);
1381
1382 /* Add auxiliary station for scanning */
1383 ret = iwl_mvm_add_aux_sta(mvm);
1384 if (ret)
1385 goto error;
1386
1387 return 0;
1388 error:
Chaya Rachel Ivgifcb6b922016-02-22 10:21:41 +02001389 iwl_mvm_stop_device(mvm);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001390 return ret;
1391}
1392
Johannes Berg04168412015-06-23 21:22:09 +02001393void iwl_mvm_rx_card_state_notif(struct iwl_mvm *mvm,
1394 struct iwl_rx_cmd_buffer *rxb)
Johannes Berg8ca151b2013-01-24 14:25:36 +01001395{
1396 struct iwl_rx_packet *pkt = rxb_addr(rxb);
1397 struct iwl_card_state_notif *card_state_notif = (void *)pkt->data;
1398 u32 flags = le32_to_cpu(card_state_notif->flags);
1399
1400 IWL_DEBUG_RF_KILL(mvm, "Card state received: HW:%s SW:%s CT:%s\n",
1401 (flags & HW_CARD_DISABLED) ? "Kill" : "On",
1402 (flags & SW_CARD_DISABLED) ? "Kill" : "On",
1403 (flags & CT_KILL_CARD_DISABLED) ?
1404 "Reached" : "Not reached");
Johannes Berg8ca151b2013-01-24 14:25:36 +01001405}
1406
Johannes Berg04168412015-06-23 21:22:09 +02001407void iwl_mvm_rx_mfuart_notif(struct iwl_mvm *mvm,
1408 struct iwl_rx_cmd_buffer *rxb)
Chaya Rachel Ivgy30269c12014-11-15 21:08:29 +02001409{
1410 struct iwl_rx_packet *pkt = rxb_addr(rxb);
1411 struct iwl_mfuart_load_notif *mfuart_notif = (void *)pkt->data;
1412
Golan Ben-Ami0c8d0a42017-01-25 15:11:30 +02001413 IWL_DEBUG_INFO(mvm,
1414 "MFUART: installed ver: 0x%08x, external ver: 0x%08x, status: 0x%08x, duration: 0x%08x\n",
1415 le32_to_cpu(mfuart_notif->installed_ver),
1416 le32_to_cpu(mfuart_notif->external_ver),
1417 le32_to_cpu(mfuart_notif->status),
1418 le32_to_cpu(mfuart_notif->duration));
1419
Golan Ben-Ami19f63c52016-11-07 17:40:43 +02001420 if (iwl_rx_packet_payload_len(pkt) == sizeof(*mfuart_notif))
1421 IWL_DEBUG_INFO(mvm,
Golan Ben-Ami0c8d0a42017-01-25 15:11:30 +02001422 "MFUART: image size: 0x%08x\n",
Golan Ben-Ami19f63c52016-11-07 17:40:43 +02001423 le32_to_cpu(mfuart_notif->image_size));
Chaya Rachel Ivgy30269c12014-11-15 21:08:29 +02001424}