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 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 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 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 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 int 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 int err; 172 173 err = of_get_mac_address(np, phy->macaddr); 174 if (err == -EPROBE_DEFER) 175 return err; 176 177 if (!is_valid_ether_addr(phy->macaddr)) { 178 eth_random_addr(phy->macaddr); 179 dev_info(dev->dev, 180 "Invalid MAC address, using random address %pM\n", 181 phy->macaddr); 182 } 183 184 return 0; 185 } 186 EXPORT_SYMBOL_GPL(mt76_eeprom_override); 187 188 static bool mt76_string_prop_find(struct property *prop, const char *str) 189 { 190 const char *cp = NULL; 191 192 if (!prop || !str || !str[0]) 193 return false; 194 195 while ((cp = of_prop_next_string(prop, cp)) != NULL) 196 if (!strcasecmp(cp, str)) 197 return true; 198 199 return false; 200 } 201 202 struct device_node * 203 mt76_find_power_limits_node(struct mt76_dev *dev) 204 { 205 struct device_node *np = dev->dev->of_node; 206 const char *const region_names[] = { 207 [NL80211_DFS_UNSET] = "ww", 208 [NL80211_DFS_ETSI] = "etsi", 209 [NL80211_DFS_FCC] = "fcc", 210 [NL80211_DFS_JP] = "jp", 211 }; 212 struct device_node *cur, *fallback = NULL; 213 const char *region_name = NULL; 214 215 if (dev->region < ARRAY_SIZE(region_names)) 216 region_name = region_names[dev->region]; 217 218 np = of_get_child_by_name(np, "power-limits"); 219 if (!np) 220 return NULL; 221 222 for_each_child_of_node(np, cur) { 223 struct property *country = of_find_property(cur, "country", NULL); 224 struct property *regd = of_find_property(cur, "regdomain", NULL); 225 226 if (!country && !regd) { 227 fallback = cur; 228 continue; 229 } 230 231 if (mt76_string_prop_find(country, dev->alpha2) || 232 mt76_string_prop_find(regd, region_name)) { 233 of_node_put(np); 234 return cur; 235 } 236 } 237 238 of_node_put(np); 239 return fallback; 240 } 241 EXPORT_SYMBOL_GPL(mt76_find_power_limits_node); 242 243 static const __be32 * 244 mt76_get_of_array(struct device_node *np, char *name, size_t *len, int min) 245 { 246 struct property *prop = of_find_property(np, name, NULL); 247 248 if (!prop || !prop->value || prop->length < min * 4) 249 return NULL; 250 251 *len = prop->length; 252 253 return prop->value; 254 } 255 256 static const s8 * 257 mt76_get_of_array_s8(struct device_node *np, char *name, size_t *len, int min) 258 { 259 struct property *prop = of_find_property(np, name, NULL); 260 261 if (!prop || !prop->value || prop->length < min) 262 return NULL; 263 264 *len = prop->length; 265 266 return prop->value; 267 } 268 269 struct device_node * 270 mt76_find_channel_node(struct device_node *np, struct ieee80211_channel *chan) 271 { 272 struct device_node *cur; 273 const __be32 *val; 274 size_t len; 275 276 for_each_child_of_node(np, cur) { 277 val = mt76_get_of_array(cur, "channels", &len, 2); 278 if (!val) 279 continue; 280 281 while (len >= 2 * sizeof(*val)) { 282 if (chan->hw_value >= be32_to_cpu(val[0]) && 283 chan->hw_value <= be32_to_cpu(val[1])) 284 return cur; 285 286 val += 2; 287 len -= 2 * sizeof(*val); 288 } 289 } 290 291 return NULL; 292 } 293 EXPORT_SYMBOL_GPL(mt76_find_channel_node); 294 295 296 static s8 297 mt76_get_txs_delta(struct device_node *np, u8 nss) 298 { 299 const __be32 *val; 300 size_t len; 301 302 val = mt76_get_of_array(np, "txs-delta", &len, nss); 303 if (!val) 304 return 0; 305 306 return be32_to_cpu(val[nss - 1]); 307 } 308 309 static void 310 mt76_apply_array_limit(s8 *pwr, size_t pwr_len, const s8 *data, 311 s8 target_power, s8 nss_delta, s8 *max_power) 312 { 313 int i; 314 315 if (!data) 316 return; 317 318 for (i = 0; i < pwr_len; i++) { 319 pwr[i] = min_t(s8, target_power, data[i] + nss_delta); 320 *max_power = max(*max_power, pwr[i]); 321 } 322 } 323 324 static void 325 mt76_apply_multi_array_limit(s8 *pwr, size_t pwr_len, s8 pwr_num, 326 const s8 *data, size_t len, s8 target_power, 327 s8 nss_delta) 328 { 329 int i, cur; 330 s8 max_power = -128; 331 332 if (!data) 333 return; 334 335 cur = data[0]; 336 for (i = 0; i < pwr_num; i++) { 337 if (len < pwr_len + 1) 338 break; 339 340 mt76_apply_array_limit(pwr + pwr_len * i, pwr_len, data + 1, 341 target_power, nss_delta, &max_power); 342 if (--cur > 0) 343 continue; 344 345 data += pwr_len + 1; 346 len -= pwr_len + 1; 347 if (!len) 348 break; 349 350 cur = data[0]; 351 } 352 } 353 354 s8 mt76_get_rate_power_limits(struct mt76_phy *phy, 355 struct ieee80211_channel *chan, 356 struct mt76_power_limits *dest, 357 s8 target_power) 358 { 359 struct mt76_dev *dev = phy->dev; 360 struct device_node *np; 361 const s8 *val; 362 char name[16]; 363 u32 mcs_rates = dev->drv->mcs_rates; 364 u32 ru_rates = ARRAY_SIZE(dest->ru[0]); 365 char band; 366 size_t len; 367 s8 max_power = 0; 368 s8 max_power_backoff = -127; 369 s8 txs_delta; 370 int n_chains = hweight16(phy->chainmask); 371 s8 target_power_combine = target_power + mt76_tx_power_path_delta(n_chains); 372 373 if (!mcs_rates) 374 mcs_rates = 10; 375 376 memset(dest, target_power, sizeof(*dest) - sizeof(dest->path)); 377 memset(&dest->path, 0, sizeof(dest->path)); 378 379 if (!IS_ENABLED(CONFIG_OF)) 380 return target_power; 381 382 np = mt76_find_power_limits_node(dev); 383 if (!np) 384 return target_power; 385 386 switch (chan->band) { 387 case NL80211_BAND_2GHZ: 388 band = '2'; 389 break; 390 case NL80211_BAND_5GHZ: 391 band = '5'; 392 break; 393 case NL80211_BAND_6GHZ: 394 band = '6'; 395 break; 396 default: 397 return target_power; 398 } 399 400 snprintf(name, sizeof(name), "txpower-%cg", band); 401 np = of_get_child_by_name(np, name); 402 if (!np) 403 return target_power; 404 405 np = mt76_find_channel_node(np, chan); 406 if (!np) 407 return target_power; 408 409 txs_delta = mt76_get_txs_delta(np, hweight16(phy->chainmask)); 410 411 val = mt76_get_of_array_s8(np, "rates-cck", &len, ARRAY_SIZE(dest->cck)); 412 mt76_apply_array_limit(dest->cck, ARRAY_SIZE(dest->cck), val, 413 target_power, txs_delta, &max_power); 414 415 val = mt76_get_of_array_s8(np, "rates-ofdm", 416 &len, ARRAY_SIZE(dest->ofdm)); 417 mt76_apply_array_limit(dest->ofdm, ARRAY_SIZE(dest->ofdm), val, 418 target_power, txs_delta, &max_power); 419 420 val = mt76_get_of_array_s8(np, "rates-mcs", &len, mcs_rates + 1); 421 mt76_apply_multi_array_limit(dest->mcs[0], ARRAY_SIZE(dest->mcs[0]), 422 ARRAY_SIZE(dest->mcs), val, len, 423 target_power, txs_delta); 424 425 val = mt76_get_of_array_s8(np, "rates-ru", &len, ru_rates + 1); 426 mt76_apply_multi_array_limit(dest->ru[0], ARRAY_SIZE(dest->ru[0]), 427 ARRAY_SIZE(dest->ru), val, len, 428 target_power, txs_delta); 429 430 max_power_backoff = max_power; 431 val = mt76_get_of_array_s8(np, "paths-cck", &len, ARRAY_SIZE(dest->path.cck)); 432 mt76_apply_array_limit(dest->path.cck, ARRAY_SIZE(dest->path.cck), val, 433 target_power_combine, txs_delta, &max_power_backoff); 434 435 val = mt76_get_of_array_s8(np, "paths-ofdm", &len, ARRAY_SIZE(dest->path.ofdm)); 436 mt76_apply_array_limit(dest->path.ofdm, ARRAY_SIZE(dest->path.ofdm), val, 437 target_power_combine, txs_delta, &max_power_backoff); 438 439 val = mt76_get_of_array_s8(np, "paths-ofdm-bf", &len, ARRAY_SIZE(dest->path.ofdm_bf)); 440 mt76_apply_array_limit(dest->path.ofdm_bf, ARRAY_SIZE(dest->path.ofdm_bf), val, 441 target_power_combine, txs_delta, &max_power_backoff); 442 443 val = mt76_get_of_array_s8(np, "paths-ru", &len, ARRAY_SIZE(dest->path.ru[0]) + 1); 444 mt76_apply_multi_array_limit(dest->path.ru[0], ARRAY_SIZE(dest->path.ru[0]), 445 ARRAY_SIZE(dest->path.ru), val, len, 446 target_power_combine, txs_delta); 447 448 val = mt76_get_of_array_s8(np, "paths-ru-bf", &len, ARRAY_SIZE(dest->path.ru_bf[0]) + 1); 449 mt76_apply_multi_array_limit(dest->path.ru_bf[0], ARRAY_SIZE(dest->path.ru_bf[0]), 450 ARRAY_SIZE(dest->path.ru_bf), val, len, 451 target_power_combine, txs_delta); 452 453 return max_power; 454 } 455 EXPORT_SYMBOL_GPL(mt76_get_rate_power_limits); 456 457 int 458 mt76_eeprom_init(struct mt76_dev *dev, int len) 459 { 460 dev->eeprom.size = len; 461 dev->eeprom.data = devm_kzalloc(dev->dev, len, GFP_KERNEL); 462 if (!dev->eeprom.data) 463 return -ENOMEM; 464 465 return !mt76_get_of_eeprom(dev, dev->eeprom.data, len); 466 } 467 EXPORT_SYMBOL_GPL(mt76_eeprom_init); 468