core.c 31.7 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 60 61 62 63
		},
	},
};

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

66
	complete(&ar->target_suspend);
67 68 69 70 71 72 73 74 75 76 77
}

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) {
78
		ath10k_err(ar, "settings HTC version failed\n");
79 80 81 82 83 84
		return ret;
	}

	/* set the firmware mode to STA/IBSS/AP */
	ret = ath10k_bmi_read32(ar, hi_option_flag, &param_host);
	if (ret) {
85
		ath10k_err(ar, "setting firmware mode (1/2) failed\n");
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
		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) {
104
		ath10k_err(ar, "setting firmware mode (2/2) failed\n");
105 106 107 108 109 110
		return ret;
	}

	/* We do all byte-swapping on the host */
	ret = ath10k_bmi_write32(ar, hi_be, 0);
	if (ret) {
111
		ath10k_err(ar, "setting host CPU BE mode failed\n");
112 113 114 115 116 117 118
		return ret;
	}

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

	if (ret) {
119
		ath10k_err(ar, "setting FW data/desc swap flags failed\n");
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
		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;
}

148 149
static int ath10k_push_board_ext_data(struct ath10k *ar, const void *data,
				      size_t data_len)
150
{
151 152
	u32 board_data_size = ar->hw_params.fw.board_size;
	u32 board_ext_data_size = ar->hw_params.fw.board_ext_size;
153 154 155 156 157
	u32 board_ext_data_addr;
	int ret;

	ret = ath10k_bmi_read32(ar, hi_board_ext_data, &board_ext_data_addr);
	if (ret) {
158 159
		ath10k_err(ar, "could not read board ext data addr (%d)\n",
			   ret);
160 161 162
		return ret;
	}

163
	ath10k_dbg(ar, ATH10K_DBG_BOOT,
164
		   "boot push board extended data addr 0x%x\n",
165 166 167 168 169
		   board_ext_data_addr);

	if (board_ext_data_addr == 0)
		return 0;

170
	if (data_len != (board_data_size + board_ext_data_size)) {
171
		ath10k_err(ar, "invalid board (ext) data sizes %zu != %d+%d\n",
172
			   data_len, board_data_size, board_ext_data_size);
173 174 175 176
		return -EINVAL;
	}

	ret = ath10k_bmi_write_memory(ar, board_ext_data_addr,
177
				      data + board_data_size,
178 179
				      board_ext_data_size);
	if (ret) {
180
		ath10k_err(ar, "could not write board ext data (%d)\n", ret);
181 182 183 184 185 186
		return ret;
	}

	ret = ath10k_bmi_write32(ar, hi_board_ext_data_config,
				 (board_ext_data_size << 16) | 1);
	if (ret) {
187 188
		ath10k_err(ar, "could not write board ext data bit (%d)\n",
			   ret);
189 190 191 192 193 194
		return ret;
	}

	return 0;
}

195 196
static int ath10k_download_board_data(struct ath10k *ar, const void *data,
				      size_t data_len)
197
{
198
	u32 board_data_size = ar->hw_params.fw.board_size;
199 200 201
	u32 address;
	int ret;

202
	ret = ath10k_push_board_ext_data(ar, data, data_len);
203
	if (ret) {
204
		ath10k_err(ar, "could not push board ext data (%d)\n", ret);
205 206 207 208 209
		goto exit;
	}

	ret = ath10k_bmi_read32(ar, hi_board_data, &address);
	if (ret) {
210
		ath10k_err(ar, "could not read board data addr (%d)\n", ret);
211 212 213
		goto exit;
	}

214
	ret = ath10k_bmi_write_memory(ar, address, data,
215
				      min_t(u32, board_data_size,
216
					    data_len));
217
	if (ret) {
218
		ath10k_err(ar, "could not write board data (%d)\n", ret);
219 220 221 222 223
		goto exit;
	}

	ret = ath10k_bmi_write32(ar, hi_board_data_initialized, 1);
	if (ret) {
224
		ath10k_err(ar, "could not write board data bit (%d)\n", ret);
225 226 227 228 229 230 231
		goto exit;
	}

exit:
	return ret;
}

