core.c 25.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
/*
 * 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>

#include "core.h"
#include "mac.h"
#include "htc.h"
#include "hif.h"
#include "wmi.h"
#include "bmi.h"
#include "debug.h"
#include "htt.h"

unsigned int ath10k_debug_mask;
static bool uart_print;
static unsigned int ath10k_p2p;
module_param_named(debug_mask, ath10k_debug_mask, uint, 0644);
module_param(uart_print, bool, 0644);
module_param_named(p2p, ath10k_p2p, uint, 0644);
MODULE_PARM_DESC(debug_mask, "Debugging mask");
MODULE_PARM_DESC(uart_print, "Uart target debugging");
MODULE_PARM_DESC(p2p, "Enable ath10k P2P support");

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

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

58
	complete(&ar->target_suspend);
59 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 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 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
}

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) {
		ath10k_err("settings HTC version failed\n");
		return ret;
	}

	/* set the firmware mode to STA/IBSS/AP */
	ret = ath10k_bmi_read32(ar, hi_option_flag, &param_host);
	if (ret) {
		ath10k_err("setting firmware mode (1/2) failed\n");
		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) {
		ath10k_err("setting firmware mode (2/2) failed\n");
		return ret;
	}

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

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

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

140
static int ath10k_push_board_ext_data(struct ath10k *ar)
141 142 143 144 145 146 147 148 149 150 151 152
{
	u32 board_data_size = QCA988X_BOARD_DATA_SZ;
	u32 board_ext_data_size = QCA988X_BOARD_EXT_DATA_SZ;
	u32 board_ext_data_addr;
	int ret;

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

153
	ath10k_dbg(ATH10K_DBG_BOOT,
154
		   "boot push board extended data addr 0x%x\n",
155 156 157 158 159
		   board_ext_data_addr);

	if (board_ext_data_addr == 0)
		return 0;

160
	if (ar->board_len != (board_data_size + board_ext_data_size)) {
161
		ath10k_err("invalid board (ext) data sizes %zu != %d+%d\n",
162
			   ar->board_len, board_data_size, board_ext_data_size);
163 164 165 166
		return -EINVAL;
	}

	ret = ath10k_bmi_write_memory(ar, board_ext_data_addr,
167
				      ar->board_data + board_data_size,
168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
				      board_ext_data_size);
	if (ret) {
		ath10k_err("could not write board ext data (%d)\n", ret);
		return ret;
	}

	ret = ath10k_bmi_write32(ar, hi_board_ext_data_config,
				 (board_ext_data_size << 16) | 1);
	if (ret) {
		ath10k_err("could not write board ext data bit (%d)\n", ret);
		return ret;
	}

	return 0;
}

static int ath10k_download_board_data(struct ath10k *ar)
{
	u32 board_data_size = QCA988X_BOARD_DATA_SZ;
	u32 address;
	int ret;

190
	ret = ath10k_push_board_ext_data(ar);
191 192 193 194 195 196 197 198 199 200 201
	if (ret) {
		ath10k_err("could not push board ext data (%d)\n", ret);
		goto exit;
	}

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

202 203 204
	ret = ath10k_bmi_write_memory(ar, address, ar->board_data,
				      min_t(u32, board_data_size,
					    ar->board_len));
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
	if (ret) {
		ath10k_err("could not write board data (%d)\n", ret);
		goto exit;
	}

	ret = ath10k_bmi_write32(ar, hi_board_data_initialized, 1);
	if (ret) {
		ath10k_err("could not write board data bit (%d)\n", ret);
		goto exit;
	}

exit:
	return ret;
}

static int ath10k_download_and_run_otp(struct ath10k *ar)
{
222
	u32 result, address = ar->hw_params.patch_load_addr;
223 224 225 226
	int ret;

	/* OTP is optional */

K
Kalle Valo 已提交
227
	if (!ar->otp_data || !ar->otp_len) {
228 229
		ath10k_warn("Not running otp, calibration will be incorrect (otp-data %p otp_len %zd)!\n",
			    ar->otp_data, ar->otp_len);
230
		return 0;
K
Kalle Valo 已提交
231 232 233 234
	}

	ath10k_dbg(ATH10K_DBG_BOOT, "boot upload otp to 0x%x len %zd\n",
		   address, ar->otp_len);
235

236
	ret = ath10k_bmi_fast_download(ar, address, ar->otp_data, ar->otp_len);
237 238
	if (ret) {
		ath10k_err("could not write otp (%d)\n", ret);
K
Kalle Valo 已提交
239
		return ret;
240 241
	}

242
	ret = ath10k_bmi_execute(ar, address, 0, &result);
243 244
	if (ret) {
		ath10k_err("could not execute otp (%d)\n", ret);
K
Kalle Valo 已提交
245
		return ret;
246 247
	}

K
Kalle Valo 已提交
248 249 250 251 252 253 254 255
	ath10k_dbg(ATH10K_DBG_BOOT, "boot otp execute result %d\n", result);

	if (result != 0) {
		ath10k_err("otp calibration failed: %d", result);
		return -EINVAL;
	}

	return 0;
256 257 258 259 260 261 262 263 264
}

