core.c 41.9 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 58 59 60 61
		.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,
62 63
			.board_size = QCA988X_BOARD_DATA_SZ,
			.board_ext_size = QCA988X_BOARD_EXT_DATA_SZ,
64 65
		},
	},
M
Michal Kazior 已提交
66 67 68 69 70
	{
		.id = QCA6174_HW_2_1_VERSION,
		.name = "qca6174 hw2.1",
		.patch_load_addr = QCA6174_HW_2_1_PATCH_LOAD_ADDR,
		.uart_pin = 6,
71
		.otp_exe_param = 0,
72
		.channel_counters_freq_hz = 88000,
M
Michal Kazior 已提交
73 74 75 76 77 78 79 80 81 82 83 84 85 86
		.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,
87
		.otp_exe_param = 0,
88
		.channel_counters_freq_hz = 88000,
M
Michal Kazior 已提交
89 90 91 92 93 94 95 96 97
		.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 已提交
98 99 100 101 102
	{
		.id = QCA6174_HW_3_2_VERSION,
		.name = "qca6174 hw3.2",
		.patch_load_addr = QCA6174_HW_3_0_PATCH_LOAD_ADDR,
		.uart_pin = 6,
103
		.otp_exe_param = 0,
104
		.channel_counters_freq_hz = 88000,
M
Michal Kazior 已提交
105 106 107 108 109 110 111 112 113 114
		.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,
		},
	},
115 116 117 118 119
	{
		.id = QCA99X0_HW_2_0_DEV_VERSION,
		.name = "qca99x0 hw2.0",
		.patch_load_addr = QCA99X0_HW_2_0_PATCH_LOAD_ADDR,
		.uart_pin = 7,
120
		.otp_exe_param = 0x00000700,
121
		.continuous_frag_desc = true,
122
		.channel_counters_freq_hz = 150000,
123 124 125 126 127 128 129 130 131
		.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,
		},
	},
132 133
};

134 135 136 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
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);
		}
	}
}

178 179
static void ath10k_send_suspend_complete(struct ath10k *ar)
{
180
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot suspend complete\n");
181

182
	complete(&ar->target_suspend);
183 184 185 186 187 188 189 190 191 192 193
}

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) {
194
		ath10k_err(ar, "settings HTC version failed\n");
195 196 197 198 199 200
		return ret;
	}

	/* set the firmware mode to STA/IBSS/AP */
	ret = ath10k_bmi_read32(ar, hi_option_flag, &param_host);
	if (ret) {
201
		ath10k_err(ar, "setting firmware mode (1/2) failed\n");
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
		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) {
220
		ath10k_err(ar, "setting firmware mode (2/2) failed\n");
221 222 223 224 225 226
		return ret;
	}

	/* We do all byte-swapping on the host */
	ret = ath10k_bmi_write32(ar, hi_be, 0);
	if (ret) {
227
		ath10k_err(ar, "setting host CPU BE mode failed\n");
228 229 230 231 232 233 234
		return ret;
	}

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

	if (ret) {
235
		ath10k_err(ar, "setting FW data/desc swap flags failed\n");
236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
		return ret;
	}

	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;
}

264 265
static int ath10k_push_board_ext_data(struct ath10k *ar, const void *data,
				      size_t data_len)
266
{
267 268
	u32 board_data_size = ar->hw_params.fw.board_size;
	u32 board_ext_data_size = ar->hw_params.fw.board_ext_size;
269 270 271 272 273
	u32 board_ext_data_addr;
	int ret;

	ret = ath10k_bmi_read32(ar, hi_board_ext_data, &board_ext_data_addr);
	if (ret) {
274 275
		ath10k_err(ar, "could not read board ext data addr (%d)\n",
			   ret);
276 277 278
		return ret;
	}

279
	ath10k_dbg(ar, ATH10K_DBG_BOOT,
280
		   "boot push board extended data addr 0x%x\n",
281 282 283 284 285
		   board_ext_data_addr);

	if (board_ext_data_addr == 0)
		return 0;

286
	if (data_len != (board_data_size + board_ext_data_size)) {
287
		ath10k_err(ar, "invalid board (ext) data sizes %zu != %d+%d\n",
288
			   data_len, board_data_size, board_ext_data_size);
289 290 291 292
		return -EINVAL;
	}

	ret = ath10k_bmi_write_memory(ar, board_ext_data_addr,
293
				      data + board_data_size,
294 295
				      board_ext_data_size);
	if (ret) {
296
		ath10k_err(ar, "could not write board ext data (%d)\n", ret);
297 298 299 300 301 302
		return ret;
	}

	ret = ath10k_bmi_write32(ar, hi_board_ext_data_config,
				 (board_ext_data_size << 16) | 1);
	if (ret) {
303 304
		ath10k_err(ar, "could not write board ext data bit (%d)\n",
			   ret);
305 306 307 308 309 310
		return ret;
	}

	return 0;
}

