drivers/net/wireless/mediatek/mt76/mt76x2_eeprom.c

   1 /*
   2  * Copyright (C) 2016 Felix Fietkau <nbd@nbd.name>
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include <asm/unaligned.h>
  18 #include "mt76x2.h"
  19 #include "mt76x2_eeprom.h"
  20
  21 #define EE_FIELD(_name, _value) [MT_EE_##_name] = (_value) | 1
  22
  23 static int
  24 mt76x2_eeprom_copy(struct mt76x2_dev *dev, enum mt76x02_eeprom_field field,
  25                    void *dest, int len)
  26 {
  27         if (field + len > dev->mt76.eeprom.size)
  28                 return -1;
  29
  30         memcpy(dest, dev->mt76.eeprom.data + field, len);
  31         return 0;
  32 }
  33
  34 static int
  35 mt76x2_eeprom_get_macaddr(struct mt76x2_dev *dev)
  36 {
  37         void *src = dev->mt76.eeprom.data + MT_EE_MAC_ADDR;
  38
  39         memcpy(dev->mt76.macaddr, src, ETH_ALEN);
  40         return 0;
  41 }
  42
  43 static bool
  44 mt76x2_has_cal_free_data(struct mt76x2_dev *dev, u8 *efuse)
  45 {
  46         u16 *efuse_w = (u16 *) efuse;
  47
  48         if (efuse_w[MT_EE_NIC_CONF_0] != 0)
  49                 return false;
  50
  51         if (efuse_w[MT_EE_XTAL_TRIM_1] == 0xffff)
  52                 return false;
  53
  54         if (efuse_w[MT_EE_TX_POWER_DELTA_BW40] != 0)
  55                 return false;
  56
  57         if (efuse_w[MT_EE_TX_POWER_0_START_2G] == 0xffff)
  58                 return false;
  59
  60         if (efuse_w[MT_EE_TX_POWER_0_GRP3_TX_POWER_DELTA] != 0)
  61                 return false;
  62
  63         if (efuse_w[MT_EE_TX_POWER_0_GRP4_TSSI_SLOPE] == 0xffff)
  64                 return false;
  65
  66         return true;
  67 }
  68
  69 static void
  70 mt76x2_apply_cal_free_data(struct mt76x2_dev *dev, u8 *efuse)
  71 {
  72 #define GROUP_5G(_id)                                                      \
  73         MT_EE_TX_POWER_0_START_5G + MT_TX_POWER_GROUP_SIZE_5G * (_id),     \
  74         MT_EE_TX_POWER_0_START_5G + MT_TX_POWER_GROUP_SIZE_5G * (_id) + 1, \
  75         MT_EE_TX_POWER_1_START_5G + MT_TX_POWER_GROUP_SIZE_5G * (_id),     \
  76         MT_EE_TX_POWER_1_START_5G + MT_TX_POWER_GROUP_SIZE_5G * (_id) + 1
  77
  78         static const u8 cal_free_bytes[] = {
  79                 MT_EE_XTAL_TRIM_1,
  80                 MT_EE_TX_POWER_EXT_PA_5G + 1,
  81                 MT_EE_TX_POWER_0_START_2G,
  82                 MT_EE_TX_POWER_0_START_2G + 1,
  83                 MT_EE_TX_POWER_1_START_2G,
  84                 MT_EE_TX_POWER_1_START_2G + 1,
  85                 GROUP_5G(0),
  86                 GROUP_5G(1),
  87                 GROUP_5G(2),
  88                 GROUP_5G(3),
  89                 GROUP_5G(4),
  90                 GROUP_5G(5),
  91                 MT_EE_RF_2G_TSSI_OFF_TXPOWER,
  92                 MT_EE_RF_2G_RX_HIGH_GAIN + 1,
  93                 MT_EE_RF_5G_GRP0_1_RX_HIGH_GAIN,
  94                 MT_EE_RF_5G_GRP0_1_RX_HIGH_GAIN + 1,
  95                 MT_EE_RF_5G_GRP2_3_RX_HIGH_GAIN,
  96                 MT_EE_RF_5G_GRP2_3_RX_HIGH_GAIN + 1,
  97                 MT_EE_RF_5G_GRP4_5_RX_HIGH_GAIN,
  98                 MT_EE_RF_5G_GRP4_5_RX_HIGH_GAIN + 1,
  99         };
 100         u8 *eeprom = dev->mt76.eeprom.data;
 101         u8 prev_grp0[4] = {
 102                 eeprom[MT_EE_TX_POWER_0_START_5G],
 103                 eeprom[MT_EE_TX_POWER_0_START_5G + 1],
 104                 eeprom[MT_EE_TX_POWER_1_START_5G],
 105                 eeprom[MT_EE_TX_POWER_1_START_5G + 1]
 106         };
 107         u16 val;
 108         int i;
 109
 110         if (!mt76x2_has_cal_free_data(dev, efuse))
 111                 return;
 112
 113         for (i = 0; i < ARRAY_SIZE(cal_free_bytes); i++) {
 114                 int offset = cal_free_bytes[i];
 115
 116                 eeprom[offset] = efuse[offset];
 117         }
 118
 119         if (!(efuse[MT_EE_TX_POWER_0_START_5G] |
 120               efuse[MT_EE_TX_POWER_0_START_5G + 1]))
 121                 memcpy(eeprom + MT_EE_TX_POWER_0_START_5G, prev_grp0, 2);
 122         if (!(efuse[MT_EE_TX_POWER_1_START_5G] |
 123               efuse[MT_EE_TX_POWER_1_START_5G + 1]))
 124                 memcpy(eeprom + MT_EE_TX_POWER_1_START_5G, prev_grp0 + 2, 2);
 125
 126         val = get_unaligned_le16(efuse + MT_EE_BT_RCAL_RESULT);
 127         if (val != 0xffff)
 128                 eeprom[MT_EE_BT_RCAL_RESULT] = val & 0xff;
 129
 130         val = get_unaligned_le16(efuse + MT_EE_BT_VCDL_CALIBRATION);
 131         if (val != 0xffff)
 132                 eeprom[MT_EE_BT_VCDL_CALIBRATION + 1] = val >> 8;
 133
 134         val = get_unaligned_le16(efuse + MT_EE_BT_PMUCFG);
 135         if (val != 0xffff)
 136                 eeprom[MT_EE_BT_PMUCFG] = val & 0xff;
 137 }
 138
 139 static int mt76x2_check_eeprom(struct mt76x2_dev *dev)
 140 {
 141         u16 val = get_unaligned_le16(dev->mt76.eeprom.data);
 142
 143         if (!val)
 144                 val = get_unaligned_le16(dev->mt76.eeprom.data + MT_EE_PCI_ID);
 145
 146         switch (val) {
 147         case 0x7662:
 148         case 0x7612:
 149                 return 0;
 150         default:
 151                 dev_err(dev->mt76.dev, "EEPROM data check failed: %04x\n", val);
 152                 return -EINVAL;
 153         }
 154 }
 155
 156 static int
 157 mt76x2_eeprom_load(struct mt76x2_dev *dev)
 158 {
 159         void *efuse;
 160         bool found;
 161         int ret;
 162
 163         ret = mt76_eeprom_init(&dev->mt76, MT7662_EEPROM_SIZE);
 164         if (ret < 0)
 165                 return ret;
 166
 167         found = ret;
 168         if (found)
 169                 found = !mt76x2_check_eeprom(dev);
 170
 171         dev->mt76.otp.data = devm_kzalloc(dev->mt76.dev, MT7662_EEPROM_SIZE,
 172                                           GFP_KERNEL);
 173         dev->mt76.otp.size = MT7662_EEPROM_SIZE;
 174         if (!dev->mt76.otp.data)
 175                 return -ENOMEM;
 176
 177         efuse = dev->mt76.otp.data;
 178
 179         if (mt76x02_get_efuse_data(&dev->mt76, 0, efuse,
 180                                    MT7662_EEPROM_SIZE, MT_EE_READ))
 181                 goto out;
 182
 183         if (found) {
 184                 mt76x2_apply_cal_free_data(dev, efuse);
 185         } else {
 186                 /* FIXME: check if efuse data is complete */
 187                 found = true;
 188                 memcpy(dev->mt76.eeprom.data, efuse, MT7662_EEPROM_SIZE);
 189         }
 190
 191 out:
 192         if (!found)
 193                 return -ENOENT;
 194
 195         return 0;
 196 }
 197
 198 static inline int
 199 mt76x2_sign_extend_optional(u32 val, unsigned int size)
 200 {
 201         bool enable = val & BIT(size);
 202
 203         return enable ? mt76x02_sign_extend(val, size) : 0;
 204 }
 205
 206 static void
 207 mt76x2_set_rx_gain_group(struct mt76x2_dev *dev, u8 val)
 208 {
 209         s8 *dest = dev->cal.rx.high_gain;
 210
 211         if (!mt76x02_field_valid(val)) {
 212                 dest[0] = 0;
 213                 dest[1] = 0;
 214                 return;
 215         }
 216
 217         dest[0] = mt76x02_sign_extend(val, 4);
 218         dest[1] = mt76x02_sign_extend(val >> 4, 4);
 219 }
 220
 221 static void
 222 mt76x2_set_rssi_offset(struct mt76x2_dev *dev, int chain, u8 val)
 223 {
 224         s8 *dest = dev->cal.rx.rssi_offset;
 225
 226         if (!mt76x02_field_valid(val)) {
 227                 dest[chain] = 0;
 228                 return;
 229         }
 230
 231         dest[chain] = mt76x2_sign_extend_optional(val, 7);
 232 }
 233
 234 static enum mt76x2_cal_channel_group
 235 mt76x2_get_cal_channel_group(int channel)
 236 {
 237         if (channel >= 184 && channel <= 196)
 238                 return MT_CH_5G_JAPAN;
 239         if (channel <= 48)
 240                 return MT_CH_5G_UNII_1;
 241         if (channel <= 64)
 242                 return MT_CH_5G_UNII_2;
 243         if (channel <= 114)
 244                 return MT_CH_5G_UNII_2E_1;
 245         if (channel <= 144)
 246                 return MT_CH_5G_UNII_2E_2;
 247         return MT_CH_5G_UNII_3;
 248 }
 249
 250 static u8
 251 mt76x2_get_5g_rx_gain(struct mt76x2_dev *dev, u8 channel)
 252 {
 253         enum mt76x2_cal_channel_group group;
 254
 255         group = mt76x2_get_cal_channel_group(channel);
 256         switch (group) {
 257         case MT_CH_5G_JAPAN:
 258                 return mt76x02_eeprom_get(&dev->mt76,
 259                                           MT_EE_RF_5G_GRP0_1_RX_HIGH_GAIN);
 260         case MT_CH_5G_UNII_1:
 261                 return mt76x02_eeprom_get(&dev->mt76,
 262                                           MT_EE_RF_5G_GRP0_1_RX_HIGH_GAIN) >> 8;
 263         case MT_CH_5G_UNII_2:
 264                 return mt76x02_eeprom_get(&dev->mt76,
 265                                           MT_EE_RF_5G_GRP2_3_RX_HIGH_GAIN);
 266         case MT_CH_5G_UNII_2E_1:
 267                 return mt76x02_eeprom_get(&dev->mt76,
 268                                           MT_EE_RF_5G_GRP2_3_RX_HIGH_GAIN) >> 8;
 269         case MT_CH_5G_UNII_2E_2:
 270                 return mt76x02_eeprom_get(&dev->mt76,
 271                                           MT_EE_RF_5G_GRP4_5_RX_HIGH_GAIN);
 272         default:
 273                 return mt76x02_eeprom_get(&dev->mt76,
 274                                           MT_EE_RF_5G_GRP4_5_RX_HIGH_GAIN) >> 8;
 275         }
 276 }
 277
 278 void mt76x2_read_rx_gain(struct mt76x2_dev *dev)
 279 {
 280         struct ieee80211_channel *chan = dev->mt76.chandef.chan;
 281         int channel = chan->hw_value;
 282         s8 lna_5g[3], lna_2g;
 283         u8 lna;
 284         u16 val;
 285
 286         if (chan->band == NL80211_BAND_2GHZ)
 287                 val = mt76x02_eeprom_get(&dev->mt76,
 288                                          MT_EE_RF_2G_RX_HIGH_GAIN) >> 8;
 289         else
 290                 val = mt76x2_get_5g_rx_gain(dev, channel);
 291
 292         mt76x2_set_rx_gain_group(dev, val);
 293
 294         mt76x02_get_rx_gain(&dev->mt76, chan->band, &val, &lna_2g, lna_5g);
 295         mt76x2_set_rssi_offset(dev, 0, val);
 296         mt76x2_set_rssi_offset(dev, 1, val >> 8);
 297
 298         dev->cal.rx.mcu_gain =  (lna_2g & 0xff);
 299         dev->cal.rx.mcu_gain |= (lna_5g[0] & 0xff) << 8;
 300         dev->cal.rx.mcu_gain |= (lna_5g[1] & 0xff) << 16;
 301         dev->cal.rx.mcu_gain |= (lna_5g[2] & 0xff) << 24;
 302
 303         lna = mt76x02_get_lna_gain(&dev->mt76, &lna_2g, lna_5g, chan);
 304         dev->cal.rx.lna_gain = mt76x02_sign_extend(lna, 8);
 305 }
 306 EXPORT_SYMBOL_GPL(mt76x2_read_rx_gain);
 307
 308 static s8
 309 mt76x2_rate_power_val(u8 val)
 310 {
 311         if (!mt76x02_field_valid(val))
 312                 return 0;
 313
 314         return mt76x2_sign_extend_optional(val, 7);
 315 }
 316
 317 void mt76x2_get_rate_power(struct mt76x2_dev *dev, struct mt76_rate_power *t,
 318                            struct ieee80211_channel *chan)
 319 {
 320         bool is_5ghz;
 321         u16 val;
 322
 323         is_5ghz = chan->band == NL80211_BAND_5GHZ;
 324
 325         memset(t, 0, sizeof(*t));
 326
 327         val = mt76x02_eeprom_get(&dev->mt76, MT_EE_TX_POWER_CCK);
 328         t->cck[0] = t->cck[1] = mt76x2_rate_power_val(val);
 329         t->cck[2] = t->cck[3] = mt76x2_rate_power_val(val >> 8);
 330
 331         if (is_5ghz)
 332                 val = mt76x02_eeprom_get(&dev->mt76,
 333                                          MT_EE_TX_POWER_OFDM_5G_6M);
 334         else
 335                 val = mt76x02_eeprom_get(&dev->mt76,
 336                                          MT_EE_TX_POWER_OFDM_2G_6M);
 337         t->ofdm[0] = t->ofdm[1] = mt76x2_rate_power_val(val);
 338         t->ofdm[2] = t->ofdm[3] = mt76x2_rate_power_val(val >> 8);
 339
 340         if (is_5ghz)
 341                 val = mt76x02_eeprom_get(&dev->mt76,
 342                                          MT_EE_TX_POWER_OFDM_5G_24M);
 343         else
 344                 val = mt76x02_eeprom_get(&dev->mt76,
 345                                          MT_EE_TX_POWER_OFDM_2G_24M);
 346         t->ofdm[4] = t->ofdm[5] = mt76x2_rate_power_val(val);
 347         t->ofdm[6] = t->ofdm[7] = mt76x2_rate_power_val(val >> 8);
 348
 349         val = mt76x02_eeprom_get(&dev->mt76, MT_EE_TX_POWER_HT_MCS0);
 350         t->ht[0] = t->ht[1] = mt76x2_rate_power_val(val);
 351         t->ht[2] = t->ht[3] = mt76x2_rate_power_val(val >> 8);
 352
 353         val = mt76x02_eeprom_get(&dev->mt76, MT_EE_TX_POWER_HT_MCS4);
 354         t->ht[4] = t->ht[5] = mt76x2_rate_power_val(val);
 355         t->ht[6] = t->ht[7] = mt76x2_rate_power_val(val >> 8);
 356
 357         val = mt76x02_eeprom_get(&dev->mt76, MT_EE_TX_POWER_HT_MCS8);
 358         t->ht[8] = t->ht[9] = mt76x2_rate_power_val(val);
 359         t->ht[10] = t->ht[11] = mt76x2_rate_power_val(val >> 8);
 360
 361         val = mt76x02_eeprom_get(&dev->mt76, MT_EE_TX_POWER_HT_MCS12);
 362         t->ht[12] = t->ht[13] = mt76x2_rate_power_val(val);
 363         t->ht[14] = t->ht[15] = mt76x2_rate_power_val(val >> 8);
 364
 365         val = mt76x02_eeprom_get(&dev->mt76, MT_EE_TX_POWER_VHT_MCS0);
 366         t->vht[0] = t->vht[1] = mt76x2_rate_power_val(val);
 367         t->vht[2] = t->vht[3] = mt76x2_rate_power_val(val >> 8);
 368
 369         val = mt76x02_eeprom_get(&dev->mt76, MT_EE_TX_POWER_VHT_MCS4);
 370         t->vht[4] = t->vht[5] = mt76x2_rate_power_val(val);
 371         t->vht[6] = t->vht[7] = mt76x2_rate_power_val(val >> 8);
 372
 373         val = mt76x02_eeprom_get(&dev->mt76, MT_EE_TX_POWER_VHT_MCS8);
 374         if (!is_5ghz)
 375                 val >>= 8;
 376         t->vht[8] = t->vht[9] = mt76x2_rate_power_val(val >> 8);
 377
 378         memcpy(t->stbc, t->ht, sizeof(t->stbc[0]) * 8);
 379         t->stbc[8] = t->vht[8];
 380         t->stbc[9] = t->vht[9];
 381 }
 382 EXPORT_SYMBOL_GPL(mt76x2_get_rate_power);
 383
 384 int mt76x2_get_max_rate_power(struct mt76_rate_power *r)
 385 {
 386         int i;
 387         s8 ret = 0;
 388
 389         for (i = 0; i < sizeof(r->all); i++)
 390                 ret = max(ret, r->all[i]);
 391
 392         return ret;
 393 }
 394 EXPORT_SYMBOL_GPL(mt76x2_get_max_rate_power);
 395
 396 static void
 397 mt76x2_get_power_info_2g(struct mt76x2_dev *dev, struct mt76x2_tx_power_info *t,
 398                          struct ieee80211_channel *chan, int chain, int offset)
 399 {
 400         int channel = chan->hw_value;
 401         int delta_idx;
 402         u8 data[6];
 403         u16 val;
 404
 405         if (channel < 6)
 406                 delta_idx = 3;
 407         else if (channel < 11)
 408                 delta_idx = 4;
 409         else
 410                 delta_idx = 5;
 411
 412         mt76x2_eeprom_copy(dev, offset, data, sizeof(data));
 413
 414         t->chain[chain].tssi_slope = data[0];
 415         t->chain[chain].tssi_offset = data[1];
 416         t->chain[chain].target_power = data[2];
 417         t->chain[chain].delta = mt76x2_sign_extend_optional(data[delta_idx], 7);
 418
 419         val = mt76x02_eeprom_get(&dev->mt76, MT_EE_RF_2G_TSSI_OFF_TXPOWER);
 420         t->target_power = val >> 8;
 421 }
 422
 423 static void
 424 mt76x2_get_power_info_5g(struct mt76x2_dev *dev, struct mt76x2_tx_power_info *t,
 425                          struct ieee80211_channel *chan, int chain, int offset)
 426 {
 427         int channel = chan->hw_value;
 428         enum mt76x2_cal_channel_group group;
 429         int delta_idx;
 430         u16 val;
 431         u8 data[5];
 432
 433         group = mt76x2_get_cal_channel_group(channel);
 434         offset += group * MT_TX_POWER_GROUP_SIZE_5G;
 435
 436         if (channel >= 192)
 437                 delta_idx = 4;
 438         else if (channel >= 184)
 439                 delta_idx = 3;
 440         else if (channel < 44)
 441                 delta_idx = 3;
 442         else if (channel < 52)
 443                 delta_idx = 4;
 444         else if (channel < 58)
 445                 delta_idx = 3;
 446         else if (channel < 98)
 447                 delta_idx = 4;
 448         else if (channel < 106)
 449                 delta_idx = 3;
 450         else if (channel < 116)
 451                 delta_idx = 4;
 452         else if (channel < 130)
 453                 delta_idx = 3;
 454         else if (channel < 149)
 455                 delta_idx = 4;
 456         else if (channel < 157)
 457                 delta_idx = 3;
 458         else
 459                 delta_idx = 4;
 460
 461         mt76x2_eeprom_copy(dev, offset, data, sizeof(data));
 462
 463         t->chain[chain].tssi_slope = data[0];
 464         t->chain[chain].tssi_offset = data[1];
 465         t->chain[chain].target_power = data[2];
 466         t->chain[chain].delta = mt76x2_sign_extend_optional(data[delta_idx], 7);
 467
 468         val = mt76x02_eeprom_get(&dev->mt76, MT_EE_RF_2G_RX_HIGH_GAIN);
 469         t->target_power = val & 0xff;
 470 }
 471
 472 void mt76x2_get_power_info(struct mt76x2_dev *dev,
 473                            struct mt76x2_tx_power_info *t,
 474                            struct ieee80211_channel *chan)
 475 {
 476         u16 bw40, bw80;
 477
 478         memset(t, 0, sizeof(*t));
 479
 480         bw40 = mt76x02_eeprom_get(&dev->mt76, MT_EE_TX_POWER_DELTA_BW40);
 481         bw80 = mt76x02_eeprom_get(&dev->mt76, MT_EE_TX_POWER_DELTA_BW80);
 482
 483         if (chan->band == NL80211_BAND_5GHZ) {
 484                 bw40 >>= 8;
 485                 mt76x2_get_power_info_5g(dev, t, chan, 0,
 486                                          MT_EE_TX_POWER_0_START_5G);
 487                 mt76x2_get_power_info_5g(dev, t, chan, 1,
 488                                          MT_EE_TX_POWER_1_START_5G);
 489         } else {
 490                 mt76x2_get_power_info_2g(dev, t, chan, 0,
 491                                          MT_EE_TX_POWER_0_START_2G);
 492                 mt76x2_get_power_info_2g(dev, t, chan, 1,
 493                                          MT_EE_TX_POWER_1_START_2G);
 494         }
 495
 496         if (mt76x2_tssi_enabled(dev) ||
 497             !mt76x02_field_valid(t->target_power))
 498                 t->target_power = t->chain[0].target_power;
 499
 500         t->delta_bw40 = mt76x2_rate_power_val(bw40);
 501         t->delta_bw80 = mt76x2_rate_power_val(bw80);
 502 }
 503 EXPORT_SYMBOL_GPL(mt76x2_get_power_info);
 504
 505 int mt76x2_get_temp_comp(struct mt76x2_dev *dev, struct mt76x2_temp_comp *t)
 506 {
 507         enum nl80211_band band = dev->mt76.chandef.chan->band;
 508         u16 val, slope;
 509         u8 bounds;
 510
 511         memset(t, 0, sizeof(*t));
 512
 513         if (!mt76x2_temp_tx_alc_enabled(dev))
 514                 return -EINVAL;
 515
 516         if (!mt76x02_ext_pa_enabled(&dev->mt76, band))
 517                 return -EINVAL;
 518
 519         val = mt76x02_eeprom_get(&dev->mt76, MT_EE_TX_POWER_EXT_PA_5G) >> 8;
 520         t->temp_25_ref = val & 0x7f;
 521         if (band == NL80211_BAND_5GHZ) {
 522                 slope = mt76x02_eeprom_get(&dev->mt76,
 523                                            MT_EE_RF_TEMP_COMP_SLOPE_5G);
 524                 bounds = mt76x02_eeprom_get(&dev->mt76,
 525                                             MT_EE_TX_POWER_EXT_PA_5G);
 526         } else {
 527                 slope = mt76x02_eeprom_get(&dev->mt76,
 528                                            MT_EE_RF_TEMP_COMP_SLOPE_2G);
 529                 bounds = mt76x02_eeprom_get(&dev->mt76,
 530                                             MT_EE_TX_POWER_DELTA_BW80) >> 8;
 531         }
 532
 533         t->high_slope = slope & 0xff;
 534         t->low_slope = slope >> 8;
 535         t->lower_bound = 0 - (bounds & 0xf);
 536         t->upper_bound = (bounds >> 4) & 0xf;
 537
 538         return 0;
 539 }
 540 EXPORT_SYMBOL_GPL(mt76x2_get_temp_comp);
 541
 542 int mt76x2_eeprom_init(struct mt76x2_dev *dev)
 543 {
 544         int ret;
 545
 546         ret = mt76x2_eeprom_load(dev);
 547         if (ret)
 548                 return ret;
 549
 550         mt76x02_eeprom_parse_hw_cap(&dev->mt76);
 551         mt76x2_eeprom_get_macaddr(dev);
 552         mt76_eeprom_override(&dev->mt76);
 553         dev->mt76.macaddr[0] &= ~BIT(1);
 554
 555         return 0;
 556 }
 557 EXPORT_SYMBOL_GPL(mt76x2_eeprom_init);
 558
 559 MODULE_LICENSE("Dual BSD/GPL");