core.c 36.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
 * Copyright (c) 2005-2011 Atheros Communications Inc.
 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <linux/module.h>
#include <linux/firmware.h>
20
#include <linux/of.h>
21 22 23 24 25 26 27 28 29

#include "core.h"
#include "mac.h"
#include "htc.h"
#include "hif.h"
#include "wmi.h"
#include "bmi.h"
#include "debug.h"
#include "htt.h"
K
Kalle Valo 已提交
30
#include "testmode.h"
M
Michal Kazior 已提交
31
#include "wmi-ops.h"
32 33 34

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

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

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

static const struct ath10k_hw_params ath10k_hw_params_list[] = {
	{
		.id = QCA988X_HW_2_0_VERSION,
		.name = "qca988x hw2.0",
		.patch_load_addr = QCA988X_HW_2_0_PATCH_LOAD_ADDR,
50
		.uart_pin = 7,
51
		.has_shifted_cc_wraparound = true,
52 53 54 55 56
		.fw = {
			.dir = QCA988X_HW_2_0_FW_DIR,
			.fw = QCA988X_HW_2_0_FW_FILE,
			.otp = QCA988X_HW_2_0_OTP_FILE,
			.board = QCA988X_HW_2_0_BOARD_DATA_FILE,
57 58
			.board_size = QCA988X_BOARD_DATA_SZ,
			.board_ext_size = QCA988X_BOARD_EXT_DATA_SZ,
59 60
		},
	},
M
Michal Kazior 已提交
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
	{
		.id = QCA6174_HW_2_1_VERSION,
		.name = "qca6174 hw2.1",
		.patch_load_addr = QCA6174_HW_2_1_PATCH_LOAD_ADDR,
		.uart_pin = 6,
		.fw = {
			.dir = QCA6174_HW_2_1_FW_DIR,
			.fw = QCA6174_HW_2_1_FW_FILE,
			.otp = QCA6174_HW_2_1_OTP_FILE,
			.board = QCA6174_HW_2_1_BOARD_DATA_FILE,
			.board_size = QCA6174_BOARD_DATA_SZ,
			.board_ext_size = QCA6174_BOARD_EXT_DATA_SZ,
		},
	},
	{
		.id = QCA6174_HW_3_0_VERSION,
		.name = "qca6174 hw3.0",
		.patch_load_addr = QCA6174_HW_3_0_PATCH_LOAD_ADDR,
		.uart_pin = 6,
		.fw = {
			.dir = QCA6174_HW_3_0_FW_DIR,
			.fw = QCA6174_HW_3_0_FW_FILE,
			.otp = QCA6174_HW_3_0_OTP_FILE,
			.board = QCA6174_HW_3_0_BOARD_DATA_FILE,
			.board_size = QCA6174_BOARD_DATA_SZ,
			.board_ext_size = QCA6174_BOARD_EXT_DATA_SZ,
		},
	},
M
Michal Kazior 已提交
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
	{
		.id = QCA6174_HW_3_2_VERSION,
		.name = "qca6174 hw3.2",
		.patch_load_addr = QCA6174_HW_3_0_PATCH_LOAD_ADDR,
		.uart_pin = 6,
		.fw = {
			/* uses same binaries as hw3.0 */
			.dir = QCA6174_HW_3_0_FW_DIR,
			.fw = QCA6174_HW_3_0_FW_FILE,
			.otp = QCA6174_HW_3_0_OTP_FILE,
			.board = QCA6174_HW_3_0_BOARD_DATA_FILE,
			.board_size = QCA6174_BOARD_DATA_SZ,
			.board_ext_size = QCA6174_BOARD_EXT_DATA_SZ,
		},
	},
104 105 106 107
};

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

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

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

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

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

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

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

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

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

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

	if (board_ext_data_addr == 0)
		return 0;

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

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

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

	return 0;
}

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

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

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

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

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

exit:
	return ret;
}

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

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

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

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

366 367
	/* OTP is optional */

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

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

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

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

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

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

	return 0;
399 400
}

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

	address = ar->hw_params.patch_load_addr;

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

437 438 439 440 441
	return ret;
}

