core.c 38.2 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 34

unsigned int ath10k_debug_mask;
static bool uart_print;
35 36
static bool skip_otp;

37 38
module_param_named(debug_mask, ath10k_debug_mask, uint, 0644);
module_param(uart_print, bool, 0644);
39 40
module_param(skip_otp, bool, 0644);

41 42
MODULE_PARM_DESC(debug_mask, "Debugging mask");
MODULE_PARM_DESC(uart_print, "Uart target debugging");
43
MODULE_PARM_DESC(skip_otp, "Skip otp failure for calibration in testmode");
44 45 46 47 48 49

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,
50
		.uart_pin = 7,
51
		.has_shifted_cc_wraparound = true,
52 53 54 55 56
		.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,
57 58
			.board_size = QCA988X_BOARD_DATA_SZ,
			.board_ext_size = QCA988X_BOARD_EXT_DATA_SZ,
59 60
		},
	},
M
Michal Kazior 已提交
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
	{
		.id = QCA6174_HW_2_1_VERSION,
		.name = "qca6174 hw2.1",
		.patch_load_addr = QCA6174_HW_2_1_PATCH_LOAD_ADDR,
		.uart_pin = 6,
		.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,
		.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 已提交
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
	{
		.id = QCA6174_HW_3_2_VERSION,
		.name = "qca6174 hw3.2",
		.patch_load_addr = QCA6174_HW_3_0_PATCH_LOAD_ADDR,
		.uart_pin = 6,
		.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,
		},
	},
104 105
};

106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
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);
		}
	}
}

150 151
static void ath10k_send_suspend_complete(struct ath10k *ar)
{
152
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot suspend complete\n");
153

154
	complete(&ar->target_suspend);
155 156 157 158 159 160 161 162 163 164 165
}

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) {
166
		ath10k_err(ar, "settings HTC version failed\n");
167 168 169 170 171 172
		return ret;
	}

	/* set the firmware mode to STA/IBSS/AP */
	ret = ath10k_bmi_read32(ar, hi_option_flag, &param_host);
	if (ret) {
173
		ath10k_err(ar, "setting firmware mode (1/2) failed\n");
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
		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) {
192
		ath10k_err(ar, "setting firmware mode (2/2) failed\n");
193 194 195 196 197 198
		return ret;
	}

	/* We do all byte-swapping on the host */
	ret = ath10k_bmi_write32(ar, hi_be, 0);
	if (ret) {
199
		ath10k_err(ar, "setting host CPU BE mode failed\n");
200 201 202 203 204 205 206
		return ret;
	}

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

	if (ret) {
207
		ath10k_err(ar, "setting FW data/desc swap flags failed\n");
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235
		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;
}

236 237
static int ath10k_push_board_ext_data(struct ath10k *ar, const void *data,
				      size_t data_len)
238
{
239 240
	u32 board_data_size = ar->hw_params.fw.board_size;
	u32 board_ext_data_size = ar->hw_params.fw.board_ext_size;
241 242 243 244 245
	u32 board_ext_data_addr;
	int ret;

	ret = ath10k_bmi_read32(ar, hi_board_ext_data, &board_ext_data_addr);
	if (ret) {
246 247
		ath10k_err(ar, "could not read board ext data addr (%d)\n",
			   ret);
248 249 250
		return ret;
	}

251
	ath10k_dbg(ar, ATH10K_DBG_BOOT,
252
		   "boot push board extended data addr 0x%x\n",
253 254 255 256 257
		   board_ext_data_addr);

	if (board_ext_data_addr == 0)
		return 0;

258
	if (data_len != (board_data_size + board_ext_data_size)) {
259
		ath10k_err(ar, "invalid board (ext) data sizes %zu != %d+%d\n",
260
			   data_len, board_data_size, board_ext_data_size);
261 262 263 264
		return -EINVAL;
	}

	ret = ath10k_bmi_write_memory(ar, board_ext_data_addr,
265
				      data + board_data_size,
266 267
				      board_ext_data_size);
	if (ret) {
268
		ath10k_err(ar, "could not write board ext data (%d)\n", ret);
269 270 271 272 273 274
		return ret;
	}

	ret = ath10k_bmi_write32(ar, hi_board_ext_data_config,
				 (board_ext_data_size << 16) | 1);
	if (ret) {
275 276
		ath10k_err(ar, "could not write board ext data bit (%d)\n",
			   ret);
277 278 279 280 281 282
		return ret;
	}

	return 0;
}

283 284
static int ath10k_download_board_data(struct ath10k *ar, const void *data,
				      size_t data_len)