232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253
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;
}

254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
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;
}

311 312
static int ath10k_download_and_run_otp(struct ath10k *ar)
{
313
	u32 result, address = ar->hw_params.patch_load_addr;
314 315
	int ret;

316
	ret = ath10k_download_board_data(ar, ar->board_data, ar->board_len);
317 318 319 320 321
	if (ret) {
		ath10k_err(ar, "failed to download board data: %d\n", ret);
		return ret;
	}

322 323
	/* OTP is optional */

K
Kalle Valo 已提交
324
	if (!ar->otp_data || !ar->otp_len) {
325
		ath10k_warn(ar, "Not running otp, calibration will be incorrect (otp-data %p otp_len %zd)!\n",
326
			    ar->otp_data, ar->otp_len);
327
		return 0;
K
Kalle Valo 已提交
328 329
	}

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

333
	ret = ath10k_bmi_fast_download(ar, address, ar->otp_data, ar->otp_len);
334
	if (ret) {
335
		ath10k_err(ar, "could not write otp (%d)\n", ret);
K
Kalle Valo 已提交
336
		return ret;
337 338
	}

339
	ret = ath10k_bmi_execute(ar, address, 0, &result);
340
	if (ret) {
341
		ath10k_err(ar, "could not execute otp (%d)\n", ret);
K
Kalle Valo 已提交
342
		return ret;
343 344
	}

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

347
	if (!skip_otp && result != 0) {
348
		ath10k_err(ar, "otp calibration failed: %d", result);
K
Kalle Valo 已提交
349 350 351 352
		return -EINVAL;
	}

	return 0;
353 354
}

K
Kalle Valo 已提交
355
static int ath10k_download_fw(struct ath10k *ar, enum ath10k_firmware_mode mode)
356
{
K
Kalle Valo 已提交
357 358 359
	u32 address, data_len;
	const char *mode_name;
	const void *data;
360 361 362 363
	int ret;

	address = ar->hw_params.patch_load_addr;

K
Kalle Valo 已提交
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384
	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);
385
	if (ret) {
K
Kalle Valo 已提交
386 387 388
		ath10k_err(ar, "failed to download %s firmware: %d\n",
			   mode_name, ret);
		return ret;
389 390
	}

391 392 393 394 395
	return ret;
}

static void ath10k_core_free_firmware_files(struct ath10k *ar)
{
396 397
	if (ar->board && !IS_ERR(ar->board))
		release_firmware(ar->board);
398 399 400 401 402 403 404

	if (ar->otp && !IS_ERR(ar->otp))
		release_firmware(ar->otp);

	if (ar->firmware && !IS_ERR(ar->firmware))
		release_firmware(ar->firmware);

405 406 407
	if (ar->cal_file && !IS_ERR(ar->cal_file))
		release_firmware(ar->cal_file);

408
	ar->board = NULL;
409 410 411
	ar->board_data = NULL;
	ar->board_len = 0;

412
	ar->otp = NULL;
413 414 415
	ar->otp_data = NULL;
	ar->otp_len = 0;

416
	ar->firmware = NULL;
417 418
	ar->firmware_data = NULL;
	ar->firmware_len = 0;
419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439

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

442
static int ath10k_core_fetch_firmware_api_1(struct ath10k *ar)
443 444 445 446
{
	int ret = 0;

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

	if (ar->hw_params.fw.board == NULL) {
452
		ath10k_err(ar, "board data file not defined");
453 454 455
		return -EINVAL;
	}

456 457 458 459 460
	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);
461
		ath10k_err(ar, "could not fetch board data (%d)\n", ret);
462 463 464
		goto err;
	}

