core.c 42.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
 * Copyright (c) 2005-2011 Atheros Communications Inc.
 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <linux/module.h>
#include <linux/firmware.h>
20
#include <linux/of.h>
21 22 23 24 25 26 27 28 29

#include "core.h"
#include "mac.h"
#include "htc.h"
#include "hif.h"
#include "wmi.h"
#include "bmi.h"
#include "debug.h"
#include "htt.h"
K
Kalle Valo 已提交
30
#include "testmode.h"
M
Michal Kazior 已提交
31
#include "wmi-ops.h"
32 33

unsigned int ath10k_debug_mask;
34
static unsigned int ath10k_cryptmode_param;
35
static bool uart_print;
36 37
static bool skip_otp;

38
module_param_named(debug_mask, ath10k_debug_mask, uint, 0644);
39
module_param_named(cryptmode, ath10k_cryptmode_param, uint, 0644);
40
module_param(uart_print, bool, 0644);
41 42
module_param(skip_otp, bool, 0644);

43 44
MODULE_PARM_DESC(debug_mask, "Debugging mask");
MODULE_PARM_DESC(uart_print, "Uart target debugging");
45
MODULE_PARM_DESC(skip_otp, "Skip otp failure for calibration in testmode");
46
MODULE_PARM_DESC(cryptmode, "Crypto mode: 0-hardware, 1-software");
47 48 49 50 51 52

static const struct ath10k_hw_params ath10k_hw_params_list[] = {
	{
		.id = QCA988X_HW_2_0_VERSION,
		.name = "qca988x hw2.0",
		.patch_load_addr = QCA988X_HW_2_0_PATCH_LOAD_ADDR,
53
		.uart_pin = 7,
54
		.has_shifted_cc_wraparound = true,
55
		.otp_exe_param = 0,
56
		.channel_counters_freq_hz = 88000,
57
		.max_probe_resp_desc_thres = 0,
58 59 60 61 62
		.fw = {
			.dir = QCA988X_HW_2_0_FW_DIR,
			.fw = QCA988X_HW_2_0_FW_FILE,
			.otp = QCA988X_HW_2_0_OTP_FILE,
			.board = QCA988X_HW_2_0_BOARD_DATA_FILE,
63 64
			.board_size = QCA988X_BOARD_DATA_SZ,
			.board_ext_size = QCA988X_BOARD_EXT_DATA_SZ,
65 66
		},
	},
M
Michal Kazior 已提交
67 68 69 70 71
	{
		.id = QCA6174_HW_2_1_VERSION,
		.name = "qca6174 hw2.1",
		.patch_load_addr = QCA6174_HW_2_1_PATCH_LOAD_ADDR,
		.uart_pin = 6,
72
		.otp_exe_param = 0,
73
		.channel_counters_freq_hz = 88000,
74
		.max_probe_resp_desc_thres = 0,
M
Michal Kazior 已提交
75 76 77 78 79 80 81 82 83 84 85 86 87 88
		.fw = {
			.dir = QCA6174_HW_2_1_FW_DIR,
			.fw = QCA6174_HW_2_1_FW_FILE,
			.otp = QCA6174_HW_2_1_OTP_FILE,
			.board = QCA6174_HW_2_1_BOARD_DATA_FILE,
			.board_size = QCA6174_BOARD_DATA_SZ,
			.board_ext_size = QCA6174_BOARD_EXT_DATA_SZ,
		},
	},
	{
		.id = QCA6174_HW_3_0_VERSION,
		.name = "qca6174 hw3.0",
		.patch_load_addr = QCA6174_HW_3_0_PATCH_LOAD_ADDR,
		.uart_pin = 6,
89
		.otp_exe_param = 0,
90
		.channel_counters_freq_hz = 88000,
91
		.max_probe_resp_desc_thres = 0,
M
Michal Kazior 已提交
92 93 94 95 96 97 98 99 100
		.fw = {
			.dir = QCA6174_HW_3_0_FW_DIR,
			.fw = QCA6174_HW_3_0_FW_FILE,
			.otp = QCA6174_HW_3_0_OTP_FILE,
			.board = QCA6174_HW_3_0_BOARD_DATA_FILE,
			.board_size = QCA6174_BOARD_DATA_SZ,
			.board_ext_size = QCA6174_BOARD_EXT_DATA_SZ,
		},
	},
M
Michal Kazior 已提交
101 102 103 104 105
	{
		.id = QCA6174_HW_3_2_VERSION,
		.name = "qca6174 hw3.2",
		.patch_load_addr = QCA6174_HW_3_0_PATCH_LOAD_ADDR,
		.uart_pin = 6,
106
		.otp_exe_param = 0,
107
		.channel_counters_freq_hz = 88000,
108
		.max_probe_resp_desc_thres = 0,
M
Michal Kazior 已提交
109 110 111 112 113 114 115 116 117 118
		.fw = {
			/* uses same binaries as hw3.0 */
			.dir = QCA6174_HW_3_0_FW_DIR,
			.fw = QCA6174_HW_3_0_FW_FILE,
			.otp = QCA6174_HW_3_0_OTP_FILE,
			.board = QCA6174_HW_3_0_BOARD_DATA_FILE,
			.board_size = QCA6174_BOARD_DATA_SZ,
			.board_ext_size = QCA6174_BOARD_EXT_DATA_SZ,
		},
	},
119 120 121 122 123
	{
		.id = QCA99X0_HW_2_0_DEV_VERSION,
		.name = "qca99x0 hw2.0",
		.patch_load_addr = QCA99X0_HW_2_0_PATCH_LOAD_ADDR,
		.uart_pin = 7,
124
		.otp_exe_param = 0x00000700,
125
		.continuous_frag_desc = true,
126
		.channel_counters_freq_hz = 150000,
127
		.max_probe_resp_desc_thres = 24,
128 129 130 131 132 133 134 135 136
		.fw = {
			.dir = QCA99X0_HW_2_0_FW_DIR,
			.fw = QCA99X0_HW_2_0_FW_FILE,
			.otp = QCA99X0_HW_2_0_OTP_FILE,
			.board = QCA99X0_HW_2_0_BOARD_DATA_FILE,
			.board_size = QCA99X0_BOARD_DATA_SZ,
			.board_ext_size = QCA99X0_BOARD_EXT_DATA_SZ,
		},
	},
137 138
};

139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
static const char *const ath10k_core_fw_feature_str[] = {
	[ATH10K_FW_FEATURE_EXT_WMI_MGMT_RX] = "wmi-mgmt-rx",
	[ATH10K_FW_FEATURE_WMI_10X] = "wmi-10.x",
	[ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX] = "has-wmi-mgmt-tx",
	[ATH10K_FW_FEATURE_NO_P2P] = "no-p2p",
	[ATH10K_FW_FEATURE_WMI_10_2] = "wmi-10.2",
	[ATH10K_FW_FEATURE_MULTI_VIF_PS_SUPPORT] = "multi-vif-ps",
	[ATH10K_FW_FEATURE_WOWLAN_SUPPORT] = "wowlan",
	[ATH10K_FW_FEATURE_IGNORE_OTP_RESULT] = "ignore-otp",
	[ATH10K_FW_FEATURE_NO_NWIFI_DECAP_4ADDR_PADDING] = "no-4addr-pad",
	[ATH10K_FW_FEATURE_SUPPORTS_SKIP_CLOCK_INIT] = "skip-clock-init",
};

static unsigned int ath10k_core_get_fw_feature_str(char *buf,
						   size_t buf_len,
						   enum ath10k_fw_features feat)
{
	if (feat >= ARRAY_SIZE(ath10k_core_fw_feature_str) ||
	    WARN_ON(!ath10k_core_fw_feature_str[feat])) {
		return scnprintf(buf, buf_len, "bit%d", feat);
	}

	return scnprintf(buf, buf_len, "%s", ath10k_core_fw_feature_str[feat]);
}

void ath10k_core_get_fw_features_str(struct ath10k *ar,
				     char *buf,
				     size_t buf_len)
{
	unsigned int len = 0;
	int i;

	for (i = 0; i < ATH10K_FW_FEATURE_COUNT; i++) {
		if (test_bit(i, ar->fw_features)) {
			if (len > 0)
				len += scnprintf(buf + len, buf_len - len, ",");

			len += ath10k_core_get_fw_feature_str(buf + len,
							      buf_len - len,
							      i);
		}
	}
}

183 184
static void ath10k_send_suspend_complete(struct ath10k *ar)
{
185
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot suspend complete\n");
186

187
	complete(&ar->target_suspend);
188 189 190 191 192 193 194 195 196 197 198
}