285
{
286
	u32 board_data_size = ar->hw_params.fw.board_size;
287 288 289
	u32 address;
	int ret;

290
	ret = ath10k_push_board_ext_data(ar, data, data_len);
291
	if (ret) {
292
		ath10k_err(ar, "could not push board ext data (%d)\n", ret);
293 294 295 296 297
		goto exit;
	}

	ret = ath10k_bmi_read32(ar, hi_board_data, &address);
	if (ret) {
298
		ath10k_err(ar, "could not read board data addr (%d)\n", ret);
299 300 301
		goto exit;
	}

302
	ret = ath10k_bmi_write_memory(ar, address, data,
303
				      min_t(u32, board_data_size,
304
					    data_len));
305
	if (ret) {
306
		ath10k_err(ar, "could not write board data (%d)\n", ret);
307 308 309 310 311
		goto exit;
	}

	ret = ath10k_bmi_write32(ar, hi_board_data_initialized, 1);
	if (ret) {
312
		ath10k_err(ar, "could not write board data bit (%d)\n", ret);
313 314 315 316 317 318 319
		goto exit;
	}

exit:
	return ret;
}

320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
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;
}

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

399 400
static int ath10k_download_and_run_otp(struct ath10k *ar)
{
401
	u32 result, address = ar->hw_params.patch_load_addr;
402 403
	int ret;

404
	ret = ath10k_download_board_data(ar, ar->board_data, ar->board_len);
405 406 407 408 409
	if (ret) {
		ath10k_err(ar, "failed to download board data: %d\n", ret);
		return ret;
	}

410 411
	/* OTP is optional */

K
Kalle Valo 已提交
412
	if (!ar->otp_data || !ar->otp_len) {
413
		ath10k_warn(ar, "Not running otp, calibration will be incorrect (otp-data %p otp_len %zd)!\n",
414
			    ar->otp_data, ar->otp_len);
415
		return 0;
K
Kalle Valo 已提交
416 417
	}

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

421
	ret = ath10k_bmi_fast_download(ar, address, ar->otp_data, ar->otp_len);
422
	if (ret) {
423
		ath10k_err(ar, "could not write otp (%d)\n", ret);
K
Kalle Valo 已提交
424
		return ret;
425 426
	}

427
	ret = ath10k_bmi_execute(ar, address, 0, &result);
428
	if (ret) {
429
		ath10k_err(ar, "could not execute otp (%d)\n", ret);
K
Kalle Valo 已提交
430
		return ret;
431 432
	}

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

435 436 437
	if (!(skip_otp || test_bit(ATH10K_FW_FEATURE_IGNORE_OTP_RESULT,
				   ar->fw_features))
	    && result != 0) {
438
		ath10k_err(ar, "otp calibration failed: %d", result);
K
Kalle Valo 已提交
439 440 441 442
		return -EINVAL;
	}

	return 0;
443 444
}

K
Kalle Valo 已提交
445
static int ath10k_download_fw(struct ath10k *ar, enum ath10k_firmware_mode mode)
446
{
K
Kalle Valo 已提交
447 448 449
	u32 address, data_len;
	const char *mode_name;
	const void *data;
450 451 452 453
	int ret;

	address = ar->hw_params.patch_load_addr;

K
Kalle Valo 已提交
454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474
	switch (mode) {
	case ATH10K_FIRMWARE_MODE_NORMAL:
		data = ar->firmware_data;
		data_len = ar->firmware_len;
		mode_name = "normal";
		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);
475
	if (ret) {
K
Kalle Valo 已提交
476 477 478
		ath10k_err(ar, "failed to download %s firmware: %d\n",
			   mode_name, ret);
		return ret;
479 480
	}

481 482 483 484 485
	return ret;
}

static void ath10k_core_free_firmware_files(struct ath10k *ar)
{
486
	if (!IS_ERR(ar->board))
487
		release_firmware(ar->board);
488

489
	if (!IS_ERR(ar->otp))
490 491
		release_firmware(ar->otp);

492
	if (!IS_ERR(ar->firmware))
493 494
		release_firmware(ar->firmware);

495
	if (!IS_ERR(ar->cal_file))
496 497
		release_firmware(ar->cal_file);

498
	ar->board = NULL;
499 500 501
	ar->board_data = NULL;
	ar->board_len = 0;

502
	ar->otp = NULL;
503 504 505
	ar->otp_data = NULL;
	ar->otp_len = 0;

506
	ar->firmware = NULL;
507 508
	ar->firmware_data = NULL;
	ar->firmware_len = 0;
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529

	ar->cal_file = NULL;
}

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