static void ath10k_core_free_firmware_files(struct ath10k *ar)
{
442
	if (!IS_ERR(ar->board))
443
		release_firmware(ar->board);
444

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

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

451
	if (!IS_ERR(ar->cal_file))
452 453
		release_firmware(ar->cal_file);

454
	ar->board = NULL;
455 456 457
	ar->board_data = NULL;
	ar->board_len = 0;

458
	ar->otp = NULL;
459 460 461
	ar->otp_data = NULL;
	ar->otp_len = 0;

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

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

488
static int ath10k_core_fetch_spec_board_file(struct ath10k *ar)
489
{
490 491 492 493 494 495 496 497 498 499 500 501
	char filename[100];

	scnprintf(filename, sizeof(filename), "board-%s-%s.bin",
		  ath10k_bus_str(ar->hif.bus), ar->spec_board_id);

	ar->board = ath10k_fetch_fw_file(ar, ar->hw_params.fw.dir, filename);
	if (IS_ERR(ar->board))
		return PTR_ERR(ar->board);

	ar->board_data = ar->board->data;
	ar->board_len = ar->board->size;
	ar->spec_board_loaded = true;
502

503 504 505 506 507
	return 0;
}

static int ath10k_core_fetch_generic_board_file(struct ath10k *ar)
{
508 509
	if (!ar->hw_params.fw.board) {
		ath10k_err(ar, "failed to find board file fw entry\n");
510 511 512
		return -EINVAL;
	}

513 514 515
	ar->board = ath10k_fetch_fw_file(ar,
					 ar->hw_params.fw.dir,
					 ar->hw_params.fw.board);
516 517
	if (IS_ERR(ar->board))
		return PTR_ERR(ar->board);
518

519 520
	ar->board_data = ar->board->data;
	ar->board_len = ar->board->size;
521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548
	ar->spec_board_loaded = false;

	return 0;
}

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

	if (strlen(ar->spec_board_id) > 0) {
		ret = ath10k_core_fetch_spec_board_file(ar);
		if (ret) {
			ath10k_info(ar, "failed to load spec board file, falling back to generic: %d\n",
				    ret);
			goto generic;
		}

		ath10k_dbg(ar, ATH10K_DBG_BOOT, "found specific board file for %s\n",
			   ar->spec_board_id);
		return 0;
	}

generic:
	ret = ath10k_core_fetch_generic_board_file(ar);
	if (ret) {
		ath10k_err(ar, "failed to fetch generic board data: %d\n", ret);
		return ret;
	}
549

550 551 552 553 554 555 556 557 558 559 560 561
	return 0;
}

static int ath10k_core_fetch_firmware_api_1(struct ath10k *ar)
{
	int ret = 0;

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

562 563 564 565 566
	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);
567
		ath10k_err(ar, "could not fetch firmware (%d)\n", ret);
568 569 570
		goto err;
	}

571 572 573
	ar->firmware_data = ar->firmware->data;
	ar->firmware_len = ar->firmware->size;