465 466 467
	ar->board_data = ar->board->data;
	ar->board_len = ar->board->size;

468 469 470 471 472
	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);
473
		ath10k_err(ar, "could not fetch firmware (%d)\n", ret);
474 475 476
		goto err;
	}

477 478 479
	ar->firmware_data = ar->firmware->data;
	ar->firmware_len = ar->firmware->size;

480 481 482 483 484 485 486 487 488
	/* 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);
489
		ath10k_err(ar, "could not fetch otp (%d)\n", ret);
490 491 492
		goto err;
	}

493 494 495
	ar->otp_data = ar->otp->data;
	ar->otp_len = ar->otp->size;

496 497 498 499
	return 0;

err:
	ath10k_core_free_firmware_files(ar);
500 501 502
	return ret;
}

503 504 505 506 507 508
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;
509
	__le32 *timestamp, *version;
510 511 512 513

	/* 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)) {
514
		ath10k_err(ar, "could not fetch firmware file '%s/%s': %ld\n",
515
			   ar->hw_params.fw.dir, name, PTR_ERR(ar->firmware));
516 517 518 519 520 521 522 523 524 525
		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) {
526
		ath10k_err(ar, "firmware file '%s/%s' too small to contain magic: %zu\n",
527
			   ar->hw_params.fw.dir, name, len);
528 529
		ret = -EINVAL;
		goto err;
530 531 532
	}

	if (memcmp(data, ATH10K_FIRMWARE_MAGIC, magic_len) != 0) {
533
		ath10k_err(ar, "invalid firmware magic\n");
534 535
		ret = -EINVAL;
		goto err;
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
	}

	/* 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) {
555
			ath10k_err(ar, "invalid length for FW IE %d (%zu < %zu)\n",
556
				   ie_id, len, ie_len);
557 558
			ret = -EINVAL;
			goto err;
559 560 561 562 563 564 565 566 567 568
		}

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

569
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
570 571 572 573 574 575 576 577 578
				   "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;

579
			ath10k_dbg(ar, ATH10K_DBG_BOOT, "found fw timestamp %d\n",
580 581 582
				   le32_to_cpup(timestamp));
			break;
		case ATH10K_FW_IE_FEATURES:
583
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
584 585 586 587 588 589 590 591 592 593
				   "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;

594
				if (data[index] & (1 << bit)) {
595
					ath10k_dbg(ar, ATH10K_DBG_BOOT,
596 597
						   "Enabling feature bit: %i\n",
						   i);
598
					__set_bit(i, ar->fw_features);
599
				}
600 601
			}

602
			ath10k_dbg_dump(ar, ATH10K_DBG_BOOT, "features", "",
603 604 605 606
					ar->fw_features,
					sizeof(ar->fw_features));
			break;
		case ATH10K_FW_IE_FW_IMAGE:
607
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
608 609 610 611 612 613 614 615
				   "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:
616
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
617 618 619 620 621 622 623
				   "found otp image ie (%zd B)\n",
				   ie_len);

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

			break;
624 625 626 627 628 629 630 631 632 633 634
		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;
635
		default:
636
			ath10k_warn(ar, "Unknown FW IE: %u\n",
637 638 639 640 641 642 643 644 645
				    le32_to_cpu(hdr->id));
			break;
		}

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

		len -= ie_len;
		data += ie_len;
646
	}
647 648

	if (!ar->firmware_data || !ar->firmware_len) {
649
		ath10k_warn(ar, "No ATH10K_FW_IE_FW_IMAGE found from '%s/%s', skipping\n",
650
			    ar->hw_params.fw.dir, name);
651 652 653 654 655 656
		ret = -ENOMEDIUM;
		goto err;
	}

	/* now fetch the board file */
	if (ar->hw_params.fw.board == NULL) {
657
		ath10k_err(ar, "board data file not defined");
658 659 660 661 662 663 664 665 666
		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);
