Merge ath-next from ath.git

* Qualcomm Atheros ath10k wireless devices

For ath10k devices the calibration data can be provided through Device

Tree. The node is a child node of the PCI controller.

Required properties:

-compatible : Should be "qcom,ath10k"

Optional properties:

- qcom,ath10k-calibration-data : calibration data as an array, the

				 length can vary between hw versions

Example:

pci {

	pcie@0 {

		reg = <0 0 0 0 0>;

		#interrupt-cells = <1>;

		#size-cells = <2>;

		#address-cells = <3>;

		device_type = "pci";

		ath10k@0,0 {

			reg = <0 0 0 0 0>;

			device_type = "pci";

			qcom,ath10k-calibration-data = [ 01 02 03 ... ];

		};

	};

};

		 htt_tx.o \

		 txrx.o \

		 wmi.o \

		 wmi-tlv.o \

		 bmi.o

ath10k_core-$(CONFIG_ATH10K_DEBUGFS) += spectral.o

ath10k_core-$(CONFIG_NL80211_TESTMODE) += testmode.o

ath10k_core-$(CONFIG_ATH10K_TRACING) += trace.o

ath10k_core-$(CONFIG_THERMAL) += thermal.o

obj-$(CONFIG_ATH10K_PCI) += ath10k_pci.o

ath10k_pci-y += pci.o \

		     (CE_HTT_H2T_MSG_SRC_NENTRIES - 1));

	BUILD_BUG_ON(2*TARGET_10X_NUM_MSDU_DESC >

		     (CE_HTT_H2T_MSG_SRC_NENTRIES - 1));

	BUILD_BUG_ON(2*TARGET_TLV_NUM_MSDU_DESC >

		     (CE_HTT_H2T_MSG_SRC_NENTRIES - 1));

	ce_state->ar = ar;

	ce_state->id = ce_id;

#include <linux/module.h>

#include <linux/firmware.h>

#include <linux/of.h>

#include "core.h"

#include "mac.h"

#include "debug.h"

#include "htt.h"

#include "testmode.h"

#include "wmi-ops.h"

unsigned int ath10k_debug_mask;

static bool uart_print;

static unsigned int ath10k_p2p;

static bool skip_otp;

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_param(skip_otp, bool, 0644);

MODULE_PARM_DESC(debug_mask, "Debugging mask");

MODULE_PARM_DESC(uart_print, "Uart target debugging");

MODULE_PARM_DESC(p2p, "Enable ath10k P2P support");

MODULE_PARM_DESC(skip_otp, "Skip otp failure for calibration in testmode");

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,

		.uart_pin = 7,

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

			.board_size = QCA988X_BOARD_DATA_SZ,

			.board_ext_size = QCA988X_BOARD_EXT_DATA_SZ,

		},

	},

};

static int ath10k_push_board_ext_data(struct ath10k *ar, const void *data,

				      size_t data_len)

{

	u32 board_data_size = QCA988X_BOARD_DATA_SZ;

	u32 board_ext_data_size = QCA988X_BOARD_EXT_DATA_SZ;

	u32 board_data_size = ar->hw_params.fw.board_size;

	u32 board_ext_data_size = ar->hw_params.fw.board_ext_size;

	u32 board_ext_data_addr;

	int ret;

static int ath10k_download_board_data(struct ath10k *ar, const void *data,

				      size_t data_len)

{

	u32 board_data_size = QCA988X_BOARD_DATA_SZ;

	u32 board_data_size = ar->hw_params.fw.board_size;

	u32 address;

	int ret;

	return 0;

}

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;

}

static int ath10k_download_and_run_otp(struct ath10k *ar)

{

	u32 result, address = ar->hw_params.patch_load_addr;

	int ie_id, i, index, bit, ret;

	struct ath10k_fw_ie *hdr;

	const u8 *data;

	__le32 *timestamp;

	__le32 *timestamp, *version;

	/* first fetch the firmware file (firmware-*.bin) */

	ar->firmware = ath10k_fetch_fw_file(ar, ar->hw_params.fw.dir, name);

			ar->otp_len = ie_len;

			break;

		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;

		default:

			ath10k_warn(ar, "Unknown FW IE: %u\n",

				    le32_to_cpu(hdr->id));

		goto err;

	}

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

		ret = -EINVAL;

		goto err;

	}

	/* now fetch the board file */

	if (ar->hw_params.fw.board == NULL) {

		ath10k_err(ar, "board data file not defined");

	/* calibration file is optional, don't check for any errors */

	ath10k_fetch_cal_file(ar);

	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;

	ar->fw_api = 3;

	ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);

	}

	ath10k_dbg(ar, ATH10K_DBG_BOOT,

		   "boot did not find a calibration file, try OTP next: %d\n",

		   "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",

		   ret);

	ret = ath10k_download_and_run_otp(ar);

	if (!uart_print)

		return 0;

	ret = ath10k_bmi_write32(ar, hi_dbg_uart_txpin, 7);

	ret = ath10k_bmi_write32(ar, hi_dbg_uart_txpin, ar->hw_params.uart_pin);

	if (ret) {

		ath10k_warn(ar, "could not enable UART prints (%d)\n", ret);

		return ret;

	complete_all(&ar->offchan_tx_completed);

	complete_all(&ar->install_key_done);

	complete_all(&ar->vdev_setup_done);

	complete_all(&ar->thermal.wmi_sync);

	wake_up(&ar->htt.empty_tx_wq);

	wake_up(&ar->wmi.tx_credits_wq);

	wake_up(&ar->peer_mapping_wq);

	mutex_unlock(&ar->conf_mutex);

}

