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

   1 // SPDX-License-Identifier: ISC
   2 /* Copyright (C) 2020 MediaTek Inc. */
   3
   4 #include <linux/firmware.h>
   5 #include "mt7915.h"
   6 #include "eeprom.h"
   7
   8 static int mt7915_eeprom_load_precal(struct mt7915_dev *dev)
   9 {
  10         struct mt76_dev *mdev = &dev->mt76;
  11         u8 *eeprom = mdev->eeprom.data;
  12         u32 val = eeprom[MT_EE_DO_PRE_CAL];
  13         u32 offs;
  14
  15         if (!dev->flash_mode)
  16                 return 0;
  17
  18         if (val != (MT_EE_WIFI_CAL_DPD | MT_EE_WIFI_CAL_GROUP))
  19                 return 0;
  20
  21         val = MT_EE_CAL_GROUP_SIZE + MT_EE_CAL_DPD_SIZE;
  22         dev->cal = devm_kzalloc(mdev->dev, val, GFP_KERNEL);
  23         if (!dev->cal)
  24                 return -ENOMEM;
  25
  26         offs = is_mt7915(&dev->mt76) ? MT_EE_PRECAL : MT_EE_PRECAL_V2;
  27
  28         return mt76_get_of_eeprom(mdev, dev->cal, offs, val);
  29 }
  30
  31 static int mt7915_check_eeprom(struct mt7915_dev *dev)
  32 {
  33         u8 *eeprom = dev->mt76.eeprom.data;
  34         u16 val = get_unaligned_le16(eeprom);
  35
  36         switch (val) {
  37         case 0x7915:
  38         case 0x7916:
  39         case 0x7986:
  40                 return 0;
  41         default:
  42                 return -EINVAL;
  43         }
  44 }
  45
  46 static char *mt7915_eeprom_name(struct mt7915_dev *dev)
  47 {
  48         switch (mt76_chip(&dev->mt76)) {
  49         case 0x7915:
  50                 return dev->dbdc_support ?
  51                        MT7915_EEPROM_DEFAULT_DBDC : MT7915_EEPROM_DEFAULT;
  52         case 0x7986:
  53                 switch (mt7915_check_adie(dev, true)) {
  54                 case MT7976_ONE_ADIE_DBDC:
  55                         return MT7986_EEPROM_MT7976_DEFAULT_DBDC;
  56                 case MT7975_ONE_ADIE:
  57                         return MT7986_EEPROM_MT7975_DEFAULT;
  58                 case MT7976_ONE_ADIE:
  59                         return MT7986_EEPROM_MT7976_DEFAULT;
  60                 case MT7975_DUAL_ADIE:
  61                         return MT7986_EEPROM_MT7975_DUAL_DEFAULT;
  62                 case MT7976_DUAL_ADIE:
  63                         return MT7986_EEPROM_MT7976_DUAL_DEFAULT;
  64                 default:
  65                         break;
  66                 }
  67                 return NULL;
  68         default:
  69                 return MT7916_EEPROM_DEFAULT;
  70         }
  71 }
  72
  73 static int
  74 mt7915_eeprom_load_default(struct mt7915_dev *dev)
  75 {
  76         u8 *eeprom = dev->mt76.eeprom.data;
  77         const struct firmware *fw = NULL;
  78         int ret;
  79
  80         ret = request_firmware(&fw, mt7915_eeprom_name(dev), dev->mt76.dev);
  81         if (ret)
  82                 return ret;
  83
  84         if (!fw || !fw->data) {
  85                 dev_err(dev->mt76.dev, "Invalid default bin\n");
  86                 ret = -EINVAL;
  87                 goto out;
  88         }
  89
  90         memcpy(eeprom, fw->data, mt7915_eeprom_size(dev));
  91         dev->flash_mode = true;
  92
  93 out:
  94         release_firmware(fw);
  95
  96         return ret;
  97 }
  98
  99 static int mt7915_eeprom_load(struct mt7915_dev *dev)
 100 {
 101         int ret;
 102         u16 eeprom_size = mt7915_eeprom_size(dev);
 103
 104         ret = mt76_eeprom_init(&dev->mt76, eeprom_size);
 105         if (ret < 0)
 106                 return ret;
 107
 108         if (ret) {
 109                 dev->flash_mode = true;
 110         } else {
 111                 u8 free_block_num;
 112                 u32 block_num, i;
 113
 114                 mt7915_mcu_get_eeprom_free_block(dev, &free_block_num);
 115                 /* efuse info not enough */
 116                 if (free_block_num >= 29)
 117                         return -EINVAL;
 118
 119                 /* read eeprom data from efuse */
 120                 block_num = DIV_ROUND_UP(eeprom_size,
 121                                          MT7915_EEPROM_BLOCK_SIZE);
 122                 for (i = 0; i < block_num; i++)
 123                         mt7915_mcu_get_eeprom(dev,
 124                                               i * MT7915_EEPROM_BLOCK_SIZE);
 125         }
 126
 127         return mt7915_check_eeprom(dev);
 128 }
 129
 130 static void mt7915_eeprom_parse_band_config(struct mt7915_phy *phy)
 131 {
 132         struct mt7915_dev *dev = phy->dev;
 133         u8 *eeprom = dev->mt76.eeprom.data;
 134         u32 val;
 135
 136         val = eeprom[MT_EE_WIFI_CONF + phy->band_idx];
 137         val = FIELD_GET(MT_EE_WIFI_CONF0_BAND_SEL, val);
 138
 139         if (!is_mt7915(&dev->mt76)) {
 140                 switch (val) {
 141                 case MT_EE_V2_BAND_SEL_5GHZ:
 142                         phy->mt76->cap.has_5ghz = true;
 143                         return;
 144                 case MT_EE_V2_BAND_SEL_6GHZ:
 145                         phy->mt76->cap.has_6ghz = true;
 146                         return;
 147                 case MT_EE_V2_BAND_SEL_5GHZ_6GHZ:
 148                         phy->mt76->cap.has_5ghz = true;
 149                         phy->mt76->cap.has_6ghz = true;
 150                         return;
 151                 default:
 152                         phy->mt76->cap.has_2ghz = true;
 153                         return;
 154                 }
 155         }
 156
 157         switch (val) {
 158         case MT_EE_BAND_SEL_5GHZ:
 159                 phy->mt76->cap.has_5ghz = true;
 160                 break;
 161         case MT_EE_BAND_SEL_2GHZ:
 162                 phy->mt76->cap.has_2ghz = true;
 163                 break;
 164         default:
 165                 phy->mt76->cap.has_2ghz = true;
 166                 phy->mt76->cap.has_5ghz = true;
 167                 break;
 168         }
 169 }
 170
 171 void mt7915_eeprom_parse_hw_cap(struct mt7915_dev *dev,
 172                                 struct mt7915_phy *phy)
 173 {
 174         u8 nss, nss_band, nss_band_max, *eeprom = dev->mt76.eeprom.data;
 175         struct mt76_phy *mphy = phy->mt76;
 176         bool ext_phy = phy != &dev->phy;
 177
 178         mt7915_eeprom_parse_band_config(phy);
 179
 180         /* read tx/rx mask from eeprom */
 181         if (is_mt7915(&dev->mt76)) {
 182                 nss = FIELD_GET(MT_EE_WIFI_CONF0_TX_PATH,
 183                                 eeprom[MT_EE_WIFI_CONF]);
 184         } else {
 185                 nss = FIELD_GET(MT_EE_WIFI_CONF0_TX_PATH,
 186                                 eeprom[MT_EE_WIFI_CONF + phy->band_idx]);
 187         }
 188
 189         if (!nss || nss > 4)
 190                 nss = 4;
 191
 192         /* read tx/rx stream */
 193         nss_band = nss;
 194
 195         if (dev->dbdc_support) {
 196                 if (is_mt7915(&dev->mt76)) {
 197                         nss_band = FIELD_GET(MT_EE_WIFI_CONF3_TX_PATH_B0,
 198                                              eeprom[MT_EE_WIFI_CONF + 3]);
 199                         if (phy->band_idx)
 200                                 nss_band = FIELD_GET(MT_EE_WIFI_CONF3_TX_PATH_B1,
 201                                                      eeprom[MT_EE_WIFI_CONF + 3]);
 202                 } else {
 203                         nss_band = FIELD_GET(MT_EE_WIFI_CONF_STREAM_NUM,
 204                                              eeprom[MT_EE_WIFI_CONF + 2 + phy->band_idx]);
 205                 }
 206
 207                 nss_band_max = is_mt7986(&dev->mt76) ?
 208                                MT_EE_NSS_MAX_DBDC_MA7986 : MT_EE_NSS_MAX_DBDC_MA7915;
 209         } else {
 210                 nss_band_max = is_mt7986(&dev->mt76) ?
 211                                MT_EE_NSS_MAX_MA7986 : MT_EE_NSS_MAX_MA7915;
 212         }
 213
 214         if (!nss_band || nss_band > nss_band_max)
 215                 nss_band = nss_band_max;
 216
 217         if (nss_band > nss) {
 218                 dev_warn(dev->mt76.dev,
 219                          "nss mismatch, nss(%d) nss_band(%d) band(%d) ext_phy(%d)\n",
 220                          nss, nss_band, phy->band_idx, ext_phy);
 221                 nss = nss_band;
 222         }
 223
 224         mphy->chainmask = BIT(nss) - 1;
 225         if (ext_phy)
 226                 mphy->chainmask <<= dev->chainshift;
 227         mphy->antenna_mask = BIT(nss_band) - 1;
 228         dev->chainmask |= mphy->chainmask;
 229         dev->chainshift = hweight8(dev->mphy.chainmask);
 230 }
 231
 232 int mt7915_eeprom_init(struct mt7915_dev *dev)
 233 {
 234         int ret;
 235
 236         ret = mt7915_eeprom_load(dev);
 237         if (ret < 0) {
 238                 if (ret != -EINVAL)
 239                         return ret;
 240
 241                 dev_warn(dev->mt76.dev, "eeprom load fail, use default bin\n");
 242                 ret = mt7915_eeprom_load_default(dev);
 243                 if (ret)
 244                         return ret;
 245         }
 246
 247         ret = mt7915_eeprom_load_precal(dev);
 248         if (ret)
 249                 return ret;
 250
 251         mt7915_eeprom_parse_hw_cap(dev, &dev->phy);
 252         memcpy(dev->mphy.macaddr, dev->mt76.eeprom.data + MT_EE_MAC_ADDR,
 253                ETH_ALEN);
 254
 255         mt76_eeprom_override(&dev->mphy);
 256
 257         return 0;
 258 }
 259
 260 int mt7915_eeprom_get_target_power(struct mt7915_dev *dev,
 261                                    struct ieee80211_channel *chan,
 262                                    u8 chain_idx)
 263 {
 264         u8 *eeprom = dev->mt76.eeprom.data;
 265         int index, target_power;
 266         bool tssi_on, is_7976;
 267
 268         if (chain_idx > 3)
 269                 return -EINVAL;
 270
 271         tssi_on = mt7915_tssi_enabled(dev, chan->band);
 272         is_7976 = mt7915_check_adie(dev, false) || is_mt7916(&dev->mt76);
 273
 274         if (chan->band == NL80211_BAND_2GHZ) {
 275                 if (is_7976) {
 276                         index = MT_EE_TX0_POWER_2G_V2 + chain_idx;
 277                         target_power = eeprom[index];
 278                 } else {
 279                         index = MT_EE_TX0_POWER_2G + chain_idx * 3;
 280                         target_power = eeprom[index];
 281
 282                         if (!tssi_on)
 283                                 target_power += eeprom[index + 1];
 284                 }
 285         } else if (chan->band == NL80211_BAND_5GHZ) {
 286                 int group = mt7915_get_channel_group_5g(chan->hw_value, is_7976);
 287
 288                 if (is_7976) {
 289                         index = MT_EE_TX0_POWER_5G_V2 + chain_idx * 5;
 290                         target_power = eeprom[index + group];
 291                 } else {
 292                         index = MT_EE_TX0_POWER_5G + chain_idx * 12;
 293                         target_power = eeprom[index + group];
 294
 295                         if (!tssi_on)
 296                                 target_power += eeprom[index + 8];
 297                 }
 298         } else {
 299                 int group = mt7915_get_channel_group_6g(chan->hw_value);
 300
 301                 index = MT_EE_TX0_POWER_6G_V2 + chain_idx * 8;
 302                 target_power = is_7976 ? eeprom[index + group] : 0;
 303         }
 304
 305         return target_power;
 306 }
 307
 308 s8 mt7915_eeprom_get_power_delta(struct mt7915_dev *dev, int band)
 309 {
 310         u8 *eeprom = dev->mt76.eeprom.data;
 311         u32 val, offs;
 312         s8 delta;
 313         bool is_7976 = mt7915_check_adie(dev, false) || is_mt7916(&dev->mt76);
 314
 315         if (band == NL80211_BAND_2GHZ)
 316                 offs = is_7976 ? MT_EE_RATE_DELTA_2G_V2 : MT_EE_RATE_DELTA_2G;
 317         else if (band == NL80211_BAND_5GHZ)
 318                 offs = is_7976 ? MT_EE_RATE_DELTA_5G_V2 : MT_EE_RATE_DELTA_5G;
 319         else
 320                 offs = is_7976 ? MT_EE_RATE_DELTA_6G_V2 : 0;
 321
 322         val = eeprom[offs];
 323
 324         if (!offs || !(val & MT_EE_RATE_DELTA_EN))
 325                 return 0;
 326
 327         delta = FIELD_GET(MT_EE_RATE_DELTA_MASK, val);
 328
 329         return val & MT_EE_RATE_DELTA_SIGN ? delta : -delta;
 330 }
 331
 332 const u8 mt7915_sku_group_len[] = {
 333         [SKU_CCK] = 4,
 334         [SKU_OFDM] = 8,
 335         [SKU_HT_BW20] = 8,
 336         [SKU_HT_BW40] = 9,
 337         [SKU_VHT_BW20] = 12,
 338         [SKU_VHT_BW40] = 12,
 339         [SKU_VHT_BW80] = 12,
 340         [SKU_VHT_BW160] = 12,
 341         [SKU_HE_RU26] = 12,
 342         [SKU_HE_RU52] = 12,
 343         [SKU_HE_RU106] = 12,
 344         [SKU_HE_RU242] = 12,
 345         [SKU_HE_RU484] = 12,
 346         [SKU_HE_RU996] = 12,
 347         [SKU_HE_RU2x996] = 12
 348 };