core.c 34.6 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 52 53 54 55
		.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,
56 57
			.board_size = QCA988X_BOARD_DATA_SZ,
			.board_ext_size = QCA988X_BOARD_EXT_DATA_SZ,
58 59
		},
	},
M
Michal Kazior 已提交
60 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
	{
		.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 已提交
88 89 90 91 92 93 94 95 96 97 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,
		.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,
		},
	},
103 104 105 106
};

static void ath10k_send_suspend_complete(struct ath10k *ar)
{
107
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot suspend complete\n");
108

109
	complete(&ar->target_suspend);
110 111 112 113 114 115 116 117 118 119 120
}

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) {
121
		ath10k_err(ar, "settings HTC version failed\n");
122 123 124 125 126 127
		return ret;
	}

	/* set the firmware mode to STA/IBSS/AP */
	ret = ath10k_bmi_read32(ar, hi_option_flag, &param_host);
	if (ret) {
128
		ath10k_err(ar, "setting firmware mode (1/2) failed\n");
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
		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) {
147
		ath10k_err(ar, "setting firmware mode (2/2) failed\n");
148 149 150 151 152 153
		return ret;
	}

	/* We do all byte-swapping on the host */
	ret = ath10k_bmi_write32(ar, hi_be, 0);
	if (ret) {
154
		ath10k_err(ar, "setting host CPU BE mode failed\n");
155 156 157 158 159 160 161
		return ret;
	}

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

	if (ret) {
162
		ath10k_err(ar, "setting FW data/desc swap flags failed\n");
163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
		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;
}

191 192
static int ath10k_push_board_ext_data(struct ath10k *ar, const void *data,
				      size_t data_len)
193
{
194 195
	u32 board_data_size = ar->hw_params.fw.board_size;
	u32 board_ext_data_size = ar->hw_params.fw.board_ext_size;
196 197 198 199 200
	u32 board_ext_data_addr;
	int ret;

	ret = ath10k_bmi_read32(ar, hi_board_ext_data, &board_ext_data_addr);
	if (ret) {
201 202
		ath10k_err(ar, "could not read board ext data addr (%d)\n",
			   ret);
203 204 205
		return ret;
	}

206
	ath10k_dbg(ar, ATH10K_DBG_BOOT,
207
		   "boot push board extended data addr 0x%x\n",
208 209 210 211 212
		   board_ext_data_addr);

	if (board_ext_data_addr == 0)
		return 0;

213
	if (data_len != (board_data_size + board_ext_data_size)) {
214
		ath10k_err(ar, "invalid board (ext) data sizes %zu != %d+%d\n",
215
			   data_len, board_data_size, board_ext_data_size);
216 217 218 219
		return -EINVAL;
	}

	ret = ath10k_bmi_write_memory(ar, board_ext_data_addr,
220
				      data + board_data_size,
221 222
				      board_ext_data_size);
	if (ret) {
223
		ath10k_err(ar, "could not write board ext data (%d)\n", ret);
224 225 226 227 228 229
		return ret;
	}

	ret = ath10k_bmi_write32(ar, hi_board_ext_data_config,
				 (board_ext_data_size << 16) | 1);
	if (ret) {
230 231
		ath10k_err(ar, "could not write board ext data bit (%d)\n",
			   ret);
232 233 234 235 236 237
		return ret;
	}

	return 0;
}

238 239
static int ath10k_download_board_data(struct ath10k *ar, const void *data,
				      size_t data_len)
240
{
241
	u32 board_data_size = ar->hw_params.fw.board_size;
242 243 244
	u32 address;
	int ret;

245
	ret = ath10k_push_board_ext_data(ar, data, data_len);
246
	if (ret) {
247
		ath10k_err(ar, "could not push board ext data (%d)\n", ret);
248 249 250 251 252
		goto exit;
	}

	ret = ath10k_bmi_read32(ar, hi_board_data, &address);
	if (ret) {
253
		ath10k_err(ar, "could not read board data addr (%d)\n", ret);
254 255 256
		goto exit;
	}

257
	ret = ath10k_bmi_write_memory(ar, address, data,
258
				      min_t(u32, board_data_size,
259
					    data_len));
260
	if (ret) {
261
		ath10k_err(ar, "could not write board data (%d)\n", ret);
262 263 264 265 266
		goto exit;
	}

	ret = ath10k_bmi_write32(ar, hi_board_data_initialized, 1);
	if (ret) {
267
		ath10k_err(ar, "could not write board data bit (%d)\n", ret);
268 269 270 271 272 273 274
		goto exit;
	}

exit:
	return ret;
}

