1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
2 /*
3  * Copyright (C) 2005-2014, 2020-2021 Intel Corporation
4  * Copyright (C) 2016 Intel Deutschland GmbH
5  */
6 #include <linux/slab.h>
7 #include <linux/string.h>
8 #include <linux/export.h>
9 
10 #include "iwl-drv.h"
11 #include "iwl-phy-db.h"
12 #include "iwl-debug.h"
13 #include "iwl-op-mode.h"
14 #include "iwl-trans.h"
15 
16 struct iwl_phy_db_entry {
17 	u16	size;
18 	u8	*data;
19 };
20 
21 /**
22  * struct iwl_phy_db - stores phy configuration and calibration data.
23  *
24  * @cfg: phy configuration.
25  * @calib_nch: non channel specific calibration data.
26  * @n_group_papd: number of entries in papd channel group.
27  * @calib_ch_group_papd: calibration data related to papd channel group.
28  * @n_group_txp: number of entries in tx power channel group.
29  * @calib_ch_group_txp: calibration data related to tx power chanel group.
30  * @trans: transport layer
31  */
32 struct iwl_phy_db {
33 	struct iwl_phy_db_entry	cfg;
34 	struct iwl_phy_db_entry	calib_nch;
35 	int n_group_papd;
36 	struct iwl_phy_db_entry	*calib_ch_group_papd;
37 	int n_group_txp;
38 	struct iwl_phy_db_entry	*calib_ch_group_txp;
39 
40 	struct iwl_trans *trans;
41 };
42 
43 enum iwl_phy_db_section_type {
44 	IWL_PHY_DB_CFG = 1,
45 	IWL_PHY_DB_CALIB_NCH,
46 	IWL_PHY_DB_UNUSED,
47 	IWL_PHY_DB_CALIB_CHG_PAPD,
48 	IWL_PHY_DB_CALIB_CHG_TXP,
49 	IWL_PHY_DB_MAX
50 };
51 
52 #define PHY_DB_CMD 0x6c
53 
54 /* for parsing of tx power channel group data that comes from the firmware*/
55 struct iwl_phy_db_chg_txp {
56 	__le32 space;
57 	__le16 max_channel_idx;
58 } __packed;
59 
60 struct iwl_phy_db *iwl_phy_db_init(struct iwl_trans *trans)
61 {
62 	struct iwl_phy_db *phy_db = kzalloc(sizeof(struct iwl_phy_db),
63 					    GFP_KERNEL);
64 
65 	if (!phy_db)
66 		return phy_db;
67 
68 	phy_db->trans = trans;
69 
70 	phy_db->n_group_txp = -1;
71 	phy_db->n_group_papd = -1;
72 
73 	/* TODO: add default values of the phy db. */
74 	return phy_db;
75 }
76 IWL_EXPORT_SYMBOL(iwl_phy_db_init);
77 
78 /*
79  * get phy db section: returns a pointer to a phy db section specified by
80  * type and channel group id.
81  */
82 static struct iwl_phy_db_entry *
83 iwl_phy_db_get_section(struct iwl_phy_db *phy_db,
84 		       enum iwl_phy_db_section_type type,
85 		       u16 chg_id)
86 {
87 	if (!phy_db || type >= IWL_PHY_DB_MAX)
88 		return NULL;
89 
90 	switch (type) {
91 	case IWL_PHY_DB_CFG:
92 		return &phy_db->cfg;
93 	case IWL_PHY_DB_CALIB_NCH:
94 		return &phy_db->calib_nch;
95 	case IWL_PHY_DB_CALIB_CHG_PAPD:
96 		if (chg_id >= phy_db->n_group_papd)
97 			return NULL;
98 		return &phy_db->calib_ch_group_papd[chg_id];
99 	case IWL_PHY_DB_CALIB_CHG_TXP:
100 		if (chg_id >= phy_db->n_group_txp)
101 			return NULL;
102 		return &phy_db->calib_ch_group_txp[chg_id];
103 	default:
104 		return NULL;
105 	}
106 	return NULL;
107 }
108 
109 static void iwl_phy_db_free_section(struct iwl_phy_db *phy_db,
110 				    enum iwl_phy_db_section_type type,
111 				    u16 chg_id)
112 {
113 	struct iwl_phy_db_entry *entry =
114 				iwl_phy_db_get_section(phy_db, type, chg_id);
115 	if (!entry)
116 		return;
117 
118 	kfree(entry->data);
119 	entry->data = NULL;
120 	entry->size = 0;
121 }
122 
123 void iwl_phy_db_free(struct iwl_phy_db *phy_db)
124 {
125 	int i;
126 
127 	if (!phy_db)
128 		return;
129 
130 	iwl_phy_db_free_section(phy_db, IWL_PHY_DB_CFG, 0);
131 	iwl_phy_db_free_section(phy_db, IWL_PHY_DB_CALIB_NCH, 0);
132 
133 	for (i = 0; i < phy_db->n_group_papd; i++)
134 		iwl_phy_db_free_section(phy_db, IWL_PHY_DB_CALIB_CHG_PAPD, i);
135 	kfree(phy_db->calib_ch_group_papd);
136 
137 	for (i = 0; i < phy_db->n_group_txp; i++)
138 		iwl_phy_db_free_section(phy_db, IWL_PHY_DB_CALIB_CHG_TXP, i);
139 	kfree(phy_db->calib_ch_group_txp);
140 
141 	kfree(phy_db);
142 }
143 IWL_EXPORT_SYMBOL(iwl_phy_db_free);
144 
145 int iwl_phy_db_set_section(struct iwl_phy_db *phy_db,
146 			   struct iwl_rx_packet *pkt)
147 {
148 	unsigned int pkt_len = iwl_rx_packet_payload_len(pkt);
149 	struct iwl_calib_res_notif_phy_db *phy_db_notif =
150 			(struct iwl_calib_res_notif_phy_db *)pkt->data;
151 	enum iwl_phy_db_section_type type;
152 	u16 size;
153 	struct iwl_phy_db_entry *entry;
154 	u16 chg_id = 0;
155 
156 	if (pkt_len < sizeof(*phy_db_notif))
157 		return -EINVAL;
158 
159 	type = le16_to_cpu(phy_db_notif->type);
160 	size = le16_to_cpu(phy_db_notif->length);
161 
162 	if (pkt_len < sizeof(*phy_db_notif) + size)
163 		return -EINVAL;
164 
165 	if (!phy_db)
166 		return -EINVAL;
167 
168 	if (type == IWL_PHY_DB_CALIB_CHG_PAPD) {
169 		chg_id = le16_to_cpup((__le16 *)phy_db_notif->data);
170 		if (phy_db && !phy_db->calib_ch_group_papd) {
171 			/*
172 			 * Firmware sends the largest index first, so we can use
173 			 * it to know how much we should allocate.
174 			 */
175 			phy_db->calib_ch_group_papd = kcalloc(chg_id + 1,
176 							      sizeof(struct iwl_phy_db_entry),
177 							      GFP_ATOMIC);
178 			if (!phy_db->calib_ch_group_papd)
179 				return -ENOMEM;
180 			phy_db->n_group_papd = chg_id + 1;
181 		}
182 	} else if (type == IWL_PHY_DB_CALIB_CHG_TXP) {
183 		chg_id = le16_to_cpup((__le16 *)phy_db_notif->data);
184 		if (phy_db && !phy_db->calib_ch_group_txp) {
185 			/*
186 			 * Firmware sends the largest index first, so we can use
187 			 * it to know how much we should allocate.
188 			 */
189 			phy_db->calib_ch_group_txp = kcalloc(chg_id + 1,
190 							     sizeof(struct iwl_phy_db_entry),
191 							     GFP_ATOMIC);
192 			if (!phy_db->calib_ch_group_txp)
193 				return -ENOMEM;
194 			phy_db->n_group_txp = chg_id + 1;
195 		}
196 	}
197 
198 	entry = iwl_phy_db_get_section(phy_db, type, chg_id);
199 	if (!entry)
200 		return -EINVAL;
201 
202 	kfree(entry->data);
203 	entry->data = kmemdup(phy_db_notif->data, size, GFP_ATOMIC);
204 	if (!entry->data) {
205 		entry->size = 0;
206 		return -ENOMEM;
207 	}
208 
209 	entry->size = size;
210 
211 	IWL_DEBUG_INFO(phy_db->trans,
212 		       "%s(%d): [PHYDB]SET: Type %d , Size: %d\n",
213 		       __func__, __LINE__, type, size);
214 
215 	return 0;
216 }
217 IWL_EXPORT_SYMBOL(iwl_phy_db_set_section);
218 
219 static int is_valid_channel(u16 ch_id)
220 {
221 	if (ch_id <= 14 ||
222 	    (36 <= ch_id && ch_id <= 64 && ch_id % 4 == 0) ||
223 	    (100 <= ch_id && ch_id <= 140 && ch_id % 4 == 0) ||
224 	    (145 <= ch_id && ch_id <= 165 && ch_id % 4 == 1))
225 		return 1;
226 	return 0;
227 }
228 
229 static u8 ch_id_to_ch_index(u16 ch_id)
230 {
231 	if (WARN_ON(!is_valid_channel(ch_id)))
232 		return 0xff;
233 
234 	if (ch_id <= 14)
235 		return ch_id - 1;
236 	if (ch_id <= 64)
237 		return (ch_id + 20) / 4;
238 	if (ch_id <= 140)
239 		return (ch_id - 12) / 4;
240 	return (ch_id - 13) / 4;
241 }
242 
243 
244 static u16 channel_id_to_papd(u16 ch_id)
245 {
246 	if (WARN_ON(!is_valid_channel(ch_id)))
247 		return 0xff;
248 
249 	if (1 <= ch_id && ch_id <= 14)
250 		return 0;
251 	if (36 <= ch_id && ch_id <= 64)
252 		return 1;
253 	if (100 <= ch_id && ch_id <= 140)
254 		return 2;
255 	return 3;
256 }
257 
258 static u16 channel_id_to_txp(struct iwl_phy_db *phy_db, u16 ch_id)
259 {
260 	struct iwl_phy_db_chg_txp *txp_chg;
261 	int i;
262 	u8 ch_index = ch_id_to_ch_index(ch_id);
263 	if (ch_index == 0xff)
264 		return 0xff;
265 
266 	for (i = 0; i < phy_db->n_group_txp; i++) {
267 		txp_chg = (void *)phy_db->calib_ch_group_txp[i].data;
268 		if (!txp_chg)
269 			return 0xff;
270 		/*
271 		 * Looking for the first channel group that its max channel is
272 		 * higher then wanted channel.
273 		 */
274 		if (le16_to_cpu(txp_chg->max_channel_idx) >= ch_index)
275 			return i;
276 	}
277 	return 0xff;
278 }
279 static
280 int iwl_phy_db_get_section_data(struct iwl_phy_db *phy_db,
281 				u32 type, u8 **data, u16 *size, u16 ch_id)
282 {
283 	struct iwl_phy_db_entry *entry;
284 	u16 ch_group_id = 0;
285 
286 	if (!phy_db)
287 		return -EINVAL;
288 
289 	/* find wanted channel group */
290 	if (type == IWL_PHY_DB_CALIB_CHG_PAPD)
291 		ch_group_id = channel_id_to_papd(ch_id);
292 	else if (type == IWL_PHY_DB_CALIB_CHG_TXP)
293 		ch_group_id = channel_id_to_txp(phy_db, ch_id);
294 
295 	entry = iwl_phy_db_get_section(phy_db, type, ch_group_id);
296 	if (!entry)
297 		return -EINVAL;
298 
299 	*data = entry->data;
300 	*size = entry->size;
301 
302 	IWL_DEBUG_INFO(phy_db->trans,
303 		       "%s(%d): [PHYDB] GET: Type %d , Size: %d\n",
304 		       __func__, __LINE__, type, *size);
305 
306 	return 0;
307 }
308 
309 static int iwl_send_phy_db_cmd(struct iwl_phy_db *phy_db, u16 type,
310 			       u16 length, void *data)
311 {
312 	struct iwl_phy_db_cmd phy_db_cmd;
313 	struct iwl_host_cmd cmd = {
314 		.id = PHY_DB_CMD,
315 	};
316 
317 	IWL_DEBUG_INFO(phy_db->trans,
318 		       "Sending PHY-DB hcmd of type %d, of length %d\n",
319 		       type, length);
320 
321 	/* Set phy db cmd variables */
322 	phy_db_cmd.type = cpu_to_le16(type);
323 	phy_db_cmd.length = cpu_to_le16(length);
324 
325 	/* Set hcmd variables */
326 	cmd.data[0] = &phy_db_cmd;
327 	cmd.len[0] = sizeof(struct iwl_phy_db_cmd);
328 	cmd.data[1] = data;
329 	cmd.len[1] = length;
330 	cmd.dataflags[1] = IWL_HCMD_DFL_NOCOPY;
331 
332 	return iwl_trans_send_cmd(phy_db->trans, &cmd);
333 }
334 
335 static int iwl_phy_db_send_all_channel_groups(
336 					struct iwl_phy_db *phy_db,
337 					enum iwl_phy_db_section_type type,
338 					u8 max_ch_groups)
339 {
340 	u16 i;
341 	int err;
342 	struct iwl_phy_db_entry *entry;
343 
344 	/* Send all the  channel specific groups to operational fw */
345 	for (i = 0; i < max_ch_groups; i++) {
346 		entry = iwl_phy_db_get_section(phy_db,
347 					       type,
348 					       i);
349 		if (!entry)
350 			return -EINVAL;
351 
352 		if (!entry->size)
353 			continue;
354 
355 		/* Send the requested PHY DB section */
356 		err = iwl_send_phy_db_cmd(phy_db,
357 					  type,
358 					  entry->size,
359 					  entry->data);
360 		if (err) {
361 			IWL_ERR(phy_db->trans,
362 				"Can't SEND phy_db section %d (%d), err %d\n",
363 				type, i, err);
364 			return err;
365 		}
366 
367 		IWL_DEBUG_INFO(phy_db->trans,
368 			       "Sent PHY_DB HCMD, type = %d num = %d\n",
369 			       type, i);
370 	}
371 
372 	return 0;
373 }
374 
375 int iwl_send_phy_db_data(struct iwl_phy_db *phy_db)
376 {
377 	u8 *data = NULL;
378 	u16 size = 0;
379 	int err;
380 
381 	IWL_DEBUG_INFO(phy_db->trans,
382 		       "Sending phy db data and configuration to runtime image\n");
383 
384 	/* Send PHY DB CFG section */
385 	err = iwl_phy_db_get_section_data(phy_db, IWL_PHY_DB_CFG,
386 					  &data, &size, 0);
387 	if (err) {
388 		IWL_ERR(phy_db->trans, "Cannot get Phy DB cfg section\n");
389 		return err;
390 	}
391 
392 	err = iwl_send_phy_db_cmd(phy_db, IWL_PHY_DB_CFG, size, data);
393 	if (err) {
394 		IWL_ERR(phy_db->trans,
395 			"Cannot send HCMD of  Phy DB cfg section\n");
396 		return err;
397 	}
398 
399 	err = iwl_phy_db_get_section_data(phy_db, IWL_PHY_DB_CALIB_NCH,
400 					  &data, &size, 0);
401 	if (err) {
402 		IWL_ERR(phy_db->trans,
403 			"Cannot get Phy DB non specific channel section\n");
404 		return err;
405 	}
406 
407 	err = iwl_send_phy_db_cmd(phy_db, IWL_PHY_DB_CALIB_NCH, size, data);
408 	if (err) {
409 		IWL_ERR(phy_db->trans,
410 			"Cannot send HCMD of Phy DB non specific channel section\n");
411 		return err;
412 	}
413 
414 	/* Send all the TXP channel specific data */
415 	err = iwl_phy_db_send_all_channel_groups(phy_db,
416 						 IWL_PHY_DB_CALIB_CHG_PAPD,
417 						 phy_db->n_group_papd);
418 	if (err) {
419 		IWL_ERR(phy_db->trans,
420 			"Cannot send channel specific PAPD groups\n");
421 		return err;
422 	}
423 
424 	/* Send all the TXP channel specific data */
425 	err = iwl_phy_db_send_all_channel_groups(phy_db,
426 						 IWL_PHY_DB_CALIB_CHG_TXP,
427 						 phy_db->n_group_txp);
428 	if (err) {
429 		IWL_ERR(phy_db->trans,
430 			"Cannot send channel specific TX power groups\n");
431 		return err;
432 	}
433 
434 	IWL_DEBUG_INFO(phy_db->trans,
435 		       "Finished sending phy db non channel data\n");
436 	return 0;
437 }
438 IWL_EXPORT_SYMBOL(iwl_send_phy_db_data);
439