667
		ath10k_err(ar, "could not fetch board data '%s/%s' (%d)\n",
668 669
			   ar->hw_params.fw.dir, ar->hw_params.fw.board,
			   ret);
670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686
		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;

687 688 689
	/* calibration file is optional, don't check for any errors */
	ath10k_fetch_cal_file(ar);

690
	ar->fw_api = 3;
691
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
692 693 694 695 696

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

697
	ar->fw_api = 2;
698
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
699

700
	ret = ath10k_core_fetch_firmware_api_n(ar, ATH10K_FW_API2_FILE);
701 702 703 704
	if (ret == 0)
		goto success;

	ar->fw_api = 1;
705
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
706 707 708 709 710

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

711
success:
712
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "using fw api %d\n", ar->fw_api);
713 714 715 716

	return 0;
}

717
static int ath10k_download_cal_data(struct ath10k *ar)
718 719 720
{
	int ret;

721 722 723 724 725 726 727
	ret = ath10k_download_cal_file(ar);
	if (ret == 0) {
		ar->cal_mode = ATH10K_CAL_MODE_FILE;
		goto done;
	}

	ath10k_dbg(ar, ATH10K_DBG_BOOT,
728 729 730 731 732 733 734 735 736 737 738
		   "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",
739 740
		   ret);

741
	ret = ath10k_download_and_run_otp(ar);
742
	if (ret) {
743
		ath10k_err(ar, "failed to run otp: %d\n", ret);
744
		return ret;
745
	}
746

747 748 749 750 751 752
	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;
753 754 755 756 757 758 759 760 761 762 763 764
}

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) {
765
		ath10k_warn(ar, "could not disable UART prints (%d)\n", ret);
766 767 768
		return ret;
	}

769
	if (!uart_print)
770 771
		return 0;

772
	ret = ath10k_bmi_write32(ar, hi_dbg_uart_txpin, ar->hw_params.uart_pin);
773
	if (ret) {
774
		ath10k_warn(ar, "could not enable UART prints (%d)\n", ret);
775 776 777 778 779
		return ret;
	}

	ret = ath10k_bmi_write32(ar, hi_serial_enable, 1);
	if (ret) {
780
		ath10k_warn(ar, "could not enable UART prints (%d)\n", ret);
781 782 783
		return ret;
	}

784 785 786
	/* Set the UART baud rate to 19200. */
	ret = ath10k_bmi_write32(ar, hi_desired_baud_rate, 19200);
	if (ret) {
787
		ath10k_warn(ar, "could not set the baud rate (%d)\n", ret);
788 789 790
		return ret;
	}

791
	ath10k_info(ar, "UART prints enabled\n");
792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807
	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)) {
808
		ath10k_err(ar, "Unsupported hardware version: 0x%x\n",
809 810 811 812 813 814
			   ar->target_version);
		return -EINVAL;
	}

	ar->hw_params = *hw_params;

815
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "Hardware name %s version 0x%x\n",
816
		   ar->hw_params.name, ar->target_version);
817 818 819 820

	return 0;
}

821 822 823 824
static void ath10k_core_restart(struct work_struct *work)
{
	struct ath10k *ar = container_of(work, struct ath10k, restart_work);

M
Michal Kazior 已提交
825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843
	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);
	wake_up(&ar->htt.empty_tx_wq);
	wake_up(&ar->wmi.tx_credits_wq);
	wake_up(&ar->peer_mapping_wq);