275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
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;
}

297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353
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;
}

354 355
static int ath10k_download_and_run_otp(struct ath10k *ar)
{
356
	u32 result, address = ar->hw_params.patch_load_addr;
357 358
	int ret;

359
	ret = ath10k_download_board_data(ar, ar->board_data, ar->board_len);
360 361 362 363 364
	if (ret) {
		ath10k_err(ar, "failed to download board data: %d\n", ret);
		return ret;
	}

365 366
	/* OTP is optional */

K
Kalle Valo 已提交
367
	if (!ar->otp_data || !ar->otp_len) {
368
		ath10k_warn(ar, "Not running otp, calibration will be incorrect (otp-data %p otp_len %zd)!\n",
369
			    ar->otp_data, ar->otp_len);
370
		return 0;
K
Kalle Valo 已提交
371 372
	}

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

376
	ret = ath10k_bmi_fast_download(ar, address, ar->otp_data, ar->otp_len);
377
	if (ret) {
378
		ath10k_err(ar, "could not write otp (%d)\n", ret);
K
Kalle Valo 已提交
379
		return ret;
380 381
	}

382
	ret = ath10k_bmi_execute(ar, address, 0, &result);
383
	if (ret) {
384
		ath10k_err(ar, "could not execute otp (%d)\n", ret);
K
Kalle Valo 已提交
385
		return ret;
386 387
	}

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

390
	if (!skip_otp && result != 0) {
391
		ath10k_err(ar, "otp calibration failed: %d", result);
K
Kalle Valo 已提交
392 393 394 395
		return -EINVAL;
	}

	return 0;
396 397
}

K
Kalle Valo 已提交
398
static int ath10k_download_fw(struct ath10k *ar, enum ath10k_firmware_mode mode)
399
{
K
Kalle Valo 已提交
400 401 402
	u32 address, data_len;
	const char *mode_name;
	const void *data;
403 404 405 406
	int ret;

	address = ar->hw_params.patch_load_addr;

K
Kalle Valo 已提交
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427
	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);
428
	if (ret) {
K
Kalle Valo 已提交
429 430 431
		ath10k_err(ar, "failed to download %s firmware: %d\n",
			   mode_name, ret);
		return ret;
432 433
	}

434 435 436 437 438
	return ret;
}

static void ath10k_core_free_firmware_files(struct ath10k *ar)
{
439
	if (!IS_ERR(ar->board))
440
		release_firmware(ar->board);
441

442
	if (!IS_ERR(ar->otp))
443 444
		release_firmware(ar->otp);

445
	if (!IS_ERR(ar->firmware))
446 447
		release_firmware(ar->firmware);

448
	if (!IS_ERR(ar->cal_file))
449 450
		release_firmware(ar->cal_file);

451
	ar->board = NULL;
452 453 454
	ar->board_data = NULL;
	ar->board_len = 0;

455
	ar->otp = NULL;
456 457 458
	ar->otp_data = NULL;
	ar->otp_len = 0;

459
	ar->firmware = NULL;
460 461
	ar->firmware_data = NULL;
	ar->firmware_len = 0;
462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482

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

485
static int ath10k_core_fetch_firmware_api_1(struct ath10k *ar)
486 487 488 489
{
	int ret = 0;

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

	if (ar->hw_params.fw.board == NULL) {
495
		ath10k_err(ar, "board data file not defined");
496 497 498
		return -EINVAL;
	}

499 500 501 502 503
	ar->board = ath10k_fetch_fw_file(ar,
					 ar->hw_params.fw.dir,
					 ar->hw_params.fw.board);
	if (IS_ERR(ar->board)) {
		ret = PTR_ERR(ar->board);
504
		ath10k_err(ar, "could not fetch board data (%d)\n", ret);
505 506 507
		goto err;
	}

508 509 510
	ar->board_data = ar->board->data;
	ar->board_len = ar->board->size;

511 512 513 514 515
	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);
516
		ath10k_err(ar, "could not fetch firmware (%d)\n", ret);
517 518 519
		goto err;
	}

520 521 522
	ar->firmware_data = ar->firmware->data;
	ar->firmware_len = ar->firmware->size;

