Attachment #288091 for bug #203709




#include "iwl-drv.h"
#include "iwl-debug.h"
#include "acpi.h"
#include "fw/runtime.h"

void *iwl_acpi_get_object(struct device *dev, acpi_string method)
{

	return ret;
}
IWL_EXPORT_SYMBOL(iwl_acpi_get_eckv);

int iwl_sar_set_profile(union acpi_object *table,
			struct iwl_sar_profile *profile,
			bool enabled)
{
	int i;

	profile->enabled = enabled;

	for (i = 0; i < ACPI_SAR_TABLE_SIZE; i++) {
		if (table[i].type != ACPI_TYPE_INTEGER ||
		    table[i].integer.value > U8_MAX)
			return -EINVAL;

		profile->table[i] = table[i].integer.value;
	}

	return 0;
}
IWL_EXPORT_SYMBOL(iwl_sar_set_profile);

int iwl_sar_select_profile(struct iwl_fw_runtime *fwrt,
			   __le16 per_chain_restriction[][IWL_NUM_SUB_BANDS],
			   int prof_a, int prof_b)
{
	int i, j, idx;
	int profs[ACPI_SAR_NUM_CHAIN_LIMITS] = { prof_a, prof_b };

	BUILD_BUG_ON(ACPI_SAR_NUM_CHAIN_LIMITS < 2);
	BUILD_BUG_ON(ACPI_SAR_NUM_CHAIN_LIMITS * ACPI_SAR_NUM_SUB_BANDS !=
		     ACPI_SAR_TABLE_SIZE);

	for (i = 0; i < ACPI_SAR_NUM_CHAIN_LIMITS; i++) {
		struct iwl_sar_profile *prof;

		/* don't allow SAR to be disabled (profile 0 means disable) */
		if (profs[i] == 0)
			return -EPERM;

		/* we are off by one, so allow up to ACPI_SAR_PROFILE_NUM */
		if (profs[i] > ACPI_SAR_PROFILE_NUM)
			return -EINVAL;

		/* profiles go from 1 to 4, so decrement to access the array */
		prof = &fwrt->sar_profiles[profs[i] - 1];

		/* if the profile is disabled, do nothing */
		if (!prof->enabled) {
			IWL_DEBUG_RADIO(fwrt, "SAR profile %d is disabled.\n",
					profs[i]);
			/* if one of the profiles is disabled, we fail all */
			return -ENOENT;
		}
		IWL_DEBUG_INFO(fwrt,
			       "SAR EWRD: chain %d profile index %d\n",
			       i, profs[i]);
		IWL_DEBUG_RADIO(fwrt, "  Chain[%d]:\n", i);
		for (j = 0; j < ACPI_SAR_NUM_SUB_BANDS; j++) {
			idx = (i * ACPI_SAR_NUM_SUB_BANDS) + j;
			per_chain_restriction[i][j] =
				cpu_to_le16(prof->table[idx]);
			IWL_DEBUG_RADIO(fwrt, "    Band[%d] = %d * .125dBm\n",
					j, prof->table[idx]);
		}
	}

	return 0;
}
IWL_EXPORT_SYMBOL(iwl_sar_select_profile);

int iwl_sar_get_wrds_table(struct iwl_fw_runtime *fwrt)
{
	union acpi_object *wifi_pkg, *table, *data;
	bool enabled;
	int ret, tbl_rev;

	data = iwl_acpi_get_object(fwrt->dev, ACPI_WRDS_METHOD);
	if (IS_ERR(data))
		return PTR_ERR(data);

	wifi_pkg = iwl_acpi_get_wifi_pkg(fwrt->dev, data,
					 ACPI_WRDS_WIFI_DATA_SIZE, &tbl_rev);
	if (IS_ERR(wifi_pkg) || tbl_rev != 0) {
		ret = PTR_ERR(wifi_pkg);
		goto out_free;
	}

	if (wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER) {
		ret = -EINVAL;
		goto out_free;
	}

	enabled = !!(wifi_pkg->package.elements[1].integer.value);

	/* position of the actual table */
	table = &wifi_pkg->package.elements[2];

	/* The profile from WRDS is officially profile 1, but goes
	 * into sar_profiles[0] (because we don't have a profile 0).
	 */
	ret = iwl_sar_set_profile(table, &fwrt->sar_profiles[0], enabled);
out_free:
	kfree(data);
	return ret;
}
IWL_EXPORT_SYMBOL(iwl_sar_get_wrds_table);

int iwl_sar_get_ewrd_table(struct iwl_fw_runtime *fwrt)
{
	union acpi_object *wifi_pkg, *data;
	bool enabled;
	int i, n_profiles, tbl_rev, pos;
	int ret = 0;

	data = iwl_acpi_get_object(fwrt->dev, ACPI_EWRD_METHOD);
	if (IS_ERR(data))
		return PTR_ERR(data);

	wifi_pkg = iwl_acpi_get_wifi_pkg(fwrt->dev, data,
					 ACPI_EWRD_WIFI_DATA_SIZE, &tbl_rev);
	if (IS_ERR(wifi_pkg) || tbl_rev != 0) {
		ret = PTR_ERR(wifi_pkg);
		goto out_free;
	}

	if (wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER ||
	    wifi_pkg->package.elements[2].type != ACPI_TYPE_INTEGER) {
		ret = -EINVAL;
		goto out_free;
	}

	enabled = !!(wifi_pkg->package.elements[1].integer.value);
	n_profiles = wifi_pkg->package.elements[2].integer.value;

	/*
	 * Check the validity of n_profiles.  The EWRD profiles start
	 * from index 1, so the maximum value allowed here is
	 * ACPI_SAR_PROFILES_NUM - 1.
	 */
	if (n_profiles <= 0 || n_profiles >= ACPI_SAR_PROFILE_NUM) {
		ret = -EINVAL;
		goto out_free;
	}

	/* the tables start at element 3 */
	pos = 3;

	for (i = 0; i < n_profiles; i++) {
		/* The EWRD profiles officially go from 2 to 4, but we
		 * save them in sar_profiles[1-3] (because we don't
		 * have profile 0).  So in the array we start from 1.
		 */
		ret = iwl_sar_set_profile(&wifi_pkg->package.elements[pos],
					  &fwrt->sar_profiles[i + 1],
					  enabled);
		if (ret < 0)
			break;

		/* go to the next table */
		pos += ACPI_SAR_TABLE_SIZE;
	}

out_free:
	kfree(data);
	return ret;
}
IWL_EXPORT_SYMBOL(iwl_sar_get_ewrd_table);

int iwl_sar_get_wgds_table(struct iwl_fw_runtime *fwrt)
{
	union acpi_object *wifi_pkg, *data;
	int i, j, ret, tbl_rev;
	int idx = 1;

	data = iwl_acpi_get_object(fwrt->dev, ACPI_WGDS_METHOD);
	if (IS_ERR(data))
		return PTR_ERR(data);

	wifi_pkg = iwl_acpi_get_wifi_pkg(fwrt->dev, data,
					 ACPI_WGDS_WIFI_DATA_SIZE, &tbl_rev);
	if (IS_ERR(wifi_pkg) || tbl_rev > 1) {
		ret = PTR_ERR(wifi_pkg);
		goto out_free;
	}

	fwrt->geo_rev = tbl_rev;
	for (i = 0; i < ACPI_NUM_GEO_PROFILES; i++) {
		for (j = 0; j < ACPI_GEO_TABLE_SIZE; j++) {
			union acpi_object *entry;

			entry = &wifi_pkg->package.elements[idx++];
			if (entry->type != ACPI_TYPE_INTEGER ||
			    entry->integer.value > U8_MAX) {
				ret = -EINVAL;
				goto out_free;
			}

			fwrt->geo_profiles[i].values[j] = entry->integer.value;
		}
	}
	ret = 0;
out_free:
	kfree(data);
	return ret;
}
IWL_EXPORT_SYMBOL(iwl_sar_get_wgds_table);