532
static int ath10k_core_fetch_spec_board_file(struct ath10k *ar)
533
{
534 535 536 537 538 539 540 541 542 543 544 545
	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;
546

547 548 549 550 551
	return 0;
}

static int ath10k_core_fetch_generic_board_file(struct ath10k *ar)
{
552 553
	if (!ar->hw_params.fw.board) {
		ath10k_err(ar, "failed to find board file fw entry\n");
554 555 556
		return -EINVAL;
	}

557 558 559
	ar->board = ath10k_fetch_fw_file(ar,
					 ar->hw_params.fw.dir,
					 ar->hw_params.fw.board);
560 561
	if (IS_ERR(ar->board))
		return PTR_ERR(ar->board);
562

563 564
	ar->board_data = ar->board->data;
	ar->board_len = ar->board->size;
565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592
	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;
	}
593

594 595 596 597 598 599 600 601 602 603 604 605
	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;
	}

606 607 608 609 610
	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);
611
		ath10k_err(ar, "could not fetch firmware (%d)\n", ret);
612 613 614
		goto err;
	}

615 616 617
	ar->firmware_data = ar->firmware->data;
	ar->firmware_len = ar->firmware->size;

618 619 620 621 622 623 624 625 626
	/* 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);
627
		ath10k_err(ar, "could not fetch otp (%d)\n", ret);
628 629 630
		goto err;
	}

631 632 633
	ar->otp_data = ar->otp->data;
	ar->otp_len = ar->otp->size;

634 635 636 637
	return 0;

err:
	ath10k_core_free_firmware_files(ar);
638 639 640
	return ret;
}

641 642 643 644 645 646
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;
647
	__le32 *timestamp, *version;
648 649 650 651

	/* 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)) {
652
		ath10k_err(ar, "could not fetch firmware file '%s/%s': %ld\n",
653
			   ar->hw_params.fw.dir, name, PTR_ERR(ar->firmware));
654 655 656 657 658 659 660 661 662 663
		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) {
664
		ath10k_err(ar, "firmware file '%s/%s' too small to contain magic: %zu\n",
665
			   ar->hw_params.fw.dir, name, len);
666 667
		ret = -EINVAL;
		goto err;
668 669 670
	}

	if (memcmp(data, ATH10K_FIRMWARE_MAGIC, magic_len) != 0) {
671
		ath10k_err(ar, "invalid firmware magic\n");
672 673
		ret = -EINVAL;
		goto err;
674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692
	}

	/* 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) {
693
			ath10k_err(ar, "invalid length for FW IE %d (%zu < %zu)\n",
694
				   ie_id, len, ie_len);
695 696
			ret = -EINVAL;
			goto err;
697 698 699 700 701 702 703 704 705 706
		}

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

707
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
708 709 710 711 712 713 714 715 716
				   "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;

717
			ath10k_dbg(ar, ATH10K_DBG_BOOT, "found fw timestamp %d\n",
718 719 720
				   le32_to_cpup(timestamp));
			break;
		case ATH10K_FW_IE_FEATURES:
721
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
722 723 724 725 726 727 728 729 730 731
				   "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;

732
				if (data[index] & (1 << bit)) {
733
					ath10k_dbg(ar, ATH10K_DBG_BOOT,
734 735
						   "Enabling feature bit: %i\n",
						   i);
736
					__set_bit(i, ar->fw_features);
737
				}
738 739
			}

740
			ath10k_dbg_dump(ar, ATH10K_DBG_BOOT, "features", "",
741 742 743 744
					ar->fw_features,
					sizeof(ar->fw_features));
			break;
		case ATH10K_FW_IE_FW_IMAGE:
745
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
746 747 748 749 750 751 752 753
				   "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:
754
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
755 756 757 758 759 760 761
				   "found otp image ie (%zd B)\n",
				   ie_len);

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

			break;
762 763 764 765 766 767 768 769 770 771 772
		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;
773 774 775 776 777 778 779 780 781 782 783
		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;
784
		default:
785
			ath10k_warn(ar, "Unknown FW IE: %u\n",
786 787 788 789 790 791 792 793 794
				    le32_to_cpu(hdr->id));
			break;
		}

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

		len -= ie_len;
		data += ie_len;
795
	}
796 797

	if (!ar->firmware_data || !ar->firmware_len) {
798
		ath10k_warn(ar, "No ATH10K_FW_IE_FW_IMAGE found from '%s/%s', skipping\n",
799
			    ar->hw_params.fw.dir, name);
800 801 802 803 804 805 806 807 808 809 810 811 812 813 814
		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;

815 816 817
	/* calibration file is optional, don't check for any errors */
	ath10k_fetch_cal_file(ar);