static int ath10k_download_fw(struct ath10k *ar)
{
	u32 address;
	int ret;

	address = ar->hw_params.patch_load_addr;

265 266
	ret = ath10k_bmi_fast_download(ar, address, ar->firmware_data,
				       ar->firmware_len);
267 268 269 270 271 272
	if (ret) {
		ath10k_err("could not write fw (%d)\n", ret);
		goto exit;
	}

exit:
273 274 275 276 277
	return ret;
}

static void ath10k_core_free_firmware_files(struct ath10k *ar)
{
278 279
	if (ar->board && !IS_ERR(ar->board))
		release_firmware(ar->board);
280 281 282 283 284 285 286

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

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

287
	ar->board = NULL;
288 289 290
	ar->board_data = NULL;
	ar->board_len = 0;

291
	ar->otp = NULL;
292 293 294
	ar->otp_data = NULL;
	ar->otp_len = 0;

295
	ar->firmware = NULL;
296 297
	ar->firmware_data = NULL;
	ar->firmware_len = 0;
298 299
}

300
static int ath10k_core_fetch_firmware_api_1(struct ath10k *ar)
301 302 303 304 305 306 307 308 309 310 311 312 313
{
	int ret = 0;

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

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

314 315 316 317 318
	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);
319 320 321 322
		ath10k_err("could not fetch board data (%d)\n", ret);
		goto err;
	}

323 324 325
	ar->board_data = ar->board->data;
	ar->board_len = ar->board->size;

326 327 328 329 330 331 332 333 334
	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);
		ath10k_err("could not fetch firmware (%d)\n", ret);
		goto err;
	}

335 336 337
	ar->firmware_data = ar->firmware->data;
	ar->firmware_len = ar->firmware->size;

338 339 340 341 342 343 344 345 346 347 348 349 350
	/* 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);
		ath10k_err("could not fetch otp (%d)\n", ret);
		goto err;
	}

351 352 353
	ar->otp_data = ar->otp->data;
	ar->otp_len = ar->otp->size;

354 355 356 357
	return 0;

err:
	ath10k_core_free_firmware_files(ar);
358 359 360
	return ret;
}

361 362 363 364 365 366 367 368 369 370 371
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;
	__le32 *timestamp;

	/* 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)) {
372 373
		ath10k_err("could not fetch firmware file '%s/%s': %ld\n",
			   ar->hw_params.fw.dir, name, PTR_ERR(ar->firmware));
374 375 376 377 378 379 380 381 382 383
		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) {
384 385
		ath10k_err("firmware file '%s/%s' too small to contain magic: %zu\n",
			   ar->hw_params.fw.dir, name, len);
386 387
		ret = -EINVAL;
		goto err;
388 389 390
	}

	if (memcmp(data, ATH10K_FIRMWARE_MAGIC, magic_len) != 0) {
391
		ath10k_err("invalid firmware magic\n");
392 393
		ret = -EINVAL;
		goto err;
394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412
	}

	/* 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) {
413
			ath10k_err("invalid length for FW IE %d (%zu < %zu)\n",
414
				   ie_id, len, ie_len);
415 416
			ret = -EINVAL;
			goto err;
417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451
		}

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

			ath10k_dbg(ATH10K_DBG_BOOT,
				   "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;

			ath10k_dbg(ATH10K_DBG_BOOT, "found fw timestamp %d\n",
				   le32_to_cpup(timestamp));
			break;
		case ATH10K_FW_IE_FEATURES:
			ath10k_dbg(ATH10K_DBG_BOOT,
				   "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;

452 453 454 455
				if (data[index] & (1 << bit)) {
					ath10k_dbg(ATH10K_DBG_BOOT,
						   "Enabling feature bit: %i\n",
						   i);
456
					__set_bit(i, ar->fw_features);
457
				}
458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492
			}

			ath10k_dbg_dump(ATH10K_DBG_BOOT, "features", "",
					ar->fw_features,
					sizeof(ar->fw_features));
			break;
		case ATH10K_FW_IE_FW_IMAGE:
			ath10k_dbg(ATH10K_DBG_BOOT,
				   "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:
			ath10k_dbg(ATH10K_DBG_BOOT,
				   "found otp image ie (%zd B)\n",
				   ie_len);

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

			break;
		default:
			ath10k_warn("Unknown FW IE: %u\n",
				    le32_to_cpu(hdr->id));
			break;
		}

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

		len -= ie_len;
		data += ie_len;
493
	}
494 495

	if (!ar->firmware_data || !ar->firmware_len) {
496 497
		ath10k_warn("No ATH10K_FW_IE_FW_IMAGE found from '%s/%s', skipping\n",
			    ar->hw_params.fw.dir, name);
498 499 500 501
		ret = -ENOMEDIUM;
		goto err;
	}

502 503 504 505 506 507 508
	if (test_bit(ATH10K_FW_FEATURE_WMI_10_2, ar->fw_features) &&
	    !test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
		ath10k_err("feature bits corrupted: 10.2 feature requires 10.x feature to be set as well");
		ret = -EINVAL;
		goto err;
	}

509 510 511 512 513 514 515 516 517 518 519 520
	/* now fetch the board file */
	if (ar->hw_params.fw.board == NULL) {
		ath10k_err("board data file not defined");
		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);