311 312
static int ath10k_download_board_data(struct ath10k *ar, const void *data,
				      size_t data_len)
313
{
314
	u32 board_data_size = ar->hw_params.fw.board_size;
315 316 317
	u32 address;
	int ret;

318
	ret = ath10k_push_board_ext_data(ar, data, data_len);
319
	if (ret) {
320
		ath10k_err(ar, "could not push board ext data (%d)\n", ret);
321 322 323 324 325
		goto exit;
	}

	ret = ath10k_bmi_read32(ar, hi_board_data, &address);
	if (ret) {
326
		ath10k_err(ar, "could not read board data addr (%d)\n", ret);
327 328 329
		goto exit;
	}

330
	ret = ath10k_bmi_write_memory(ar, address, data,
331
				      min_t(u32, board_data_size,
332
					    data_len));
333
	if (ret) {
334
		ath10k_err(ar, "could not write board data (%d)\n", ret);
335 336 337 338 339
		goto exit;
	}

	ret = ath10k_bmi_write32(ar, hi_board_data_initialized, 1);
	if (ret) {
340
		ath10k_err(ar, "could not write board data bit (%d)\n", ret);
341 342 343 344 345 346 347
		goto exit;
	}

exit:
	return ret;
}

348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369
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;
}

370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 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
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;
}

427 428
static int ath10k_download_and_run_otp(struct ath10k *ar)
{
429
	u32 result, address = ar->hw_params.patch_load_addr;
430
	u32 bmi_otp_exe_param = ar->hw_params.otp_exe_param;
431 432
	int ret;

433
	ret = ath10k_download_board_data(ar, ar->board_data, ar->board_len);
434 435 436 437 438
	if (ret) {
		ath10k_err(ar, "failed to download board data: %d\n", ret);
		return ret;
	}

439 440
	/* OTP is optional */

K
Kalle Valo 已提交
441
	if (!ar->otp_data || !ar->otp_len) {
442
		ath10k_warn(ar, "Not running otp, calibration will be incorrect (otp-data %p otp_len %zd)!\n",
443
			    ar->otp_data, ar->otp_len);
444
		return 0;
K
Kalle Valo 已提交
445 446
	}

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

450
	ret = ath10k_bmi_fast_download(ar, address, ar->otp_data, ar->otp_len);
451
	if (ret) {
452
		ath10k_err(ar, "could not write otp (%d)\n", ret);
K
Kalle Valo 已提交
453
		return ret;
454 455
	}

456
	ret = ath10k_bmi_execute(ar, address, bmi_otp_exe_param, &result);
457
	if (ret) {
458
		ath10k_err(ar, "could not execute otp (%d)\n", ret);
K
Kalle Valo 已提交
459
		return ret;
460 461
	}

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

464 465 466
	if (!(skip_otp || test_bit(ATH10K_FW_FEATURE_IGNORE_OTP_RESULT,
				   ar->fw_features))
	    && result != 0) {
467
		ath10k_err(ar, "otp calibration failed: %d", result);
K
Kalle Valo 已提交
468 469 470 471
		return -EINVAL;
	}

	return 0;
472 473
}

K
Kalle Valo 已提交
474
static int ath10k_download_fw(struct ath10k *ar, enum ath10k_firmware_mode mode)
475
{
K
Kalle Valo 已提交
476 477 478
	u32 address, data_len;
	const char *mode_name;
	const void *data;
479 480 481 482
	int ret;

	address = ar->hw_params.patch_load_addr;

K
Kalle Valo 已提交
483 484 485 486 487
	switch (mode) {
	case ATH10K_FIRMWARE_MODE_NORMAL:
		data = ar->firmware_data;
		data_len = ar->firmware_len;
		mode_name = "normal";
488 489 490 491 492 493 494
		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 已提交
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
		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);
511
	if (ret) {
K
Kalle Valo 已提交
512 513 514
		ath10k_err(ar, "failed to download %s firmware: %d\n",
			   mode_name, ret);
		return ret;
515 516
	}

517 518 519 520 521
	return ret;
}

static void ath10k_core_free_firmware_files(struct ath10k *ar)
{
522
	if (!IS_ERR(ar->board))
523
		release_firmware(ar->board);
524

525
	if (!IS_ERR(ar->otp))
526 527
		release_firmware(ar->otp);

528
	if (!IS_ERR(ar->firmware))
529 530
		release_firmware(ar->firmware);

531
	if (!IS_ERR(ar->cal_file))
532 533
		release_firmware(ar->cal_file);

534 535
	ath10k_swap_code_seg_release(ar);

536
	ar->board = NULL;
537 538 539
	ar->board_data = NULL;
	ar->board_len = 0;

540
	ar->otp = NULL;
541 542 543
	ar->otp_data = NULL;
	ar->otp_len = 0;

544
	ar->firmware = NULL;
545 546
	ar->firmware_data = NULL;
	ar->firmware_len = 0;
547 548

	ar->cal_file = NULL;
549

550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568
}

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;
569 570
}