818 819 820 821 822 823
	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 已提交
824 825 826 827 828 829 830
	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;

831 832 833 834 835 836 837
	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;

838
	ar->fw_api = 3;
839
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
840 841 842 843 844

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

845
	ar->fw_api = 2;
846
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
847

848
	ret = ath10k_core_fetch_firmware_api_n(ar, ATH10K_FW_API2_FILE);
849 850 851 852
	if (ret == 0)
		goto success;

	ar->fw_api = 1;
853
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
854 855 856 857 858

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

859
success:
860
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "using fw api %d\n", ar->fw_api);
861 862 863 864

	return 0;
}

865
static int ath10k_download_cal_data(struct ath10k *ar)
866 867 868
{
	int ret;

869 870 871 872 873 874 875
	ret = ath10k_download_cal_file(ar);
	if (ret == 0) {
		ar->cal_mode = ATH10K_CAL_MODE_FILE;
		goto done;
	}

	ath10k_dbg(ar, ATH10K_DBG_BOOT,
876 877 878 879 880 881 882 883 884 885 886
		   "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",
887 888
		   ret);

889
	ret = ath10k_download_and_run_otp(ar);
890
	if (ret) {
891
		ath10k_err(ar, "failed to run otp: %d\n", ret);
892
		return ret;
893
	}
894

895 896 897 898 899 900
	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;
901 902 903 904 905 906 907 908 909 910 911 912
}

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) {
913
		ath10k_warn(ar, "could not disable UART prints (%d)\n", ret);
914 915 916
		return ret;
	}

917
	if (!uart_print)
918 919
		return 0;

920
	ret = ath10k_bmi_write32(ar, hi_dbg_uart_txpin, ar->hw_params.uart_pin);
921
	if (ret) {
922
		ath10k_warn(ar, "could not enable UART prints (%d)\n", ret);
923 924 925 926 927
		return ret;
	}

	ret = ath10k_bmi_write32(ar, hi_serial_enable, 1);
	if (ret) {
928
		ath10k_warn(ar, "could not enable UART prints (%d)\n", ret);
929 930 931
		return ret;
	}

932 933 934
	/* Set the UART baud rate to 19200. */
	ret = ath10k_bmi_write32(ar, hi_desired_baud_rate, 19200);
	if (ret) {
935
		ath10k_warn(ar, "could not set the baud rate (%d)\n", ret);
936 937 938
		return ret;
	}

939
	ath10k_info(ar, "UART prints enabled\n");
940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955
	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)) {
956
		ath10k_err(ar, "Unsupported hardware version: 0x%x\n",
957 958 959 960 961 962
			   ar->target_version);
		return -EINVAL;
	}

	ar->hw_params = *hw_params;

963
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "Hardware name %s version 0x%x\n",
964
		   ar->hw_params.name, ar->target_version);
965 966 967 968

	return 0;
}

969 970 971 972
static void ath10k_core_restart(struct work_struct *work)
{
	struct ath10k *ar = container_of(work, struct ath10k, restart_work);

M
Michal Kazior 已提交
973 974 975 976 977 978 979 980 981 982 983 984 985 986 987
	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);
988
	complete_all(&ar->thermal.wmi_sync);
M
Michal Kazior 已提交
989 990 991 992
	wake_up(&ar->htt.empty_tx_wq);
	wake_up(&ar->wmi.tx_credits_wq);
	wake_up(&ar->peer_mapping_wq);

993 994 995 996 997
	mutex_lock(&ar->conf_mutex);

	switch (ar->state) {
	case ATH10K_STATE_ON:
		ar->state = ATH10K_STATE_RESTARTING;
998
		ath10k_hif_stop(ar);
999
		ath10k_scan_finish(ar);
1000 1001 1002
		ieee80211_restart_hw(ar->hw);
		break;
	case ATH10K_STATE_OFF:
1003 1004
		/* this can happen if driver is being unloaded
		 * or if the crash happens during FW probing */
1005
		ath10k_warn(ar, "cannot restart a device that hasn't been started\n");
1006 1007
		break;
	case ATH10K_STATE_RESTARTING:
1008 1009
		/* hw restart might be requested from multiple places */
		break;
1010 1011 1012 1013
	case ATH10K_STATE_RESTARTED:
		ar->state = ATH10K_STATE_WEDGED;
		/* fall through */
	case ATH10K_STATE_WEDGED:
1014
		ath10k_warn(ar, "device is wedged, will not restart\n");
1015
		break;
K
Kalle Valo 已提交
1016 1017 1018
	case ATH10K_STATE_UTF:
		ath10k_warn(ar, "firmware restart in UTF mode not supported\n");
		break;
1019 1020 1021 1022 1023
	}

	mutex_unlock(&ar->conf_mutex);
}

