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 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 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 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 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 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 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 * 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 of_node_put(fallback); 235 fallback = of_node_get(cur); 236 continue; 237 } 238 239 if (mt76_string_prop_find(country, dev->alpha2) || 240 mt76_string_prop_find(regd, region_name)) { 241 of_node_put(fallback); 242 of_node_put(np); 243 return cur; 244 } 245 } 246 247 of_node_put(np); 248 return fallback; 249 } 250 EXPORT_SYMBOL_GPL(mt76_find_power_limits_node); 251 252 static const __be32 * 253 mt76_get_of_array(struct device_node *np, char *name, size_t *len, int min) 254 { 255 struct property *prop = of_find_property(np, name, NULL); 256 257 if (!prop || !prop->value || prop->length < min * 4) 258 return NULL; 259 260 *len = prop->length; 261 262 return prop->value; 263 } 264 265 static const s8 * 266 mt76_get_of_array_s8(struct device_node *np, char *name, size_t *len, int min) 267 { 268 struct property *prop = of_find_property(np, name, NULL); 269 270 if (!prop || !prop->value || prop->length < min) 271 return NULL; 272 273 *len = prop->length; 274 275 return prop->value; 276 } 277 278 struct device_node * 279 mt76_find_channel_node(struct device_node *np, struct ieee80211_channel *chan) 280 { 281 struct device_node *cur; 282 const __be32 *val; 283 size_t len; 284 285 for_each_child_of_node(np, cur) { 286 val = mt76_get_of_array(cur, "channels", &len, 2); 287 if (!val) 288 continue; 289 290 while (len >= 2 * sizeof(*val)) { 291 if (chan->hw_value >= be32_to_cpu(val[0]) && 292 chan->hw_value <= be32_to_cpu(val[1])) 293 return cur; 294 295 val += 2; 296 len -= 2 * sizeof(*val); 297 } 298 } 299 300 return NULL; 301 } 302 EXPORT_SYMBOL_GPL(mt76_find_channel_node); 303 304 static s8 305 mt76_get_txs_delta(struct device_node *np, u8 nss) 306 { 307 const __be32 *val; 308 size_t len; 309 310 val = mt76_get_of_array(np, "txs-delta", &len, nss); 311 if (!val) 312 return 0; 313 314 return be32_to_cpu(val[nss - 1]); 315 } 316 317 static inline u8 mt76_backoff_n_chains(struct mt76_dev *dev, u8 idx) 318 { 319 /* 0:1T1ss, 1:2T1ss, ..., 14:5T5ss */ 320 static const u8 connac3_table[] = { 321 1, 2, 3, 4, 5, 2, 3, 4, 5, 3, 4, 5, 4, 5, 5}; 322 static const u8 connac2_table[] = { 323 1, 2, 3, 4, 2, 3, 4, 3, 4, 4, 0, 0, 0, 0, 0}; 324 325 if (idx >= ARRAY_SIZE(connac3_table)) 326 return 0; 327 328 return is_mt799x(dev) ? connac3_table[idx] : connac2_table[idx]; 329 } 330 331 static void 332 mt76_apply_array_limit(struct mt76_dev *dev, s8 *pwr, size_t pwr_len, 333 const s8 *data, s8 target_power, s8 nss_delta, 334 s8 *max_power, int n_chains, enum mt76_sku_type type) 335 { 336 int i; 337 338 if (!data) 339 return; 340 341 for (i = 0; i < pwr_len; i++) { 342 u8 backoff_chain_idx = i; 343 int backoff_n_chains; 344 s8 backoff_delta; 345 s8 delta; 346 347 switch (type) { 348 case MT76_SKU_RATE: 349 delta = 0; 350 backoff_delta = 0; 351 backoff_n_chains = 0; 352 break; 353 case MT76_SKU_BACKOFF_BF_OFFSET: 354 backoff_chain_idx += 1; 355 fallthrough; 356 case MT76_SKU_BACKOFF: 357 delta = mt76_tx_power_path_delta(n_chains); 358 backoff_n_chains = mt76_backoff_n_chains(dev, backoff_chain_idx); 359 backoff_delta = mt76_tx_power_path_delta(backoff_n_chains); 360 break; 361 default: 362 return; 363 } 364 365 pwr[i] = min_t(s8, target_power + delta - backoff_delta, data[i] + nss_delta); 366 367 /* used for padding, doesn't need to be considered */ 368 if (data[i] >= S8_MAX - 1) 369 continue; 370 371 /* only consider backoff value for the configured chain number */ 372 if (type != MT76_SKU_RATE && n_chains != backoff_n_chains) 373 continue; 374 375 *max_power = max(*max_power, pwr[i]); 376 } 377 } 378 379 static void 380 mt76_apply_multi_array_limit(struct mt76_dev *dev, s8 *pwr, size_t pwr_len, 381 s8 pwr_num, const s8 *data, size_t len, 382 s8 target_power, s8 nss_delta, s8 *max_power, 383 int n_chains, enum mt76_sku_type type) 384 { 385 static const int connac2_backoff_ru_idx = 2; 386 int i, cur; 387 388 if (!data) 389 return; 390 391 cur = data[0]; 392 for (i = 0; i < pwr_num; i++) { 393 if (len < pwr_len + 1) 394 break; 395 396 /* Each RU entry (RU26, RU52, RU106, BW20, ...) in the DTS 397 * corresponds to 10 stream combinations (1T1ss, 2T1ss, 3T1ss, 398 * 4T1ss, 2T2ss, 3T2ss, 4T2ss, 3T3ss, 4T3ss, 4T4ss). 399 * 400 * For beamforming tables: 401 * - In connac2, beamforming entries for BW20~BW160 and OFDM 402 * do not include 1T1ss. 403 * - In connac3, beamforming entries for BW20~BW160 and RU 404 * include 1T1ss, but OFDM beamforming does not include 1T1ss. 405 * 406 * Non-beamforming and RU entries for both connac2 and connac3 407 * include 1T1ss. 408 */ 409 if (!is_mt799x(dev) && type == MT76_SKU_BACKOFF && 410 i > connac2_backoff_ru_idx) 411 type = MT76_SKU_BACKOFF_BF_OFFSET; 412 413 mt76_apply_array_limit(dev, pwr + pwr_len * i, pwr_len, data + 1, 414 target_power, nss_delta, max_power, 415 n_chains, type); 416 if (--cur > 0) 417 continue; 418 419 data += pwr_len + 1; 420 len -= pwr_len + 1; 421 if (!len) 422 break; 423 424 cur = data[0]; 425 } 426 } 427 428 s8 mt76_get_rate_power_limits(struct mt76_phy *phy, 429 struct ieee80211_channel *chan, 430 struct mt76_power_limits *dest, 431 s8 target_power) 432 { 433 struct mt76_dev *dev = phy->dev; 434 struct device_node *np, *band_np; 435 const s8 *val; 436 char name[16]; 437 char band; 438 size_t len; 439 s8 max_power = -127; 440 s8 txs_delta; 441 int n_chains = hweight16(phy->chainmask); 442 443 memset(dest, target_power, sizeof(*dest) - sizeof(dest->path)); 444 memset(&dest->path, 0, sizeof(dest->path)); 445 446 if (!IS_ENABLED(CONFIG_OF)) 447 return target_power; 448 449 np = mt76_find_power_limits_node(dev); 450 if (!np) 451 return target_power; 452 453 switch (chan->band) { 454 case NL80211_BAND_2GHZ: 455 band = '2'; 456 break; 457 case NL80211_BAND_5GHZ: 458 band = '5'; 459 break; 460 case NL80211_BAND_6GHZ: 461 band = '6'; 462 break; 463 default: 464 of_node_put(np); 465 return target_power; 466 } 467 468 snprintf(name, sizeof(name), "txpower-%cg", band); 469 band_np = of_get_child_by_name(np, name); 470 of_node_put(np); 471 if (!band_np) 472 return target_power; 473 474 np = mt76_find_channel_node(band_np, chan); 475 of_node_put(band_np); 476 if (!np) 477 return target_power; 478 479 txs_delta = mt76_get_txs_delta(np, hweight16(phy->chainmask)); 480 481 val = mt76_get_of_array_s8(np, "rates-cck", &len, ARRAY_SIZE(dest->cck)); 482 mt76_apply_array_limit(dev, dest->cck, ARRAY_SIZE(dest->cck), val, 483 target_power, txs_delta, &max_power, n_chains, MT76_SKU_RATE); 484 485 val = mt76_get_of_array_s8(np, "rates-ofdm", &len, ARRAY_SIZE(dest->ofdm)); 486 mt76_apply_array_limit(dev, dest->ofdm, ARRAY_SIZE(dest->ofdm), val, 487 target_power, txs_delta, &max_power, n_chains, MT76_SKU_RATE); 488 489 val = mt76_get_of_array_s8(np, "rates-mcs", &len, ARRAY_SIZE(dest->mcs[0]) + 1); 490 mt76_apply_multi_array_limit(dev, dest->mcs[0], ARRAY_SIZE(dest->mcs[0]), 491 ARRAY_SIZE(dest->mcs), val, len, target_power, 492 txs_delta, &max_power, n_chains, MT76_SKU_RATE); 493 494 val = mt76_get_of_array_s8(np, "rates-ru", &len, ARRAY_SIZE(dest->ru[0]) + 1); 495 mt76_apply_multi_array_limit(dev, dest->ru[0], ARRAY_SIZE(dest->ru[0]), 496 ARRAY_SIZE(dest->ru), val, len, target_power, 497 txs_delta, &max_power, n_chains, MT76_SKU_RATE); 498 499 val = mt76_get_of_array_s8(np, "paths-cck", &len, ARRAY_SIZE(dest->path.cck)); 500 mt76_apply_array_limit(dev, dest->path.cck, ARRAY_SIZE(dest->path.cck), val, 501 target_power, txs_delta, &max_power, n_chains, MT76_SKU_BACKOFF); 502 503 val = mt76_get_of_array_s8(np, "paths-ofdm", &len, ARRAY_SIZE(dest->path.ofdm)); 504 mt76_apply_array_limit(dev, dest->path.ofdm, ARRAY_SIZE(dest->path.ofdm), val, 505 target_power, txs_delta, &max_power, n_chains, MT76_SKU_BACKOFF); 506 507 val = mt76_get_of_array_s8(np, "paths-ofdm-bf", &len, ARRAY_SIZE(dest->path.ofdm_bf)); 508 mt76_apply_array_limit(dev, dest->path.ofdm_bf, ARRAY_SIZE(dest->path.ofdm_bf), val, 509 target_power, txs_delta, &max_power, n_chains, 510 MT76_SKU_BACKOFF_BF_OFFSET); 511 512 val = mt76_get_of_array_s8(np, "paths-ru", &len, ARRAY_SIZE(dest->path.ru[0]) + 1); 513 mt76_apply_multi_array_limit(dev, dest->path.ru[0], ARRAY_SIZE(dest->path.ru[0]), 514 ARRAY_SIZE(dest->path.ru), val, len, target_power, 515 txs_delta, &max_power, n_chains, MT76_SKU_BACKOFF); 516 517 val = mt76_get_of_array_s8(np, "paths-ru-bf", &len, ARRAY_SIZE(dest->path.ru_bf[0]) + 1); 518 mt76_apply_multi_array_limit(dev, dest->path.ru_bf[0], ARRAY_SIZE(dest->path.ru_bf[0]), 519 ARRAY_SIZE(dest->path.ru_bf), val, len, target_power, 520 txs_delta, &max_power, n_chains, MT76_SKU_BACKOFF); 521 522 of_node_put(np); 523 524 return max_power; 525 } 526 EXPORT_SYMBOL_GPL(mt76_get_rate_power_limits); 527 528 int 529 mt76_eeprom_init(struct mt76_dev *dev, int len) 530 { 531 dev->eeprom.size = len; 532 dev->eeprom.data = devm_kzalloc(dev->dev, len, GFP_KERNEL); 533 if (!dev->eeprom.data) 534 return -ENOMEM; 535 536 return !mt76_get_of_eeprom(dev, dev->eeprom.data, len); 537 } 538 EXPORT_SYMBOL_GPL(mt76_eeprom_init); 539