571
static int ath10k_core_fetch_spec_board_file(struct ath10k *ar)
572
{
573 574 575 576 577 578 579 580 581 582 583 584
	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;
585

586 587 588 589 590
	return 0;
}

static int ath10k_core_fetch_generic_board_file(struct ath10k *ar)
{
591 592
	if (!ar->hw_params.fw.board) {
		ath10k_err(ar, "failed to find board file fw entry\n");
593 594 595
		return -EINVAL;
	}

596 597 598
	ar->board = ath10k_fetch_fw_file(ar,
					 ar->hw_params.fw.dir,
					 ar->hw_params.fw.board);
599 600
	if (IS_ERR(ar->board))
		return PTR_ERR(ar->board);
601

602 603
	ar->board_data = ar->board->data;
	ar->board_len = ar->board->size;
604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631
	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;
	}
632

633 634 635 636 637 638 639 640 641 642 643 644
	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;
	}

645 646 647 648 649
	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);
650
		ath10k_err(ar, "could not fetch firmware (%d)\n", ret);
651 652 653
		goto err;
	}

654 655 656
	ar->firmware_data = ar->firmware->data;
	ar->firmware_len = ar->firmware->size;

657 658 659 660 661 662 663 664 665
	/* 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);
666
		ath10k_err(ar, "could not fetch otp (%d)\n", ret);
667 668 669
		goto err;
	}

670 671 672
	ar->otp_data = ar->otp->data;
	ar->otp_len = ar->otp->size;

673 674 675 676
	return 0;

err:
	ath10k_core_free_firmware_files(ar);
677 678 679
	return ret;
}

680 681 682 683 684 685
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;
686
	__le32 *timestamp, *version;
687 688 689 690

	/* 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)) {
691
		ath10k_err(ar, "could not fetch firmware file '%s/%s': %ld\n",
692
			   ar->hw_params.fw.dir, name, PTR_ERR(ar->firmware));
693 694 695 696 697 698 699 700 701 702
		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) {
703
		ath10k_err(ar, "firmware file '%s/%s' too small to contain magic: %zu\n",
704
			   ar->hw_params.fw.dir, name, len);
705 706
		ret = -EINVAL;
		goto err;
707 708 709
	}

	if (memcmp(data, ATH10K_FIRMWARE_MAGIC, magic_len) != 0) {
710
		ath10k_err(ar, "invalid firmware magic\n");
711 712
		ret = -EINVAL;
		goto err;
713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731
	}

	/* 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) {
732
			ath10k_err(ar, "invalid length for FW IE %d (%zu < %zu)\n",
733
				   ie_id, len, ie_len);
734 735
			ret = -EINVAL;
			goto err;
736 737 738 739 740 741 742 743 744 745
		}

		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';

746
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
747 748 749 750 751 752 753 754 755
				   "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;

756
			ath10k_dbg(ar, ATH10K_DBG_BOOT, "found fw timestamp %d\n",
757 758 759
				   le32_to_cpup(timestamp));
			break;
		case ATH10K_FW_IE_FEATURES:
760
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
761 762 763 764 765 766 767 768 769 770
				   "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;

771
				if (data[index] & (1 << bit)) {
772
					ath10k_dbg(ar, ATH10K_DBG_BOOT,
773 774
						   "Enabling feature bit: %i\n",
						   i);
775
					__set_bit(i, ar->fw_features);
776
				}
777 778
			}

779
			ath10k_dbg_dump(ar, ATH10K_DBG_BOOT, "features", "",
780 781 782 783
					ar->fw_features,
					sizeof(ar->fw_features));
			break;
		case ATH10K_FW_IE_FW_IMAGE:
784
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
785 786 787 788 789 790 791 792
				   "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:
793
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
794 795 796 797 798 799 800
				   "found otp image ie (%zd B)\n",
				   ie_len);

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

			break;
801 802 803 804 805 806 807 808 809 810 811
		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;
812 813 814 815 816 817 818 819 820 821 822
		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;
823 824 825 826 827 828 829
		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;
830
		default:
831
			ath10k_warn(ar, "Unknown FW IE: %u\n",
832 833 834 835 836 837 838 839 840
				    le32_to_cpu(hdr->id));
			break;
		}

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

		len -= ie_len;
		data += ie_len;
841
	}
842 843

	if (!ar->firmware_data || !ar->firmware_len) {
844
		ath10k_warn(ar, "No ATH10K_FW_IE_FW_IMAGE found from '%s/%s', skipping\n",
845
			    ar->hw_params.fw.dir, name);
846 847 848 849 850 851 852 853 854 855 856 857 858 859 860
		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;

861 862 863
	/* calibration file is optional, don't check for any errors */
	ath10k_fetch_cal_file(ar);