521 522 523
		ath10k_err("could not fetch board data '%s/%s' (%d)\n",
			   ar->hw_params.fw.dir, ar->hw_params.fw.board,
			   ret);
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
		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;

541 542 543 544 545 546 547
	ar->fw_api = 3;
	ath10k_dbg(ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);

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

548 549 550
	ar->fw_api = 2;
	ath10k_dbg(ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);

551
	ret = ath10k_core_fetch_firmware_api_n(ar, ATH10K_FW_API2_FILE);
552 553 554 555 556
	if (ret == 0)
		goto success;

	ar->fw_api = 1;
	ath10k_dbg(ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
557 558 559 560 561

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

562
success:
563 564 565 566 567
	ath10k_dbg(ATH10K_DBG_BOOT, "using fw api %d\n", ar->fw_api);

	return 0;
}

568 569 570 571 572
static int ath10k_init_download_firmware(struct ath10k *ar)
{
	int ret;

	ret = ath10k_download_board_data(ar);
573 574
	if (ret) {
		ath10k_err("failed to download board data: %d\n", ret);
575
		return ret;
576
	}
577 578

	ret = ath10k_download_and_run_otp(ar);
579 580
	if (ret) {
		ath10k_err("failed to run otp: %d\n", ret);
581
		return ret;
582
	}
583 584

	ret = ath10k_download_fw(ar);
585 586
	if (ret) {
		ath10k_err("failed to download firmware: %d\n", ret);
587
		return ret;
588
	}
589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606

	return ret;
}

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

607
	if (!uart_print)
608 609 610 611 612 613 614 615 616 617 618 619 620 621
		return 0;

	ret = ath10k_bmi_write32(ar, hi_dbg_uart_txpin, 7);
	if (ret) {
		ath10k_warn("could not enable UART prints (%d)\n", ret);
		return ret;
	}

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

622 623 624 625 626 627 628
	/* Set the UART baud rate to 19200. */
	ret = ath10k_bmi_write32(ar, hi_desired_baud_rate, 19200);
	if (ret) {
		ath10k_warn("could not set the baud rate (%d)\n", ret);
		return ret;
	}

629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652
	ath10k_info("UART prints enabled\n");
	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)) {
		ath10k_err("Unsupported hardware version: 0x%x\n",
			   ar->target_version);
		return -EINVAL;
	}

	ar->hw_params = *hw_params;

653 654
	ath10k_dbg(ATH10K_DBG_BOOT, "Hardware name %s version 0x%x\n",
		   ar->hw_params.name, ar->target_version);
655 656 657 658

	return 0;
}