1024
static int ath10k_core_init_firmware_features(struct ath10k *ar)
1025
{
1026 1027 1028 1029 1030 1031
	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;
	}

1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
	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;
	}

	/* 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)) {
1043 1044
			if (test_bit(ATH10K_FW_FEATURE_WMI_10_2,
				     ar->fw_features))
1045 1046 1047 1048 1049 1050 1051 1052 1053 1054
				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:
1055 1056
		ar->max_num_peers = TARGET_NUM_PEERS;
		ar->max_num_stations = TARGET_NUM_STATIONS;
1057
		ar->max_num_vdevs = TARGET_NUM_VDEVS;
1058
		ar->htt.max_num_pending_tx = TARGET_NUM_MSDU_DESC;
1059 1060
		ar->fw_stats_req_mask = WMI_STAT_PDEV | WMI_STAT_VDEV |
			WMI_STAT_PEER;
1061 1062 1063
		break;
	case ATH10K_FW_WMI_OP_VERSION_10_1:
	case ATH10K_FW_WMI_OP_VERSION_10_2:
1064
	case ATH10K_FW_WMI_OP_VERSION_10_2_4:
1065 1066
		ar->max_num_peers = TARGET_10X_NUM_PEERS;
		ar->max_num_stations = TARGET_10X_NUM_STATIONS;
1067
		ar->max_num_vdevs = TARGET_10X_NUM_VDEVS;
1068
		ar->htt.max_num_pending_tx = TARGET_10X_NUM_MSDU_DESC;
1069
		ar->fw_stats_req_mask = WMI_STAT_PEER;
1070
		break;
M
Michal Kazior 已提交
1071 1072 1073
	case ATH10K_FW_WMI_OP_VERSION_TLV:
		ar->max_num_peers = TARGET_TLV_NUM_PEERS;
		ar->max_num_stations = TARGET_TLV_NUM_STATIONS;
1074
		ar->max_num_vdevs = TARGET_TLV_NUM_VDEVS;
1075
		ar->max_num_tdls_vdevs = TARGET_TLV_NUM_TDLS_VDEVS;
M
Michal Kazior 已提交
1076
		ar->htt.max_num_pending_tx = TARGET_TLV_NUM_MSDU_DESC;
1077
		ar->wow.max_num_patterns = TARGET_TLV_NUM_WOW_PATTERNS;
1078 1079
		ar->fw_stats_req_mask = WMI_STAT_PDEV | WMI_STAT_VDEV |
			WMI_STAT_PEER;
M
Michal Kazior 已提交
1080
		break;
1081 1082 1083 1084
	case ATH10K_FW_WMI_OP_VERSION_UNSET:
	case ATH10K_FW_WMI_OP_VERSION_MAX:
		WARN_ON(1);
		return -EINVAL;
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
	/* 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;
		case ATH10K_FW_WMI_OP_VERSION_UNSET:
		case ATH10K_FW_WMI_OP_VERSION_MAX:
			WARN_ON(1);
			return -EINVAL;
		}
	}

1110
	return 0;
1111 1112
}

K
Kalle Valo 已提交
1113
int ath10k_core_start(struct ath10k *ar, enum ath10k_firmware_mode mode)
1114 1115 1116
{
	int status;

1117 1118
	lockdep_assert_held(&ar->conf_mutex);

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

1121 1122
	ath10k_bmi_start(ar);

1123 1124 1125 1126 1127
	if (ath10k_init_configure_target(ar)) {
		status = -EINVAL;
		goto err;
	}

1128 1129 1130 1131
	status = ath10k_download_cal_data(ar);
	if (status)
		goto err;

1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147
	/* 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;
		}
	}

1148
	status = ath10k_download_fw(ar, mode);
1149 1150 1151 1152 1153 1154 1155
	if (status)
		goto err;

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

1156 1157
	ar->htc.htc_ops.target_send_suspend_complete =
		ath10k_send_suspend_complete;
1158

1159 1160
	status = ath10k_htc_init(ar);
	if (status) {
1161
		ath10k_err(ar, "could not init HTC (%d)\n", status);
1162 1163 1164 1165 1166
		goto err;
	}

	status = ath10k_bmi_done(ar);
	if (status)
1167
		goto err;
1168 1169 1170

	status = ath10k_wmi_attach(ar);
	if (status) {
1171
		ath10k_err(ar, "WMI attach failed: %d\n", status);
1172
		goto err;
1173 1174
	}

M
Michal Kazior 已提交
1175 1176
	status = ath10k_htt_init(ar);
	if (status) {
1177
		ath10k_err(ar, "failed to init htt: %d\n", status);
M
Michal Kazior 已提交
1178 1179 1180 1181 1182
		goto err_wmi_detach;
	}

	status = ath10k_htt_tx_alloc(&ar->htt);
	if (status) {
1183
		ath10k_err(ar, "failed to alloc htt tx: %d\n", status);
M
Michal Kazior 已提交
1184 1185 1186 1187 1188
		goto err_wmi_detach;
	}

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

M
Michal Kazior 已提交
1193 1194
	status = ath10k_hif_start(ar);
	if (status) {
1195
		ath10k_err(ar, "could not start HIF: %d\n", status);
M
Michal Kazior 已提交
1196
		goto err_htt_rx_detach;
M
Michal Kazior 已提交
1197 1198 1199 1200
	}

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

K
Kalle Valo 已提交
1205 1206 1207 1208 1209 1210
	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;
		}
1211 1212
	}

M
Michal Kazior 已提交
1213 1214
	status = ath10k_wmi_connect(ar);
	if (status) {
1215
		ath10k_err(ar, "could not connect wmi: %d\n", status);
M
Michal Kazior 已提交
1216 1217 1218 1219 1220
		goto err_hif_stop;
	}

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

K
Kalle Valo 已提交
1225 1226
	if (mode == ATH10K_FIRMWARE_MODE_NORMAL) {
		status = ath10k_wmi_wait_for_service_ready(ar);
1227
		if (status) {
K
Kalle Valo 已提交
1228 1229 1230
			ath10k_warn(ar, "wmi service ready event not received");
			goto err_hif_stop;
		}
M
Michal Kazior 已提交
1231
	}
1232

1233
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "firmware %s booted\n",
1234
		   ar->hw->wiphy->fw_version);
1235 1236 1237

	status = ath10k_wmi_cmd_init(ar);
	if (status) {
1238 1239
		ath10k_err(ar, "could not send WMI init command (%d)\n",
			   status);
M
Michal Kazior 已提交
1240
		goto err_hif_stop;
1241 1242 1243
	}

	status = ath10k_wmi_wait_for_unified_ready(ar);
1244
	if (status) {
1245
		ath10k_err(ar, "wmi unified ready event not received\n");
M
Michal Kazior 已提交
1246
		goto err_hif_stop;
1247 1248
	}

1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260
	/* 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 已提交
1261 1262 1263 1264 1265 1266 1267
	/* 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 已提交
1268
	}
1269

1270 1271
	status = ath10k_debug_start(ar);
	if (status)
M
Michal Kazior 已提交
1272
		goto err_hif_stop;
1273

1274
	ar->free_vdev_map = (1LL << ar->max_num_vdevs) - 1;
1275

M
Michal Kazior 已提交
1276
	INIT_LIST_HEAD(&ar->arvifs);
1277

1278 1279
	return 0;

M
Michal Kazior 已提交
1280 1281
err_hif_stop:
	ath10k_hif_stop(ar);
M
Michal Kazior 已提交
1282 1283 1284 1285
err_htt_rx_detach:
	ath10k_htt_rx_free(&ar->htt);
err_htt_tx_detach:
	ath10k_htt_tx_free(&ar->htt);
1286 1287 1288 1289 1290
err_wmi_detach:
	ath10k_wmi_detach(ar);
err:
	return status;
}
1291
EXPORT_SYMBOL(ath10k_core_start);
1292

1293 1294 1295
int ath10k_wait_for_suspend(struct ath10k *ar, u32 suspend_opt)
{
	int ret;
1296
	unsigned long time_left;
1297 1298 1299 1300 1301

	reinit_completion(&ar->target_suspend);

	ret = ath10k_wmi_pdev_suspend_target(ar, suspend_opt);
	if (ret) {
1302
		ath10k_warn(ar, "could not suspend target (%d)\n", ret);
1303 1304 1305
		return ret;
	}

1306
	time_left = wait_for_completion_timeout(&ar->target_suspend, 1 * HZ);
1307

1308
	if (!time_left) {
1309
		ath10k_warn(ar, "suspend timed out - target pause event never came\n");
1310 1311 1312 1313 1314 1315
		return -ETIMEDOUT;
	}

	return 0;
}

1316 1317
void ath10k_core_stop(struct ath10k *ar)
{
1318 1319
	lockdep_assert_held(&ar->conf_mutex);

1320
	/* try to suspend target */