523 524 525 526 527 528 529 530 531
	/* 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);
532
		ath10k_err(ar, "could not fetch otp (%d)\n", ret);
533 534 535
		goto err;
	}

536 537 538
	ar->otp_data = ar->otp->data;
	ar->otp_len = ar->otp->size;

539 540 541 542
	return 0;

err:
	ath10k_core_free_firmware_files(ar);
543 544 545
	return ret;
}

546 547 548 549 550 551
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;
552
	__le32 *timestamp, *version;
553 554 555 556

	/* 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)) {
557
		ath10k_err(ar, "could not fetch firmware file '%s/%s': %ld\n",
558
			   ar->hw_params.fw.dir, name, PTR_ERR(ar->firmware));
559 560 561 562 563 564 565 566 567 568
		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) {
569
		ath10k_err(ar, "firmware file '%s/%s' too small to contain magic: %zu\n",
570
			   ar->hw_params.fw.dir, name, len);
571 572
		ret = -EINVAL;
		goto err;
573 574 575
	}

	if (memcmp(data, ATH10K_FIRMWARE_MAGIC, magic_len) != 0) {
576
		ath10k_err(ar, "invalid firmware magic\n");
577 578
		ret = -EINVAL;
		goto err;
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
	}

	/* 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) {
598
			ath10k_err(ar, "invalid length for FW IE %d (%zu < %zu)\n",
599
				   ie_id, len, ie_len);
600 601
			ret = -EINVAL;
			goto err;
602 603 604 605 606 607 608 609 610 611
		}

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

612
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
613 614 615 616 617 618 619 620 621
				   "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;

622
			ath10k_dbg(ar, ATH10K_DBG_BOOT, "found fw timestamp %d\n",
623 624 625
				   le32_to_cpup(timestamp));
			break;
		case ATH10K_FW_IE_FEATURES:
626
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
627 628 629 630 631 632 633 634 635 636
				   "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;

637
				if (data[index] & (1 << bit)) {
638
					ath10k_dbg(ar, ATH10K_DBG_BOOT,
639 640
						   "Enabling feature bit: %i\n",
						   i);
641
					__set_bit(i, ar->fw_features);
642
				}
643 644
			}

645
			ath10k_dbg_dump(ar, ATH10K_DBG_BOOT, "features", "",
646 647 648 649
					ar->fw_features,
					sizeof(ar->fw_features));
			break;
		case ATH10K_FW_IE_FW_IMAGE:
650
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
651 652 653 654 655 656 657 658
				   "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:
659
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
660 661 662 663 664 665 666
				   "found otp image ie (%zd B)\n",
				   ie_len);

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

			break;
667 668 669 670 671 672 673 674 675 676 677
		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;
678 679 680 681 682 683 684 685 686 687 688
		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;
689
		default:
690
			ath10k_warn(ar, "Unknown FW IE: %u\n",
691 692 693 694 695 696 697 698 699
				    le32_to_cpu(hdr->id));
			break;
		}

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

		len -= ie_len;
		data += ie_len;
700
	}
701 702

	if (!ar->firmware_data || !ar->firmware_len) {
703
		ath10k_warn(ar, "No ATH10K_FW_IE_FW_IMAGE found from '%s/%s', skipping\n",
704
			    ar->hw_params.fw.dir, name);
705 706 707 708 709 710
		ret = -ENOMEDIUM;
		goto err;
	}

	/* now fetch the board file */
	if (ar->hw_params.fw.board == NULL) {
711
		ath10k_err(ar, "board data file not defined");
712 713 714 715 716 717 718 719 720
		ret = -EINVAL;
		goto err;
	}

	ar->board = ath10k_fetch_fw_file(ar,
					 ar->hw_params.fw.dir,
					 ar->hw_params.fw.board);
	if (IS_ERR(ar->board)) {
		ret = PTR_ERR(ar->board);
721
		ath10k_err(ar, "could not fetch board data '%s/%s' (%d)\n",
722 723
			   ar->hw_params.fw.dir, ar->hw_params.fw.board,
			   ret);
724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740
		goto err;
	}

	ar->board_data = ar->board->data;
	ar->board_len = ar->board->size;

	return 0;

err:
	ath10k_core_free_firmware_files(ar);
	return ret;
}

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

741 742 743
	/* calibration file is optional, don't check for any errors */
	ath10k_fetch_cal_file(ar);