844 845 846 847 848
	mutex_lock(&ar->conf_mutex);

	switch (ar->state) {
	case ATH10K_STATE_ON:
		ar->state = ATH10K_STATE_RESTARTING;
849
		ath10k_hif_stop(ar);
850
		ath10k_scan_finish(ar);
851 852 853
		ieee80211_restart_hw(ar->hw);
		break;
	case ATH10K_STATE_OFF:
854 855
		/* this can happen if driver is being unloaded
		 * or if the crash happens during FW probing */
856
		ath10k_warn(ar, "cannot restart a device that hasn't been started\n");
857 858
		break;
	case ATH10K_STATE_RESTARTING:
859 860
		/* hw restart might be requested from multiple places */
		break;
861 862 863 864
	case ATH10K_STATE_RESTARTED:
		ar->state = ATH10K_STATE_WEDGED;
		/* fall through */
	case ATH10K_STATE_WEDGED:
865
		ath10k_warn(ar, "device is wedged, will not restart\n");
866
		break;
K
Kalle Valo 已提交
867 868 869
	case ATH10K_STATE_UTF:
		ath10k_warn(ar, "firmware restart in UTF mode not supported\n");
		break;
870 871 872 873 874
	}

	mutex_unlock(&ar->conf_mutex);
}

875
static int ath10k_core_init_firmware_features(struct ath10k *ar)
876
{
877 878 879 880 881 882
	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;
	}

883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904
	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)) {
			if (test_bit(ATH10K_FW_FEATURE_WMI_10_2, ar->fw_features))
				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:
905 906
		ar->max_num_peers = TARGET_NUM_PEERS;
		ar->max_num_stations = TARGET_NUM_STATIONS;
907
		ar->htt.max_num_pending_tx = TARGET_NUM_MSDU_DESC;
908 909 910 911 912
		break;
	case ATH10K_FW_WMI_OP_VERSION_10_1:
	case ATH10K_FW_WMI_OP_VERSION_10_2:
		ar->max_num_peers = TARGET_10X_NUM_PEERS;
		ar->max_num_stations = TARGET_10X_NUM_STATIONS;
913
		ar->htt.max_num_pending_tx = TARGET_10X_NUM_MSDU_DESC;
914
		break;
M
Michal Kazior 已提交
915 916 917 918 919
	case ATH10K_FW_WMI_OP_VERSION_TLV:
		ar->max_num_peers = TARGET_TLV_NUM_PEERS;
		ar->max_num_stations = TARGET_TLV_NUM_STATIONS;
		ar->htt.max_num_pending_tx = TARGET_TLV_NUM_MSDU_DESC;
		break;
920 921 922 923
	case ATH10K_FW_WMI_OP_VERSION_UNSET:
	case ATH10K_FW_WMI_OP_VERSION_MAX:
		WARN_ON(1);
		return -EINVAL;
924
	}
925 926

	return 0;
927 928
}

K
Kalle Valo 已提交
929
int ath10k_core_start(struct ath10k *ar, enum ath10k_firmware_mode mode)
930 931 932
{
	int status;

933 934
	lockdep_assert_held(&ar->conf_mutex);

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

937 938
	ath10k_bmi_start(ar);

939 940 941 942 943
	if (ath10k_init_configure_target(ar)) {
		status = -EINVAL;
		goto err;
	}

944 945 946 947 948
	status = ath10k_download_cal_data(ar);
	if (status)
		goto err;

	status = ath10k_download_fw(ar, mode);
949 950 951 952 953 954 955
	if (status)
		goto err;

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

956 957
	ar->htc.htc_ops.target_send_suspend_complete =
		ath10k_send_suspend_complete;
958

959 960
	status = ath10k_htc_init(ar);
	if (status) {
961
		ath10k_err(ar, "could not init HTC (%d)\n", status);
962 963 964 965 966
		goto err;
	}

	status = ath10k_bmi_done(ar);
	if (status)
967
		goto err;
968 969 970

	status = ath10k_wmi_attach(ar);
	if (status) {
971
		ath10k_err(ar, "WMI attach failed: %d\n", status);
972
		goto err;
973 974
	}

M
Michal Kazior 已提交
975 976
	status = ath10k_htt_init(ar);
	if (status) {
977
		ath10k_err(ar, "failed to init htt: %d\n", status);
M
Michal Kazior 已提交
978 979 980 981 982
		goto err_wmi_detach;
	}

	status = ath10k_htt_tx_alloc(&ar->htt);
	if (status) {
983
		ath10k_err(ar, "failed to alloc htt tx: %d\n", status);
M
Michal Kazior 已提交
984 985 986 987 988
		goto err_wmi_detach;
	}

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

M
Michal Kazior 已提交
993 994
	status = ath10k_hif_start(ar);
	if (status) {
995
		ath10k_err(ar, "could not start HIF: %d\n", status);
M
Michal Kazior 已提交
996
		goto err_htt_rx_detach;
M
Michal Kazior 已提交
997 998 999 1000
	}

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

K
Kalle Valo 已提交
1005 1006 1007 1008 1009 1010
	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;
		}