864 865 866 867 868 869
	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 已提交
870 871 872 873 874 875 876
	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;

877 878 879 880 881 882 883
	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;

884
	ar->fw_api = 3;
885
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
886 887 888 889 890

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

891
	ar->fw_api = 2;
892
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
893

894
	ret = ath10k_core_fetch_firmware_api_n(ar, ATH10K_FW_API2_FILE);
895 896 897 898
	if (ret == 0)
		goto success;

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

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

905
success:
906
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "using fw api %d\n", ar->fw_api);
907 908 909 910

	return 0;
}

911
static int ath10k_download_cal_data(struct ath10k *ar)
912 913 914
{
	int ret;

915 916 917 918 919 920 921
	ret = ath10k_download_cal_file(ar);
	if (ret == 0) {
		ar->cal_mode = ATH10K_CAL_MODE_FILE;
		goto done;
	}

	ath10k_dbg(ar, ATH10K_DBG_BOOT,
922 923 924 925 926 927 928 929 930 931 932
		   "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",
933 934
		   ret);

935
	ret = ath10k_download_and_run_otp(ar);
936
	if (ret) {
937
		ath10k_err(ar, "failed to run otp: %d\n", ret);
938
		return ret;
939
	}
940

941 942 943 944 945 946
	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;
947 948 949 950 951 952 953 954 955 956 957 958
}

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) {
959
		ath10k_warn(ar, "could not disable UART prints (%d)\n", ret);
960 961 962
		return ret;
	}

963
	if (!uart_print)
964 965
		return 0;

966
	ret = ath10k_bmi_write32(ar, hi_dbg_uart_txpin, ar->hw_params.uart_pin);
967
	if (ret) {
968
		ath10k_warn(ar, "could not enable UART prints (%d)\n", ret);
969 970 971 972 973
		return ret;
	}

	ret = ath10k_bmi_write32(ar, hi_serial_enable, 1);
	if (ret) {
974
		ath10k_warn(ar, "could not enable UART prints (%d)\n", ret);
975 976 977
		return ret;
	}

978 979 980
	/* Set the UART baud rate to 19200. */
	ret = ath10k_bmi_write32(ar, hi_desired_baud_rate, 19200);
	if (ret) {
981
		ath10k_warn(ar, "could not set the baud rate (%d)\n", ret);
982 983 984
		return ret;
	}

985
	ath10k_info(ar, "UART prints enabled\n");
986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001
	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)) {
1002
		ath10k_err(ar, "Unsupported hardware version: 0x%x\n",
1003 1004 1005 1006 1007 1008
			   ar->target_version);
		return -EINVAL;
	}

	ar->hw_params = *hw_params;

1009
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "Hardware name %s version 0x%x\n",
1010
		   ar->hw_params.name, ar->target_version);
1011 1012 1013 1014

	return 0;
}

1015 1016 1017 1018
static void ath10k_core_restart(struct work_struct *work)
{
	struct ath10k *ar = container_of(work, struct ath10k, restart_work);

M
Michal Kazior 已提交
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
	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);
1034
	complete_all(&ar->thermal.wmi_sync);
M
Michal Kazior 已提交
1035 1036 1037 1038
	wake_up(&ar->htt.empty_tx_wq);
	wake_up(&ar->wmi.tx_credits_wq);
	wake_up(&ar->peer_mapping_wq);

1039 1040 1041 1042 1043
	mutex_lock(&ar->conf_mutex);

	switch (ar->state) {
	case ATH10K_STATE_ON:
		ar->state = ATH10K_STATE_RESTARTING;
1044
		ath10k_hif_stop(ar);
1045
		ath10k_scan_finish(ar);
1046 1047 1048
		ieee80211_restart_hw(ar->hw);
		break;
	case ATH10K_STATE_OFF:
1049 1050
		/* this can happen if driver is being unloaded
		 * or if the crash happens during FW probing */
1051
		ath10k_warn(ar, "cannot restart a device that hasn't been started\n");
1052 1053
		break;
	case ATH10K_STATE_RESTARTING:
1054 1055
		/* hw restart might be requested from multiple places */
		break;
1056 1057 1058 1059
	case ATH10K_STATE_RESTARTED:
		ar->state = ATH10K_STATE_WEDGED;
		/* fall through */
	case ATH10K_STATE_WEDGED:
1060
		ath10k_warn(ar, "device is wedged, will not restart\n");
1061
		break;
K
Kalle Valo 已提交
1062 1063 1064
	case ATH10K_STATE_UTF:
		ath10k_warn(ar, "firmware restart in UTF mode not supported\n");
		break;
1065 1066 1067 1068 1069
	}

	mutex_unlock(&ar->conf_mutex);
}

1070
static int ath10k_core_init_firmware_features(struct ath10k *ar)
1071
{
1072 1073 1074 1075 1076 1077
	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;
	}

1078 1079 1080 1081 1082 1083
	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;
	}