K
Kalle Valo 已提交
744 745 746 747 748 749 750
	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;

751 752 753 754 755 756 757
	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;

758
	ar->fw_api = 3;
759
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
760 761 762 763 764

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

765
	ar->fw_api = 2;
766
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
767

768
	ret = ath10k_core_fetch_firmware_api_n(ar, ATH10K_FW_API2_FILE);
769 770 771 772
	if (ret == 0)
		goto success;

	ar->fw_api = 1;
773
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
774 775 776 777 778

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

779
success:
780
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "using fw api %d\n", ar->fw_api);
781 782 783 784

	return 0;
}

785
static int ath10k_download_cal_data(struct ath10k *ar)
786 787 788
{
	int ret;

789 790 791 792 793 794 795
	ret = ath10k_download_cal_file(ar);
	if (ret == 0) {
		ar->cal_mode = ATH10K_CAL_MODE_FILE;
		goto done;
	}

	ath10k_dbg(ar, ATH10K_DBG_BOOT,
796 797 798 799 800 801 802 803 804 805 806
		   "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",
807 808
		   ret);

809
	ret = ath10k_download_and_run_otp(ar);
810
	if (ret) {
811
		ath10k_err(ar, "failed to run otp: %d\n", ret);
812
		return ret;
813
	}
814

815 816 817 818 819 820
	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;
821 822 823 824 825 826 827 828 829 830 831 832
}

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) {
833
		ath10k_warn(ar, "could not disable UART prints (%d)\n", ret);
834 835 836
		return ret;
	}

837
	if (!uart_print)
838 839
		return 0;

840
	ret = ath10k_bmi_write32(ar, hi_dbg_uart_txpin, ar->hw_params.uart_pin);
841
	if (ret) {
842
		ath10k_warn(ar, "could not enable UART prints (%d)\n", ret);
843 844 845 846 847
		return ret;
	}

	ret = ath10k_bmi_write32(ar, hi_serial_enable, 1);
	if (ret) {
848
		ath10k_warn(ar, "could not enable UART prints (%d)\n", ret);
849 850 851
		return ret;
	}

852 853 854
	/* Set the UART baud rate to 19200. */
	ret = ath10k_bmi_write32(ar, hi_desired_baud_rate, 19200);
	if (ret) {
855
		ath10k_warn(ar, "could not set the baud rate (%d)\n", ret);
856 857 858
		return ret;
	}

859
	ath10k_info(ar, "UART prints enabled\n");
860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875
	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)) {
876
		ath10k_err(ar, "Unsupported hardware version: 0x%x\n",
877 878 879 880 881 882
			   ar->target_version);
		return -EINVAL;
	}

	ar->hw_params = *hw_params;

883
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "Hardware name %s version 0x%x\n",
884
		   ar->hw_params.name, ar->target_version);
885 886 887 888

	return 0;
}

889 890 891 892
static void ath10k_core_restart(struct work_struct *work)
{
	struct ath10k *ar = container_of(work, struct ath10k, restart_work);

M
Michal Kazior 已提交
893 894 895 896 897 898 899 900 901 902 903 904 905 906 907
	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);
908
	complete_all(&ar->thermal.wmi_sync);
M
Michal Kazior 已提交
909 910 911 912
	wake_up(&ar->htt.empty_tx_wq);
	wake_up(&ar->wmi.tx_credits_wq);
	wake_up(&ar->peer_mapping_wq);

913 914 915 916 917
	mutex_lock(&ar->conf_mutex);

	switch (ar->state) {
	case ATH10K_STATE_ON:
		ar->state = ATH10K_STATE_RESTARTING;
918
		ath10k_hif_stop(ar);
919
		ath10k_scan_finish(ar);
920 921 922
		ieee80211_restart_hw(ar->hw);
		break;
	case ATH10K_STATE_OFF:
923 924
		/* this can happen if driver is being unloaded
		 * or if the crash happens during FW probing */
925
		ath10k_warn(ar, "cannot restart a device that hasn't been started\n");
926 927
		break;
	case ATH10K_STATE_RESTARTING:
928 929
		/* hw restart might be requested from multiple places */
		break;
930 931 932 933
	case ATH10K_STATE_RESTARTED:
		ar->state = ATH10K_STATE_WEDGED;
		/* fall through */
	case ATH10K_STATE_WEDGED:
934
		ath10k_warn(ar, "device is wedged, will not restart\n");
935
		break;
K
Kalle Valo 已提交
936 937 938
	case ATH10K_STATE_UTF:
		ath10k_warn(ar, "firmware restart in UTF mode not supported\n");
		break;
939 940 941 942 943
	}

	mutex_unlock(&ar->conf_mutex);
}

