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