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