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
mt7996_check_eeprom(struct mt7996_dev * dev)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
mt7996_eeprom_name(struct mt7996_dev * dev)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
mt7996_eeprom_parse_stream(const u8 * eeprom,u8 band_idx,u8 * path,u8 * rx_path,u8 * nss)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
mt7996_eeprom_variant_valid(struct mt7996_dev * dev,const u8 * def)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
mt7996_eeprom_check_or_use_default(struct mt7996_dev * dev,bool use_default)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
mt7996_eeprom_load(struct mt7996_dev * dev)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
mt7996_eeprom_parse_efuse_hw_cap(struct mt7996_phy * phy,u8 * path,u8 * rx_path,u8 * nss)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
mt7996_eeprom_parse_band_config(struct mt7996_phy * phy)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
mt7996_eeprom_parse_hw_cap(struct mt7996_dev * dev,struct mt7996_phy * phy)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
mt7996_eeprom_init(struct mt7996_dev * dev)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
mt7996_eeprom_get_target_power(struct mt7996_dev * dev,struct ieee80211_channel * chan)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
mt7996_eeprom_get_power_delta(struct mt7996_dev * dev,int band)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
mt7996_eeprom_has_background_radar(struct mt7996_dev * dev)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