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, val: 0, timeout: 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, p: 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, addr: MT_EE_USAGE_MAP_START + i * 16, |
76 | data: data + i * 16, mode: 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(p: 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(p: eeprom + MT_EE_NIC_CONF_0); |
109 | u16 nic_conf1 = get_unaligned_le16(p: eeprom + MT_EE_NIC_CONF_1); |
110 | |
111 | if (!field_valid(val: 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(val: 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(val: 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(val: eeprom[MT_EE_FREQ_OFFSET]); |
210 | comp = field_validate(val: 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 | (struct mt7601u_dev *dev, u8 *eeprom) |
220 | { |
221 | int i; |
222 | s8 * = 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 | (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(reg: value); |
257 | rate->bw20 = s6_to_int(reg: 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(rate: &t->cck[0], delta, value: (val >> 0) & 0xff); |
270 | mt7601u_set_power_rate(rate: &t->cck[1], delta, value: (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(rate: &t->ofdm[0], delta, value: (val >> 16) & 0xff); |
276 | mt7601u_set_power_rate(rate: &t->ofdm[1], delta, value: (val >> 24) & 0xff); |
277 | break; |
278 | case 1: |
279 | mt7601u_set_power_rate(rate: &t->ofdm[2], delta, value: (val >> 0) & 0xff); |
280 | mt7601u_set_power_rate(rate: &t->ofdm[3], delta, value: (val >> 8) & 0xff); |
281 | mt7601u_set_power_rate(rate: &t->ht[0], delta, value: (val >> 16) & 0xff); |
282 | mt7601u_set_power_rate(rate: &t->ht[1], delta, value: (val >> 24) & 0xff); |
283 | break; |
284 | case 2: |
285 | mt7601u_set_power_rate(rate: &t->ht[2], delta, value: (val >> 0) & 0xff); |
286 | mt7601u_set_power_rate(rate: &t->ht[3], delta, value: (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(val: eeprom[MT_EE_TX_POWER_DELTA_BW40]); |
316 | |
317 | for (i = 0; i < 5; i++) { |
318 | val = get_unaligned_le32(p: eeprom + MT_EE_TX_POWER_BYRATE(i)); |
319 | |
320 | mt7601u_save_power_rate(dev, delta: 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->dev, size: 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, addr: i, data: eeprom + i, mode: 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, addr: 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(objp: eeprom); |
389 | return ret; |
390 | } |
391 | |