1 /******************************************************************************
2  *
3  * This file is provided under a dual BSD/GPLv2 license.  When using or
4  * redistributing this file, you may do so under either license.
5  *
6  * GPL LICENSE SUMMARY
7  *
8  * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
9  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
10  * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
11  *
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  * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
38  * 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>
68 #include <linux/netdevice.h>
69 #include <linux/acpi.h>
70 
71 #include "iwl-trans.h"
72 #include "iwl-op-mode.h"
73 #include "fw/img.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 */
77 #include "iwl-prph.h"
78 #include "iwl-eeprom-parse.h"
79 
80 #include "mvm.h"
81 #include "fw-dbg.h"
82 #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 
89 struct iwl_mvm_alive_data {
90 	bool valid;
91 	u32 scd_base_addr;
92 };
93 
94 static 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 
100 	IWL_DEBUG_FW(mvm, "select valid tx ant: %u\n", valid_tx_ant);
101 	return iwl_mvm_send_cmd_pdu(mvm, TX_ANT_CONFIGURATION_CMD, 0,
102 				    sizeof(tx_ant_cmd), &tx_ant_cmd);
103 }
104 
105 static 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 |
111 			     IWL_RSS_HASH_TYPE_IPV4_UDP |
112 			     IWL_RSS_HASH_TYPE_IPV4_PAYLOAD |
113 			     IWL_RSS_HASH_TYPE_IPV6_TCP |
114 			     IWL_RSS_HASH_TYPE_IPV6_UDP |
115 			     IWL_RSS_HASH_TYPE_IPV6_PAYLOAD,
116 	};
117 
118 	if (mvm->trans->num_rx_queues == 1)
119 		return 0;
120 
121 	/* Do not direct RSS traffic to Q 0 which is our fallback queue */
122 	for (i = 0; i < ARRAY_SIZE(cmd.indirection_table); i++)
123 		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));
126 
127 	return iwl_mvm_send_cmd_pdu(mvm, RSS_CONFIG_CMD, 0, sizeof(cmd), &cmd);
128 }
129 
130 static 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 
147 void iwl_free_fw_paging(struct iwl_mvm *mvm)
148 {
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++) {
155 		struct iwl_fw_paging *paging = &mvm->fw_paging_db[i];
156 
157 		if (!paging->fw_paging_block) {
158 			IWL_DEBUG_FW(mvm,
159 				     "Paging: block %d already freed, continue to next page\n",
160 				     i);
161 
162 			continue;
163 		}
164 		dma_unmap_page(mvm->trans->dev, paging->fw_paging_phys,
165 			       paging->fw_paging_size, DMA_BIDIRECTIONAL);
166 
167 		__free_pages(paging->fw_paging_block,
168 			     get_order(paging->fw_paging_size));
169 		paging->fw_paging_block = NULL;
170 	}
171 	kfree(mvm->trans->paging_download_buf);
172 	mvm->trans->paging_download_buf = NULL;
173 	mvm->trans->paging_db = NULL;
174 
175 	memset(mvm->fw_paging_db, 0, sizeof(mvm->fw_paging_db));
176 }
177 
178 static 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 	 */
194 	for (sec_idx = 0; sec_idx < image->num_sec; sec_idx++) {
195 		if (image->sec[sec_idx].offset == PAGING_SEPARATOR_SECTION) {
196 			sec_idx++;
197 			break;
198 		}
199 	}
200 
201 	/*
202 	 * If paging is enabled there should be at least 2 more sections left
203 	 * (one for CSS and one for Paging data)
204 	 */
205 	if (sec_idx >= image->num_sec - 1) {
206 		IWL_ERR(mvm, "Paging: Missing CSS and/or paging sections\n");
207 		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);
218 	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);
222 
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++) {
236 		struct iwl_fw_paging *block = &mvm->fw_paging_db[idx];
237 
238 		memcpy(page_address(block->fw_paging_block),
239 		       image->sec[sec_idx].data + offset,
240 		       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 
246 
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) {
257 		struct iwl_fw_paging *block = &mvm->fw_paging_db[idx];
258 
259 		memcpy(page_address(block->fw_paging_block),
260 		       image->sec[sec_idx].data + offset,
261 		       FW_PAGING_SIZE * mvm->num_of_pages_in_last_blk);
262 		dma_sync_single_for_device(mvm->trans->dev,
263 					   block->fw_paging_phys,
264 					   block->fw_paging_size,
265 					   DMA_BIDIRECTIONAL);
266 
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 
275 void 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 
296 static 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;
301 	int blk_idx, order, num_of_pages, size, dma_enabled;
302 
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;
312 	mvm->num_of_paging_blk =
313 		DIV_ROUND_UP(num_of_pages, NUM_OF_PAGE_PER_GROUP);
314 	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 
323 	/*
324 	 * Allocate CSS and paging blocks in dram.
325 	 */
326 	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);
330 		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;
338 		mvm->fw_paging_db[blk_idx].fw_paging_size = size;
339 
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;
353 		} else {
354 			mvm->fw_paging_db[blk_idx].fw_paging_phys =
355 				PAGING_ADDR_SIG |
356 				blk_idx << BLOCK_2_EXP_SIZE;
357 		}
358 
359 		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);
367 	}
368 
369 	return 0;
370 }
371 
372 static 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 */
385 static int iwl_send_paging_cmd(struct iwl_mvm *mvm, const struct fw_img *fw)
386 {
387 	struct iwl_fw_paging_cmd paging_cmd = {
388 		.flags = cpu_to_le32(PAGING_CMD_IS_SECURED |
389 				     PAGING_CMD_IS_ENABLED |
390 				     (mvm->num_of_pages_in_last_blk <<
391 				      PAGING_CMD_NUM_OF_PAGES_IN_LAST_GRP_POS)),
392 		.block_size = cpu_to_le32(BLOCK_2_EXP_SIZE),
393 		.block_num = cpu_to_le32(mvm->num_of_paging_blk),
394 	};
395 	int blk_idx;
396 
397 	/* loop for for all paging blocks + CSS block */
398 	for (blk_idx = 0; blk_idx < mvm->num_of_paging_blk + 1; blk_idx++) {
399 		dma_addr_t addr = mvm->fw_paging_db[blk_idx].fw_paging_phys;
400 		__le32 phy_addr;
401 
402 		addr = addr >> PAGE_2_EXP_SIZE;
403 		phy_addr = cpu_to_le32(addr);
404 		paging_cmd.device_phy_addr[blk_idx] = phy_addr;
405 	}
406 
407 	return iwl_mvm_send_cmd_pdu(mvm, iwl_cmd_id(FW_PAGING_BLOCK_CMD,
408 						    IWL_ALWAYS_LONG_GROUP, 0),
409 				    0, sizeof(paging_cmd), &paging_cmd);
410 }
411 
412 /*
413  * Send paging item cmd to FW in case CPU2 has paging image
414  */
415 static int iwl_trans_get_paging_item(struct iwl_mvm *mvm)
416 {
417 	int ret;
418 	struct iwl_fw_get_item_cmd fw_get_item_cmd = {
419 		.item_id = cpu_to_le32(IWL_FW_ITEM_ID_PAGING),
420 	};
421 
422 	struct iwl_fw_get_item_resp *item_resp;
423 	struct iwl_host_cmd cmd = {
424 		.id = iwl_cmd_id(FW_GET_ITEM_CMD, IWL_ALWAYS_LONG_GROUP, 0),
425 		.flags = CMD_WANT_SKB | CMD_SEND_IN_RFKILL,
426 		.data = { &fw_get_item_cmd, },
427 	};
428 
429 	cmd.len[0] = sizeof(struct iwl_fw_get_item_cmd);
430 
431 	ret = iwl_mvm_send_cmd(mvm, &cmd);
432 	if (ret) {
433 		IWL_ERR(mvm,
434 			"Paging: Failed to send FW_GET_ITEM_CMD cmd (err = %d)\n",
435 			ret);
436 		return ret;
437 	}
438 
439 	item_resp = (void *)((struct iwl_rx_packet *)cmd.resp_pkt)->data;
440 	if (item_resp->item_id != cpu_to_le32(IWL_FW_ITEM_ID_PAGING)) {
441 		IWL_ERR(mvm,
442 			"Paging: got wrong item in FW_GET_ITEM_CMD resp (item_id = %u)\n",
443 			le32_to_cpu(item_resp->item_id));
444 		ret = -EIO;
445 		goto exit;
446 	}
447 
448 	/* Add an extra page for headers */
449 	mvm->trans->paging_download_buf = kzalloc(PAGING_BLOCK_SIZE +
450 						  FW_PAGING_SIZE,
451 						  GFP_KERNEL);
452 	if (!mvm->trans->paging_download_buf) {
453 		ret = -ENOMEM;
454 		goto exit;
455 	}
456 	mvm->trans->paging_req_addr = le32_to_cpu(item_resp->item_val);
457 	mvm->trans->paging_db = mvm->fw_paging_db;
458 	IWL_DEBUG_FW(mvm,
459 		     "Paging: got paging request address (paging_req_addr 0x%08x)\n",
460 		     mvm->trans->paging_req_addr);
461 
462 exit:
463 	iwl_free_resp(&cmd);
464 
465 	return ret;
466 }
467 
468 static bool iwl_alive_fn(struct iwl_notif_wait_data *notif_wait,
469 			 struct iwl_rx_packet *pkt, void *data)
470 {
471 	struct iwl_mvm *mvm =
472 		container_of(notif_wait, struct iwl_mvm, notif_wait);
473 	struct iwl_mvm_alive_data *alive_data = data;
474 	struct mvm_alive_resp_v3 *palive3;
475 	struct mvm_alive_resp *palive;
476 	struct iwl_umac_alive *umac;
477 	struct iwl_lmac_alive *lmac1;
478 	struct iwl_lmac_alive *lmac2 = NULL;
479 	u16 status;
480 
481 	if (iwl_rx_packet_payload_len(pkt) == sizeof(*palive)) {
482 		palive = (void *)pkt->data;
483 		umac = &palive->umac_data;
484 		lmac1 = &palive->lmac_data[0];
485 		lmac2 = &palive->lmac_data[1];
486 		status = le16_to_cpu(palive->status);
487 	} else {
488 		palive3 = (void *)pkt->data;
489 		umac = &palive3->umac_data;
490 		lmac1 = &palive3->lmac_data;
491 		status = le16_to_cpu(palive3->status);
492 	}
493 
494 	mvm->error_event_table[0] = le32_to_cpu(lmac1->error_event_table_ptr);
495 	if (lmac2)
496 		mvm->error_event_table[1] =
497 			le32_to_cpu(lmac2->error_event_table_ptr);
498 	mvm->log_event_table = le32_to_cpu(lmac1->log_event_table_ptr);
499 	mvm->sf_space.addr = le32_to_cpu(lmac1->st_fwrd_addr);
500 	mvm->sf_space.size = le32_to_cpu(lmac1->st_fwrd_size);
501 
502 	mvm->umac_error_event_table = le32_to_cpu(umac->error_info_addr);
503 
504 	alive_data->scd_base_addr = le32_to_cpu(lmac1->scd_base_ptr);
505 	alive_data->valid = status == IWL_ALIVE_STATUS_OK;
506 	if (mvm->umac_error_event_table)
507 		mvm->support_umac_log = true;
508 
509 	IWL_DEBUG_FW(mvm,
510 		     "Alive ucode status 0x%04x revision 0x%01X 0x%01X\n",
511 		     status, lmac1->ver_type, lmac1->ver_subtype);
512 
513 	if (lmac2)
514 		IWL_DEBUG_FW(mvm, "Alive ucode CDB\n");
515 
516 	IWL_DEBUG_FW(mvm,
517 		     "UMAC version: Major - 0x%x, Minor - 0x%x\n",
518 		     le32_to_cpu(umac->umac_major),
519 		     le32_to_cpu(umac->umac_minor));
520 
521 	return true;
522 }
523 
524 static bool iwl_wait_init_complete(struct iwl_notif_wait_data *notif_wait,
525 				   struct iwl_rx_packet *pkt, void *data)
526 {
527 	WARN_ON(pkt->hdr.cmd != INIT_COMPLETE_NOTIF);
528 
529 	return true;
530 }
531 
532 static bool iwl_wait_phy_db_entry(struct iwl_notif_wait_data *notif_wait,
533 				  struct iwl_rx_packet *pkt, void *data)
534 {
535 	struct iwl_phy_db *phy_db = data;
536 
537 	if (pkt->hdr.cmd != CALIB_RES_NOTIF_PHY_DB) {
538 		WARN_ON(pkt->hdr.cmd != INIT_COMPLETE_NOTIF);
539 		return true;
540 	}
541 
542 	WARN_ON(iwl_phy_db_set_section(phy_db, pkt));
543 
544 	return false;
545 }
546 
547 static int iwl_mvm_init_paging(struct iwl_mvm *mvm)
548 {
549 	const struct fw_img *fw = &mvm->fw->img[mvm->cur_ucode];
550 	int ret;
551 
552 	/*
553 	 * Configure and operate fw paging mechanism.
554 	 * The driver configures the paging flow only once.
555 	 * The CPU2 paging image is included in the IWL_UCODE_INIT image.
556 	 */
557 	if (!fw->paging_mem_size)
558 		return 0;
559 
560 	/*
561 	 * When dma is not enabled, the driver needs to copy / write
562 	 * the downloaded / uploaded page to / from the smem.
563 	 * This gets the location of the place were the pages are
564 	 * stored.
565 	 */
566 	if (!is_device_dma_capable(mvm->trans->dev)) {
567 		ret = iwl_trans_get_paging_item(mvm);
568 		if (ret) {
569 			IWL_ERR(mvm, "failed to get FW paging item\n");
570 			return ret;
571 		}
572 	}
573 
574 	ret = iwl_save_fw_paging(mvm, fw);
575 	if (ret) {
576 		IWL_ERR(mvm, "failed to save the FW paging image\n");
577 		return ret;
578 	}
579 
580 	ret = iwl_send_paging_cmd(mvm, fw);
581 	if (ret) {
582 		IWL_ERR(mvm, "failed to send the paging cmd\n");
583 		iwl_free_fw_paging(mvm);
584 		return ret;
585 	}
586 
587 	return 0;
588 }
589 static int iwl_mvm_load_ucode_wait_alive(struct iwl_mvm *mvm,
590 					 enum iwl_ucode_type ucode_type)
591 {
592 	struct iwl_notification_wait alive_wait;
593 	struct iwl_mvm_alive_data alive_data;
594 	const struct fw_img *fw;
595 	int ret, i;
596 	enum iwl_ucode_type old_type = mvm->cur_ucode;
597 	static const u16 alive_cmd[] = { MVM_ALIVE };
598 	struct iwl_sf_region st_fwrd_space;
599 
600 	if (ucode_type == IWL_UCODE_REGULAR &&
601 	    iwl_fw_dbg_conf_usniffer(mvm->fw, FW_DBG_START_FROM_ALIVE) &&
602 	    !(fw_has_capa(&mvm->fw->ucode_capa,
603 			  IWL_UCODE_TLV_CAPA_USNIFFER_UNIFIED)))
604 		fw = iwl_get_ucode_image(mvm->fw, IWL_UCODE_REGULAR_USNIFFER);
605 	else
606 		fw = iwl_get_ucode_image(mvm->fw, ucode_type);
607 	if (WARN_ON(!fw))
608 		return -EINVAL;
609 	mvm->cur_ucode = ucode_type;
610 	clear_bit(IWL_MVM_STATUS_FIRMWARE_RUNNING, &mvm->status);
611 
612 	iwl_init_notification_wait(&mvm->notif_wait, &alive_wait,
613 				   alive_cmd, ARRAY_SIZE(alive_cmd),
614 				   iwl_alive_fn, &alive_data);
615 
616 	ret = iwl_trans_start_fw(mvm->trans, fw, ucode_type == IWL_UCODE_INIT);
617 	if (ret) {
618 		mvm->cur_ucode = old_type;
619 		iwl_remove_notification(&mvm->notif_wait, &alive_wait);
620 		return ret;
621 	}
622 
623 	/*
624 	 * Some things may run in the background now, but we
625 	 * just wait for the ALIVE notification here.
626 	 */
627 	ret = iwl_wait_notification(&mvm->notif_wait, &alive_wait,
628 				    MVM_UCODE_ALIVE_TIMEOUT);
629 	if (ret) {
630 		struct iwl_trans *trans = mvm->trans;
631 
632 		if (trans->cfg->device_family == IWL_DEVICE_FAMILY_A000)
633 			IWL_ERR(mvm,
634 				"SecBoot CPU1 Status: 0x%x, CPU2 Status: 0x%x\n",
635 				iwl_read_prph(trans, UMAG_SB_CPU_1_STATUS),
636 				iwl_read_prph(trans, UMAG_SB_CPU_2_STATUS));
637 		else if (trans->cfg->device_family >= IWL_DEVICE_FAMILY_8000)
638 			IWL_ERR(mvm,
639 				"SecBoot CPU1 Status: 0x%x, CPU2 Status: 0x%x\n",
640 				iwl_read_prph(trans, SB_CPU_1_STATUS),
641 				iwl_read_prph(trans, SB_CPU_2_STATUS));
642 		mvm->cur_ucode = old_type;
643 		return ret;
644 	}
645 
646 	if (!alive_data.valid) {
647 		IWL_ERR(mvm, "Loaded ucode is not valid!\n");
648 		mvm->cur_ucode = old_type;
649 		return -EIO;
650 	}
651 
652 	/*
653 	 * update the sdio allocation according to the pointer we get in the
654 	 * alive notification.
655 	 */
656 	st_fwrd_space.addr = mvm->sf_space.addr;
657 	st_fwrd_space.size = mvm->sf_space.size;
658 	ret = iwl_trans_update_sf(mvm->trans, &st_fwrd_space);
659 	if (ret) {
660 		IWL_ERR(mvm, "Failed to update SF size. ret %d\n", ret);
661 		return ret;
662 	}
663 
664 	iwl_trans_fw_alive(mvm->trans, alive_data.scd_base_addr);
665 
666 	/*
667 	 * Note: all the queues are enabled as part of the interface
668 	 * initialization, but in firmware restart scenarios they
669 	 * could be stopped, so wake them up. In firmware restart,
670 	 * mac80211 will have the queues stopped as well until the
671 	 * reconfiguration completes. During normal startup, they
672 	 * will be empty.
673 	 */
674 
675 	memset(&mvm->queue_info, 0, sizeof(mvm->queue_info));
676 	if (iwl_mvm_is_dqa_supported(mvm))
677 		mvm->queue_info[IWL_MVM_DQA_CMD_QUEUE].hw_queue_refcount = 1;
678 	else
679 		mvm->queue_info[IWL_MVM_CMD_QUEUE].hw_queue_refcount = 1;
680 
681 	for (i = 0; i < IEEE80211_MAX_QUEUES; i++)
682 		atomic_set(&mvm->mac80211_queue_stop_count[i], 0);
683 
684 	set_bit(IWL_MVM_STATUS_FIRMWARE_RUNNING, &mvm->status);
685 
686 	return 0;
687 }
688 
689 static int iwl_run_unified_mvm_ucode(struct iwl_mvm *mvm, bool read_nvm)
690 {
691 	struct iwl_notification_wait init_wait;
692 	struct iwl_nvm_access_complete_cmd nvm_complete = {};
693 	struct iwl_init_extended_cfg_cmd init_cfg = {
694 		.init_flags = cpu_to_le32(BIT(IWL_INIT_NVM)),
695 	};
696 	static const u16 init_complete[] = {
697 		INIT_COMPLETE_NOTIF,
698 	};
699 	int ret;
700 
701 	lockdep_assert_held(&mvm->mutex);
702 
703 	iwl_init_notification_wait(&mvm->notif_wait,
704 				   &init_wait,
705 				   init_complete,
706 				   ARRAY_SIZE(init_complete),
707 				   iwl_wait_init_complete,
708 				   NULL);
709 
710 	/* Will also start the device */
711 	ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_REGULAR);
712 	if (ret) {
713 		IWL_ERR(mvm, "Failed to start RT ucode: %d\n", ret);
714 		goto error;
715 	}
716 
717 	/* Send init config command to mark that we are sending NVM access
718 	 * commands
719 	 */
720 	ret = iwl_mvm_send_cmd_pdu(mvm, WIDE_ID(SYSTEM_GROUP,
721 						INIT_EXTENDED_CFG_CMD), 0,
722 				   sizeof(init_cfg), &init_cfg);
723 	if (ret) {
724 		IWL_ERR(mvm, "Failed to run init config command: %d\n",
725 			ret);
726 		goto error;
727 	}
728 
729 	/* Load NVM to NIC if needed */
730 	if (mvm->nvm_file_name) {
731 		iwl_mvm_read_external_nvm(mvm);
732 		iwl_mvm_load_nvm_to_nic(mvm);
733 	}
734 
735 	if (IWL_MVM_PARSE_NVM && read_nvm) {
736 		ret = iwl_nvm_init(mvm, true);
737 		if (ret) {
738 			IWL_ERR(mvm, "Failed to read NVM: %d\n", ret);
739 			goto error;
740 		}
741 	}
742 
743 	ret = iwl_mvm_send_cmd_pdu(mvm, WIDE_ID(REGULATORY_AND_NVM_GROUP,
744 						NVM_ACCESS_COMPLETE), 0,
745 				   sizeof(nvm_complete), &nvm_complete);
746 	if (ret) {
747 		IWL_ERR(mvm, "Failed to run complete NVM access: %d\n",
748 			ret);
749 		goto error;
750 	}
751 
752 	/* We wait for the INIT complete notification */
753 	ret = iwl_wait_notification(&mvm->notif_wait, &init_wait,
754 				    MVM_UCODE_ALIVE_TIMEOUT);
755 	if (ret)
756 		return ret;
757 
758 	/* Read the NVM only at driver load time, no need to do this twice */
759 	if (!IWL_MVM_PARSE_NVM && read_nvm) {
760 		ret = iwl_mvm_nvm_get_from_fw(mvm);
761 		if (ret) {
762 			IWL_ERR(mvm, "Failed to read NVM: %d\n", ret);
763 			return ret;
764 		}
765 	}
766 
767 	return 0;
768 
769 error:
770 	iwl_remove_notification(&mvm->notif_wait, &init_wait);
771 	return ret;
772 }
773 
774 static int iwl_send_phy_cfg_cmd(struct iwl_mvm *mvm)
775 {
776 	struct iwl_phy_cfg_cmd phy_cfg_cmd;
777 	enum iwl_ucode_type ucode_type = mvm->cur_ucode;
778 
779 	/* Set parameters */
780 	phy_cfg_cmd.phy_cfg = cpu_to_le32(iwl_mvm_get_phy_config(mvm));
781 	phy_cfg_cmd.calib_control.event_trigger =
782 		mvm->fw->default_calib[ucode_type].event_trigger;
783 	phy_cfg_cmd.calib_control.flow_trigger =
784 		mvm->fw->default_calib[ucode_type].flow_trigger;
785 
786 	IWL_DEBUG_INFO(mvm, "Sending Phy CFG command: 0x%x\n",
787 		       phy_cfg_cmd.phy_cfg);
788 
789 	return iwl_mvm_send_cmd_pdu(mvm, PHY_CONFIGURATION_CMD, 0,
790 				    sizeof(phy_cfg_cmd), &phy_cfg_cmd);
791 }
792 
793 int iwl_run_init_mvm_ucode(struct iwl_mvm *mvm, bool read_nvm)
794 {
795 	struct iwl_notification_wait calib_wait;
796 	static const u16 init_complete[] = {
797 		INIT_COMPLETE_NOTIF,
798 		CALIB_RES_NOTIF_PHY_DB
799 	};
800 	int ret;
801 
802 	if (iwl_mvm_has_new_tx_api(mvm))
803 		return iwl_run_unified_mvm_ucode(mvm, true);
804 
805 	lockdep_assert_held(&mvm->mutex);
806 
807 	if (WARN_ON_ONCE(mvm->calibrating))
808 		return 0;
809 
810 	iwl_init_notification_wait(&mvm->notif_wait,
811 				   &calib_wait,
812 				   init_complete,
813 				   ARRAY_SIZE(init_complete),
814 				   iwl_wait_phy_db_entry,
815 				   mvm->phy_db);
816 
817 	/* Will also start the device */
818 	ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_INIT);
819 	if (ret) {
820 		IWL_ERR(mvm, "Failed to start INIT ucode: %d\n", ret);
821 		goto error;
822 	}
823 
824 	if (mvm->cfg->device_family < IWL_DEVICE_FAMILY_8000) {
825 		ret = iwl_mvm_send_bt_init_conf(mvm);
826 		if (ret)
827 			goto error;
828 	}
829 
830 	/* Read the NVM only at driver load time, no need to do this twice */
831 	if (read_nvm) {
832 		/* Read nvm */
833 		ret = iwl_nvm_init(mvm, true);
834 		if (ret) {
835 			IWL_ERR(mvm, "Failed to read NVM: %d\n", ret);
836 			goto error;
837 		}
838 	}
839 
840 	/* In case we read the NVM from external file, load it to the NIC */
841 	if (mvm->nvm_file_name)
842 		iwl_mvm_load_nvm_to_nic(mvm);
843 
844 	ret = iwl_nvm_check_version(mvm->nvm_data, mvm->trans);
845 	WARN_ON(ret);
846 
847 	/*
848 	 * abort after reading the nvm in case RF Kill is on, we will complete
849 	 * the init seq later when RF kill will switch to off
850 	 */
851 	if (iwl_mvm_is_radio_hw_killed(mvm)) {
852 		IWL_DEBUG_RF_KILL(mvm,
853 				  "jump over all phy activities due to RF kill\n");
854 		iwl_remove_notification(&mvm->notif_wait, &calib_wait);
855 		ret = 1;
856 		goto out;
857 	}
858 
859 	mvm->calibrating = true;
860 
861 	/* Send TX valid antennas before triggering calibrations */
862 	ret = iwl_send_tx_ant_cfg(mvm, iwl_mvm_get_valid_tx_ant(mvm));
863 	if (ret)
864 		goto error;
865 
866 	/*
867 	 * Send phy configurations command to init uCode
868 	 * to start the 16.0 uCode init image internal calibrations.
869 	 */
870 	ret = iwl_send_phy_cfg_cmd(mvm);
871 	if (ret) {
872 		IWL_ERR(mvm, "Failed to run INIT calibrations: %d\n",
873 			ret);
874 		goto error;
875 	}
876 
877 	/*
878 	 * Some things may run in the background now, but we
879 	 * just wait for the calibration complete notification.
880 	 */
881 	ret = iwl_wait_notification(&mvm->notif_wait, &calib_wait,
882 			MVM_UCODE_CALIB_TIMEOUT);
883 
884 	if (ret && iwl_mvm_is_radio_hw_killed(mvm)) {
885 		IWL_DEBUG_RF_KILL(mvm, "RFKILL while calibrating.\n");
886 		ret = 1;
887 	}
888 	goto out;
889 
890 error:
891 	iwl_remove_notification(&mvm->notif_wait, &calib_wait);
892 out:
893 	mvm->calibrating = false;
894 	if (iwlmvm_mod_params.init_dbg && !mvm->nvm_data) {
895 		/* we want to debug INIT and we have no NVM - fake */
896 		mvm->nvm_data = kzalloc(sizeof(struct iwl_nvm_data) +
897 					sizeof(struct ieee80211_channel) +
898 					sizeof(struct ieee80211_rate),
899 					GFP_KERNEL);
900 		if (!mvm->nvm_data)
901 			return -ENOMEM;
902 		mvm->nvm_data->bands[0].channels = mvm->nvm_data->channels;
903 		mvm->nvm_data->bands[0].n_channels = 1;
904 		mvm->nvm_data->bands[0].n_bitrates = 1;
905 		mvm->nvm_data->bands[0].bitrates =
906 			(void *)mvm->nvm_data->channels + 1;
907 		mvm->nvm_data->bands[0].bitrates->hw_value = 10;
908 	}
909 
910 	return ret;
911 }
912 
913 static void iwl_mvm_parse_shared_mem_a000(struct iwl_mvm *mvm,
914 					  struct iwl_rx_packet *pkt)
915 {
916 	struct iwl_shared_mem_cfg *mem_cfg = (void *)pkt->data;
917 	int i, lmac;
918 	int lmac_num = le32_to_cpu(mem_cfg->lmac_num);
919 
920 	if (WARN_ON(lmac_num > ARRAY_SIZE(mem_cfg->lmac_smem)))
921 		return;
922 
923 	mvm->smem_cfg.num_lmacs = lmac_num;
924 	mvm->smem_cfg.num_txfifo_entries =
925 		ARRAY_SIZE(mem_cfg->lmac_smem[0].txfifo_size);
926 	mvm->smem_cfg.rxfifo2_size = le32_to_cpu(mem_cfg->rxfifo2_size);
927 
928 	for (lmac = 0; lmac < lmac_num; lmac++) {
929 		struct iwl_shared_mem_lmac_cfg *lmac_cfg =
930 			&mem_cfg->lmac_smem[lmac];
931 
932 		for (i = 0; i < ARRAY_SIZE(lmac_cfg->txfifo_size); i++)
933 			mvm->smem_cfg.lmac[lmac].txfifo_size[i] =
934 				le32_to_cpu(lmac_cfg->txfifo_size[i]);
935 		mvm->smem_cfg.lmac[lmac].rxfifo1_size =
936 			le32_to_cpu(lmac_cfg->rxfifo1_size);
937 	}
938 }
939 
940 static void iwl_mvm_parse_shared_mem(struct iwl_mvm *mvm,
941 				     struct iwl_rx_packet *pkt)
942 {
943 	struct iwl_shared_mem_cfg_v2 *mem_cfg = (void *)pkt->data;
944 	int i;
945 
946 	mvm->smem_cfg.num_lmacs = 1;
947 
948 	mvm->smem_cfg.num_txfifo_entries = ARRAY_SIZE(mem_cfg->txfifo_size);
949 	for (i = 0; i < ARRAY_SIZE(mem_cfg->txfifo_size); i++)
950 		mvm->smem_cfg.lmac[0].txfifo_size[i] =
951 			le32_to_cpu(mem_cfg->txfifo_size[i]);
952 
953 	mvm->smem_cfg.lmac[0].rxfifo1_size =
954 		le32_to_cpu(mem_cfg->rxfifo_size[0]);
955 	mvm->smem_cfg.rxfifo2_size = le32_to_cpu(mem_cfg->rxfifo_size[1]);
956 
957 	/* new API has more data, from rxfifo_addr field and on */
958 	if (fw_has_capa(&mvm->fw->ucode_capa,
959 			IWL_UCODE_TLV_CAPA_EXTEND_SHARED_MEM_CFG)) {
960 		BUILD_BUG_ON(sizeof(mvm->smem_cfg.internal_txfifo_size) !=
961 			     sizeof(mem_cfg->internal_txfifo_size));
962 
963 		for (i = 0;
964 		     i < ARRAY_SIZE(mvm->smem_cfg.internal_txfifo_size);
965 		     i++)
966 			mvm->smem_cfg.internal_txfifo_size[i] =
967 				le32_to_cpu(mem_cfg->internal_txfifo_size[i]);
968 	}
969 }
970 
971 static void iwl_mvm_get_shared_mem_conf(struct iwl_mvm *mvm)
972 {
973 	struct iwl_host_cmd cmd = {
974 		.flags = CMD_WANT_SKB,
975 		.data = { NULL, },
976 		.len = { 0, },
977 	};
978 	struct iwl_rx_packet *pkt;
979 
980 	lockdep_assert_held(&mvm->mutex);
981 
982 	if (fw_has_capa(&mvm->fw->ucode_capa,
983 			IWL_UCODE_TLV_CAPA_EXTEND_SHARED_MEM_CFG))
984 		cmd.id = iwl_cmd_id(SHARED_MEM_CFG_CMD, SYSTEM_GROUP, 0);
985 	else
986 		cmd.id = SHARED_MEM_CFG;
987 
988 	if (WARN_ON(iwl_mvm_send_cmd(mvm, &cmd)))
989 		return;
990 
991 	pkt = cmd.resp_pkt;
992 	if (iwl_mvm_has_new_tx_api(mvm))
993 		iwl_mvm_parse_shared_mem_a000(mvm, pkt);
994 	else
995 		iwl_mvm_parse_shared_mem(mvm, pkt);
996 
997 	IWL_DEBUG_INFO(mvm, "SHARED MEM CFG: got memory offsets/sizes\n");
998 
999 	iwl_free_resp(&cmd);
1000 }
1001 
1002 static int iwl_mvm_config_ltr(struct iwl_mvm *mvm)
1003 {
1004 	struct iwl_ltr_config_cmd cmd = {
1005 		.flags = cpu_to_le32(LTR_CFG_FLAG_FEATURE_ENABLE),
1006 	};
1007 
1008 	if (!mvm->trans->ltr_enabled)
1009 		return 0;
1010 
1011 	return iwl_mvm_send_cmd_pdu(mvm, LTR_CONFIG, 0,
1012 				    sizeof(cmd), &cmd);
1013 }
1014 
1015 #ifdef CONFIG_ACPI
1016 #define ACPI_WRDS_METHOD		"WRDS"
1017 #define ACPI_EWRD_METHOD		"EWRD"
1018 #define ACPI_WGDS_METHOD		"WGDS"
1019 #define ACPI_WIFI_DOMAIN		(0x07)
1020 #define ACPI_WRDS_WIFI_DATA_SIZE	(IWL_MVM_SAR_TABLE_SIZE + 2)
1021 #define ACPI_EWRD_WIFI_DATA_SIZE	((IWL_MVM_SAR_PROFILE_NUM - 1) * \
1022 					 IWL_MVM_SAR_TABLE_SIZE + 3)
1023 #define ACPI_WGDS_WIFI_DATA_SIZE	18
1024 #define ACPI_WGDS_NUM_BANDS		2
1025 #define ACPI_WGDS_TABLE_SIZE		3
1026 
1027 static int iwl_mvm_sar_set_profile(struct iwl_mvm *mvm,
1028 				   union acpi_object *table,
1029 				   struct iwl_mvm_sar_profile *profile,
1030 				   bool enabled)
1031 {
1032 	int i;
1033 
1034 	profile->enabled = enabled;
1035 
1036 	for (i = 0; i < IWL_MVM_SAR_TABLE_SIZE; i++) {
1037 		if ((table[i].type != ACPI_TYPE_INTEGER) ||
1038 		    (table[i].integer.value > U8_MAX))
1039 			return -EINVAL;
1040 
1041 		profile->table[i] = table[i].integer.value;
1042 	}
1043 
1044 	return 0;
1045 }
1046 
1047 static union acpi_object *iwl_mvm_sar_find_wifi_pkg(struct iwl_mvm *mvm,
1048 						    union acpi_object *data,
1049 						    int data_size)
1050 {
1051 	int i;
1052 	union acpi_object *wifi_pkg;
1053 
1054 	/*
1055 	 * We need at least two packages, one for the revision and one
1056 	 * for the data itself.  Also check that the revision is valid
1057 	 * (i.e. it is an integer set to 0).
1058 	 */
1059 	if (data->type != ACPI_TYPE_PACKAGE ||
1060 	    data->package.count < 2 ||
1061 	    data->package.elements[0].type != ACPI_TYPE_INTEGER ||
1062 	    data->package.elements[0].integer.value != 0) {
1063 		IWL_DEBUG_RADIO(mvm, "Unsupported packages structure\n");
1064 		return ERR_PTR(-EINVAL);
1065 	}
1066 
1067 	/* loop through all the packages to find the one for WiFi */
1068 	for (i = 1; i < data->package.count; i++) {
1069 		union acpi_object *domain;
1070 
1071 		wifi_pkg = &data->package.elements[i];
1072 
1073 		/* Skip anything that is not a package with the right
1074 		 * amount of elements (i.e. domain_type,
1075 		 * enabled/disabled plus the actual data size.
1076 		 */
1077 		if (wifi_pkg->type != ACPI_TYPE_PACKAGE ||
1078 		    wifi_pkg->package.count != data_size)
1079 			continue;
1080 
1081 		domain = &wifi_pkg->package.elements[0];
1082 		if (domain->type == ACPI_TYPE_INTEGER &&
1083 		    domain->integer.value == ACPI_WIFI_DOMAIN)
1084 			break;
1085 
1086 		wifi_pkg = NULL;
1087 	}
1088 
1089 	if (!wifi_pkg)
1090 		return ERR_PTR(-ENOENT);
1091 
1092 	return wifi_pkg;
1093 }
1094 
1095 static int iwl_mvm_sar_get_wrds_table(struct iwl_mvm *mvm)
1096 {
1097 	union acpi_object *wifi_pkg, *table;
1098 	acpi_handle root_handle;
1099 	acpi_handle handle;
1100 	struct acpi_buffer wrds = {ACPI_ALLOCATE_BUFFER, NULL};
1101 	acpi_status status;
1102 	bool enabled;
1103 	int ret;
1104 
1105 	root_handle = ACPI_HANDLE(mvm->dev);
1106 	if (!root_handle) {
1107 		IWL_DEBUG_RADIO(mvm,
1108 				"Could not retrieve root port ACPI handle\n");
1109 		return -ENOENT;
1110 	}
1111 
1112 	/* Get the method's handle */
1113 	status = acpi_get_handle(root_handle, (acpi_string)ACPI_WRDS_METHOD,
1114 				 &handle);
1115 	if (ACPI_FAILURE(status)) {
1116 		IWL_DEBUG_RADIO(mvm, "WRDS method not found\n");
1117 		return -ENOENT;
1118 	}
1119 
1120 	/* Call WRDS with no arguments */
1121 	status = acpi_evaluate_object(handle, NULL, NULL, &wrds);
1122 	if (ACPI_FAILURE(status)) {
1123 		IWL_DEBUG_RADIO(mvm, "WRDS invocation failed (0x%x)\n", status);
1124 		return -ENOENT;
1125 	}
1126 
1127 	wifi_pkg = iwl_mvm_sar_find_wifi_pkg(mvm, wrds.pointer,
1128 					     ACPI_WRDS_WIFI_DATA_SIZE);
1129 	if (IS_ERR(wifi_pkg)) {
1130 		ret = PTR_ERR(wifi_pkg);
1131 		goto out_free;
1132 	}
1133 
1134 	if (wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER) {
1135 		ret = -EINVAL;
1136 		goto out_free;
1137 	}
1138 
1139 	enabled = !!(wifi_pkg->package.elements[1].integer.value);
1140 
1141 	/* position of the actual table */
1142 	table = &wifi_pkg->package.elements[2];
1143 
1144 	/* The profile from WRDS is officially profile 1, but goes
1145 	 * into sar_profiles[0] (because we don't have a profile 0).
1146 	 */
1147 	ret = iwl_mvm_sar_set_profile(mvm, table, &mvm->sar_profiles[0],
1148 				      enabled);
1149 
1150 out_free:
1151 	kfree(wrds.pointer);
1152 	return ret;
1153 }
1154 
1155 static int iwl_mvm_sar_get_ewrd_table(struct iwl_mvm *mvm)
1156 {
1157 	union acpi_object *wifi_pkg;
1158 	acpi_handle root_handle;
1159 	acpi_handle handle;
1160 	struct acpi_buffer ewrd = {ACPI_ALLOCATE_BUFFER, NULL};
1161 	acpi_status status;
1162 	bool enabled;
1163 	int i, n_profiles, ret;
1164 
1165 	root_handle = ACPI_HANDLE(mvm->dev);
1166 	if (!root_handle) {
1167 		IWL_DEBUG_RADIO(mvm,
1168 				"Could not retrieve root port ACPI handle\n");
1169 		return -ENOENT;
1170 	}
1171 
1172 	/* Get the method's handle */
1173 	status = acpi_get_handle(root_handle, (acpi_string)ACPI_EWRD_METHOD,
1174 				 &handle);
1175 	if (ACPI_FAILURE(status)) {
1176 		IWL_DEBUG_RADIO(mvm, "EWRD method not found\n");
1177 		return -ENOENT;
1178 	}
1179 
1180 	/* Call EWRD with no arguments */
1181 	status = acpi_evaluate_object(handle, NULL, NULL, &ewrd);
1182 	if (ACPI_FAILURE(status)) {
1183 		IWL_DEBUG_RADIO(mvm, "EWRD invocation failed (0x%x)\n", status);
1184 		return -ENOENT;
1185 	}
1186 
1187 	wifi_pkg = iwl_mvm_sar_find_wifi_pkg(mvm, ewrd.pointer,
1188 					     ACPI_EWRD_WIFI_DATA_SIZE);
1189 	if (IS_ERR(wifi_pkg)) {
1190 		ret = PTR_ERR(wifi_pkg);
1191 		goto out_free;
1192 	}
1193 
1194 	if ((wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER) ||
1195 	    (wifi_pkg->package.elements[2].type != ACPI_TYPE_INTEGER)) {
1196 		ret = -EINVAL;
1197 		goto out_free;
1198 	}
1199 
1200 	enabled = !!(wifi_pkg->package.elements[1].integer.value);
1201 	n_profiles = wifi_pkg->package.elements[2].integer.value;
1202 
1203 	/* in case of BIOS bug */
1204 	if (n_profiles <= 0) {
1205 		ret = -EINVAL;
1206 		goto out_free;
1207 	}
1208 
1209 	for (i = 0; i < n_profiles; i++) {
1210 		/* the tables start at element 3 */
1211 		static int pos = 3;
1212 
1213 		/* The EWRD profiles officially go from 2 to 4, but we
1214 		 * save them in sar_profiles[1-3] (because we don't
1215 		 * have profile 0).  So in the array we start from 1.
1216 		 */
1217 		ret = iwl_mvm_sar_set_profile(mvm,
1218 					      &wifi_pkg->package.elements[pos],
1219 					      &mvm->sar_profiles[i + 1],
1220 					      enabled);
1221 		if (ret < 0)
1222 			break;
1223 
1224 		/* go to the next table */
1225 		pos += IWL_MVM_SAR_TABLE_SIZE;
1226 	}
1227 
1228 out_free:
1229 	kfree(ewrd.pointer);
1230 	return ret;
1231 }
1232 
1233 static int iwl_mvm_sar_get_wgds_table(struct iwl_mvm *mvm)
1234 {
1235 	union acpi_object *wifi_pkg;
1236 	acpi_handle root_handle;
1237 	acpi_handle handle;
1238 	struct acpi_buffer wgds = {ACPI_ALLOCATE_BUFFER, NULL};
1239 	acpi_status status;
1240 	int i, j, ret;
1241 	int idx = 1;
1242 
1243 	root_handle = ACPI_HANDLE(mvm->dev);
1244 	if (!root_handle) {
1245 		IWL_DEBUG_RADIO(mvm,
1246 				"Could not retrieve root port ACPI handle\n");
1247 		return -ENOENT;
1248 	}
1249 
1250 	/* Get the method's handle */
1251 	status = acpi_get_handle(root_handle, (acpi_string)ACPI_WGDS_METHOD,
1252 				 &handle);
1253 	if (ACPI_FAILURE(status)) {
1254 		IWL_DEBUG_RADIO(mvm, "WGDS method not found\n");
1255 		return -ENOENT;
1256 	}
1257 
1258 	/* Call WGDS with no arguments */
1259 	status = acpi_evaluate_object(handle, NULL, NULL, &wgds);
1260 	if (ACPI_FAILURE(status)) {
1261 		IWL_DEBUG_RADIO(mvm, "WGDS invocation failed (0x%x)\n", status);
1262 		return -ENOENT;
1263 	}
1264 
1265 	wifi_pkg = iwl_mvm_sar_find_wifi_pkg(mvm, wgds.pointer,
1266 					     ACPI_WGDS_WIFI_DATA_SIZE);
1267 	if (IS_ERR(wifi_pkg)) {
1268 		ret = PTR_ERR(wifi_pkg);
1269 		goto out_free;
1270 	}
1271 
1272 	for (i = 0; i < IWL_NUM_GEO_PROFILES; i++) {
1273 		for (j = 0; j < IWL_MVM_GEO_TABLE_SIZE; j++) {
1274 			union acpi_object *entry;
1275 
1276 			entry = &wifi_pkg->package.elements[idx++];
1277 			if ((entry->type != ACPI_TYPE_INTEGER) ||
1278 			    (entry->integer.value > U8_MAX))
1279 				return -EINVAL;
1280 
1281 			mvm->geo_profiles[i].values[j] = entry->integer.value;
1282 		}
1283 	}
1284 	ret = 0;
1285 out_free:
1286 	kfree(wgds.pointer);
1287 	return ret;
1288 }
1289 
1290 int iwl_mvm_sar_select_profile(struct iwl_mvm *mvm, int prof_a, int prof_b)
1291 {
1292 	struct iwl_dev_tx_power_cmd cmd = {
1293 		.v3.set_mode = cpu_to_le32(IWL_TX_POWER_MODE_SET_CHAINS),
1294 	};
1295 	int i, j, idx;
1296 	int profs[IWL_NUM_CHAIN_LIMITS] = { prof_a, prof_b };
1297 	int len = sizeof(cmd);
1298 
1299 	BUILD_BUG_ON(IWL_NUM_CHAIN_LIMITS < 2);
1300 	BUILD_BUG_ON(IWL_NUM_CHAIN_LIMITS * IWL_NUM_SUB_BANDS !=
1301 		     IWL_MVM_SAR_TABLE_SIZE);
1302 
1303 	if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TX_POWER_ACK))
1304 		len = sizeof(cmd.v3);
1305 
1306 	for (i = 0; i < IWL_NUM_CHAIN_LIMITS; i++) {
1307 		struct iwl_mvm_sar_profile *prof;
1308 
1309 		/* don't allow SAR to be disabled (profile 0 means disable) */
1310 		if (profs[i] == 0)
1311 			return -EPERM;
1312 
1313 		/* we are off by one, so allow up to IWL_MVM_SAR_PROFILE_NUM */
1314 		if (profs[i] > IWL_MVM_SAR_PROFILE_NUM)
1315 			return -EINVAL;
1316 
1317 		/* profiles go from 1 to 4, so decrement to access the array */
1318 		prof = &mvm->sar_profiles[profs[i] - 1];
1319 
1320 		/* if the profile is disabled, do nothing */
1321 		if (!prof->enabled) {
1322 			IWL_DEBUG_RADIO(mvm, "SAR profile %d is disabled.\n",
1323 					profs[i]);
1324 			/* if one of the profiles is disabled, we fail all */
1325 			return -ENOENT;
1326 		}
1327 
1328 		IWL_DEBUG_RADIO(mvm, "  Chain[%d]:\n", i);
1329 		for (j = 0; j < IWL_NUM_SUB_BANDS; j++) {
1330 			idx = (i * IWL_NUM_SUB_BANDS) + j;
1331 			cmd.v3.per_chain_restriction[i][j] =
1332 				cpu_to_le16(prof->table[idx]);
1333 			IWL_DEBUG_RADIO(mvm, "    Band[%d] = %d * .125dBm\n",
1334 					j, prof->table[idx]);
1335 		}
1336 	}
1337 
1338 	IWL_DEBUG_RADIO(mvm, "Sending REDUCE_TX_POWER_CMD per chain\n");
1339 
1340 	return iwl_mvm_send_cmd_pdu(mvm, REDUCE_TX_POWER_CMD, 0, len, &cmd);
1341 }
1342 
1343 int iwl_mvm_get_sar_geo_profile(struct iwl_mvm *mvm)
1344 {
1345 	struct iwl_geo_tx_power_profiles_resp *resp;
1346 	int ret;
1347 
1348 	struct iwl_geo_tx_power_profiles_cmd geo_cmd = {
1349 		.ops = cpu_to_le32(IWL_PER_CHAIN_OFFSET_GET_CURRENT_TABLE),
1350 	};
1351 	struct iwl_host_cmd cmd = {
1352 		.id =  WIDE_ID(PHY_OPS_GROUP, GEO_TX_POWER_LIMIT),
1353 		.len = { sizeof(geo_cmd), },
1354 		.flags = CMD_WANT_SKB,
1355 		.data = { &geo_cmd },
1356 	};
1357 
1358 	ret = iwl_mvm_send_cmd(mvm, &cmd);
1359 	if (ret) {
1360 		IWL_ERR(mvm, "Failed to get geographic profile info %d\n", ret);
1361 		return ret;
1362 	}
1363 
1364 	resp = (void *)cmd.resp_pkt->data;
1365 	ret = le32_to_cpu(resp->profile_idx);
1366 	if (WARN_ON(ret > IWL_NUM_GEO_PROFILES)) {
1367 		ret = -EIO;
1368 		IWL_WARN(mvm, "Invalid geographic profile idx (%d)\n", ret);
1369 	}
1370 
1371 	iwl_free_resp(&cmd);
1372 	return ret;
1373 }
1374 
1375 static int iwl_mvm_sar_geo_init(struct iwl_mvm *mvm)
1376 {
1377 	struct iwl_geo_tx_power_profiles_cmd cmd = {
1378 		.ops = cpu_to_le32(IWL_PER_CHAIN_OFFSET_SET_TABLES),
1379 	};
1380 	int ret, i, j;
1381 	u16 cmd_wide_id =  WIDE_ID(PHY_OPS_GROUP, GEO_TX_POWER_LIMIT);
1382 
1383 	ret = iwl_mvm_sar_get_wgds_table(mvm);
1384 	if (ret < 0) {
1385 		IWL_DEBUG_RADIO(mvm,
1386 				"Geo SAR BIOS table invalid or unavailable. (%d)\n",
1387 				ret);
1388 		/* we don't fail if the table is not available */
1389 		return 0;
1390 	}
1391 
1392 	IWL_DEBUG_RADIO(mvm, "Sending GEO_TX_POWER_LIMIT\n");
1393 
1394 	BUILD_BUG_ON(IWL_NUM_GEO_PROFILES * ACPI_WGDS_NUM_BANDS *
1395 		     ACPI_WGDS_TABLE_SIZE !=  ACPI_WGDS_WIFI_DATA_SIZE);
1396 
1397 	for (i = 0; i < IWL_NUM_GEO_PROFILES; i++) {
1398 		struct iwl_per_chain_offset *chain =
1399 			(struct iwl_per_chain_offset *)&cmd.table[i];
1400 
1401 		for (j = 0; j < ACPI_WGDS_NUM_BANDS; j++) {
1402 			u8 *value;
1403 
1404 			value = &mvm->geo_profiles[i].values[j *
1405 				IWL_GEO_PER_CHAIN_SIZE];
1406 			chain[j].max_tx_power = cpu_to_le16(value[0]);
1407 			chain[j].chain_a = value[1];
1408 			chain[j].chain_b = value[2];
1409 			IWL_DEBUG_RADIO(mvm,
1410 					"SAR geographic profile[%d] Band[%d]: chain A = %d chain B = %d max_tx_power = %d\n",
1411 					i, j, value[1], value[2], value[0]);
1412 		}
1413 	}
1414 	return iwl_mvm_send_cmd_pdu(mvm, cmd_wide_id, 0, sizeof(cmd), &cmd);
1415 }
1416 
1417 #else /* CONFIG_ACPI */
1418 static int iwl_mvm_sar_get_wrds_table(struct iwl_mvm *mvm)
1419 {
1420 	return -ENOENT;
1421 }
1422 
1423 static int iwl_mvm_sar_get_ewrd_table(struct iwl_mvm *mvm)
1424 {
1425 	return -ENOENT;
1426 }
1427 
1428 static int iwl_mvm_sar_geo_init(struct iwl_mvm *mvm)
1429 {
1430 	return 0;
1431 }
1432 #endif /* CONFIG_ACPI */
1433 
1434 static int iwl_mvm_sar_init(struct iwl_mvm *mvm)
1435 {
1436 	int ret;
1437 
1438 	ret = iwl_mvm_sar_get_wrds_table(mvm);
1439 	if (ret < 0) {
1440 		IWL_DEBUG_RADIO(mvm,
1441 				"WRDS SAR BIOS table invalid or unavailable. (%d)\n",
1442 				ret);
1443 		/* if not available, don't fail and don't bother with EWRD */
1444 		return 0;
1445 	}
1446 
1447 	ret = iwl_mvm_sar_get_ewrd_table(mvm);
1448 	/* if EWRD is not available, we can still use WRDS, so don't fail */
1449 	if (ret < 0)
1450 		IWL_DEBUG_RADIO(mvm,
1451 				"EWRD SAR BIOS table invalid or unavailable. (%d)\n",
1452 				ret);
1453 
1454 	/* choose profile 1 (WRDS) as default for both chains */
1455 	ret = iwl_mvm_sar_select_profile(mvm, 1, 1);
1456 
1457 	/* if we don't have profile 0 from BIOS, just skip it */
1458 	if (ret == -ENOENT)
1459 		return 0;
1460 
1461 	return ret;
1462 }
1463 
1464 static int iwl_mvm_load_rt_fw(struct iwl_mvm *mvm)
1465 {
1466 	int ret;
1467 
1468 	if (iwl_mvm_has_new_tx_api(mvm))
1469 		return iwl_run_unified_mvm_ucode(mvm, false);
1470 
1471 	ret = iwl_run_init_mvm_ucode(mvm, false);
1472 
1473 	if (iwlmvm_mod_params.init_dbg)
1474 		return 0;
1475 
1476 	if (ret) {
1477 		IWL_ERR(mvm, "Failed to run INIT ucode: %d\n", ret);
1478 		/* this can't happen */
1479 		if (WARN_ON(ret > 0))
1480 			ret = -ERFKILL;
1481 		return ret;
1482 	}
1483 
1484 	/*
1485 	 * Stop and start the transport without entering low power
1486 	 * mode. This will save the state of other components on the
1487 	 * device that are triggered by the INIT firwmare (MFUART).
1488 	 */
1489 	_iwl_trans_stop_device(mvm->trans, false);
1490 	ret = _iwl_trans_start_hw(mvm->trans, false);
1491 	if (ret)
1492 		return ret;
1493 
1494 	ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_REGULAR);
1495 	if (ret)
1496 		return ret;
1497 
1498 	return iwl_mvm_init_paging(mvm);
1499 }
1500 
1501 int iwl_mvm_up(struct iwl_mvm *mvm)
1502 {
1503 	int ret, i;
1504 	struct ieee80211_channel *chan;
1505 	struct cfg80211_chan_def chandef;
1506 
1507 	lockdep_assert_held(&mvm->mutex);
1508 
1509 	ret = iwl_trans_start_hw(mvm->trans);
1510 	if (ret)
1511 		return ret;
1512 
1513 	ret = iwl_mvm_load_rt_fw(mvm);
1514 	if (ret) {
1515 		IWL_ERR(mvm, "Failed to start RT ucode: %d\n", ret);
1516 		goto error;
1517 	}
1518 
1519 	iwl_mvm_get_shared_mem_conf(mvm);
1520 
1521 	ret = iwl_mvm_sf_update(mvm, NULL, false);
1522 	if (ret)
1523 		IWL_ERR(mvm, "Failed to initialize Smart Fifo\n");
1524 
1525 	mvm->fw_dbg_conf = FW_DBG_INVALID;
1526 	/* if we have a destination, assume EARLY START */
1527 	if (mvm->fw->dbg_dest_tlv)
1528 		mvm->fw_dbg_conf = FW_DBG_START_FROM_ALIVE;
1529 	iwl_mvm_start_fw_dbg_conf(mvm, FW_DBG_START_FROM_ALIVE);
1530 
1531 	ret = iwl_send_tx_ant_cfg(mvm, iwl_mvm_get_valid_tx_ant(mvm));
1532 	if (ret)
1533 		goto error;
1534 
1535 	/* Send phy db control command and then phy db calibration*/
1536 	if (!iwl_mvm_has_new_tx_api(mvm)) {
1537 		ret = iwl_send_phy_db_data(mvm->phy_db);
1538 		if (ret)
1539 			goto error;
1540 
1541 		ret = iwl_send_phy_cfg_cmd(mvm);
1542 		if (ret)
1543 			goto error;
1544 	}
1545 
1546 	ret = iwl_mvm_send_bt_init_conf(mvm);
1547 	if (ret)
1548 		goto error;
1549 
1550 	/* Init RSS configuration */
1551 	/* TODO - remove a000 disablement when we have RXQ config API */
1552 	if (iwl_mvm_has_new_rx_api(mvm) && !iwl_mvm_has_new_tx_api(mvm)) {
1553 		ret = iwl_send_rss_cfg_cmd(mvm);
1554 		if (ret) {
1555 			IWL_ERR(mvm, "Failed to configure RSS queues: %d\n",
1556 				ret);
1557 			goto error;
1558 		}
1559 	}
1560 
1561 	/* init the fw <-> mac80211 STA mapping */
1562 	for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++)
1563 		RCU_INIT_POINTER(mvm->fw_id_to_mac_id[i], NULL);
1564 
1565 	mvm->tdls_cs.peer.sta_id = IWL_MVM_INVALID_STA;
1566 
1567 	/* reset quota debouncing buffer - 0xff will yield invalid data */
1568 	memset(&mvm->last_quota_cmd, 0xff, sizeof(mvm->last_quota_cmd));
1569 
1570 	/* Enable DQA-mode if required */
1571 	if (iwl_mvm_is_dqa_supported(mvm)) {
1572 		ret = iwl_mvm_send_dqa_cmd(mvm);
1573 		if (ret)
1574 			goto error;
1575 	} else {
1576 		IWL_DEBUG_FW(mvm, "Working in non-DQA mode\n");
1577 	}
1578 
1579 	/* Add auxiliary station for scanning */
1580 	ret = iwl_mvm_add_aux_sta(mvm);
1581 	if (ret)
1582 		goto error;
1583 
1584 	/* Add all the PHY contexts */
1585 	chan = &mvm->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels[0];
1586 	cfg80211_chandef_create(&chandef, chan, NL80211_CHAN_NO_HT);
1587 	for (i = 0; i < NUM_PHY_CTX; i++) {
1588 		/*
1589 		 * The channel used here isn't relevant as it's
1590 		 * going to be overwritten in the other flows.
1591 		 * For now use the first channel we have.
1592 		 */
1593 		ret = iwl_mvm_phy_ctxt_add(mvm, &mvm->phy_ctxts[i],
1594 					   &chandef, 1, 1);
1595 		if (ret)
1596 			goto error;
1597 	}
1598 
1599 #ifdef CONFIG_THERMAL
1600 	if (iwl_mvm_is_tt_in_fw(mvm)) {
1601 		/* in order to give the responsibility of ct-kill and
1602 		 * TX backoff to FW we need to send empty temperature reporting
1603 		 * cmd during init time
1604 		 */
1605 		iwl_mvm_send_temp_report_ths_cmd(mvm);
1606 	} else {
1607 		/* Initialize tx backoffs to the minimal possible */
1608 		iwl_mvm_tt_tx_backoff(mvm, 0);
1609 	}
1610 
1611 	/* TODO: read the budget from BIOS / Platform NVM */
1612 	if (iwl_mvm_is_ctdp_supported(mvm) && mvm->cooling_dev.cur_state > 0) {
1613 		ret = iwl_mvm_ctdp_command(mvm, CTDP_CMD_OPERATION_START,
1614 					   mvm->cooling_dev.cur_state);
1615 		if (ret)
1616 			goto error;
1617 	}
1618 #else
1619 	/* Initialize tx backoffs to the minimal possible */
1620 	iwl_mvm_tt_tx_backoff(mvm, 0);
1621 #endif
1622 
1623 	WARN_ON(iwl_mvm_config_ltr(mvm));
1624 
1625 	ret = iwl_mvm_power_update_device(mvm);
1626 	if (ret)
1627 		goto error;
1628 
1629 	/*
1630 	 * RTNL is not taken during Ct-kill, but we don't need to scan/Tx
1631 	 * anyway, so don't init MCC.
1632 	 */
1633 	if (!test_bit(IWL_MVM_STATUS_HW_CTKILL, &mvm->status)) {
1634 		ret = iwl_mvm_init_mcc(mvm);
1635 		if (ret)
1636 			goto error;
1637 	}
1638 
1639 	if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
1640 		mvm->scan_type = IWL_SCAN_TYPE_NOT_SET;
1641 		ret = iwl_mvm_config_scan(mvm);
1642 		if (ret)
1643 			goto error;
1644 	}
1645 
1646 	/* allow FW/transport low power modes if not during restart */
1647 	if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
1648 		iwl_mvm_unref(mvm, IWL_MVM_REF_UCODE_DOWN);
1649 
1650 	ret = iwl_mvm_sar_init(mvm);
1651 	if (ret)
1652 		goto error;
1653 
1654 	ret = iwl_mvm_sar_geo_init(mvm);
1655 	if (ret)
1656 		goto error;
1657 
1658 	IWL_DEBUG_INFO(mvm, "RT uCode started.\n");
1659 	return 0;
1660  error:
1661 	if (!iwlmvm_mod_params.init_dbg)
1662 		iwl_mvm_stop_device(mvm);
1663 	return ret;
1664 }
1665 
1666 int iwl_mvm_load_d3_fw(struct iwl_mvm *mvm)
1667 {
1668 	int ret, i;
1669 
1670 	lockdep_assert_held(&mvm->mutex);
1671 
1672 	ret = iwl_trans_start_hw(mvm->trans);
1673 	if (ret)
1674 		return ret;
1675 
1676 	ret = iwl_mvm_load_ucode_wait_alive(mvm, IWL_UCODE_WOWLAN);
1677 	if (ret) {
1678 		IWL_ERR(mvm, "Failed to start WoWLAN firmware: %d\n", ret);
1679 		goto error;
1680 	}
1681 
1682 	ret = iwl_send_tx_ant_cfg(mvm, iwl_mvm_get_valid_tx_ant(mvm));
1683 	if (ret)
1684 		goto error;
1685 
1686 	/* Send phy db control command and then phy db calibration*/
1687 	ret = iwl_send_phy_db_data(mvm->phy_db);
1688 	if (ret)
1689 		goto error;
1690 
1691 	ret = iwl_send_phy_cfg_cmd(mvm);
1692 	if (ret)
1693 		goto error;
1694 
1695 	/* init the fw <-> mac80211 STA mapping */
1696 	for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++)
1697 		RCU_INIT_POINTER(mvm->fw_id_to_mac_id[i], NULL);
1698 
1699 	/* Add auxiliary station for scanning */
1700 	ret = iwl_mvm_add_aux_sta(mvm);
1701 	if (ret)
1702 		goto error;
1703 
1704 	return 0;
1705  error:
1706 	iwl_mvm_stop_device(mvm);
1707 	return ret;
1708 }
1709 
1710 void iwl_mvm_rx_card_state_notif(struct iwl_mvm *mvm,
1711 				 struct iwl_rx_cmd_buffer *rxb)
1712 {
1713 	struct iwl_rx_packet *pkt = rxb_addr(rxb);
1714 	struct iwl_card_state_notif *card_state_notif = (void *)pkt->data;
1715 	u32 flags = le32_to_cpu(card_state_notif->flags);
1716 
1717 	IWL_DEBUG_RF_KILL(mvm, "Card state received: HW:%s SW:%s CT:%s\n",
1718 			  (flags & HW_CARD_DISABLED) ? "Kill" : "On",
1719 			  (flags & SW_CARD_DISABLED) ? "Kill" : "On",
1720 			  (flags & CT_KILL_CARD_DISABLED) ?
1721 			  "Reached" : "Not reached");
1722 }
1723 
1724 void iwl_mvm_rx_mfuart_notif(struct iwl_mvm *mvm,
1725 			     struct iwl_rx_cmd_buffer *rxb)
1726 {
1727 	struct iwl_rx_packet *pkt = rxb_addr(rxb);
1728 	struct iwl_mfuart_load_notif *mfuart_notif = (void *)pkt->data;
1729 
1730 	IWL_DEBUG_INFO(mvm,
1731 		       "MFUART: installed ver: 0x%08x, external ver: 0x%08x, status: 0x%08x, duration: 0x%08x\n",
1732 		       le32_to_cpu(mfuart_notif->installed_ver),
1733 		       le32_to_cpu(mfuart_notif->external_ver),
1734 		       le32_to_cpu(mfuart_notif->status),
1735 		       le32_to_cpu(mfuart_notif->duration));
1736 
1737 	if (iwl_rx_packet_payload_len(pkt) == sizeof(*mfuart_notif))
1738 		IWL_DEBUG_INFO(mvm,
1739 			       "MFUART: image size: 0x%08x\n",
1740 			       le32_to_cpu(mfuart_notif->image_size));
1741 }
1742