static int ath10k_init_configure_target(struct ath10k *ar)
{
	u32 param_host;
	int ret;

	/* tell target which HTC version it is used*/
	ret = ath10k_bmi_write32(ar, hi_app_host_interest,
				 HTC_PROTOCOL_VERSION);
	if (ret) {
199
		ath10k_err(ar, "settings HTC version failed\n");
200 201 202 203 204 205
		return ret;
	}

	/* set the firmware mode to STA/IBSS/AP */
	ret = ath10k_bmi_read32(ar, hi_option_flag, &param_host);
	if (ret) {
206
		ath10k_err(ar, "setting firmware mode (1/2) failed\n");
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
		return ret;
	}

	/* TODO following parameters need to be re-visited. */
	/* num_device */
	param_host |= (1 << HI_OPTION_NUM_DEV_SHIFT);
	/* Firmware mode */
	/* FIXME: Why FW_MODE_AP ??.*/
	param_host |= (HI_OPTION_FW_MODE_AP << HI_OPTION_FW_MODE_SHIFT);
	/* mac_addr_method */
	param_host |= (1 << HI_OPTION_MAC_ADDR_METHOD_SHIFT);
	/* firmware_bridge */
	param_host |= (0 << HI_OPTION_FW_BRIDGE_SHIFT);
	/* fwsubmode */
	param_host |= (0 << HI_OPTION_FW_SUBMODE_SHIFT);

	ret = ath10k_bmi_write32(ar, hi_option_flag, param_host);
	if (ret) {
225
		ath10k_err(ar, "setting firmware mode (2/2) failed\n");
226 227 228 229 230 231
		return ret;
	}

	/* We do all byte-swapping on the host */
	ret = ath10k_bmi_write32(ar, hi_be, 0);
	if (ret) {
232
		ath10k_err(ar, "setting host CPU BE mode failed\n");
233 234 235 236 237 238 239
		return ret;
	}

	/* FW descriptor/Data swap flags */
	ret = ath10k_bmi_write32(ar, hi_fw_swap, 0);

	if (ret) {
240
		ath10k_err(ar, "setting FW data/desc swap flags failed\n");
241 242 243
		return ret;
	}

M
Michal Kazior 已提交
244 245 246 247 248 249 250 251 252 253 254
	/* Some devices have a special sanity check that verifies the PCI
	 * Device ID is written to this host interest var. It is known to be
	 * required to boot QCA6164.
	 */
	ret = ath10k_bmi_write32(ar, hi_hci_uart_pwr_mgmt_params_ext,
				 ar->dev_id);
	if (ret) {
		ath10k_err(ar, "failed to set pwr_mgmt_params: %d\n", ret);
		return ret;
	}

255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
	return 0;
}

static const struct firmware *ath10k_fetch_fw_file(struct ath10k *ar,
						   const char *dir,
						   const char *file)
{
	char filename[100];
	const struct firmware *fw;
	int ret;

	if (file == NULL)
		return ERR_PTR(-ENOENT);

	if (dir == NULL)
		dir = ".";

	snprintf(filename, sizeof(filename), "%s/%s", dir, file);
	ret = request_firmware(&fw, filename, ar->dev);
	if (ret)
		return ERR_PTR(ret);

	return fw;
}

280 281
static int ath10k_push_board_ext_data(struct ath10k *ar, const void *data,
				      size_t data_len)
282
{
283 284
	u32 board_data_size = ar->hw_params.fw.board_size;
	u32 board_ext_data_size = ar->hw_params.fw.board_ext_size;
285 286 287 288 289
	u32 board_ext_data_addr;
	int ret;

	ret = ath10k_bmi_read32(ar, hi_board_ext_data, &board_ext_data_addr);
	if (ret) {
290 291
		ath10k_err(ar, "could not read board ext data addr (%d)\n",
			   ret);
292 293 294
		return ret;
	}

295
	ath10k_dbg(ar, ATH10K_DBG_BOOT,
296
		   "boot push board extended data addr 0x%x\n",
297 298 299 300 301
		   board_ext_data_addr);

	if (board_ext_data_addr == 0)
		return 0;

302
	if (data_len != (board_data_size + board_ext_data_size)) {
303
		ath10k_err(ar, "invalid board (ext) data sizes %zu != %d+%d\n",
304
			   data_len, board_data_size, board_ext_data_size);
305 306 307 308
		return -EINVAL;
	}

	ret = ath10k_bmi_write_memory(ar, board_ext_data_addr,
309
				      data + board_data_size,
310 311
				      board_ext_data_size);
	if (ret) {
312
		ath10k_err(ar, "could not write board ext data (%d)\n", ret);
313 314 315 316 317 318
		return ret;
	}

	ret = ath10k_bmi_write32(ar, hi_board_ext_data_config,
				 (board_ext_data_size << 16) | 1);
	if (ret) {
319 320
		ath10k_err(ar, "could not write board ext data bit (%d)\n",
			   ret);
321 322 323 324 325 326
		return ret;
	}

	return 0;
}

327 328
static int ath10k_download_board_data(struct ath10k *ar, const void *data,
				      size_t data_len)
329
{
330
	u32 board_data_size = ar->hw_params.fw.board_size;
331 332 333
	u32 address;
	int ret;

334
	ret = ath10k_push_board_ext_data(ar, data, data_len);
335
	if (ret) {
336
		ath10k_err(ar, "could not push board ext data (%d)\n", ret);
337 338 339 340 341
		goto exit;
	}

	ret = ath10k_bmi_read32(ar, hi_board_data, &address);
	if (ret) {
342
		ath10k_err(ar, "could not read board data addr (%d)\n", ret);
343 344 345
		goto exit;
	}

346
	ret = ath10k_bmi_write_memory(ar, address, data,
347
				      min_t(u32, board_data_size,
348
					    data_len));
349
	if (ret) {
350
		ath10k_err(ar, "could not write board data (%d)\n", ret);
351 352 353 354 355
		goto exit;
	}

	ret = ath10k_bmi_write32(ar, hi_board_data_initialized, 1);
	if (ret) {
356
		ath10k_err(ar, "could not write board data bit (%d)\n", ret);
357 358 359 360 361 362 363
		goto exit;
	}

exit:
	return ret;
}

364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
static int ath10k_download_cal_file(struct ath10k *ar)
{
	int ret;

	if (!ar->cal_file)
		return -ENOENT;

	if (IS_ERR(ar->cal_file))
		return PTR_ERR(ar->cal_file);

	ret = ath10k_download_board_data(ar, ar->cal_file->data,
					 ar->cal_file->size);
	if (ret) {
		ath10k_err(ar, "failed to download cal_file data: %d\n", ret);
		return ret;
	}

	ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot cal file downloaded\n");

	return 0;
}

386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
static int ath10k_download_cal_dt(struct ath10k *ar)
{
	struct device_node *node;
	int data_len;
	void *data;
	int ret;

	node = ar->dev->of_node;
	if (!node)
		/* Device Tree is optional, don't print any warnings if
		 * there's no node for ath10k.
		 */
		return -ENOENT;

	if (!of_get_property(node, "qcom,ath10k-calibration-data",
			     &data_len)) {
		/* The calibration data node is optional */
		return -ENOENT;
	}

	if (data_len != QCA988X_CAL_DATA_LEN) {
		ath10k_warn(ar, "invalid calibration data length in DT: %d\n",
			    data_len);
		ret = -EMSGSIZE;
		goto out;
	}

	data = kmalloc(data_len, GFP_KERNEL);
	if (!data) {
		ret = -ENOMEM;
		goto out;
	}

	ret = of_property_read_u8_array(node, "qcom,ath10k-calibration-data",
					data, data_len);
	if (ret) {
		ath10k_warn(ar, "failed to read calibration data from DT: %d\n",
			    ret);
		goto out_free;
	}

	ret = ath10k_download_board_data(ar, data, data_len);
	if (ret) {
		ath10k_warn(ar, "failed to download calibration data from Device Tree: %d\n",
			    ret);
		goto out_free;
	}

	ret = 0;

out_free:
	kfree(data);

out:
	return ret;
}

