1 // SPDX-License-Identifier: BSD-3-Clause-Clear
2 /*
3 * Copyright (C) 2016 Felix Fietkau <nbd@nbd.name>
4 */
5 #include <linux/of.h>
6 #include <linux/of_net.h>
7 #include <linux/mtd/mtd.h>
8 #include <linux/mtd/partitions.h>
9 #include <linux/nvmem-consumer.h>
10 #include <linux/etherdevice.h>
11 #include "mt76.h"
12 #include "mt76_connac.h"
13
14 enum mt76_sku_type {
15 MT76_SKU_RATE,
16 MT76_SKU_BACKOFF,
17 MT76_SKU_BACKOFF_BF_OFFSET,
18 };
19
mt76_get_of_eeprom_data(struct mt76_dev * dev,void * eep,int len)20 static int mt76_get_of_eeprom_data(struct mt76_dev *dev, void *eep, int len)
21 {
22 struct device_node *np = dev->dev->of_node;
23 const void *data;
24 int size;
25
26 data = of_get_property(np, "mediatek,eeprom-data", &size);
27 if (!data)
28 return -ENOENT;
29
30 if (size > len)
31 return -EINVAL;
32
33 memcpy(eep, data, size);
34
35 return 0;
36 }
37
mt76_get_of_data_from_mtd(struct mt76_dev * dev,void * eep,int offset,int len)38 int mt76_get_of_data_from_mtd(struct mt76_dev *dev, void *eep, int offset, int len)
39 {
40 #ifdef CONFIG_MTD
41 struct device_node *np = dev->dev->of_node;
42 struct mtd_info *mtd;
43 const __be32 *list;
44 const char *part;
45 phandle phandle;
46 size_t retlen;
47 int size;
48 int ret;
49
50 list = of_get_property(np, "mediatek,mtd-eeprom", &size);
51 if (!list)
52 return -ENOENT;
53
54 phandle = be32_to_cpup(list++);
55 if (!phandle)
56 return -ENOENT;
57
58 np = of_find_node_by_phandle(phandle);
59 if (!np)
60 return -EINVAL;
61
62 part = of_get_property(np, "label", NULL);
63 if (!part)
64 part = np->name;
65
66 mtd = get_mtd_device_nm(part);
67 if (IS_ERR(mtd)) {
68 ret = PTR_ERR(mtd);
69 goto out_put_node;
70 }
71
72 if (size <= sizeof(*list)) {
73 ret = -EINVAL;
74 goto out_put_node;
75 }
76
77 offset += be32_to_cpup(list);
78 ret = mtd_read(mtd, offset, len, &retlen, eep);
79 put_mtd_device(mtd);
80 if (mtd_is_bitflip(ret))
81 ret = 0;
82 if (ret) {
83 dev_err(dev->dev, "reading EEPROM from mtd %s failed: %i\n",
84 part, ret);
85 goto out_put_node;
86 }
87
88 if (retlen < len) {
89 ret = -EINVAL;
90 goto out_put_node;
91 }
92
93 if (of_property_read_bool(dev->dev->of_node, "big-endian")) {
94 u8 *data = (u8 *)eep;
95 int i;
96
97 /* convert eeprom data in Little Endian */
98 for (i = 0; i < round_down(len, 2); i += 2)
99 put_unaligned_le16(get_unaligned_be16(&data[i]),
100 &data[i]);
101 }
102
103 #ifdef CONFIG_NL80211_TESTMODE
104 dev->test_mtd.name = devm_kstrdup(dev->dev, part, GFP_KERNEL);
105 if (!dev->test_mtd.name) {
106 ret = -ENOMEM;
107 goto out_put_node;
108 }
109 dev->test_mtd.offset = offset;
110 #endif
111
112 out_put_node:
113 of_node_put(np);
114 return ret;
115 #else
116 return -ENOENT;
117 #endif
118 }
119 EXPORT_SYMBOL_GPL(mt76_get_of_data_from_mtd);
120
mt76_get_of_data_from_nvmem(struct mt76_dev * dev,void * eep,const char * cell_name,int len)121 int mt76_get_of_data_from_nvmem(struct mt76_dev *dev, void *eep,
122 const char *cell_name, int len)
123 {
124 struct device_node *np = dev->dev->of_node;
125 struct nvmem_cell *cell;
126 const void *data;
127 size_t retlen;
128 int ret = 0;
129
130 cell = of_nvmem_cell_get(np, cell_name);
131 if (IS_ERR(cell))
132 return PTR_ERR(cell);
133
134 data = nvmem_cell_read(cell, &retlen);
135 nvmem_cell_put(cell);
136
137 if (IS_ERR(data))
138 return PTR_ERR(data);
139
140 if (retlen < len) {
141 ret = -EINVAL;
142 goto exit;
143 }
144
145 memcpy(eep, data, len);
146
147 exit:
148 kfree(data);
149
150 return ret;
151 }
152 EXPORT_SYMBOL_GPL(mt76_get_of_data_from_nvmem);
153
mt76_get_of_eeprom(struct mt76_dev * dev,void * eep,int len)154 static int mt76_get_of_eeprom(struct mt76_dev *dev, void *eep, int len)
155 {
156 struct device_node *np = dev->dev->of_node;
157 int ret;
158
159 if (!np)
160 return -ENOENT;
161
162 ret = mt76_get_of_eeprom_data(dev, eep, len);
163 if (!ret)
164 return 0;
165
166 ret = mt76_get_of_data_from_mtd(dev, eep, 0, len);
167 if (!ret)
168 return 0;
169
170 return mt76_get_of_data_from_nvmem(dev, eep, "eeprom", len);
171 }
172
173 int
mt76_eeprom_override(struct mt76_phy * phy)174 mt76_eeprom_override(struct mt76_phy *phy)
175 {
176 struct mt76_dev *dev = phy->dev;
177 struct device_node *np = dev->dev->of_node;
178 int err;
179
180 err = of_get_mac_address(np, phy->macaddr);
181 if (err == -EPROBE_DEFER)
182 return err;
183
184 if (!is_valid_ether_addr(phy->macaddr)) {
185 eth_random_addr(phy->macaddr);
186 dev_info(dev->dev,
187 "Invalid MAC address, using random address %pM\n",
188 phy->macaddr);
189 }
190
191 return 0;
192 }
193 EXPORT_SYMBOL_GPL(mt76_eeprom_override);
194
mt76_string_prop_find(struct property * prop,const char * str)195 static bool mt76_string_prop_find(struct property *prop, const char *str)
196 {
197 const char *cp = NULL;
198
199 if (!prop || !str || !str[0])
200 return false;
201
202 while ((cp = of_prop_next_string(prop, cp)) != NULL)
203 if (!strcasecmp(cp, str))
204 return true;
205
206 return false;
207 }
208
209 struct device_node *
mt76_find_power_limits_node(struct mt76_dev * dev)210 mt76_find_power_limits_node(struct mt76_dev *dev)
211 {
212 struct device_node *np = dev->dev->of_node;
213 const char *const region_names[] = {
214 [NL80211_DFS_UNSET] = "ww",
215 [NL80211_DFS_ETSI] = "etsi",
216 [NL80211_DFS_FCC] = "fcc",
217 [NL80211_DFS_JP] = "jp",
218 };
219 struct device_node *cur, *fallback = NULL;
220 const char *region_name = NULL;
221
222 if (dev->region < ARRAY_SIZE(region_names))
223 region_name = region_names[dev->region];
224
225 np = of_get_child_by_name(np, "power-limits");
226 if (!np)
227 return NULL;
228
229 for_each_child_of_node(np, cur) {
230 struct property *country = of_find_property(cur, "country", NULL);
231 struct property *regd = of_find_property(cur, "regdomain", NULL);
232
233 if (!country && !regd) {
234 fallback = cur;
235 continue;
236 }
237
238 if (mt76_string_prop_find(country, dev->alpha2) ||
239 mt76_string_prop_find(regd, region_name)) {
240 of_node_put(np);
241 return cur;
242 }
243 }
244
245 of_node_put(np);
246 return fallback;
247 }
248 EXPORT_SYMBOL_GPL(mt76_find_power_limits_node);
249
250 static const __be32 *
mt76_get_of_array(struct device_node * np,char * name,size_t * len,int min)251 mt76_get_of_array(struct device_node *np, char *name, size_t *len, int min)
252 {
253 struct property *prop = of_find_property(np, name, NULL);
254
255 if (!prop || !prop->value || prop->length < min * 4)
256 return NULL;
257
258 *len = prop->length;
259
260 return prop->value;
261 }
262
263 static const s8 *
mt76_get_of_array_s8(struct device_node * np,char * name,size_t * len,int min)264 mt76_get_of_array_s8(struct device_node *np, char *name, size_t *len, int min)
265 {
266 struct property *prop = of_find_property(np, name, NULL);
267
268 if (!prop || !prop->value || prop->length < min)
269 return NULL;
270
271 *len = prop->length;
272
273 return prop->value;
274 }
275
276 struct device_node *
mt76_find_channel_node(struct device_node * np,struct ieee80211_channel * chan)277 mt76_find_channel_node(struct device_node *np, struct ieee80211_channel *chan)
278 {
279 struct device_node *cur;
280 const __be32 *val;
281 size_t len;
282
283 for_each_child_of_node(np, cur) {
284 val = mt76_get_of_array(cur, "channels", &len, 2);
285 if (!val)
286 continue;
287
288 while (len >= 2 * sizeof(*val)) {
289 if (chan->hw_value >= be32_to_cpu(val[0]) &&
290 chan->hw_value <= be32_to_cpu(val[1]))
291 return cur;
292
293 val += 2;
294 len -= 2 * sizeof(*val);
295 }
296 }
297
298 return NULL;
299 }
300 EXPORT_SYMBOL_GPL(mt76_find_channel_node);
301
302 static s8
mt76_get_txs_delta(struct device_node * np,u8 nss)303 mt76_get_txs_delta(struct device_node *np, u8 nss)
304 {
305 const __be32 *val;
306 size_t len;
307
308 val = mt76_get_of_array(np, "txs-delta", &len, nss);
309 if (!val)
310 return 0;
311
312 return be32_to_cpu(val[nss - 1]);
313 }
314
mt76_backoff_n_chains(struct mt76_dev * dev,u8 idx)315 static inline u8 mt76_backoff_n_chains(struct mt76_dev *dev, u8 idx)
316 {
317 /* 0:1T1ss, 1:2T1ss, ..., 14:5T5ss */
318 static const u8 connac3_table[] = {
319 1, 2, 3, 4, 5, 2, 3, 4, 5, 3, 4, 5, 4, 5, 5};
320 static const u8 connac2_table[] = {
321 1, 2, 3, 4, 2, 3, 4, 3, 4, 4, 0, 0, 0, 0, 0};
322
323 if (idx >= ARRAY_SIZE(connac3_table))
324 return 0;
325
326 return is_mt799x(dev) ? connac3_table[idx] : connac2_table[idx];
327 }
328
329 static void
mt76_apply_array_limit(struct mt76_dev * dev,s8 * pwr,size_t pwr_len,const s8 * data,s8 target_power,s8 nss_delta,s8 * max_power,int n_chains,enum mt76_sku_type type)330 mt76_apply_array_limit(struct mt76_dev *dev, s8 *pwr, size_t pwr_len,
331 const s8 *data, s8 target_power, s8 nss_delta,
332 s8 *max_power, int n_chains, enum mt76_sku_type type)
333 {
334 int i;
335
336 if (!data)
337 return;
338
339 for (i = 0; i < pwr_len; i++) {
340 u8 backoff_chain_idx = i;
341 int backoff_n_chains;
342 s8 backoff_delta;
343 s8 delta;
344
345 switch (type) {
346 case MT76_SKU_RATE:
347 delta = 0;
348 backoff_delta = 0;
349 backoff_n_chains = 0;
350 break;
351 case MT76_SKU_BACKOFF_BF_OFFSET:
352 backoff_chain_idx += 1;
353 fallthrough;
354 case MT76_SKU_BACKOFF:
355 delta = mt76_tx_power_path_delta(n_chains);
356 backoff_n_chains = mt76_backoff_n_chains(dev, backoff_chain_idx);
357 backoff_delta = mt76_tx_power_path_delta(backoff_n_chains);
358 break;
359 default:
360 return;
361 }
362
363 pwr[i] = min_t(s8, target_power + delta - backoff_delta, data[i] + nss_delta);
364
365 /* used for padding, doesn't need to be considered */
366 if (data[i] >= S8_MAX - 1)
367 continue;
368
369 /* only consider backoff value for the configured chain number */
370 if (type != MT76_SKU_RATE && n_chains != backoff_n_chains)
371 continue;
372
373 *max_power = max(*max_power, pwr[i]);
374 }
375 }
376
377 static void
mt76_apply_multi_array_limit(struct mt76_dev * dev,s8 * pwr,size_t pwr_len,s8 pwr_num,const s8 * data,size_t len,s8 target_power,s8 nss_delta,s8 * max_power,int n_chains,enum mt76_sku_type type)378 mt76_apply_multi_array_limit(struct mt76_dev *dev, s8 *pwr, size_t pwr_len,
379 s8 pwr_num, const s8 *data, size_t len,
380 s8 target_power, s8 nss_delta, s8 *max_power,
381 int n_chains, enum mt76_sku_type type)
382 {
383 static const int connac2_backoff_ru_idx = 2;
384 int i, cur;
385
386 if (!data)
387 return;
388
389 cur = data[0];
390 for (i = 0; i < pwr_num; i++) {
391 if (len < pwr_len + 1)
392 break;
393
394 /* Each RU entry (RU26, RU52, RU106, BW20, ...) in the DTS
395 * corresponds to 10 stream combinations (1T1ss, 2T1ss, 3T1ss,
396 * 4T1ss, 2T2ss, 3T2ss, 4T2ss, 3T3ss, 4T3ss, 4T4ss).
397 *
398 * For beamforming tables:
399 * - In connac2, beamforming entries for BW20~BW160 and OFDM
400 * do not include 1T1ss.
401 * - In connac3, beamforming entries for BW20~BW160 and RU
402 * include 1T1ss, but OFDM beamforming does not include 1T1ss.
403 *
404 * Non-beamforming and RU entries for both connac2 and connac3
405 * include 1T1ss.
406 */
407 if (!is_mt799x(dev) && type == MT76_SKU_BACKOFF &&
408 i > connac2_backoff_ru_idx)
409 type = MT76_SKU_BACKOFF_BF_OFFSET;
410
411 mt76_apply_array_limit(dev, pwr + pwr_len * i, pwr_len, data + 1,
412 target_power, nss_delta, max_power,
413 n_chains, type);
414 if (--cur > 0)
415 continue;
416
417 data += pwr_len + 1;
418 len -= pwr_len + 1;
419 if (!len)
420 break;
421
422 cur = data[0];
423 }
424 }
425
mt76_get_rate_power_limits(struct mt76_phy * phy,struct ieee80211_channel * chan,struct mt76_power_limits * dest,s8 target_power)426 s8 mt76_get_rate_power_limits(struct mt76_phy *phy,
427 struct ieee80211_channel *chan,
428 struct mt76_power_limits *dest,
429 s8 target_power)
430 {
431 struct mt76_dev *dev = phy->dev;
432 struct device_node *np;
433 const s8 *val;
434 char name[16];
435 char band;
436 size_t len;
437 s8 max_power = -127;
438 s8 txs_delta;
439 int n_chains = hweight16(phy->chainmask);
440
441 memset(dest, target_power, sizeof(*dest) - sizeof(dest->path));
442 memset(&dest->path, 0, sizeof(dest->path));
443
444 if (!IS_ENABLED(CONFIG_OF))
445 return target_power;
446
447 np = mt76_find_power_limits_node(dev);
448 if (!np)
449 return target_power;
450
451 switch (chan->band) {
452 case NL80211_BAND_2GHZ:
453 band = '2';
454 break;
455 case NL80211_BAND_5GHZ:
456 band = '5';
457 break;
458 case NL80211_BAND_6GHZ:
459 band = '6';
460 break;
461 default:
462 return target_power;
463 }
464
465 snprintf(name, sizeof(name), "txpower-%cg", band);
466 np = of_get_child_by_name(np, name);
467 if (!np)
468 return target_power;
469
470 np = mt76_find_channel_node(np, chan);
471 if (!np)
472 return target_power;
473
474 txs_delta = mt76_get_txs_delta(np, hweight16(phy->chainmask));
475
476 val = mt76_get_of_array_s8(np, "rates-cck", &len, ARRAY_SIZE(dest->cck));
477 mt76_apply_array_limit(dev, dest->cck, ARRAY_SIZE(dest->cck), val,
478 target_power, txs_delta, &max_power, n_chains, MT76_SKU_RATE);
479
480 val = mt76_get_of_array_s8(np, "rates-ofdm", &len, ARRAY_SIZE(dest->ofdm));
481 mt76_apply_array_limit(dev, dest->ofdm, ARRAY_SIZE(dest->ofdm), val,
482 target_power, txs_delta, &max_power, n_chains, MT76_SKU_RATE);
483
484 val = mt76_get_of_array_s8(np, "rates-mcs", &len, ARRAY_SIZE(dest->mcs[0]) + 1);
485 mt76_apply_multi_array_limit(dev, dest->mcs[0], ARRAY_SIZE(dest->mcs[0]),
486 ARRAY_SIZE(dest->mcs), val, len, target_power,
487 txs_delta, &max_power, n_chains, MT76_SKU_RATE);
488
489 val = mt76_get_of_array_s8(np, "rates-ru", &len, ARRAY_SIZE(dest->ru[0]) + 1);
490 mt76_apply_multi_array_limit(dev, dest->ru[0], ARRAY_SIZE(dest->ru[0]),
491 ARRAY_SIZE(dest->ru), val, len, target_power,
492 txs_delta, &max_power, n_chains, MT76_SKU_RATE);
493
494 val = mt76_get_of_array_s8(np, "paths-cck", &len, ARRAY_SIZE(dest->path.cck));
495 mt76_apply_array_limit(dev, dest->path.cck, ARRAY_SIZE(dest->path.cck), val,
496 target_power, txs_delta, &max_power, n_chains, MT76_SKU_BACKOFF);
497
498 val = mt76_get_of_array_s8(np, "paths-ofdm", &len, ARRAY_SIZE(dest->path.ofdm));
499 mt76_apply_array_limit(dev, dest->path.ofdm, ARRAY_SIZE(dest->path.ofdm), val,
500 target_power, txs_delta, &max_power, n_chains, MT76_SKU_BACKOFF);
501
502 val = mt76_get_of_array_s8(np, "paths-ofdm-bf", &len, ARRAY_SIZE(dest->path.ofdm_bf));
503 mt76_apply_array_limit(dev, dest->path.ofdm_bf, ARRAY_SIZE(dest->path.ofdm_bf), val,
504 target_power, txs_delta, &max_power, n_chains,
505 MT76_SKU_BACKOFF_BF_OFFSET);
506
507 val = mt76_get_of_array_s8(np, "paths-ru", &len, ARRAY_SIZE(dest->path.ru[0]) + 1);
508 mt76_apply_multi_array_limit(dev, dest->path.ru[0], ARRAY_SIZE(dest->path.ru[0]),
509 ARRAY_SIZE(dest->path.ru), val, len, target_power,
510 txs_delta, &max_power, n_chains, MT76_SKU_BACKOFF);
511
512 val = mt76_get_of_array_s8(np, "paths-ru-bf", &len, ARRAY_SIZE(dest->path.ru_bf[0]) + 1);
513 mt76_apply_multi_array_limit(dev, dest->path.ru_bf[0], ARRAY_SIZE(dest->path.ru_bf[0]),
514 ARRAY_SIZE(dest->path.ru_bf), val, len, target_power,
515 txs_delta, &max_power, n_chains, MT76_SKU_BACKOFF);
516
517 return max_power;
518 }
519 EXPORT_SYMBOL_GPL(mt76_get_rate_power_limits);
520
521 int
mt76_eeprom_init(struct mt76_dev * dev,int len)522 mt76_eeprom_init(struct mt76_dev *dev, int len)
523 {
524 dev->eeprom.size = len;
525 dev->eeprom.data = devm_kzalloc(dev->dev, len, GFP_KERNEL);
526 if (!dev->eeprom.data)
527 return -ENOMEM;
528
529 return !mt76_get_of_eeprom(dev, dev->eeprom.data, len);
530 }
531 EXPORT_SYMBOL_GPL(mt76_eeprom_init);
532