574 575 576 577 578 579 580 581 582
	/* 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);
583
		ath10k_err(ar, "could not fetch otp (%d)\n", ret);
584 585 586
		goto err;
	}

587 588 589
	ar->otp_data = ar->otp->data;
	ar->otp_len = ar->otp->size;

590 591 592 593
	return 0;

err:
	ath10k_core_free_firmware_files(ar);
594 595 596
	return ret;
}

597 598 599 600 601 602
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;
603
	__le32 *timestamp, *version;
604 605 606 607

	/* 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)) {
608
		ath10k_err(ar, "could not fetch firmware file '%s/%s': %ld\n",
609
			   ar->hw_params.fw.dir, name, PTR_ERR(ar->firmware));
610 611 612 613 614 615 616 617 618 619
		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) {
620
		ath10k_err(ar, "firmware file '%s/%s' too small to contain magic: %zu\n",
621
			   ar->hw_params.fw.dir, name, len);
622 623
		ret = -EINVAL;
		goto err;
624 625 626
	}

	if (memcmp(data, ATH10K_FIRMWARE_MAGIC, magic_len) != 0) {
627
		ath10k_err(ar, "invalid firmware magic\n");
628 629
		ret = -EINVAL;
		goto err;
630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648
	}

	/* 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) {
649
			ath10k_err(ar, "invalid length for FW IE %d (%zu < %zu)\n",
650
				   ie_id, len, ie_len);
651 652
			ret = -EINVAL;
			goto err;
653 654 655 656 657 658 659 660 661 662
		}

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

663
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
664 665 666 667 668 669 670 671 672
				   "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;

673
			ath10k_dbg(ar, ATH10K_DBG_BOOT, "found fw timestamp %d\n",
674 675 676
				   le32_to_cpup(timestamp));
			break;
		case ATH10K_FW_IE_FEATURES:
677
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
678 679 680 681 682 683 684 685 686 687
				   "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;

688
				if (data[index] & (1 << bit)) {
689
					ath10k_dbg(ar, ATH10K_DBG_BOOT,
690 691
						   "Enabling feature bit: %i\n",
						   i);
692
					__set_bit(i, ar->fw_features);
693
				}
694 695
			}

696
			ath10k_dbg_dump(ar, ATH10K_DBG_BOOT, "features", "",
697 698 699 700
					ar->fw_features,
					sizeof(ar->fw_features));
			break;
		case ATH10K_FW_IE_FW_IMAGE:
701
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
702 703 704 705 706 707 708 709
				   "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:
710
			ath10k_dbg(ar, ATH10K_DBG_BOOT,
711 712 713 714 715 716 717
				   "found otp image ie (%zd B)\n",
				   ie_len);

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

			break;
718 719 720 721 722 723 724 725 726 727 728
		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;
729 730 731 732 733 734 735 736 737 738 739
		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;
740
		default:
741
			ath10k_warn(ar, "Unknown FW IE: %u\n",
742 743 744 745 746 747 748 749 750
				    le32_to_cpu(hdr->id));
			break;
		}

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

		len -= ie_len;
		data += ie_len;
751
	}
752 753

	if (!ar->firmware_data || !ar->firmware_len) {
754
		ath10k_warn(ar, "No ATH10K_FW_IE_FW_IMAGE found from '%s/%s', skipping\n",
755
			    ar->hw_params.fw.dir, name);
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770
		ret = -ENOMEDIUM;
		goto err;
	}

	return 0;

err:
	ath10k_core_free_firmware_files(ar);
	return ret;
}

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

771 772 773
	/* calibration file is optional, don't check for any errors */
	ath10k_fetch_cal_file(ar);

774 775 776 777 778 779
	ret = ath10k_core_fetch_board_file(ar);
	if (ret) {
		ath10k_err(ar, "failed to fetch board file: %d\n", ret);
		return ret;
	}

K
Kalle Valo 已提交
780 781 782 783 784 785 786
	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;

787 788 789 790 791 792 793
	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;

794
	ar->fw_api = 3;
795
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
796 797 798 799 800

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

801
	ar->fw_api = 2;
802
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
803

804
	ret = ath10k_core_fetch_firmware_api_n(ar, ATH10K_FW_API2_FILE);
805 806 807 808
	if (ret == 0)
		goto success;

	ar->fw_api = 1;
809
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
810 811 812 813 814

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

815
success:
816
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "using fw api %d\n", ar->fw_api);
817 818 819 820

	return 0;
}

821
static int ath10k_download_cal_data(struct ath10k *ar)
822 823 824
{
	int ret;

825 826 827 828 829 830 831
	ret = ath10k_download_cal_file(ar);
	if (ret == 0) {
		ar->cal_mode = ATH10K_CAL_MODE_FILE;
		goto done;
	}

	ath10k_dbg(ar, ATH10K_DBG_BOOT,
832 833 834 835 836 837 838 839 840 841 842
		   "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",
843 844
		   ret);

845
	ret = ath10k_download_and_run_otp(ar);
846
	if (ret) {
847
		ath10k_err(ar, "failed to run otp: %d\n", ret);
848
		return ret;
849
	}
850

851 852 853 854 855 856
	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;
857 858 859 860 861 862 863 864 865 866 867 868
}

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

873
	if (!uart_print)
874 875
		return 0;

876
	ret = ath10k_bmi_write32(ar, hi_dbg_uart_txpin, ar->hw_params.uart_pin);
877
	if (ret) {
878
		ath10k_warn(ar, "could not enable UART prints (%d)\n", ret);
879 880 881 882 883
		return ret;
	}

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