static void ath10k_core_init_max_sta_count(struct ath10k *ar)

static int ath10k_core_init_firmware_features(struct ath10k *ar)

{

	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;

	}

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

		ar->max_num_peers = TARGET_10X_NUM_PEERS;

		ar->max_num_stations = TARGET_10X_NUM_STATIONS;

			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:

		ar->max_num_peers = TARGET_NUM_PEERS;

		ar->max_num_stations = TARGET_NUM_STATIONS;

		ar->max_num_vdevs = TARGET_NUM_VDEVS;

		ar->htt.max_num_pending_tx = TARGET_NUM_MSDU_DESC;

		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->max_num_peers = TARGET_10X_NUM_PEERS;

		ar->max_num_stations = TARGET_10X_NUM_STATIONS;

		ar->max_num_vdevs = TARGET_10X_NUM_VDEVS;

		ar->htt.max_num_pending_tx = TARGET_10X_NUM_MSDU_DESC;

		break;

	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;

	case ATH10K_FW_WMI_OP_VERSION_UNSET:

	case ATH10K_FW_WMI_OP_VERSION_MAX:

		WARN_ON(1);

		return -EINVAL;

	}

	return 0;

}

int ath10k_core_start(struct ath10k *ar, enum ath10k_firmware_mode mode)

	if (status)

		goto err_hif_stop;

	if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features))

		ar->free_vdev_map = (1LL << TARGET_10X_NUM_VDEVS) - 1;

	else

		ar->free_vdev_map = (1LL << TARGET_NUM_VDEVS) - 1;

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

	INIT_LIST_HEAD(&ar->arvifs);

	ret = ath10k_bmi_get_target_info(ar, &target_info);

	if (ret) {

		ath10k_err(ar, "could not get target info (%d)\n", ret);

		ath10k_hif_power_down(ar);

		return ret;

		goto err_power_down;

	}

	ar->target_version = target_info.version;

	ret = ath10k_init_hw_params(ar);

	if (ret) {

		ath10k_err(ar, "could not get hw params (%d)\n", ret);

		ath10k_hif_power_down(ar);

		return ret;

		goto err_power_down;

	}

	ret = ath10k_core_fetch_firmware_files(ar);

	if (ret) {

		ath10k_err(ar, "could not fetch firmware files (%d)\n", ret);

		ath10k_hif_power_down(ar);

		return ret;

		goto err_power_down;

	}

	ath10k_core_init_max_sta_count(ar);

	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;

	}

	mutex_lock(&ar->conf_mutex);

	ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);

	if (ret) {

		ath10k_err(ar, "could not init core (%d)\n", ret);

		ath10k_core_free_firmware_files(ar);

		ath10k_hif_power_down(ar);

		mutex_unlock(&ar->conf_mutex);

		return ret;

		goto err_unlock;

	}

	ath10k_print_driver_info(ar);

	ath10k_hif_power_down(ar);

	return 0;

}

static int ath10k_core_check_chip_id(struct ath10k *ar)

{

	u32 hw_revision = MS(ar->chip_id, SOC_CHIP_ID_REV);

	ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot chip_id 0x%08x hw_revision 0x%x\n",

		   ar->chip_id, hw_revision);

	/* 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(ar, "ERROR: qca988x hw1.0 is not supported\n");

		return -EOPNOTSUPP;

err_unlock:

	mutex_unlock(&ar->conf_mutex);

	case QCA988X_HW_2_0_CHIP_ID_REV:

		/* known hardware revision, continue normally */

		return 0;

err_free_firmware_files:

	ath10k_core_free_firmware_files(ar);

	default:

		ath10k_warn(ar, "Warning: hardware revision unknown (0x%x), expect problems\n",

			    ar->chip_id);

		return 0;

	}

