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