443 444
static int ath10k_download_and_run_otp(struct ath10k *ar)
{
445
	u32 result, address = ar->hw_params.patch_load_addr;
446
	u32 bmi_otp_exe_param = ar->hw_params.otp_exe_param;
447 448
	int ret;

449
	ret = ath10k_download_board_data(ar, ar->board_data, ar->board_len);
450 451 452 453 454
	if (ret) {
		ath10k_err(ar, "failed to download board data: %d\n", ret);
		return ret;
	}

455 456
	/* OTP is optional */

K
Kalle Valo 已提交
457
	if (!ar->otp_data || !ar->otp_len) {
458
		ath10k_warn(ar, "Not running otp, calibration will be incorrect (otp-data %p otp_len %zd)!\n",
459
			    ar->otp_data, ar->otp_len);
460
		return 0;
K
Kalle Valo 已提交
461 462
	}

463
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot upload otp to 0x%x len %zd\n",
K
Kalle Valo 已提交
464
		   address, ar->otp_len);
465

466
	ret = ath10k_bmi_fast_download(ar, address, ar->otp_data, ar->otp_len);
467
	if (ret) {
468
		ath10k_err(ar, "could not write otp (%d)\n", ret);
K
Kalle Valo 已提交
469
		return ret;
470 471
	}

472
	ret = ath10k_bmi_execute(ar, address, bmi_otp_exe_param, &result);
473
	if (ret) {
474
		ath10k_err(ar, "could not execute otp (%d)\n", ret);
K
Kalle Valo 已提交
475
		return ret;
476 477
	}

478
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot otp execute result %d\n", result);
K
Kalle Valo 已提交
479

480 481 482
	if (!(skip_otp || test_bit(ATH10K_FW_FEATURE_IGNORE_OTP_RESULT,
				   ar->fw_features))
	    && result != 0) {
483
		ath10k_err(ar, "otp calibration failed: %d", result);
K
Kalle Valo 已提交
484 485 486 487
		return -EINVAL;
	}

	return 0;
488 489
}

K
Kalle Valo 已提交
490
static int ath10k_download_fw(struct ath10k *ar, enum ath10k_firmware_mode mode)
491
{
K
Kalle Valo 已提交
492 493 494
	u32 address, data_len;
	const char *mode_name;
	const void *data;
495 496 497 498
	int ret;

	address = ar->hw_params.patch_load_addr;

K
Kalle Valo 已提交
499 500 501 502 503
	switch (mode) {
	case ATH10K_FIRMWARE_MODE_NORMAL:
		data = ar->firmware_data;
		data_len = ar->firmware_len;
		mode_name = "normal";
504 505 506 507 508 509 510
		ret = ath10k_swap_code_seg_configure(ar,
				ATH10K_SWAP_CODE_SEG_BIN_TYPE_FW);
		if (ret) {
			ath10k_err(ar, "failed to configure fw code swap: %d\n",
				   ret);
			return ret;
		}
K
Kalle Valo 已提交
511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526
		break;
	case ATH10K_FIRMWARE_MODE_UTF:
		data = ar->testmode.utf->data;
		data_len = ar->testmode.utf->size;
		mode_name = "utf";
		break;
	default:
		ath10k_err(ar, "unknown firmware mode: %d\n", mode);
		return -EINVAL;
	}

	ath10k_dbg(ar, ATH10K_DBG_BOOT,
		   "boot uploading firmware image %p len %d mode %s\n",
		   data, data_len, mode_name);

	ret = ath10k_bmi_fast_download(ar, address, data, data_len);
527
	if (ret) {
K
Kalle Valo 已提交
528 529 530
		ath10k_err(ar, "failed to download %s firmware: %d\n",
			   mode_name, ret);
		return ret;
531 532
	}

533 534 535 536 537
	return ret;
}

static void ath10k_core_free_firmware_files(struct ath10k *ar)
{
538
	if (!IS_ERR(ar->board))
539
		release_firmware(ar->board);
540

541
	if (!IS_ERR(ar->otp))
542 543
		release_firmware(ar->otp);

544
	if (!IS_ERR(ar->firmware))
545 546
		release_firmware(ar->firmware);

547
	if (!IS_ERR(ar->cal_file))
548 549
		release_firmware(ar->cal_file);

550 551
	ath10k_swap_code_seg_release(ar);

552
	ar->board = NULL;
553 554 555
	ar->board_data = NULL;
	ar->board_len = 0;

556
	ar->otp = NULL;
557 558 559
	ar->otp_data = NULL;
	ar->otp_len = 0;

560
	ar->firmware = NULL;
561 562
	ar->firmware_data = NULL;
	ar->firmware_len = 0;
563 564

	ar->cal_file = NULL;
565

566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
}

static int ath10k_fetch_cal_file(struct ath10k *ar)
{
	char filename[100];

	/* cal-<bus>-<id>.bin */
	scnprintf(filename, sizeof(filename), "cal-%s-%s.bin",
		  ath10k_bus_str(ar->hif.bus), dev_name(ar->dev));

	ar->cal_file = ath10k_fetch_fw_file(ar, ATH10K_FW_DIR, filename);
	if (IS_ERR(ar->cal_file))
		/* calibration file is optional, don't print any warnings */
		return PTR_ERR(ar->cal_file);

	ath10k_dbg(ar, ATH10K_DBG_BOOT, "found calibration file %s/%s\n",
		   ATH10K_FW_DIR, filename);

	return 0;
585 586
}

587
static int ath10k_core_fetch_spec_board_file(struct ath10k *ar)
588
{
589 590 591 592 593 594 595 596 597 598 599 600
	char filename[100];

	scnprintf(filename, sizeof(filename), "board-%s-%s.bin",
		  ath10k_bus_str(ar->hif.bus), ar->spec_board_id);

	ar->board = ath10k_fetch_fw_file(ar, ar->hw_params.fw.dir, filename);
	if (IS_ERR(ar->board))
		return PTR_ERR(ar->board);

	ar->board_data = ar->board->data;
	ar->board_len = ar->board->size;
	ar->spec_board_loaded = true;
601

602 603 604 605 606
	return 0;
}

static int ath10k_core_fetch_generic_board_file(struct ath10k *ar)
{
607 608
	if (!ar->hw_params.fw.board) {
		ath10k_err(ar, "failed to find board file fw entry\n");
609 610 611
		return -EINVAL;
	}

612 613 614
	ar->board = ath10k_fetch_fw_file(ar,
					 ar->hw_params.fw.dir,
					 ar->hw_params.fw.board);
615 616
	if (IS_ERR(ar->board))
		return PTR_ERR(ar->board);
617

618 619
	ar->board_data = ar->board->data;
	ar->board_len = ar->board->size;
620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647
	ar->spec_board_loaded = false;

	return 0;
}

static int ath10k_core_fetch_board_file(struct ath10k *ar)
{
	int ret;

	if (strlen(ar->spec_board_id) > 0) {
		ret = ath10k_core_fetch_spec_board_file(ar);
		if (ret) {
			ath10k_info(ar, "failed to load spec board file, falling back to generic: %d\n",
				    ret);
			goto generic;
		}

		ath10k_dbg(ar, ATH10K_DBG_BOOT, "found specific board file for %s\n",
			   ar->spec_board_id);
		return 0;
	}

generic:
	ret = ath10k_core_fetch_generic_board_file(ar);
	if (ret) {
		ath10k_err(ar, "failed to fetch generic board data: %d\n", ret);
		return ret;
	}
648

649 650 651 652 653 654 655 656 657 658 659 660
	return 0;
}

static int ath10k_core_fetch_firmware_api_1(struct ath10k *ar)
{
	int ret = 0;

	if (ar->hw_params.fw.fw == NULL) {
		ath10k_err(ar, "firmware file not defined\n");
		return -EINVAL;
	}

661 662 663 664 665
	ar->firmware = ath10k_fetch_fw_file(ar,
					    ar->hw_params.fw.dir,
					    ar->hw_params.fw.fw);
	if (IS_ERR(ar->firmware)) {
		ret = PTR_ERR(ar->firmware);
666
		ath10k_err(ar, "could not fetch firmware (%d)\n", ret);
667 668 669
		goto err;
	}

670 671 672
	ar->firmware_data = ar->firmware->data;
	ar->firmware_len = ar->firmware->size;

673 674 675 676 677 678 679 680 681
	/* OTP may be undefined. If so, don't fetch it at all */
	if (ar->hw_params.fw.otp == NULL)
		return 0;

	ar->otp = ath10k_fetch_fw_file(ar,
				       ar->hw_params.fw.dir,
				       ar->hw_params.fw.otp);
	if (IS_ERR(ar->otp)) {
		ret = PTR_ERR(ar->otp);
682
		ath10k_err(ar, "could not fetch otp (%d)\n", ret);
683 684 685
		goto err;
	}

686 687 688
	ar->otp_data = ar->otp->data;
	ar->otp_len = ar->otp->size;

689 690 691 692
	return 0;

err:
	ath10k_core_free_firmware_files(ar);
693 694 695
	return ret;
}

