1 // SPDX-License-Identifier: ISC
2 /*
3 * Copyright (C) 2016 Felix Fietkau <[email protected]>
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
mt76_get_of_eeprom_data(struct mt76_dev * dev,void * eep,int len)13 static int mt76_get_of_eeprom_data(struct mt76_dev *dev, void *eep, int len)
14 {
15 struct device_node *np = dev->dev->of_node;
16 const void *data;
17 int size;
18
19 data = of_get_property(np, "mediatek,eeprom-data", &size);
20 if (!data)
21 return -ENOENT;
22
23 if (size > len)
24 return -EINVAL;
25
26 memcpy(eep, data, size);
27
28 return 0;
29 }
30
mt76_get_of_data_from_mtd(struct mt76_dev * dev,void * eep,int offset,int len)31 int mt76_get_of_data_from_mtd(struct mt76_dev *dev, void *eep, int offset, int len)
32 {
33 #ifdef CONFIG_MTD
34 struct device_node *np = dev->dev->of_node;
35 struct mtd_info *mtd;
36 const __be32 *list;
37 const char *part;
38 phandle phandle;
39 size_t retlen;
40 int size;
41 int ret;
42
43 list = of_get_property(np, "mediatek,mtd-eeprom", &size);
44 if (!list)
45 return -ENOENT;
46
47 phandle = be32_to_cpup(list++);
48 if (!phandle)
49 return -ENOENT;
50
51 np = of_find_node_by_phandle(phandle);
52 if (!np)
53 return -EINVAL;
54
55 part = of_get_property(np, "label", NULL);
56 if (!part)
57 part = np->name;
58
59 mtd = get_mtd_device_nm(part);
60 if (IS_ERR(mtd)) {
61 ret = PTR_ERR(mtd);
62 goto out_put_node;
63 }
64
65 if (size <= sizeof(*list)) {
66 ret = -EINVAL;
67 goto out_put_node;
68 }
69
70 offset += be32_to_cpup(list);
71 ret = mtd_read(mtd, offset, len, &retlen, eep);
72 put_mtd_device(mtd);
73 if (mtd_is_bitflip(ret))
74 ret = 0;
75 if (ret) {
76 dev_err(dev->dev, "reading EEPROM from mtd %s failed: %i\n",
77 part, ret);
78 goto out_put_node;
79 }
80
81 if (retlen < len) {
82 ret = -EINVAL;
83 goto out_put_node;
84 }
85
86 if (of_property_read_bool(dev->dev->of_node, "big-endian")) {
87 u8 *data = (u8 *)eep;
88 int i;
89
90 /* convert eeprom data in Little Endian */
91 for (i = 0; i < round_down(len, 2); i += 2)
92 put_unaligned_le16(get_unaligned_be16(&data[i]),
93 &data[i]);
94 }
95
96 #ifdef CONFIG_NL80211_TESTMODE
97 dev->test_mtd.name = devm_kstrdup(dev->dev, part, GFP_KERNEL);
98 if (!dev->test_mtd.name) {
99 ret = -ENOMEM;
100 goto out_put_node;
101 }
102 dev->test_mtd.offset = offset;
103 #endif
104
105 out_put_node:
106 of_node_put(np);
107 return ret;
108 #else
109 return -ENOENT;
110 #endif
111 }
112 EXPORT_SYMBOL_GPL(mt76_get_of_data_from_mtd);
113
mt76_get_of_data_from_nvmem(struct mt76_dev * dev,void * eep,const char * cell_name,int len)114 int mt76_get_of_data_from_nvmem(struct mt76_dev *dev, void *eep,
115 const char *cell_name, int len)
116 {
117 struct device_node *np = dev->dev->of_node;
118 struct nvmem_cell *cell;
119 const void *data;
120 size_t retlen;
121 int ret = 0;
122
123 cell = of_nvmem_cell_get(np, cell_name);
124 if (IS_ERR(cell))
125 return PTR_ERR(cell);
126
127 data = nvmem_cell_read(cell, &retlen);
128 nvmem_cell_put(cell);
129
130 if (IS_ERR(data))
131 return PTR_ERR(data);
132
133 if (retlen < len) {
134 ret = -EINVAL;
135 goto exit;
136 }
137
138 memcpy(eep, data, len);
139
140 exit:
141 kfree(data);
142
143 return ret;
144 }
145 EXPORT_SYMBOL_GPL(mt76_get_of_data_from_nvmem);
146
mt76_get_of_eeprom(struct mt76_dev * dev,void * eep,int len)147 static int mt76_get_of_eeprom(struct mt76_dev *dev, void *eep, int len)
148 {
149 struct device_node *np = dev->dev->of_node;
150 int ret;
151
152 if (!np)
153 return -ENOENT;
154
155 ret = mt76_get_of_eeprom_data(dev, eep, len);
156 if (!ret)
157 return 0;
158
159 ret = mt76_get_of_data_from_mtd(dev, eep, 0, len);
160 if (!ret)
161 return 0;
162
163 return mt76_get_of_data_from_nvmem(dev, eep, "eeprom", len);
164 }
165
166 void
mt76_eeprom_override(struct mt76_phy * phy)167 mt76_eeprom_override(struct mt76_phy *phy)
168 {
169 struct mt76_dev *dev = phy->dev;
170 struct device_node *np = dev->dev->of_node;
171
172 of_get_mac_address(np, phy->macaddr);
173
174 if (!is_valid_ether_addr(phy->macaddr)) {
175 eth_random_addr(phy->macaddr);
176 dev_info(dev->dev,
177 "Invalid MAC address, using random address %pM\n",
178 phy->macaddr);
179 }
180 }
181 EXPORT_SYMBOL_GPL(mt76_eeprom_override);
182
mt76_string_prop_find(struct property * prop,const char * str)183 static bool mt76_string_prop_find(struct property *prop, const char *str)
184 {
185 const char *cp = NULL;
186
187 if (!prop || !str || !str[0])
188 return false;
189
190 while ((cp = of_prop_next_string(prop, cp)) != NULL)
191 if (!strcasecmp(cp, str))
192 return true;
193
194 return false;
195 }
196
197 struct device_node *
mt76_find_power_limits_node(struct mt76_dev * dev)198 mt76_find_power_limits_node(struct mt76_dev *dev)
199 {
200 struct device_node *np = dev->dev->of_node;
201 const char *const region_names[] = {
202 [NL80211_DFS_UNSET] = "ww",
203 [NL80211_DFS_ETSI] = "etsi",
204 [NL80211_DFS_FCC] = "fcc",
205 [NL80211_DFS_JP] = "jp",
206 };
207 struct device_node *cur, *fallback = NULL;
208 const char *region_name = NULL;
209
210 if (dev->region < ARRAY_SIZE(region_names))
211 region_name = region_names[dev->region];
212
213 np = of_get_child_by_name(np, "power-limits");
214 if (!np)
215 return NULL;
216
217 for_each_child_of_node(np, cur) {
218 struct property *country = of_find_property(cur, "country", NULL);
219 struct property *regd = of_find_property(cur, "regdomain", NULL);
220
221 if (!country && !regd) {
222 fallback = cur;
223 continue;
224 }
225
226 if (mt76_string_prop_find(country, dev->alpha2) ||
227 mt76_string_prop_find(regd, region_name)) {
228 of_node_put(np);
229 return cur;
230 }
231 }
232
233 of_node_put(np);
234 return fallback;
235 }
236 EXPORT_SYMBOL_GPL(mt76_find_power_limits_node);
237
238 static const __be32 *
mt76_get_of_array(struct device_node * np,char * name,size_t * len,int min)239 mt76_get_of_array(struct device_node *np, char *name, size_t *len, int min)
240 {
241 struct property *prop = of_find_property(np, name, NULL);
242
243 if (!prop || !prop->value || prop->length < min * 4)
244 return NULL;
245
246 *len = prop->length;
247
248 return prop->value;
249 }
250
251 struct device_node *
mt76_find_channel_node(struct device_node * np,struct ieee80211_channel * chan)252 mt76_find_channel_node(struct device_node *np, struct ieee80211_channel *chan)
253 {
254 struct device_node *cur;
255 const __be32 *val;
256 size_t len;
257
258 for_each_child_of_node(np, cur) {
259 val = mt76_get_of_array(cur, "channels", &len, 2);
260 if (!val)
261 continue;
262
263 while (len >= 2 * sizeof(*val)) {
264 if (chan->hw_value >= be32_to_cpu(val[0]) &&
265 chan->hw_value <= be32_to_cpu(val[1]))
266 return cur;
267
268 val += 2;
269 len -= 2 * sizeof(*val);
270 }
271 }
272
273 return NULL;
274 }
275 EXPORT_SYMBOL_GPL(mt76_find_channel_node);
276
277
278 static s8
mt76_get_txs_delta(struct device_node * np,u8 nss)279 mt76_get_txs_delta(struct device_node *np, u8 nss)
280 {
281 const __be32 *val;
282 size_t len;
283
284 val = mt76_get_of_array(np, "txs-delta", &len, nss);
285 if (!val)
286 return 0;
287
288 return be32_to_cpu(val[nss - 1]);
289 }
290
291 static void
mt76_apply_array_limit(s8 * pwr,size_t pwr_len,const __be32 * data,s8 target_power,s8 nss_delta,s8 * max_power)292 mt76_apply_array_limit(s8 *pwr, size_t pwr_len, const __be32 *data,
293 s8 target_power, s8 nss_delta, s8 *max_power)
294 {
295 int i;
296
297 if (!data)
298 return;
299
300 for (i = 0; i < pwr_len; i++) {
301 pwr[i] = min_t(s8, target_power,
302 be32_to_cpu(data[i]) + nss_delta);
303 *max_power = max(*max_power, pwr[i]);
304 }
305 }
306
307 static void
mt76_apply_multi_array_limit(s8 * pwr,size_t pwr_len,s8 pwr_num,const __be32 * data,size_t len,s8 target_power,s8 nss_delta,s8 * max_power)308 mt76_apply_multi_array_limit(s8 *pwr, size_t pwr_len, s8 pwr_num,
309 const __be32 *data, size_t len, s8 target_power,
310 s8 nss_delta, s8 *max_power)
311 {
312 int i, cur;
313
314 if (!data)
315 return;
316
317 len /= 4;
318 cur = be32_to_cpu(data[0]);
319 for (i = 0; i < pwr_num; i++) {
320 if (len < pwr_len + 1)
321 break;
322
323 mt76_apply_array_limit(pwr + pwr_len * i, pwr_len, data + 1,
324 target_power, nss_delta, max_power);
325 if (--cur > 0)
326 continue;
327
328 data += pwr_len + 1;
329 len -= pwr_len + 1;
330 if (!len)
331 break;
332
333 cur = be32_to_cpu(data[0]);
334 }
335 }
336
mt76_get_rate_power_limits(struct mt76_phy * phy,struct ieee80211_channel * chan,struct mt76_power_limits * dest,s8 target_power)337 s8 mt76_get_rate_power_limits(struct mt76_phy *phy,
338 struct ieee80211_channel *chan,
339 struct mt76_power_limits *dest,
340 s8 target_power)
341 {
342 struct mt76_dev *dev = phy->dev;
343 struct device_node *np;
344 const __be32 *val;
345 char name[16];
346 u32 mcs_rates = dev->drv->mcs_rates;
347 u32 ru_rates = ARRAY_SIZE(dest->ru[0]);
348 char band;
349 size_t len;
350 s8 max_power = 0;
351 s8 txs_delta;
352
353 if (!mcs_rates)
354 mcs_rates = 10;
355
356 memset(dest, target_power, sizeof(*dest));
357
358 if (!IS_ENABLED(CONFIG_OF))
359 return target_power;
360
361 np = mt76_find_power_limits_node(dev);
362 if (!np)
363 return target_power;
364
365 switch (chan->band) {
366 case NL80211_BAND_2GHZ:
367 band = '2';
368 break;
369 case NL80211_BAND_5GHZ:
370 band = '5';
371 break;
372 case NL80211_BAND_6GHZ:
373 band = '6';
374 break;
375 default:
376 return target_power;
377 }
378
379 snprintf(name, sizeof(name), "txpower-%cg", band);
380 np = of_get_child_by_name(np, name);
381 if (!np)
382 return target_power;
383
384 np = mt76_find_channel_node(np, chan);
385 if (!np)
386 return target_power;
387
388 txs_delta = mt76_get_txs_delta(np, hweight16(phy->chainmask));
389
390 val = mt76_get_of_array(np, "rates-cck", &len, ARRAY_SIZE(dest->cck));
391 mt76_apply_array_limit(dest->cck, ARRAY_SIZE(dest->cck), val,
392 target_power, txs_delta, &max_power);
393
394 val = mt76_get_of_array(np, "rates-ofdm",
395 &len, ARRAY_SIZE(dest->ofdm));
396 mt76_apply_array_limit(dest->ofdm, ARRAY_SIZE(dest->ofdm), val,
397 target_power, txs_delta, &max_power);
398
399 val = mt76_get_of_array(np, "rates-mcs", &len, mcs_rates + 1);
400 mt76_apply_multi_array_limit(dest->mcs[0], ARRAY_SIZE(dest->mcs[0]),
401 ARRAY_SIZE(dest->mcs), val, len,
402 target_power, txs_delta, &max_power);
403
404 val = mt76_get_of_array(np, "rates-ru", &len, ru_rates + 1);
405 mt76_apply_multi_array_limit(dest->ru[0], ARRAY_SIZE(dest->ru[0]),
406 ARRAY_SIZE(dest->ru), val, len,
407 target_power, txs_delta, &max_power);
408
409 return max_power;
410 }
411 EXPORT_SYMBOL_GPL(mt76_get_rate_power_limits);
412
413 int
mt76_eeprom_init(struct mt76_dev * dev,int len)414 mt76_eeprom_init(struct mt76_dev *dev, int len)
415 {
416 dev->eeprom.size = len;
417 dev->eeprom.data = devm_kzalloc(dev->dev, len, GFP_KERNEL);
418 if (!dev->eeprom.data)
419 return -ENOMEM;
420
421 return !mt76_get_of_eeprom(dev, dev->eeprom.data, len);
422 }
423 EXPORT_SYMBOL_GPL(mt76_eeprom_init);
424