659 660 661 662 663 664 665 666 667
static void ath10k_core_restart(struct work_struct *work)
{
	struct ath10k *ar = container_of(work, struct ath10k, restart_work);

	mutex_lock(&ar->conf_mutex);

	switch (ar->state) {
	case ATH10K_STATE_ON:
		ar->state = ATH10K_STATE_RESTARTING;
668
		ath10k_scan_finish(ar);
669 670 671
		ieee80211_restart_hw(ar->hw);
		break;
	case ATH10K_STATE_OFF:
672 673
		/* this can happen if driver is being unloaded
		 * or if the crash happens during FW probing */
674 675 676
		ath10k_warn("cannot restart a device that hasn't been started\n");
		break;
	case ATH10K_STATE_RESTARTING:
677 678
		/* hw restart might be requested from multiple places */
		break;
679 680 681 682 683 684 685 686 687 688 689
	case ATH10K_STATE_RESTARTED:
		ar->state = ATH10K_STATE_WEDGED;
		/* fall through */
	case ATH10K_STATE_WEDGED:
		ath10k_warn("device is wedged, will not restart\n");
		break;
	}

	mutex_unlock(&ar->conf_mutex);
}

690
int ath10k_core_start(struct ath10k *ar)
691 692 693
{
	int status;

694 695
	lockdep_assert_held(&ar->conf_mutex);

696 697
	ath10k_bmi_start(ar);

698 699 700 701 702 703 704 705 706 707 708 709 710
	if (ath10k_init_configure_target(ar)) {
		status = -EINVAL;
		goto err;
	}

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

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

711 712
	ar->htc.htc_ops.target_send_suspend_complete =
		ath10k_send_suspend_complete;
713

714 715 716
	status = ath10k_htc_init(ar);
	if (status) {
		ath10k_err("could not init HTC (%d)\n", status);
717 718 719 720 721
		goto err;
	}

	status = ath10k_bmi_done(ar);
	if (status)
722
		goto err;
723 724 725 726

	status = ath10k_wmi_attach(ar);
	if (status) {
		ath10k_err("WMI attach failed: %d\n", status);
727
		goto err;
728 729
	}

M
Michal Kazior 已提交
730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
	status = ath10k_htt_init(ar);
	if (status) {
		ath10k_err("failed to init htt: %d\n", status);
		goto err_wmi_detach;
	}

	status = ath10k_htt_tx_alloc(&ar->htt);
	if (status) {
		ath10k_err("failed to alloc htt tx: %d\n", status);
		goto err_wmi_detach;
	}

	status = ath10k_htt_rx_alloc(&ar->htt);
	if (status) {
		ath10k_err("failed to alloc htt rx: %d\n", status);
		goto err_htt_tx_detach;
	}

M
Michal Kazior 已提交
748 749 750
	status = ath10k_hif_start(ar);
	if (status) {
		ath10k_err("could not start HIF: %d\n", status);
M
Michal Kazior 已提交
751
		goto err_htt_rx_detach;
M
Michal Kazior 已提交
752 753 754 755 756 757 758
	}

	status = ath10k_htc_wait_target(&ar->htc);
	if (status) {
		ath10k_err("failed to connect to HTC: %d\n", status);
		goto err_hif_stop;
	}
759

M
Michal Kazior 已提交
760
	status = ath10k_htt_connect(&ar->htt);
761
	if (status) {
M
Michal Kazior 已提交
762
		ath10k_err("failed to connect htt (%d)\n", status);
M
Michal Kazior 已提交
763
		goto err_hif_stop;
764 765
	}

M
Michal Kazior 已提交
766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781
	status = ath10k_wmi_connect(ar);
	if (status) {
		ath10k_err("could not connect wmi: %d\n", status);
		goto err_hif_stop;
	}

	status = ath10k_htc_start(&ar->htc);
	if (status) {
		ath10k_err("failed to start htc: %d\n", status);
		goto err_hif_stop;
	}

	status = ath10k_wmi_wait_for_service_ready(ar);
	if (status <= 0) {
		ath10k_warn("wmi service ready event not received");
		status = -ETIMEDOUT;
M
Michal Kazior 已提交
782
		goto err_hif_stop;
M
Michal Kazior 已提交
783
	}
784

785 786
	ath10k_dbg(ATH10K_DBG_BOOT, "firmware %s booted\n",
		   ar->hw->wiphy->fw_version);
787 788 789 790

	status = ath10k_wmi_cmd_init(ar);
	if (status) {
		ath10k_err("could not send WMI init command (%d)\n", status);
M
Michal Kazior 已提交
791
		goto err_hif_stop;
792 793 794 795 796 797
	}

	status = ath10k_wmi_wait_for_unified_ready(ar);
	if (status <= 0) {
		ath10k_err("wmi unified ready event not received\n");
		status = -ETIMEDOUT;
M
Michal Kazior 已提交
798
		goto err_hif_stop;
799 800
	}

M
Michal Kazior 已提交
801 802 803
	status = ath10k_htt_setup(&ar->htt);
	if (status) {
		ath10k_err("failed to setup htt: %d\n", status);
M
Michal Kazior 已提交
804
		goto err_hif_stop;
M
Michal Kazior 已提交
805
	}
806

807 808
	status = ath10k_debug_start(ar);
	if (status)
M
Michal Kazior 已提交
809
		goto err_hif_stop;
810

811 812 813 814 815
	if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features))
		ar->free_vdev_map = (1 << TARGET_10X_NUM_VDEVS) - 1;
	else
		ar->free_vdev_map = (1 << TARGET_NUM_VDEVS) - 1;