696 697 698 699 700 701
static int ath10k_core_fetch_firmware_api_n(struct ath10k *ar, const char *name)
{
	size_t magic_len, len, ie_len;
	int ie_id, i, index, bit, ret;
	struct ath10k_fw_ie *hdr;
	const u8 *data;
702
	__le32 *timestamp, *version;
703 704 705 706

	/* first fetch the firmware file (firmware-*.bin) */
	ar->firmware = ath10k_fetch_fw_file(ar, ar->hw_params.fw.dir, name);
	if (IS_ERR(ar->firmware)) {
707
		ath10k_err(ar, "could not fetch firmware file '%s/%s': %ld\n",
708
			   ar->hw_params.fw.dir, name, PTR_ERR(ar->firmware));
709 710 711 712 713 714 715 716 717 718
		return PTR_ERR(ar->firmware);
	}

	data = ar->firmware->data;
	len = ar->firmware->size;

	/* magic also includes the null byte, check that as well */
	magic_len = strlen(ATH10K_FIRMWARE_MAGIC) + 1;

	if (len < magic_len) {
719
		ath10k_err(ar, "firmware file '%s/%s' too small to contain magic: %zu\n",
720
			   ar->hw_params.fw.dir, name, len);
721 722
		ret = -EINVAL;
		goto err;
723 724 725
	}

	if (memcmp(data, ATH10K_FIRMWARE_MAGIC, magic_len) != 0) {
726
		ath10k_err(ar, "invalid firmware magic\n");
727 728
		ret = -EINVAL;
		goto err;
729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
	}

	/* jump over the padding */
	magic_len = ALIGN(magic_len, 4);

	len -= magic_len;
	data += magic_len;

	/* loop elements */
	while (len > sizeof(struct ath10k_fw_ie)) {
		hdr = (struct ath10k_fw_ie *)data;

		ie_id = le32_to_cpu(hdr->id);
		ie_len = le32_to_cpu(hdr->len);

		len -= sizeof(*hdr);
		data += sizeof(*hdr);

		if (len < ie_len) {
748
			ath10k_err(ar, "invalid length for FW IE %d (%zu < %zu)\n",
749
				   ie_id, len, ie_len);
750 751
			ret = -EINVAL;
			goto err;
752 753 754 755 756 757 758 759 760 761
		}

		switch (ie_id) {
		case ATH10K_FW_IE_FW_VERSION:
			if (ie_len > sizeof(ar->hw->wiphy->fw_version) - 1)
				break;

			memcpy(ar->hw->wiphy->fw_version, data, ie_len);
			ar->hw->wiphy->fw_version[ie_len] = '\0';

762
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
763 764 765 766 767 768 769 770 771
				   "found fw version %s\n",
				    ar->hw->wiphy->fw_version);
			break;
		case ATH10K_FW_IE_TIMESTAMP:
			if (ie_len != sizeof(u32))
				break;

			timestamp = (__le32 *)data;

772
			ath10k_dbg(ar, ATH10K_DBG_BOOT, "found fw timestamp %d\n",
773 774 775
				   le32_to_cpup(timestamp));
			break;
		case ATH10K_FW_IE_FEATURES:
776
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
777 778 779 780 781 782 783 784 785 786
				   "found firmware features ie (%zd B)\n",
				   ie_len);

			for (i = 0; i < ATH10K_FW_FEATURE_COUNT; i++) {
				index = i / 8;
				bit = i % 8;

				if (index == ie_len)
					break;

787
				if (data[index] & (1 << bit)) {
788
					ath10k_dbg(ar, ATH10K_DBG_BOOT,
789 790
						   "Enabling feature bit: %i\n",
						   i);
791
					__set_bit(i, ar->fw_features);
792
				}
793 794
			}

795
			ath10k_dbg_dump(ar, ATH10K_DBG_BOOT, "features", "",
796 797 798 799
					ar->fw_features,
					sizeof(ar->fw_features));
			break;
		case ATH10K_FW_IE_FW_IMAGE:
800
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
801 802 803 804 805 806 807 808
				   "found fw image ie (%zd B)\n",
				   ie_len);

			ar->firmware_data = data;
			ar->firmware_len = ie_len;

			break;
		case ATH10K_FW_IE_OTP_IMAGE:
809
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
810 811 812 813 814 815 816
				   "found otp image ie (%zd B)\n",
				   ie_len);

			ar->otp_data = data;
			ar->otp_len = ie_len;

			break;
817 818 819 820 821 822 823 824 825 826 827
		case ATH10K_FW_IE_WMI_OP_VERSION:
			if (ie_len != sizeof(u32))
				break;

			version = (__le32 *)data;

			ar->wmi.op_version = le32_to_cpup(version);

			ath10k_dbg(ar, ATH10K_DBG_BOOT, "found fw ie wmi op version %d\n",
				   ar->wmi.op_version);
			break;
828 829 830 831 832 833 834 835 836 837 838
		case ATH10K_FW_IE_HTT_OP_VERSION:
			if (ie_len != sizeof(u32))
				break;

			version = (__le32 *)data;

			ar->htt.op_version = le32_to_cpup(version);

			ath10k_dbg(ar, ATH10K_DBG_BOOT, "found fw ie htt op version %d\n",
				   ar->htt.op_version);
			break;
839 840 841 842 843 844 845
		case ATH10K_FW_IE_FW_CODE_SWAP_IMAGE:
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
				   "found fw code swap image ie (%zd B)\n",
				   ie_len);
			ar->swap.firmware_codeswap_data = data;
			ar->swap.firmware_codeswap_len = ie_len;
			break;
846
		default:
847
			ath10k_warn(ar, "Unknown FW IE: %u\n",
848 849 850 851 852 853 854 855 856
				    le32_to_cpu(hdr->id));
			break;
		}

		/* jump over the padding */
		ie_len = ALIGN(ie_len, 4);

		len -= ie_len;
		data += ie_len;
857
	}
858 859

	if (!ar->firmware_data || !ar->firmware_len) {
860
		ath10k_warn(ar, "No ATH10K_FW_IE_FW_IMAGE found from '%s/%s', skipping\n",
861
			    ar->hw_params.fw.dir, name);
862 863 864 865 866 867 868 869 870 871 872 873 874 875 876
		ret = -ENOMEDIUM;
		goto err;
	}

	return 0;

err:
	ath10k_core_free_firmware_files(ar);
	return ret;
}

static int ath10k_core_fetch_firmware_files(struct ath10k *ar)
{
	int ret;

877 878 879
	/* calibration file is optional, don't check for any errors */
	ath10k_fetch_cal_file(ar);

880 881 882 883 884 885
	ret = ath10k_core_fetch_board_file(ar);
	if (ret) {
		ath10k_err(ar, "failed to fetch board file: %d\n", ret);
		return ret;
	}

K
Kalle Valo 已提交
886 887 888 889 890 891 892
	ar->fw_api = 5;
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);

	ret = ath10k_core_fetch_firmware_api_n(ar, ATH10K_FW_API5_FILE);
	if (ret == 0)
		goto success;

893 894 895 896 897 898 899
	ar->fw_api = 4;
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);

	ret = ath10k_core_fetch_firmware_api_n(ar, ATH10K_FW_API4_FILE);
	if (ret == 0)
		goto success;

900
	ar->fw_api = 3;
901
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
902 903 904 905 906

	ret = ath10k_core_fetch_firmware_api_n(ar, ATH10K_FW_API3_FILE);
	if (ret == 0)
		goto success;

907
	ar->fw_api = 2;
908
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
909

910
	ret = ath10k_core_fetch_firmware_api_n(ar, ATH10K_FW_API2_FILE);
911 912 913 914
	if (ret == 0)
		goto success;

	ar->fw_api = 1;
915
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
916 917 918 919 920

	ret = ath10k_core_fetch_firmware_api_1(ar);
	if (ret)
		return ret;

921
success:
922
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "using fw api %d\n", ar->fw_api);
923 924 925 926

	return 0;
}