944
static int ath10k_core_init_firmware_features(struct ath10k *ar)
945
{
946 947 948 949 950 951
	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;
	}

952 953 954 955 956 957 958 959 960 961 962
	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)) {
963 964
			if (test_bit(ATH10K_FW_FEATURE_WMI_10_2,
				     ar->fw_features))
965 966 967 968 969 970 971 972 973 974
				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:
975 976
		ar->max_num_peers = TARGET_NUM_PEERS;
		ar->max_num_stations = TARGET_NUM_STATIONS;
977
		ar->max_num_vdevs = TARGET_NUM_VDEVS;
978
		ar->htt.max_num_pending_tx = TARGET_NUM_MSDU_DESC;
979 980 981
		break;
	case ATH10K_FW_WMI_OP_VERSION_10_1:
	case ATH10K_FW_WMI_OP_VERSION_10_2:
982
	case ATH10K_FW_WMI_OP_VERSION_10_2_4:
983 984
		ar->max_num_peers = TARGET_10X_NUM_PEERS;
		ar->max_num_stations = TARGET_10X_NUM_STATIONS;
985
		ar->max_num_vdevs = TARGET_10X_NUM_VDEVS;
986
		ar->htt.max_num_pending_tx = TARGET_10X_NUM_MSDU_DESC;
987
		break;
M
Michal Kazior 已提交
988 989 990
	case ATH10K_FW_WMI_OP_VERSION_TLV:
		ar->max_num_peers = TARGET_TLV_NUM_PEERS;
		ar->max_num_stations = TARGET_TLV_NUM_STATIONS;
991
		ar->max_num_vdevs = TARGET_TLV_NUM_VDEVS;
M
Michal Kazior 已提交
992
		ar->htt.max_num_pending_tx = TARGET_TLV_NUM_MSDU_DESC;
993
		ar->wow.max_num_patterns = TARGET_TLV_NUM_WOW_PATTERNS;
M
Michal Kazior 已提交
994
		break;
995 996 997 998
	case ATH10K_FW_WMI_OP_VERSION_UNSET:
	case ATH10K_FW_WMI_OP_VERSION_MAX:
		WARN_ON(1);
		return -EINVAL;
999
	}
1000 1001

	return 0;
1002 1003
}

K
Kalle Valo 已提交
1004
int ath10k_core_start(struct ath10k *ar, enum ath10k_firmware_mode mode)
1005 1006 1007
{
	int status;

1008 1009
	lockdep_assert_held(&ar->conf_mutex);

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

1012 1013
	ath10k_bmi_start(ar);

1014 1015 1016 1017 1018
	if (ath10k_init_configure_target(ar)) {
		status = -EINVAL;
		goto err;
	}

1019 1020 1021 1022 1023
	status = ath10k_download_cal_data(ar);
	if (status)
		goto err;

	status = ath10k_download_fw(ar, mode);
1024 1025 1026 1027 1028 1029 1030
	if (status)
		goto err;

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

1031 1032
	ar->htc.htc_ops.target_send_suspend_complete =
		ath10k_send_suspend_complete;
1033

1034 1035
	status = ath10k_htc_init(ar);
	if (status) {
1036
		ath10k_err(ar, "could not init HTC (%d)\n", status);
1037 1038 1039 1040 1041
		goto err;
	}

	status = ath10k_bmi_done(ar);
	if (status)
1042
		goto err;
1043 1044 1045

	status = ath10k_wmi_attach(ar);
	if (status) {
1046
		ath10k_err(ar, "WMI attach failed: %d\n", status);
1047
		goto err;
1048 1049
	}

M
Michal Kazior 已提交
1050 1051
	status = ath10k_htt_init(ar);
	if (status) {
1052
		ath10k_err(ar, "failed to init htt: %d\n", status);
M
Michal Kazior 已提交
1053 1054 1055 1056 1057
		goto err_wmi_detach;
	}

	status = ath10k_htt_tx_alloc(&ar->htt);
	if (status) {
1058
		ath10k_err(ar, "failed to alloc htt tx: %d\n", status);
M
Michal Kazior 已提交
1059 1060 1061 1062 1063
		goto err_wmi_detach;
	}

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

M
Michal Kazior 已提交
1068 1069
	status = ath10k_hif_start(ar);
	if (status) {
1070
		ath10k_err(ar, "could not start HIF: %d\n", status);
M
Michal Kazior 已提交
1071
		goto err_htt_rx_detach;
M
Michal Kazior 已提交
1072 1073 1074 1075
	}

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

K
Kalle Valo 已提交
1080 1081 1082 1083 1084 1085
	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;
		}