1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
	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;
	}

1124 1125 1126 1127 1128
	/* 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)) {
1129 1130
			if (test_bit(ATH10K_FW_FEATURE_WMI_10_2,
				     ar->fw_features))
1131 1132 1133 1134 1135 1136 1137 1138 1139 1140
				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:
1141 1142
		ar->max_num_peers = TARGET_NUM_PEERS;
		ar->max_num_stations = TARGET_NUM_STATIONS;
1143
		ar->max_num_vdevs = TARGET_NUM_VDEVS;
1144
		ar->htt.max_num_pending_tx = TARGET_NUM_MSDU_DESC;
1145 1146
		ar->fw_stats_req_mask = WMI_STAT_PDEV | WMI_STAT_VDEV |
			WMI_STAT_PEER;
1147
		ar->max_spatial_stream = WMI_MAX_SPATIAL_STREAM;
1148 1149 1150
		break;
	case ATH10K_FW_WMI_OP_VERSION_10_1:
	case ATH10K_FW_WMI_OP_VERSION_10_2:
1151
	case ATH10K_FW_WMI_OP_VERSION_10_2_4:
1152 1153
		ar->max_num_peers = TARGET_10X_NUM_PEERS;
		ar->max_num_stations = TARGET_10X_NUM_STATIONS;
1154
		ar->max_num_vdevs = TARGET_10X_NUM_VDEVS;
1155
		ar->htt.max_num_pending_tx = TARGET_10X_NUM_MSDU_DESC;
1156
		ar->fw_stats_req_mask = WMI_STAT_PEER;
1157
		ar->max_spatial_stream = WMI_MAX_SPATIAL_STREAM;
1158
		break;
M
Michal Kazior 已提交
1159 1160 1161
	case ATH10K_FW_WMI_OP_VERSION_TLV:
		ar->max_num_peers = TARGET_TLV_NUM_PEERS;
		ar->max_num_stations = TARGET_TLV_NUM_STATIONS;
1162
		ar->max_num_vdevs = TARGET_TLV_NUM_VDEVS;
1163
		ar->max_num_tdls_vdevs = TARGET_TLV_NUM_TDLS_VDEVS;
M
Michal Kazior 已提交
1164
		ar->htt.max_num_pending_tx = TARGET_TLV_NUM_MSDU_DESC;
1165
		ar->wow.max_num_patterns = TARGET_TLV_NUM_WOW_PATTERNS;
1166 1167
		ar->fw_stats_req_mask = WMI_STAT_PDEV | WMI_STAT_VDEV |
			WMI_STAT_PEER;
1168
		ar->max_spatial_stream = WMI_MAX_SPATIAL_STREAM;
M
Michal Kazior 已提交
1169
		break;
1170
	case ATH10K_FW_WMI_OP_VERSION_10_4:
1171 1172 1173 1174 1175
		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;
1176
		ar->htt.max_num_pending_tx = TARGET_10_4_NUM_MSDU_DESC;
1177
		ar->fw_stats_req_mask = WMI_STAT_PEER;
1178
		ar->max_spatial_stream = WMI_10_4_MAX_SPATIAL_STREAM;
1179
		break;
1180 1181 1182 1183
	case ATH10K_FW_WMI_OP_VERSION_UNSET:
	case ATH10K_FW_WMI_OP_VERSION_MAX:
		WARN_ON(1);
		return -EINVAL;
1184
	}
1185

1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201
	/* 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;
1202
		case ATH10K_FW_WMI_OP_VERSION_10_4:
1203 1204 1205 1206 1207 1208 1209
		case ATH10K_FW_WMI_OP_VERSION_UNSET:
		case ATH10K_FW_WMI_OP_VERSION_MAX:
			WARN_ON(1);
			return -EINVAL;
		}
	}

1210
	return 0;
1211 1212
}

K
Kalle Valo 已提交
1213
int ath10k_core_start(struct ath10k *ar, enum ath10k_firmware_mode mode)
1214 1215 1216
{
	int status;

1217 1218
	lockdep_assert_held(&ar->conf_mutex);

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

1221 1222
	ath10k_bmi_start(ar);

1223 1224 1225 1226 1227
	if (ath10k_init_configure_target(ar)) {
		status = -EINVAL;
		goto err;
	}

1228 1229 1230 1231
	status = ath10k_download_cal_data(ar);
	if (status)
		goto err;

1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247
	/* 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;
		}
	}

1248
	status = ath10k_download_fw(ar, mode);
1249 1250 1251 1252 1253 1254 1255
	if (status)
		goto err;

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

1256 1257
	ar->htc.htc_ops.target_send_suspend_complete =
		ath10k_send_suspend_complete;
1258

1259 1260
	status = ath10k_htc_init(ar);
	if (status) {
1261
		ath10k_err(ar, "could not init HTC (%d)\n", status);
1262 1263 1264 1265 1266
		goto err;
	}

	status = ath10k_bmi_done(ar);
	if (status)
1267
		goto err;
1268 1269 1270

	status = ath10k_wmi_attach(ar);
	if (status) {
1271
		ath10k_err(ar, "WMI attach failed: %d\n", status);
1272
		goto err;
1273 1274
	}

M
Michal Kazior 已提交
1275 1276
	status = ath10k_htt_init(ar);
	if (status) {
1277
		ath10k_err(ar, "failed to init htt: %d\n", status);
M
Michal Kazior 已提交
1278 1279 1280 1281 1282
		goto err_wmi_detach;
	}

	status = ath10k_htt_tx_alloc(&ar->htt);
	if (status) {
1283
		ath10k_err(ar, "failed to alloc htt tx: %d\n", status);
M
Michal Kazior 已提交
1284 1285 1286 1287 1288
		goto err_wmi_detach;
	}

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

M
Michal Kazior 已提交
1293 1294
	status = ath10k_hif_start(ar);
	if (status) {
1295
		ath10k_err(ar, "could not start HIF: %d\n", status);
M
Michal Kazior 已提交
1296
		goto err_htt_rx_detach;
M
Michal Kazior 已提交
1297 1298 1299 1300
	}

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

K
Kalle Valo 已提交
1305 1306 1307 1308 1309 1310
	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;
		}
1311 1312
	}

M
Michal Kazior 已提交
1313 1314
	status = ath10k_wmi_connect(ar);
	if (status) {
1315
		ath10k_err(ar, "could not connect wmi: %d\n", status);
M
Michal Kazior 已提交
1316 1317 1318 1319 1320
		goto err_hif_stop;
	}

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

K
Kalle Valo 已提交
1325 1326
	if (mode == ATH10K_FIRMWARE_MODE_NORMAL) {
		status = ath10k_wmi_wait_for_service_ready(ar);
1327
		if (status) {
K
Kalle Valo 已提交
1328 1329 1330
			ath10k_warn(ar, "wmi service ready event not received");
			goto err_hif_stop;
		}
M
Michal Kazior 已提交
1331
	}
1332

1333
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "firmware %s booted\n",
1334
		   ar->hw->wiphy->fw_version);
1335 1336 1337

	status = ath10k_wmi_cmd_init(ar);
	if (status) {
1338 1339
		ath10k_err(ar, "could not send WMI init command (%d)\n",
			   status);
M
Michal Kazior 已提交
1340
		goto err_hif_stop;
1341 1342 1343
	}

	status = ath10k_wmi_wait_for_unified_ready(ar);
1344
	if (status) {
1345
		ath10k_err(ar, "wmi unified ready event not received\n");
M
Michal Kazior 已提交
1346
		goto err_hif_stop;
1347 1348
	}

1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360
	/* 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 已提交
1361 1362 1363 1364 1365 1366 1367
	/* 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 已提交
1368
	}
1369

1370 1371
	status = ath10k_debug_start(ar);
	if (status)
M
Michal Kazior 已提交
1372
		goto err_hif_stop;
1373

1374
	ar->free_vdev_map = (1LL << ar->max_num_vdevs) - 1;
1375

M
Michal Kazior 已提交
1376
	INIT_LIST_HEAD(&ar->arvifs);
1377

1378 1379
	return 0;

M
Michal Kazior 已提交
1380 1381
err_hif_stop:
	ath10k_hif_stop(ar);
M
Michal Kazior 已提交
1382 1383 1384 1385
err_htt_rx_detach:
	ath10k_htt_rx_free(&ar->htt);
err_htt_tx_detach:
	ath10k_htt_tx_free(&ar->htt);
1386 1387 1388 1389 1390
err_wmi_detach:
	ath10k_wmi_detach(ar);
err:
	return status;
}
1391
EXPORT_SYMBOL(ath10k_core_start);
1392

1393 1394 1395
int ath10k_wait_for_suspend(struct ath10k *ar, u32 suspend_opt)
{
	int ret;
1396
	unsigned long time_left;
1397 1398 1399 1400 1401

	reinit_completion(&ar->target_suspend);

	ret = ath10k_wmi_pdev_suspend_target(ar, suspend_opt);
	if (ret) {
1402
		ath10k_warn(ar, "could not suspend target (%d)\n", ret);
1403 1404 1405
		return ret;
	}

1406
	time_left = wait_for_completion_timeout(&ar->target_suspend, 1 * HZ);
1407

1408
	if (!time_left) {
1409
		ath10k_warn(ar, "suspend timed out - target pause event never came\n");
1410 1411 1412 1413 1414 1415
		return -ETIMEDOUT;
	}

	return 0;
}

1416 1417
void ath10k_core_stop(struct ath10k *ar)
{
1418
	lockdep_assert_held(&ar->conf_mutex);
1419
	ath10k_debug_stop(ar);
1420

1421
	/* try to suspend target */