bool iwl_sar_geo_support(struct iwl_fw_runtime *fwrt)
{
	/*
	 * The GEO_TX_POWER_LIMIT command is not supported on earlier
	 * firmware versions.  Unfortunately, we don't have a TLV API
	 * flag to rely on, so rely on the major version which is in
	 * the first byte of ucode_ver.  This was implemented
	 * initially on version 38 and then backported to 17.  It was
	 * also backported to 29, but only for 7265D devices.  The
	 * intention was to have it in 36 as well, but not all 8000
	 * family got this feature enabled.  The 8000 family is the
	 * only one using version 36, so skip this version entirely.
	 */
	return IWL_UCODE_SERIAL(fwrt->fw->ucode_ver) >= 38 ||
	       IWL_UCODE_SERIAL(fwrt->fw->ucode_ver) == 17 ||
	       (IWL_UCODE_SERIAL(fwrt->fw->ucode_ver) == 29 &&
		((fwrt->trans->hw_rev & CSR_HW_REV_TYPE_MSK) ==
		 CSR_HW_REV_TYPE_7265D));
}
IWL_EXPORT_SYMBOL(iwl_sar_geo_support);

int iwl_validate_sar_geo_profile(struct iwl_fw_runtime *fwrt,
				 struct iwl_host_cmd *cmd)
{
	struct iwl_geo_tx_power_profiles_resp *resp;
	int ret;

	resp = (void *)cmd->resp_pkt->data;
	ret = le32_to_cpu(resp->profile_idx);
	if (WARN_ON(ret > ACPI_NUM_GEO_PROFILES)) {
		ret = -EIO;
		IWL_WARN(fwrt, "Invalid geographic profile idx (%d)\n", ret);
	}

	return ret;
}
IWL_EXPORT_SYMBOL(iwl_validate_sar_geo_profile);

void iwl_sar_geo_init(struct iwl_fw_runtime *fwrt,
		      struct iwl_per_chain_offset_group *table)
{
	int ret, i, j;

	if (!iwl_sar_geo_support(fwrt))
		return;

	ret = iwl_sar_get_wgds_table(fwrt);
	if (ret < 0) {
		IWL_DEBUG_RADIO(fwrt,
				"Geo SAR BIOS table invalid or unavailable. (%d)\n",
				ret);
		/* we don't fail if the table is not available */
		return;
	}

	BUILD_BUG_ON(ACPI_NUM_GEO_PROFILES * ACPI_WGDS_NUM_BANDS *
		     ACPI_WGDS_TABLE_SIZE + 1 !=  ACPI_WGDS_WIFI_DATA_SIZE);

	BUILD_BUG_ON(ACPI_NUM_GEO_PROFILES > IWL_NUM_GEO_PROFILES);

	for (i = 0; i < ACPI_NUM_GEO_PROFILES; i++) {
		struct iwl_per_chain_offset *chain =
			(struct iwl_per_chain_offset *)&table[i];

		for (j = 0; j < ACPI_WGDS_NUM_BANDS; j++) {
			u8 *value;

			value = &fwrt->geo_profiles[i].values[j *
				ACPI_GEO_PER_CHAIN_SIZE];
			chain[j].max_tx_power = cpu_to_le16(value[0]);
			chain[j].chain_a = value[1];
			chain[j].chain_b = value[2];
			IWL_DEBUG_RADIO(fwrt,
					"SAR geographic profile[%d] Band[%d]: chain A = %d chain B = %d max_tx_power = %d\n",
					i, j, value[1], value[2], value[0]);
		}
	}
}
IWL_EXPORT_SYMBOL(iwl_sar_geo_init);




#define __iwl_fw_acpi__

#include <linux/acpi.h>
#include "fw/api/commands.h"
#include "fw/api/power.h"
#include "fw/api/phy.h"
#include "fw/img.h"
#include "iwl-trans.h"


#define ACPI_WRDS_METHOD	"WRDS"
#define ACPI_EWRD_METHOD	"EWRD"

#define ACPI_PPAG_MIN_HB -16
#define ACPI_PPAG_MAX_HB 40

struct iwl_sar_profile {
	bool enabled;
	u8 table[ACPI_SAR_TABLE_SIZE];
};

struct iwl_geo_profile {
	u8 values[ACPI_GEO_TABLE_SIZE];
};

#ifdef CONFIG_ACPI

struct iwl_fw_runtime;

void *iwl_acpi_get_object(struct device *dev, acpi_string method);

union acpi_object *iwl_acpi_get_wifi_pkg(struct device *dev,
					 union acpi_object *data,
					 int data_size, int *tbl_rev);

 */
int iwl_acpi_get_eckv(struct device *dev, u32 *extl_clk);

int iwl_sar_set_profile(union acpi_object *table,
			struct iwl_sar_profile *profile,
			bool enabled);

int iwl_sar_select_profile(struct iwl_fw_runtime *fwrt,
			   __le16 per_chain_restriction[][IWL_NUM_SUB_BANDS],
			   int prof_a, int prof_b);

int iwl_sar_get_wrds_table(struct iwl_fw_runtime *fwrt);

int iwl_sar_get_ewrd_table(struct iwl_fw_runtime *fwrt);

int iwl_sar_get_wgds_table(struct iwl_fw_runtime *fwrt);

bool iwl_sar_geo_support(struct iwl_fw_runtime *fwrt);

int iwl_validate_sar_geo_profile(struct iwl_fw_runtime *fwrt,
				 struct iwl_host_cmd *cmd);

void iwl_sar_geo_init(struct iwl_fw_runtime *fwrt,
		      struct iwl_per_chain_offset_group *table);
#else /* CONFIG_ACPI */

static inline void *iwl_acpi_get_object(struct device *dev, acpi_string method)

	return -ENOENT;
}

static inline int iwl_sar_set_profile(union acpi_object *table,
				      struct iwl_sar_profile *profile,
				      bool enabled)
{
	return -ENOENT;
}

static inline int iwl_sar_select_profile(struct iwl_fw_runtime *fwrt,
			   __le16 per_chain_restriction[][IWL_NUM_SUB_BANDS],
			   int prof_a, int prof_b)
{
	return -ENOENT;
}

static inline int iwl_sar_get_wrds_table(struct iwl_fw_runtime *fwrt)
{
	return -ENOENT;
}

static inline int iwl_sar_get_ewrd_table(struct iwl_fw_runtime *fwrt)
{
	return -ENOENT;
}

static inline int iwl_sar_get_wgds_table(struct iwl_fw_runtime *fwrt)
{
	return -ENOENT;
}

static inline bool iwl_sar_geo_support(struct iwl_fw_runtime *fwrt)
{
	return false;
}

static inline int iwl_validate_sar_geo_profile(struct iwl_fw_runtime *fwrt,
					       struct iwl_host_cmd *cmd)
{
	return -ENOENT;
}

