drivers/staging/vt6656/rf.c

   1 /*
   2  * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
   3  * All rights reserved.
   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 as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  *
  20  * File: rf.c
  21  *
  22  * Purpose: rf function code
  23  *
  24  * Author: Jerry Chen
  25  *
  26  * Date: Feb. 19, 2004
  27  *
  28  * Functions:
  29  *      vnt_rf_write_embedded   - Embedded write RF register via MAC
  30  *
  31  * Revision History:
  32  *      RF_VT3226: RobertYu:20051111, VT3226C0 and before
  33  *      RF_VT3226D0: RobertYu:20051228
  34  *      RF_VT3342A0: RobertYu:20060609
  35  *
  36  */
  37
  38 #include "mac.h"
  39 #include "rf.h"
  40 #include "baseband.h"
  41 #include "usbpipe.h"
  42
  43 #define CB_AL2230_INIT_SEQ    15
  44 #define AL2230_PWR_IDX_LEN    64
  45
  46 #define CB_AL7230_INIT_SEQ    16
  47 #define AL7230_PWR_IDX_LEN    64
  48
  49 #define CB_VT3226_INIT_SEQ    11
  50 #define VT3226_PWR_IDX_LEN    64
  51
  52 #define CB_VT3342_INIT_SEQ    13
  53 #define VT3342_PWR_IDX_LEN    64
  54
  55 static u8 al2230_init_table[CB_AL2230_INIT_SEQ][3] = {
  56         {0x03, 0xf7, 0x90},
  57         {0x03, 0x33, 0x31},
  58         {0x01, 0xb8, 0x02},
  59         {0x00, 0xff, 0xf3},
  60         {0x00, 0x05, 0xa4},
  61         {0x0f, 0x4d, 0xc5},
  62         {0x08, 0x05, 0xb6},
  63         {0x01, 0x47, 0xc7},
  64         {0x00, 0x06, 0x88},
  65         {0x04, 0x03, 0xb9},
  66         {0x00, 0xdb, 0xba},
  67         {0x00, 0x09, 0x9b},
  68         {0x0b, 0xdf, 0xfc},
  69         {0x00, 0x00, 0x0d},
  70         {0x00, 0x58, 0x0f}
  71 };
  72
  73 static u8 al2230_channel_table0[CB_MAX_CHANNEL_24G][3] = {
  74         {0x03, 0xf7, 0x90},
  75         {0x03, 0xf7, 0x90},
  76         {0x03, 0xe7, 0x90},
  77         {0x03, 0xe7, 0x90},
  78         {0x03, 0xf7, 0xa0},
  79         {0x03, 0xf7, 0xa0},
  80         {0x03, 0xe7, 0xa0},
  81         {0x03, 0xe7, 0xa0},
  82         {0x03, 0xf7, 0xb0},
  83         {0x03, 0xf7, 0xb0},
  84         {0x03, 0xe7, 0xb0},
  85         {0x03, 0xe7, 0xb0},
  86         {0x03, 0xf7, 0xc0},
  87         {0x03, 0xe7, 0xc0}
  88 };
  89
  90 static u8 al2230_channel_table1[CB_MAX_CHANNEL_24G][3] = {
  91         {0x03, 0x33, 0x31},
  92         {0x0b, 0x33, 0x31},
  93         {0x03, 0x33, 0x31},
  94         {0x0b, 0x33, 0x31},
  95         {0x03, 0x33, 0x31},
  96         {0x0b, 0x33, 0x31},
  97         {0x03, 0x33, 0x31},
  98         {0x0b, 0x33, 0x31},
  99         {0x03, 0x33, 0x31},
 100         {0x0b, 0x33, 0x31},
 101         {0x03, 0x33, 0x31},
 102         {0x0b, 0x33, 0x31},
 103         {0x03, 0x33, 0x31},
 104         {0x06, 0x66, 0x61}
 105 };
 106
 107 static u8 al7230_init_table[CB_AL7230_INIT_SEQ][3] = {
 108         {0x20, 0x37, 0x90},
 109         {0x13, 0x33, 0x31},
 110         {0x84, 0x1f, 0xf2},
 111         {0x3f, 0xdf, 0xa3},
 112         {0x7f, 0xd7, 0x84},
 113         {0x80, 0x2b, 0x55},
 114         {0x56, 0xaf, 0x36},
 115         {0xce, 0x02, 0x07},
 116         {0x6e, 0xbc, 0x98},
 117         {0x22, 0x1b, 0xb9},
 118         {0xe0, 0x00, 0x0a},
 119         {0x08, 0x03, 0x1b},
 120         {0x00, 0x0a, 0x3c},
 121         {0xff, 0xff, 0xfd},
 122         {0x00, 0x00, 0x0e},
 123         {0x1a, 0xba, 0x8f}
 124 };
 125
 126 static u8 al7230_init_table_amode[CB_AL7230_INIT_SEQ][3] = {
 127         {0x2f, 0xf5, 0x20},
 128         {0x00, 0x00, 0x01},
 129         {0x45, 0x1f, 0xe2},
 130         {0x5f, 0xdf, 0xa3},
 131         {0x6f, 0xd7, 0x84},
 132         {0x85, 0x3f, 0x55},
 133         {0x56, 0xaf, 0x36},
 134         {0xce, 0x02, 0x07},
 135         {0x6e, 0xbc, 0x98},
 136         {0x22, 0x1b, 0xb9},
 137         {0xe0, 0x60, 0x0a},
 138         {0x08, 0x03, 0x1b},
 139         {0x00, 0x14, 0x7c},
 140         {0xff, 0xff, 0xfd},
 141         {0x00, 0x00, 0x0e},
 142         {0x12, 0xba, 0xcf}
 143 };
 144
 145 static u8 al7230_channel_table0[CB_MAX_CHANNEL][3] = {
 146         {0x20, 0x37, 0x90},
 147         {0x20, 0x37, 0x90},
 148         {0x20, 0x37, 0x90},
 149         {0x20, 0x37, 0x90},
 150         {0x20, 0x37, 0xa0},
 151         {0x20, 0x37, 0xa0},
 152         {0x20, 0x37, 0xa0},
 153         {0x20, 0x37, 0xa0},
 154         {0x20, 0x37, 0xb0},
 155         {0x20, 0x37, 0xb0},
 156         {0x20, 0x37, 0xb0},
 157         {0x20, 0x37, 0xb0},
 158         {0x20, 0x37, 0xc0},
 159         {0x20, 0x37, 0xc0},
 160         {0x0f, 0xf5, 0x20}, /* channel 15 Tf = 4915MHz */
 161         {0x2f, 0xf5, 0x20},
 162         {0x0f, 0xf5, 0x20},
 163         {0x0f, 0xf5, 0x20},
 164         {0x2f, 0xf5, 0x20},
 165         {0x0f, 0xf5, 0x20},
 166         {0x2f, 0xf5, 0x30},
 167         {0x2f, 0xf5, 0x30},
 168         {0x0f, 0xf5, 0x40},
 169         {0x2f, 0xf5, 0x40},
 170         {0x0f, 0xf5, 0x40},
 171         {0x0f, 0xf5, 0x40},
 172         {0x2f, 0xf5, 0x40},
 173         {0x2f, 0xf5, 0x50},
 174         {0x2f, 0xf5, 0x60},
 175         {0x2f, 0xf5, 0x60},
 176         {0x2f, 0xf5, 0x70},
 177         {0x2f, 0xf5, 0x70},
 178         {0x2f, 0xf5, 0x70},
 179         {0x2f, 0xf5, 0x70},
 180         {0x2f, 0xf5, 0x70},
 181         {0x2f, 0xf5, 0x70},
 182         {0x2f, 0xf5, 0x80},
 183         {0x2f, 0xf5, 0x80},
 184         {0x2f, 0xf5, 0x80},
 185         {0x2f, 0xf5, 0x90},
 186         {0x2f, 0xf5, 0xc0},
 187         {0x2f, 0xf5, 0xc0},
 188         {0x2f, 0xf5, 0xc0},
 189         {0x2f, 0xf5, 0xd0},
 190         {0x2f, 0xf5, 0xd0},
 191         {0x2f, 0xf5, 0xd0},
 192         {0x2f, 0xf5, 0xe0},
 193         {0x2f, 0xf5, 0xe0},
 194         {0x2f, 0xf5, 0xe0},
 195         {0x2f, 0xf5, 0xf0},
 196         {0x2f, 0xf5, 0xf0},
 197         {0x2f, 0xf6, 0x00},
 198         {0x2f, 0xf6, 0x00},
 199         {0x2f, 0xf6, 0x00},
 200         {0x2f, 0xf6, 0x10},
 201         {0x2f, 0xf6, 0x10}
 202 };
 203
 204 static u8 al7230_channel_table1[CB_MAX_CHANNEL][3] = {
 205         {0x13, 0x33, 0x31},
 206         {0x1b, 0x33, 0x31},
 207         {0x03, 0x33, 0x31},
 208         {0x0b, 0x33, 0x31},
 209         {0x13, 0x33, 0x31},
 210         {0x1b, 0x33, 0x31},
 211         {0x03, 0x33, 0x31},
 212         {0x0b, 0x33, 0x31},
 213         {0x13, 0x33, 0x31},
 214         {0x1b, 0x33, 0x31},
 215         {0x03, 0x33, 0x31},
 216         {0x0b, 0x33, 0x31},
 217         {0x13, 0x33, 0x31},
 218         {0x06, 0x66, 0x61},
 219         {0x1d, 0x55, 0x51}, /* channel = 15, Tf = 4915MHz */
 220         {0x00, 0x00, 0x01},
 221         {0x02, 0xaa, 0xa1},
 222         {0x08, 0x00, 0x01},
 223         {0x0a, 0xaa, 0xa1},
 224         {0x0d, 0x55, 0x51},
 225         {0x15, 0x55, 0x51},
 226         {0x00, 0x00, 0x01},
 227         {0x1d, 0x55, 0x51},
 228         {0x00, 0x00, 0x01},
 229         {0x02, 0xaa, 0xa1},
 230         {0x08, 0x00, 0x01},
 231         {0x0a, 0xaa, 0xa1},
 232         {0x15, 0x55, 0x51},
 233         {0x05, 0x55, 0x51},
 234         {0x0a, 0xaa, 0xa1},
 235         {0x10, 0x00, 0x01},
 236         {0x15, 0x55, 0x51},
 237         {0x1a, 0xaa, 0xa1},
 238         {0x00, 0x00, 0x01},
 239         {0x05, 0x55, 0x51},
 240         {0x0a, 0xaa, 0xa1},
 241         {0x15, 0x55, 0x51},
 242         {0x00, 0x00, 0x01},
 243         {0x0a, 0xaa, 0xa1},
 244         {0x15, 0x55, 0x51},
 245         {0x15, 0x55, 0x51},
 246         {0x00, 0x00, 0x01},
 247         {0x0a, 0xaa, 0xa1},
 248         {0x15, 0x55, 0x51},
 249         {0x00, 0x00, 0x01},
 250         {0x0a, 0xaa, 0xa1},
 251         {0x15, 0x55, 0x51},
 252         {0x00, 0x00, 0x01},
 253         {0x0a, 0xaa, 0xa1},
 254         {0x15, 0x55, 0x51},
 255         {0x00, 0x00, 0x01},
 256         {0x18, 0x00, 0x01},
 257         {0x02, 0xaa, 0xa1},
 258         {0x0d, 0x55, 0x51},
 259         {0x18, 0x00, 0x01},
 260         {0x02, 0xaa, 0xb1}
 261 };
 262
 263 static u8 al7230_channel_table2[CB_MAX_CHANNEL][3] = {
 264         {0x7f, 0xd7, 0x84},
 265         {0x7f, 0xd7, 0x84},
 266         {0x7f, 0xd7, 0x84},
 267         {0x7f, 0xd7, 0x84},
 268         {0x7f, 0xd7, 0x84},
 269         {0x7f, 0xd7, 0x84},
 270         {0x7f, 0xd7, 0x84},
 271         {0x7f, 0xd7, 0x84},
 272         {0x7f, 0xd7, 0x84},
 273         {0x7f, 0xd7, 0x84},
 274         {0x7f, 0xd7, 0x84},
 275         {0x7f, 0xd7, 0x84},
 276         {0x7f, 0xd7, 0x84},
 277         {0x7f, 0xd7, 0x84},
 278         {0x7f, 0xd7, 0x84}, /* channel = 15 Tf = 4915MHz */
 279         {0x6f, 0xd7, 0x84},
 280         {0x7f, 0xd7, 0x84},
 281         {0x7f, 0xd7, 0x84},
 282         {0x7f, 0xd7, 0x84},
 283         {0x7f, 0xd7, 0x84},
 284         {0x7f, 0xd7, 0x84},
 285         {0x6f, 0xd7, 0x84},
 286         {0x7f, 0xd7, 0x84},
 287         {0x6f, 0xd7, 0x84},
 288         {0x7f, 0xd7, 0x84},
 289         {0x7f, 0xd7, 0x84},
 290         {0x7f, 0xd7, 0x84},
 291         {0x7f, 0xd7, 0x84},
 292         {0x7f, 0xd7, 0x84},
 293         {0x7f, 0xd7, 0x84},
 294         {0x7f, 0xd7, 0x84},
 295         {0x7f, 0xd7, 0x84},
 296         {0x7f, 0xd7, 0x84},
 297         {0x6f, 0xd7, 0x84},
 298         {0x7f, 0xd7, 0x84},
 299         {0x7f, 0xd7, 0x84},
 300         {0x7f, 0xd7, 0x84},
 301         {0x6f, 0xd7, 0x84},
 302         {0x7f, 0xd7, 0x84},
 303         {0x7f, 0xd7, 0x84},
 304         {0x7f, 0xd7, 0x84},
 305         {0x6f, 0xd7, 0x84},
 306         {0x7f, 0xd7, 0x84},
 307         {0x7f, 0xd7, 0x84},
 308         {0x6f, 0xd7, 0x84},
 309         {0x7f, 0xd7, 0x84},
 310         {0x7f, 0xd7, 0x84},
 311         {0x6f, 0xd7, 0x84},
 312         {0x7f, 0xd7, 0x84},
 313         {0x7f, 0xd7, 0x84},
 314         {0x6f, 0xd7, 0x84},
 315         {0x7f, 0xd7, 0x84},
 316         {0x7f, 0xd7, 0x84},
 317         {0x7f, 0xd7, 0x84},
 318         {0x7f, 0xd7, 0x84},
 319         {0x7f, 0xd7, 0x84}
 320 };
 321
 322 static u8 vt3226_init_table[CB_VT3226_INIT_SEQ][3] = {
 323         {0x03, 0xff, 0x80},
 324         {0x02, 0x82, 0xa1},
 325         {0x03, 0xc6, 0xa2},
 326         {0x01, 0x97, 0x93},
 327         {0x03, 0x66, 0x64},
 328         {0x00, 0x61, 0xa5},
 329         {0x01, 0x7b, 0xd6},
 330         {0x00, 0x80, 0x17},
 331         {0x03, 0xf8, 0x08},
 332         {0x00, 0x02, 0x39},
 333         {0x02, 0x00, 0x2a}
 334 };
 335
 336 static u8 vt3226d0_init_table[CB_VT3226_INIT_SEQ][3] = {
 337         {0x03, 0xff, 0x80},
 338         {0x03, 0x02, 0x21},
 339         {0x03, 0xc6, 0xa2},
 340         {0x01, 0x97, 0x93},
 341         {0x03, 0x66, 0x64},
 342         {0x00, 0x71, 0xa5},
 343         {0x01, 0x15, 0xc6},
 344         {0x01, 0x2e, 0x07},
 345         {0x00, 0x58, 0x08},
 346         {0x00, 0x02, 0x79},
 347         {0x02, 0x01, 0xaa}
 348 };
 349
 350 static u8 vt3226_channel_table0[CB_MAX_CHANNEL_24G][3] = {
 351         {0x01, 0x97, 0x83},
 352         {0x01, 0x97, 0x83},
 353         {0x01, 0x97, 0x93},
 354         {0x01, 0x97, 0x93},
 355         {0x01, 0x97, 0x93},
 356         {0x01, 0x97, 0x93},
 357         {0x01, 0x97, 0xa3},
 358         {0x01, 0x97, 0xa3},
 359         {0x01, 0x97, 0xa3},
 360         {0x01, 0x97, 0xa3},
 361         {0x01, 0x97, 0xb3},
 362         {0x01, 0x97, 0xb3},
 363         {0x01, 0x97, 0xb3},
 364         {0x03, 0x37, 0xc3}
 365 };
 366
 367 static u8 vt3226_channel_table1[CB_MAX_CHANNEL_24G][3] = {
 368         {0x02, 0x66, 0x64},
 369         {0x03, 0x66, 0x64},
 370         {0x00, 0x66, 0x64},
 371         {0x01, 0x66, 0x64},
 372         {0x02, 0x66, 0x64},
 373         {0x03, 0x66, 0x64},
 374         {0x00, 0x66, 0x64},
 375         {0x01, 0x66, 0x64},
 376         {0x02, 0x66, 0x64},
 377         {0x03, 0x66, 0x64},
 378         {0x00, 0x66, 0x64},
 379         {0x01, 0x66, 0x64},
 380         {0x02, 0x66, 0x64},
 381         {0x00, 0xcc, 0xc4}
 382 };
 383
 384 static const u32 vt3226d0_lo_current_table[CB_MAX_CHANNEL_24G] = {
 385         0x0135c600,
 386         0x0135c600,
 387         0x0235c600,
 388         0x0235c600,
 389         0x0235c600,
 390         0x0335c600,
 391         0x0335c600,
 392         0x0335c600,
 393         0x0335c600,
 394         0x0335c600,
 395         0x0335c600,
 396         0x0335c600,
 397         0x0335c600,
 398         0x0135c600
 399 };
 400
 401 static u8 vt3342a0_init_table[CB_VT3342_INIT_SEQ][3] = { /* 11b/g mode */
 402         {0x03, 0xff, 0x80},
 403         {0x02, 0x08, 0x81},
 404         {0x00, 0xc6, 0x02},
 405         {0x03, 0xc5, 0x13},
 406         {0x00, 0xee, 0xe4},
 407         {0x00, 0x71, 0xa5},
 408         {0x01, 0x75, 0x46},
 409         {0x01, 0x40, 0x27},
 410         {0x01, 0x54, 0x08},
 411         {0x00, 0x01, 0x69},
 412         {0x02, 0x00, 0xaa},
 413         {0x00, 0x08, 0xcb},
 414         {0x01, 0x70, 0x0c}
 415 };
 416
 417 static u8 vt3342_channel_table0[CB_MAX_CHANNEL][3] = {
 418         {0x02, 0x05, 0x03},
 419         {0x01, 0x15, 0x03},
 420         {0x03, 0xc5, 0x03},
 421         {0x02, 0x65, 0x03},
 422         {0x01, 0x15, 0x13},
 423         {0x03, 0xc5, 0x13},
 424         {0x02, 0x05, 0x13},
 425         {0x01, 0x15, 0x13},
 426         {0x03, 0xc5, 0x13},
 427         {0x02, 0x65, 0x13},
 428         {0x01, 0x15, 0x23},
 429         {0x03, 0xc5, 0x23},
 430         {0x02, 0x05, 0x23},
 431         {0x00, 0xd5, 0x23},
 432         {0x01, 0x15, 0x13}, /* channel = 15 Tf = 4915MHz */
 433         {0x01, 0x15, 0x13},
 434         {0x01, 0x15, 0x13},
 435         {0x01, 0x15, 0x13},
 436         {0x01, 0x15, 0x13},
 437         {0x01, 0x15, 0x13},
 438         {0x01, 0x15, 0x13},
 439         {0x01, 0x15, 0x13},
 440         {0x01, 0x15, 0x13},
 441         {0x01, 0x15, 0x13},
 442         {0x01, 0x15, 0x13},
 443         {0x01, 0x15, 0x13},
 444         {0x01, 0x15, 0x13},
 445         {0x01, 0x15, 0x13},
 446         {0x01, 0x15, 0x13},
 447         {0x01, 0x55, 0x63},
 448         {0x01, 0x55, 0x63},
 449         {0x02, 0xa5, 0x63},
 450         {0x02, 0xa5, 0x63},
 451         {0x00, 0x05, 0x73},
 452         {0x00, 0x05, 0x73},
 453         {0x01, 0x55, 0x73},
 454         {0x02, 0xa5, 0x73},
 455         {0x00, 0x05, 0x83},
 456         {0x01, 0x55, 0x83},
 457         {0x02, 0xa5, 0x83},
 458         {0x02, 0xa5, 0x83},
 459         {0x02, 0xa5, 0x83},
 460         {0x02, 0xa5, 0x83},
 461         {0x02, 0xa5, 0x83},
 462         {0x02, 0xa5, 0x83},
 463         {0x02, 0xa5, 0x83},
 464         {0x02, 0xa5, 0x83},
 465         {0x02, 0xa5, 0x83},
 466         {0x02, 0xa5, 0x83},
 467         {0x02, 0xa5, 0x83},
 468         {0x02, 0xa5, 0x83},
 469         {0x00, 0x05, 0xF3},
 470         {0x01, 0x56, 0x03},
 471         {0x02, 0xa6, 0x03},
 472         {0x00, 0x06, 0x03},
 473         {0x00, 0x06, 0x03}
 474 };
 475
 476 static u8 vt3342_channel_table1[CB_MAX_CHANNEL][3] = {
 477         {0x01, 0x99, 0x94},
 478         {0x02, 0x44, 0x44},
 479         {0x02, 0xee, 0xe4},
 480         {0x03, 0x99, 0x94},
 481         {0x00, 0x44, 0x44},
 482         {0x00, 0xee, 0xe4},
 483         {0x01, 0x99, 0x94},
 484         {0x02, 0x44, 0x44},
 485         {0x02, 0xee, 0xe4},
 486         {0x03, 0x99, 0x94},
 487         {0x00, 0x44, 0x44},
 488         {0x00, 0xee, 0xe4},
 489         {0x01, 0x99, 0x94},
 490         {0x03, 0x33, 0x34},
 491         {0x00, 0x44, 0x44}, /* channel = 15 Tf = 4915MHz */
 492         {0x00, 0x44, 0x44},
 493         {0x00, 0x44, 0x44},
 494         {0x00, 0x44, 0x44},
 495         {0x00, 0x44, 0x44},
 496         {0x00, 0x44, 0x44},
 497         {0x00, 0x44, 0x44},
 498         {0x00, 0x44, 0x44},
 499         {0x00, 0x44, 0x44},
 500         {0x00, 0x44, 0x44},
 501         {0x00, 0x44, 0x44},
 502         {0x00, 0x44, 0x44},
 503         {0x00, 0x44, 0x44},
 504         {0x00, 0x44, 0x44},
 505         {0x00, 0x44, 0x44},
 506         {0x01, 0x55, 0x54},
 507         {0x01, 0x55, 0x54},
 508         {0x02, 0xaa, 0xa4},
 509         {0x02, 0xaa, 0xa4},
 510         {0x00, 0x00, 0x04},
 511         {0x00, 0x00, 0x04},
 512         {0x01, 0x55, 0x54},
 513         {0x02, 0xaa, 0xa4},
 514         {0x00, 0x00, 0x04},
 515         {0x01, 0x55, 0x54},
 516         {0x02, 0xaa, 0xa4},
 517         {0x02, 0xaa, 0xa4},
 518         {0x02, 0xaa, 0xa4},
 519         {0x02, 0xaa, 0xa4},
 520         {0x02, 0xaa, 0xa4},
 521         {0x02, 0xaa, 0xa4},
 522         {0x02, 0xaa, 0xa4},
 523         {0x02, 0xaa, 0xa4},
 524         {0x02, 0xaa, 0xa4},
 525         {0x02, 0xaa, 0xa4},
 526         {0x02, 0xaa, 0xa4},
 527         {0x02, 0xaa, 0xa4},
 528         {0x03, 0x00, 0x04},
 529         {0x00, 0x55, 0x54},
 530         {0x01, 0xaa, 0xa4},
 531         {0x03, 0x00, 0x04},
 532         {0x03, 0x00, 0x04}
 533 };
 534
 535 /* Power Table */
 536 static const u32 al2230_power_table[AL2230_PWR_IDX_LEN] = {
 537         0x04040900,
 538         0x04041900,
 539         0x04042900,
 540         0x04043900,
 541         0x04044900,
 542         0x04045900,
 543         0x04046900,
 544         0x04047900,
 545         0x04048900,
 546         0x04049900,
 547         0x0404a900,
 548         0x0404b900,
 549         0x0404c900,
 550         0x0404d900,
 551         0x0404e900,
 552         0x0404f900,
 553         0x04050900,
 554         0x04051900,
 555         0x04052900,
 556         0x04053900,
 557         0x04054900,
 558         0x04055900,
 559         0x04056900,
 560         0x04057900,
 561         0x04058900,
 562         0x04059900,
 563         0x0405a900,
 564         0x0405b900,
 565         0x0405c900,
 566         0x0405d900,
 567         0x0405e900,
 568         0x0405f900,
 569         0x04060900,
 570         0x04061900,
 571         0x04062900,
 572         0x04063900,
 573         0x04064900,
 574         0x04065900,
 575         0x04066900,
 576         0x04067900,
 577         0x04068900,
 578         0x04069900,
 579         0x0406a900,
 580         0x0406b900,
 581         0x0406c900,
 582         0x0406d900,
 583         0x0406e900,
 584         0x0406f900,
 585         0x04070900,
 586         0x04071900,
 587         0x04072900,
 588         0x04073900,
 589         0x04074900,
 590         0x04075900,
 591         0x04076900,
 592         0x04077900,
 593         0x04078900,
 594         0x04079900,
 595         0x0407a900,
 596         0x0407b900,
 597         0x0407c900,
 598         0x0407d900,
 599         0x0407e900,
 600         0x0407f900
 601 };
 602
 603 /*
 604  * Description: Write to IF/RF, by embedded programming
 605  */
 606 int vnt_rf_write_embedded(struct vnt_private *priv, u32 data)
 607 {
 608         u8 reg_data[4];
 609
 610         data |= (VNT_RF_REG_LEN << 3) | IFREGCTL_REGW;
 611
 612         reg_data[0] = (u8)data;
 613         reg_data[1] = (u8)(data >> 8);
 614         reg_data[2] = (u8)(data >> 16);
 615         reg_data[3] = (u8)(data >> 24);
 616
 617         vnt_control_out(priv, MESSAGE_TYPE_WRITE_IFRF,
 618                                 0, 0, ARRAY_SIZE(reg_data), reg_data);
 619
 620         return true;
 621 }
 622
 623 /* Set Tx power by rate and channel number */
 624 int vnt_rf_setpower(struct vnt_private *priv, u32 rate, u32 channel)
 625 {
 626         int ret = true;
 627         u8 power = priv->cck_pwr;
 628
 629         if (channel == 0)
 630                 return -EINVAL;
 631
 632         switch (rate) {
 633         case RATE_1M:
 634         case RATE_2M:
 635         case RATE_5M:
 636         case RATE_11M:
 637                 channel--;
 638
 639                 if (channel < sizeof(priv->cck_pwr_tbl))
 640                         power = priv->cck_pwr_tbl[channel];
 641                 break;
 642         case RATE_6M:
 643         case RATE_9M:
 644         case RATE_18M:
 645         case RATE_24M:
 646         case RATE_36M:
 647         case RATE_48M:
 648         case RATE_54M:
 649                 if (channel > CB_MAX_CHANNEL_24G)
 650                         power = priv->ofdm_a_pwr_tbl[channel-15];
 651                 else
 652                         power = priv->ofdm_pwr_tbl[channel-1];
 653                 break;
 654         }
 655
 656         ret = vnt_rf_set_txpower(priv, power, rate);
 657
 658         return ret;
 659 }
 660
 661 static u8 vnt_rf_addpower(struct vnt_private *priv)
 662 {
 663         s32 rssi = -priv->current_rssi;
 664
 665         if (!rssi)
 666                 return 7;
 667
 668         if (priv->rf_type == RF_VT3226D0) {
 669                 if (rssi < -70)
 670                         return 9;
 671                 else if (rssi < -65)
 672                         return 7;
 673                 else if (rssi < -60)
 674                         return 5;
 675         } else {
 676                 if (rssi < -80)
 677                         return 9;
 678                 else if (rssi < -75)
 679                         return 7;
 680                 else if (rssi < -70)
 681                         return 5;
 682         }
 683
 684         return 0;
 685 }
 686
 687 /* Set Tx power by power level and rate */
 688 int vnt_rf_set_txpower(struct vnt_private *priv, u8 power, u32 rate)
 689 {
 690         u32 power_setting = 0;
 691         int ret = true;
 692
 693         power += vnt_rf_addpower(priv);
 694         if (power > VNT_RF_MAX_POWER)
 695                 power = VNT_RF_MAX_POWER;
 696
 697         if (priv->power == power)
 698                 return true;
 699
 700         priv->power = power;
 701
 702         switch (priv->rf_type) {
 703         case RF_AL2230:
 704                 if (power >= AL2230_PWR_IDX_LEN)
 705                         return false;
 706
 707                 ret &= vnt_rf_write_embedded(priv, al2230_power_table[power]);
 708
 709                 if (rate <= RATE_11M)
 710                         ret &= vnt_rf_write_embedded(priv, 0x0001b400);
 711                 else
 712                         ret &= vnt_rf_write_embedded(priv, 0x0005a400);
 713                 break;
 714         case RF_AL2230S:
 715                 if (power >= AL2230_PWR_IDX_LEN)
 716                         return false;
 717
 718                 ret &= vnt_rf_write_embedded(priv, al2230_power_table[power]);
 719
 720                 if (rate <= RATE_11M) {
 721                         ret &= vnt_rf_write_embedded(priv, 0x040c1400);
 722                         ret &= vnt_rf_write_embedded(priv, 0x00299b00);
 723                 } else {
 724                         ret &= vnt_rf_write_embedded(priv, 0x0005a400);
 725                         ret &= vnt_rf_write_embedded(priv, 0x00099b00);
 726                 }
 727                 break;
 728
 729         case RF_AIROHA7230:
 730                 if (rate <= RATE_11M)
 731                         ret &= vnt_rf_write_embedded(priv, 0x111bb900);
 732                 else
 733                         ret &= vnt_rf_write_embedded(priv, 0x221bb900);
 734
 735                 if (power >= AL7230_PWR_IDX_LEN)
 736                         return false;
 737
 738                 /*
 739                 * 0x080F1B00 for 3 wire control TxGain(D10)
 740                 * and 0x31 as TX Gain value
 741                 */
 742                 power_setting = 0x080c0b00 | (power << 12);
 743
 744                 ret &= vnt_rf_write_embedded(priv, power_setting);
 745
 746                 break;
 747
 748         case RF_VT3226:
 749                 if (power >= VT3226_PWR_IDX_LEN)
 750                         return false;
 751                 power_setting = ((0x3f - power) << 20) | (0x17 << 8);
 752
 753                 ret &= vnt_rf_write_embedded(priv, power_setting);
 754
 755                 break;
 756         case RF_VT3226D0:
 757                 if (power >= VT3226_PWR_IDX_LEN)
 758                         return false;
 759
 760                 if (rate <= RATE_11M) {
 761                         u16 hw_value = priv->hw->conf.chandef.chan->hw_value;
 762
 763                         power_setting = ((0x3f - power) << 20) | (0xe07 << 8);
 764
 765                         ret &= vnt_rf_write_embedded(priv, power_setting);
 766                         ret &= vnt_rf_write_embedded(priv, 0x03c6a200);
 767
 768                         dev_dbg(&priv->usb->dev,
 769                                 "%s 11b channel [%d]\n", __func__, hw_value);
 770
 771                         hw_value--;
 772
 773                         if (hw_value < ARRAY_SIZE(vt3226d0_lo_current_table))
 774                                 ret &= vnt_rf_write_embedded(priv,
 775                                         vt3226d0_lo_current_table[hw_value]);
 776
 777                         ret &= vnt_rf_write_embedded(priv, 0x015C0800);
 778                 } else {
 779                         dev_dbg(&priv->usb->dev,
 780                                         "@@@@ vnt_rf_set_txpower> 11G mode\n");
 781
 782                         power_setting = ((0x3f - power) << 20) | (0x7 << 8);
 783
 784                         ret &= vnt_rf_write_embedded(priv, power_setting);
 785                         ret &= vnt_rf_write_embedded(priv, 0x00C6A200);
 786                         ret &= vnt_rf_write_embedded(priv, 0x016BC600);
 787                         ret &= vnt_rf_write_embedded(priv, 0x00900800);
 788                 }
 789                 break;
 790
 791         case RF_VT3342A0:
 792                 if (power >= VT3342_PWR_IDX_LEN)
 793                         return false;
 794
 795                 power_setting =  ((0x3f - power) << 20) | (0x27 << 8);
 796
 797                 ret &= vnt_rf_write_embedded(priv, power_setting);
 798
 799                 break;
 800         default:
 801                 break;
 802         }
 803         return ret;
 804 }
 805
 806 /* Convert rssi to dbm */
 807 void vnt_rf_rssi_to_dbm(struct vnt_private *priv, u8 rssi, long *dbm)
 808 {
 809         u8 idx = (((rssi & 0xc0) >> 6) & 0x03);
 810         long b = (rssi & 0x3f);
 811         long a = 0;
 812         u8 airoharf[4] = {0, 18, 0, 40};
 813
 814         switch (priv->rf_type) {
 815         case RF_AL2230:
 816         case RF_AL2230S:
 817         case RF_AIROHA7230:
 818         case RF_VT3226:
 819         case RF_VT3226D0:
 820         case RF_VT3342A0:
 821                 a = airoharf[idx];
 822                 break;
 823         default:
 824                 break;
 825         }
 826
 827         *dbm = -1 * (a + b * 2);
 828 }
 829
 830 void vnt_rf_table_download(struct vnt_private *priv)
 831 {
 832         u16 length1 = 0, length2 = 0, length3 = 0;
 833         u8 *addr1 = NULL, *addr2 = NULL, *addr3 = NULL;
 834         u16 length, value;
 835         u8 array[256];
 836
 837         switch (priv->rf_type) {
 838         case RF_AL2230:
 839         case RF_AL2230S:
 840                 length1 = CB_AL2230_INIT_SEQ * 3;
 841                 length2 = CB_MAX_CHANNEL_24G * 3;
 842                 length3 = CB_MAX_CHANNEL_24G * 3;
 843                 addr1 = &al2230_init_table[0][0];
 844                 addr2 = &al2230_channel_table0[0][0];
 845                 addr3 = &al2230_channel_table1[0][0];
 846                 break;
 847         case RF_AIROHA7230:
 848                 length1 = CB_AL7230_INIT_SEQ * 3;
 849                 length2 = CB_MAX_CHANNEL * 3;
 850                 length3 = CB_MAX_CHANNEL * 3;
 851                 addr1 = &al7230_init_table[0][0];
 852                 addr2 = &al7230_channel_table0[0][0];
 853                 addr3 = &al7230_channel_table1[0][0];
 854                 break;
 855         case RF_VT3226:
 856                 length1 = CB_VT3226_INIT_SEQ * 3;
 857                 length2 = CB_MAX_CHANNEL_24G * 3;
 858                 length3 = CB_MAX_CHANNEL_24G * 3;
 859                 addr1 = &vt3226_init_table[0][0];
 860                 addr2 = &vt3226_channel_table0[0][0];
 861                 addr3 = &vt3226_channel_table1[0][0];
 862                 break;
 863         case RF_VT3226D0:
 864                 length1 = CB_VT3226_INIT_SEQ * 3;
 865                 length2 = CB_MAX_CHANNEL_24G * 3;
 866                 length3 = CB_MAX_CHANNEL_24G * 3;
 867                 addr1 = &vt3226d0_init_table[0][0];
 868                 addr2 = &vt3226_channel_table0[0][0];
 869                 addr3 = &vt3226_channel_table1[0][0];
 870                 break;
 871         case RF_VT3342A0:
 872                 length1 = CB_VT3342_INIT_SEQ * 3;
 873                 length2 = CB_MAX_CHANNEL * 3;
 874                 length3 = CB_MAX_CHANNEL * 3;
 875                 addr1 = &vt3342a0_init_table[0][0];
 876                 addr2 = &vt3342_channel_table0[0][0];
 877                 addr3 = &vt3342_channel_table1[0][0];
 878                 break;
 879         }
 880
 881         /* Init Table */
 882         memcpy(array, addr1, length1);
 883
 884         vnt_control_out(priv, MESSAGE_TYPE_WRITE, 0,
 885                 MESSAGE_REQUEST_RF_INIT, length1, array);
 886
 887         /* Channel Table 0 */
 888         value = 0;
 889         while (length2 > 0) {
 890                 if (length2 >= 64)
 891                         length = 64;
 892                 else
 893                         length = length2;
 894
 895                 memcpy(array, addr2, length);
 896
 897                 vnt_control_out(priv, MESSAGE_TYPE_WRITE,
 898                         value, MESSAGE_REQUEST_RF_CH0, length, array);
 899
 900                 length2 -= length;
 901                 value += length;
 902                 addr2 += length;
 903         }
 904
 905         /* Channel table 1 */
 906         value = 0;
 907         while (length3 > 0) {
 908                 if (length3 >= 64)
 909                         length = 64;
 910                 else
 911                         length = length3;
 912
 913                 memcpy(array, addr3, length);
 914
 915                 vnt_control_out(priv, MESSAGE_TYPE_WRITE,
 916                         value, MESSAGE_REQUEST_RF_CH1, length, array);
 917
 918                 length3 -= length;
 919                 value += length;
 920                 addr3 += length;
 921         }
 922
 923         if (priv->rf_type == RF_AIROHA7230) {
 924                 length1 = CB_AL7230_INIT_SEQ * 3;
 925                 length2 = CB_MAX_CHANNEL * 3;
 926                 addr1 = &(al7230_init_table_amode[0][0]);
 927                 addr2 = &(al7230_channel_table2[0][0]);
 928
 929                 memcpy(array, addr1, length1);
 930
 931                 /* Init Table 2 */
 932                 vnt_control_out(priv, MESSAGE_TYPE_WRITE,
 933                         0, MESSAGE_REQUEST_RF_INIT2, length1, array);
 934
 935                 /* Channel Table 0 */
 936                 value = 0;
 937                 while (length2 > 0) {
 938                         if (length2 >= 64)
 939                                 length = 64;
 940                         else
 941                                 length = length2;
 942
 943                         memcpy(array, addr2, length);
 944
 945                         vnt_control_out(priv, MESSAGE_TYPE_WRITE,
 946                                 value, MESSAGE_REQUEST_RF_CH2, length, array);
 947
 948                         length2 -= length;
 949                         value += length;
 950                         addr2 += length;
 951                 }
 952         }
 953 }