1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
4 * All rights reserved.
5 *
6 * Purpose: rf function code
7 *
8 * Author: Jerry Chen
9 *
10 * Date: Feb. 19, 2004
11 *
12 * Functions:
13 * vnt_rf_write_embedded - Embedded write RF register via MAC
14 *
15 * Revision History:
16 * RF_VT3226: RobertYu:20051111, VT3226C0 and before
17 * RF_VT3226D0: RobertYu:20051228
18 * RF_VT3342A0: RobertYu:20060609
19 *
20 */
21
22 #include <linux/errno.h>
23 #include "mac.h"
24 #include "rf.h"
25 #include "baseband.h"
26 #include "usbpipe.h"
27
28 #define CB_AL2230_INIT_SEQ 15
29 #define CB_AL7230_INIT_SEQ 16
30 #define CB_VT3226_INIT_SEQ 11
31 #define CB_VT3342_INIT_SEQ 13
32
33 static u8 al2230_init_table[CB_AL2230_INIT_SEQ][3] = {
34 {0x03, 0xf7, 0x90},
35 {0x03, 0x33, 0x31},
36 {0x01, 0xb8, 0x02},
37 {0x00, 0xff, 0xf3},
38 {0x00, 0x05, 0xa4},
39 {0x0f, 0x4d, 0xc5},
40 {0x08, 0x05, 0xb6},
41 {0x01, 0x47, 0xc7},
42 {0x00, 0x06, 0x88},
43 {0x04, 0x03, 0xb9},
44 {0x00, 0xdb, 0xba},
45 {0x00, 0x09, 0x9b},
46 {0x0b, 0xdf, 0xfc},
47 {0x00, 0x00, 0x0d},
48 {0x00, 0x58, 0x0f}
49 };
50
51 static u8 al2230_channel_table0[CB_MAX_CHANNEL_24G][3] = {
52 {0x03, 0xf7, 0x90},
53 {0x03, 0xf7, 0x90},
54 {0x03, 0xe7, 0x90},
55 {0x03, 0xe7, 0x90},
56 {0x03, 0xf7, 0xa0},
57 {0x03, 0xf7, 0xa0},
58 {0x03, 0xe7, 0xa0},
59 {0x03, 0xe7, 0xa0},
60 {0x03, 0xf7, 0xb0},
61 {0x03, 0xf7, 0xb0},
62 {0x03, 0xe7, 0xb0},
63 {0x03, 0xe7, 0xb0},
64 {0x03, 0xf7, 0xc0},
65 {0x03, 0xe7, 0xc0}
66 };
67
68 static u8 al2230_channel_table1[CB_MAX_CHANNEL_24G][3] = {
69 {0x03, 0x33, 0x31},
70 {0x0b, 0x33, 0x31},
71 {0x03, 0x33, 0x31},
72 {0x0b, 0x33, 0x31},
73 {0x03, 0x33, 0x31},
74 {0x0b, 0x33, 0x31},
75 {0x03, 0x33, 0x31},
76 {0x0b, 0x33, 0x31},
77 {0x03, 0x33, 0x31},
78 {0x0b, 0x33, 0x31},
79 {0x03, 0x33, 0x31},
80 {0x0b, 0x33, 0x31},
81 {0x03, 0x33, 0x31},
82 {0x06, 0x66, 0x61}
83 };
84
85 static u8 vt3226_init_table[CB_VT3226_INIT_SEQ][3] = {
86 {0x03, 0xff, 0x80},
87 {0x02, 0x82, 0xa1},
88 {0x03, 0xc6, 0xa2},
89 {0x01, 0x97, 0x93},
90 {0x03, 0x66, 0x64},
91 {0x00, 0x61, 0xa5},
92 {0x01, 0x7b, 0xd6},
93 {0x00, 0x80, 0x17},
94 {0x03, 0xf8, 0x08},
95 {0x00, 0x02, 0x39},
96 {0x02, 0x00, 0x2a}
97 };
98
99 static u8 vt3226d0_init_table[CB_VT3226_INIT_SEQ][3] = {
100 {0x03, 0xff, 0x80},
101 {0x03, 0x02, 0x21},
102 {0x03, 0xc6, 0xa2},
103 {0x01, 0x97, 0x93},
104 {0x03, 0x66, 0x64},
105 {0x00, 0x71, 0xa5},
106 {0x01, 0x15, 0xc6},
107 {0x01, 0x2e, 0x07},
108 {0x00, 0x58, 0x08},
109 {0x00, 0x02, 0x79},
110 {0x02, 0x01, 0xaa}
111 };
112
113 static u8 vt3226_channel_table0[CB_MAX_CHANNEL_24G][3] = {
114 {0x01, 0x97, 0x83},
115 {0x01, 0x97, 0x83},
116 {0x01, 0x97, 0x93},
117 {0x01, 0x97, 0x93},
118 {0x01, 0x97, 0x93},
119 {0x01, 0x97, 0x93},
120 {0x01, 0x97, 0xa3},
121 {0x01, 0x97, 0xa3},
122 {0x01, 0x97, 0xa3},
123 {0x01, 0x97, 0xa3},
124 {0x01, 0x97, 0xb3},
125 {0x01, 0x97, 0xb3},
126 {0x01, 0x97, 0xb3},
127 {0x03, 0x37, 0xc3}
128 };
129
130 static u8 vt3226_channel_table1[CB_MAX_CHANNEL_24G][3] = {
131 {0x02, 0x66, 0x64},
132 {0x03, 0x66, 0x64},
133 {0x00, 0x66, 0x64},
134 {0x01, 0x66, 0x64},
135 {0x02, 0x66, 0x64},
136 {0x03, 0x66, 0x64},
137 {0x00, 0x66, 0x64},
138 {0x01, 0x66, 0x64},
139 {0x02, 0x66, 0x64},
140 {0x03, 0x66, 0x64},
141 {0x00, 0x66, 0x64},
142 {0x01, 0x66, 0x64},
143 {0x02, 0x66, 0x64},
144 {0x00, 0xcc, 0xc4}
145 };
146
147 static const u32 vt3226d0_lo_current_table[CB_MAX_CHANNEL_24G] = {
148 0x0135c600,
149 0x0135c600,
150 0x0235c600,
151 0x0235c600,
152 0x0235c600,
153 0x0335c600,
154 0x0335c600,
155 0x0335c600,
156 0x0335c600,
157 0x0335c600,
158 0x0335c600,
159 0x0335c600,
160 0x0335c600,
161 0x0135c600
162 };
163
164 enum {
165 VNT_TABLE_INIT = 0,
166 VNT_TABLE_INIT_2 = 0,
167 VNT_TABLE_0 = 1,
168 VNT_TABLE_1 = 2,
169 VNT_TABLE_2 = 1
170 };
171
172 struct vnt_table_info {
173 u8 *addr;
174 int length;
175 };
176
177 static const struct vnt_table_info vnt_table_seq[][3] = {
178 { /* RF_AL2230, RF_AL2230S init table, channel table 0 and 1 */
179 {&al2230_init_table[0][0], CB_AL2230_INIT_SEQ * 3},
180 {&al2230_channel_table0[0][0], CB_MAX_CHANNEL_24G * 3},
181 {&al2230_channel_table1[0][0], CB_MAX_CHANNEL_24G * 3}
182 }, { /* RF_VT3226 init table, channel table 0 and 1 */
183 {&vt3226_init_table[0][0], CB_VT3226_INIT_SEQ * 3},
184 {&vt3226_channel_table0[0][0], CB_MAX_CHANNEL_24G * 3},
185 {&vt3226_channel_table1[0][0], CB_MAX_CHANNEL_24G * 3}
186 }, { /* RF_VT3226D0 init table, channel table 0 and 1 */
187 {&vt3226d0_init_table[0][0], CB_VT3226_INIT_SEQ * 3},
188 {&vt3226_channel_table0[0][0], CB_MAX_CHANNEL_24G * 3},
189 {&vt3226_channel_table1[0][0], CB_MAX_CHANNEL_24G * 3}
190 }
191 };
192
193 /*
194 * Description: Write to IF/RF, by embedded programming
195 */
vnt_rf_write_embedded(struct vnt_private * priv,u32 data)196 int vnt_rf_write_embedded(struct vnt_private *priv, u32 data)
197 {
198 u8 reg_data[4];
199
200 data |= (VNT_RF_REG_LEN << 3) | IFREGCTL_REGW;
201
202 reg_data[0] = (u8)data;
203 reg_data[1] = (u8)(data >> 8);
204 reg_data[2] = (u8)(data >> 16);
205 reg_data[3] = (u8)(data >> 24);
206
207 return vnt_control_out(priv, MESSAGE_TYPE_WRITE_IFRF, 0, 0,
208 ARRAY_SIZE(reg_data), reg_data);
209 }
210
vnt_rf_addpower(struct vnt_private * priv)211 static u8 vnt_rf_addpower(struct vnt_private *priv)
212 {
213 int base;
214 s32 rssi = -priv->current_rssi;
215
216 if (!rssi)
217 return 7;
218
219 if (priv->rf_type == RF_VT3226D0)
220 base = -60;
221 else
222 base = -70;
223
224 if (rssi < base)
225 return ((rssi - base + 1) / -5) * 2 + 5;
226
227 return 0;
228 }
229
230 /* Set Tx power by power level and rate */
vnt_rf_set_txpower(struct vnt_private * priv,u8 power,struct ieee80211_channel * ch)231 static int vnt_rf_set_txpower(struct vnt_private *priv, u8 power,
232 struct ieee80211_channel *ch)
233 {
234 u32 power_setting = 0;
235 int ret = 0;
236
237 power += vnt_rf_addpower(priv);
238 if (power > VNT_RF_MAX_POWER)
239 power = VNT_RF_MAX_POWER;
240
241 if (priv->power == power)
242 return 0;
243
244 priv->power = power;
245
246 switch (priv->rf_type) {
247 case RF_AL2230:
248 power_setting = 0x0404090 | (power << 12);
249
250 ret = vnt_rf_write_embedded(priv, power_setting);
251 if (ret)
252 return ret;
253
254 if (ch->flags & IEEE80211_CHAN_NO_OFDM)
255 ret = vnt_rf_write_embedded(priv, 0x0001b400);
256 else
257 ret = vnt_rf_write_embedded(priv, 0x0005a400);
258
259 break;
260 case RF_AL2230S:
261 power_setting = 0x0404090 | (power << 12);
262
263 ret = vnt_rf_write_embedded(priv, power_setting);
264 if (ret)
265 return ret;
266
267 if (ch->flags & IEEE80211_CHAN_NO_OFDM) {
268 ret = vnt_rf_write_embedded(priv, 0x040c1400);
269 if (ret)
270 return ret;
271
272 ret = vnt_rf_write_embedded(priv, 0x00299b00);
273 } else {
274 ret = vnt_rf_write_embedded(priv, 0x0005a400);
275 if (ret)
276 return ret;
277
278 ret = vnt_rf_write_embedded(priv, 0x00099b00);
279 }
280
281 break;
282
283 case RF_VT3226:
284 power_setting = ((0x3f - power) << 20) | (0x17 << 8);
285
286 ret = vnt_rf_write_embedded(priv, power_setting);
287 break;
288 case RF_VT3226D0:
289 if (ch->flags & IEEE80211_CHAN_NO_OFDM) {
290 u16 hw_value = ch->hw_value;
291
292 power_setting = ((0x3f - power) << 20) | (0xe07 << 8);
293
294 ret = vnt_rf_write_embedded(priv, power_setting);
295 if (ret)
296 return ret;
297
298 ret = vnt_rf_write_embedded(priv, 0x03c6a200);
299 if (ret)
300 return ret;
301
302 dev_dbg(&priv->usb->dev,
303 "%s 11b channel [%d]\n", __func__, hw_value);
304
305 hw_value--;
306
307 if (hw_value < ARRAY_SIZE(vt3226d0_lo_current_table)) {
308 ret = vnt_rf_write_embedded(priv,
309 vt3226d0_lo_current_table[hw_value]);
310 if (ret)
311 return ret;
312 }
313
314 ret = vnt_rf_write_embedded(priv, 0x015C0800);
315 } else {
316 dev_dbg(&priv->usb->dev,
317 "@@@@ %s> 11G mode\n", __func__);
318
319 power_setting = ((0x3f - power) << 20) | (0x7 << 8);
320
321 ret = vnt_rf_write_embedded(priv, power_setting);
322 if (ret)
323 return ret;
324
325 ret = vnt_rf_write_embedded(priv, 0x00C6A200);
326 if (ret)
327 return ret;
328
329 ret = vnt_rf_write_embedded(priv, 0x016BC600);
330 if (ret)
331 return ret;
332
333 ret = vnt_rf_write_embedded(priv, 0x00900800);
334 }
335
336 break;
337
338 default:
339 break;
340 }
341 return ret;
342 }
343
344 /* Set Tx power by channel number type */
vnt_rf_setpower(struct vnt_private * priv,struct ieee80211_channel * ch)345 int vnt_rf_setpower(struct vnt_private *priv,
346 struct ieee80211_channel *ch)
347 {
348 u16 channel;
349 u8 power = priv->cck_pwr;
350
351 if (!ch)
352 return -EINVAL;
353
354 /* set channel number to array number */
355 channel = ch->hw_value - 1;
356
357 if (ch->flags & IEEE80211_CHAN_NO_OFDM) {
358 if (channel < ARRAY_SIZE(priv->cck_pwr_tbl))
359 power = priv->cck_pwr_tbl[channel];
360 } else if (ch->band == NL80211_BAND_5GHZ) {
361 /* remove 14 channels to array size */
362 channel -= 14;
363
364 if (channel < ARRAY_SIZE(priv->ofdm_a_pwr_tbl))
365 power = priv->ofdm_a_pwr_tbl[channel];
366 } else {
367 if (channel < ARRAY_SIZE(priv->ofdm_pwr_tbl))
368 power = priv->ofdm_pwr_tbl[channel];
369 }
370
371 return vnt_rf_set_txpower(priv, power, ch);
372 }
373
374 /* Convert rssi to dbm */
vnt_rf_rssi_to_dbm(struct vnt_private * priv,u8 rssi,long * dbm)375 void vnt_rf_rssi_to_dbm(struct vnt_private *priv, u8 rssi, long *dbm)
376 {
377 u8 idx = ((rssi & 0xc0) >> 6) & 0x03;
378 long b = rssi & 0x3f;
379 long a = 0;
380 u8 airoharf[4] = {0, 18, 0, 40};
381
382 switch (priv->rf_type) {
383 case RF_AL2230:
384 case RF_AL2230S:
385 case RF_VT3226:
386 case RF_VT3226D0:
387 a = airoharf[idx];
388 break;
389 default:
390 break;
391 }
392
393 *dbm = -1 * (a + b * 2);
394 }
395
vnt_rf_table_download(struct vnt_private * priv)396 int vnt_rf_table_download(struct vnt_private *priv)
397 {
398 int ret;
399 int idx = -1;
400 const struct vnt_table_info *table_seq;
401
402 switch (priv->rf_type) {
403 case RF_AL2230:
404 case RF_AL2230S:
405 idx = 0;
406 break;
407 case RF_VT3226:
408 idx = 1;
409 break;
410 case RF_VT3226D0:
411 idx = 2;
412 break;
413 }
414
415 if (idx < 0)
416 return 0;
417
418 table_seq = &vnt_table_seq[idx][0];
419
420 /* Init Table */
421 ret = vnt_control_out(priv, MESSAGE_TYPE_WRITE, 0,
422 MESSAGE_REQUEST_RF_INIT,
423 table_seq[VNT_TABLE_INIT].length,
424 table_seq[VNT_TABLE_INIT].addr);
425 if (ret)
426 return ret;
427
428 /* Channel Table 0 */
429 ret = vnt_control_out_blocks(priv, VNT_REG_BLOCK_SIZE,
430 MESSAGE_REQUEST_RF_CH0,
431 table_seq[VNT_TABLE_0].length,
432 table_seq[VNT_TABLE_0].addr);
433 if (ret)
434 return ret;
435
436 /* Channel Table 1 */
437 ret = vnt_control_out_blocks(priv, VNT_REG_BLOCK_SIZE,
438 MESSAGE_REQUEST_RF_CH1,
439 table_seq[VNT_TABLE_1].length,
440 table_seq[VNT_TABLE_1].addr);
441
442 return ret;
443 }
444