888 889 890
	/* Set the UART baud rate to 19200. */
	ret = ath10k_bmi_write32(ar, hi_desired_baud_rate, 19200);
	if (ret) {
891
		ath10k_warn(ar, "could not set the baud rate (%d)\n", ret);
892 893 894
		return ret;
	}

895
	ath10k_info(ar, "UART prints enabled\n");
896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911
	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)) {
912
		ath10k_err(ar, "Unsupported hardware version: 0x%x\n",
913 914 915 916 917 918
			   ar->target_version);
		return -EINVAL;
	}

	ar->hw_params = *hw_params;

919
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "Hardware name %s version 0x%x\n",
920
		   ar->hw_params.name, ar->target_version);
921 922 923 924

	return 0;
}

925 926 927 928
static void ath10k_core_restart(struct work_struct *work)
{
	struct ath10k *ar = container_of(work, struct ath10k, restart_work);

M
Michal Kazior 已提交
929 930 931 932 933 934 935 936 937 938 939 940 941 942 943
	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);
944
	complete_all(&ar->thermal.wmi_sync);
M
Michal Kazior 已提交
945 946 947 948
	wake_up(&ar->htt.empty_tx_wq);
	wake_up(&ar->wmi.tx_credits_wq);
	wake_up(&ar->peer_mapping_wq);

949 950 951 952 953
	mutex_lock(&ar->conf_mutex);

	switch (ar->state) {
	case ATH10K_STATE_ON:
		ar->state = ATH10K_STATE_RESTARTING;
954
		ath10k_hif_stop(ar);
955
		ath10k_scan_finish(ar);
956 957 958
		ieee80211_restart_hw(ar->hw);
		break;
	case ATH10K_STATE_OFF:
959 960
		/* this can happen if driver is being unloaded
		 * or if the crash happens during FW probing */
961
		ath10k_warn(ar, "cannot restart a device that hasn't been started\n");
962 963
		break;
	case ATH10K_STATE_RESTARTING:
964 965
		/* hw restart might be requested from multiple places */
		break;
966 967 968 969
	case ATH10K_STATE_RESTARTED:
		ar->state = ATH10K_STATE_WEDGED;
		/* fall through */
	case ATH10K_STATE_WEDGED:
970
		ath10k_warn(ar, "device is wedged, will not restart\n");
971
		break;
K
Kalle Valo 已提交
972 973 974
	case ATH10K_STATE_UTF:
		ath10k_warn(ar, "firmware restart in UTF mode not supported\n");
		break;
975 976 977 978 979
	}

	mutex_unlock(&ar->conf_mutex);
}

980
static int ath10k_core_init_firmware_features(struct ath10k *ar)
981
{
982 983 984 985 986 987
	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;
	}

988 989 990 991 992 993 994 995 996 997 998
	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)) {
999 1000
			if (test_bit(ATH10K_FW_FEATURE_WMI_10_2,
				     ar->fw_features))
1001 1002 1003 1004 1005 1006 1007 1008 1009 1010
				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:
1011 1012
		ar->max_num_peers = TARGET_NUM_PEERS;
		ar->max_num_stations = TARGET_NUM_STATIONS;
1013
		ar->max_num_vdevs = TARGET_NUM_VDEVS;
1014
		ar->htt.max_num_pending_tx = TARGET_NUM_MSDU_DESC;
1015 1016
		ar->fw_stats_req_mask = WMI_STAT_PDEV | WMI_STAT_VDEV |
			WMI_STAT_PEER;
1017 1018 1019
		break;
	case ATH10K_FW_WMI_OP_VERSION_10_1:
	case ATH10K_FW_WMI_OP_VERSION_10_2:
1020
	case ATH10K_FW_WMI_OP_VERSION_10_2_4:
1021 1022
		ar->max_num_peers = TARGET_10X_NUM_PEERS;
		ar->max_num_stations = TARGET_10X_NUM_STATIONS;
1023
		ar->max_num_vdevs = TARGET_10X_NUM_VDEVS;
1024
		ar->htt.max_num_pending_tx = TARGET_10X_NUM_MSDU_DESC;
1025
		ar->fw_stats_req_mask = WMI_STAT_PEER;
1026
		break;
M
Michal Kazior 已提交
1027 1028 1029
	case ATH10K_FW_WMI_OP_VERSION_TLV:
		ar->max_num_peers = TARGET_TLV_NUM_PEERS;
		ar->max_num_stations = TARGET_TLV_NUM_STATIONS;
1030
		ar->max_num_vdevs = TARGET_TLV_NUM_VDEVS;
1031
		ar->max_num_tdls_vdevs = TARGET_TLV_NUM_TDLS_VDEVS;
M
Michal Kazior 已提交
1032
		ar->htt.max_num_pending_tx = TARGET_TLV_NUM_MSDU_DESC;
1033
		ar->wow.max_num_patterns = TARGET_TLV_NUM_WOW_PATTERNS;
1034 1035
		ar->fw_stats_req_mask = WMI_STAT_PDEV | WMI_STAT_VDEV |
			WMI_STAT_PEER;
M
Michal Kazior 已提交
1036
		break;
1037 1038 1039 1040
	case ATH10K_FW_WMI_OP_VERSION_UNSET:
	case ATH10K_FW_WMI_OP_VERSION_MAX:
		WARN_ON(1);
		return -EINVAL;
1041
	}