1011 1012
	}

M
Michal Kazior 已提交
1013 1014
	status = ath10k_wmi_connect(ar);
	if (status) {
1015
		ath10k_err(ar, "could not connect wmi: %d\n", status);
M
Michal Kazior 已提交
1016 1017 1018 1019 1020
		goto err_hif_stop;
	}

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

K
Kalle Valo 已提交
1025 1026 1027 1028 1029 1030 1031
	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 已提交
1032
	}
1033

1034
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "firmware %s booted\n",
1035
		   ar->hw->wiphy->fw_version);
1036 1037 1038

	status = ath10k_wmi_cmd_init(ar);
	if (status) {
1039 1040
		ath10k_err(ar, "could not send WMI init command (%d)\n",
			   status);
M
Michal Kazior 已提交
1041
		goto err_hif_stop;
1042 1043 1044 1045
	}

	status = ath10k_wmi_wait_for_unified_ready(ar);
	if (status <= 0) {
1046
		ath10k_err(ar, "wmi unified ready event not received\n");
1047
		status = -ETIMEDOUT;
M
Michal Kazior 已提交
1048
		goto err_hif_stop;
1049 1050
	}

K
Kalle Valo 已提交
1051 1052 1053 1054 1055 1056 1057
	/* 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 已提交
1058
	}
1059

1060 1061
	status = ath10k_debug_start(ar);
	if (status)
M
Michal Kazior 已提交
1062
		goto err_hif_stop;
1063

1064
	if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features))
B
Ben Greear 已提交
1065
		ar->free_vdev_map = (1LL << TARGET_10X_NUM_VDEVS) - 1;
1066
	else
B
Ben Greear 已提交
1067
		ar->free_vdev_map = (1LL << TARGET_NUM_VDEVS) - 1;
1068

M
Michal Kazior 已提交
1069
	INIT_LIST_HEAD(&ar->arvifs);
1070

1071 1072
	return 0;

M
Michal Kazior 已提交
1073 1074
err_hif_stop:
	ath10k_hif_stop(ar);
M
Michal Kazior 已提交
1075 1076 1077 1078
err_htt_rx_detach:
	ath10k_htt_rx_free(&ar->htt);
err_htt_tx_detach:
	ath10k_htt_tx_free(&ar->htt);
1079 1080 1081 1082 1083
err_wmi_detach:
	ath10k_wmi_detach(ar);
err:
	return status;
}
1084
EXPORT_SYMBOL(ath10k_core_start);
1085

1086 1087 1088 1089 1090 1091 1092 1093
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) {
1094
		ath10k_warn(ar, "could not suspend target (%d)\n", ret);
1095 1096 1097 1098 1099 1100
		return ret;
	}

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

	if (ret == 0) {
1101
		ath10k_warn(ar, "suspend timed out - target pause event never came\n");
1102 1103 1104 1105 1106 1107
		return -ETIMEDOUT;
	}

	return 0;
}

1108 1109
void ath10k_core_stop(struct ath10k *ar)
{
1110 1111
	lockdep_assert_held(&ar->conf_mutex);

1112
	/* try to suspend target */