927
static int ath10k_download_cal_data(struct ath10k *ar)
928 929 930
{
	int ret;

931 932 933 934 935 936 937
	ret = ath10k_download_cal_file(ar);
	if (ret == 0) {
		ar->cal_mode = ATH10K_CAL_MODE_FILE;
		goto done;
	}

	ath10k_dbg(ar, ATH10K_DBG_BOOT,
938 939 940 941 942 943 944 945 946 947 948
		   "boot did not find a calibration file, try DT next: %d\n",
		   ret);

	ret = ath10k_download_cal_dt(ar);
	if (ret == 0) {
		ar->cal_mode = ATH10K_CAL_MODE_DT;
		goto done;
	}

	ath10k_dbg(ar, ATH10K_DBG_BOOT,
		   "boot did not find DT entry, try OTP next: %d\n",
949 950
		   ret);

951
	ret = ath10k_download_and_run_otp(ar);
952
	if (ret) {
953
		ath10k_err(ar, "failed to run otp: %d\n", ret);
954
		return ret;
955
	}
956

957 958 959 960 961 962
	ar->cal_mode = ATH10K_CAL_MODE_OTP;

done:
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot using calibration mode %s\n",
		   ath10k_cal_mode_str(ar->cal_mode));
	return 0;
963 964 965 966 967 968 969 970 971 972 973 974
}

static int ath10k_init_uart(struct ath10k *ar)
{
	int ret;

	/*
	 * Explicitly setting UART prints to zero as target turns it on
	 * based on scratch registers.
	 */
	ret = ath10k_bmi_write32(ar, hi_serial_enable, 0);
	if (ret) {
975
		ath10k_warn(ar, "could not disable UART prints (%d)\n", ret);
976 977 978
		return ret;
	}

979
	if (!uart_print)
980 981
		return 0;

982
	ret = ath10k_bmi_write32(ar, hi_dbg_uart_txpin, ar->hw_params.uart_pin);
983
	if (ret) {
984
		ath10k_warn(ar, "could not enable UART prints (%d)\n", ret);
985 986 987 988 989
		return ret;
	}

	ret = ath10k_bmi_write32(ar, hi_serial_enable, 1);
	if (ret) {
990
		ath10k_warn(ar, "could not enable UART prints (%d)\n", ret);
991 992 993
		return ret;
	}

994 995 996
	/* Set the UART baud rate to 19200. */
	ret = ath10k_bmi_write32(ar, hi_desired_baud_rate, 19200);
	if (ret) {
997
		ath10k_warn(ar, "could not set the baud rate (%d)\n", ret);
998 999 1000
		return ret;
	}

1001
	ath10k_info(ar, "UART prints enabled\n");
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017
	return 0;
}

static int ath10k_init_hw_params(struct ath10k *ar)
{
	const struct ath10k_hw_params *uninitialized_var(hw_params);
	int i;

	for (i = 0; i < ARRAY_SIZE(ath10k_hw_params_list); i++) {
		hw_params = &ath10k_hw_params_list[i];

		if (hw_params->id == ar->target_version)
			break;
	}

	if (i == ARRAY_SIZE(ath10k_hw_params_list)) {
1018
		ath10k_err(ar, "Unsupported hardware version: 0x%x\n",
1019 1020 1021 1022 1023 1024
			   ar->target_version);
		return -EINVAL;
	}

	ar->hw_params = *hw_params;

1025
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "Hardware name %s version 0x%x\n",
1026
		   ar->hw_params.name, ar->target_version);
1027 1028 1029 1030

	return 0;
}

1031 1032 1033 1034
static void ath10k_core_restart(struct work_struct *work)
{
	struct ath10k *ar = container_of(work, struct ath10k, restart_work);

M
Michal Kazior 已提交
1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
	set_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags);

	/* Place a barrier to make sure the compiler doesn't reorder
	 * CRASH_FLUSH and calling other functions.
	 */
	barrier();

	ieee80211_stop_queues(ar->hw);
	ath10k_drain_tx(ar);
	complete_all(&ar->scan.started);
	complete_all(&ar->scan.completed);
	complete_all(&ar->scan.on_channel);
	complete_all(&ar->offchan_tx_completed);
	complete_all(&ar->install_key_done);
	complete_all(&ar->vdev_setup_done);
1050
	complete_all(&ar->thermal.wmi_sync);
M
Michal Kazior 已提交
1051 1052 1053 1054
	wake_up(&ar->htt.empty_tx_wq);
	wake_up(&ar->wmi.tx_credits_wq);
	wake_up(&ar->peer_mapping_wq);

1055 1056 1057 1058 1059
	mutex_lock(&ar->conf_mutex);

	switch (ar->state) {
	case ATH10K_STATE_ON:
		ar->state = ATH10K_STATE_RESTARTING;
1060
		ath10k_hif_stop(ar);
1061
		ath10k_scan_finish(ar);
1062 1063 1064
		ieee80211_restart_hw(ar->hw);
		break;
	case ATH10K_STATE_OFF:
1065 1066
		/* this can happen if driver is being unloaded
		 * or if the crash happens during FW probing */
1067
		ath10k_warn(ar, "cannot restart a device that hasn't been started\n");
1068 1069
		break;
	case ATH10K_STATE_RESTARTING:
1070 1071
		/* hw restart might be requested from multiple places */
		break;
1072 1073 1074 1075
	case ATH10K_STATE_RESTARTED:
		ar->state = ATH10K_STATE_WEDGED;
		/* fall through */
	case ATH10K_STATE_WEDGED:
1076
		ath10k_warn(ar, "device is wedged, will not restart\n");
1077
		break;
K
Kalle Valo 已提交
1078 1079 1080
	case ATH10K_STATE_UTF:
		ath10k_warn(ar, "firmware restart in UTF mode not supported\n");
		break;
1081 1082 1083 1084 1085
	}

	mutex_unlock(&ar->conf_mutex);
}

1086
static int ath10k_core_init_firmware_features(struct ath10k *ar)
1087
{
1088 1089 1090 1091 1092 1093
	if (test_bit(ATH10K_FW_FEATURE_WMI_10_2, ar->fw_features) &&
	    !test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
		ath10k_err(ar, "feature bits corrupted: 10.2 feature requires 10.x feature to be set as well");
		return -EINVAL;
	}

1094 1095 1096 1097 1098 1099
	if (ar->wmi.op_version >= ATH10K_FW_WMI_OP_VERSION_MAX) {
		ath10k_err(ar, "unsupported WMI OP version (max %d): %d\n",
			   ATH10K_FW_WMI_OP_VERSION_MAX, ar->wmi.op_version);
		return -EINVAL;
	}

1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
	ar->wmi.rx_decap_mode = ATH10K_HW_TXRX_NATIVE_WIFI;
	switch (ath10k_cryptmode_param) {
	case ATH10K_CRYPT_MODE_HW:
		clear_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags);
		clear_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags);
		break;
	case ATH10K_CRYPT_MODE_SW:
		if (!test_bit(ATH10K_FW_FEATURE_RAW_MODE_SUPPORT,
			      ar->fw_features)) {
			ath10k_err(ar, "cryptmode > 0 requires raw mode support from firmware");
			return -EINVAL;
		}

		set_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags);
		set_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags);
		break;
	default:
		ath10k_info(ar, "invalid cryptmode: %d\n",
			    ath10k_cryptmode_param);
		return -EINVAL;
	}

	ar->htt.max_num_amsdu = ATH10K_HTT_MAX_NUM_AMSDU_DEFAULT;
	ar->htt.max_num_ampdu = ATH10K_HTT_MAX_NUM_AMPDU_DEFAULT;

	if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
		ar->wmi.rx_decap_mode = ATH10K_HW_TXRX_RAW;

		/* Workaround:
		 *
		 * Firmware A-MSDU aggregation breaks with RAW Tx encap mode
		 * and causes enormous performance issues (malformed frames,
		 * etc).
		 *
		 * Disabling A-MSDU makes RAW mode stable with heavy traffic
		 * albeit a bit slower compared to regular operation.
		 */
		ar->htt.max_num_amsdu = 1;
	}

