1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
2 /*
3  * Copyright(c) 2021-2023 Intel Corporation
4  */
5 
6 #include "iwl-drv.h"
7 #include "pnvm.h"
8 #include "iwl-prph.h"
9 #include "iwl-io.h"
10 
11 #include "fw/uefi.h"
12 #include "fw/api/alive.h"
13 #include <linux/efi.h>
14 #include "fw/runtime.h"
15 
16 #define IWL_EFI_VAR_GUID EFI_GUID(0x92daaf2f, 0xc02b, 0x455b,	\
17 				  0xb2, 0xec, 0xf5, 0xa3,	\
18 				  0x59, 0x4f, 0x4a, 0xea)
19 
20 struct iwl_uefi_pnvm_mem_desc {
21 	__le32 addr;
22 	__le32 size;
23 	const u8 data[];
24 } __packed;
25 
26 static void *iwl_uefi_get_variable(efi_char16_t *name, efi_guid_t *guid,
27 				   unsigned long *data_size)
28 {
29 	efi_status_t status;
30 	void *data;
31 
32 	if (!data_size)
33 		return ERR_PTR(-EINVAL);
34 
35 	if (!efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE))
36 		return ERR_PTR(-ENODEV);
37 
38 	/* first call with NULL data to get the exact entry size */
39 	*data_size = 0;
40 	status = efi.get_variable(name, guid, NULL, data_size, NULL);
41 	if (status != EFI_BUFFER_TOO_SMALL || !*data_size)
42 		return ERR_PTR(-EIO);
43 
44 	data = kmalloc(*data_size, GFP_KERNEL);
45 	if (!data)
46 		return ERR_PTR(-ENOMEM);
47 
48 	status = efi.get_variable(name, guid, NULL, data_size, data);
49 	if (status != EFI_SUCCESS) {
50 		kfree(data);
51 		return ERR_PTR(-ENOENT);
52 	}
53 
54 	return data;
55 }
56 
57 void *iwl_uefi_get_pnvm(struct iwl_trans *trans, size_t *len)
58 {
59 	unsigned long package_size;
60 	void *data;
61 
62 	*len = 0;
63 
64 	data = iwl_uefi_get_variable(IWL_UEFI_OEM_PNVM_NAME, &IWL_EFI_VAR_GUID,
65 				     &package_size);
66 	if (IS_ERR(data)) {
67 		IWL_DEBUG_FW(trans,
68 			     "PNVM UEFI variable not found 0x%lx (len %lu)\n",
69 			     PTR_ERR(data), package_size);
70 		return data;
71 	}
72 
73 	IWL_DEBUG_FW(trans, "Read PNVM from UEFI with size %lu\n", package_size);
74 	*len = package_size;
75 
76 	return data;
77 }
78 
79 int iwl_uefi_handle_tlv_mem_desc(struct iwl_trans *trans, const u8 *data,
80 				 u32 tlv_len, struct iwl_pnvm_image *pnvm_data)
81 {
82 	const struct iwl_uefi_pnvm_mem_desc *desc = (const void *)data;
83 	u32 data_len;
84 
85 	if (tlv_len < sizeof(*desc)) {
86 		IWL_DEBUG_FW(trans, "TLV len (%d) is too small\n", tlv_len);
87 		return -EINVAL;
88 	}
89 
90 	data_len = tlv_len - sizeof(*desc);
91 
92 	IWL_DEBUG_FW(trans,
93 		     "Handle IWL_UCODE_TLV_MEM_DESC, len %d data_len %d\n",
94 		     tlv_len, data_len);
95 
96 	if (le32_to_cpu(desc->size) != data_len) {
97 		IWL_DEBUG_FW(trans, "invalid mem desc size %d\n", desc->size);
98 		return -EINVAL;
99 	}
100 
101 	if (pnvm_data->n_chunks == IPC_DRAM_MAP_ENTRY_NUM_MAX) {
102 		IWL_DEBUG_FW(trans, "too many payloads to allocate in DRAM.\n");
103 		return -EINVAL;
104 	}
105 
106 	IWL_DEBUG_FW(trans, "Adding data (size %d)\n", data_len);
107 
108 	pnvm_data->chunks[pnvm_data->n_chunks].data = desc->data;
109 	pnvm_data->chunks[pnvm_data->n_chunks].len = data_len;
110 	pnvm_data->n_chunks++;
111 
112 	return 0;
113 }
114 
115 static int iwl_uefi_reduce_power_section(struct iwl_trans *trans,
116 					 const u8 *data, size_t len,
117 					 struct iwl_pnvm_image *pnvm_data)
118 {
119 	const struct iwl_ucode_tlv *tlv;
120 
121 	IWL_DEBUG_FW(trans, "Handling REDUCE_POWER section\n");
122 	memset(pnvm_data, 0, sizeof(*pnvm_data));
123 
124 	while (len >= sizeof(*tlv)) {
125 		u32 tlv_len, tlv_type;
126 
127 		len -= sizeof(*tlv);
128 		tlv = (const void *)data;
129 
130 		tlv_len = le32_to_cpu(tlv->length);
131 		tlv_type = le32_to_cpu(tlv->type);
132 
133 		if (len < tlv_len) {
134 			IWL_ERR(trans, "invalid TLV len: %zd/%u\n",
135 				len, tlv_len);
136 			return -EINVAL;
137 		}
138 
139 		data += sizeof(*tlv);
140 
141 		switch (tlv_type) {
142 		case IWL_UCODE_TLV_MEM_DESC:
143 			if (iwl_uefi_handle_tlv_mem_desc(trans, data, tlv_len,
144 							 pnvm_data))
145 				return -EINVAL;
146 			break;
147 		case IWL_UCODE_TLV_PNVM_SKU:
148 			IWL_DEBUG_FW(trans,
149 				     "New REDUCE_POWER section started, stop parsing.\n");
150 			goto done;
151 		default:
152 			IWL_DEBUG_FW(trans, "Found TLV 0x%0x, len %d\n",
153 				     tlv_type, tlv_len);
154 			break;
155 		}
156 
157 		len -= ALIGN(tlv_len, 4);
158 		data += ALIGN(tlv_len, 4);
159 	}
160 
161 done:
162 	if (!pnvm_data->n_chunks) {
163 		IWL_DEBUG_FW(trans, "Empty REDUCE_POWER, skipping.\n");
164 		return -ENOENT;
165 	}
166 	return 0;
167 }
168 
169 int iwl_uefi_reduce_power_parse(struct iwl_trans *trans,
170 				const u8 *data, size_t len,
171 				struct iwl_pnvm_image *pnvm_data)
172 {
173 	const struct iwl_ucode_tlv *tlv;
174 
175 	IWL_DEBUG_FW(trans, "Parsing REDUCE_POWER data\n");
176 
177 	while (len >= sizeof(*tlv)) {
178 		u32 tlv_len, tlv_type;
179 
180 		len -= sizeof(*tlv);
181 		tlv = (const void *)data;
182 
183 		tlv_len = le32_to_cpu(tlv->length);
184 		tlv_type = le32_to_cpu(tlv->type);
185 
186 		if (len < tlv_len) {
187 			IWL_ERR(trans, "invalid TLV len: %zd/%u\n",
188 				len, tlv_len);
189 			return -EINVAL;
190 		}
191 
192 		if (tlv_type == IWL_UCODE_TLV_PNVM_SKU) {
193 			const struct iwl_sku_id *sku_id =
194 				(const void *)(data + sizeof(*tlv));
195 
196 			IWL_DEBUG_FW(trans,
197 				     "Got IWL_UCODE_TLV_PNVM_SKU len %d\n",
198 				     tlv_len);
199 			IWL_DEBUG_FW(trans, "sku_id 0x%0x 0x%0x 0x%0x\n",
200 				     le32_to_cpu(sku_id->data[0]),
201 				     le32_to_cpu(sku_id->data[1]),
202 				     le32_to_cpu(sku_id->data[2]));
203 
204 			data += sizeof(*tlv) + ALIGN(tlv_len, 4);
205 			len -= ALIGN(tlv_len, 4);
206 
207 			if (trans->sku_id[0] == le32_to_cpu(sku_id->data[0]) &&
208 			    trans->sku_id[1] == le32_to_cpu(sku_id->data[1]) &&
209 			    trans->sku_id[2] == le32_to_cpu(sku_id->data[2])) {
210 				int ret = iwl_uefi_reduce_power_section(trans,
211 								    data, len,
212 								    pnvm_data);
213 				if (!ret)
214 					return 0;
215 			} else {
216 				IWL_DEBUG_FW(trans, "SKU ID didn't match!\n");
217 			}
218 		} else {
219 			data += sizeof(*tlv) + ALIGN(tlv_len, 4);
220 			len -= ALIGN(tlv_len, 4);
221 		}
222 	}
223 
224 	return -ENOENT;
225 }
226 
227 u8 *iwl_uefi_get_reduced_power(struct iwl_trans *trans, size_t *len)
228 {
229 	struct pnvm_sku_package *package;
230 	unsigned long package_size;
231 	u8 *data;
232 
233 	package = iwl_uefi_get_variable(IWL_UEFI_REDUCED_POWER_NAME,
234 					&IWL_EFI_VAR_GUID, &package_size);
235 
236 	if (IS_ERR(package)) {
237 		IWL_DEBUG_FW(trans,
238 			     "Reduced Power UEFI variable not found 0x%lx (len %lu)\n",
239 			     PTR_ERR(package), package_size);
240 		return ERR_CAST(package);
241 	}
242 
243 	if (package_size < sizeof(*package)) {
244 		IWL_DEBUG_FW(trans,
245 			     "Invalid Reduced Power UEFI variable len (%lu)\n",
246 			     package_size);
247 		kfree(package);
248 		return ERR_PTR(-EINVAL);
249 	}
250 
251 	IWL_DEBUG_FW(trans, "Read reduced power from UEFI with size %lu\n",
252 		     package_size);
253 
254 	IWL_DEBUG_FW(trans, "rev %d, total_size %d, n_skus %d\n",
255 		     package->rev, package->total_size, package->n_skus);
256 
257 	*len = package_size - sizeof(*package);
258 	data = kmemdup(package->data, *len, GFP_KERNEL);
259 	if (!data) {
260 		kfree(package);
261 		return ERR_PTR(-ENOMEM);
262 	}
263 
264 	kfree(package);
265 
266 	return data;
267 }
268 
269 static int iwl_uefi_step_parse(struct uefi_cnv_common_step_data *common_step_data,
270 			       struct iwl_trans *trans)
271 {
272 	if (common_step_data->revision != 1)
273 		return -EINVAL;
274 
275 	trans->mbx_addr_0_step = (u32)common_step_data->revision |
276 		(u32)common_step_data->cnvi_eq_channel << 8 |
277 		(u32)common_step_data->cnvr_eq_channel << 16 |
278 		(u32)common_step_data->radio1 << 24;
279 	trans->mbx_addr_1_step = (u32)common_step_data->radio2;
280 	return 0;
281 }
282 
283 void iwl_uefi_get_step_table(struct iwl_trans *trans)
284 {
285 	struct uefi_cnv_common_step_data *data;
286 	unsigned long package_size;
287 	int ret;
288 
289 	if (trans->trans_cfg->device_family < IWL_DEVICE_FAMILY_AX210)
290 		return;
291 
292 	data = iwl_uefi_get_variable(IWL_UEFI_STEP_NAME, &IWL_EFI_VAR_GUID,
293 				     &package_size);
294 
295 	if (IS_ERR(data)) {
296 		IWL_DEBUG_FW(trans,
297 			     "STEP UEFI variable not found 0x%lx\n",
298 			     PTR_ERR(data));
299 		return;
300 	}
301 
302 	if (package_size < sizeof(*data)) {
303 		IWL_DEBUG_FW(trans,
304 			     "Invalid STEP table UEFI variable len (%lu)\n",
305 			     package_size);
306 		kfree(data);
307 		return;
308 	}
309 
310 	IWL_DEBUG_FW(trans, "Read STEP from UEFI with size %lu\n",
311 		     package_size);
312 
313 	ret = iwl_uefi_step_parse(data, trans);
314 	if (ret < 0)
315 		IWL_DEBUG_FW(trans, "Cannot read STEP tables. rev is invalid\n");
316 
317 	kfree(data);
318 }
319 IWL_EXPORT_SYMBOL(iwl_uefi_get_step_table);
320 
321 #ifdef CONFIG_ACPI
322 static int iwl_uefi_sgom_parse(struct uefi_cnv_wlan_sgom_data *sgom_data,
323 			       struct iwl_fw_runtime *fwrt)
324 {
325 	int i, j;
326 
327 	if (sgom_data->revision != 1)
328 		return -EINVAL;
329 
330 	memcpy(fwrt->sgom_table.offset_map, sgom_data->offset_map,
331 	       sizeof(fwrt->sgom_table.offset_map));
332 
333 	for (i = 0; i < MCC_TO_SAR_OFFSET_TABLE_ROW_SIZE; i++) {
334 		for (j = 0; j < MCC_TO_SAR_OFFSET_TABLE_COL_SIZE; j++) {
335 			/* since each byte is composed of to values, */
336 			/* one for each letter, */
337 			/* extract and check each of them separately */
338 			u8 value = fwrt->sgom_table.offset_map[i][j];
339 			u8 low = value & 0xF;
340 			u8 high = (value & 0xF0) >> 4;
341 
342 			if (high > fwrt->geo_num_profiles)
343 				high = 0;
344 			if (low > fwrt->geo_num_profiles)
345 				low = 0;
346 			fwrt->sgom_table.offset_map[i][j] = (high << 4) | low;
347 		}
348 	}
349 
350 	fwrt->sgom_enabled = true;
351 	return 0;
352 }
353 
354 void iwl_uefi_get_sgom_table(struct iwl_trans *trans,
355 			     struct iwl_fw_runtime *fwrt)
356 {
357 	struct uefi_cnv_wlan_sgom_data *data;
358 	unsigned long package_size;
359 	int ret;
360 
361 	if (!fwrt->geo_enabled)
362 		return;
363 
364 	data = iwl_uefi_get_variable(IWL_UEFI_SGOM_NAME, &IWL_EFI_VAR_GUID,
365 				     &package_size);
366 	if (IS_ERR(data)) {
367 		IWL_DEBUG_FW(trans,
368 			     "SGOM UEFI variable not found 0x%lx\n",
369 			     PTR_ERR(data));
370 		return;
371 	}
372 
373 	if (package_size < sizeof(*data)) {
374 		IWL_DEBUG_FW(trans,
375 			     "Invalid SGOM table UEFI variable len (%lu)\n",
376 			     package_size);
377 		kfree(data);
378 		return;
379 	}
380 
381 	IWL_DEBUG_FW(trans, "Read SGOM from UEFI with size %lu\n",
382 		     package_size);
383 
384 	ret = iwl_uefi_sgom_parse(data, fwrt);
385 	if (ret < 0)
386 		IWL_DEBUG_FW(trans, "Cannot read SGOM tables. rev is invalid\n");
387 
388 	kfree(data);
389 }
390 IWL_EXPORT_SYMBOL(iwl_uefi_get_sgom_table);
391 #endif /* CONFIG_ACPI */
392