K
Kalle Valo 已提交
1113 1114
	if (ar->state != ATH10K_STATE_RESTARTING &&
	    ar->state != ATH10K_STATE_UTF)
1115 1116
		ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND_AND_DISABLE_INTR);

1117
	ath10k_debug_stop(ar);
M
Michal Kazior 已提交
1118 1119 1120
	ath10k_hif_stop(ar);
	ath10k_htt_tx_free(&ar->htt);
	ath10k_htt_rx_free(&ar->htt);
1121 1122
	ath10k_wmi_detach(ar);
}
1123 1124 1125 1126 1127 1128 1129 1130
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)
{
1131 1132
	struct bmi_target_info target_info;
	int ret = 0;
1133 1134 1135

	ret = ath10k_hif_power_up(ar);
	if (ret) {
1136
		ath10k_err(ar, "could not start pci hif (%d)\n", ret);
1137 1138 1139
		return ret;
	}

1140 1141 1142
	memset(&target_info, 0, sizeof(target_info));
	ret = ath10k_bmi_get_target_info(ar, &target_info);
	if (ret) {
1143
		ath10k_err(ar, "could not get target info (%d)\n", ret);
1144
		goto err_power_down;
1145 1146 1147 1148 1149 1150 1151
	}

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

	ret = ath10k_init_hw_params(ar);
	if (ret) {
1152
		ath10k_err(ar, "could not get hw params (%d)\n", ret);
1153
		goto err_power_down;
1154 1155 1156 1157
	}

	ret = ath10k_core_fetch_firmware_files(ar);
	if (ret) {
1158
		ath10k_err(ar, "could not fetch firmware files (%d)\n", ret);
1159
		goto err_power_down;
1160 1161
	}

1162 1163 1164 1165 1166 1167
	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;
	}
1168

1169 1170
	mutex_lock(&ar->conf_mutex);

K
Kalle Valo 已提交
1171
	ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
1172
	if (ret) {
1173
		ath10k_err(ar, "could not init core (%d)\n", ret);
1174
		goto err_unlock;
1175 1176
	}

M
Michal Kazior 已提交
1177
	ath10k_print_driver_info(ar);
1178
	ath10k_core_stop(ar);
1179 1180 1181

	mutex_unlock(&ar->conf_mutex);

1182 1183
	ath10k_hif_power_down(ar);
	return 0;
1184 1185 1186 1187

err_unlock:
	mutex_unlock(&ar->conf_mutex);

1188
err_free_firmware_files:
1189 1190 1191 1192 1193 1194
	ath10k_core_free_firmware_files(ar);

err_power_down:
	ath10k_hif_power_down(ar);

	return ret;
1195
}
1196

1197
static void ath10k_core_register_work(struct work_struct *work)
1198
{
1199
	struct ath10k *ar = container_of(work, struct ath10k, register_work);
1200 1201
	int status;

1202 1203
	status = ath10k_core_probe_fw(ar);
	if (status) {
1204
		ath10k_err(ar, "could not probe fw (%d)\n", status);
1205
		goto err;
1206
	}
1207

1208
	status = ath10k_mac_register(ar);
1209
	if (status) {
1210
		ath10k_err(ar, "could not register to mac80211 (%d)\n", status);
1211
		goto err_release_fw;
1212
	}
1213

1214
	status = ath10k_debug_register(ar);
1215
	if (status) {
1216
		ath10k_err(ar, "unable to initialize debugfs\n");
1217 1218 1219
		goto err_unregister_mac;
	}

1220 1221
	status = ath10k_spectral_create(ar);
	if (status) {
1222
		ath10k_err(ar, "failed to initialize spectral\n");
1223 1224 1225
		goto err_debug_destroy;
	}

1226 1227
	set_bit(ATH10K_FLAG_CORE_REGISTERED, &ar->dev_flags);
	return;
1228

1229 1230
err_debug_destroy:
	ath10k_debug_destroy(ar);
1231 1232
err_unregister_mac:
	ath10k_mac_unregister(ar);
1233 1234
err_release_fw:
	ath10k_core_free_firmware_files(ar);
1235
err:
1236 1237 1238
	/* TODO: It's probably a good idea to release device from the driver
	 * but calling device_release_driver() here will cause a deadlock.
	 */
1239 1240 1241 1242 1243 1244 1245 1246 1247
	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;
1248 1249 1250 1251 1252
}
EXPORT_SYMBOL(ath10k_core_register);