1140 1141 1142 1143 1144
	/* Backwards compatibility for firmwares without
	 * ATH10K_FW_IE_WMI_OP_VERSION.
	 */
	if (ar->wmi.op_version == ATH10K_FW_WMI_OP_VERSION_UNSET) {
		if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
1145 1146
			if (test_bit(ATH10K_FW_FEATURE_WMI_10_2,
				     ar->fw_features))
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
				ar->wmi.op_version = ATH10K_FW_WMI_OP_VERSION_10_2;
			else
				ar->wmi.op_version = ATH10K_FW_WMI_OP_VERSION_10_1;
		} else {
			ar->wmi.op_version = ATH10K_FW_WMI_OP_VERSION_MAIN;
		}
	}

	switch (ar->wmi.op_version) {
	case ATH10K_FW_WMI_OP_VERSION_MAIN:
1157 1158
		ar->max_num_peers = TARGET_NUM_PEERS;
		ar->max_num_stations = TARGET_NUM_STATIONS;
1159
		ar->max_num_vdevs = TARGET_NUM_VDEVS;
1160
		ar->htt.max_num_pending_tx = TARGET_NUM_MSDU_DESC;
1161 1162
		ar->fw_stats_req_mask = WMI_STAT_PDEV | WMI_STAT_VDEV |
			WMI_STAT_PEER;
1163
		ar->max_spatial_stream = WMI_MAX_SPATIAL_STREAM;
1164 1165 1166
		break;
	case ATH10K_FW_WMI_OP_VERSION_10_1:
	case ATH10K_FW_WMI_OP_VERSION_10_2:
1167
	case ATH10K_FW_WMI_OP_VERSION_10_2_4:
1168 1169
		ar->max_num_peers = TARGET_10X_NUM_PEERS;
		ar->max_num_stations = TARGET_10X_NUM_STATIONS;
1170
		ar->max_num_vdevs = TARGET_10X_NUM_VDEVS;
1171
		ar->htt.max_num_pending_tx = TARGET_10X_NUM_MSDU_DESC;
1172
		ar->fw_stats_req_mask = WMI_STAT_PEER;
1173
		ar->max_spatial_stream = WMI_MAX_SPATIAL_STREAM;
1174
		break;
M
Michal Kazior 已提交
1175 1176 1177
	case ATH10K_FW_WMI_OP_VERSION_TLV:
		ar->max_num_peers = TARGET_TLV_NUM_PEERS;
		ar->max_num_stations = TARGET_TLV_NUM_STATIONS;
1178
		ar->max_num_vdevs = TARGET_TLV_NUM_VDEVS;
1179
		ar->max_num_tdls_vdevs = TARGET_TLV_NUM_TDLS_VDEVS;
M
Michal Kazior 已提交
1180
		ar->htt.max_num_pending_tx = TARGET_TLV_NUM_MSDU_DESC;
1181
		ar->wow.max_num_patterns = TARGET_TLV_NUM_WOW_PATTERNS;
1182 1183
		ar->fw_stats_req_mask = WMI_STAT_PDEV | WMI_STAT_VDEV |
			WMI_STAT_PEER;
1184
		ar->max_spatial_stream = WMI_MAX_SPATIAL_STREAM;
M
Michal Kazior 已提交
1185
		break;
1186
	case ATH10K_FW_WMI_OP_VERSION_10_4:
1187 1188 1189 1190 1191
		ar->max_num_peers = TARGET_10_4_NUM_PEERS;
		ar->max_num_stations = TARGET_10_4_NUM_STATIONS;
		ar->num_active_peers = TARGET_10_4_ACTIVE_PEERS;
		ar->max_num_vdevs = TARGET_10_4_NUM_VDEVS;
		ar->num_tids = TARGET_10_4_TGT_NUM_TIDS;
1192
		ar->htt.max_num_pending_tx = TARGET_10_4_NUM_MSDU_DESC;
1193
		ar->fw_stats_req_mask = WMI_STAT_PEER;
1194
		ar->max_spatial_stream = WMI_10_4_MAX_SPATIAL_STREAM;
1195
		break;
1196 1197 1198 1199
	case ATH10K_FW_WMI_OP_VERSION_UNSET:
	case ATH10K_FW_WMI_OP_VERSION_MAX:
		WARN_ON(1);
		return -EINVAL;
1200
	}
1201

1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217
	/* Backwards compatibility for firmwares without
	 * ATH10K_FW_IE_HTT_OP_VERSION.
	 */
	if (ar->htt.op_version == ATH10K_FW_HTT_OP_VERSION_UNSET) {
		switch (ar->wmi.op_version) {
		case ATH10K_FW_WMI_OP_VERSION_MAIN:
			ar->htt.op_version = ATH10K_FW_HTT_OP_VERSION_MAIN;
			break;
		case ATH10K_FW_WMI_OP_VERSION_10_1:
		case ATH10K_FW_WMI_OP_VERSION_10_2:
		case ATH10K_FW_WMI_OP_VERSION_10_2_4:
			ar->htt.op_version = ATH10K_FW_HTT_OP_VERSION_10_1;
			break;
		case ATH10K_FW_WMI_OP_VERSION_TLV:
			ar->htt.op_version = ATH10K_FW_HTT_OP_VERSION_TLV;
			break;
1218
		case ATH10K_FW_WMI_OP_VERSION_10_4:
1219 1220 1221 1222 1223 1224 1225
		case ATH10K_FW_WMI_OP_VERSION_UNSET:
		case ATH10K_FW_WMI_OP_VERSION_MAX:
			WARN_ON(1);
			return -EINVAL;
		}
	}

1226
	return 0;
1227 1228
}

K
Kalle Valo 已提交
1229
int ath10k_core_start(struct ath10k *ar, enum ath10k_firmware_mode mode)
1230 1231 1232
{
	int status;

1233 1234
	lockdep_assert_held(&ar->conf_mutex);

M
Michal Kazior 已提交
1235 1236
	clear_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags);

1237 1238
	ath10k_bmi_start(ar);

1239 1240 1241 1242 1243
	if (ath10k_init_configure_target(ar)) {
		status = -EINVAL;
		goto err;
	}

1244 1245 1246 1247
	status = ath10k_download_cal_data(ar);
	if (status)
		goto err;

1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263
	/* Some of of qca988x solutions are having global reset issue
         * during target initialization. Bypassing PLL setting before
         * downloading firmware and letting the SoC run on REF_CLK is
         * fixing the problem. Corresponding firmware change is also needed
         * to set the clock source once the target is initialized.
	 */
	if (test_bit(ATH10K_FW_FEATURE_SUPPORTS_SKIP_CLOCK_INIT,
		     ar->fw_features)) {
		status = ath10k_bmi_write32(ar, hi_skip_clock_init, 1);
		if (status) {
			ath10k_err(ar, "could not write to skip_clock_init: %d\n",
				   status);
			goto err;
		}
	}

1264
	status = ath10k_download_fw(ar, mode);
1265 1266 1267 1268 1269 1270 1271
	if (status)
		goto err;

	status = ath10k_init_uart(ar);
	if (status)
		goto err;

1272 1273
	ar->htc.htc_ops.target_send_suspend_complete =
		ath10k_send_suspend_complete;
1274

1275 1276
	status = ath10k_htc_init(ar);
	if (status) {
1277
		ath10k_err(ar, "could not init HTC (%d)\n", status);
1278 1279 1280 1281 1282
		goto err;
	}

	status = ath10k_bmi_done(ar);
	if (status)
1283
		goto err;
1284 1285 1286

	status = ath10k_wmi_attach(ar);
	if (status) {
1287
		ath10k_err(ar, "WMI attach failed: %d\n", status);
1288
		goto err;
1289 1290
	}

M
Michal Kazior 已提交
1291 1292
	status = ath10k_htt_init(ar);
	if (status) {
1293
		ath10k_err(ar, "failed to init htt: %d\n", status);
M
Michal Kazior 已提交
1294 1295 1296 1297 1298
		goto err_wmi_detach;
	}

	status = ath10k_htt_tx_alloc(&ar->htt);
	if (status) {
1299
		ath10k_err(ar, "failed to alloc htt tx: %d\n", status);
M
Michal Kazior 已提交
1300 1301 1302 1303 1304
		goto err_wmi_detach;
	}

	status = ath10k_htt_rx_alloc(&ar->htt);
	if (status) {
1305
		ath10k_err(ar, "failed to alloc htt rx: %d\n", status);
M
Michal Kazior 已提交
1306 1307 1308
		goto err_htt_tx_detach;
	}

M
Michal Kazior 已提交
1309 1310
	status = ath10k_hif_start(ar);
	if (status) {
1311
		ath10k_err(ar, "could not start HIF: %d\n", status);
M
Michal Kazior 已提交
1312
		goto err_htt_rx_detach;
M
Michal Kazior 已提交
1313 1314 1315 1316
	}

	status = ath10k_htc_wait_target(&ar->htc);
	if (status) {
1317
		ath10k_err(ar, "failed to connect to HTC: %d\n", status);
M
Michal Kazior 已提交
1318 1319
		goto err_hif_stop;
	}