K
Kalle Valo 已提交
1422 1423
	if (ar->state != ATH10K_STATE_RESTARTING &&
	    ar->state != ATH10K_STATE_UTF)
1424 1425
		ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND_AND_DISABLE_INTR);

M
Michal Kazior 已提交
1426 1427 1428
	ath10k_hif_stop(ar);
	ath10k_htt_tx_free(&ar->htt);
	ath10k_htt_rx_free(&ar->htt);
1429 1430
	ath10k_wmi_detach(ar);
}
1431 1432 1433 1434 1435 1436 1437 1438
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)
{
1439 1440
	struct bmi_target_info target_info;
	int ret = 0;
1441 1442 1443

	ret = ath10k_hif_power_up(ar);
	if (ret) {
1444
		ath10k_err(ar, "could not start pci hif (%d)\n", ret);
1445 1446 1447
		return ret;
	}

1448 1449 1450
	memset(&target_info, 0, sizeof(target_info));
	ret = ath10k_bmi_get_target_info(ar, &target_info);
	if (ret) {
1451
		ath10k_err(ar, "could not get target info (%d)\n", ret);
1452
		goto err_power_down;
1453 1454 1455 1456 1457 1458 1459
	}

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

	ret = ath10k_init_hw_params(ar);
	if (ret) {
1460
		ath10k_err(ar, "could not get hw params (%d)\n", ret);
1461
		goto err_power_down;
1462 1463 1464 1465
	}

	ret = ath10k_core_fetch_firmware_files(ar);
	if (ret) {
1466
		ath10k_err(ar, "could not fetch firmware files (%d)\n", ret);
1467
		goto err_power_down;
1468 1469
	}

1470 1471 1472 1473 1474 1475
	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;
	}