void ath10k_core_unregister(struct ath10k *ar)
{
1253 1254 1255 1256 1257
	cancel_work_sync(&ar->register_work);

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

1258 1259 1260 1261 1262 1263
	/* 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);

1264 1265 1266 1267
	/* 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);
1268

K
Kalle Valo 已提交
1269 1270
	ath10k_testmode_destroy(ar);

1271
	ath10k_core_free_firmware_files(ar);
1272

1273
	ath10k_debug_unregister(ar);
1274 1275 1276
}
EXPORT_SYMBOL(ath10k_core_unregister);

M
Michal Kazior 已提交
1277
struct ath10k *ath10k_core_create(size_t priv_size, struct device *dev,
K
Kalle Valo 已提交
1278
				  enum ath10k_bus bus,
1279 1280 1281
				  const struct ath10k_hif_ops *hif_ops)
{
	struct ath10k *ar;
1282
	int ret;
1283

M
Michal Kazior 已提交
1284
	ar = ath10k_mac_create(priv_size);
1285 1286 1287 1288 1289 1290 1291
	if (!ar)
		return NULL;

	ar->ath_common.priv = ar;
	ar->ath_common.hw = ar->hw;
	ar->dev = dev;
	ar->hif.ops = hif_ops;
K
Kalle Valo 已提交
1292
	ar->hif.bus = bus;
1293 1294 1295 1296 1297 1298 1299 1300 1301

	init_completion(&ar->scan.started);
	init_completion(&ar->scan.completed);
	init_completion(&ar->scan.on_channel);
	init_completion(&ar->target_suspend);

	init_completion(&ar->install_key_done);
	init_completion(&ar->vdev_setup_done);

1302
	INIT_DELAYED_WORK(&ar->scan.timeout, ath10k_scan_timeout_work);
1303 1304 1305

	ar->workqueue = create_singlethread_workqueue("ath10k_wq");
	if (!ar->workqueue)
1306
		goto err_free_mac;
1307 1308 1309 1310 1311 1312

	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 已提交
1313 1314
	init_waitqueue_head(&ar->htt.empty_tx_wq);
	init_waitqueue_head(&ar->wmi.tx_credits_wq);
1315 1316 1317 1318 1319 1320 1321 1322

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

1323
	INIT_WORK(&ar->register_work, ath10k_core_register_work);
1324 1325
	INIT_WORK(&ar->restart_work, ath10k_core_restart);

1326 1327 1328 1329
	ret = ath10k_debug_create(ar);
	if (ret)
		goto err_free_wq;

1330 1331
	return ar;

1332 1333 1334 1335
err_free_wq:
	destroy_workqueue(ar->workqueue);

err_free_mac:
1336
	ath10k_mac_destroy(ar);
1337

1338 1339 1340 1341 1342 1343 1344 1345 1346
	return NULL;
}
EXPORT_SYMBOL(ath10k_core_create);

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

1347
	ath10k_debug_destroy(ar);
1348 1349 1350 1351
	ath10k_mac_destroy(ar);
}
EXPORT_SYMBOL(ath10k_core_destroy);

1352 1353 1354
MODULE_AUTHOR("Qualcomm Atheros");
MODULE_DESCRIPTION("Core module for QCA988X PCIe devices.");
MODULE_LICENSE("Dual BSD/GPL");