mediatek/mt76/eeprom.c

0001 // SPDX-License-Identifier: ISC
0002 /*
0003  * Copyright (C) 2016 Felix Fietkau <nbd@nbd.name>
0004  */
0005 #include <linux/of.h>
0006 #include <linux/of_net.h>
0007 #include <linux/mtd/mtd.h>
0008 #include <linux/mtd/partitions.h>
0009 #include <linux/etherdevice.h>
0010 #include "mt76.h"
0011
0012 int mt76_get_of_eeprom(struct mt76_dev *dev, void *eep, int offset, int len)
0013 {
0014 #if defined(CONFIG_OF) && defined(CONFIG_MTD)
0015     struct device_node *np = dev->dev->of_node;
0016     struct mtd_info *mtd;
0017     const __be32 *list;
0018     const void *data;
0019     const char *part;
0020     phandle phandle;
0021     int size;
0022     size_t retlen;
0023     int ret;
0024
0025     if (!np)
0026         return -ENOENT;
0027
0028     data = of_get_property(np, "mediatek,eeprom-data", &size);
0029     if (data) {
0030         if (size > len)
0031             return -EINVAL;
0032
0033         memcpy(eep, data, size);
0034
0035         return 0;
0036     }
0037
0038     list = of_get_property(np, "mediatek,mtd-eeprom", &size);
0039     if (!list)
0040         return -ENOENT;
0041
0042     phandle = be32_to_cpup(list++);
0043     if (!phandle)
0044         return -ENOENT;
0045
0046     np = of_find_node_by_phandle(phandle);
0047     if (!np)
0048         return -EINVAL;
0049
0050     part = of_get_property(np, "label", NULL);
0051     if (!part)
0052         part = np->name;
0053
0054     mtd = get_mtd_device_nm(part);
0055     if (IS_ERR(mtd)) {
0056         ret =  PTR_ERR(mtd);
0057         goto out_put_node;
0058     }
0059
0060     if (size <= sizeof(*list)) {
0061         ret = -EINVAL;
0062         goto out_put_node;
0063     }
0064
0065     offset = be32_to_cpup(list);
0066     ret = mtd_read(mtd, offset, len, &retlen, eep);
0067     put_mtd_device(mtd);
0068     if (mtd_is_bitflip(ret))
0069         ret = 0;
0070     if (ret) {
0071         dev_err(dev->dev, "reading EEPROM from mtd %s failed: %i\n",
0072             part, ret);
0073         goto out_put_node;
0074     }
0075
0076     if (retlen < len) {
0077         ret = -EINVAL;
0078         goto out_put_node;
0079     }
0080
0081     if (of_property_read_bool(dev->dev->of_node, "big-endian")) {
0082         u8 *data = (u8 *)eep;
0083         int i;
0084
0085         /* convert eeprom data in Little Endian */
0086         for (i = 0; i < round_down(len, 2); i += 2)
0087             put_unaligned_le16(get_unaligned_be16(&data[i]),
0088                        &data[i]);
0089     }
0090
0091 #ifdef CONFIG_NL80211_TESTMODE
0092     dev->test_mtd.name = devm_kstrdup(dev->dev, part, GFP_KERNEL);
0093     dev->test_mtd.offset = offset;
0094 #endif
0095
0096 out_put_node:
0097     of_node_put(np);
0098     return ret;
0099 #else
0100     return -ENOENT;
0101 #endif
0102 }
0103 EXPORT_SYMBOL_GPL(mt76_get_of_eeprom);
0104
0105 void
0106 mt76_eeprom_override(struct mt76_phy *phy)
0107 {
0108     struct mt76_dev *dev = phy->dev;
0109     struct device_node *np = dev->dev->of_node;
0110
0111     of_get_mac_address(np, phy->macaddr);
0112
0113     if (!is_valid_ether_addr(phy->macaddr)) {
0114         eth_random_addr(phy->macaddr);
0115         dev_info(dev->dev,
0116              "Invalid MAC address, using random address %pM\n",
0117              phy->macaddr);
0118     }
0119 }
0120 EXPORT_SYMBOL_GPL(mt76_eeprom_override);
0121
0122 static bool mt76_string_prop_find(struct property *prop, const char *str)
0123 {
0124     const char *cp = NULL;
0125
0126     if (!prop || !str || !str[0])
0127         return false;
0128
0129     while ((cp = of_prop_next_string(prop, cp)) != NULL)
0130         if (!strcasecmp(cp, str))
0131             return true;
0132
0133     return false;
0134 }
0135
0136 static struct device_node *
0137 mt76_find_power_limits_node(struct mt76_dev *dev)
0138 {
0139     struct device_node *np = dev->dev->of_node;
0140     const char *const region_names[] = {
0141         [NL80211_DFS_ETSI] = "etsi",
0142         [NL80211_DFS_FCC] = "fcc",
0143         [NL80211_DFS_JP] = "jp",
0144     };
0145     struct device_node *cur, *fallback = NULL;
0146     const char *region_name = NULL;
0147
0148     if (dev->region < ARRAY_SIZE(region_names))
0149         region_name = region_names[dev->region];
0150
0151     np = of_get_child_by_name(np, "power-limits");
0152     if (!np)
0153         return NULL;
0154
0155     for_each_child_of_node(np, cur) {
0156         struct property *country = of_find_property(cur, "country", NULL);
0157         struct property *regd = of_find_property(cur, "regdomain", NULL);
0158
0159         if (!country && !regd) {
0160             fallback = cur;
0161             continue;
0162         }
0163
0164         if (mt76_string_prop_find(country, dev->alpha2) ||
0165             mt76_string_prop_find(regd, region_name)) {
0166             of_node_put(np);
0167             return cur;
0168         }
0169     }
0170
0171     of_node_put(np);
0172     return fallback;
0173 }
0174
0175 static const __be32 *
0176 mt76_get_of_array(struct device_node *np, char *name, size_t *len, int min)
0177 {
0178     struct property *prop = of_find_property(np, name, NULL);
0179
0180     if (!prop || !prop->value || prop->length < min * 4)
0181         return NULL;
0182
0183     *len = prop->length;
0184
0185     return prop->value;
0186 }
0187
0188 static struct device_node *
0189 mt76_find_channel_node(struct device_node *np, struct ieee80211_channel *chan)
0190 {
0191     struct device_node *cur;
0192     const __be32 *val;
0193     size_t len;
0194
0195     for_each_child_of_node(np, cur) {
0196         val = mt76_get_of_array(cur, "channels", &len, 2);
0197         if (!val)
0198             continue;
0199
0200         while (len >= 2 * sizeof(*val)) {
0201             if (chan->hw_value >= be32_to_cpu(val[0]) &&
0202                 chan->hw_value <= be32_to_cpu(val[1]))
0203                 return cur;
0204
0205             val += 2;
0206             len -= 2 * sizeof(*val);
0207         }
0208     }
0209
0210     return NULL;
0211 }
0212
0213 static s8
0214 mt76_get_txs_delta(struct device_node *np, u8 nss)
0215 {
0216     const __be32 *val;
0217     size_t len;
0218
0219     val = mt76_get_of_array(np, "txs-delta", &len, nss);
0220     if (!val)
0221         return 0;
0222
0223     return be32_to_cpu(val[nss - 1]);
0224 }
0225
0226 static void
0227 mt76_apply_array_limit(s8 *pwr, size_t pwr_len, const __be32 *data,
0228                s8 target_power, s8 nss_delta, s8 *max_power)
0229 {
0230     int i;
0231
0232     if (!data)
0233         return;
0234
0235     for (i = 0; i < pwr_len; i++) {
0236         pwr[i] = min_t(s8, target_power,
0237                    be32_to_cpu(data[i]) + nss_delta);
0238         *max_power = max(*max_power, pwr[i]);
0239     }
0240 }
0241
0242 static void
0243 mt76_apply_multi_array_limit(s8 *pwr, size_t pwr_len, s8 pwr_num,
0244                  const __be32 *data, size_t len, s8 target_power,
0245                  s8 nss_delta, s8 *max_power)
0246 {
0247     int i, cur;
0248
0249     if (!data)
0250         return;
0251
0252     len /= 4;
0253     cur = be32_to_cpu(data[0]);
0254     for (i = 0; i < pwr_num; i++) {
0255         if (len < pwr_len + 1)
0256             break;
0257
0258         mt76_apply_array_limit(pwr + pwr_len * i, pwr_len, data + 1,
0259                        target_power, nss_delta, max_power);
0260         if (--cur > 0)
0261             continue;
0262
0263         data += pwr_len + 1;
0264         len -= pwr_len + 1;
0265         if (!len)
0266             break;
0267
0268         cur = be32_to_cpu(data[0]);
0269     }
0270 }
0271
0272 s8 mt76_get_rate_power_limits(struct mt76_phy *phy,
0273                   struct ieee80211_channel *chan,
0274                   struct mt76_power_limits *dest,
0275                   s8 target_power)
0276 {
0277     struct mt76_dev *dev = phy->dev;
0278     struct device_node *np;
0279     const __be32 *val;
0280     char name[16];
0281     u32 mcs_rates = dev->drv->mcs_rates;
0282     u32 ru_rates = ARRAY_SIZE(dest->ru[0]);
0283     char band;
0284     size_t len;
0285     s8 max_power = 0;
0286     s8 txs_delta;
0287
0288     if (!mcs_rates)
0289         mcs_rates = 10;
0290
0291     memset(dest, target_power, sizeof(*dest));
0292
0293     if (!IS_ENABLED(CONFIG_OF))
0294         return target_power;
0295
0296     np = mt76_find_power_limits_node(dev);
0297     if (!np)
0298         return target_power;
0299
0300     switch (chan->band) {
0301     case NL80211_BAND_2GHZ:
0302         band = '2';
0303         break;
0304     case NL80211_BAND_5GHZ:
0305         band = '5';
0306         break;
0307     case NL80211_BAND_6GHZ:
0308         band = '6';
0309         break;
0310     default:
0311         return target_power;
0312     }
0313
0314     snprintf(name, sizeof(name), "txpower-%cg", band);
0315     np = of_get_child_by_name(np, name);
0316     if (!np)
0317         return target_power;
0318
0319     np = mt76_find_channel_node(np, chan);
0320     if (!np)
0321         return target_power;
0322
0323     txs_delta = mt76_get_txs_delta(np, hweight8(phy->antenna_mask));
0324
0325     val = mt76_get_of_array(np, "rates-cck", &len, ARRAY_SIZE(dest->cck));
0326     mt76_apply_array_limit(dest->cck, ARRAY_SIZE(dest->cck), val,
0327                    target_power, txs_delta, &max_power);
0328
0329     val = mt76_get_of_array(np, "rates-ofdm",
0330                 &len, ARRAY_SIZE(dest->ofdm));
0331     mt76_apply_array_limit(dest->ofdm, ARRAY_SIZE(dest->ofdm), val,
0332                    target_power, txs_delta, &max_power);
0333
0334     val = mt76_get_of_array(np, "rates-mcs", &len, mcs_rates + 1);
0335     mt76_apply_multi_array_limit(dest->mcs[0], ARRAY_SIZE(dest->mcs[0]),
0336                      ARRAY_SIZE(dest->mcs), val, len,
0337                      target_power, txs_delta, &max_power);
0338
0339     val = mt76_get_of_array(np, "rates-ru", &len, ru_rates + 1);
0340     mt76_apply_multi_array_limit(dest->ru[0], ARRAY_SIZE(dest->ru[0]),
0341                      ARRAY_SIZE(dest->ru), val, len,
0342                      target_power, txs_delta, &max_power);
0343
0344     return max_power;
0345 }
0346 EXPORT_SYMBOL_GPL(mt76_get_rate_power_limits);
0347
0348 int
0349 mt76_eeprom_init(struct mt76_dev *dev, int len)
0350 {
0351     dev->eeprom.size = len;
0352     dev->eeprom.data = devm_kzalloc(dev->dev, len, GFP_KERNEL);
0353     if (!dev->eeprom.data)
0354         return -ENOMEM;
0355
0356     return !mt76_get_of_eeprom(dev, dev->eeprom.data, 0, len);
0357 }
0358 EXPORT_SYMBOL_GPL(mt76_eeprom_init);