1476

1477 1478 1479 1480 1481 1482 1483
	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;
	}

1484 1485
	mutex_lock(&ar->conf_mutex);

K
Kalle Valo 已提交
1486
	ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
1487
	if (ret) {
1488
		ath10k_err(ar, "could not init core (%d)\n", ret);
1489
		goto err_unlock;
1490 1491
	}

M
Michal Kazior 已提交
1492
	ath10k_print_driver_info(ar);
1493
	ath10k_core_stop(ar);
1494 1495 1496

	mutex_unlock(&ar->conf_mutex);

1497 1498
	ath10k_hif_power_down(ar);
	return 0;
1499 1500 1501 1502

err_unlock:
	mutex_unlock(&ar->conf_mutex);

1503
err_free_firmware_files:
1504 1505 1506 1507 1508 1509
	ath10k_core_free_firmware_files(ar);

err_power_down:
	ath10k_hif_power_down(ar);

	return ret;
1510
}
1511

1512
static void ath10k_core_register_work(struct work_struct *work)
1513
{
1514
	struct ath10k *ar = container_of(work, struct ath10k, register_work);
1515 1516
	int status;

1517 1518
	status = ath10k_core_probe_fw(ar);
	if (status) {
1519
		ath10k_err(ar, "could not probe fw (%d)\n", status);
1520
		goto err;
1521
	}
1522

1523
	status = ath10k_mac_register(ar);
1524
	if (status) {
1525
		ath10k_err(ar, "could not register to mac80211 (%d)\n", status);
1526
		goto err_release_fw;
1527
	}
1528

1529
	status = ath10k_debug_register(ar);
1530
	if (status) {
1531
		ath10k_err(ar, "unable to initialize debugfs\n");
1532 1533 1534
		goto err_unregister_mac;
	}

1535 1536
	status = ath10k_spectral_create(ar);
	if (status) {
1537
		ath10k_err(ar, "failed to initialize spectral\n");
1538 1539 1540
		goto err_debug_destroy;
	}

1541 1542 1543 1544 1545 1546 1547
	status = ath10k_thermal_register(ar);
	if (status) {
		ath10k_err(ar, "could not register thermal device: %d\n",
			   status);
		goto err_spectral_destroy;
	}

1548 1549
	set_bit(ATH10K_FLAG_CORE_REGISTERED, &ar->dev_flags);
	return;
1550

1551 1552
err_spectral_destroy:
	ath10k_spectral_destroy(ar);
1553 1554
err_debug_destroy:
	ath10k_debug_destroy(ar);
1555 1556
err_unregister_mac:
	ath10k_mac_unregister(ar);
1557 1558
err_release_fw:
	ath10k_core_free_firmware_files(ar);
1559
err:
1560 1561 1562
	/* TODO: It's probably a good idea to release device from the driver
	 * but calling device_release_driver() here will cause a deadlock.
	 */
1563 1564 1565 1566 1567 1568 1569 1570 1571
	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;
1572 1573 1574 1575 1576
}
EXPORT_SYMBOL(ath10k_core_register);