static inline void iwl_sar_geo_init(struct iwl_fw_runtime *fwrt,
				    struct iwl_per_chain_offset_group *table)
{
}

#endif /* CONFIG_ACPI */
#endif /* __iwl_fw_acpi__ */




#include "img.h"
#include "fw/api/debug.h"
#include "fw/api/paging.h"
#include "fw/api/power.h"
#include "iwl-eeprom-parse.h"
#include "fw/acpi.h"

#define IWL_FW_DBG_DOMAIN		IWL_FW_INI_DOMAIN_ALWAYS_ON


		u32 delay;
		u64 seq;
	} timestamp;
	bool tpc_enabled;
#endif /* CONFIG_IWLWIFI_DEBUGFS */
#ifdef CONFIG_ACPI
	struct iwl_sar_profile sar_profiles[ACPI_SAR_PROFILE_NUM];
	u8 sar_chain_a_profile;
	u8 sar_chain_b_profile;
	struct iwl_geo_profile geo_profiles[ACPI_NUM_GEO_PROFILES];
	u32 geo_rev;
	struct iwl_ppag_table_cmd ppag_table;
#endif
};

void iwl_fw_runtime_init(struct iwl_fw_runtime *fwrt, struct iwl_trans *trans,

Lines 378-384 static ssize_t iwl_dbgfs_sar_geo_profile_read(struct file *file, Link Here

(-)a/drivers/net/wireless/intel/iwlwifi/mvm/debugfs.c (-1 / +1 lines)
378	pos = scnprintf(buf, bufsz,	378	pos = scnprintf(buf, bufsz,
379	"SAR geographic profile disabled\n");	379	"SAR geographic profile disabled\n");
380	} else {	380	} else {
381	value = &mvm->fwrt.geo_profiles[tbl_idx - 1].values[0];	381	value = &mvm->geo_profiles[tbl_idx - 1].values[0];
382		382
383	pos += scnprintf(buf + pos, bufsz - pos,	383	pos += scnprintf(buf + pos, bufsz - pos,
384	"Use geographic profile %d\n", tbl_idx);	384	"Use geographic profile %d\n", tbl_idx);




}

#ifdef CONFIG_ACPI
static inline int iwl_mvm_sar_set_profile(struct iwl_mvm *mvm,
					  union acpi_object *table,
					  struct iwl_mvm_sar_profile *profile,
					  bool enabled)
{
	int i;

	profile->enabled = enabled;

	for (i = 0; i < ACPI_SAR_TABLE_SIZE; i++) {
		if ((table[i].type != ACPI_TYPE_INTEGER) ||
		    (table[i].integer.value > U8_MAX))
			return -EINVAL;

		profile->table[i] = table[i].integer.value;
	}

	return 0;
}

static int iwl_mvm_sar_get_wrds_table(struct iwl_mvm *mvm)
{
	union acpi_object *wifi_pkg, *table, *data;
	bool enabled;
	int ret, tbl_rev;

	data = iwl_acpi_get_object(mvm->dev, ACPI_WRDS_METHOD);
	if (IS_ERR(data))
		return PTR_ERR(data);

	wifi_pkg = iwl_acpi_get_wifi_pkg(mvm->dev, data,
					 ACPI_WRDS_WIFI_DATA_SIZE, &tbl_rev);
	if (IS_ERR(wifi_pkg)) {
		ret = PTR_ERR(wifi_pkg);
		goto out_free;
	}

	if (wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER ||
	    tbl_rev != 0) {
		ret = -EINVAL;
		goto out_free;
	}

	enabled = !!(wifi_pkg->package.elements[1].integer.value);

	/* position of the actual table */
	table = &wifi_pkg->package.elements[2];

	/* The profile from WRDS is officially profile 1, but goes
	 * into sar_profiles[0] (because we don't have a profile 0).
	 */
	ret = iwl_mvm_sar_set_profile(mvm, table, &mvm->sar_profiles[0],
				      enabled);
out_free:
	kfree(data);
	return ret;
}

static int iwl_mvm_sar_get_ewrd_table(struct iwl_mvm *mvm)
{
	union acpi_object *wifi_pkg, *data;
	bool enabled;
	int i, n_profiles, ret, tbl_rev;

	data = iwl_acpi_get_object(mvm->dev, ACPI_EWRD_METHOD);
	if (IS_ERR(data))
		return PTR_ERR(data);

	wifi_pkg = iwl_acpi_get_wifi_pkg(mvm->dev, data,
					 ACPI_EWRD_WIFI_DATA_SIZE, &tbl_rev);
	if (IS_ERR(wifi_pkg)) {
		ret = PTR_ERR(wifi_pkg);
		goto out_free;
	}

	if ((wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER) ||
	    (wifi_pkg->package.elements[2].type != ACPI_TYPE_INTEGER) ||
	    tbl_rev != 0) {
		ret = -EINVAL;
		goto out_free;
	}

	enabled = !!(wifi_pkg->package.elements[1].integer.value);
	n_profiles = wifi_pkg->package.elements[2].integer.value;

	/*
	 * Check the validity of n_profiles.  The EWRD profiles start
	 * from index 1, so the maximum value allowed here is
	 * ACPI_SAR_PROFILES_NUM - 1.
	 */
	if (n_profiles <= 0 || n_profiles >= ACPI_SAR_PROFILE_NUM) {
		ret = -EINVAL;
		goto out_free;
	}

	for (i = 0; i < n_profiles; i++) {
		/* the tables start at element 3 */
		int pos = 3;

		/* The EWRD profiles officially go from 2 to 4, but we
		 * save them in sar_profiles[1-3] (because we don't
		 * have profile 0).  So in the array we start from 1.
		 */
		ret = iwl_mvm_sar_set_profile(mvm,
					      &wifi_pkg->package.elements[pos],
					      &mvm->sar_profiles[i + 1],
					      enabled);
		if (ret < 0)
			break;

		/* go to the next table */
		pos += ACPI_SAR_TABLE_SIZE;
	}

out_free:
	kfree(data);
	return ret;
}

static int iwl_mvm_sar_get_wgds_table(struct iwl_mvm *mvm)
{
	union acpi_object *wifi_pkg, *data;
	int i, j, ret, tbl_rev;
	int idx = 1;

	data = iwl_acpi_get_object(mvm->dev, ACPI_WGDS_METHOD);
	if (IS_ERR(data))
		return PTR_ERR(data);

	wifi_pkg = iwl_acpi_get_wifi_pkg(mvm->dev, data,
					 ACPI_WGDS_WIFI_DATA_SIZE, &tbl_rev);
	if (IS_ERR(wifi_pkg)) {
		ret = PTR_ERR(wifi_pkg);
		goto out_free;
	}

	if (tbl_rev != 0) {
		ret = -EINVAL;
		goto out_free;
	}

	mvm->geo_rev = tbl_rev;
	for (i = 0; i < ACPI_NUM_GEO_PROFILES; i++) {
		for (j = 0; j < ACPI_GEO_TABLE_SIZE; j++) {
			union acpi_object *entry;

			entry = &wifi_pkg->package.elements[idx++];
			if ((entry->type != ACPI_TYPE_INTEGER) ||
			    (entry->integer.value > U8_MAX)) {
				ret = -EINVAL;
				goto out_free;
			}

			mvm->geo_profiles[i].values[j] = entry->integer.value;
		}
	}
	ret = 0;
out_free:
	kfree(data);
	return ret;
}

int iwl_mvm_sar_select_profile(struct iwl_mvm *mvm, int prof_a, int prof_b)
{
	union {
		struct iwl_dev_tx_power_cmd v5;
		struct iwl_dev_tx_power_cmd_v4 v4;
	} cmd;
	int i, j, idx;
	int profs[ACPI_SAR_NUM_CHAIN_LIMITS] = { prof_a, prof_b };
	int len;

	BUILD_BUG_ON(ACPI_SAR_NUM_CHAIN_LIMITS < 2);
	BUILD_BUG_ON(ACPI_SAR_NUM_CHAIN_LIMITS * ACPI_SAR_NUM_SUB_BANDS !=
		     ACPI_SAR_TABLE_SIZE);

	cmd.v5.v3.set_mode = cpu_to_le32(IWL_TX_POWER_MODE_SET_CHAINS);


		len = sizeof(cmd.v5);
	else if (fw_has_capa(&mvm->fw->ucode_capa,
			     IWL_UCODE_TLV_CAPA_TX_POWER_ACK))
		len = sizeof(cmd.v4);
	else
		len = sizeof(cmd.v4.v3);

	for (i = 0; i < ACPI_SAR_NUM_CHAIN_LIMITS; i++) {
		struct iwl_mvm_sar_profile *prof;

		/* don't allow SAR to be disabled (profile 0 means disable) */
		if (profs[i] == 0)
			return -EPERM;

		/* we are off by one, so allow up to ACPI_SAR_PROFILE_NUM */
		if (profs[i] > ACPI_SAR_PROFILE_NUM)
			return -EINVAL;

		/* profiles go from 1 to 4, so decrement to access the array */
		prof = &mvm->sar_profiles[profs[i] - 1];

		/* if the profile is disabled, do nothing */
		if (!prof->enabled) {
			IWL_DEBUG_RADIO(mvm, "SAR profile %d is disabled.\n",
					profs[i]);
			/* if one of the profiles is disabled, we fail all */
			return -ENOENT;
		}

		IWL_DEBUG_INFO(mvm,
			       "SAR EWRD: chain %d profile index %d\n",
			       i, profs[i]);
		IWL_DEBUG_RADIO(mvm, "  Chain[%d]:\n", i);
		for (j = 0; j < ACPI_SAR_NUM_SUB_BANDS; j++) {
			idx = (i * ACPI_SAR_NUM_SUB_BANDS) + j;
			cmd.v5.v3.per_chain_restriction[i][j] =
				cpu_to_le16(prof->table[idx]);
			IWL_DEBUG_RADIO(mvm, "    Band[%d] = %d * .125dBm\n",
					j, prof->table[idx]);
		}
	}

	if (iwl_sar_select_profile(&mvm->fwrt, cmd.v5.v3.per_chain_restriction,
				   prof_a, prof_b))
		return -ENOENT;
	IWL_DEBUG_RADIO(mvm, "Sending REDUCE_TX_POWER_CMD per chain\n");

	return iwl_mvm_send_cmd_pdu(mvm, REDUCE_TX_POWER_CMD, 0, len, &cmd);
}

static bool iwl_mvm_sar_geo_support(struct iwl_mvm *mvm)
{
	/*
	 * The GEO_TX_POWER_LIMIT command is not supported on earlier
	 * firmware versions.  Unfortunately, we don't have a TLV API
	 * flag to rely on, so rely on the major version which is in
	 * the first byte of ucode_ver.  This was implemented
	 * initially on version 38 and then backported to 17.  It was
	 * also backported to 29, but only for 7265D devices.  The
	 * intention was to have it in 36 as well, but not all 8000
	 * family got this feature enabled.  The 8000 family is the
	 * only one using version 36, so skip this version entirely.
	 */
	return IWL_UCODE_SERIAL(mvm->fw->ucode_ver) >= 38 ||
	       IWL_UCODE_SERIAL(mvm->fw->ucode_ver) == 17 ||
	       (IWL_UCODE_SERIAL(mvm->fw->ucode_ver) == 29 &&
		((mvm->trans->hw_rev & CSR_HW_REV_TYPE_MSK) ==
		 CSR_HW_REV_TYPE_7265D));
}

int iwl_mvm_get_sar_geo_profile(struct iwl_mvm *mvm)
{
	struct iwl_geo_tx_power_profiles_resp *resp;
	u16 len;
	int ret;
	u16 len;
	void *data;
	struct iwl_geo_tx_power_profiles_cmd geo_cmd;
	struct iwl_geo_tx_power_profiles_cmd_v1 geo_cmd_v1;
	struct iwl_host_cmd cmd;

	if (fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_SAR_TABLE_VER)) {
		geo_cmd.ops =
		geo_tx_cmd.geo_cmd.ops =
			cpu_to_le32(IWL_PER_CHAIN_OFFSET_GET_CURRENT_TABLE);
		len = sizeof(geo_cmd);
		data = &geo_cmd;
	} else {
		geo_cmd_v1.ops =
			cpu_to_le32(IWL_PER_CHAIN_OFFSET_GET_CURRENT_TABLE);
		len = sizeof(geo_cmd_v1);
		data = &geo_cmd_v1;
	}

	if (!iwl_sar_geo_support(&mvm->fwrt))
		return -EOPNOTSUPP;

	cmd = (struct iwl_host_cmd){
		.id =  WIDE_ID(PHY_OPS_GROUP, GEO_TX_POWER_LIMIT),
		.len = { len, },
		.flags = CMD_WANT_SKB,
		.data = { data },
	};

	if (!iwl_mvm_sar_geo_support(mvm))
		return -EOPNOTSUPP;

	ret = iwl_mvm_send_cmd(mvm, &cmd);
	if (ret) {
		IWL_ERR(mvm, "Failed to get geographic profile info %d\n", ret);
		return ret;
	}

	resp = (void *)cmd.resp_pkt->data;
	ret = le32_to_cpu(resp->profile_idx);
	if (WARN_ON(ret > ACPI_NUM_GEO_PROFILES)) {
		ret = -EIO;
		IWL_WARN(mvm, "Invalid geographic profile idx (%d)\n", ret);
	}

	iwl_free_resp(&cmd);
	return ret;
}

