1 /* 2 * Copyright (C) 2014 Felix Fietkau <nbd@openwrt.org> 3 * Copyright (C) 2015 Jakub Kicinski <kubakici@wp.pl> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License version 2 7 * as published by the Free Software Foundation 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 */ 14 15 #include <linux/of.h> 16 #include <linux/mtd/mtd.h> 17 #include <linux/mtd/partitions.h> 18 #include <linux/etherdevice.h> 19 #include <asm/unaligned.h> 20 #include "mt7601u.h" 21 #include "eeprom.h" 22 #include "mac.h" 23 24 static bool 25 field_valid(u8 val) 26 { 27 return val != 0xff; 28 } 29 30 static s8 31 field_validate(u8 val) 32 { 33 if (!field_valid(val)) 34 return 0; 35 36 return val; 37 } 38 39 static int 40 mt7601u_efuse_read(struct mt7601u_dev *dev, u16 addr, u8 *data, 41 enum mt7601u_eeprom_access_modes mode) 42 { 43 u32 val; 44 int i; 45 46 val = mt76_rr(dev, MT_EFUSE_CTRL); 47 val &= ~(MT_EFUSE_CTRL_AIN | 48 MT_EFUSE_CTRL_MODE); 49 val |= FIELD_PREP(MT_EFUSE_CTRL_AIN, addr & ~0xf) | 50 FIELD_PREP(MT_EFUSE_CTRL_MODE, mode) | 51 MT_EFUSE_CTRL_KICK; 52 mt76_wr(dev, MT_EFUSE_CTRL, val); 53 54 if (!mt76_poll(dev, MT_EFUSE_CTRL, MT_EFUSE_CTRL_KICK, 0, 1000)) 55 return -ETIMEDOUT; 56 57 val = mt76_rr(dev, MT_EFUSE_CTRL); 58 if ((val & MT_EFUSE_CTRL_AOUT) == MT_EFUSE_CTRL_AOUT) { 59 /* Parts of eeprom not in the usage map (0x80-0xc0,0xf0) 60 * will not return valid data but it's ok. 61 */ 62 memset(data, 0xff, 16); 63 return 0; 64 } 65 66 for (i = 0; i < 4; i++) { 67 val = mt76_rr(dev, MT_EFUSE_DATA(i)); 68 put_unaligned_le32(val, data + 4 * i); 69 } 70 71 return 0; 72 } 73 74 static int 75 mt7601u_efuse_physical_size_check(struct mt7601u_dev *dev) 76 { 77 const int map_reads = DIV_ROUND_UP(MT_EFUSE_USAGE_MAP_SIZE, 16); 78 u8 data[round_up(MT_EFUSE_USAGE_MAP_SIZE, 16)]; 79 int ret, i; 80 u32 start = 0, end = 0, cnt_free; 81 82 for (i = 0; i < map_reads; i++) { 83 ret = mt7601u_efuse_read(dev, MT_EE_USAGE_MAP_START + i * 16, 84 data + i * 16, MT_EE_PHYSICAL_READ); 85 if (ret) 86 return ret; 87 } 88 89 for (i = 0; i < MT_EFUSE_USAGE_MAP_SIZE; i++) 90 if (!data[i]) { 91 if (!start) 92 start = MT_EE_USAGE_MAP_START + i; 93 end = MT_EE_USAGE_MAP_START + i; 94 } 95 cnt_free = end - start + 1; 96 97 if (MT_EFUSE_USAGE_MAP_SIZE - cnt_free < 5) { 98 dev_err(dev->dev, "Error: your device needs default EEPROM file and this driver doesn't support it!\n"); 99 return -EINVAL; 100 } 101 102 return 0; 103 } 104 105 static bool 106 mt7601u_has_tssi(struct mt7601u_dev *dev, u8 *eeprom) 107 { 108 u16 nic_conf1 = get_unaligned_le16(eeprom + MT_EE_NIC_CONF_1); 109 110 return ~nic_conf1 && (nic_conf1 & MT_EE_NIC_CONF_1_TX_ALC_EN); 111 } 112 113 static void 114 mt7601u_set_chip_cap(struct mt7601u_dev *dev, u8 *eeprom) 115 { 116 u16 nic_conf0 = get_unaligned_le16(eeprom + MT_EE_NIC_CONF_0); 117 u16 nic_conf1 = get_unaligned_le16(eeprom + MT_EE_NIC_CONF_1); 118 119 if (!field_valid(nic_conf1 & 0xff)) 120 nic_conf1 &= 0xff00; 121 122 dev->ee->tssi_enabled = mt7601u_has_tssi(dev, eeprom) && 123 !(nic_conf1 & MT_EE_NIC_CONF_1_TEMP_TX_ALC); 124 125 if (nic_conf1 & MT_EE_NIC_CONF_1_HW_RF_CTRL) 126 dev_err(dev->dev, 127 "Error: this driver does not support HW RF ctrl\n"); 128 129 if (!field_valid(nic_conf0 >> 8)) 130 return; 131 132 if (FIELD_GET(MT_EE_NIC_CONF_0_RX_PATH, nic_conf0) > 1 || 133 FIELD_GET(MT_EE_NIC_CONF_0_TX_PATH, nic_conf0) > 1) 134 dev_err(dev->dev, 135 "Error: device has more than 1 RX/TX stream!\n"); 136 } 137 138 static void mt7601u_set_channel_target_power(struct mt7601u_dev *dev, 139 u8 *eeprom, u8 max_pwr) 140 { 141 u8 trgt_pwr = eeprom[MT_EE_TX_TSSI_TARGET_POWER]; 142 143 if (trgt_pwr > max_pwr || !trgt_pwr) { 144 dev_warn(dev->dev, "Error: EEPROM trgt power invalid %hhx!\n", 145 trgt_pwr); 146 trgt_pwr = 0x20; 147 } 148 149 memset(dev->ee->chan_pwr, trgt_pwr, sizeof(dev->ee->chan_pwr)); 150 } 151 152 static void 153 mt7601u_set_channel_power(struct mt7601u_dev *dev, u8 *eeprom) 154 { 155 u32 i, val; 156 u8 max_pwr; 157 158 val = mt7601u_rr(dev, MT_TX_ALC_CFG_0); 159 max_pwr = FIELD_GET(MT_TX_ALC_CFG_0_LIMIT_0, val); 160 161 if (mt7601u_has_tssi(dev, eeprom)) { 162 mt7601u_set_channel_target_power(dev, eeprom, max_pwr); 163 return; 164 } 165 166 for (i = 0; i < 14; i++) { 167 s8 power = field_validate(eeprom[MT_EE_TX_POWER_OFFSET + i]); 168 169 if (power > max_pwr || power < 0) 170 power = MT7601U_DEFAULT_TX_POWER; 171 172 dev->ee->chan_pwr[i] = power; 173 } 174 } 175 176 static void 177 mt7601u_set_country_reg(struct mt7601u_dev *dev, u8 *eeprom) 178 { 179 /* Note: - region 31 is not valid for mt7601u (see rtmp_init.c) 180 * - comments in rtmp_def.h are incorrect (see rt_channel.c) 181 */ 182 static const struct reg_channel_bounds chan_bounds[] = { 183 /* EEPROM country regions 0 - 7 */ 184 { 1, 11 }, { 1, 13 }, { 10, 2 }, { 10, 4 }, 185 { 14, 1 }, { 1, 14 }, { 3, 7 }, { 5, 9 }, 186 /* EEPROM country regions 32 - 33 */ 187 { 1, 11 }, { 1, 14 } 188 }; 189 u8 val = eeprom[MT_EE_COUNTRY_REGION]; 190 int idx = -1; 191 192 if (val < 8) 193 idx = val; 194 if (val > 31 && val < 33) 195 idx = val - 32 + 8; 196 197 if (idx != -1) 198 dev_info(dev->dev, 199 "EEPROM country region %02hhx (channels %hhd-%hhd)\n", 200 val, chan_bounds[idx].start, 201 chan_bounds[idx].start + chan_bounds[idx].num - 1); 202 else 203 idx = 5; /* channels 1 - 14 */ 204 205 dev->ee->reg = chan_bounds[idx]; 206 207 /* TODO: country region 33 is special - phy should be set to B-mode 208 * before entering channel 14 (see sta/connect.c) 209 */ 210 } 211 212 static void 213 mt7601u_set_rf_freq_off(struct mt7601u_dev *dev, u8 *eeprom) 214 { 215 u8 comp; 216 217 dev->ee->rf_freq_off = field_validate(eeprom[MT_EE_FREQ_OFFSET]); 218 comp = field_validate(eeprom[MT_EE_FREQ_OFFSET_COMPENSATION]); 219 220 if (comp & BIT(7)) 221 dev->ee->rf_freq_off -= comp & 0x7f; 222 else 223 dev->ee->rf_freq_off += comp; 224 } 225 226 static void 227 mt7601u_set_rssi_offset(struct mt7601u_dev *dev, u8 *eeprom) 228 { 229 int i; 230 s8 *rssi_offset = dev->ee->rssi_offset; 231 232 for (i = 0; i < 2; i++) { 233 rssi_offset[i] = eeprom[MT_EE_RSSI_OFFSET + i]; 234 235 if (rssi_offset[i] < -10 || rssi_offset[i] > 10) { 236 dev_warn(dev->dev, 237 "Warning: EEPROM RSSI is invalid %02hhx\n", 238 rssi_offset[i]); 239 rssi_offset[i] = 0; 240 } 241 } 242 } 243 244 static void 245 mt7601u_extra_power_over_mac(struct mt7601u_dev *dev) 246 { 247 u32 val; 248 249 val = ((mt7601u_rr(dev, MT_TX_PWR_CFG_1) & 0x0000ff00) >> 8); 250 val |= ((mt7601u_rr(dev, MT_TX_PWR_CFG_2) & 0x0000ff00) << 8); 251 mt7601u_wr(dev, MT_TX_PWR_CFG_7, val); 252 253 val = ((mt7601u_rr(dev, MT_TX_PWR_CFG_4) & 0x0000ff00) >> 8); 254 mt7601u_wr(dev, MT_TX_PWR_CFG_9, val); 255 } 256 257 static void 258 mt7601u_set_power_rate(struct power_per_rate *rate, s8 delta, u8 value) 259 { 260 /* Invalid? Note: vendor driver does not handle this */ 261 if (value == 0xff) 262 return; 263 264 rate->raw = s6_validate(value); 265 rate->bw20 = s6_to_int(value); 266 /* Note: vendor driver does cap the value to s6 right away */ 267 rate->bw40 = rate->bw20 + delta; 268 } 269 270 static void 271 mt7601u_save_power_rate(struct mt7601u_dev *dev, s8 delta, u32 val, int i) 272 { 273 struct mt7601u_rate_power *t = &dev->ee->power_rate_table; 274 275 switch (i) { 276 case 0: 277 mt7601u_set_power_rate(&t->cck[0], delta, (val >> 0) & 0xff); 278 mt7601u_set_power_rate(&t->cck[1], delta, (val >> 8) & 0xff); 279 /* Save cck bw20 for fixups of channel 14 */ 280 dev->ee->real_cck_bw20[0] = t->cck[0].bw20; 281 dev->ee->real_cck_bw20[1] = t->cck[1].bw20; 282 283 mt7601u_set_power_rate(&t->ofdm[0], delta, (val >> 16) & 0xff); 284 mt7601u_set_power_rate(&t->ofdm[1], delta, (val >> 24) & 0xff); 285 break; 286 case 1: 287 mt7601u_set_power_rate(&t->ofdm[2], delta, (val >> 0) & 0xff); 288 mt7601u_set_power_rate(&t->ofdm[3], delta, (val >> 8) & 0xff); 289 mt7601u_set_power_rate(&t->ht[0], delta, (val >> 16) & 0xff); 290 mt7601u_set_power_rate(&t->ht[1], delta, (val >> 24) & 0xff); 291 break; 292 case 2: 293 mt7601u_set_power_rate(&t->ht[2], delta, (val >> 0) & 0xff); 294 mt7601u_set_power_rate(&t->ht[3], delta, (val >> 8) & 0xff); 295 break; 296 } 297 } 298 299 static s8 300 get_delta(u8 val) 301 { 302 s8 ret; 303 304 if (!field_valid(val) || !(val & BIT(7))) 305 return 0; 306 307 ret = val & 0x1f; 308 if (ret > 8) 309 ret = 8; 310 if (val & BIT(6)) 311 ret = -ret; 312 313 return ret; 314 } 315 316 static void 317 mt7601u_config_tx_power_per_rate(struct mt7601u_dev *dev, u8 *eeprom) 318 { 319 u32 val; 320 s8 bw40_delta; 321 int i; 322 323 bw40_delta = get_delta(eeprom[MT_EE_TX_POWER_DELTA_BW40]); 324 325 for (i = 0; i < 5; i++) { 326 val = get_unaligned_le32(eeprom + MT_EE_TX_POWER_BYRATE(i)); 327 328 mt7601u_save_power_rate(dev, bw40_delta, val, i); 329 330 if (~val) 331 mt7601u_wr(dev, MT_TX_PWR_CFG_0 + i * 4, val); 332 } 333 334 mt7601u_extra_power_over_mac(dev); 335 } 336 337 static void 338 mt7601u_init_tssi_params(struct mt7601u_dev *dev, u8 *eeprom) 339 { 340 struct tssi_data *d = &dev->ee->tssi_data; 341 342 if (!dev->ee->tssi_enabled) 343 return; 344 345 d->slope = eeprom[MT_EE_TX_TSSI_SLOPE]; 346 d->tx0_delta_offset = eeprom[MT_EE_TX_TSSI_OFFSET] * 1024; 347 d->offset[0] = eeprom[MT_EE_TX_TSSI_OFFSET_GROUP]; 348 d->offset[1] = eeprom[MT_EE_TX_TSSI_OFFSET_GROUP + 1]; 349 d->offset[2] = eeprom[MT_EE_TX_TSSI_OFFSET_GROUP + 2]; 350 } 351 352 int 353 mt7601u_eeprom_init(struct mt7601u_dev *dev) 354 { 355 u8 *eeprom; 356 int i, ret; 357 358 ret = mt7601u_efuse_physical_size_check(dev); 359 if (ret) 360 return ret; 361 362 dev->ee = devm_kzalloc(dev->dev, sizeof(*dev->ee), GFP_KERNEL); 363 if (!dev->ee) 364 return -ENOMEM; 365 366 eeprom = kmalloc(MT7601U_EEPROM_SIZE, GFP_KERNEL); 367 if (!eeprom) 368 return -ENOMEM; 369 370 for (i = 0; i + 16 <= MT7601U_EEPROM_SIZE; i += 16) { 371 ret = mt7601u_efuse_read(dev, i, eeprom + i, MT_EE_READ); 372 if (ret) 373 goto out; 374 } 375 376 if (eeprom[MT_EE_VERSION_EE] > MT7601U_EE_MAX_VER) 377 dev_warn(dev->dev, 378 "Warning: unsupported EEPROM version %02hhx\n", 379 eeprom[MT_EE_VERSION_EE]); 380 dev_info(dev->dev, "EEPROM ver:%02hhx fae:%02hhx\n", 381 eeprom[MT_EE_VERSION_EE], eeprom[MT_EE_VERSION_FAE]); 382 383 mt7601u_set_macaddr(dev, eeprom + MT_EE_MAC_ADDR); 384 mt7601u_set_chip_cap(dev, eeprom); 385 mt7601u_set_channel_power(dev, eeprom); 386 mt7601u_set_country_reg(dev, eeprom); 387 mt7601u_set_rf_freq_off(dev, eeprom); 388 mt7601u_set_rssi_offset(dev, eeprom); 389 dev->ee->ref_temp = eeprom[MT_EE_REF_TEMP]; 390 dev->ee->lna_gain = eeprom[MT_EE_LNA_GAIN]; 391 392 mt7601u_config_tx_power_per_rate(dev, eeprom); 393 394 mt7601u_init_tssi_params(dev, eeprom); 395 out: 396 kfree(eeprom); 397 return ret; 398 } 399