void ath10k_core_unregister(struct ath10k *ar)
{
1577 1578 1579 1580 1581
	cancel_work_sync(&ar->register_work);

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

1582
	ath10k_thermal_unregister(ar);
1583 1584 1585 1586 1587 1588
	/* 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);

1589 1590 1591 1592
	/* 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);
1593

K
Kalle Valo 已提交
1594 1595
	ath10k_testmode_destroy(ar);

1596
	ath10k_core_free_firmware_files(ar);
1597

1598
	ath10k_debug_unregister(ar);
1599 1600 1601
}
EXPORT_SYMBOL(ath10k_core_unregister);

M
Michal Kazior 已提交
1602
struct ath10k *ath10k_core_create(size_t priv_size, struct device *dev,
K
Kalle Valo 已提交
1603
				  enum ath10k_bus bus,
M
Michal Kazior 已提交
1604
				  enum ath10k_hw_rev hw_rev,
1605 1606 1607
				  const struct ath10k_hif_ops *hif_ops)
{
	struct ath10k *ar;
1608
	int ret;
1609

M
Michal Kazior 已提交
1610
	ar = ath10k_mac_create(priv_size);
1611 1612 1613 1614 1615 1616
	if (!ar)
		return NULL;

	ar->ath_common.priv = ar;
	ar->ath_common.hw = ar->hw;
	ar->dev = dev;
M
Michal Kazior 已提交
1617
	ar->hw_rev = hw_rev;
1618
	ar->hif.ops = hif_ops;
K
Kalle Valo 已提交
1619
	ar->hif.bus = bus;
1620

M
Michal Kazior 已提交
1621 1622 1623
	switch (hw_rev) {
	case ATH10K_HW_QCA988X:
		ar->regs = &qca988x_regs;
1624
		ar->hw_values = &qca988x_values;
M
Michal Kazior 已提交
1625 1626 1627
		break;
	case ATH10K_HW_QCA6174:
		ar->regs = &qca6174_regs;
1628
		ar->hw_values = &qca6174_values;
M
Michal Kazior 已提交
1629
		break;
1630 1631 1632 1633
	case ATH10K_HW_QCA99X0:
		ar->regs = &qca99x0_regs;
		ar->hw_values = &qca99x0_values;
		break;
M
Michal Kazior 已提交
1634 1635 1636 1637 1638 1639 1640
	default:
		ath10k_err(ar, "unsupported core hardware revision %d\n",
			   hw_rev);
		ret = -ENOTSUPP;
		goto err_free_mac;
	}

1641 1642 1643 1644
	init_completion(&ar->scan.started);
	init_completion(&ar->scan.completed);
	init_completion(&ar->scan.on_channel);
	init_completion(&ar->target_suspend);
1645
	init_completion(&ar->wow.wakeup_completed);
1646 1647 1648

	init_completion(&ar->install_key_done);
	init_completion(&ar->vdev_setup_done);
1649
	init_completion(&ar->thermal.wmi_sync);
1650

1651
	INIT_DELAYED_WORK(&ar->scan.timeout, ath10k_scan_timeout_work);
1652 1653 1654

	ar->workqueue = create_singlethread_workqueue("ath10k_wq");
	if (!ar->workqueue)
1655
		goto err_free_mac;
1656

1657 1658 1659 1660
	ar->workqueue_aux = create_singlethread_workqueue("ath10k_aux_wq");
	if (!ar->workqueue_aux)
		goto err_free_wq;

1661 1662 1663 1664 1665
	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 已提交
1666 1667
	init_waitqueue_head(&ar->htt.empty_tx_wq);
	init_waitqueue_head(&ar->wmi.tx_credits_wq);
1668 1669 1670 1671 1672 1673 1674 1675

	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);

1676
	INIT_WORK(&ar->register_work, ath10k_core_register_work);
1677 1678
	INIT_WORK(&ar->restart_work, ath10k_core_restart);

1679 1680
	ret = ath10k_debug_create(ar);
	if (ret)
1681
		goto err_free_aux_wq;
1682

1683 1684
	return ar;

1685 1686
err_free_aux_wq:
	destroy_workqueue(ar->workqueue_aux);
1687 1688 1689 1690
err_free_wq:
	destroy_workqueue(ar->workqueue);

err_free_mac:
1691
	ath10k_mac_destroy(ar);
1692

1693 1694 1695 1696 1697 1698 1699 1700 1701
	return NULL;
}
EXPORT_SYMBOL(ath10k_core_create);

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

1702 1703 1704
	flush_workqueue(ar->workqueue_aux);
	destroy_workqueue(ar->workqueue_aux);

1705
	ath10k_debug_destroy(ar);
1706 1707 1708 1709
	ath10k_mac_destroy(ar);
}
EXPORT_SYMBOL(ath10k_core_destroy);

1710 1711 1712
MODULE_AUTHOR("Qualcomm Atheros");
MODULE_DESCRIPTION("Core module for QCA988X PCIe devices.");
MODULE_LICENSE("Dual BSD/GPL");