static int iwl_mvm_sar_geo_init(struct iwl_mvm *mvm)
{
	struct iwl_geo_tx_power_profiles_cmd cmd = {
		.ops = cpu_to_le32(IWL_PER_CHAIN_OFFSET_SET_TABLES),
	};
	int ret, i, j;
	u16 cmd_wide_id =  WIDE_ID(PHY_OPS_GROUP, GEO_TX_POWER_LIMIT);
	union geo_tx_power_profiles_cmd cmd;
	u16 len;

	if (!iwl_mvm_sar_geo_support(mvm))
		return 0;

	ret = iwl_mvm_sar_get_wgds_table(mvm);
	if (ret < 0) {
		IWL_DEBUG_RADIO(mvm,
				"Geo SAR BIOS table invalid or unavailable. (%d)\n",
				ret);
		/* we don't fail if the table is not available */
		return 0;
	}

	IWL_DEBUG_RADIO(mvm, "Sending GEO_TX_POWER_LIMIT\n");

	BUILD_BUG_ON(ACPI_NUM_GEO_PROFILES * ACPI_WGDS_NUM_BANDS *
		     ACPI_WGDS_TABLE_SIZE + 1 !=  ACPI_WGDS_WIFI_DATA_SIZE);

	BUILD_BUG_ON(ACPI_NUM_GEO_PROFILES > IWL_NUM_GEO_PROFILES);

	for (i = 0; i < ACPI_NUM_GEO_PROFILES; i++) {
		struct iwl_per_chain_offset *chain =
			(struct iwl_per_chain_offset *)&cmd.table[i];

		for (j = 0; j < ACPI_WGDS_NUM_BANDS; j++) {
			u8 *value;

			value = &mvm->geo_profiles[i].values[j *
				ACPI_GEO_PER_CHAIN_SIZE];
			chain[j].max_tx_power = cpu_to_le16(value[0]);
			chain[j].chain_a = value[1];
			chain[j].chain_b = value[2];
			IWL_DEBUG_RADIO(mvm,
					"SAR geographic profile[%d] Band[%d]: chain A = %d chain B = %d max_tx_power = %d\n",
					i, j, value[1], value[2], value[0]);
		}
	}

	cmd.table_revision = cpu_to_le32(mvm->geo_rev);

	if (!fw_has_api(&mvm->fw->ucode_capa,
		       IWL_UCODE_TLV_API_SAR_TABLE_VER)) {
		return iwl_mvm_send_cmd_pdu(mvm, cmd_wide_id, 0,
				sizeof(struct iwl_geo_tx_power_profiles_cmd_v1),
				&cmd);
	}

	return iwl_mvm_send_cmd_pdu(mvm, cmd_wide_id, 0, sizeof(cmd), &cmd);
}

