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 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 * 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 * 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 * 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 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 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 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 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 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 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