err_power_down:

	ath10k_hif_power_down(ar);

	return 0;

	return ret;

}

static void ath10k_core_register_work(struct work_struct *work)

		goto err_debug_destroy;

	}

	status = ath10k_thermal_register(ar);

	if (status) {

		ath10k_err(ar, "could not register thermal device: %d\n",

			   status);

		goto err_spectral_destroy;

	}

	set_bit(ATH10K_FLAG_CORE_REGISTERED, &ar->dev_flags);

	return;

err_spectral_destroy:

	ath10k_spectral_destroy(ar);

err_debug_destroy:

	ath10k_debug_destroy(ar);

err_unregister_mac:

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(ar, "Unsupported chip id 0x%08x\n", ar->chip_id);

		return status;

	}

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

	return 0;

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

		return;

	ath10k_thermal_unregister(ar);

	/* 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.

	ar->ath_common.priv = ar;

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

	ar->p2p = !!ath10k_p2p;

	ar->dev = dev;

	ar->hif.ops = hif_ops;

	ar->hif.bus = bus;

	init_completion(&ar->install_key_done);

	init_completion(&ar->vdev_setup_done);

	init_completion(&ar->thermal.wmi_sync);

	INIT_DELAYED_WORK(&ar->scan.timeout, ath10k_scan_timeout_work);

#include "../regd.h"

#include "../dfs_pattern_detector.h"

#include "spectral.h"

#include "thermal.h"

#define MS(_v, _f) (((_v) & _f##_MASK) >> _f##_LSB)

#define SM(_v, _f) (((_v) << _f##_LSB) & _f##_MASK)

};

struct ath10k_wmi {

	enum ath10k_fw_wmi_op_version op_version;

	enum ath10k_htc_ep_id eid;

	struct completion service_ready;

	struct completion unified_ready;

	struct wmi_cmd_map *cmd;

	struct wmi_vdev_param_map *vdev_param;

	struct wmi_pdev_param_map *pdev_param;

	const struct wmi_ops *ops;

	u32 num_mem_chunks;

	struct ath10k_mem_chunk mem_chunks[WMI_MAX_MEM_REQS];

	u32 fw_dbglog_mask;

	u32 pktlog_filter;

	u32 reg_addr;

	u32 nf_cal_period;

	u8 htt_max_amsdu;

	u8 htt_max_ampdu;

	/* wmi_mgmt_rx_hdr contains extra RSSI information */

	ATH10K_FW_FEATURE_EXT_WMI_MGMT_RX = 0,

	/* firmware from 10X branch */

	/* Firmware from 10X branch. Deprecated, don't use in new code. */

	ATH10K_FW_FEATURE_WMI_10X = 1,

	/* firmware support tx frame management over WMI, otherwise it's HTT */

	/* Firmware does not support P2P */

	ATH10K_FW_FEATURE_NO_P2P = 3,

	/* Firmware 10.2 feature bit. The ATH10K_FW_FEATURE_WMI_10X feature bit

	 * is required to be set as well.

	/* Firmware 10.2 feature bit. The ATH10K_FW_FEATURE_WMI_10X feature

	 * bit is required to be set as well. Deprecated, don't use in new

	 * code.

	 */

	ATH10K_FW_FEATURE_WMI_10_2 = 4,

enum ath10k_cal_mode {

	ATH10K_CAL_MODE_FILE,

	ATH10K_CAL_MODE_OTP,

	ATH10K_CAL_MODE_DT,

};

static inline const char *ath10k_cal_mode_str(enum ath10k_cal_mode mode)

		return "file";

	case ATH10K_CAL_MODE_OTP:

		return "otp";

	case ATH10K_CAL_MODE_DT:

		return "dt";

	}

	return "unknown";

		u32 id;

		const char *name;

		u32 patch_load_addr;

		int uart_pin;

		struct ath10k_hw_params_fw {

			const char *dir;

			const char *fw;

			const char *otp;

			const char *board;

			size_t board_size;

			size_t board_ext_size;

		} fw;

	} hw_params;

	int max_num_peers;

	int max_num_stations;

	int max_num_vdevs;

	struct work_struct offchan_tx_work;

	struct sk_buff_head offchan_tx_queue;

		/* protected by conf_mutex */

		const struct firmware *utf;

		DECLARE_BITMAP(orig_fw_features, ATH10K_FW_FEATURE_COUNT);

		enum ath10k_fw_wmi_op_version orig_wmi_op_version;

		/* protected by data_lock */

		bool utf_monitor;

		u32 fw_cold_reset_counter;

	} stats;

	struct ath10k_thermal thermal;

	/* must be last */

	u8 drv_priv[0] __aligned(sizeof(void *));

};