drivers/net/wireless/mediatek/mt76/mt7615/eeprom.c

   1 // SPDX-License-Identifier: ISC
   2 /* Copyright (C) 2019 MediaTek Inc.
   3  *
   4  * Author: Ryder Lee <ryder.lee@mediatek.com>
   5  *         Felix Fietkau <nbd@nbd.name>
   6  */
   7
   8 #include <linux/of.h>
   9 #include "mt7615.h"
  10 #include "eeprom.h"
  11
  12 static int mt7615_efuse_read(struct mt7615_dev *dev, u32 base,
  13                              u16 addr, u8 *data)
  14 {
  15         u32 val;
  16         int i;
  17
  18         val = mt76_rr(dev, base + MT_EFUSE_CTRL);
  19         val &= ~(MT_EFUSE_CTRL_AIN | MT_EFUSE_CTRL_MODE);
  20         val |= FIELD_PREP(MT_EFUSE_CTRL_AIN, addr & ~0xf);
  21         val |= MT_EFUSE_CTRL_KICK;
  22         mt76_wr(dev, base + MT_EFUSE_CTRL, val);
  23
  24         if (!mt76_poll(dev, base + MT_EFUSE_CTRL, MT_EFUSE_CTRL_KICK, 0, 1000))
  25                 return -ETIMEDOUT;
  26
  27         udelay(2);
  28
  29         val = mt76_rr(dev, base + MT_EFUSE_CTRL);
  30         if ((val & MT_EFUSE_CTRL_AOUT) == MT_EFUSE_CTRL_AOUT ||
  31             WARN_ON_ONCE(!(val & MT_EFUSE_CTRL_VALID))) {
  32                 memset(data, 0x0, 16);
  33                 return 0;
  34         }
  35
  36         for (i = 0; i < 4; i++) {
  37                 val = mt76_rr(dev, base + MT_EFUSE_RDATA(i));
  38                 put_unaligned_le32(val, data + 4 * i);
  39         }
  40
  41         return 0;
  42 }
  43
  44 static int mt7615_efuse_init(struct mt7615_dev *dev, u32 base)
  45 {
  46         int i, len = MT7615_EEPROM_SIZE;
  47         void *buf;
  48         u32 val;
  49
  50         if (is_mt7663(&dev->mt76))
  51                 len = MT7663_EEPROM_SIZE;
  52
  53         val = mt76_rr(dev, base + MT_EFUSE_BASE_CTRL);
  54         if (val & MT_EFUSE_BASE_CTRL_EMPTY)
  55                 return 0;
  56
  57         dev->mt76.otp.data = devm_kzalloc(dev->mt76.dev, len, GFP_KERNEL);
  58         dev->mt76.otp.size = len;
  59         if (!dev->mt76.otp.data)
  60                 return -ENOMEM;
  61
  62         buf = dev->mt76.otp.data;
  63         for (i = 0; i + 16 <= len; i += 16) {
  64                 int ret;
  65
  66                 ret = mt7615_efuse_read(dev, base, i, buf + i);
  67                 if (ret)
  68                         return ret;
  69         }
  70
  71         return 0;
  72 }
  73
  74 static int mt7615_eeprom_load(struct mt7615_dev *dev, u32 addr)
  75 {
  76         int ret;
  77
  78         BUILD_BUG_ON(MT7615_EEPROM_FULL_SIZE < MT7663_EEPROM_SIZE);
  79
  80         ret = mt76_eeprom_init(&dev->mt76, MT7615_EEPROM_FULL_SIZE);
  81         if (ret < 0)
  82                 return ret;
  83
  84         return mt7615_efuse_init(dev, addr);
  85 }
  86
  87 static int mt7615_check_eeprom(struct mt76_dev *dev)
  88 {
  89         u16 val = get_unaligned_le16(dev->eeprom.data);
  90
  91         switch (val) {
  92         case 0x7615:
  93         case 0x7622:
  94         case 0x7663:
  95                 return 0;
  96         default:
  97                 return -EINVAL;
  98         }
  99 }
 100
 101 static void
 102 mt7615_eeprom_parse_hw_band_cap(struct mt7615_dev *dev)
 103 {
 104         u8 val, *eeprom = dev->mt76.eeprom.data;
 105
 106         if (is_mt7663(&dev->mt76)) {
 107                 /* dual band */
 108                 dev->mphy.cap.has_2ghz = true;
 109                 dev->mphy.cap.has_5ghz = true;
 110                 return;
 111         }
 112
 113         if (is_mt7622(&dev->mt76)) {
 114                 /* 2GHz only */
 115                 dev->mphy.cap.has_2ghz = true;
 116                 return;
 117         }
 118
 119         if (is_mt7611(&dev->mt76)) {
 120                 /* 5GHz only */
 121                 dev->mphy.cap.has_5ghz = true;
 122                 return;
 123         }
 124
 125         val = FIELD_GET(MT_EE_NIC_WIFI_CONF_BAND_SEL,
 126                         eeprom[MT_EE_WIFI_CONF]);
 127         switch (val) {
 128         case MT_EE_5GHZ:
 129                 dev->mphy.cap.has_5ghz = true;
 130                 break;
 131         case MT_EE_DBDC:
 132                 dev->dbdc_support = true;
 133                 fallthrough;
 134         case MT_EE_2GHZ:
 135                 dev->mphy.cap.has_2ghz = true;
 136                 break;
 137         default:
 138                 dev->mphy.cap.has_2ghz = true;
 139                 dev->mphy.cap.has_5ghz = true;
 140                 break;
 141         }
 142 }
 143
 144 static void mt7615_eeprom_parse_hw_cap(struct mt7615_dev *dev)
 145 {
 146         u8 *eeprom = dev->mt76.eeprom.data;
 147         u8 tx_mask, max_nss;
 148
 149         mt7615_eeprom_parse_hw_band_cap(dev);
 150
 151         if (is_mt7663(&dev->mt76)) {
 152                 max_nss = 2;
 153                 tx_mask = FIELD_GET(MT_EE_HW_CONF1_TX_MASK,
 154                                     eeprom[MT7663_EE_HW_CONF1]);
 155         } else {
 156                 u32 val;
 157
 158                 /* read tx-rx mask from eeprom */
 159                 val = mt76_rr(dev, MT_TOP_STRAP_STA);
 160                 max_nss = val & MT_TOP_3NSS ? 3 : 4;
 161
 162                 tx_mask =  FIELD_GET(MT_EE_NIC_CONF_TX_MASK,
 163                                      eeprom[MT_EE_NIC_CONF_0]);
 164         }
 165         if (!tx_mask || tx_mask > max_nss)
 166                 tx_mask = max_nss;
 167
 168         dev->chainmask = BIT(tx_mask) - 1;
 169         dev->mphy.antenna_mask = dev->chainmask;
 170         dev->mphy.chainmask = dev->chainmask;
 171 }
 172
 173 static int mt7663_eeprom_get_target_power_index(struct mt7615_dev *dev,
 174                                                 struct ieee80211_channel *chan,
 175                                                 u8 chain_idx)
 176 {
 177         int index, group;
 178
 179         if (chain_idx > 1)
 180                 return -EINVAL;
 181
 182         if (chan->band == NL80211_BAND_2GHZ)
 183                 return MT7663_EE_TX0_2G_TARGET_POWER + (chain_idx << 4);
 184
 185         group = mt7615_get_channel_group(chan->hw_value);
 186         if (chain_idx == 1)
 187                 index = MT7663_EE_TX1_5G_G0_TARGET_POWER;
 188         else
 189                 index = MT7663_EE_TX0_5G_G0_TARGET_POWER;
 190
 191         return index + group * 3;
 192 }
 193
 194 int mt7615_eeprom_get_target_power_index(struct mt7615_dev *dev,
 195                                          struct ieee80211_channel *chan,
 196                                          u8 chain_idx)
 197 {
 198         int index;
 199
 200         if (is_mt7663(&dev->mt76))
 201                 return mt7663_eeprom_get_target_power_index(dev, chan,
 202                                                             chain_idx);
 203
 204         if (chain_idx > 3)
 205                 return -EINVAL;
 206
 207         /* TSSI disabled */
 208         if (mt7615_ext_pa_enabled(dev, chan->band)) {
 209                 if (chan->band == NL80211_BAND_2GHZ)
 210                         return MT_EE_EXT_PA_2G_TARGET_POWER;
 211                 else
 212                         return MT_EE_EXT_PA_5G_TARGET_POWER;
 213         }
 214
 215         /* TSSI enabled */
 216         if (chan->band == NL80211_BAND_2GHZ) {
 217                 index = MT_EE_TX0_2G_TARGET_POWER + chain_idx * 6;
 218         } else {
 219                 int group = mt7615_get_channel_group(chan->hw_value);
 220
 221                 switch (chain_idx) {
 222                 case 1:
 223                         index = MT_EE_TX1_5G_G0_TARGET_POWER;
 224                         break;
 225                 case 2:
 226                         index = MT_EE_TX2_5G_G0_TARGET_POWER;
 227                         break;
 228                 case 3:
 229                         index = MT_EE_TX3_5G_G0_TARGET_POWER;
 230                         break;
 231                 case 0:
 232                 default:
 233                         index = MT_EE_TX0_5G_G0_TARGET_POWER;
 234                         break;
 235                 }
 236                 index += 5 * group;
 237         }
 238
 239         return index;
 240 }
 241
 242 int mt7615_eeprom_get_power_delta_index(struct mt7615_dev *dev,
 243                                         enum nl80211_band band)
 244 {
 245         /* assume the first rate has the highest power offset */
 246         if (is_mt7663(&dev->mt76)) {
 247                 if (band == NL80211_BAND_2GHZ)
 248                         return MT_EE_TX0_5G_G0_TARGET_POWER;
 249                 else
 250                         return MT7663_EE_5G_RATE_POWER;
 251         }
 252
 253         if (band == NL80211_BAND_2GHZ)
 254                 return MT_EE_2G_RATE_POWER;
 255         else
 256                 return MT_EE_5G_RATE_POWER;
 257 }
 258
 259 static void mt7615_apply_cal_free_data(struct mt7615_dev *dev)
 260 {
 261         static const u16 ical[] = {
 262                 0x53, 0x54, 0x55, 0x56, 0x57, 0x5c, 0x5d, 0x62, 0x63, 0x68,
 263                 0x69, 0x6e, 0x6f, 0x73, 0x74, 0x78, 0x79, 0x82, 0x83, 0x87,
 264                 0x88, 0x8c, 0x8d, 0x91, 0x92, 0x96, 0x97, 0x9b, 0x9c, 0xa0,
 265                 0xa1, 0xaa, 0xab, 0xaf, 0xb0, 0xb4, 0xb5, 0xb9, 0xba, 0xf4,
 266                 0xf7, 0xff,
 267                 0x140, 0x141, 0x145, 0x146, 0x14a, 0x14b, 0x154, 0x155, 0x159,
 268                 0x15a, 0x15e, 0x15f, 0x163, 0x164, 0x168, 0x169, 0x16d, 0x16e,
 269                 0x172, 0x173, 0x17c, 0x17d, 0x181, 0x182, 0x186, 0x187, 0x18b,
 270                 0x18c
 271         };
 272         static const u16 ical_nocheck[] = {
 273                 0x110, 0x111, 0x112, 0x113, 0x114, 0x115, 0x116, 0x117, 0x118,
 274                 0x1b5, 0x1b6, 0x1b7, 0x3ac, 0x3ad, 0x3ae, 0x3af, 0x3b0, 0x3b1,
 275                 0x3b2
 276         };
 277         u8 *eeprom = dev->mt76.eeprom.data;
 278         u8 *otp = dev->mt76.otp.data;
 279         int i;
 280
 281         if (!otp)
 282                 return;
 283
 284         for (i = 0; i < ARRAY_SIZE(ical); i++)
 285                 if (!otp[ical[i]])
 286                         return;
 287
 288         for (i = 0; i < ARRAY_SIZE(ical); i++)
 289                 eeprom[ical[i]] = otp[ical[i]];
 290
 291         for (i = 0; i < ARRAY_SIZE(ical_nocheck); i++)
 292                 eeprom[ical_nocheck[i]] = otp[ical_nocheck[i]];
 293 }
 294
 295 static void mt7622_apply_cal_free_data(struct mt7615_dev *dev)
 296 {
 297         static const u16 ical[] = {
 298                 0x53, 0x54, 0x55, 0x56, 0xf4, 0xf7, 0x144, 0x156, 0x15b
 299         };
 300         u8 *eeprom = dev->mt76.eeprom.data;
 301         u8 *otp = dev->mt76.otp.data;
 302         int i;
 303
 304         if (!otp)
 305                 return;
 306
 307         for (i = 0; i < ARRAY_SIZE(ical); i++) {
 308                 if (!otp[ical[i]])
 309                         continue;
 310
 311                 eeprom[ical[i]] = otp[ical[i]];
 312         }
 313 }
 314
 315 static void mt7615_cal_free_data(struct mt7615_dev *dev)
 316 {
 317         struct device_node *np = dev->mt76.dev->of_node;
 318
 319         if (!np || !of_property_read_bool(np, "mediatek,eeprom-merge-otp"))
 320                 return;
 321
 322         switch (mt76_chip(&dev->mt76)) {
 323         case 0x7622:
 324                 mt7622_apply_cal_free_data(dev);
 325                 break;
 326         case 0x7615:
 327         case 0x7611:
 328                 mt7615_apply_cal_free_data(dev);
 329                 break;
 330         }
 331 }
 332
 333 int mt7615_eeprom_init(struct mt7615_dev *dev, u32 addr)
 334 {
 335         int ret;
 336
 337         ret = mt7615_eeprom_load(dev, addr);
 338         if (ret < 0)
 339                 return ret;
 340
 341         ret = mt7615_check_eeprom(&dev->mt76);
 342         if (ret && dev->mt76.otp.data) {
 343                 memcpy(dev->mt76.eeprom.data, dev->mt76.otp.data,
 344                        dev->mt76.otp.size);
 345         } else {
 346                 dev->flash_eeprom = true;
 347                 mt7615_cal_free_data(dev);
 348         }
 349
 350         mt7615_eeprom_parse_hw_cap(dev);
 351         memcpy(dev->mphy.macaddr, dev->mt76.eeprom.data + MT_EE_MAC_ADDR,
 352                ETH_ALEN);
 353
 354         mt76_eeprom_override(&dev->mphy);
 355
 356         return 0;
 357 }
 358 EXPORT_SYMBOL_GPL(mt7615_eeprom_init);