1320

K
Kalle Valo 已提交
1321 1322 1323 1324 1325 1326
	if (mode == ATH10K_FIRMWARE_MODE_NORMAL) {
		status = ath10k_htt_connect(&ar->htt);
		if (status) {
			ath10k_err(ar, "failed to connect htt (%d)\n", status);
			goto err_hif_stop;
		}
1327 1328
	}

M
Michal Kazior 已提交
1329 1330
	status = ath10k_wmi_connect(ar);
	if (status) {
1331
		ath10k_err(ar, "could not connect wmi: %d\n", status);
M
Michal Kazior 已提交
1332 1333 1334 1335 1336
		goto err_hif_stop;
	}

	status = ath10k_htc_start(&ar->htc);
	if (status) {
1337
		ath10k_err(ar, "failed to start htc: %d\n", status);
M
Michal Kazior 已提交
1338 1339 1340
		goto err_hif_stop;
	}

K
Kalle Valo 已提交
1341 1342
	if (mode == ATH10K_FIRMWARE_MODE_NORMAL) {
		status = ath10k_wmi_wait_for_service_ready(ar);
1343
		if (status) {
K
Kalle Valo 已提交
1344 1345 1346
			ath10k_warn(ar, "wmi service ready event not received");
			goto err_hif_stop;
		}
M
Michal Kazior 已提交
1347
	}
1348

1349
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "firmware %s booted\n",
1350
		   ar->hw->wiphy->fw_version);
1351 1352 1353

	status = ath10k_wmi_cmd_init(ar);
	if (status) {
1354 1355
		ath10k_err(ar, "could not send WMI init command (%d)\n",
			   status);
M
Michal Kazior 已提交
1356
		goto err_hif_stop;
1357 1358 1359
	}

	status = ath10k_wmi_wait_for_unified_ready(ar);
1360
	if (status) {
1361
		ath10k_err(ar, "wmi unified ready event not received\n");
M
Michal Kazior 已提交
1362
		goto err_hif_stop;
1363 1364
	}

1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376
	/* If firmware indicates Full Rx Reorder support it must be used in a
	 * slightly different manner. Let HTT code know.
	 */
	ar->htt.rx_ring.in_ord_rx = !!(test_bit(WMI_SERVICE_RX_FULL_REORDER,
						ar->wmi.svc_map));

	status = ath10k_htt_rx_ring_refill(ar);
	if (status) {
		ath10k_err(ar, "failed to refill htt rx ring: %d\n", status);
		goto err_hif_stop;
	}

K
Kalle Valo 已提交
1377 1378 1379 1380 1381 1382 1383
	/* we don't care about HTT in UTF mode */
	if (mode == ATH10K_FIRMWARE_MODE_NORMAL) {
		status = ath10k_htt_setup(&ar->htt);
		if (status) {
			ath10k_err(ar, "failed to setup htt: %d\n", status);
			goto err_hif_stop;
		}
M
Michal Kazior 已提交
1384
	}
1385

1386 1387
	status = ath10k_debug_start(ar);
	if (status)
M
Michal Kazior 已提交
1388
		goto err_hif_stop;
1389

1390
	ar->free_vdev_map = (1LL << ar->max_num_vdevs) - 1;
1391

M
Michal Kazior 已提交
1392
	INIT_LIST_HEAD(&ar->arvifs);
1393

1394 1395
	return 0;

M
Michal Kazior 已提交
1396 1397
err_hif_stop:
	ath10k_hif_stop(ar);
M
Michal Kazior 已提交
1398 1399 1400 1401
err_htt_rx_detach:
	ath10k_htt_rx_free(&ar->htt);
err_htt_tx_detach:
	ath10k_htt_tx_free(&ar->htt);
1402 1403 1404 1405 1406
err_wmi_detach:
	ath10k_wmi_detach(ar);
err:
	return status;
}
1407
EXPORT_SYMBOL(ath10k_core_start);
1408

1409 1410 1411
int ath10k_wait_for_suspend(struct ath10k *ar, u32 suspend_opt)
{
	int ret;
1412
	unsigned long time_left;
1413 1414 1415 1416 1417

	reinit_completion(&ar->target_suspend);

	ret = ath10k_wmi_pdev_suspend_target(ar, suspend_opt);
	if (ret) {
1418
		ath10k_warn(ar, "could not suspend target (%d)\n", ret);
1419 1420 1421
		return ret;
	}

1422
	time_left = wait_for_completion_timeout(&ar->target_suspend, 1 * HZ);
1423

1424
	if (!time_left) {
1425
		ath10k_warn(ar, "suspend timed out - target pause event never came\n");
1426 1427 1428 1429 1430 1431
		return -ETIMEDOUT;
	}

	return 0;
}

1432 1433
void ath10k_core_stop(struct ath10k *ar)
{
1434
	lockdep_assert_held(&ar->conf_mutex);
1435
	ath10k_debug_stop(ar);
1436

1437
	/* try to suspend target */
K
Kalle Valo 已提交
1438 1439
	if (ar->state != ATH10K_STATE_RESTARTING &&
	    ar->state != ATH10K_STATE_UTF)
1440 1441
		ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND_AND_DISABLE_INTR);

M
Michal Kazior 已提交
1442 1443 1444
	ath10k_hif_stop(ar);
	ath10k_htt_tx_free(&ar->htt);
	ath10k_htt_rx_free(&ar->htt);
1445 1446
	ath10k_wmi_detach(ar);
}
1447 1448 1449 1450 1451 1452 1453 1454
EXPORT_SYMBOL(ath10k_core_stop);

/* mac80211 manages fw/hw initialization through start/stop hooks. However in
 * order to know what hw capabilities should be advertised to mac80211 it is
 * necessary to load the firmware (and tear it down immediately since start
 * hook will try to init it again) before registering */
static int ath10k_core_probe_fw(struct ath10k *ar)
{
1455 1456
	struct bmi_target_info target_info;
	int ret = 0;
1457 1458 1459

	ret = ath10k_hif_power_up(ar);
	if (ret) {
1460
		ath10k_err(ar, "could not start pci hif (%d)\n", ret);
1461 1462 1463
		return ret;
	}

1464 1465 1466
	memset(&target_info, 0, sizeof(target_info));
	ret = ath10k_bmi_get_target_info(ar, &target_info);
	if (ret) {
1467
		ath10k_err(ar, "could not get target info (%d)\n", ret);
1468
		goto err_power_down;
1469 1470 1471 1472 1473 1474 1475
	}

	ar->target_version = target_info.version;
	ar->hw->wiphy->hw_version = target_info.version;

	ret = ath10k_init_hw_params(ar);
	if (ret) {
1476
		ath10k_err(ar, "could not get hw params (%d)\n", ret);
1477
		goto err_power_down;
1478 1479 1480 1481
	}

	ret = ath10k_core_fetch_firmware_files(ar);
	if (ret) {
1482
		ath10k_err(ar, "could not fetch firmware files (%d)\n", ret);
1483
		goto err_power_down;
1484 1485
	}

1486 1487 1488 1489 1490 1491
	ret = ath10k_core_init_firmware_features(ar);
	if (ret) {
		ath10k_err(ar, "fatal problem with firmware features: %d\n",
			   ret);
		goto err_free_firmware_files;
	}
1492

1493 1494 1495 1496 1497 1498 1499
	ret = ath10k_swap_code_seg_init(ar);
	if (ret) {
		ath10k_err(ar, "failed to initialize code swap segment: %d\n",
			   ret);
		goto err_free_firmware_files;
	}

1500 1501
	mutex_lock(&ar->conf_mutex);

K
Kalle Valo 已提交
1502
	ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
1503
	if (ret) {
1504
		ath10k_err(ar, "could not init core (%d)\n", ret);
1505
		goto err_unlock;
1506 1507
	}

M
Michal Kazior 已提交
1508
	ath10k_print_driver_info(ar);
1509
	ath10k_core_stop(ar);
1510 1511 1512

	mutex_unlock(&ar->conf_mutex);

1513 1514
	ath10k_hif_power_down(ar);
	return 0;
1515 1516 1517 1518

err_unlock:
	mutex_unlock(&ar->conf_mutex);

1519
err_free_firmware_files:
1520 1521 1522 1523 1524 1525
	ath10k_core_free_firmware_files(ar);

err_power_down:
	ath10k_hif_power_down(ar);

	return ret;
1526
}
1527