M
Michal Kazior 已提交
816
	INIT_LIST_HEAD(&ar->arvifs);
817

818 819
	return 0;

M
Michal Kazior 已提交
820 821
err_hif_stop:
	ath10k_hif_stop(ar);
M
Michal Kazior 已提交
822 823 824 825
err_htt_rx_detach:
	ath10k_htt_rx_free(&ar->htt);
err_htt_tx_detach:
	ath10k_htt_tx_free(&ar->htt);
826 827 828 829 830
err_wmi_detach:
	ath10k_wmi_detach(ar);
err:
	return status;
}
831
EXPORT_SYMBOL(ath10k_core_start);
832

833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854
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) {
		ath10k_warn("could not suspend target (%d)\n", ret);
		return ret;
	}

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

	if (ret == 0) {
		ath10k_warn("suspend timed out - target pause event never came\n");
		return -ETIMEDOUT;
	}

	return 0;
}

855 856
void ath10k_core_stop(struct ath10k *ar)
{
857 858
	lockdep_assert_held(&ar->conf_mutex);

859
	/* try to suspend target */
860 861 862
	if (ar->state != ATH10K_STATE_RESTARTING)
		ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND_AND_DISABLE_INTR);

863
	ath10k_debug_stop(ar);
M
Michal Kazior 已提交
864 865 866
	ath10k_hif_stop(ar);
	ath10k_htt_tx_free(&ar->htt);
	ath10k_htt_rx_free(&ar->htt);
867 868
	ath10k_wmi_detach(ar);
}
869 870 871 872 873 874 875 876
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)
{
877 878
	struct bmi_target_info target_info;
	int ret = 0;
879 880 881 882 883 884 885

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

886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910
	memset(&target_info, 0, sizeof(target_info));
	ret = ath10k_bmi_get_target_info(ar, &target_info);
	if (ret) {
		ath10k_err("could not get target info (%d)\n", ret);
		ath10k_hif_power_down(ar);
		return ret;
	}

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

	ret = ath10k_init_hw_params(ar);
	if (ret) {
		ath10k_err("could not get hw params (%d)\n", ret);
		ath10k_hif_power_down(ar);
		return ret;
	}

	ret = ath10k_core_fetch_firmware_files(ar);
	if (ret) {
		ath10k_err("could not fetch firmware files (%d)\n", ret);
		ath10k_hif_power_down(ar);
		return ret;
	}

911 912
	mutex_lock(&ar->conf_mutex);

913 914 915
	ret = ath10k_core_start(ar);
	if (ret) {
		ath10k_err("could not init core (%d)\n", ret);
916
		ath10k_core_free_firmware_files(ar);
917
		ath10k_hif_power_down(ar);
918
		mutex_unlock(&ar->conf_mutex);
919 920 921
		return ret;
	}

M
Michal Kazior 已提交
922
	ath10k_print_driver_info(ar);
923
	ath10k_core_stop(ar);
924 925 926

	mutex_unlock(&ar->conf_mutex);

927 928 929
	ath10k_hif_power_down(ar);
	return 0;
}
930

931 932 933 934
static int ath10k_core_check_chip_id(struct ath10k *ar)
{
	u32 hw_revision = MS(ar->chip_id, SOC_CHIP_ID_REV);

935 936 937
	ath10k_dbg(ATH10K_DBG_BOOT, "boot chip_id 0x%08x hw_revision 0x%x\n",
		   ar->chip_id, hw_revision);

938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958
	/* Check that we are not using hw1.0 (some of them have same pci id
	 * as hw2.0) before doing anything else as ath10k crashes horribly
	 * due to missing hw1.0 workarounds. */
	switch (hw_revision) {
	case QCA988X_HW_1_0_CHIP_ID_REV:
		ath10k_err("ERROR: qca988x hw1.0 is not supported\n");
		return -EOPNOTSUPP;

	case QCA988X_HW_2_0_CHIP_ID_REV:
		/* known hardware revision, continue normally */
		return 0;

	default:
		ath10k_warn("Warning: hardware revision unknown (0x%x), expect problems\n",
			    ar->chip_id);
		return 0;
	}

	return 0;
}

