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 */ 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 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 */ 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 */ 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 */ 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 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