1086 1087
	}

M
Michal Kazior 已提交
1088 1089
	status = ath10k_wmi_connect(ar);
	if (status) {
1090
		ath10k_err(ar, "could not connect wmi: %d\n", status);
M
Michal Kazior 已提交
1091 1092 1093 1094 1095
		goto err_hif_stop;
	}

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

K
Kalle Valo 已提交
1100 1101 1102 1103 1104 1105 1106
	if (mode == ATH10K_FIRMWARE_MODE_NORMAL) {
		status = ath10k_wmi_wait_for_service_ready(ar);
		if (status <= 0) {
			ath10k_warn(ar, "wmi service ready event not received");
			status = -ETIMEDOUT;
			goto err_hif_stop;
		}
M
Michal Kazior 已提交
1107
	}
1108

1109
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "firmware %s booted\n",
1110
		   ar->hw->wiphy->fw_version);
1111 1112 1113

	status = ath10k_wmi_cmd_init(ar);
	if (status) {
1114 1115
		ath10k_err(ar, "could not send WMI init command (%d)\n",
			   status);
M
Michal Kazior 已提交
1116
		goto err_hif_stop;
1117 1118 1119 1120
	}

	status = ath10k_wmi_wait_for_unified_ready(ar);
	if (status <= 0) {
1121
		ath10k_err(ar, "wmi unified ready event not received\n");
1122
		status = -ETIMEDOUT;
M
Michal Kazior 已提交
1123
		goto err_hif_stop;
1124 1125
	}

1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137
	/* 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 已提交
1138 1139 1140 1141 1142 1143 1144
	/* 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 已提交
1145
	}
1146

1147 1148
	status = ath10k_debug_start(ar);
	if (status)
M
Michal Kazior 已提交
1149
		goto err_hif_stop;
1150

1151
	ar->free_vdev_map = (1LL << ar->max_num_vdevs) - 1;
1152

M
Michal Kazior 已提交
1153
	INIT_LIST_HEAD(&ar->arvifs);
1154

1155 1156
	return 0;

M
Michal Kazior 已提交
1157 1158
err_hif_stop:
	ath10k_hif_stop(ar);
M
Michal Kazior 已提交
1159 1160 1161 1162
err_htt_rx_detach:
	ath10k_htt_rx_free(&ar->htt);
err_htt_tx_detach:
	ath10k_htt_tx_free(&ar->htt);
1163 1164 1165 1166 1167
err_wmi_detach:
	ath10k_wmi_detach(ar);
err:
	return status;
}
1168
EXPORT_SYMBOL(ath10k_core_start);
1169

1170 1171 1172 1173 1174 1175 1176 1177
int ath10k_wait_for_suspend(struct ath10k *ar, u32 suspend_opt)
{
	int ret;

	reinit_completion(&ar->target_suspend);

	ret = ath10k_wmi_pdev_suspend_target(ar, suspend_opt);
	if (ret) {
1178
		ath10k_warn(ar, "could not suspend target (%d)\n", ret);
1179 1180 1181 1182 1183 1184
		return ret;
	}

	ret = wait_for_completion_timeout(&ar->target_suspend, 1 * HZ);

	if (ret == 0) {
1185
		ath10k_warn(ar, "suspend timed out - target pause event never came\n");
1186 1187 1188 1189 1190 1191
		return -ETIMEDOUT;
	}

	return 0;
}

1192 1193
void ath10k_core_stop(struct ath10k *ar)
{
1194 1195
	lockdep_assert_held(&ar->conf_mutex);

1196
	/* try to suspend target */
K
Kalle Valo 已提交
1197 1198
	if (ar->state != ATH10K_STATE_RESTARTING &&
	    ar->state != ATH10K_STATE_UTF)