1042

1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065
	/* Backwards compatibility for firmwares without
	 * ATH10K_FW_IE_HTT_OP_VERSION.
	 */
	if (ar->htt.op_version == ATH10K_FW_HTT_OP_VERSION_UNSET) {
		switch (ar->wmi.op_version) {
		case ATH10K_FW_WMI_OP_VERSION_MAIN:
			ar->htt.op_version = ATH10K_FW_HTT_OP_VERSION_MAIN;
			break;
		case ATH10K_FW_WMI_OP_VERSION_10_1:
		case ATH10K_FW_WMI_OP_VERSION_10_2:
		case ATH10K_FW_WMI_OP_VERSION_10_2_4:
			ar->htt.op_version = ATH10K_FW_HTT_OP_VERSION_10_1;
			break;
		case ATH10K_FW_WMI_OP_VERSION_TLV:
			ar->htt.op_version = ATH10K_FW_HTT_OP_VERSION_TLV;
			break;
		case ATH10K_FW_WMI_OP_VERSION_UNSET:
		case ATH10K_FW_WMI_OP_VERSION_MAX:
			WARN_ON(1);
			return -EINVAL;
		}
	}

1066
	return 0;
1067 1068
}

K
Kalle Valo 已提交
1069
int ath10k_core_start(struct ath10k *ar, enum ath10k_firmware_mode mode)
1070 1071 1072
{
	int status;

1073 1074
	lockdep_assert_held(&ar->conf_mutex);

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

1077 1078
	ath10k_bmi_start(ar);

1079 1080 1081 1082 1083
	if (ath10k_init_configure_target(ar)) {
		status = -EINVAL;
		goto err;
	}

1084 1085 1086 1087
	status = ath10k_download_cal_data(ar);
	if (status)
		goto err;

1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
	/* Some of of qca988x solutions are having global reset issue
         * during target initialization. Bypassing PLL setting before
         * downloading firmware and letting the SoC run on REF_CLK is
         * fixing the problem. Corresponding firmware change is also needed
         * to set the clock source once the target is initialized.
	 */
	if (test_bit(ATH10K_FW_FEATURE_SUPPORTS_SKIP_CLOCK_INIT,
		     ar->fw_features)) {
		status = ath10k_bmi_write32(ar, hi_skip_clock_init, 1);
		if (status) {
			ath10k_err(ar, "could not write to skip_clock_init: %d\n",
				   status);
			goto err;
		}
	}

1104
	status = ath10k_download_fw(ar, mode);
1105 1106 1107 1108 1109 1110 1111
	if (status)
		goto err;

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

1112 1113
	ar->htc.htc_ops.target_send_suspend_complete =
		ath10k_send_suspend_complete;
1114

1115 1116
	status = ath10k_htc_init(ar);
	if (status) {
1117
		ath10k_err(ar, "could not init HTC (%d)\n", status);
1118 1119 1120 1121 1122
		goto err;
	}

	status = ath10k_bmi_done(ar);
	if (status)
1123
		goto err;
1124 1125 1126

	status = ath10k_wmi_attach(ar);
	if (status) {
1127
		ath10k_err(ar, "WMI attach failed: %d\n", status);
1128
		goto err;
1129 1130
	}

M
Michal Kazior 已提交
1131 1132
	status = ath10k_htt_init(ar);
	if (status) {
1133
		ath10k_err(ar, "failed to init htt: %d\n", status);
M
Michal Kazior 已提交
1134 1135 1136 1137 1138
		goto err_wmi_detach;
	}

	status = ath10k_htt_tx_alloc(&ar->htt);
	if (status) {
1139
		ath10k_err(ar, "failed to alloc htt tx: %d\n", status);
M
Michal Kazior 已提交
1140 1141 1142 1143 1144
		goto err_wmi_detach;
	}

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

M
Michal Kazior 已提交
1149 1150
	status = ath10k_hif_start(ar);
	if (status) {
1151
		ath10k_err(ar, "could not start HIF: %d\n", status);
M
Michal Kazior 已提交
1152
		goto err_htt_rx_detach;
M
Michal Kazior 已提交
1153 1154 1155 1156
	}

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

K
Kalle Valo 已提交
1161 1162 1163 1164 1165 1166
	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;
		}
