linux/drivers/net/wireless/zd1211rw/zd_rf_al7230b.c
<<
>>
Prefs 
   1/* ZD1211 USB-WLAN driver for Linux
   2 *
   3 * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
   4 * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
   5 *
   6 * This program is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation; either version 2 of the License, or
   9 * (at your option) any later version.
  10 *
  11 * This program is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 * GNU General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with this program; if not, write to the Free Software
  18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19 */
  20
  21#include <linux/kernel.h>
  22
  23#include "zd_rf.h"
  24#include "zd_usb.h"
  25#include "zd_chip.h"
  26
  27static const u32 chan_rv[][2] = {
  28        RF_CHANNEL( 1) = { 0x09ec00, 0x8cccc8 },
  29        RF_CHANNEL( 2) = { 0x09ec00, 0x8cccd8 },
  30        RF_CHANNEL( 3) = { 0x09ec00, 0x8cccc0 },
  31        RF_CHANNEL( 4) = { 0x09ec00, 0x8cccd0 },
  32        RF_CHANNEL( 5) = { 0x05ec00, 0x8cccc8 },
  33        RF_CHANNEL( 6) = { 0x05ec00, 0x8cccd8 },
  34        RF_CHANNEL( 7) = { 0x05ec00, 0x8cccc0 },
  35        RF_CHANNEL( 8) = { 0x05ec00, 0x8cccd0 },
  36        RF_CHANNEL( 9) = { 0x0dec00, 0x8cccc8 },
  37        RF_CHANNEL(10) = { 0x0dec00, 0x8cccd8 },
  38        RF_CHANNEL(11) = { 0x0dec00, 0x8cccc0 },
  39        RF_CHANNEL(12) = { 0x0dec00, 0x8cccd0 },
  40        RF_CHANNEL(13) = { 0x03ec00, 0x8cccc8 },
  41        RF_CHANNEL(14) = { 0x03ec00, 0x866660 },
  42};
  43
  44static const u32 std_rv[] = {
  45        0x4ff821,
  46        0xc5fbfc,
  47        0x21ebfe,
  48        0xafd401, /* freq shift 0xaad401 */
  49        0x6cf56a,
  50        0xe04073,
  51        0x193d76,
  52        0x9dd844,
  53        0x500007,
  54        0xd8c010,
  55};
  56
  57static const u32 rv_init1[] = {
  58        0x3c9000,
  59        0xbfffff,
  60        0x700000,
  61        0xf15d58,
  62};
  63
  64static const u32 rv_init2[] = {
  65        0xf15d59,
  66        0xf15d5c,
  67        0xf15d58,
  68};
  69
  70static const struct zd_ioreq16 ioreqs_sw[] = {
  71        { CR128, 0x14 }, { CR129, 0x12 }, { CR130, 0x10 },
  72        { CR38,  0x38 }, { CR136, 0xdf },
  73};
  74
  75static int zd1211b_al7230b_finalize(struct zd_chip *chip)
  76{
  77        int r;
  78        static const struct zd_ioreq16 ioreqs[] = {
  79                { CR80,  0x30 }, { CR81,  0x30 }, { CR79,  0x58 },
  80                { CR12,  0xf0 }, { CR77,  0x1b }, { CR78,  0x58 },
  81                { CR203, 0x04 },
  82                { },
  83                { CR240, 0x80 },
  84        };
  85
  86        r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
  87        if (r)
  88                return r;
  89
  90        if (chip->new_phy_layout) {
  91                /* antenna selection? */
  92                r = zd_iowrite16_locked(chip, 0xe5, CR9);
  93                if (r)
  94                        return r;
  95        }
  96
  97        return zd_iowrite16_locked(chip, 0x04, CR203);
  98}
  99
 100static int zd1211_al7230b_init_hw(struct zd_rf *rf)
 101{
 102        int r;
 103        struct zd_chip *chip = zd_rf_to_chip(rf);
 104
 105        /* All of these writes are identical to AL2230 unless otherwise
 106         * specified */
 107        static const struct zd_ioreq16 ioreqs_1[] = {
 108                /* This one is 7230-specific, and happens before the rest */
 109                { CR240,  0x57 },
 110                { },
 111
 112                { CR15,   0x20 }, { CR23,   0x40 }, { CR24,  0x20 },
 113                { CR26,   0x11 }, { CR28,   0x3e }, { CR29,  0x00 },
 114                { CR44,   0x33 },
 115                /* This value is different for 7230 (was: 0x2a) */
 116                { CR106,  0x22 },
 117                { CR107,  0x1a }, { CR109,  0x09 }, { CR110,  0x27 },
 118                { CR111,  0x2b }, { CR112,  0x2b }, { CR119,  0x0a },
 119                /* This happened further down in AL2230,
 120                 * and the value changed (was: 0xe0) */
 121                { CR122,  0xfc },
 122                { CR10,   0x89 },
 123                /* for newest (3rd cut) AL2300 */
 124                { CR17,   0x28 },
 125                { CR26,   0x93 }, { CR34,   0x30 },
 126                /* for newest (3rd cut) AL2300 */
 127                { CR35,   0x3e },
 128                { CR41,   0x24 }, { CR44,   0x32 },
 129                /* for newest (3rd cut) AL2300 */
 130                { CR46,   0x96 },
 131                { CR47,   0x1e }, { CR79,   0x58 }, { CR80,  0x30 },
 132                { CR81,   0x30 }, { CR87,   0x0a }, { CR89,  0x04 },
 133                { CR92,   0x0a }, { CR99,   0x28 },
 134                /* This value is different for 7230 (was: 0x00) */
 135                { CR100,  0x02 },
 136                { CR101,  0x13 }, { CR102,  0x27 },
 137                /* This value is different for 7230 (was: 0x24) */
 138                { CR106,  0x22 },
 139                /* This value is different for 7230 (was: 0x2a) */
 140                { CR107,  0x3f },
 141                { CR109,  0x09 },
 142                /* This value is different for 7230 (was: 0x13) */
 143                { CR110,  0x1f },
 144                { CR111,  0x1f }, { CR112,  0x1f }, { CR113, 0x27 },
 145                { CR114,  0x27 },
 146                /* for newest (3rd cut) AL2300 */
 147                { CR115,  0x24 },
 148                /* This value is different for 7230 (was: 0x24) */
 149                { CR116,  0x3f },
 150                /* This value is different for 7230 (was: 0xf4) */
 151                { CR117,  0xfa },
 152                { CR118,  0xfc }, { CR119,  0x10 }, { CR120, 0x4f },
 153                { CR121,  0x77 }, { CR137,  0x88 },
 154                /* This one is 7230-specific */
 155                { CR138,  0xa8 },
 156                /* This value is different for 7230 (was: 0xff) */
 157                { CR252,  0x34 },
 158                /* This value is different for 7230 (was: 0xff) */
 159                { CR253,  0x34 },
 160
 161                /* PLL_OFF */
 162                { CR251, 0x2f },
 163        };
 164
 165        static const struct zd_ioreq16 ioreqs_2[] = {
 166                { CR251, 0x3f }, /* PLL_ON */
 167                { CR128, 0x14 }, { CR129, 0x12 }, { CR130, 0x10 },
 168                { CR38,  0x38 }, { CR136, 0xdf },
 169        };
 170
 171        r = zd_iowrite16a_locked(chip, ioreqs_1, ARRAY_SIZE(ioreqs_1));
 172        if (r)
 173                return r;
 174
 175        r = zd_rfwritev_cr_locked(chip, chan_rv[0], ARRAY_SIZE(chan_rv[0]));
 176        if (r)
 177                return r;
 178
 179        r = zd_rfwritev_cr_locked(chip, std_rv, ARRAY_SIZE(std_rv));
 180        if (r)
 181                return r;
 182
 183        r = zd_rfwritev_cr_locked(chip, rv_init1, ARRAY_SIZE(rv_init1));
 184        if (r)
 185                return r;
 186
 187        r = zd_iowrite16a_locked(chip, ioreqs_2, ARRAY_SIZE(ioreqs_2));
 188        if (r)
 189                return r;
 190
 191        r = zd_rfwritev_cr_locked(chip, rv_init2, ARRAY_SIZE(rv_init2));
 192        if (r)
 193                return r;
 194
 195        r = zd_iowrite16_locked(chip, 0x06, CR203);
 196        if (r)
 197                return r;
 198        r = zd_iowrite16_locked(chip, 0x80, CR240);
 199        if (r)
 200                return r;
 201
 202        return 0;
 203}
 204
 205static int zd1211b_al7230b_init_hw(struct zd_rf *rf)
 206{
 207        int r;
 208        struct zd_chip *chip = zd_rf_to_chip(rf);
 209
 210        static const struct zd_ioreq16 ioreqs_1[] = {
 211                { CR240, 0x57 }, { CR9,   0x9 },
 212                { },
 213                { CR10,  0x8b }, { CR15,  0x20 },
 214                { CR17,  0x2B }, /* for newest (3rd cut) AL2230 */
 215                { CR20,  0x10 }, /* 4N25->Stone Request */
 216                { CR23,  0x40 }, { CR24,  0x20 }, { CR26,  0x93 },
 217                { CR28,  0x3e }, { CR29,  0x00 },
 218                { CR33,  0x28 }, /* 5613 */
 219                { CR34,  0x30 },
 220                { CR35,  0x3e }, /* for newest (3rd cut) AL2230 */
 221                { CR41,  0x24 }, { CR44,  0x32 },
 222                { CR46,  0x99 }, /* for newest (3rd cut) AL2230 */
 223                { CR47,  0x1e },
 224
 225                /* ZD1215 5610 */
 226                { CR48,  0x00 }, { CR49,  0x00 }, { CR51,  0x01 },
 227                { CR52,  0x80 }, { CR53,  0x7e }, { CR65,  0x00 },
 228                { CR66,  0x00 }, { CR67,  0x00 }, { CR68,  0x00 },
 229                { CR69,  0x28 },
 230
 231                { CR79,  0x58 }, { CR80,  0x30 }, { CR81,  0x30 },
 232                { CR87,  0x0A }, { CR89,  0x04 },
 233                { CR90,  0x58 }, /* 5112 */
 234                { CR91,  0x00 }, /* 5613 */
 235                { CR92,  0x0a },
 236                { CR98,  0x8d }, /* 4804, for 1212 new algorithm */
 237                { CR99,  0x00 }, { CR100, 0x02 }, { CR101, 0x13 },
 238                { CR102, 0x27 },
 239                { CR106, 0x20 }, /* change to 0x24 for AL7230B */
 240                { CR109, 0x13 }, /* 4804, for 1212 new algorithm */
 241                { CR112, 0x1f },
 242        };
 243
 244        static const struct zd_ioreq16 ioreqs_new_phy[] = {
 245                { CR107, 0x28 },
 246                { CR110, 0x1f }, /* 5127, 0x13->0x1f */
 247                { CR111, 0x1f }, /* 0x13 to 0x1f for AL7230B */
 248                { CR116, 0x2a }, { CR118, 0xfa }, { CR119, 0x12 },
 249                { CR121, 0x6c }, /* 5613 */
 250        };
 251
 252        static const struct zd_ioreq16 ioreqs_old_phy[] = {
 253                { CR107, 0x24 },
 254                { CR110, 0x13 }, /* 5127, 0x13->0x1f */
 255                { CR111, 0x13 }, /* 0x13 to 0x1f for AL7230B */
 256                { CR116, 0x24 }, { CR118, 0xfc }, { CR119, 0x11 },
 257                { CR121, 0x6a }, /* 5613 */
 258        };
 259
 260        static const struct zd_ioreq16 ioreqs_2[] = {
 261                { CR113, 0x27 }, { CR114, 0x27 }, { CR115, 0x24 },
 262                { CR117, 0xfa }, { CR120, 0x4f },
 263                { CR122, 0xfc }, /* E0->FCh at 4901 */
 264                { CR123, 0x57 }, /* 5613 */
 265                { CR125, 0xad }, /* 4804, for 1212 new algorithm */
 266                { CR126, 0x6c }, /* 5613 */
 267                { CR127, 0x03 }, /* 4804, for 1212 new algorithm */
 268                { CR130, 0x10 },
 269                { CR131, 0x00 }, /* 5112 */
 270                { CR137, 0x50 }, /* 5613 */
 271                { CR138, 0xa8 }, /* 5112 */
 272                { CR144, 0xac }, /* 5613 */
 273                { CR148, 0x40 }, /* 5112 */
 274                { CR149, 0x40 }, /* 4O07, 50->40 */
 275                { CR150, 0x1a }, /* 5112, 0C->1A */
 276                { CR252, 0x34 }, { CR253, 0x34 },
 277                { CR251, 0x2f }, /* PLL_OFF */
 278        };
 279
 280        static const struct zd_ioreq16 ioreqs_3[] = {
 281                { CR251, 0x7f }, /* PLL_ON */
 282                { CR128, 0x14 }, { CR129, 0x12 }, { CR130, 0x10 },
 283                { CR38,  0x38 }, { CR136, 0xdf },
 284        };
 285
 286        r = zd_iowrite16a_locked(chip, ioreqs_1, ARRAY_SIZE(ioreqs_1));
 287        if (r)
 288                return r;
 289
 290        if (chip->new_phy_layout)
 291                r = zd_iowrite16a_locked(chip, ioreqs_new_phy,
 292                        ARRAY_SIZE(ioreqs_new_phy));
 293        else
 294                r = zd_iowrite16a_locked(chip, ioreqs_old_phy,
 295                        ARRAY_SIZE(ioreqs_old_phy));
 296        if (r)
 297                return r;
 298
 299        r = zd_iowrite16a_locked(chip, ioreqs_2, ARRAY_SIZE(ioreqs_2));
 300        if (r)
 301                return r;
 302
 303        r = zd_rfwritev_cr_locked(chip, chan_rv[0], ARRAY_SIZE(chan_rv[0]));
 304        if (r)
 305                return r;
 306
 307        r = zd_rfwritev_cr_locked(chip, std_rv, ARRAY_SIZE(std_rv));
 308        if (r)
 309                return r;
 310
 311        r = zd_rfwritev_cr_locked(chip, rv_init1, ARRAY_SIZE(rv_init1));
 312        if (r)
 313                return r;
 314
 315        r = zd_iowrite16a_locked(chip, ioreqs_3, ARRAY_SIZE(ioreqs_3));
 316        if (r)
 317                return r;
 318
 319        r = zd_rfwritev_cr_locked(chip, rv_init2, ARRAY_SIZE(rv_init2));
 320        if (r)
 321                return r;
 322
 323        return zd1211b_al7230b_finalize(chip);
 324}
 325
 326static int zd1211_al7230b_set_channel(struct zd_rf *rf, u8 channel)
 327{
 328        int r;
 329        const u32 *rv = chan_rv[channel-1];
 330        struct zd_chip *chip = zd_rf_to_chip(rf);
 331
 332        static const struct zd_ioreq16 ioreqs[] = {
 333                /* PLL_ON */
 334                { CR251, 0x3f },
 335                { CR203, 0x06 }, { CR240, 0x08 },
 336        };
 337
 338        r = zd_iowrite16_locked(chip, 0x57, CR240);
 339        if (r)
 340                return r;
 341
 342        /* PLL_OFF */
 343        r = zd_iowrite16_locked(chip, 0x2f, CR251);
 344        if (r)
 345                return r;
 346
 347        r = zd_rfwritev_cr_locked(chip, std_rv, ARRAY_SIZE(std_rv));
 348        if (r)
 349                return r;
 350
 351        r = zd_rfwrite_cr_locked(chip, 0x3c9000);
 352        if (r)
 353                return r;
 354        r = zd_rfwrite_cr_locked(chip, 0xf15d58);
 355        if (r)
 356                return r;
 357
 358        r = zd_iowrite16a_locked(chip, ioreqs_sw, ARRAY_SIZE(ioreqs_sw));
 359        if (r)
 360                return r;
 361
 362        r = zd_rfwritev_cr_locked(chip, rv, 2);
 363        if (r)
 364                return r;
 365
 366        r = zd_rfwrite_cr_locked(chip, 0x3c9000);
 367        if (r)
 368                return r;
 369
 370        return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
 371}
 372
 373static int zd1211b_al7230b_set_channel(struct zd_rf *rf, u8 channel)
 374{
 375        int r;
 376        const u32 *rv = chan_rv[channel-1];
 377        struct zd_chip *chip = zd_rf_to_chip(rf);
 378
 379        r = zd_iowrite16_locked(chip, 0x57, CR240);
 380        if (r)
 381                return r;
 382        r = zd_iowrite16_locked(chip, 0xe4, CR9);
 383        if (r)
 384                return r;
 385
 386        /* PLL_OFF */
 387        r = zd_iowrite16_locked(chip, 0x2f, CR251);
 388        if (r)
 389                return r;
 390        r = zd_rfwritev_cr_locked(chip, std_rv, ARRAY_SIZE(std_rv));
 391        if (r)
 392                return r;
 393
 394        r = zd_rfwrite_cr_locked(chip, 0x3c9000);
 395        if (r)
 396                return r;
 397        r = zd_rfwrite_cr_locked(chip, 0xf15d58);
 398        if (r)
 399                return r;
 400
 401        r = zd_iowrite16a_locked(chip, ioreqs_sw, ARRAY_SIZE(ioreqs_sw));
 402        if (r)
 403                return r;
 404
 405        r = zd_rfwritev_cr_locked(chip, rv, 2);
 406        if (r)
 407                return r;
 408
 409        r = zd_rfwrite_cr_locked(chip, 0x3c9000);
 410        if (r)
 411                return r;
 412
 413        r = zd_iowrite16_locked(chip, 0x7f, CR251);
 414        if (r)
 415                return r;
 416
 417        return zd1211b_al7230b_finalize(chip);
 418}
 419
 420static int zd1211_al7230b_switch_radio_on(struct zd_rf *rf)
 421{
 422        struct zd_chip *chip = zd_rf_to_chip(rf);
 423        static const struct zd_ioreq16 ioreqs[] = {
 424                { CR11,  0x00 },
 425                { CR251, 0x3f },
 426        };
 427
 428        return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
 429}
 430
 431static int zd1211b_al7230b_switch_radio_on(struct zd_rf *rf)
 432{
 433        struct zd_chip *chip = zd_rf_to_chip(rf);
 434        static const struct zd_ioreq16 ioreqs[] = {
 435                { CR11,  0x00 },
 436                { CR251, 0x7f },
 437        };
 438
 439        return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
 440}
 441
 442static int al7230b_switch_radio_off(struct zd_rf *rf)
 443{
 444        struct zd_chip *chip = zd_rf_to_chip(rf);
 445        static const struct zd_ioreq16 ioreqs[] = {
 446                { CR11,  0x04 },
 447                { CR251, 0x2f },
 448        };
 449
 450        return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
 451}
 452
 453/* ZD1211B+AL7230B 6m band edge patching differs slightly from other
 454 * configurations */
 455static int zd1211b_al7230b_patch_6m(struct zd_rf *rf, u8 channel)
 456{
 457        struct zd_chip *chip = zd_rf_to_chip(rf);
 458        struct zd_ioreq16 ioreqs[] = {
 459                { CR128, 0x14 }, { CR129, 0x12 },
 460        };
 461
 462        /* FIXME: Channel 11 is not the edge for all regulatory domains. */
 463        if (channel == 1) {
 464                ioreqs[0].value = 0x0e;
 465                ioreqs[1].value = 0x10;
 466        } else if (channel == 11) {
 467                ioreqs[0].value = 0x10;
 468                ioreqs[1].value = 0x10;
 469        }
 470
 471        dev_dbg_f(zd_chip_dev(chip), "patching for channel %d\n", channel);
 472        return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
 473}
 474
 475int zd_rf_init_al7230b(struct zd_rf *rf)
 476{
 477        struct zd_chip *chip = zd_rf_to_chip(rf);
 478
 479        if (zd_chip_is_zd1211b(chip)) {
 480                rf->init_hw = zd1211b_al7230b_init_hw;
 481                rf->switch_radio_on = zd1211b_al7230b_switch_radio_on;
 482                rf->set_channel = zd1211b_al7230b_set_channel;
 483                rf->patch_6m_band_edge = zd1211b_al7230b_patch_6m;
 484        } else {
 485                rf->init_hw = zd1211_al7230b_init_hw;
 486                rf->switch_radio_on = zd1211_al7230b_switch_radio_on;
 487                rf->set_channel = zd1211_al7230b_set_channel;
 488                rf->patch_6m_band_edge = zd_rf_generic_patch_6m;
 489                rf->patch_cck_gain = 1;
 490        }
 491
 492        rf->switch_radio_off = al7230b_switch_radio_off;
 493
 494        return 0;
 495}
 496
The original LXR software by the LXR community, this experimental version by lxr@linux.no.
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.