420 lines · c
1// SPDX-License-Identifier: ISC2/*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 13static 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 31int mt76_get_of_data_from_mtd(struct mt76_dev *dev, void *eep, int offset, int len)32{33#ifdef CONFIG_MTD34 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_TESTMODE97 dev->test_mtd.name = devm_kstrdup(dev->dev, part, GFP_KERNEL);98 dev->test_mtd.offset = offset;99#endif100 101out_put_node:102 of_node_put(np);103 return ret;104#else105 return -ENOENT;106#endif107}108EXPORT_SYMBOL_GPL(mt76_get_of_data_from_mtd);109 110int mt76_get_of_data_from_nvmem(struct mt76_dev *dev, void *eep,111 const char *cell_name, int len)112{113 struct device_node *np = dev->dev->of_node;114 struct nvmem_cell *cell;115 const void *data;116 size_t retlen;117 int ret = 0;118 119 cell = of_nvmem_cell_get(np, cell_name);120 if (IS_ERR(cell))121 return PTR_ERR(cell);122 123 data = nvmem_cell_read(cell, &retlen);124 nvmem_cell_put(cell);125 126 if (IS_ERR(data))127 return PTR_ERR(data);128 129 if (retlen < len) {130 ret = -EINVAL;131 goto exit;132 }133 134 memcpy(eep, data, len);135 136exit:137 kfree(data);138 139 return ret;140}141EXPORT_SYMBOL_GPL(mt76_get_of_data_from_nvmem);142 143static int mt76_get_of_eeprom(struct mt76_dev *dev, void *eep, int len)144{145 struct device_node *np = dev->dev->of_node;146 int ret;147 148 if (!np)149 return -ENOENT;150 151 ret = mt76_get_of_eeprom_data(dev, eep, len);152 if (!ret)153 return 0;154 155 ret = mt76_get_of_data_from_mtd(dev, eep, 0, len);156 if (!ret)157 return 0;158 159 return mt76_get_of_data_from_nvmem(dev, eep, "eeprom", len);160}161 162void163mt76_eeprom_override(struct mt76_phy *phy)164{165 struct mt76_dev *dev = phy->dev;166 struct device_node *np = dev->dev->of_node;167 168 of_get_mac_address(np, phy->macaddr);169 170 if (!is_valid_ether_addr(phy->macaddr)) {171 eth_random_addr(phy->macaddr);172 dev_info(dev->dev,173 "Invalid MAC address, using random address %pM\n",174 phy->macaddr);175 }176}177EXPORT_SYMBOL_GPL(mt76_eeprom_override);178 179static bool mt76_string_prop_find(struct property *prop, const char *str)180{181 const char *cp = NULL;182 183 if (!prop || !str || !str[0])184 return false;185 186 while ((cp = of_prop_next_string(prop, cp)) != NULL)187 if (!strcasecmp(cp, str))188 return true;189 190 return false;191}192 193struct device_node *194mt76_find_power_limits_node(struct mt76_dev *dev)195{196 struct device_node *np = dev->dev->of_node;197 const char *const region_names[] = {198 [NL80211_DFS_UNSET] = "ww",199 [NL80211_DFS_ETSI] = "etsi",200 [NL80211_DFS_FCC] = "fcc",201 [NL80211_DFS_JP] = "jp",202 };203 struct device_node *cur, *fallback = NULL;204 const char *region_name = NULL;205 206 if (dev->region < ARRAY_SIZE(region_names))207 region_name = region_names[dev->region];208 209 np = of_get_child_by_name(np, "power-limits");210 if (!np)211 return NULL;212 213 for_each_child_of_node(np, cur) {214 struct property *country = of_find_property(cur, "country", NULL);215 struct property *regd = of_find_property(cur, "regdomain", NULL);216 217 if (!country && !regd) {218 fallback = cur;219 continue;220 }221 222 if (mt76_string_prop_find(country, dev->alpha2) ||223 mt76_string_prop_find(regd, region_name)) {224 of_node_put(np);225 return cur;226 }227 }228 229 of_node_put(np);230 return fallback;231}232EXPORT_SYMBOL_GPL(mt76_find_power_limits_node);233 234static const __be32 *235mt76_get_of_array(struct device_node *np, char *name, size_t *len, int min)236{237 struct property *prop = of_find_property(np, name, NULL);238 239 if (!prop || !prop->value || prop->length < min * 4)240 return NULL;241 242 *len = prop->length;243 244 return prop->value;245}246 247struct device_node *248mt76_find_channel_node(struct device_node *np, struct ieee80211_channel *chan)249{250 struct device_node *cur;251 const __be32 *val;252 size_t len;253 254 for_each_child_of_node(np, cur) {255 val = mt76_get_of_array(cur, "channels", &len, 2);256 if (!val)257 continue;258 259 while (len >= 2 * sizeof(*val)) {260 if (chan->hw_value >= be32_to_cpu(val[0]) &&261 chan->hw_value <= be32_to_cpu(val[1]))262 return cur;263 264 val += 2;265 len -= 2 * sizeof(*val);266 }267 }268 269 return NULL;270}271EXPORT_SYMBOL_GPL(mt76_find_channel_node);272 273 274static s8275mt76_get_txs_delta(struct device_node *np, u8 nss)276{277 const __be32 *val;278 size_t len;279 280 val = mt76_get_of_array(np, "txs-delta", &len, nss);281 if (!val)282 return 0;283 284 return be32_to_cpu(val[nss - 1]);285}286 287static void288mt76_apply_array_limit(s8 *pwr, size_t pwr_len, const __be32 *data,289 s8 target_power, s8 nss_delta, s8 *max_power)290{291 int i;292 293 if (!data)294 return;295 296 for (i = 0; i < pwr_len; i++) {297 pwr[i] = min_t(s8, target_power,298 be32_to_cpu(data[i]) + nss_delta);299 *max_power = max(*max_power, pwr[i]);300 }301}302 303static void304mt76_apply_multi_array_limit(s8 *pwr, size_t pwr_len, s8 pwr_num,305 const __be32 *data, size_t len, s8 target_power,306 s8 nss_delta, s8 *max_power)307{308 int i, cur;309 310 if (!data)311 return;312 313 len /= 4;314 cur = be32_to_cpu(data[0]);315 for (i = 0; i < pwr_num; i++) {316 if (len < pwr_len + 1)317 break;318 319 mt76_apply_array_limit(pwr + pwr_len * i, pwr_len, data + 1,320 target_power, nss_delta, max_power);321 if (--cur > 0)322 continue;323 324 data += pwr_len + 1;325 len -= pwr_len + 1;326 if (!len)327 break;328 329 cur = be32_to_cpu(data[0]);330 }331}332 333s8 mt76_get_rate_power_limits(struct mt76_phy *phy,334 struct ieee80211_channel *chan,335 struct mt76_power_limits *dest,336 s8 target_power)337{338 struct mt76_dev *dev = phy->dev;339 struct device_node *np;340 const __be32 *val;341 char name[16];342 u32 mcs_rates = dev->drv->mcs_rates;343 u32 ru_rates = ARRAY_SIZE(dest->ru[0]);344 char band;345 size_t len;346 s8 max_power = 0;347 s8 txs_delta;348 349 if (!mcs_rates)350 mcs_rates = 10;351 352 memset(dest, target_power, sizeof(*dest));353 354 if (!IS_ENABLED(CONFIG_OF))355 return target_power;356 357 np = mt76_find_power_limits_node(dev);358 if (!np)359 return target_power;360 361 switch (chan->band) {362 case NL80211_BAND_2GHZ:363 band = '2';364 break;365 case NL80211_BAND_5GHZ:366 band = '5';367 break;368 case NL80211_BAND_6GHZ:369 band = '6';370 break;371 default:372 return target_power;373 }374 375 snprintf(name, sizeof(name), "txpower-%cg", band);376 np = of_get_child_by_name(np, name);377 if (!np)378 return target_power;379 380 np = mt76_find_channel_node(np, chan);381 if (!np)382 return target_power;383 384 txs_delta = mt76_get_txs_delta(np, hweight16(phy->chainmask));385 386 val = mt76_get_of_array(np, "rates-cck", &len, ARRAY_SIZE(dest->cck));387 mt76_apply_array_limit(dest->cck, ARRAY_SIZE(dest->cck), val,388 target_power, txs_delta, &max_power);389 390 val = mt76_get_of_array(np, "rates-ofdm",391 &len, ARRAY_SIZE(dest->ofdm));392 mt76_apply_array_limit(dest->ofdm, ARRAY_SIZE(dest->ofdm), val,393 target_power, txs_delta, &max_power);394 395 val = mt76_get_of_array(np, "rates-mcs", &len, mcs_rates + 1);396 mt76_apply_multi_array_limit(dest->mcs[0], ARRAY_SIZE(dest->mcs[0]),397 ARRAY_SIZE(dest->mcs), val, len,398 target_power, txs_delta, &max_power);399 400 val = mt76_get_of_array(np, "rates-ru", &len, ru_rates + 1);401 mt76_apply_multi_array_limit(dest->ru[0], ARRAY_SIZE(dest->ru[0]),402 ARRAY_SIZE(dest->ru), val, len,403 target_power, txs_delta, &max_power);404 405 return max_power;406}407EXPORT_SYMBOL_GPL(mt76_get_rate_power_limits);408 409int410mt76_eeprom_init(struct mt76_dev *dev, int len)411{412 dev->eeprom.size = len;413 dev->eeprom.data = devm_kzalloc(dev->dev, len, GFP_KERNEL);414 if (!dev->eeprom.data)415 return -ENOMEM;416 417 return !mt76_get_of_eeprom(dev, dev->eeprom.data, len);418}419EXPORT_SYMBOL_GPL(mt76_eeprom_init);420