1199 1200
		ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND_AND_DISABLE_INTR);

1201
	ath10k_debug_stop(ar);
M
Michal Kazior 已提交
1202 1203 1204
	ath10k_hif_stop(ar);
	ath10k_htt_tx_free(&ar->htt);
	ath10k_htt_rx_free(&ar->htt);
1205 1206
	ath10k_wmi_detach(ar);
}
1207 1208 1209 1210 1211 1212 1213 1214
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)
{
1215 1216
	struct bmi_target_info target_info;
	int ret = 0;
1217 1218 1219

	ret = ath10k_hif_power_up(ar);
	if (ret) {
1220
		ath10k_err(ar, "could not start pci hif (%d)\n", ret);
1221 1222 1223
		return ret;
	}

1224 1225 1226
	memset(&target_info, 0, sizeof(target_info));
	ret = ath10k_bmi_get_target_info(ar, &target_info);
	if (ret) {
1227
		ath10k_err(ar, "could not get target info (%d)\n", ret);
1228
		goto err_power_down;
1229 1230 1231 1232 1233 1234 1235
	}

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

	ret = ath10k_init_hw_params(ar);
	if (ret) {
1236
		ath10k_err(ar, "could not get hw params (%d)\n", ret);
1237
		goto err_power_down;
1238 1239 1240 1241
	}

	ret = ath10k_core_fetch_firmware_files(ar);
	if (ret) {
1242
		ath10k_err(ar, "could not fetch firmware files (%d)\n", ret);
1243
		goto err_power_down;
1244 1245
	}

1246 1247 1248 1249 1250 1251
	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;
	}
1252

1253 1254
	mutex_lock(&ar->conf_mutex);

K
Kalle Valo 已提交
1255
	ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
1256
	if (ret) {
1257
		ath10k_err(ar, "could not init core (%d)\n", ret);
1258
		goto err_unlock;
1259 1260
	}

M
Michal Kazior 已提交
1261
	ath10k_print_driver_info(ar);
1262
	ath10k_core_stop(ar);
1263 1264 1265

	mutex_unlock(&ar->conf_mutex);

1266 1267
	ath10k_hif_power_down(ar);
	return 0;
1268 1269 1270 1271

err_unlock:
	mutex_unlock(&ar->conf_mutex);

1272
err_free_firmware_files:
1273 1274 1275 1276 1277 1278
	ath10k_core_free_firmware_files(ar);

err_power_down:
	ath10k_hif_power_down(ar);

	return ret;
1279
}
1280

1281
static void ath10k_core_register_work(struct work_struct *work)
1282
{
1283
	struct ath10k *ar = container_of(work, struct ath10k, register_work);
1284 1285
	int status;

1286 1287
	status = ath10k_core_probe_fw(ar);
	if (status) {
1288
		ath10k_err(ar, "could not probe fw (%d)\n", status);
1289
		goto err;
1290
	}
1291

1292
	status = ath10k_mac_register(ar);
1293
	if (status) {
1294
		ath10k_err(ar, "could not register to mac80211 (%d)\n", status);
1295
		goto err_release_fw;
1296
	}
1297

1298
	status = ath10k_debug_register(ar);
1299
	if (status) {
1300
		ath10k_err(ar, "unable to initialize debugfs\n");
1301 1302 1303
		goto err_unregister_mac;
	}

1304 1305
	status = ath10k_spectral_create(ar);
	if (status) {
1306
		ath10k_err(ar, "failed to initialize spectral\n");
1307 1308 1309
		goto err_debug_destroy;
	}

1310 1311 1312 1313 1314 1315 1316
	status = ath10k_thermal_register(ar);
	if (status) {
		ath10k_err(ar, "could not register thermal device: %d\n",
			   status);
		goto err_spectral_destroy;
	}

1317 1318
	set_bit(ATH10K_FLAG_CORE_REGISTERED, &ar->dev_flags);
	return;
1319

1320 1321
err_spectral_destroy:
	ath10k_spectral_destroy(ar);
1322 1323
err_debug_destroy:
	ath10k_debug_destroy(ar);
1324 1325
err_unregister_mac:
	ath10k_mac_unregister(ar);
1326 1327
err_release_fw:
	ath10k_core_free_firmware_files(ar);
1328
err:
1329 1330 1331
	/* TODO: It's probably a good idea to release device from the driver
	 * but calling device_release_driver() here will cause a deadlock.
	 */
1332 1333 1334 1335 1336 1337 1338 1339 1340
	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;
1341 1342 1343 1344 1345
}
EXPORT_SYMBOL(ath10k_core_register);

