eeprom.c

  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
 10static 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
 27static 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
 64static void
 65mt7996_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
 96static 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
134static int
135mt7996_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
158out:
159	release_firmware(fw);
160
161	return ret;
162}
163
164static 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
217out:
218	return mt7996_eeprom_check_or_use_default(dev, use_default);
219}
220
221static 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
251static 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
288int 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
324int 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	memcpy(dev->mphy.macaddr, dev->mt76.eeprom.data + MT_EE_MAC_ADDR, ETH_ALEN);
337
338	return mt76_eeprom_override(&dev->mphy);
339}
340
341int mt7996_eeprom_get_target_power(struct mt7996_dev *dev,
342				   struct ieee80211_channel *chan)
343{
344	u8 *eeprom = dev->mt76.eeprom.data;
345	int target_power;
346
347	if (chan->band == NL80211_BAND_5GHZ)
348		target_power = eeprom[MT_EE_TX0_POWER_5G +
349				      mt7996_get_channel_group_5g(chan->hw_value)];
350	else if (chan->band == NL80211_BAND_6GHZ)
351		target_power = eeprom[MT_EE_TX0_POWER_6G +
352				      mt7996_get_channel_group_6g(chan->hw_value)];
353	else
354		target_power = eeprom[MT_EE_TX0_POWER_2G];
355
356	return target_power;
357}
358
359s8 mt7996_eeprom_get_power_delta(struct mt7996_dev *dev, int band)
360{
361	u8 *eeprom = dev->mt76.eeprom.data;
362	u32 val;
363	s8 delta;
364
365	if (band == NL80211_BAND_5GHZ)
366		val = eeprom[MT_EE_RATE_DELTA_5G];
367	else if (band == NL80211_BAND_6GHZ)
368		val = eeprom[MT_EE_RATE_DELTA_6G];
369	else
370		val = eeprom[MT_EE_RATE_DELTA_2G];
371
372	if (!(val & MT_EE_RATE_DELTA_EN))
373		return 0;
374
375	delta = FIELD_GET(MT_EE_RATE_DELTA_MASK, val);
376
377	return val & MT_EE_RATE_DELTA_SIGN ? delta : -delta;
378}
379
380bool mt7996_eeprom_has_background_radar(struct mt7996_dev *dev)
381{
382	switch (mt76_chip(&dev->mt76)) {
383	case MT7996_DEVICE_ID:
384		if (dev->var.type == MT7996_VAR_TYPE_233)
385			return false;
386		break;
387	case MT7992_DEVICE_ID:
388		if (dev->var.type == MT7992_VAR_TYPE_23)
389			return false;
390		break;
391	case MT7990_DEVICE_ID: {
392		u8 path, rx_path, nss, *eeprom = dev->mt76.eeprom.data;
393
394		mt7996_eeprom_parse_stream(eeprom, MT_BAND1, &path, &rx_path, &nss);
395		/* Disable background radar capability in 3T3R */
396		if (path == 3 || rx_path == 3)
397			return false;
398		break;
399		}
400	default:
401		return false;
402	}
403
404	return true;
405}