static int iwl_mvm_get_ppag_table(struct iwl_mvm *mvm)

	int i, j, ret, tbl_rev;
	int idx = 2;

	mvm->ppag_table.enabled = cpu_to_le32(0);
	data = iwl_acpi_get_object(mvm->dev, ACPI_PPAG_METHOD);
	if (IS_ERR(data))
		return PTR_ERR(data);

		goto out_free;
	}

	mvm->ppag_table.enabled = cpu_to_le32(enabled->integer.value);
	if (!mvm->ppag_table.enabled) {
		ret = 0;
		goto out_free;
	}

			    (j == 0 && ent->integer.value < ACPI_PPAG_MIN_LB) ||
			    (j != 0 && ent->integer.value > ACPI_PPAG_MAX_HB) ||
			    (j != 0 && ent->integer.value < ACPI_PPAG_MIN_HB)) {
				mvm->ppag_table.enabled = cpu_to_le32(0);
				ret = -EINVAL;
				goto out_free;
			}
			mvm->ppag_table.gain[i][j] = ent->integer.value;
		}
	}
	ret = 0;

		return 0;
	}

	if (!mvm->ppag_table.enabled) {
		IWL_DEBUG_RADIO(mvm,
				"PPAG not enabled, command not sent.\n");
		return 0;

		for (j = 0; j < ACPI_PPAG_NUM_SUB_BANDS; j++) {
			IWL_DEBUG_RADIO(mvm,
					"PPAG table: chain[%d] band[%d]: gain = %d\n",
					i, j, mvm->ppag_table.gain[i][j]);
		}
	}

	ret = iwl_mvm_send_cmd_pdu(mvm, WIDE_ID(PHY_OPS_GROUP,
						PER_PLATFORM_ANT_GAIN_CMD),
				   0, sizeof(mvm->ppag_table),
				   &mvm->ppag_table);
	if (ret < 0)
		IWL_ERR(mvm, "failed to send PER_PLATFORM_ANT_GAIN_CMD (%d)\n",
			ret);

}

#else /* CONFIG_ACPI */
static int iwl_mvm_sar_get_wrds_table(struct iwl_mvm *mvm)
{
	return -ENOENT;
}

static int iwl_mvm_sar_get_ewrd_table(struct iwl_mvm *mvm)
				      int prof_a, int prof_b)
{
	return -ENOENT;
}

static int iwl_mvm_sar_get_wgds_table(struct iwl_mvm *mvm)
{
	return -ENOENT;
}

	return 0;
}

int iwl_mvm_sar_select_profile(struct iwl_mvm *mvm, int prof_a,
			       int prof_b)
{
	return -ENOENT;
}

int iwl_mvm_get_sar_geo_profile(struct iwl_mvm *mvm)
{
	return -ENOENT;
}