1167 1168
	}

M
Michal Kazior 已提交
1169 1170
	status = ath10k_wmi_connect(ar);
	if (status) {
1171
		ath10k_err(ar, "could not connect wmi: %d\n", status);
M
Michal Kazior 已提交
1172 1173 1174 1175 1176
		goto err_hif_stop;
	}

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

K
Kalle Valo 已提交
1181 1182
	if (mode == ATH10K_FIRMWARE_MODE_NORMAL) {
		status = ath10k_wmi_wait_for_service_ready(ar);
1183
		if (status) {
K
Kalle Valo 已提交
1184 1185 1186
			ath10k_warn(ar, "wmi service ready event not received");
			goto err_hif_stop;
		}
M
Michal Kazior 已提交
1187
	}
1188

1189
	ath10k_dbg(ar, ATH10K_DBG_BOOT, "firmware %s booted\n",
1190
		   ar->hw->wiphy->fw_version);
1191 1192 1193

	status = ath10k_wmi_cmd_init(ar);
	if (status) {
1194 1195
		ath10k_err(ar, "could not send WMI init command (%d)\n",
			   status);
M
Michal Kazior 已提交
1196
		goto err_hif_stop;
1197 1198 1199
	}

	status = ath10k_wmi_wait_for_unified_ready(ar);
1200
	if (status) {
1201
		ath10k_err(ar, "wmi unified ready event not received\n");
M
Michal Kazior 已提交
1202
		goto err_hif_stop;
1203 1204
	}

1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
	/* 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 已提交
1217 1218 1219 1220 1221 1222 1223
	/* 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 已提交
1224
	}
1225

1226 1227
	status = ath10k_debug_start(ar);
	if (status)
M
Michal Kazior 已提交
1228
		goto err_hif_stop;
1229

1230
	ar->free_vdev_map = (1LL << ar->max_num_vdevs) - 1;
1231

M
Michal Kazior 已提交
1232
	INIT_LIST_HEAD(&ar->arvifs);
1233

1234 1235
	return 0;

M
Michal Kazior 已提交
1236 1237
err_hif_stop:
	ath10k_hif_stop(ar);
M
Michal Kazior 已提交
1238 1239 1240 1241
err_htt_rx_detach:
	ath10k_htt_rx_free(&ar->htt);
err_htt_tx_detach:
	ath10k_htt_tx_free(&ar->htt);
1242 1243 1244 1245 1246
err_wmi_detach:
	ath10k_wmi_detach(ar);
err:
	return status;
}
1247
EXPORT_SYMBOL(ath10k_core_start);
1248

1249 1250 1251
int ath10k_wait_for_suspend(struct ath10k *ar, u32 suspend_opt)
{
	int ret;
1252
	unsigned long time_left;
1253 1254 1255 1256 1257

	reinit_completion(&ar->target_suspend);

	ret = ath10k_wmi_pdev_suspend_target(ar, suspend_opt);
	if (ret) {
1258
		ath10k_warn(ar, "could not suspend target (%d)\n", ret);
1259 1260 1261
		return ret;
	}

1262
	time_left = wait_for_completion_timeout(&ar->target_suspend, 1 * HZ);
1263

1264
	if (!time_left) {
1265
		ath10k_warn(ar, "suspend timed out - target pause event never came\n");
1266 1267 1268 1269 1270 1271
		return -ETIMEDOUT;
	}

	return 0;
}

1272 1273
void ath10k_core_stop(struct ath10k *ar)
{
1274 1275
	lockdep_assert_held(&ar->conf_mutex);

1276
	/* try to suspend target */