K
Kalle Valo 已提交
1321 1322
	if (ar->state != ATH10K_STATE_RESTARTING &&
	    ar->state != ATH10K_STATE_UTF)
1323 1324
		ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND_AND_DISABLE_INTR);

1325
	ath10k_debug_stop(ar);
M
Michal Kazior 已提交
1326 1327 1328
	ath10k_hif_stop(ar);
	ath10k_htt_tx_free(&ar->htt);
	ath10k_htt_rx_free(&ar->htt);
1329 1330
	ath10k_wmi_detach(ar);
}
1331 1332 1333 1334 1335 1336 1337 1338
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)
{
1339 1340
	struct bmi_target_info target_info;
	int ret = 0;
1341 1342 1343

	ret = ath10k_hif_power_up(ar);
	if (ret) {
1344
		ath10k_err(ar, "could not start pci hif (%d)\n", ret);
1345 1346 1347
		return ret;
	}

1348 1349 1350
	memset(&target_info, 0, sizeof(target_info));
	ret = ath10k_bmi_get_target_info(ar, &target_info);
	if (ret) {
1351
		ath10k_err(ar, "could not get target info (%d)\n", ret);
1352
		goto err_power_down;
1353 1354 1355 1356 1357 1358 1359
	}

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

	ret = ath10k_init_hw_params(ar);
	if (ret) {
1360
		ath10k_err(ar, "could not get hw params (%d)\n", ret);
1361
		goto err_power_down;
1362 1363 1364 1365
	}

	ret = ath10k_core_fetch_firmware_files(ar);
	if (ret) {
1366
		ath10k_err(ar, "could not fetch firmware files (%d)\n", ret);
1367
		goto err_power_down;
1368 1369
	}

1370 1371 1372 1373 1374 1375
	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;
	}