int iwl_mvm_ppag_send_cmd(struct iwl_mvm *mvm)
{
	return -ENOENT;


static int iwl_mvm_ppag_init(struct iwl_mvm *mvm)
{
	return -ENOENT;
}
#endif /* CONFIG_ACPI */


{
	int ret;

	ret = iwl_mvm_sar_get_wrds_table(mvm);
	if (ret < 0) {
		IWL_DEBUG_RADIO(mvm,
				"WRDS SAR BIOS table invalid or unavailable. (%d)\n",

		return 1;
	}

	ret = iwl_mvm_sar_get_ewrd_table(mvm);
	/* if EWRD is not available, we can still use WRDS, so don't fail */
	if (ret < 0)
		IWL_DEBUG_RADIO(mvm,
				"EWRD SAR BIOS table invalid or unavailable. (%d)\n",
				ret);

	/* choose profile 1 (WRDS) as default for both chains */
	ret = iwl_mvm_sar_select_profile(mvm, 1, 1);

	/*
	 * If we don't have profile 0 from BIOS, just skip it.  This
	 * means that SAR Geo will not be enabled either, even if we

	ret = iwl_mvm_sar_init(mvm);
	if (ret == 0) {
		ret = iwl_mvm_sar_geo_init(mvm);
	} else if (ret > 0 && !iwl_mvm_sar_get_wgds_table(mvm)) {
		/*
		 * If basic SAR is not available, we check for WGDS,
		 * which should *not* be available either.  If it is




	IWL_POWER_SCHEME_LP
};

union geo_tx_power_profiles_cmd {
	struct iwl_geo_tx_power_profiles_cmd geo_cmd;
	struct iwl_geo_tx_power_profiles_cmd_v1 geo_cmd_v1;
};

#define IWL_CONN_MAX_LISTEN_INTERVAL	10
#define IWL_UAPSD_MAX_SP		IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL



#define IWL_MVM_NUM_CIPHERS             10

struct iwl_mvm_sar_profile {
	bool enabled;
	u8 table[ACPI_SAR_TABLE_SIZE];
};

struct iwl_mvm_geo_profile {
	u8 values[ACPI_GEO_TABLE_SIZE];
};

struct iwl_mvm_txq {
	struct list_head list;

	/* sniffer data to include in radiotap */
	__le16 cur_aid;
	u8 cur_bssid[ETH_ALEN];

#ifdef CONFIG_ACPI
	struct iwl_mvm_sar_profile sar_profiles[ACPI_SAR_PROFILE_NUM];
	struct iwl_mvm_geo_profile geo_profiles[ACPI_NUM_GEO_PROFILES];
	u32 geo_rev;
	struct iwl_ppag_table_cmd ppag_table;
	u32 ppag_rev;
#endif
};

/* Extract MVM priv from op_mode and _hw */
- 

Return to bug 203709

Lines 61-72 Link Here

(-)a/drivers/net/wireless/intel/iwlwifi/fw/acpi.h (-84 lines)
61	#define __iwl_fw_acpi__	61	#define __iwl_fw_acpi__
62		62
63	#include <linux/acpi.h>	63	#include <linux/acpi.h>
64	#include "fw/api/commands.h"
65	#include "fw/api/power.h"
66	#include "fw/api/phy.h"
67	#include "fw/img.h"
68	#include "iwl-trans.h"
69
70		64
71	#define ACPI_WRDS_METHOD "WRDS"	65	#define ACPI_WRDS_METHOD "WRDS"
72	#define ACPI_EWRD_METHOD "EWRD"	66	#define ACPI_EWRD_METHOD "EWRD"
Lines 110-130 Link Here
110	#define ACPI_PPAG_MIN_HB -16	104	#define ACPI_PPAG_MIN_HB -16
111	#define ACPI_PPAG_MAX_HB 40	105	#define ACPI_PPAG_MAX_HB 40
112		106
113	struct iwl_sar_profile {
114	bool enabled;
115	u8 table[ACPI_SAR_TABLE_SIZE];
116	};
117
118	struct iwl_geo_profile {
119	u8 values[ACPI_GEO_TABLE_SIZE];
120	};
121
122	#ifdef CONFIG_ACPI	107	#ifdef CONFIG_ACPI
123		108
124	struct iwl_fw_runtime;
125
126	void iwl_acpi_get_object(struct device dev, acpi_string method);	109	void iwl_acpi_get_object(struct device dev, acpi_string method);
127
128	union acpi_object iwl_acpi_get_wifi_pkg(struct device dev,	110	union acpi_object iwl_acpi_get_wifi_pkg(struct device dev,
129	union acpi_object *data,	111	union acpi_object *data,
130	int data_size, int *tbl_rev);	112	int data_size, int *tbl_rev);
Lines 152-178 u64 iwl_acpi_get_pwr_limit(struct device *dev); Link Here
152	*/	134	*/
153	int iwl_acpi_get_eckv(struct device dev, u32 extl_clk);	135	int iwl_acpi_get_eckv(struct device dev, u32 extl_clk);
154		136
155	int iwl_sar_set_profile(union acpi_object *table,
156	struct iwl_sar_profile *profile,
157	bool enabled);
158
159	int iwl_sar_select_profile(struct iwl_fw_runtime *fwrt,
160	__le16 per_chain_restriction[][IWL_NUM_SUB_BANDS],
161	int prof_a, int prof_b);
162
163	int iwl_sar_get_wrds_table(struct iwl_fw_runtime *fwrt);
164
165	int iwl_sar_get_ewrd_table(struct iwl_fw_runtime *fwrt);
166
167	int iwl_sar_get_wgds_table(struct iwl_fw_runtime *fwrt);
168
169	bool iwl_sar_geo_support(struct iwl_fw_runtime *fwrt);
170
171	int iwl_validate_sar_geo_profile(struct iwl_fw_runtime *fwrt,
172	struct iwl_host_cmd *cmd);
173
174	void iwl_sar_geo_init(struct iwl_fw_runtime *fwrt,
175	struct iwl_per_chain_offset_group *table);
176	#else /* CONFIG_ACPI */	137	#else /* CONFIG_ACPI */
177		138
178	static inline void iwl_acpi_get_object(struct device dev, acpi_string method)	139	static inline void iwl_acpi_get_object(struct device dev, acpi_string method)
Lines 203-252 static inline int iwl_acpi_get_eckv(struct device dev, u32 extl_clk) Link Here
203	return -ENOENT;	164	return -ENOENT;
204	}	165	}
205		166
206	static inline int iwl_sar_set_profile(union acpi_object *table,
207	struct iwl_sar_profile *profile,
208	bool enabled)
209	{
210	return -ENOENT;
211	}
212
213	static inline int iwl_sar_select_profile(struct iwl_fw_runtime *fwrt,
214	__le16 per_chain_restriction[][IWL_NUM_SUB_BANDS],
215	int prof_a, int prof_b)
216	{
217	return -ENOENT;
218	}
219
220	static inline int iwl_sar_get_wrds_table(struct iwl_fw_runtime *fwrt)
221	{
222	return -ENOENT;
223	}
224
225	static inline int iwl_sar_get_ewrd_table(struct iwl_fw_runtime *fwrt)
226	{
227	return -ENOENT;
228	}
229
230	static inline int iwl_sar_get_wgds_table(struct iwl_fw_runtime *fwrt)
231	{
232	return -ENOENT;
233	}
234
235	static inline bool iwl_sar_geo_support(struct iwl_fw_runtime *fwrt)
236	{
237	return false;
238	}
239
240	static inline int iwl_validate_sar_geo_profile(struct iwl_fw_runtime *fwrt,
241	struct iwl_host_cmd *cmd)
242	{
243	return -ENOENT;
244	}
245
246	static inline void iwl_sar_geo_init(struct iwl_fw_runtime *fwrt,
247	struct iwl_per_chain_offset_group *table)
248	{
249	}
250
251	#endif /* CONFIG_ACPI */	167	#endif /* CONFIG_ACPI */
252	#endif /* __iwl_fw_acpi__ */	168	#endif /* __iwl_fw_acpi__ */

