cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

acpi.c (30874B)


      1// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
      2/*
      3 * Copyright (C) 2017 Intel Deutschland GmbH
      4 * Copyright (C) 2019-2022 Intel Corporation
      5 */
      6#include <linux/uuid.h>
      7#include <linux/dmi.h>
      8#include "iwl-drv.h"
      9#include "iwl-debug.h"
     10#include "acpi.h"
     11#include "fw/runtime.h"
     12
     13const guid_t iwl_guid = GUID_INIT(0xF21202BF, 0x8F78, 0x4DC6,
     14				  0xA5, 0xB3, 0x1F, 0x73,
     15				  0x8E, 0x28, 0x5A, 0xDE);
     16IWL_EXPORT_SYMBOL(iwl_guid);
     17
     18const guid_t iwl_rfi_guid = GUID_INIT(0x7266172C, 0x220B, 0x4B29,
     19				      0x81, 0x4F, 0x75, 0xE4,
     20				      0xDD, 0x26, 0xB5, 0xFD);
     21IWL_EXPORT_SYMBOL(iwl_rfi_guid);
     22
     23static const struct dmi_system_id dmi_ppag_approved_list[] = {
     24	{ .ident = "HP",
     25	  .matches = {
     26			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
     27		},
     28	},
     29	{ .ident = "SAMSUNG",
     30	  .matches = {
     31			DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD"),
     32		},
     33	},
     34	{ .ident = "MSFT",
     35	  .matches = {
     36			DMI_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"),
     37		},
     38	},
     39	{ .ident = "ASUS",
     40	  .matches = {
     41			DMI_MATCH(DMI_SYS_VENDOR, "ASUSTek COMPUTER INC."),
     42		},
     43	},
     44	{}
     45};
     46
     47static int iwl_acpi_get_handle(struct device *dev, acpi_string method,
     48			       acpi_handle *ret_handle)
     49{
     50	acpi_handle root_handle;
     51	acpi_status status;
     52
     53	root_handle = ACPI_HANDLE(dev);
     54	if (!root_handle) {
     55		IWL_DEBUG_DEV_RADIO(dev,
     56				    "ACPI: Could not retrieve root port handle\n");
     57		return -ENOENT;
     58	}
     59
     60	status = acpi_get_handle(root_handle, method, ret_handle);
     61	if (ACPI_FAILURE(status)) {
     62		IWL_DEBUG_DEV_RADIO(dev,
     63				    "ACPI: %s method not found\n", method);
     64		return -ENOENT;
     65	}
     66	return 0;
     67}
     68
     69void *iwl_acpi_get_object(struct device *dev, acpi_string method)
     70{
     71	struct acpi_buffer buf = {ACPI_ALLOCATE_BUFFER, NULL};
     72	acpi_handle handle;
     73	acpi_status status;
     74	int ret;
     75
     76	ret = iwl_acpi_get_handle(dev, method, &handle);
     77	if (ret)
     78		return ERR_PTR(-ENOENT);
     79
     80	/* Call the method with no arguments */
     81	status = acpi_evaluate_object(handle, NULL, NULL, &buf);
     82	if (ACPI_FAILURE(status)) {
     83		IWL_DEBUG_DEV_RADIO(dev,
     84				    "ACPI: %s method invocation failed (status: 0x%x)\n",
     85				    method, status);
     86		return ERR_PTR(-ENOENT);
     87	}
     88	return buf.pointer;
     89}
     90IWL_EXPORT_SYMBOL(iwl_acpi_get_object);
     91
     92/*
     93 * Generic function for evaluating a method defined in the device specific
     94 * method (DSM) interface. The returned acpi object must be freed by calling
     95 * function.
     96 */
     97static void *iwl_acpi_get_dsm_object(struct device *dev, int rev, int func,
     98				     union acpi_object *args,
     99				     const guid_t *guid)
    100{
    101	union acpi_object *obj;
    102
    103	obj = acpi_evaluate_dsm(ACPI_HANDLE(dev), guid, rev, func,
    104				args);
    105	if (!obj) {
    106		IWL_DEBUG_DEV_RADIO(dev,
    107				    "ACPI: DSM method invocation failed (rev: %d, func:%d)\n",
    108				    rev, func);
    109		return ERR_PTR(-ENOENT);
    110	}
    111	return obj;
    112}
    113
    114/*
    115 * Generic function to evaluate a DSM with no arguments
    116 * and an integer return value,
    117 * (as an integer object or inside a buffer object),
    118 * verify and assign the value in the "value" parameter.
    119 * return 0 in success and the appropriate errno otherwise.
    120 */
    121static int iwl_acpi_get_dsm_integer(struct device *dev, int rev, int func,
    122				    const guid_t *guid, u64 *value,
    123				    size_t expected_size)
    124{
    125	union acpi_object *obj;
    126	int ret = 0;
    127
    128	obj = iwl_acpi_get_dsm_object(dev, rev, func, NULL, guid);
    129	if (IS_ERR(obj)) {
    130		IWL_DEBUG_DEV_RADIO(dev,
    131				    "Failed to get  DSM object. func= %d\n",
    132				    func);
    133		return -ENOENT;
    134	}
    135
    136	if (obj->type == ACPI_TYPE_INTEGER) {
    137		*value = obj->integer.value;
    138	} else if (obj->type == ACPI_TYPE_BUFFER) {
    139		__le64 le_value = 0;
    140
    141		if (WARN_ON_ONCE(expected_size > sizeof(le_value)))
    142			return -EINVAL;
    143
    144		/* if the buffer size doesn't match the expected size */
    145		if (obj->buffer.length != expected_size)
    146			IWL_DEBUG_DEV_RADIO(dev,
    147					    "ACPI: DSM invalid buffer size, padding or truncating (%d)\n",
    148					    obj->buffer.length);
    149
    150		 /* assuming LE from Intel BIOS spec */
    151		memcpy(&le_value, obj->buffer.pointer,
    152		       min_t(size_t, expected_size, (size_t)obj->buffer.length));
    153		*value = le64_to_cpu(le_value);
    154	} else {
    155		IWL_DEBUG_DEV_RADIO(dev,
    156				    "ACPI: DSM method did not return a valid object, type=%d\n",
    157				    obj->type);
    158		ret = -EINVAL;
    159		goto out;
    160	}
    161
    162	IWL_DEBUG_DEV_RADIO(dev,
    163			    "ACPI: DSM method evaluated: func=%d, ret=%d\n",
    164			    func, ret);
    165out:
    166	ACPI_FREE(obj);
    167	return ret;
    168}
    169
    170/*
    171 * Evaluate a DSM with no arguments and a u8 return value,
    172 */
    173int iwl_acpi_get_dsm_u8(struct device *dev, int rev, int func,
    174			const guid_t *guid, u8 *value)
    175{
    176	int ret;
    177	u64 val;
    178
    179	ret = iwl_acpi_get_dsm_integer(dev, rev, func,
    180				       guid, &val, sizeof(u8));
    181
    182	if (ret < 0)
    183		return ret;
    184
    185	/* cast val (u64) to be u8 */
    186	*value = (u8)val;
    187	return 0;
    188}
    189IWL_EXPORT_SYMBOL(iwl_acpi_get_dsm_u8);
    190
    191/*
    192 * Evaluate a DSM with no arguments and a u32 return value,
    193 */
    194int iwl_acpi_get_dsm_u32(struct device *dev, int rev, int func,
    195			 const guid_t *guid, u32 *value)
    196{
    197	int ret;
    198	u64 val;
    199
    200	ret = iwl_acpi_get_dsm_integer(dev, rev, func,
    201				       guid, &val, sizeof(u32));
    202
    203	if (ret < 0)
    204		return ret;
    205
    206	/* cast val (u64) to be u32 */
    207	*value = (u32)val;
    208	return 0;
    209}
    210IWL_EXPORT_SYMBOL(iwl_acpi_get_dsm_u32);
    211
    212union acpi_object *iwl_acpi_get_wifi_pkg_range(struct device *dev,
    213					       union acpi_object *data,
    214					       int min_data_size,
    215					       int max_data_size,
    216					       int *tbl_rev)
    217{
    218	int i;
    219	union acpi_object *wifi_pkg;
    220
    221	/*
    222	 * We need at least one entry in the wifi package that
    223	 * describes the domain, and one more entry, otherwise there's
    224	 * no point in reading it.
    225	 */
    226	if (WARN_ON_ONCE(min_data_size < 2 || min_data_size > max_data_size))
    227		return ERR_PTR(-EINVAL);
    228
    229	/*
    230	 * We need at least two packages, one for the revision and one
    231	 * for the data itself.  Also check that the revision is valid
    232	 * (i.e. it is an integer (each caller has to check by itself
    233	 * if the returned revision is supported)).
    234	 */
    235	if (data->type != ACPI_TYPE_PACKAGE ||
    236	    data->package.count < 2 ||
    237	    data->package.elements[0].type != ACPI_TYPE_INTEGER) {
    238		IWL_DEBUG_DEV_RADIO(dev, "Invalid packages structure\n");
    239		return ERR_PTR(-EINVAL);
    240	}
    241
    242	*tbl_rev = data->package.elements[0].integer.value;
    243
    244	/* loop through all the packages to find the one for WiFi */
    245	for (i = 1; i < data->package.count; i++) {
    246		union acpi_object *domain;
    247
    248		wifi_pkg = &data->package.elements[i];
    249
    250		/* skip entries that are not a package with the right size */
    251		if (wifi_pkg->type != ACPI_TYPE_PACKAGE ||
    252		    wifi_pkg->package.count < min_data_size ||
    253		    wifi_pkg->package.count > max_data_size)
    254			continue;
    255
    256		domain = &wifi_pkg->package.elements[0];
    257		if (domain->type == ACPI_TYPE_INTEGER &&
    258		    domain->integer.value == ACPI_WIFI_DOMAIN)
    259			goto found;
    260	}
    261
    262	return ERR_PTR(-ENOENT);
    263
    264found:
    265	return wifi_pkg;
    266}
    267IWL_EXPORT_SYMBOL(iwl_acpi_get_wifi_pkg_range);
    268
    269int iwl_acpi_get_tas(struct iwl_fw_runtime *fwrt,
    270		     union iwl_tas_config_cmd *cmd, int fw_ver)
    271{
    272	union acpi_object *wifi_pkg, *data;
    273	int ret, tbl_rev, i, block_list_size, enabled;
    274
    275	data = iwl_acpi_get_object(fwrt->dev, ACPI_WTAS_METHOD);
    276	if (IS_ERR(data))
    277		return PTR_ERR(data);
    278
    279	/* try to read wtas table revision 1 or revision 0*/
    280	wifi_pkg = iwl_acpi_get_wifi_pkg(fwrt->dev, data,
    281					 ACPI_WTAS_WIFI_DATA_SIZE,
    282					 &tbl_rev);
    283	if (IS_ERR(wifi_pkg)) {
    284		ret = PTR_ERR(wifi_pkg);
    285		goto out_free;
    286	}
    287
    288	if (tbl_rev == 1 && wifi_pkg->package.elements[1].type ==
    289		ACPI_TYPE_INTEGER) {
    290		u32 tas_selection =
    291			(u32)wifi_pkg->package.elements[1].integer.value;
    292		u16 override_iec =
    293			(tas_selection & ACPI_WTAS_OVERRIDE_IEC_MSK) >> ACPI_WTAS_OVERRIDE_IEC_POS;
    294		u16 enabled_iec = (tas_selection & ACPI_WTAS_ENABLE_IEC_MSK) >>
    295			ACPI_WTAS_ENABLE_IEC_POS;
    296		u8 usa_tas_uhb = (tas_selection & ACPI_WTAS_USA_UHB_MSK) >> ACPI_WTAS_USA_UHB_POS;
    297
    298
    299		enabled = tas_selection & ACPI_WTAS_ENABLED_MSK;
    300		if (fw_ver <= 3) {
    301			cmd->v3.override_tas_iec = cpu_to_le16(override_iec);
    302			cmd->v3.enable_tas_iec = cpu_to_le16(enabled_iec);
    303		} else {
    304			cmd->v4.usa_tas_uhb_allowed = usa_tas_uhb;
    305			cmd->v4.override_tas_iec = (u8)override_iec;
    306			cmd->v4.enable_tas_iec = (u8)enabled_iec;
    307		}
    308
    309	} else if (tbl_rev == 0 &&
    310		wifi_pkg->package.elements[1].type == ACPI_TYPE_INTEGER) {
    311		enabled = !!wifi_pkg->package.elements[1].integer.value;
    312	} else {
    313		ret = -EINVAL;
    314		goto out_free;
    315	}
    316
    317	if (!enabled) {
    318		IWL_DEBUG_RADIO(fwrt, "TAS not enabled\n");
    319		ret = 0;
    320		goto out_free;
    321	}
    322
    323	IWL_DEBUG_RADIO(fwrt, "Reading TAS table revision %d\n", tbl_rev);
    324	if (wifi_pkg->package.elements[2].type != ACPI_TYPE_INTEGER ||
    325	    wifi_pkg->package.elements[2].integer.value >
    326	    APCI_WTAS_BLACK_LIST_MAX) {
    327		IWL_DEBUG_RADIO(fwrt, "TAS invalid array size %llu\n",
    328				wifi_pkg->package.elements[2].integer.value);
    329		ret = -EINVAL;
    330		goto out_free;
    331	}
    332	block_list_size = wifi_pkg->package.elements[2].integer.value;
    333	cmd->v4.block_list_size = cpu_to_le32(block_list_size);
    334
    335	IWL_DEBUG_RADIO(fwrt, "TAS array size %u\n", block_list_size);
    336	if (block_list_size > APCI_WTAS_BLACK_LIST_MAX) {
    337		IWL_DEBUG_RADIO(fwrt, "TAS invalid array size value %u\n",
    338				block_list_size);
    339		ret = -EINVAL;
    340		goto out_free;
    341	}
    342
    343	for (i = 0; i < block_list_size; i++) {
    344		u32 country;
    345
    346		if (wifi_pkg->package.elements[3 + i].type !=
    347		    ACPI_TYPE_INTEGER) {
    348			IWL_DEBUG_RADIO(fwrt,
    349					"TAS invalid array elem %d\n", 3 + i);
    350			ret = -EINVAL;
    351			goto out_free;
    352		}
    353
    354		country = wifi_pkg->package.elements[3 + i].integer.value;
    355		cmd->v4.block_list_array[i] = cpu_to_le32(country);
    356		IWL_DEBUG_RADIO(fwrt, "TAS block list country %d\n", country);
    357	}
    358
    359	ret = 1;
    360out_free:
    361	kfree(data);
    362	return ret;
    363}
    364IWL_EXPORT_SYMBOL(iwl_acpi_get_tas);
    365
    366int iwl_acpi_get_mcc(struct device *dev, char *mcc)
    367{
    368	union acpi_object *wifi_pkg, *data;
    369	u32 mcc_val;
    370	int ret, tbl_rev;
    371
    372	data = iwl_acpi_get_object(dev, ACPI_WRDD_METHOD);
    373	if (IS_ERR(data))
    374		return PTR_ERR(data);
    375
    376	wifi_pkg = iwl_acpi_get_wifi_pkg(dev, data, ACPI_WRDD_WIFI_DATA_SIZE,
    377					 &tbl_rev);
    378	if (IS_ERR(wifi_pkg)) {
    379		ret = PTR_ERR(wifi_pkg);
    380		goto out_free;
    381	}
    382
    383	if (wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER ||
    384	    tbl_rev != 0) {
    385		ret = -EINVAL;
    386		goto out_free;
    387	}
    388
    389	mcc_val = wifi_pkg->package.elements[1].integer.value;
    390
    391	mcc[0] = (mcc_val >> 8) & 0xff;
    392	mcc[1] = mcc_val & 0xff;
    393	mcc[2] = '\0';
    394
    395	ret = 0;
    396out_free:
    397	kfree(data);
    398	return ret;
    399}
    400IWL_EXPORT_SYMBOL(iwl_acpi_get_mcc);
    401
    402u64 iwl_acpi_get_pwr_limit(struct device *dev)
    403{
    404	union acpi_object *data, *wifi_pkg;
    405	u64 dflt_pwr_limit;
    406	int tbl_rev;
    407
    408	data = iwl_acpi_get_object(dev, ACPI_SPLC_METHOD);
    409	if (IS_ERR(data)) {
    410		dflt_pwr_limit = 0;
    411		goto out;
    412	}
    413
    414	wifi_pkg = iwl_acpi_get_wifi_pkg(dev, data,
    415					 ACPI_SPLC_WIFI_DATA_SIZE, &tbl_rev);
    416	if (IS_ERR(wifi_pkg) || tbl_rev != 0 ||
    417	    wifi_pkg->package.elements[1].integer.value != ACPI_TYPE_INTEGER) {
    418		dflt_pwr_limit = 0;
    419		goto out_free;
    420	}
    421
    422	dflt_pwr_limit = wifi_pkg->package.elements[1].integer.value;
    423out_free:
    424	kfree(data);
    425out:
    426	return dflt_pwr_limit;
    427}
    428IWL_EXPORT_SYMBOL(iwl_acpi_get_pwr_limit);
    429
    430int iwl_acpi_get_eckv(struct device *dev, u32 *extl_clk)
    431{
    432	union acpi_object *wifi_pkg, *data;
    433	int ret, tbl_rev;
    434
    435	data = iwl_acpi_get_object(dev, ACPI_ECKV_METHOD);
    436	if (IS_ERR(data))
    437		return PTR_ERR(data);
    438
    439	wifi_pkg = iwl_acpi_get_wifi_pkg(dev, data, ACPI_ECKV_WIFI_DATA_SIZE,
    440					 &tbl_rev);
    441	if (IS_ERR(wifi_pkg)) {
    442		ret = PTR_ERR(wifi_pkg);
    443		goto out_free;
    444	}
    445
    446	if (wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER ||
    447	    tbl_rev != 0) {
    448		ret = -EINVAL;
    449		goto out_free;
    450	}
    451
    452	*extl_clk = wifi_pkg->package.elements[1].integer.value;
    453
    454	ret = 0;
    455
    456out_free:
    457	kfree(data);
    458	return ret;
    459}
    460IWL_EXPORT_SYMBOL(iwl_acpi_get_eckv);
    461
    462static int iwl_sar_set_profile(union acpi_object *table,
    463			       struct iwl_sar_profile *profile,
    464			       bool enabled, u8 num_chains, u8 num_sub_bands)
    465{
    466	int i, j, idx = 0;
    467
    468	/*
    469	 * The table from ACPI is flat, but we store it in a
    470	 * structured array.
    471	 */
    472	for (i = 0; i < ACPI_SAR_NUM_CHAINS_REV2; i++) {
    473		for (j = 0; j < ACPI_SAR_NUM_SUB_BANDS_REV2; j++) {
    474			/* if we don't have the values, use the default */
    475			if (i >= num_chains || j >= num_sub_bands) {
    476				profile->chains[i].subbands[j] = 0;
    477			} else {
    478				if (table[idx].type != ACPI_TYPE_INTEGER ||
    479				    table[idx].integer.value > U8_MAX)
    480					return -EINVAL;
    481
    482				profile->chains[i].subbands[j] =
    483					table[idx].integer.value;
    484
    485				idx++;
    486			}
    487		}
    488	}
    489
    490	/* Only if all values were valid can the profile be enabled */
    491	profile->enabled = enabled;
    492
    493	return 0;
    494}
    495
    496static int iwl_sar_fill_table(struct iwl_fw_runtime *fwrt,
    497			      __le16 *per_chain, u32 n_subbands,
    498			      int prof_a, int prof_b)
    499{
    500	int profs[ACPI_SAR_NUM_CHAINS_REV0] = { prof_a, prof_b };
    501	int i, j;
    502
    503	for (i = 0; i < ACPI_SAR_NUM_CHAINS_REV0; i++) {
    504		struct iwl_sar_profile *prof;
    505
    506		/* don't allow SAR to be disabled (profile 0 means disable) */
    507		if (profs[i] == 0)
    508			return -EPERM;
    509
    510		/* we are off by one, so allow up to ACPI_SAR_PROFILE_NUM */
    511		if (profs[i] > ACPI_SAR_PROFILE_NUM)
    512			return -EINVAL;
    513
    514		/* profiles go from 1 to 4, so decrement to access the array */
    515		prof = &fwrt->sar_profiles[profs[i] - 1];
    516
    517		/* if the profile is disabled, do nothing */
    518		if (!prof->enabled) {
    519			IWL_DEBUG_RADIO(fwrt, "SAR profile %d is disabled.\n",
    520					profs[i]);
    521			/*
    522			 * if one of the profiles is disabled, we
    523			 * ignore all of them and return 1 to
    524			 * differentiate disabled from other failures.
    525			 */
    526			return 1;
    527		}
    528
    529		IWL_DEBUG_INFO(fwrt,
    530			       "SAR EWRD: chain %d profile index %d\n",
    531			       i, profs[i]);
    532		IWL_DEBUG_RADIO(fwrt, "  Chain[%d]:\n", i);
    533		for (j = 0; j < n_subbands; j++) {
    534			per_chain[i * n_subbands + j] =
    535				cpu_to_le16(prof->chains[i].subbands[j]);
    536			IWL_DEBUG_RADIO(fwrt, "    Band[%d] = %d * .125dBm\n",
    537					j, prof->chains[i].subbands[j]);
    538		}
    539	}
    540
    541	return 0;
    542}
    543
    544int iwl_sar_select_profile(struct iwl_fw_runtime *fwrt,
    545			   __le16 *per_chain, u32 n_tables, u32 n_subbands,
    546			   int prof_a, int prof_b)
    547{
    548	int i, ret = 0;
    549
    550	for (i = 0; i < n_tables; i++) {
    551		ret = iwl_sar_fill_table(fwrt,
    552			 &per_chain[i * n_subbands * ACPI_SAR_NUM_CHAINS_REV0],
    553			 n_subbands, prof_a, prof_b);
    554		if (ret)
    555			break;
    556	}
    557
    558	return ret;
    559}
    560IWL_EXPORT_SYMBOL(iwl_sar_select_profile);
    561
    562int iwl_sar_get_wrds_table(struct iwl_fw_runtime *fwrt)
    563{
    564	union acpi_object *wifi_pkg, *table, *data;
    565	int ret, tbl_rev;
    566	u32 flags;
    567	u8 num_chains, num_sub_bands;
    568
    569	data = iwl_acpi_get_object(fwrt->dev, ACPI_WRDS_METHOD);
    570	if (IS_ERR(data))
    571		return PTR_ERR(data);
    572
    573	/* start by trying to read revision 2 */
    574	wifi_pkg = iwl_acpi_get_wifi_pkg(fwrt->dev, data,
    575					 ACPI_WRDS_WIFI_DATA_SIZE_REV2,
    576					 &tbl_rev);
    577	if (!IS_ERR(wifi_pkg)) {
    578		if (tbl_rev != 2) {
    579			ret = PTR_ERR(wifi_pkg);
    580			goto out_free;
    581		}
    582
    583		num_chains = ACPI_SAR_NUM_CHAINS_REV2;
    584		num_sub_bands = ACPI_SAR_NUM_SUB_BANDS_REV2;
    585
    586		goto read_table;
    587	}
    588
    589	/* then try revision 1 */
    590	wifi_pkg = iwl_acpi_get_wifi_pkg(fwrt->dev, data,
    591					 ACPI_WRDS_WIFI_DATA_SIZE_REV1,
    592					 &tbl_rev);
    593	if (!IS_ERR(wifi_pkg)) {
    594		if (tbl_rev != 1) {
    595			ret = PTR_ERR(wifi_pkg);
    596			goto out_free;
    597		}
    598
    599		num_chains = ACPI_SAR_NUM_CHAINS_REV1;
    600		num_sub_bands = ACPI_SAR_NUM_SUB_BANDS_REV1;
    601
    602		goto read_table;
    603	}
    604
    605	/* then finally revision 0 */
    606	wifi_pkg = iwl_acpi_get_wifi_pkg(fwrt->dev, data,
    607					 ACPI_WRDS_WIFI_DATA_SIZE_REV0,
    608					 &tbl_rev);
    609	if (!IS_ERR(wifi_pkg)) {
    610		if (tbl_rev != 0) {
    611			ret = PTR_ERR(wifi_pkg);
    612			goto out_free;
    613		}
    614
    615		num_chains = ACPI_SAR_NUM_CHAINS_REV0;
    616		num_sub_bands = ACPI_SAR_NUM_SUB_BANDS_REV0;
    617
    618		goto read_table;
    619	}
    620
    621	ret = PTR_ERR(wifi_pkg);
    622	goto out_free;
    623
    624read_table:
    625	if (wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER) {
    626		ret = -EINVAL;
    627		goto out_free;
    628	}
    629
    630	IWL_DEBUG_RADIO(fwrt, "Reading WRDS tbl_rev=%d\n", tbl_rev);
    631
    632	flags = wifi_pkg->package.elements[1].integer.value;
    633	fwrt->reduced_power_flags = flags >> IWL_REDUCE_POWER_FLAGS_POS;
    634
    635	/* position of the actual table */
    636	table = &wifi_pkg->package.elements[2];
    637
    638	/* The profile from WRDS is officially profile 1, but goes
    639	 * into sar_profiles[0] (because we don't have a profile 0).
    640	 */
    641	ret = iwl_sar_set_profile(table, &fwrt->sar_profiles[0],
    642				  flags & IWL_SAR_ENABLE_MSK,
    643				  num_chains, num_sub_bands);
    644out_free:
    645	kfree(data);
    646	return ret;
    647}
    648IWL_EXPORT_SYMBOL(iwl_sar_get_wrds_table);
    649
    650int iwl_sar_get_ewrd_table(struct iwl_fw_runtime *fwrt)
    651{
    652	union acpi_object *wifi_pkg, *data;
    653	bool enabled;
    654	int i, n_profiles, tbl_rev, pos;
    655	int ret = 0;
    656	u8 num_chains, num_sub_bands;
    657
    658	data = iwl_acpi_get_object(fwrt->dev, ACPI_EWRD_METHOD);
    659	if (IS_ERR(data))
    660		return PTR_ERR(data);
    661
    662	/* start by trying to read revision 2 */
    663	wifi_pkg = iwl_acpi_get_wifi_pkg(fwrt->dev, data,
    664					 ACPI_EWRD_WIFI_DATA_SIZE_REV2,
    665					 &tbl_rev);
    666	if (!IS_ERR(wifi_pkg)) {
    667		if (tbl_rev != 2) {
    668			ret = PTR_ERR(wifi_pkg);
    669			goto out_free;
    670		}
    671
    672		num_chains = ACPI_SAR_NUM_CHAINS_REV2;
    673		num_sub_bands = ACPI_SAR_NUM_SUB_BANDS_REV2;
    674
    675		goto read_table;
    676	}
    677
    678	/* then try revision 1 */
    679	wifi_pkg = iwl_acpi_get_wifi_pkg(fwrt->dev, data,
    680					 ACPI_EWRD_WIFI_DATA_SIZE_REV1,
    681					 &tbl_rev);
    682	if (!IS_ERR(wifi_pkg)) {
    683		if (tbl_rev != 1) {
    684			ret = PTR_ERR(wifi_pkg);
    685			goto out_free;
    686		}
    687
    688		num_chains = ACPI_SAR_NUM_CHAINS_REV1;
    689		num_sub_bands = ACPI_SAR_NUM_SUB_BANDS_REV1;
    690
    691		goto read_table;
    692	}
    693
    694	/* then finally revision 0 */
    695	wifi_pkg = iwl_acpi_get_wifi_pkg(fwrt->dev, data,
    696					 ACPI_EWRD_WIFI_DATA_SIZE_REV0,
    697					 &tbl_rev);
    698	if (!IS_ERR(wifi_pkg)) {
    699		if (tbl_rev != 0) {
    700			ret = PTR_ERR(wifi_pkg);
    701			goto out_free;
    702		}
    703
    704		num_chains = ACPI_SAR_NUM_CHAINS_REV0;
    705		num_sub_bands = ACPI_SAR_NUM_SUB_BANDS_REV0;
    706
    707		goto read_table;
    708	}
    709
    710	ret = PTR_ERR(wifi_pkg);
    711	goto out_free;
    712
    713read_table:
    714	if (wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER ||
    715	    wifi_pkg->package.elements[2].type != ACPI_TYPE_INTEGER) {
    716		ret = -EINVAL;
    717		goto out_free;
    718	}
    719
    720	enabled = !!(wifi_pkg->package.elements[1].integer.value);
    721	n_profiles = wifi_pkg->package.elements[2].integer.value;
    722
    723	/*
    724	 * Check the validity of n_profiles.  The EWRD profiles start
    725	 * from index 1, so the maximum value allowed here is
    726	 * ACPI_SAR_PROFILES_NUM - 1.
    727	 */
    728	if (n_profiles <= 0 || n_profiles >= ACPI_SAR_PROFILE_NUM) {
    729		ret = -EINVAL;
    730		goto out_free;
    731	}
    732
    733	/* the tables start at element 3 */
    734	pos = 3;
    735
    736	for (i = 0; i < n_profiles; i++) {
    737		/* The EWRD profiles officially go from 2 to 4, but we
    738		 * save them in sar_profiles[1-3] (because we don't
    739		 * have profile 0).  So in the array we start from 1.
    740		 */
    741		ret = iwl_sar_set_profile(&wifi_pkg->package.elements[pos],
    742					  &fwrt->sar_profiles[i + 1], enabled,
    743					  num_chains, num_sub_bands);
    744		if (ret < 0)
    745			break;
    746
    747		/* go to the next table */
    748		pos += num_chains * num_sub_bands;
    749	}
    750
    751out_free:
    752	kfree(data);
    753	return ret;
    754}
    755IWL_EXPORT_SYMBOL(iwl_sar_get_ewrd_table);
    756
    757int iwl_sar_get_wgds_table(struct iwl_fw_runtime *fwrt)
    758{
    759	union acpi_object *wifi_pkg, *data;
    760	int i, j, k, ret, tbl_rev;
    761	u8 num_bands, num_profiles;
    762	static const struct {
    763		u8 revisions;
    764		u8 bands;
    765		u8 profiles;
    766		u8 min_profiles;
    767	} rev_data[] = {
    768		{
    769			.revisions = BIT(3),
    770			.bands = ACPI_GEO_NUM_BANDS_REV2,
    771			.profiles = ACPI_NUM_GEO_PROFILES_REV3,
    772			.min_profiles = 3,
    773		},
    774		{
    775			.revisions = BIT(2),
    776			.bands = ACPI_GEO_NUM_BANDS_REV2,
    777			.profiles = ACPI_NUM_GEO_PROFILES,
    778		},
    779		{
    780			.revisions = BIT(0) | BIT(1),
    781			.bands = ACPI_GEO_NUM_BANDS_REV0,
    782			.profiles = ACPI_NUM_GEO_PROFILES,
    783		},
    784	};
    785	int idx;
    786	/* start from one to skip the domain */
    787	int entry_idx = 1;
    788
    789	BUILD_BUG_ON(ACPI_NUM_GEO_PROFILES_REV3 != IWL_NUM_GEO_PROFILES_V3);
    790	BUILD_BUG_ON(ACPI_NUM_GEO_PROFILES != IWL_NUM_GEO_PROFILES);
    791
    792	data = iwl_acpi_get_object(fwrt->dev, ACPI_WGDS_METHOD);
    793	if (IS_ERR(data))
    794		return PTR_ERR(data);
    795
    796	/* read the highest revision we understand first */
    797	for (idx = 0; idx < ARRAY_SIZE(rev_data); idx++) {
    798		/* min_profiles != 0 requires num_profiles header */
    799		u32 hdr_size = 1 + !!rev_data[idx].min_profiles;
    800		u32 profile_size = ACPI_GEO_PER_CHAIN_SIZE *
    801				   rev_data[idx].bands;
    802		u32 max_size = hdr_size + profile_size * rev_data[idx].profiles;
    803		u32 min_size;
    804
    805		if (!rev_data[idx].min_profiles)
    806			min_size = max_size;
    807		else
    808			min_size = hdr_size +
    809				   profile_size * rev_data[idx].min_profiles;
    810
    811		wifi_pkg = iwl_acpi_get_wifi_pkg_range(fwrt->dev, data,
    812						       min_size, max_size,
    813						       &tbl_rev);
    814		if (!IS_ERR(wifi_pkg)) {
    815			if (!(BIT(tbl_rev) & rev_data[idx].revisions))
    816				continue;
    817
    818			num_bands = rev_data[idx].bands;
    819			num_profiles = rev_data[idx].profiles;
    820
    821			if (rev_data[idx].min_profiles) {
    822				/* read header that says # of profiles */
    823				union acpi_object *entry;
    824
    825				entry = &wifi_pkg->package.elements[entry_idx];
    826				entry_idx++;
    827				if (entry->type != ACPI_TYPE_INTEGER ||
    828				    entry->integer.value > num_profiles) {
    829					ret = -EINVAL;
    830					goto out_free;
    831				}
    832				num_profiles = entry->integer.value;
    833
    834				/*
    835				 * this also validates >= min_profiles since we
    836				 * otherwise wouldn't have gotten the data when
    837				 * looking up in ACPI
    838				 */
    839				if (wifi_pkg->package.count !=
    840				    hdr_size + profile_size * num_profiles) {
    841					ret = -EINVAL;
    842					goto out_free;
    843				}
    844			}
    845			goto read_table;
    846		}
    847	}
    848
    849	if (idx < ARRAY_SIZE(rev_data))
    850		ret = PTR_ERR(wifi_pkg);
    851	else
    852		ret = -ENOENT;
    853	goto out_free;
    854
    855read_table:
    856	fwrt->geo_rev = tbl_rev;
    857	for (i = 0; i < num_profiles; i++) {
    858		for (j = 0; j < ACPI_GEO_NUM_BANDS_REV2; j++) {
    859			union acpi_object *entry;
    860
    861			/*
    862			 * num_bands is either 2 or 3, if it's only 2 then
    863			 * fill the third band (6 GHz) with the values from
    864			 * 5 GHz (second band)
    865			 */
    866			if (j >= num_bands) {
    867				fwrt->geo_profiles[i].bands[j].max =
    868					fwrt->geo_profiles[i].bands[1].max;
    869			} else {
    870				entry = &wifi_pkg->package.elements[entry_idx];
    871				entry_idx++;
    872				if (entry->type != ACPI_TYPE_INTEGER ||
    873				    entry->integer.value > U8_MAX) {
    874					ret = -EINVAL;
    875					goto out_free;
    876				}
    877
    878				fwrt->geo_profiles[i].bands[j].max =
    879					entry->integer.value;
    880			}
    881
    882			for (k = 0; k < ACPI_GEO_NUM_CHAINS; k++) {
    883				/* same here as above */
    884				if (j >= num_bands) {
    885					fwrt->geo_profiles[i].bands[j].chains[k] =
    886						fwrt->geo_profiles[i].bands[1].chains[k];
    887				} else {
    888					entry = &wifi_pkg->package.elements[entry_idx];
    889					entry_idx++;
    890					if (entry->type != ACPI_TYPE_INTEGER ||
    891					    entry->integer.value > U8_MAX) {
    892						ret = -EINVAL;
    893						goto out_free;
    894					}
    895
    896					fwrt->geo_profiles[i].bands[j].chains[k] =
    897						entry->integer.value;
    898				}
    899			}
    900		}
    901	}
    902
    903	fwrt->geo_num_profiles = num_profiles;
    904	fwrt->geo_enabled = true;
    905	ret = 0;
    906out_free:
    907	kfree(data);
    908	return ret;
    909}
    910IWL_EXPORT_SYMBOL(iwl_sar_get_wgds_table);
    911
    912bool iwl_sar_geo_support(struct iwl_fw_runtime *fwrt)
    913{
    914	/*
    915	 * The PER_CHAIN_LIMIT_OFFSET_CMD command is not supported on
    916	 * earlier firmware versions.  Unfortunately, we don't have a
    917	 * TLV API flag to rely on, so rely on the major version which
    918	 * is in the first byte of ucode_ver.  This was implemented
    919	 * initially on version 38 and then backported to 17.  It was
    920	 * also backported to 29, but only for 7265D devices.  The
    921	 * intention was to have it in 36 as well, but not all 8000
    922	 * family got this feature enabled.  The 8000 family is the
    923	 * only one using version 36, so skip this version entirely.
    924	 */
    925	return IWL_UCODE_SERIAL(fwrt->fw->ucode_ver) >= 38 ||
    926		(IWL_UCODE_SERIAL(fwrt->fw->ucode_ver) == 17 &&
    927		 fwrt->trans->hw_rev != CSR_HW_REV_TYPE_3160) ||
    928		(IWL_UCODE_SERIAL(fwrt->fw->ucode_ver) == 29 &&
    929		 ((fwrt->trans->hw_rev & CSR_HW_REV_TYPE_MSK) ==
    930		  CSR_HW_REV_TYPE_7265D));
    931}
    932IWL_EXPORT_SYMBOL(iwl_sar_geo_support);
    933
    934int iwl_sar_geo_init(struct iwl_fw_runtime *fwrt,
    935		     struct iwl_per_chain_offset *table,
    936		     u32 n_bands, u32 n_profiles)
    937{
    938	int i, j;
    939
    940	if (!fwrt->geo_enabled)
    941		return -ENODATA;
    942
    943	if (!iwl_sar_geo_support(fwrt))
    944		return -EOPNOTSUPP;
    945
    946	for (i = 0; i < n_profiles; i++) {
    947		for (j = 0; j < n_bands; j++) {
    948			struct iwl_per_chain_offset *chain =
    949				&table[i * n_bands + j];
    950
    951			chain->max_tx_power =
    952				cpu_to_le16(fwrt->geo_profiles[i].bands[j].max);
    953			chain->chain_a = fwrt->geo_profiles[i].bands[j].chains[0];
    954			chain->chain_b = fwrt->geo_profiles[i].bands[j].chains[1];
    955			IWL_DEBUG_RADIO(fwrt,
    956					"SAR geographic profile[%d] Band[%d]: chain A = %d chain B = %d max_tx_power = %d\n",
    957					i, j,
    958					fwrt->geo_profiles[i].bands[j].chains[0],
    959					fwrt->geo_profiles[i].bands[j].chains[1],
    960					fwrt->geo_profiles[i].bands[j].max);
    961		}
    962	}
    963
    964	return 0;
    965}
    966IWL_EXPORT_SYMBOL(iwl_sar_geo_init);
    967
    968__le32 iwl_acpi_get_lari_config_bitmap(struct iwl_fw_runtime *fwrt)
    969{
    970	int ret;
    971	u8 value;
    972	__le32 config_bitmap = 0;
    973
    974	/*
    975	 ** Evaluate func 'DSM_FUNC_ENABLE_INDONESIA_5G2'
    976	 */
    977	ret = iwl_acpi_get_dsm_u8(fwrt->dev, 0,
    978				  DSM_FUNC_ENABLE_INDONESIA_5G2,
    979				  &iwl_guid, &value);
    980
    981	if (!ret && value == DSM_VALUE_INDONESIA_ENABLE)
    982		config_bitmap |=
    983			cpu_to_le32(LARI_CONFIG_ENABLE_5G2_IN_INDONESIA_MSK);
    984
    985	/*
    986	 ** Evaluate func 'DSM_FUNC_DISABLE_SRD'
    987	 */
    988	ret = iwl_acpi_get_dsm_u8(fwrt->dev, 0,
    989				  DSM_FUNC_DISABLE_SRD,
    990				  &iwl_guid, &value);
    991	if (!ret) {
    992		if (value == DSM_VALUE_SRD_PASSIVE)
    993			config_bitmap |=
    994				cpu_to_le32(LARI_CONFIG_CHANGE_ETSI_TO_PASSIVE_MSK);
    995		else if (value == DSM_VALUE_SRD_DISABLE)
    996			config_bitmap |=
    997				cpu_to_le32(LARI_CONFIG_CHANGE_ETSI_TO_DISABLED_MSK);
    998	}
    999
   1000	return config_bitmap;
   1001}
   1002IWL_EXPORT_SYMBOL(iwl_acpi_get_lari_config_bitmap);
   1003
   1004int iwl_acpi_get_ppag_table(struct iwl_fw_runtime *fwrt)
   1005{
   1006	union acpi_object *wifi_pkg, *data, *flags;
   1007	int i, j, ret, tbl_rev, num_sub_bands = 0;
   1008	int idx = 2;
   1009
   1010	fwrt->ppag_flags = 0;
   1011
   1012	data = iwl_acpi_get_object(fwrt->dev, ACPI_PPAG_METHOD);
   1013	if (IS_ERR(data))
   1014		return PTR_ERR(data);
   1015
   1016	/* try to read ppag table rev 2 or 1 (both have the same data size) */
   1017	wifi_pkg = iwl_acpi_get_wifi_pkg(fwrt->dev, data,
   1018				ACPI_PPAG_WIFI_DATA_SIZE_V2, &tbl_rev);
   1019
   1020	if (!IS_ERR(wifi_pkg)) {
   1021		if (tbl_rev == 1 || tbl_rev == 2) {
   1022			num_sub_bands = IWL_NUM_SUB_BANDS_V2;
   1023			IWL_DEBUG_RADIO(fwrt,
   1024					"Reading PPAG table v2 (tbl_rev=%d)\n",
   1025					tbl_rev);
   1026			goto read_table;
   1027		} else {
   1028			ret = -EINVAL;
   1029			goto out_free;
   1030		}
   1031	}
   1032
   1033	/* try to read ppag table revision 0 */
   1034	wifi_pkg = iwl_acpi_get_wifi_pkg(fwrt->dev, data,
   1035			ACPI_PPAG_WIFI_DATA_SIZE_V1, &tbl_rev);
   1036
   1037	if (!IS_ERR(wifi_pkg)) {
   1038		if (tbl_rev != 0) {
   1039			ret = -EINVAL;
   1040			goto out_free;
   1041		}
   1042		num_sub_bands = IWL_NUM_SUB_BANDS_V1;
   1043		IWL_DEBUG_RADIO(fwrt, "Reading PPAG table v1 (tbl_rev=0)\n");
   1044		goto read_table;
   1045	}
   1046
   1047read_table:
   1048	fwrt->ppag_ver = tbl_rev;
   1049	flags = &wifi_pkg->package.elements[1];
   1050
   1051	if (flags->type != ACPI_TYPE_INTEGER) {
   1052		ret = -EINVAL;
   1053		goto out_free;
   1054	}
   1055
   1056	fwrt->ppag_flags = flags->integer.value & ACPI_PPAG_MASK;
   1057
   1058	if (!fwrt->ppag_flags) {
   1059		ret = 0;
   1060		goto out_free;
   1061	}
   1062
   1063	/*
   1064	 * read, verify gain values and save them into the PPAG table.
   1065	 * first sub-band (j=0) corresponds to Low-Band (2.4GHz), and the
   1066	 * following sub-bands to High-Band (5GHz).
   1067	 */
   1068	for (i = 0; i < IWL_NUM_CHAIN_LIMITS; i++) {
   1069		for (j = 0; j < num_sub_bands; j++) {
   1070			union acpi_object *ent;
   1071
   1072			ent = &wifi_pkg->package.elements[idx++];
   1073			if (ent->type != ACPI_TYPE_INTEGER) {
   1074				ret = -EINVAL;
   1075				goto out_free;
   1076			}
   1077
   1078			fwrt->ppag_chains[i].subbands[j] = ent->integer.value;
   1079
   1080			if ((j == 0 &&
   1081				(fwrt->ppag_chains[i].subbands[j] > ACPI_PPAG_MAX_LB ||
   1082				 fwrt->ppag_chains[i].subbands[j] < ACPI_PPAG_MIN_LB)) ||
   1083				(j != 0 &&
   1084				(fwrt->ppag_chains[i].subbands[j] > ACPI_PPAG_MAX_HB ||
   1085				fwrt->ppag_chains[i].subbands[j] < ACPI_PPAG_MIN_HB))) {
   1086					fwrt->ppag_flags = 0;
   1087					ret = -EINVAL;
   1088					goto out_free;
   1089				}
   1090		}
   1091	}
   1092
   1093
   1094	ret = 0;
   1095
   1096out_free:
   1097	kfree(data);
   1098	return ret;
   1099}
   1100IWL_EXPORT_SYMBOL(iwl_acpi_get_ppag_table);
   1101
   1102int iwl_read_ppag_table(struct iwl_fw_runtime *fwrt, union iwl_ppag_table_cmd *cmd,
   1103			int *cmd_size)
   1104{
   1105        u8 cmd_ver;
   1106        int i, j, num_sub_bands;
   1107        s8 *gain;
   1108
   1109        if (!fw_has_capa(&fwrt->fw->ucode_capa, IWL_UCODE_TLV_CAPA_SET_PPAG)) {
   1110                IWL_DEBUG_RADIO(fwrt,
   1111                                "PPAG capability not supported by FW, command not sent.\n");
   1112                return -EINVAL;
   1113        }
   1114        if (!fwrt->ppag_flags) {
   1115                IWL_DEBUG_RADIO(fwrt, "PPAG not enabled, command not sent.\n");
   1116                return -EINVAL;
   1117        }
   1118
   1119        /* The 'flags' field is the same in v1 and in v2 so we can just
   1120         * use v1 to access it.
   1121         */
   1122        cmd->v1.flags = cpu_to_le32(fwrt->ppag_flags);
   1123        cmd_ver = iwl_fw_lookup_cmd_ver(fwrt->fw,
   1124                                        WIDE_ID(PHY_OPS_GROUP, PER_PLATFORM_ANT_GAIN_CMD),
   1125                                        IWL_FW_CMD_VER_UNKNOWN);
   1126	if (cmd_ver == 1) {
   1127                num_sub_bands = IWL_NUM_SUB_BANDS_V1;
   1128                gain = cmd->v1.gain[0];
   1129                *cmd_size = sizeof(cmd->v1);
   1130                if (fwrt->ppag_ver == 1 || fwrt->ppag_ver == 2) {
   1131                        IWL_DEBUG_RADIO(fwrt,
   1132                                        "PPAG table rev is %d but FW supports v1, sending truncated table\n",
   1133                                        fwrt->ppag_ver);
   1134                        cmd->v1.flags &= cpu_to_le32(IWL_PPAG_ETSI_MASK);
   1135		}
   1136	} else if (cmd_ver == 2 || cmd_ver == 3) {
   1137                num_sub_bands = IWL_NUM_SUB_BANDS_V2;
   1138                gain = cmd->v2.gain[0];
   1139                *cmd_size = sizeof(cmd->v2);
   1140                if (fwrt->ppag_ver == 0) {
   1141                        IWL_DEBUG_RADIO(fwrt,
   1142                                        "PPAG table is v1 but FW supports v2, sending padded table\n");
   1143                } else if (cmd_ver == 2 && fwrt->ppag_ver == 2) {
   1144                        IWL_DEBUG_RADIO(fwrt,
   1145                                        "PPAG table is v3 but FW supports v2, sending partial bitmap.\n");
   1146                        cmd->v1.flags &= cpu_to_le32(IWL_PPAG_ETSI_MASK);
   1147                }
   1148        } else {
   1149                IWL_DEBUG_RADIO(fwrt, "Unsupported PPAG command version\n");
   1150                return -EINVAL;
   1151        }
   1152
   1153	for (i = 0; i < IWL_NUM_CHAIN_LIMITS; i++) {
   1154                for (j = 0; j < num_sub_bands; j++) {
   1155                        gain[i * num_sub_bands + j] =
   1156                                fwrt->ppag_chains[i].subbands[j];
   1157                        IWL_DEBUG_RADIO(fwrt,
   1158                                        "PPAG table: chain[%d] band[%d]: gain = %d\n",
   1159                                        i, j, gain[i * num_sub_bands + j]);
   1160                }
   1161        }
   1162
   1163	return 0;
   1164}
   1165IWL_EXPORT_SYMBOL(iwl_read_ppag_table);
   1166
   1167bool iwl_acpi_is_ppag_approved(struct iwl_fw_runtime *fwrt)
   1168{
   1169
   1170	if (!dmi_check_system(dmi_ppag_approved_list)) {
   1171		IWL_DEBUG_RADIO(fwrt,
   1172			"System vendor '%s' is not in the approved list, disabling PPAG.\n",
   1173			dmi_get_system_info(DMI_SYS_VENDOR));
   1174			fwrt->ppag_flags = 0;
   1175			return false;
   1176	}
   1177
   1178	return true;
   1179}
   1180IWL_EXPORT_SYMBOL(iwl_acpi_is_ppag_approved);