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