1 // SPDX-License-Identifier: ISC 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/etherdevice.h> 10 #include "mt76.h" 11 12 int mt76_get_of_eeprom(struct mt76_dev *dev, void *eep, int offset, int len) 13 { 14 #if defined(CONFIG_OF) && defined(CONFIG_MTD) 15 struct device_node *np = dev->dev->of_node; 16 struct mtd_info *mtd; 17 const __be32 *list; 18 const void *data; 19 const char *part; 20 phandle phandle; 21 int size; 22 size_t retlen; 23 int ret; 24 25 if (!np) 26 return -ENOENT; 27 28 data = of_get_property(np, "mediatek,eeprom-data", &size); 29 if (data) { 30 if (size > len) 31 return -EINVAL; 32 33 memcpy(eep, data, size); 34 35 return 0; 36 } 37 38 list = of_get_property(np, "mediatek,mtd-eeprom", &size); 39 if (!list) 40 return -ENOENT; 41 42 phandle = be32_to_cpup(list++); 43 if (!phandle) 44 return -ENOENT; 45 46 np = of_find_node_by_phandle(phandle); 47 if (!np) 48 return -EINVAL; 49 50 part = of_get_property(np, "label", NULL); 51 if (!part) 52 part = np->name; 53 54 mtd = get_mtd_device_nm(part); 55 if (IS_ERR(mtd)) { 56 ret = PTR_ERR(mtd); 57 goto out_put_node; 58 } 59 60 if (size <= sizeof(*list)) { 61 ret = -EINVAL; 62 goto out_put_node; 63 } 64 65 offset = be32_to_cpup(list); 66 ret = mtd_read(mtd, offset, len, &retlen, eep); 67 put_mtd_device(mtd); 68 if (ret) 69 goto out_put_node; 70 71 if (retlen < len) { 72 ret = -EINVAL; 73 goto out_put_node; 74 } 75 76 if (of_property_read_bool(dev->dev->of_node, "big-endian")) { 77 u8 *data = (u8 *)eep; 78 int i; 79 80 /* convert eeprom data in Little Endian */ 81 for (i = 0; i < round_down(len, 2); i += 2) 82 put_unaligned_le16(get_unaligned_be16(&data[i]), 83 &data[i]); 84 } 85 86 #ifdef CONFIG_NL80211_TESTMODE 87 dev->test_mtd.name = devm_kstrdup(dev->dev, part, GFP_KERNEL); 88 dev->test_mtd.offset = offset; 89 #endif 90 91 out_put_node: 92 of_node_put(np); 93 return ret; 94 #else 95 return -ENOENT; 96 #endif 97 } 98 EXPORT_SYMBOL_GPL(mt76_get_of_eeprom); 99 100 void 101 mt76_eeprom_override(struct mt76_phy *phy) 102 { 103 struct mt76_dev *dev = phy->dev; 104 struct device_node *np = dev->dev->of_node; 105 106 of_get_mac_address(np, phy->macaddr); 107 108 if (!is_valid_ether_addr(phy->macaddr)) { 109 eth_random_addr(phy->macaddr); 110 dev_info(dev->dev, 111 "Invalid MAC address, using random address %pM\n", 112 phy->macaddr); 113 } 114 } 115 EXPORT_SYMBOL_GPL(mt76_eeprom_override); 116 117 static bool mt76_string_prop_find(struct property *prop, const char *str) 118 { 119 const char *cp = NULL; 120 121 if (!prop || !str || !str[0]) 122 return false; 123 124 while ((cp = of_prop_next_string(prop, cp)) != NULL) 125 if (!strcasecmp(cp, str)) 126 return true; 127 128 return false; 129 } 130 131 static struct device_node * 132 mt76_find_power_limits_node(struct mt76_dev *dev) 133 { 134 struct device_node *np = dev->dev->of_node; 135 const char *const region_names[] = { 136 [NL80211_DFS_ETSI] = "etsi", 137 [NL80211_DFS_FCC] = "fcc", 138 [NL80211_DFS_JP] = "jp", 139 }; 140 struct device_node *cur, *fallback = NULL; 141 const char *region_name = NULL; 142 143 if (dev->region < ARRAY_SIZE(region_names)) 144 region_name = region_names[dev->region]; 145 146 np = of_get_child_by_name(np, "power-limits"); 147 if (!np) 148 return NULL; 149 150 for_each_child_of_node(np, cur) { 151 struct property *country = of_find_property(cur, "country", NULL); 152 struct property *regd = of_find_property(cur, "regdomain", NULL); 153 154 if (!country && !regd) { 155 fallback = cur; 156 continue; 157 } 158 159 if (mt76_string_prop_find(country, dev->alpha2) || 160 mt76_string_prop_find(regd, region_name)) 161 return cur; 162 } 163 164 return fallback; 165 } 166 167 static const __be32 * 168 mt76_get_of_array(struct device_node *np, char *name, size_t *len, int min) 169 { 170 struct property *prop = of_find_property(np, name, NULL); 171 172 if (!prop || !prop->value || prop->length < min * 4) 173 return NULL; 174 175 *len = prop->length; 176 177 return prop->value; 178 } 179 180 static struct device_node * 181 mt76_find_channel_node(struct device_node *np, struct ieee80211_channel *chan) 182 { 183 struct device_node *cur; 184 const __be32 *val; 185 size_t len; 186 187 for_each_child_of_node(np, cur) { 188 val = mt76_get_of_array(cur, "channels", &len, 2); 189 if (!val) 190 continue; 191 192 while (len >= 2 * sizeof(*val)) { 193 if (chan->hw_value >= be32_to_cpu(val[0]) && 194 chan->hw_value <= be32_to_cpu(val[1])) 195 return cur; 196 197 val += 2; 198 len -= 2 * sizeof(*val); 199 } 200 } 201 202 return NULL; 203 } 204 205 static s8 206 mt76_get_txs_delta(struct device_node *np, u8 nss) 207 { 208 const __be32 *val; 209 size_t len; 210 211 val = mt76_get_of_array(np, "txs-delta", &len, nss); 212 if (!val) 213 return 0; 214 215 return be32_to_cpu(val[nss - 1]); 216 } 217 218 static void 219 mt76_apply_array_limit(s8 *pwr, size_t pwr_len, const __be32 *data, 220 s8 target_power, s8 nss_delta, s8 *max_power) 221 { 222 int i; 223 224 if (!data) 225 return; 226 227 for (i = 0; i < pwr_len; i++) { 228 pwr[i] = min_t(s8, target_power, 229 be32_to_cpu(data[i]) + nss_delta); 230 *max_power = max(*max_power, pwr[i]); 231 } 232 } 233 234 static void 235 mt76_apply_multi_array_limit(s8 *pwr, size_t pwr_len, s8 pwr_num, 236 const __be32 *data, size_t len, s8 target_power, 237 s8 nss_delta, s8 *max_power) 238 { 239 int i, cur; 240 241 if (!data) 242 return; 243 244 len /= 4; 245 cur = be32_to_cpu(data[0]); 246 for (i = 0; i < pwr_num; i++) { 247 if (len < pwr_len + 1) 248 break; 249 250 mt76_apply_array_limit(pwr + pwr_len * i, pwr_len, data + 1, 251 target_power, nss_delta, max_power); 252 if (--cur > 0) 253 continue; 254 255 data += pwr_len + 1; 256 len -= pwr_len + 1; 257 if (!len) 258 break; 259 260 cur = be32_to_cpu(data[0]); 261 } 262 } 263 264 s8 mt76_get_rate_power_limits(struct mt76_phy *phy, 265 struct ieee80211_channel *chan, 266 struct mt76_power_limits *dest, 267 s8 target_power) 268 { 269 struct mt76_dev *dev = phy->dev; 270 struct device_node *np; 271 const __be32 *val; 272 char name[16]; 273 u32 mcs_rates = dev->drv->mcs_rates; 274 u32 ru_rates = ARRAY_SIZE(dest->ru[0]); 275 char band; 276 size_t len; 277 s8 max_power = 0; 278 s8 txs_delta; 279 280 if (!mcs_rates) 281 mcs_rates = 10; 282 283 memset(dest, target_power, sizeof(*dest)); 284 285 if (!IS_ENABLED(CONFIG_OF)) 286 return target_power; 287 288 np = mt76_find_power_limits_node(dev); 289 if (!np) 290 return target_power; 291 292 switch (chan->band) { 293 case NL80211_BAND_2GHZ: 294 band = '2'; 295 break; 296 case NL80211_BAND_5GHZ: 297 band = '5'; 298 break; 299 case NL80211_BAND_6GHZ: 300 band = '6'; 301 break; 302 default: 303 return target_power; 304 } 305 306 snprintf(name, sizeof(name), "txpower-%cg", band); 307 np = of_get_child_by_name(np, name); 308 if (!np) 309 return target_power; 310 311 np = mt76_find_channel_node(np, chan); 312 if (!np) 313 return target_power; 314 315 txs_delta = mt76_get_txs_delta(np, hweight8(phy->antenna_mask)); 316 317 val = mt76_get_of_array(np, "rates-cck", &len, ARRAY_SIZE(dest->cck)); 318 mt76_apply_array_limit(dest->cck, ARRAY_SIZE(dest->cck), val, 319 target_power, txs_delta, &max_power); 320 321 val = mt76_get_of_array(np, "rates-ofdm", 322 &len, ARRAY_SIZE(dest->ofdm)); 323 mt76_apply_array_limit(dest->ofdm, ARRAY_SIZE(dest->ofdm), val, 324 target_power, txs_delta, &max_power); 325 326 val = mt76_get_of_array(np, "rates-mcs", &len, mcs_rates + 1); 327 mt76_apply_multi_array_limit(dest->mcs[0], ARRAY_SIZE(dest->mcs[0]), 328 ARRAY_SIZE(dest->mcs), val, len, 329 target_power, txs_delta, &max_power); 330 331 val = mt76_get_of_array(np, "rates-ru", &len, ru_rates + 1); 332 mt76_apply_multi_array_limit(dest->ru[0], ARRAY_SIZE(dest->ru[0]), 333 ARRAY_SIZE(dest->ru), val, len, 334 target_power, txs_delta, &max_power); 335 336 return max_power; 337 } 338 EXPORT_SYMBOL_GPL(mt76_get_rate_power_limits); 339 340 int 341 mt76_eeprom_init(struct mt76_dev *dev, int len) 342 { 343 dev->eeprom.size = len; 344 dev->eeprom.data = devm_kzalloc(dev->dev, len, GFP_KERNEL); 345 if (!dev->eeprom.data) 346 return -ENOMEM; 347 348 return !mt76_get_of_eeprom(dev, dev->eeprom.data, 0, len); 349 } 350 EXPORT_SYMBOL_GPL(mt76_eeprom_init); 351