1376

1377 1378
	mutex_lock(&ar->conf_mutex);

K
Kalle Valo 已提交
1379
	ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
1380
	if (ret) {
1381
		ath10k_err(ar, "could not init core (%d)\n", ret);
1382
		goto err_unlock;
1383 1384
	}

M
Michal Kazior 已提交
1385
	ath10k_print_driver_info(ar);
1386
	ath10k_core_stop(ar);
1387 1388 1389

	mutex_unlock(&ar->conf_mutex);

1390 1391
	ath10k_hif_power_down(ar);
	return 0;
1392 1393 1394 1395

err_unlock:
	mutex_unlock(&ar->conf_mutex);

1396
err_free_firmware_files:
1397 1398 1399 1400 1401 1402
	ath10k_core_free_firmware_files(ar);

err_power_down:
	ath10k_hif_power_down(ar);

	return ret;
1403
}
1404

1405
static void ath10k_core_register_work(struct work_struct *work)
1406
{
1407
	struct ath10k *ar = container_of(work, struct ath10k, register_work);
1408 1409
	int status;

1410 1411
	status = ath10k_core_probe_fw(ar);
	if (status) {
1412
		ath10k_err(ar, "could not probe fw (%d)\n", status);
1413
		goto err;
1414
	}
1415

1416
	status = ath10k_mac_register(ar);
1417
	if (status) {
1418
		ath10k_err(ar, "could not register to mac80211 (%d)\n", status);
1419
		goto err_release_fw;
1420
	}
1421

1422
	status = ath10k_debug_register(ar);
1423
	if (status) {
1424
		ath10k_err(ar, "unable to initialize debugfs\n");
1425 1426 1427
		goto err_unregister_mac;
	}

1428 1429
	status = ath10k_spectral_create(ar);
	if (status) {
1430
		ath10k_err(ar, "failed to initialize spectral\n");
1431 1432 1433
		goto err_debug_destroy;
	}

1434 1435 1436 1437 1438 1439 1440
	status = ath10k_thermal_register(ar);
	if (status) {
		ath10k_err(ar, "could not register thermal device: %d\n",
			   status);
		goto err_spectral_destroy;
	}

1441 1442
	set_bit(ATH10K_FLAG_CORE_REGISTERED, &ar->dev_flags);
	return;
1443

1444 1445
err_spectral_destroy:
	ath10k_spectral_destroy(ar);
1446 1447
err_debug_destroy:
	ath10k_debug_destroy(ar);
1448 1449
err_unregister_mac:
	ath10k_mac_unregister(ar);
1450 1451
err_release_fw:
	ath10k_core_free_firmware_files(ar);
1452
err:
1453 1454 1455
	/* TODO: It's probably a good idea to release device from the driver
	 * but calling device_release_driver() here will cause a deadlock.
	 */
1456 1457 1458 1459 1460 1461 1462 1463 1464
	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;
1465 1466 1467 1468 1469
}
EXPORT_SYMBOL(ath10k_core_register);