Lines 188-198 enum iwl_power_scheme { Link Here

(-)a/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h (-6 / +16 lines)
188	IWL_POWER_SCHEME_LP	188	IWL_POWER_SCHEME_LP
189	};	189	};
190		190
191	union geo_tx_power_profiles_cmd {
192	struct iwl_geo_tx_power_profiles_cmd geo_cmd;
193	struct iwl_geo_tx_power_profiles_cmd_v1 geo_cmd_v1;
194	};
195
196	#define IWL_CONN_MAX_LISTEN_INTERVAL 10	191	#define IWL_CONN_MAX_LISTEN_INTERVAL 10
197	#define IWL_UAPSD_MAX_SP IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL	192	#define IWL_UAPSD_MAX_SP IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL
198		193
Lines 779-784 enum iwl_mvm_queue_status { Link Here
779		774
780	#define IWL_MVM_NUM_CIPHERS 10	775	#define IWL_MVM_NUM_CIPHERS 10
781		776
		777	struct iwl_mvm_sar_profile {
		778	bool enabled;
		779	u8 table[ACPI_SAR_TABLE_SIZE];
		780	};
		781
		782	struct iwl_mvm_geo_profile {
		783	u8 values[ACPI_GEO_TABLE_SIZE];
		784	};
782		785
783	struct iwl_mvm_txq {	786	struct iwl_mvm_txq {
784	struct list_head list;	787	struct list_head list;
Lines 1141-1146 struct iwl_mvm { Link Here
1141	/* sniffer data to include in radiotap */	1144	/* sniffer data to include in radiotap */
1142	__le16 cur_aid;	1145	__le16 cur_aid;
1143	u8 cur_bssid[ETH_ALEN];	1146	u8 cur_bssid[ETH_ALEN];
		1147
		1148	#ifdef CONFIG_ACPI
		1149	struct iwl_mvm_sar_profile sar_profiles[ACPI_SAR_PROFILE_NUM];
		1150	struct iwl_mvm_geo_profile geo_profiles[ACPI_NUM_GEO_PROFILES];
		1151	u32 geo_rev;
		1152	struct iwl_ppag_table_cmd ppag_table;
		1153	u32 ppag_rev;
		1154	#endif
1144	};	1155	};
1145		1156
1146	/* Extract MVM priv from op_mode and _hw */	1157	/* Extract MVM priv from op_mode and _hw */
1147	-

Lines 61-67 Link Here

(-)a/drivers/net/wireless/intel/iwlwifi/fw/acpi.c (-287 lines)
61	#include "iwl-drv.h"	61	#include "iwl-drv.h"
62	#include "iwl-debug.h"	62	#include "iwl-debug.h"
63	#include "acpi.h"	63	#include "acpi.h"
64	#include "fw/runtime.h"
65		64
66	void iwl_acpi_get_object(struct device dev, acpi_string method)	65	void iwl_acpi_get_object(struct device dev, acpi_string method)
67	{	66	{
Lines 246-534 int iwl_acpi_get_eckv(struct device dev, u32 extl_clk) Link Here
246	return ret;	245	return ret;
247	}	246	}
248	IWL_EXPORT_SYMBOL(iwl_acpi_get_eckv);	247	IWL_EXPORT_SYMBOL(iwl_acpi_get_eckv);
249
250	int iwl_sar_set_profile(union acpi_object *table,
251	struct iwl_sar_profile *profile,
252	bool enabled)
253	{
254	int i;
255
256	profile->enabled = enabled;
257
258	for (i = 0; i < ACPI_SAR_TABLE_SIZE; i++) {
259	if (table[i].type != ACPI_TYPE_INTEGER \|\|
260	table[i].integer.value > U8_MAX)
261	return -EINVAL;
262
263	profile->table[i] = table[i].integer.value;
264	}
265
266	return 0;
267	}
268	IWL_EXPORT_SYMBOL(iwl_sar_set_profile);
269
270	int iwl_sar_select_profile(struct iwl_fw_runtime *fwrt,
271	__le16 per_chain_restriction[][IWL_NUM_SUB_BANDS],
272	int prof_a, int prof_b)
273	{
274	int i, j, idx;
275	int profs[ACPI_SAR_NUM_CHAIN_LIMITS] = { prof_a, prof_b };
276
277	BUILD_BUG_ON(ACPI_SAR_NUM_CHAIN_LIMITS < 2);
278	BUILD_BUG_ON(ACPI_SAR_NUM_CHAIN_LIMITS * ACPI_SAR_NUM_SUB_BANDS !=
279	ACPI_SAR_TABLE_SIZE);
280
281	for (i = 0; i < ACPI_SAR_NUM_CHAIN_LIMITS; i++) {
282	struct iwl_sar_profile *prof;
283
284	/* don't allow SAR to be disabled (profile 0 means disable) */
285	if (profs[i] == 0)
286	return -EPERM;
287
288	/* we are off by one, so allow up to ACPI_SAR_PROFILE_NUM */
289	if (profs[i] > ACPI_SAR_PROFILE_NUM)
290	return -EINVAL;
291
292	/* profiles go from 1 to 4, so decrement to access the array */
293	prof = &fwrt->sar_profiles[profs[i] - 1];
294
295	/* if the profile is disabled, do nothing */
296	if (!prof->enabled) {
297	IWL_DEBUG_RADIO(fwrt, "SAR profile %d is disabled.\n",
298	profs[i]);
299	/* if one of the profiles is disabled, we fail all */
300	return -ENOENT;
301	}
302	IWL_DEBUG_INFO(fwrt,
303	"SAR EWRD: chain %d profile index %d\n",
304	i, profs[i]);
305	IWL_DEBUG_RADIO(fwrt, " Chain[%d]:\n", i);
306	for (j = 0; j < ACPI_SAR_NUM_SUB_BANDS; j++) {
307	idx = (i * ACPI_SAR_NUM_SUB_BANDS) + j;
308	per_chain_restriction[i][j] =
309	cpu_to_le16(prof->table[idx]);
310	IWL_DEBUG_RADIO(fwrt, " Band[%d] = %d * .125dBm\n",
311	j, prof->table[idx]);
312	}
313	}
314
315	return 0;
316	}
317	IWL_EXPORT_SYMBOL(iwl_sar_select_profile);
318
319	int iwl_sar_get_wrds_table(struct iwl_fw_runtime *fwrt)
320	{
321	union acpi_object wifi_pkg, table, *data;
322	bool enabled;
323	int ret, tbl_rev;
324
325	data = iwl_acpi_get_object(fwrt->dev, ACPI_WRDS_METHOD);
326	if (IS_ERR(data))
327	return PTR_ERR(data);
328
329	wifi_pkg = iwl_acpi_get_wifi_pkg(fwrt->dev, data,
330	ACPI_WRDS_WIFI_DATA_SIZE, &tbl_rev);
331	if (IS_ERR(wifi_pkg) \|\| tbl_rev != 0) {
332	ret = PTR_ERR(wifi_pkg);
333	goto out_free;
334	}
335
336	if (wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER) {
337	ret = -EINVAL;
338	goto out_free;
339	}
340
341	enabled = !!(wifi_pkg->package.elements[1].integer.value);
342
343	/* position of the actual table */
344	table = &wifi_pkg->package.elements[2];
345
346	/* The profile from WRDS is officially profile 1, but goes
347	* into sar_profiles[0] (because we don't have a profile 0).
348	*/
349	ret = iwl_sar_set_profile(table, &fwrt->sar_profiles[0], enabled);
350	out_free:
351	kfree(data);
352	return ret;
353	}
354	IWL_EXPORT_SYMBOL(iwl_sar_get_wrds_table);
355
356	int iwl_sar_get_ewrd_table(struct iwl_fw_runtime *fwrt)
357	{
358	union acpi_object wifi_pkg, data;
359	bool enabled;
360	int i, n_profiles, tbl_rev, pos;
361	int ret = 0;
362
363	data = iwl_acpi_get_object(fwrt->dev, ACPI_EWRD_METHOD);
364	if (IS_ERR(data))
365	return PTR_ERR(data);
366
367	wifi_pkg = iwl_acpi_get_wifi_pkg(fwrt->dev, data,
368	ACPI_EWRD_WIFI_DATA_SIZE, &tbl_rev);
369	if (IS_ERR(wifi_pkg) \|\| tbl_rev != 0) {
370	ret = PTR_ERR(wifi_pkg);
371	goto out_free;
372	}
373
374	if (wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER \|\|
375	wifi_pkg->package.elements[2].type != ACPI_TYPE_INTEGER) {
376	ret = -EINVAL;
377	goto out_free;
378	}
379
380	enabled = !!(wifi_pkg->package.elements[1].integer.value);
381	n_profiles = wifi_pkg->package.elements[2].integer.value;
382
383	/*
384	* Check the validity of n_profiles. The EWRD profiles start
385	* from index 1, so the maximum value allowed here is
386	* ACPI_SAR_PROFILES_NUM - 1.
387	*/
388	if (n_profiles <= 0 \|\| n_profiles >= ACPI_SAR_PROFILE_NUM) {
389	ret = -EINVAL;
390	goto out_free;
391	}
392
393	/* the tables start at element 3 */
394	pos = 3;
395
396	for (i = 0; i < n_profiles; i++) {
397	/* The EWRD profiles officially go from 2 to 4, but we
398	* save them in sar_profiles[1-3] (because we don't
399	* have profile 0). So in the array we start from 1.
400	*/
401	ret = iwl_sar_set_profile(&wifi_pkg->package.elements[pos],
402	&fwrt->sar_profiles[i + 1],
403	enabled);
404	if (ret < 0)
405	break;
406
407	/* go to the next table */
408	pos += ACPI_SAR_TABLE_SIZE;
409	}
410
411	out_free:
412	kfree(data);
413	return ret;
414	}
415	IWL_EXPORT_SYMBOL(iwl_sar_get_ewrd_table);
416
417	int iwl_sar_get_wgds_table(struct iwl_fw_runtime *fwrt)
418	{
419	union acpi_object wifi_pkg, data;
420	int i, j, ret, tbl_rev;
421	int idx = 1;
422
423	data = iwl_acpi_get_object(fwrt->dev, ACPI_WGDS_METHOD);
424	if (IS_ERR(data))
425	return PTR_ERR(data);
426
427	wifi_pkg = iwl_acpi_get_wifi_pkg(fwrt->dev, data,
428	ACPI_WGDS_WIFI_DATA_SIZE, &tbl_rev);
429	if (IS_ERR(wifi_pkg) \|\| tbl_rev > 1) {
430	ret = PTR_ERR(wifi_pkg);
431	goto out_free;
432	}
433
434	fwrt->geo_rev = tbl_rev;
435	for (i = 0; i < ACPI_NUM_GEO_PROFILES; i++) {
436	for (j = 0; j < ACPI_GEO_TABLE_SIZE; j++) {
437	union acpi_object *entry;
438
439	entry = &wifi_pkg->package.elements[idx++];
440	if (entry->type != ACPI_TYPE_INTEGER \|\|
441	entry->integer.value > U8_MAX) {
442	ret = -EINVAL;
443	goto out_free;
444	}
445
446	fwrt->geo_profiles[i].values[j] = entry->integer.value;
447	}
448	}
449	ret = 0;
450	out_free:
451	kfree(data);
452	return ret;
453	}
454	IWL_EXPORT_SYMBOL(iwl_sar_get_wgds_table);
455
456	bool iwl_sar_geo_support(struct iwl_fw_runtime *fwrt)
457	{
458	/*
459	* The GEO_TX_POWER_LIMIT command is not supported on earlier
460	* firmware versions. Unfortunately, we don't have a TLV API
461	* flag to rely on, so rely on the major version which is in
462	* the first byte of ucode_ver. This was implemented
463	* initially on version 38 and then backported to 17. It was
464	* also backported to 29, but only for 7265D devices. The
465	* intention was to have it in 36 as well, but not all 8000
466	* family got this feature enabled. The 8000 family is the
467	* only one using version 36, so skip this version entirely.
468	*/
469	return IWL_UCODE_SERIAL(fwrt->fw->ucode_ver) >= 38 \|\|
470	IWL_UCODE_SERIAL(fwrt->fw->ucode_ver) == 17 \|\|
471	(IWL_UCODE_SERIAL(fwrt->fw->ucode_ver) == 29 &&
472	((fwrt->trans->hw_rev & CSR_HW_REV_TYPE_MSK) ==
473	CSR_HW_REV_TYPE_7265D));
474	}
475	IWL_EXPORT_SYMBOL(iwl_sar_geo_support);
476
477	int iwl_validate_sar_geo_profile(struct iwl_fw_runtime *fwrt,
478	struct iwl_host_cmd *cmd)
479	{
480	struct iwl_geo_tx_power_profiles_resp *resp;
481	int ret;
482
483	resp = (void *)cmd->resp_pkt->data;
484	ret = le32_to_cpu(resp->profile_idx);
485	if (WARN_ON(ret > ACPI_NUM_GEO_PROFILES)) {
486	ret = -EIO;
487	IWL_WARN(fwrt, "Invalid geographic profile idx (%d)\n", ret);
488	}
489
490	return ret;
491	}
492	IWL_EXPORT_SYMBOL(iwl_validate_sar_geo_profile);
493
494	void iwl_sar_geo_init(struct iwl_fw_runtime *fwrt,
495	struct iwl_per_chain_offset_group *table)
496	{
497	int ret, i, j;
498
499	if (!iwl_sar_geo_support(fwrt))
500	return;
501
502	ret = iwl_sar_get_wgds_table(fwrt);
503	if (ret < 0) {
504	IWL_DEBUG_RADIO(fwrt,
505	"Geo SAR BIOS table invalid or unavailable. (%d)\n",
506	ret);
507	/* we don't fail if the table is not available */
508	return;
509	}
510
511	BUILD_BUG_ON(ACPI_NUM_GEO_PROFILES * ACPI_WGDS_NUM_BANDS *
512	ACPI_WGDS_TABLE_SIZE + 1 != ACPI_WGDS_WIFI_DATA_SIZE);
513
514	BUILD_BUG_ON(ACPI_NUM_GEO_PROFILES > IWL_NUM_GEO_PROFILES);
515
516	for (i = 0; i < ACPI_NUM_GEO_PROFILES; i++) {
517	struct iwl_per_chain_offset *chain =
518	(struct iwl_per_chain_offset *)&table[i];
519
520	for (j = 0; j < ACPI_WGDS_NUM_BANDS; j++) {
521	u8 *value;
522
523	value = &fwrt->geo_profiles[i].values[j *
524	ACPI_GEO_PER_CHAIN_SIZE];
525	chain[j].max_tx_power = cpu_to_le16(value[0]);
526	chain[j].chain_a = value[1];
527	chain[j].chain_b = value[2];
528	IWL_DEBUG_RADIO(fwrt,
529	"SAR geographic profile[%d] Band[%d]: chain A = %d chain B = %d max_tx_power = %d\n",
530	i, j, value[1], value[2], value[0]);
531	}
532	}
533	}
534	IWL_EXPORT_SYMBOL(iwl_sar_geo_init);

Lines 65-73 Link Here

(-)a/drivers/net/wireless/intel/iwlwifi/fw/runtime.h (-11 lines)
65	#include "img.h"	65	#include "img.h"
66	#include "fw/api/debug.h"	66	#include "fw/api/debug.h"
67	#include "fw/api/paging.h"	67	#include "fw/api/paging.h"
68	#include "fw/api/power.h"
69	#include "iwl-eeprom-parse.h"	68	#include "iwl-eeprom-parse.h"
70	#include "fw/acpi.h"
71		69
72	#define IWL_FW_DBG_DOMAIN IWL_FW_INI_DOMAIN_ALWAYS_ON	70	#define IWL_FW_DBG_DOMAIN IWL_FW_INI_DOMAIN_ALWAYS_ON
73		71
Lines 205-220 struct iwl_fw_runtime { Link Here
205	u32 delay;	203	u32 delay;
206	u64 seq;	204	u64 seq;
207	} timestamp;	205	} timestamp;
208	bool tpc_enabled;
209	#endif /* CONFIG_IWLWIFI_DEBUGFS */	206	#endif /* CONFIG_IWLWIFI_DEBUGFS */
210	#ifdef CONFIG_ACPI
211	struct iwl_sar_profile sar_profiles[ACPI_SAR_PROFILE_NUM];
212	u8 sar_chain_a_profile;
213	u8 sar_chain_b_profile;
214	struct iwl_geo_profile geo_profiles[ACPI_NUM_GEO_PROFILES];
215	u32 geo_rev;
216	struct iwl_ppag_table_cmd ppag_table;
217	#endif
218	};	207	};
219		208
220	void iwl_fw_runtime_init(struct iwl_fw_runtime fwrt, struct iwl_trans trans,	209	void iwl_fw_runtime_init(struct iwl_fw_runtime fwrt, struct iwl_trans trans,