void ath10k_core_unregister(struct ath10k *ar)
{
1346 1347 1348 1349 1350
	cancel_work_sync(&ar->register_work);

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

1351
	ath10k_thermal_unregister(ar);
1352 1353 1354 1355 1356 1357
	/* 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);

1358 1359 1360 1361
	/* 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);
1362

K
Kalle Valo 已提交
1363 1364
	ath10k_testmode_destroy(ar);

1365
	ath10k_core_free_firmware_files(ar);
1366

1367
	ath10k_debug_unregister(ar);
1368 1369 1370
}
EXPORT_SYMBOL(ath10k_core_unregister);

M
Michal Kazior 已提交
1371
struct ath10k *ath10k_core_create(size_t priv_size, struct device *dev,
K
Kalle Valo 已提交
1372
				  enum ath10k_bus bus,
M
Michal Kazior 已提交
1373
				  enum ath10k_hw_rev hw_rev,
1374 1375 1376
				  const struct ath10k_hif_ops *hif_ops)
{
	struct ath10k *ar;
1377
	int ret;
1378

M
Michal Kazior 已提交
1379
	ar = ath10k_mac_create(priv_size);
1380 1381 1382 1383 1384 1385
	if (!ar)
		return NULL;

	ar->ath_common.priv = ar;
	ar->ath_common.hw = ar->hw;
	ar->dev = dev;
M
Michal Kazior 已提交
1386
	ar->hw_rev = hw_rev;
1387
	ar->hif.ops = hif_ops;
K
Kalle Valo 已提交
1388
	ar->hif.bus = bus;
1389

M
Michal Kazior 已提交
1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403
	switch (hw_rev) {
	case ATH10K_HW_QCA988X:
		ar->regs = &qca988x_regs;
		break;
	case ATH10K_HW_QCA6174:
		ar->regs = &qca6174_regs;
		break;
	default:
		ath10k_err(ar, "unsupported core hardware revision %d\n",
			   hw_rev);
		ret = -ENOTSUPP;
		goto err_free_mac;
	}

1404 1405 1406 1407
	init_completion(&ar->scan.started);
	init_completion(&ar->scan.completed);
	init_completion(&ar->scan.on_channel);
	init_completion(&ar->target_suspend);
1408
	init_completion(&ar->wow.wakeup_completed);
1409 1410 1411

	init_completion(&ar->install_key_done);
	init_completion(&ar->vdev_setup_done);
1412
	init_completion(&ar->thermal.wmi_sync);
1413

1414
	INIT_DELAYED_WORK(&ar->scan.timeout, ath10k_scan_timeout_work);
1415 1416 1417

	ar->workqueue = create_singlethread_workqueue("ath10k_wq");
	if (!ar->workqueue)
1418
		goto err_free_mac;
1419 1420 1421 1422 1423 1424

	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 已提交
1425 1426
	init_waitqueue_head(&ar->htt.empty_tx_wq);
	init_waitqueue_head(&ar->wmi.tx_credits_wq);
1427 1428 1429 1430 1431 1432 1433 1434

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

1435
	INIT_WORK(&ar->register_work, ath10k_core_register_work);
1436 1437
	INIT_WORK(&ar->restart_work, ath10k_core_restart);

1438 1439 1440 1441
	ret = ath10k_debug_create(ar);
	if (ret)
		goto err_free_wq;

1442 1443
	return ar;

1444 1445 1446 1447
err_free_wq:
	destroy_workqueue(ar->workqueue);

err_free_mac:
1448
	ath10k_mac_destroy(ar);
1449

1450 1451 1452 1453 1454 1455 1456 1457 1458
	return NULL;
}
EXPORT_SYMBOL(ath10k_core_create);

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

1459
	ath10k_debug_destroy(ar);
1460 1461 1462 1463
	ath10k_mac_destroy(ar);
}
EXPORT_SYMBOL(ath10k_core_destroy);

1464 1465 1466
MODULE_AUTHOR("Qualcomm Atheros");
MODULE_DESCRIPTION("Core module for QCA988X PCIe devices.");
MODULE_LICENSE("Dual BSD/GPL");