1 // SPDX-License-Identifier: BSD-3-Clause-Clear 2 /* 3 * Copyright (C) 2022 MediaTek Inc. 4 */ 5 6 #include <linux/firmware.h> 7 #include "mt7996.h" 8 #include "eeprom.h" 9 10 static int mt7996_check_eeprom(struct mt7996_dev *dev) 11 { 12 u8 *eeprom = dev->mt76.eeprom.data; 13 u16 val = get_unaligned_le16(eeprom); 14 15 switch (val) { 16 case MT7996_DEVICE_ID: 17 return is_mt7996(&dev->mt76) ? 0 : -EINVAL; 18 case MT7992_DEVICE_ID: 19 return is_mt7992(&dev->mt76) ? 0 : -EINVAL; 20 case MT7990_DEVICE_ID: 21 return is_mt7990(&dev->mt76) ? 0 : -EINVAL; 22 default: 23 return -EINVAL; 24 } 25 } 26 27 static char *mt7996_eeprom_name(struct mt7996_dev *dev) 28 { 29 switch (mt76_chip(&dev->mt76)) { 30 case MT7992_DEVICE_ID: 31 switch (dev->var.type) { 32 case MT7992_VAR_TYPE_23: 33 if (dev->var.fem == MT7996_FEM_INT) 34 return MT7992_EEPROM_DEFAULT_23_INT; 35 return MT7992_EEPROM_DEFAULT_23; 36 case MT7992_VAR_TYPE_24: 37 return MT7992_EEPROM_DEFAULT_24; 38 case MT7992_VAR_TYPE_44: 39 default: 40 if (dev->var.fem == MT7996_FEM_INT) 41 return MT7992_EEPROM_DEFAULT_INT; 42 if (dev->var.fem == MT7996_FEM_MIX) 43 return MT7992_EEPROM_DEFAULT_MIX; 44 return MT7992_EEPROM_DEFAULT; 45 } 46 case MT7990_DEVICE_ID: 47 if (dev->var.fem == MT7996_FEM_INT) 48 return MT7990_EEPROM_DEFAULT_INT; 49 return MT7990_EEPROM_DEFAULT; 50 case MT7996_DEVICE_ID: 51 default: 52 switch (dev->var.type) { 53 case MT7996_VAR_TYPE_233: 54 if (dev->var.fem == MT7996_FEM_INT) 55 return MT7996_EEPROM_DEFAULT_233_INT; 56 return MT7996_EEPROM_DEFAULT_233; 57 case MT7996_VAR_TYPE_444: 58 default: 59 if (dev->var.fem == MT7996_FEM_INT) 60 return MT7996_EEPROM_DEFAULT_INT; 61 return MT7996_EEPROM_DEFAULT; 62 } 63 } 64 } 65 66 static void 67 mt7996_eeprom_parse_stream(const u8 *eeprom, u8 band_idx, u8 *path, 68 u8 *rx_path, u8 *nss) 69 { 70 switch (band_idx) { 71 case MT_BAND1: 72 *path = FIELD_GET(MT_EE_WIFI_CONF2_TX_PATH_BAND1, 73 eeprom[MT_EE_WIFI_CONF + 2]); 74 *rx_path = FIELD_GET(MT_EE_WIFI_CONF3_RX_PATH_BAND1, 75 eeprom[MT_EE_WIFI_CONF + 3]); 76 *nss = FIELD_GET(MT_EE_WIFI_CONF5_STREAM_NUM_BAND1, 77 eeprom[MT_EE_WIFI_CONF + 5]); 78 break; 79 case MT_BAND2: 80 *path = FIELD_GET(MT_EE_WIFI_CONF2_TX_PATH_BAND2, 81 eeprom[MT_EE_WIFI_CONF + 2]); 82 *rx_path = FIELD_GET(MT_EE_WIFI_CONF4_RX_PATH_BAND2, 83 eeprom[MT_EE_WIFI_CONF + 4]); 84 *nss = FIELD_GET(MT_EE_WIFI_CONF5_STREAM_NUM_BAND2, 85 eeprom[MT_EE_WIFI_CONF + 5]); 86 break; 87 default: 88 *path = FIELD_GET(MT_EE_WIFI_CONF1_TX_PATH_BAND0, 89 eeprom[MT_EE_WIFI_CONF + 1]); 90 *rx_path = FIELD_GET(MT_EE_WIFI_CONF3_RX_PATH_BAND0, 91 eeprom[MT_EE_WIFI_CONF + 3]); 92 *nss = FIELD_GET(MT_EE_WIFI_CONF4_STREAM_NUM_BAND0, 93 eeprom[MT_EE_WIFI_CONF + 4]); 94 break; 95 } 96 } 97 98 static bool mt7996_eeprom_variant_valid(struct mt7996_dev *dev, const u8 *def) 99 { 100 #define FEM_INT 0 101 #define FEM_EXT 3 102 u8 *eeprom = dev->mt76.eeprom.data, fem[2]; 103 int i; 104 105 for (i = 0; i < 2; i++) 106 fem[i] = u8_get_bits(eeprom[MT_EE_WIFI_CONF + 6 + i], 107 MT_EE_WIFI_PA_LNA_CONFIG); 108 109 if (dev->var.fem == MT7996_FEM_EXT && 110 !(fem[0] == FEM_EXT && fem[1] == FEM_EXT)) 111 return false; 112 else if (dev->var.fem == MT7996_FEM_INT && 113 !(fem[0] == FEM_INT && fem[1] == FEM_INT)) 114 return false; 115 else if (dev->var.fem == MT7996_FEM_MIX && 116 !(fem[0] == FEM_INT && fem[1] == FEM_EXT)) 117 return false; 118 119 for (i = 0; i < __MT_MAX_BAND; i++) { 120 u8 path, rx_path, nss; 121 u8 def_path, def_rx_path, def_nss; 122 123 if (!dev->mt76.phys[i]) 124 continue; 125 126 mt7996_eeprom_parse_stream(eeprom, i, &path, &rx_path, &nss); 127 mt7996_eeprom_parse_stream(def, i, &def_path, &def_rx_path, 128 &def_nss); 129 if (path > def_path || rx_path > def_rx_path || nss > def_nss) 130 return false; 131 } 132 133 return true; 134 } 135 136 static int 137 mt7996_eeprom_check_or_use_default(struct mt7996_dev *dev, bool use_default) 138 { 139 u8 *eeprom = dev->mt76.eeprom.data; 140 const struct firmware *fw = NULL; 141 int ret; 142 143 ret = request_firmware(&fw, mt7996_eeprom_name(dev), dev->mt76.dev); 144 if (ret) 145 return ret; 146 147 if (!fw || !fw->data) { 148 dev_err(dev->mt76.dev, "Invalid default bin\n"); 149 ret = -EINVAL; 150 goto out; 151 } 152 153 if (fw->size < MT7996_EEPROM_SIZE) { 154 dev_err(dev->mt76.dev, "Invalid default bin size\n"); 155 ret = -EINVAL; 156 goto out; 157 } 158 159 if (!use_default && mt7996_eeprom_variant_valid(dev, fw->data)) 160 goto out; 161 162 dev_warn(dev->mt76.dev, "eeprom load fail, use default bin\n"); 163 memcpy(eeprom, fw->data, MT7996_EEPROM_SIZE); 164 dev->eeprom_mode = EEPROM_MODE_DEFAULT_BIN; 165 166 out: 167 release_firmware(fw); 168 169 return ret; 170 } 171 172 static int mt7996_eeprom_load(struct mt7996_dev *dev) 173 { 174 u32 eeprom_blk_size, block_num; 175 bool use_default = false; 176 int ret, i; 177 178 ret = mt76_eeprom_init(&dev->mt76, MT7996_EEPROM_SIZE); 179 if (ret < 0) 180 return ret; 181 182 if (ret && !mt7996_check_eeprom(dev)) { 183 dev->eeprom_mode = EEPROM_MODE_FLASH; 184 goto out; 185 } 186 187 memset(dev->mt76.eeprom.data, 0, MT7996_EEPROM_SIZE); 188 if (mt7996_has_ext_eeprom(dev)) { 189 /* external eeprom mode */ 190 dev->eeprom_mode = EEPROM_MODE_EXT; 191 eeprom_blk_size = MT7996_EXT_EEPROM_BLOCK_SIZE; 192 } else { 193 u8 free_block_num; 194 195 /* efuse mode */ 196 dev->eeprom_mode = EEPROM_MODE_EFUSE; 197 eeprom_blk_size = MT7996_EEPROM_BLOCK_SIZE; 198 ret = mt7996_mcu_get_efuse_free_block(dev, &free_block_num); 199 if (ret < 0) 200 return ret; 201 202 /* efuse info isn't enough */ 203 if (free_block_num >= 59) { 204 use_default = true; 205 goto out; 206 } 207 } 208 209 /* check if eeprom data from fw is valid */ 210 if (mt7996_mcu_get_eeprom(dev, 0, NULL, eeprom_blk_size, 211 dev->eeprom_mode) || 212 mt7996_check_eeprom(dev)) { 213 use_default = true; 214 goto out; 215 } 216 217 /* read eeprom data from fw */ 218 block_num = DIV_ROUND_UP(MT7996_EEPROM_SIZE, eeprom_blk_size); 219 for (i = 1; i < block_num; i++) { 220 u32 len = eeprom_blk_size; 221 222 if (i == block_num - 1) 223 len = MT7996_EEPROM_SIZE % eeprom_blk_size; 224 ret = mt7996_mcu_get_eeprom(dev, i * eeprom_blk_size, 225 NULL, len, dev->eeprom_mode); 226 if (ret && ret != -EINVAL) { 227 use_default = true; 228 goto out; 229 } 230 } 231 232 out: 233 return mt7996_eeprom_check_or_use_default(dev, use_default); 234 } 235 236 static int mt7996_eeprom_parse_efuse_hw_cap(struct mt7996_phy *phy, 237 u8 *path, u8 *rx_path, u8 *nss) 238 { 239 #define MODE_HE_ONLY BIT(0) 240 #define WTBL_SIZE_GROUP GENMASK(31, 28) 241 #define STREAM_CAP(_offs) ((cap & (0x7 << (_offs))) >> (_offs)) 242 struct mt7996_dev *dev = phy->dev; 243 u32 cap = 0; 244 int ret; 245 246 ret = mt7996_mcu_get_chip_config(dev, &cap); 247 if (ret) 248 return ret; 249 250 if (cap) { 251 u8 band_offs = phy->mt76->band_idx * 3; 252 253 dev->has_eht = !(cap & MODE_HE_ONLY); 254 dev->wtbl_size_group = u32_get_bits(cap, WTBL_SIZE_GROUP); 255 *nss = min_t(u8, *nss, STREAM_CAP(1 + band_offs)); 256 *path = min_t(u8, *path, STREAM_CAP(10 + band_offs)); 257 *rx_path = min_t(u8, *rx_path, STREAM_CAP(19 + band_offs)); 258 } 259 260 if (dev->wtbl_size_group < 2 || dev->wtbl_size_group > 4) 261 dev->wtbl_size_group = is_mt7996(&dev->mt76) ? 4 : 2; 262 263 return 0; 264 } 265 266 static int mt7996_eeprom_parse_band_config(struct mt7996_phy *phy) 267 { 268 u8 *eeprom = phy->dev->mt76.eeprom.data; 269 u32 val = eeprom[MT_EE_WIFI_CONF]; 270 int ret = 0; 271 272 switch (phy->mt76->band_idx) { 273 case MT_BAND1: 274 val = FIELD_GET(MT_EE_WIFI_CONF1_BAND_SEL, val); 275 break; 276 case MT_BAND2: 277 val = eeprom[MT_EE_WIFI_CONF + 1]; 278 val = FIELD_GET(MT_EE_WIFI_CONF2_BAND_SEL, val); 279 break; 280 default: 281 val = FIELD_GET(MT_EE_WIFI_CONF0_BAND_SEL, val); 282 break; 283 } 284 285 switch (val) { 286 case MT_EE_BAND_SEL_2GHZ: 287 phy->mt76->cap.has_2ghz = true; 288 break; 289 case MT_EE_BAND_SEL_5GHZ: 290 phy->mt76->cap.has_5ghz = true; 291 break; 292 case MT_EE_BAND_SEL_6GHZ: 293 phy->mt76->cap.has_6ghz = true; 294 break; 295 default: 296 ret = -EINVAL; 297 break; 298 } 299 300 return ret; 301 } 302 303 int mt7996_eeprom_parse_hw_cap(struct mt7996_dev *dev, struct mt7996_phy *phy) 304 { 305 u8 path, rx_path, nss, band_idx = phy->mt76->band_idx; 306 u8 *eeprom = dev->mt76.eeprom.data; 307 struct mt76_phy *mphy = phy->mt76; 308 int max_path = 5, max_nss = 4; 309 int ret; 310 311 mt7996_eeprom_parse_stream(eeprom, band_idx, &path, &rx_path, &nss); 312 ret = mt7996_eeprom_parse_efuse_hw_cap(phy, &path, &rx_path, &nss); 313 if (ret) 314 return ret; 315 316 if (!path || path > max_path) 317 path = max_path; 318 319 if (!nss || nss > max_nss) 320 nss = max_nss; 321 322 nss = min_t(u8, nss, path); 323 324 if (path != rx_path) 325 phy->has_aux_rx = true; 326 327 mphy->antenna_mask = BIT(nss) - 1; 328 phy->orig_antenna_mask = mphy->antenna_mask; 329 mphy->chainmask = (BIT(path) - 1) << dev->chainshift[band_idx]; 330 phy->orig_chainmask = mphy->chainmask; 331 dev->chainmask |= mphy->chainmask; 332 if (band_idx < MT_BAND2) 333 dev->chainshift[band_idx + 1] = dev->chainshift[band_idx] + 334 hweight16(mphy->chainmask); 335 336 return mt7996_eeprom_parse_band_config(phy); 337 } 338 339 int mt7996_eeprom_init(struct mt7996_dev *dev) 340 { 341 int ret; 342 343 ret = mt7996_eeprom_load(dev); 344 if (ret < 0) 345 return ret; 346 347 ret = mt7996_eeprom_parse_hw_cap(dev, &dev->phy); 348 if (ret < 0) 349 return ret; 350 351 memcpy(dev->mphy.macaddr, dev->mt76.eeprom.data + MT_EE_MAC_ADDR, ETH_ALEN); 352 353 return mt76_eeprom_override(&dev->mphy); 354 } 355 356 int mt7996_eeprom_get_target_power(struct mt7996_dev *dev, 357 struct ieee80211_channel *chan) 358 { 359 u8 *eeprom = dev->mt76.eeprom.data; 360 int target_power; 361 362 if (chan->band == NL80211_BAND_5GHZ) 363 target_power = eeprom[MT_EE_TX0_POWER_5G + 364 mt7996_get_channel_group_5g(chan->hw_value)]; 365 else if (chan->band == NL80211_BAND_6GHZ) 366 target_power = eeprom[MT_EE_TX0_POWER_6G + 367 mt7996_get_channel_group_6g(chan->hw_value)]; 368 else 369 target_power = eeprom[MT_EE_TX0_POWER_2G]; 370 371 return target_power; 372 } 373 374 s8 mt7996_eeprom_get_power_delta(struct mt7996_dev *dev, int band) 375 { 376 u8 *eeprom = dev->mt76.eeprom.data; 377 u32 val; 378 s8 delta; 379 380 if (band == NL80211_BAND_5GHZ) 381 val = eeprom[MT_EE_RATE_DELTA_5G]; 382 else if (band == NL80211_BAND_6GHZ) 383 val = eeprom[MT_EE_RATE_DELTA_6G]; 384 else 385 val = eeprom[MT_EE_RATE_DELTA_2G]; 386 387 if (!(val & MT_EE_RATE_DELTA_EN)) 388 return 0; 389 390 delta = FIELD_GET(MT_EE_RATE_DELTA_MASK, val); 391 392 return val & MT_EE_RATE_DELTA_SIGN ? delta : -delta; 393 } 394 395 bool mt7996_eeprom_has_background_radar(struct mt7996_dev *dev) 396 { 397 switch (mt76_chip(&dev->mt76)) { 398 case MT7996_DEVICE_ID: 399 if (dev->var.type == MT7996_VAR_TYPE_233) 400 return false; 401 break; 402 case MT7992_DEVICE_ID: 403 if (dev->var.type == MT7992_VAR_TYPE_23 || 404 dev->var.type == MT7992_VAR_TYPE_24) 405 return false; 406 break; 407 case MT7990_DEVICE_ID: { 408 u8 path, rx_path, nss, *eeprom = dev->mt76.eeprom.data; 409 410 mt7996_eeprom_parse_stream(eeprom, MT_BAND1, &path, &rx_path, &nss); 411 /* Disable background radar capability in 3T3R */ 412 if (path == 3 || rx_path == 3) 413 return false; 414 break; 415 } 416 default: 417 return false; 418 } 419 420 return true; 421 } 422