K
Kalle Valo 已提交
1277 1278
	if (ar->state != ATH10K_STATE_RESTARTING &&
	    ar->state != ATH10K_STATE_UTF)
1279 1280
		ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND_AND_DISABLE_INTR);

1281
	ath10k_debug_stop(ar);
M
Michal Kazior 已提交
1282 1283 1284
	ath10k_hif_stop(ar);
	ath10k_htt_tx_free(&ar->htt);
	ath10k_htt_rx_free(&ar->htt);
1285 1286
	ath10k_wmi_detach(ar);
}
1287 1288 1289 1290 1291 1292 1293 1294
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)
{
1295 1296
	struct bmi_target_info target_info;
	int ret = 0;
1297 1298 1299

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

1304 1305 1306
	memset(&target_info, 0, sizeof(target_info));
	ret = ath10k_bmi_get_target_info(ar, &target_info);
	if (ret) {
1307
		ath10k_err(ar, "could not get target info (%d)\n", ret);
1308
		goto err_power_down;
1309 1310 1311 1312 1313 1314 1315
	}

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

	ret = ath10k_init_hw_params(ar);
	if (ret) {
1316
		ath10k_err(ar, "could not get hw params (%d)\n", ret);
1317
		goto err_power_down;
1318 1319 1320 1321
	}

	ret = ath10k_core_fetch_firmware_files(ar);
	if (ret) {
1322
		ath10k_err(ar, "could not fetch firmware files (%d)\n", ret);
1323
		goto err_power_down;
1324 1325
	}

1326 1327 1328 1329 1330 1331
	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;
	}
1332

1333 1334
	mutex_lock(&ar->conf_mutex);

K
Kalle Valo 已提交
1335
	ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
1336
	if (ret) {
1337
		ath10k_err(ar, "could not init core (%d)\n", ret);
1338
		goto err_unlock;
1339 1340
	}

M
Michal Kazior 已提交
1341
	ath10k_print_driver_info(ar);
1342
	ath10k_core_stop(ar);
1343 1344 1345

	mutex_unlock(&ar->conf_mutex);

1346 1347
	ath10k_hif_power_down(ar);
	return 0;
1348 1349 1350 1351

err_unlock:
	mutex_unlock(&ar->conf_mutex);

1352
err_free_firmware_files:
1353 1354 1355 1356 1357 1358
	ath10k_core_free_firmware_files(ar);

err_power_down:
	ath10k_hif_power_down(ar);

	return ret;
1359
}
1360

1361
static void ath10k_core_register_work(struct work_struct *work)
1362
{
1363
	struct ath10k *ar = container_of(work, struct ath10k, register_work);
1364 1365
	int status;

1366 1367
	status = ath10k_core_probe_fw(ar);
	if (status) {
1368
		ath10k_err(ar, "could not probe fw (%d)\n", status);
1369
		goto err;
1370
	}
1371

1372
	status = ath10k_mac_register(ar);
1373
	if (status) {
1374
		ath10k_err(ar, "could not register to mac80211 (%d)\n", status);
1375
		goto err_release_fw;
1376
	}
1377

1378
	status = ath10k_debug_register(ar);
1379
	if (status) {
1380
		ath10k_err(ar, "unable to initialize debugfs\n");
1381 1382 1383
		goto err_unregister_mac;
	}

1384 1385
	status = ath10k_spectral_create(ar);
	if (status) {
1386
		ath10k_err(ar, "failed to initialize spectral\n");
1387 1388 1389
		goto err_debug_destroy;
	}

1390 1391 1392 1393 1394 1395 1396
	status = ath10k_thermal_register(ar);
	if (status) {
		ath10k_err(ar, "could not register thermal device: %d\n",
			   status);
		goto err_spectral_destroy;
	}

1397 1398
	set_bit(ATH10K_FLAG_CORE_REGISTERED, &ar->dev_flags);
	return;
1399

1400 1401
err_spectral_destroy:
	ath10k_spectral_destroy(ar);
1402 1403
err_debug_destroy:
	ath10k_debug_destroy(ar);
1404 1405
err_unregister_mac:
	ath10k_mac_unregister(ar);
1406 1407
err_release_fw:
	ath10k_core_free_firmware_files(ar);
1408
err:
1409 1410 1411
	/* TODO: It's probably a good idea to release device from the driver
	 * but calling device_release_driver() here will cause a deadlock.
	 */
1412 1413 1414 1415 1416 1417 1418 1419 1420
	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;
1421 1422 1423 1424 1425
}
EXPORT_SYMBOL(ath10k_core_register);