void ath10k_core_unregister(struct ath10k *ar)
{
1470 1471 1472 1473 1474
	cancel_work_sync(&ar->register_work);

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

1475
	ath10k_thermal_unregister(ar);
1476 1477 1478 1479 1480 1481
	/* 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);

1482 1483 1484 1485
	/* 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);
1486

K
Kalle Valo 已提交
1487 1488
	ath10k_testmode_destroy(ar);

1489
	ath10k_core_free_firmware_files(ar);
1490

1491
	ath10k_debug_unregister(ar);
1492 1493 1494
}
EXPORT_SYMBOL(ath10k_core_unregister);

M
Michal Kazior 已提交
1495
struct ath10k *ath10k_core_create(size_t priv_size, struct device *dev,
K
Kalle Valo 已提交
1496
				  enum ath10k_bus bus,
M
Michal Kazior 已提交
1497
				  enum ath10k_hw_rev hw_rev,
1498 1499 1500
				  const struct ath10k_hif_ops *hif_ops)
{
	struct ath10k *ar;
1501
	int ret;
1502

M
Michal Kazior 已提交
1503
	ar = ath10k_mac_create(priv_size);
1504 1505 1506 1507 1508 1509
	if (!ar)
		return NULL;

	ar->ath_common.priv = ar;
	ar->ath_common.hw = ar->hw;
	ar->dev = dev;
M
Michal Kazior 已提交
1510
	ar->hw_rev = hw_rev;
1511
	ar->hif.ops = hif_ops;
K
Kalle Valo 已提交
1512
	ar->hif.bus = bus;
1513

M
Michal Kazior 已提交
1514 1515 1516
	switch (hw_rev) {
	case ATH10K_HW_QCA988X:
		ar->regs = &qca988x_regs;
1517
		ar->hw_values = &qca988x_values;
M
Michal Kazior 已提交
1518 1519 1520
		break;
	case ATH10K_HW_QCA6174:
		ar->regs = &qca6174_regs;
1521
		ar->hw_values = &qca6174_values;
M
Michal Kazior 已提交
1522 1523 1524 1525 1526 1527 1528 1529
		break;
	default:
		ath10k_err(ar, "unsupported core hardware revision %d\n",
			   hw_rev);
		ret = -ENOTSUPP;
		goto err_free_mac;
	}

1530 1531 1532 1533
	init_completion(&ar->scan.started);
	init_completion(&ar->scan.completed);
	init_completion(&ar->scan.on_channel);
	init_completion(&ar->target_suspend);
1534
	init_completion(&ar->wow.wakeup_completed);
1535 1536 1537

	init_completion(&ar->install_key_done);
	init_completion(&ar->vdev_setup_done);
1538
	init_completion(&ar->thermal.wmi_sync);
1539

1540
	INIT_DELAYED_WORK(&ar->scan.timeout, ath10k_scan_timeout_work);
1541 1542 1543

	ar->workqueue = create_singlethread_workqueue("ath10k_wq");
	if (!ar->workqueue)
1544
		goto err_free_mac;
1545 1546 1547 1548 1549 1550

	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 已提交
1551 1552
	init_waitqueue_head(&ar->htt.empty_tx_wq);
	init_waitqueue_head(&ar->wmi.tx_credits_wq);
1553 1554 1555 1556 1557 1558 1559 1560

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

1561
	INIT_WORK(&ar->register_work, ath10k_core_register_work);
1562 1563
	INIT_WORK(&ar->restart_work, ath10k_core_restart);

1564 1565 1566 1567
	ret = ath10k_debug_create(ar);
	if (ret)
		goto err_free_wq;

1568 1569
	return ar;

1570 1571 1572 1573
err_free_wq:
	destroy_workqueue(ar->workqueue);

err_free_mac:
1574
	ath10k_mac_destroy(ar);
1575

1576 1577 1578 1579 1580 1581 1582 1583 1584
	return NULL;
}
EXPORT_SYMBOL(ath10k_core_create);

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

1585
	ath10k_debug_destroy(ar);
1586 1587 1588 1589
	ath10k_mac_destroy(ar);
}
EXPORT_SYMBOL(ath10k_core_destroy);

1590 1591 1592
MODULE_AUTHOR("Qualcomm Atheros");
MODULE_DESCRIPTION("Core module for QCA988X PCIe devices.");
MODULE_LICENSE("Dual BSD/GPL");