959
static void ath10k_core_register_work(struct work_struct *work)
960
{
961
	struct ath10k *ar = container_of(work, struct ath10k, register_work);
962 963
	int status;

964 965 966
	status = ath10k_core_probe_fw(ar);
	if (status) {
		ath10k_err("could not probe fw (%d)\n", status);
967
		goto err;
968
	}
969

970
	status = ath10k_mac_register(ar);
971 972
	if (status) {
		ath10k_err("could not register to mac80211 (%d)\n", status);
973
		goto err_release_fw;
974
	}
975 976 977 978 979 980 981

	status = ath10k_debug_create(ar);
	if (status) {
		ath10k_err("unable to initialize debugfs\n");
		goto err_unregister_mac;
	}

982 983 984 985 986 987
	status = ath10k_spectral_create(ar);
	if (status) {
		ath10k_err("failed to initialize spectral\n");
		goto err_debug_destroy;
	}

988 989
	set_bit(ATH10K_FLAG_CORE_REGISTERED, &ar->dev_flags);
	return;
990

991 992
err_debug_destroy:
	ath10k_debug_destroy(ar);
993 994
err_unregister_mac:
	ath10k_mac_unregister(ar);
995 996
err_release_fw:
	ath10k_core_free_firmware_files(ar);
997
err:
998 999 1000
	/* TODO: It's probably a good idea to release device from the driver
	 * but calling device_release_driver() here will cause a deadlock.
	 */
1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018
	return;
}

int ath10k_core_register(struct ath10k *ar, u32 chip_id)
{
	int status;

	ar->chip_id = chip_id;

	status = ath10k_core_check_chip_id(ar);
	if (status) {
		ath10k_err("Unsupported chip id 0x%08x\n", ar->chip_id);
		return status;
	}

	queue_work(ar->workqueue, &ar->register_work);

	return 0;
1019 1020 1021 1022 1023
}
EXPORT_SYMBOL(ath10k_core_register);

void ath10k_core_unregister(struct ath10k *ar)
{
1024 1025 1026 1027 1028
	cancel_work_sync(&ar->register_work);

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

1029 1030 1031 1032 1033 1034
	/* 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);

1035 1036 1037 1038
	/* 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);
1039

1040
	ath10k_core_free_firmware_files(ar);
1041 1042

	ath10k_debug_destroy(ar);
1043 1044 1045
}
EXPORT_SYMBOL(ath10k_core_unregister);

M
Michal Kazior 已提交
1046
struct ath10k *ath10k_core_create(size_t priv_size, struct device *dev,
1047 1048 1049 1050
				  const struct ath10k_hif_ops *hif_ops)
{
	struct ath10k *ar;

M
Michal Kazior 已提交
1051
	ar = ath10k_mac_create(priv_size);
1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070
	if (!ar)
		return NULL;

	ar->ath_common.priv = ar;
	ar->ath_common.hw = ar->hw;

	ar->p2p = !!ath10k_p2p;
	ar->dev = dev;

	ar->hif.ops = hif_ops;

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

1071
	INIT_DELAYED_WORK(&ar->scan.timeout, ath10k_scan_timeout_work);
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089

	ar->workqueue = create_singlethread_workqueue("ath10k_wq");
	if (!ar->workqueue)
		goto err_wq;

	mutex_init(&ar->conf_mutex);
	spin_lock_init(&ar->data_lock);

	INIT_LIST_HEAD(&ar->peers);
	init_waitqueue_head(&ar->peer_mapping_wq);

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

1090
	INIT_WORK(&ar->register_work, ath10k_core_register_work);
1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109
	INIT_WORK(&ar->restart_work, ath10k_core_restart);

	return ar;

err_wq:
	ath10k_mac_destroy(ar);
	return NULL;
}
EXPORT_SYMBOL(ath10k_core_create);

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

	ath10k_mac_destroy(ar);
}
EXPORT_SYMBOL(ath10k_core_destroy);

1110 1111 1112
MODULE_AUTHOR("Qualcomm Atheros");
MODULE_DESCRIPTION("Core module for QCA988X PCIe devices.");
MODULE_LICENSE("Dual BSD/GPL");