void ath10k_core_unregister(struct ath10k *ar)
{
1426 1427 1428 1429 1430
	cancel_work_sync(&ar->register_work);

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

1431
	ath10k_thermal_unregister(ar);
1432 1433 1434 1435 1436 1437
	/* 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);

1438 1439 1440 1441
	/* 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);
1442

K
Kalle Valo 已提交
1443 1444
	ath10k_testmode_destroy(ar);

1445
	ath10k_core_free_firmware_files(ar);
1446

1447
	ath10k_debug_unregister(ar);
1448 1449 1450
}
EXPORT_SYMBOL(ath10k_core_unregister);

M
Michal Kazior 已提交
1451
struct ath10k *ath10k_core_create(size_t priv_size, struct device *dev,
K
Kalle Valo 已提交
1452
				  enum ath10k_bus bus,
M
Michal Kazior 已提交
1453
				  enum ath10k_hw_rev hw_rev,
1454 1455 1456
				  const struct ath10k_hif_ops *hif_ops)
{
	struct ath10k *ar;
1457
	int ret;
1458

M
Michal Kazior 已提交
1459
	ar = ath10k_mac_create(priv_size);
1460 1461 1462 1463 1464 1465
	if (!ar)
		return NULL;

	ar->ath_common.priv = ar;
	ar->ath_common.hw = ar->hw;
	ar->dev = dev;
M
Michal Kazior 已提交
1466
	ar->hw_rev = hw_rev;
1467
	ar->hif.ops = hif_ops;
K
Kalle Valo 已提交
1468
	ar->hif.bus = bus;
1469

M
Michal Kazior 已提交
1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483
	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;
	}

1484 1485 1486 1487
	init_completion(&ar->scan.started);
	init_completion(&ar->scan.completed);
	init_completion(&ar->scan.on_channel);
	init_completion(&ar->target_suspend);
1488
	init_completion(&ar->wow.wakeup_completed);
1489 1490 1491

	init_completion(&ar->install_key_done);
	init_completion(&ar->vdev_setup_done);
1492
	init_completion(&ar->thermal.wmi_sync);
1493

1494
	INIT_DELAYED_WORK(&ar->scan.timeout, ath10k_scan_timeout_work);
1495 1496 1497

	ar->workqueue = create_singlethread_workqueue("ath10k_wq");
	if (!ar->workqueue)
1498
		goto err_free_mac;
1499 1500 1501 1502 1503 1504

	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 已提交
1505 1506
	init_waitqueue_head(&ar->htt.empty_tx_wq);
	init_waitqueue_head(&ar->wmi.tx_credits_wq);
1507 1508 1509 1510 1511 1512 1513 1514

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

1515
	INIT_WORK(&ar->register_work, ath10k_core_register_work);
1516 1517
	INIT_WORK(&ar->restart_work, ath10k_core_restart);

1518 1519 1520 1521
	ret = ath10k_debug_create(ar);
	if (ret)
		goto err_free_wq;

1522 1523
	return ar;

1524 1525 1526 1527
err_free_wq:
	destroy_workqueue(ar->workqueue);

err_free_mac:
1528
	ath10k_mac_destroy(ar);
1529

1530 1531 1532 1533 1534 1535 1536 1537 1538
	return NULL;
}
EXPORT_SYMBOL(ath10k_core_create);

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

1539
	ath10k_debug_destroy(ar);
1540 1541 1542 1543
	ath10k_mac_destroy(ar);
}
EXPORT_SYMBOL(ath10k_core_destroy);

1544 1545 1546
MODULE_AUTHOR("Qualcomm Atheros");
MODULE_DESCRIPTION("Core module for QCA988X PCIe devices.");
MODULE_LICENSE("Dual BSD/GPL");