1528
static void ath10k_core_register_work(struct work_struct *work)
1529
{
1530
	struct ath10k *ar = container_of(work, struct ath10k, register_work);
1531 1532
	int status;

1533 1534
	status = ath10k_core_probe_fw(ar);
	if (status) {
1535
		ath10k_err(ar, "could not probe fw (%d)\n", status);
1536
		goto err;
1537
	}
1538

1539
	status = ath10k_mac_register(ar);
1540
	if (status) {
1541
		ath10k_err(ar, "could not register to mac80211 (%d)\n", status);
1542
		goto err_release_fw;
1543
	}
1544

1545
	status = ath10k_debug_register(ar);
1546
	if (status) {
1547
		ath10k_err(ar, "unable to initialize debugfs\n");
1548 1549 1550
		goto err_unregister_mac;
	}

1551 1552
	status = ath10k_spectral_create(ar);
	if (status) {
1553
		ath10k_err(ar, "failed to initialize spectral\n");
1554 1555 1556
		goto err_debug_destroy;
	}

1557 1558 1559 1560 1561 1562 1563
	status = ath10k_thermal_register(ar);
	if (status) {
		ath10k_err(ar, "could not register thermal device: %d\n",
			   status);
		goto err_spectral_destroy;
	}

1564 1565
	set_bit(ATH10K_FLAG_CORE_REGISTERED, &ar->dev_flags);
	return;
1566

1567 1568
err_spectral_destroy:
	ath10k_spectral_destroy(ar);
1569 1570
err_debug_destroy:
	ath10k_debug_destroy(ar);
1571 1572
err_unregister_mac:
	ath10k_mac_unregister(ar);
1573 1574
err_release_fw:
	ath10k_core_free_firmware_files(ar);
1575
err:
1576 1577 1578
	/* TODO: It's probably a good idea to release device from the driver
	 * but calling device_release_driver() here will cause a deadlock.
	 */
1579 1580 1581 1582 1583 1584 1585 1586 1587
	return;
}

int ath10k_core_register(struct ath10k *ar, u32 chip_id)
{
	ar->chip_id = chip_id;
	queue_work(ar->workqueue, &ar->register_work);

	return 0;
1588 1589 1590 1591 1592
}
EXPORT_SYMBOL(ath10k_core_register);

void ath10k_core_unregister(struct ath10k *ar)
{
1593 1594 1595 1596 1597
	cancel_work_sync(&ar->register_work);

	if (!test_bit(ATH10K_FLAG_CORE_REGISTERED, &ar->dev_flags))
		return;

1598
	ath10k_thermal_unregister(ar);
1599 1600 1601 1602 1603 1604
	/* Stop spectral before unregistering from mac80211 to remove the
	 * relayfs debugfs file cleanly. Otherwise the parent debugfs tree
	 * would be already be free'd recursively, leading to a double free.
	 */
	ath10k_spectral_destroy(ar);

1605 1606 1607 1608
	/* We must unregister from mac80211 before we stop HTC and HIF.
	 * Otherwise we will fail to submit commands to FW and mac80211 will be
	 * unhappy about callback failures. */
	ath10k_mac_unregister(ar);
1609

K
Kalle Valo 已提交
1610 1611
	ath10k_testmode_destroy(ar);

1612
	ath10k_core_free_firmware_files(ar);
1613

1614
	ath10k_debug_unregister(ar);
1615 1616 1617
}
EXPORT_SYMBOL(ath10k_core_unregister);

M
Michal Kazior 已提交
1618
struct ath10k *ath10k_core_create(size_t priv_size, struct device *dev,
K
Kalle Valo 已提交
1619
				  enum ath10k_bus bus,
M
Michal Kazior 已提交
1620
				  enum ath10k_hw_rev hw_rev,
1621 1622 1623
				  const struct ath10k_hif_ops *hif_ops)
{
	struct ath10k *ar;
1624
	int ret;
1625

M
Michal Kazior 已提交
1626
	ar = ath10k_mac_create(priv_size);
1627 1628 1629 1630 1631 1632
	if (!ar)
		return NULL;

	ar->ath_common.priv = ar;
	ar->ath_common.hw = ar->hw;
	ar->dev = dev;
M
Michal Kazior 已提交
1633
	ar->hw_rev = hw_rev;
1634
	ar->hif.ops = hif_ops;
K
Kalle Valo 已提交
1635
	ar->hif.bus = bus;
1636

M
Michal Kazior 已提交
1637 1638 1639
	switch (hw_rev) {
	case ATH10K_HW_QCA988X:
		ar->regs = &qca988x_regs;
1640
		ar->hw_values = &qca988x_values;
M
Michal Kazior 已提交
1641 1642 1643
		break;
	case ATH10K_HW_QCA6174:
		ar->regs = &qca6174_regs;
1644
		ar->hw_values = &qca6174_values;
M
Michal Kazior 已提交
1645
		break;
1646 1647 1648 1649
	case ATH10K_HW_QCA99X0:
		ar->regs = &qca99x0_regs;
		ar->hw_values = &qca99x0_values;
		break;
M
Michal Kazior 已提交
1650 1651 1652 1653 1654 1655 1656
	default:
		ath10k_err(ar, "unsupported core hardware revision %d\n",
			   hw_rev);
		ret = -ENOTSUPP;
		goto err_free_mac;
	}

1657 1658 1659 1660
	init_completion(&ar->scan.started);
	init_completion(&ar->scan.completed);
	init_completion(&ar->scan.on_channel);
	init_completion(&ar->target_suspend);
1661
	init_completion(&ar->wow.wakeup_completed);
1662 1663 1664

	init_completion(&ar->install_key_done);
	init_completion(&ar->vdev_setup_done);
1665
	init_completion(&ar->thermal.wmi_sync);
1666

1667
	INIT_DELAYED_WORK(&ar->scan.timeout, ath10k_scan_timeout_work);
1668 1669 1670

	ar->workqueue = create_singlethread_workqueue("ath10k_wq");
	if (!ar->workqueue)
1671
		goto err_free_mac;
1672

1673 1674 1675 1676
	ar->workqueue_aux = create_singlethread_workqueue("ath10k_aux_wq");
	if (!ar->workqueue_aux)
		goto err_free_wq;

1677 1678 1679 1680 1681
	mutex_init(&ar->conf_mutex);
	spin_lock_init(&ar->data_lock);

	INIT_LIST_HEAD(&ar->peers);
	init_waitqueue_head(&ar->peer_mapping_wq);
M
Michal Kazior 已提交
1682 1683
	init_waitqueue_head(&ar->htt.empty_tx_wq);
	init_waitqueue_head(&ar->wmi.tx_credits_wq);
1684 1685 1686 1687 1688 1689 1690 1691

	init_completion(&ar->offchan_tx_completed);
	INIT_WORK(&ar->offchan_tx_work, ath10k_offchan_tx_work);
	skb_queue_head_init(&ar->offchan_tx_queue);

	INIT_WORK(&ar->wmi_mgmt_tx_work, ath10k_mgmt_over_wmi_tx_work);
	skb_queue_head_init(&ar->wmi_mgmt_tx_queue);

1692
	INIT_WORK(&ar->register_work, ath10k_core_register_work);
1693 1694
	INIT_WORK(&ar->restart_work, ath10k_core_restart);

1695 1696
	ret = ath10k_debug_create(ar);
	if (ret)
1697
		goto err_free_aux_wq;
1698

1699 1700
	return ar;

1701 1702
err_free_aux_wq:
	destroy_workqueue(ar->workqueue_aux);
1703 1704 1705 1706
err_free_wq:
	destroy_workqueue(ar->workqueue);

err_free_mac:
1707
	ath10k_mac_destroy(ar);
1708

1709 1710 1711 1712 1713 1714 1715 1716 1717
	return NULL;
}
EXPORT_SYMBOL(ath10k_core_create);

void ath10k_core_destroy(struct ath10k *ar)
{
	flush_workqueue(ar->workqueue);
	destroy_workqueue(ar->workqueue);

1718 1719 1720
	flush_workqueue(ar->workqueue_aux);
	destroy_workqueue(ar->workqueue_aux);

1721
	ath10k_debug_destroy(ar);
1722
	ath10k_wmi_free_host_mem(ar);
1723 1724 1725 1726
	ath10k_mac_destroy(ar);
}
EXPORT_SYMBOL(ath10k_core_destroy);

1727 1728 1729
MODULE_AUTHOR("Qualcomm Atheros");
MODULE_DESCRIPTION("Core module for QCA988X PCIe devices.");
MODULE_LICENSE("Dual BSD/GPL");