drivers/net/wireless/zd1211rw/zd_chip.c

   1 /* zd_chip.c
   2  *
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  16  */
  17
  18 /* This file implements all the hardware specific functions for the ZD1211
  19  * and ZD1211B chips. Support for the ZD1211B was possible after Timothy
  20  * Legge sent me a ZD1211B device. Thank you Tim. -- Uli
  21  */
  22
  23 #include <linux/kernel.h>
  24 #include <linux/errno.h>
  25
  26 #include "zd_def.h"
  27 #include "zd_chip.h"
  28 #include "zd_ieee80211.h"
  29 #include "zd_mac.h"
  30 #include "zd_rf.h"
  31
  32 void zd_chip_init(struct zd_chip *chip,
  33                  struct ieee80211_hw *hw,
  34                  struct usb_interface *intf)
  35 {
  36         memset(chip, 0, sizeof(*chip));
  37         mutex_init(&chip->mutex);
  38         zd_usb_init(&chip->usb, hw, intf);
  39         zd_rf_init(&chip->rf);
  40 }
  41
  42 void zd_chip_clear(struct zd_chip *chip)
  43 {
  44         ZD_ASSERT(!mutex_is_locked(&chip->mutex));
  45         zd_usb_clear(&chip->usb);
  46         zd_rf_clear(&chip->rf);
  47         mutex_destroy(&chip->mutex);
  48         ZD_MEMCLEAR(chip, sizeof(*chip));
  49 }
  50
  51 static int scnprint_mac_oui(struct zd_chip *chip, char *buffer, size_t size)
  52 {
  53         u8 *addr = zd_mac_get_perm_addr(zd_chip_to_mac(chip));
  54         return scnprintf(buffer, size, "%02x-%02x-%02x",
  55                          addr[0], addr[1], addr[2]);
  56 }
  57
  58 /* Prints an identifier line, which will support debugging. */
  59 static int scnprint_id(struct zd_chip *chip, char *buffer, size_t size)
  60 {
  61         int i = 0;
  62
  63         i = scnprintf(buffer, size, "zd1211%s chip ",
  64                       zd_chip_is_zd1211b(chip) ? "b" : "");
  65         i += zd_usb_scnprint_id(&chip->usb, buffer+i, size-i);
  66         i += scnprintf(buffer+i, size-i, " ");
  67         i += scnprint_mac_oui(chip, buffer+i, size-i);
  68         i += scnprintf(buffer+i, size-i, " ");
  69         i += zd_rf_scnprint_id(&chip->rf, buffer+i, size-i);
  70         i += scnprintf(buffer+i, size-i, " pa%1x %c%c%c%c%c", chip->pa_type,
  71                 chip->patch_cck_gain ? 'g' : '-',
  72                 chip->patch_cr157 ? '7' : '-',
  73                 chip->patch_6m_band_edge ? '6' : '-',
  74                 chip->new_phy_layout ? 'N' : '-',
  75                 chip->al2230s_bit ? 'S' : '-');
  76         return i;
  77 }
  78
  79 static void print_id(struct zd_chip *chip)
  80 {
  81         char buffer[80];
  82
  83         scnprint_id(chip, buffer, sizeof(buffer));
  84         buffer[sizeof(buffer)-1] = 0;
  85         dev_info(zd_chip_dev(chip), "%s\n", buffer);
  86 }
  87
  88 static zd_addr_t inc_addr(zd_addr_t addr)
  89 {
  90         u16 a = (u16)addr;
  91         /* Control registers use byte addressing, but everything else uses word
  92          * addressing. */
  93         if ((a & 0xf000) == CR_START)
  94                 a += 2;
  95         else
  96                 a += 1;
  97         return (zd_addr_t)a;
  98 }
  99
 100 /* Read a variable number of 32-bit values. Parameter count is not allowed to
 101  * exceed USB_MAX_IOREAD32_COUNT.
 102  */
 103 int zd_ioread32v_locked(struct zd_chip *chip, u32 *values, const zd_addr_t *addr,
 104                  unsigned int count)
 105 {
 106         int r;
 107         int i;
 108         zd_addr_t *a16;
 109         u16 *v16;
 110         unsigned int count16;
 111
 112         if (count > USB_MAX_IOREAD32_COUNT)
 113                 return -EINVAL;
 114
 115         /* Allocate a single memory block for values and addresses. */
 116         count16 = 2*count;
 117         a16 = (zd_addr_t *) kmalloc(count16 * (sizeof(zd_addr_t) + sizeof(u16)),
 118                                    GFP_KERNEL);
 119         if (!a16) {
 120                 dev_dbg_f(zd_chip_dev(chip),
 121                           "error ENOMEM in allocation of a16\n");
 122                 r = -ENOMEM;
 123                 goto out;
 124         }
 125         v16 = (u16 *)(a16 + count16);
 126
 127         for (i = 0; i < count; i++) {
 128                 int j = 2*i;
 129                 /* We read the high word always first. */
 130                 a16[j] = inc_addr(addr[i]);
 131                 a16[j+1] = addr[i];
 132         }
 133
 134         r = zd_ioread16v_locked(chip, v16, a16, count16);
 135         if (r) {
 136                 dev_dbg_f(zd_chip_dev(chip),
 137                           "error: zd_ioread16v_locked. Error number %d\n", r);
 138                 goto out;
 139         }
 140
 141         for (i = 0; i < count; i++) {
 142                 int j = 2*i;
 143                 values[i] = (v16[j] << 16) | v16[j+1];
 144         }
 145
 146 out:
 147         kfree((void *)a16);
 148         return r;
 149 }
 150
 151 int _zd_iowrite32v_locked(struct zd_chip *chip, const struct zd_ioreq32 *ioreqs,
 152                    unsigned int count)
 153 {
 154         int i, j, r;
 155         struct zd_ioreq16 *ioreqs16;
 156         unsigned int count16;
 157
 158         ZD_ASSERT(mutex_is_locked(&chip->mutex));
 159
 160         if (count == 0)
 161                 return 0;
 162         if (count > USB_MAX_IOWRITE32_COUNT)
 163                 return -EINVAL;
 164
 165         /* Allocate a single memory block for values and addresses. */
 166         count16 = 2*count;
 167         ioreqs16 = kmalloc(count16 * sizeof(struct zd_ioreq16), GFP_KERNEL);
 168         if (!ioreqs16) {
 169                 r = -ENOMEM;
 170                 dev_dbg_f(zd_chip_dev(chip),
 171                           "error %d in ioreqs16 allocation\n", r);
 172                 goto out;
 173         }
 174
 175         for (i = 0; i < count; i++) {
 176                 j = 2*i;
 177                 /* We write the high word always first. */
 178                 ioreqs16[j].value   = ioreqs[i].value >> 16;
 179                 ioreqs16[j].addr    = inc_addr(ioreqs[i].addr);
 180                 ioreqs16[j+1].value = ioreqs[i].value;
 181                 ioreqs16[j+1].addr  = ioreqs[i].addr;
 182         }
 183
 184         r = zd_usb_iowrite16v(&chip->usb, ioreqs16, count16);
 185 #ifdef DEBUG
 186         if (r) {
 187                 dev_dbg_f(zd_chip_dev(chip),
 188                           "error %d in zd_usb_write16v\n", r);
 189         }
 190 #endif /* DEBUG */
 191 out:
 192         kfree(ioreqs16);
 193         return r;
 194 }
 195
 196 int zd_iowrite16a_locked(struct zd_chip *chip,
 197                   const struct zd_ioreq16 *ioreqs, unsigned int count)
 198 {
 199         int r;
 200         unsigned int i, j, t, max;
 201
 202         ZD_ASSERT(mutex_is_locked(&chip->mutex));
 203         for (i = 0; i < count; i += j + t) {
 204                 t = 0;
 205                 max = count-i;
 206                 if (max > USB_MAX_IOWRITE16_COUNT)
 207                         max = USB_MAX_IOWRITE16_COUNT;
 208                 for (j = 0; j < max; j++) {
 209                         if (!ioreqs[i+j].addr) {
 210                                 t = 1;
 211                                 break;
 212                         }
 213                 }
 214
 215                 r = zd_usb_iowrite16v(&chip->usb, &ioreqs[i], j);
 216                 if (r) {
 217                         dev_dbg_f(zd_chip_dev(chip),
 218                                   "error zd_usb_iowrite16v. Error number %d\n",
 219                                   r);
 220                         return r;
 221                 }
 222         }
 223
 224         return 0;
 225 }
 226
 227 /* Writes a variable number of 32 bit registers. The functions will split
 228  * that in several USB requests. A split can be forced by inserting an IO
 229  * request with an zero address field.
 230  */
 231 int zd_iowrite32a_locked(struct zd_chip *chip,
 232                   const struct zd_ioreq32 *ioreqs, unsigned int count)
 233 {
 234         int r;
 235         unsigned int i, j, t, max;
 236
 237         for (i = 0; i < count; i += j + t) {
 238                 t = 0;
 239                 max = count-i;
 240                 if (max > USB_MAX_IOWRITE32_COUNT)
 241                         max = USB_MAX_IOWRITE32_COUNT;
 242                 for (j = 0; j < max; j++) {
 243                         if (!ioreqs[i+j].addr) {
 244                                 t = 1;
 245                                 break;
 246                         }
 247                 }
 248
 249                 r = _zd_iowrite32v_locked(chip, &ioreqs[i], j);
 250                 if (r) {
 251                         dev_dbg_f(zd_chip_dev(chip),
 252                                 "error _zd_iowrite32v_locked."
 253                                 " Error number %d\n", r);
 254                         return r;
 255                 }
 256         }
 257
 258         return 0;
 259 }
 260
 261 int zd_ioread16(struct zd_chip *chip, zd_addr_t addr, u16 *value)
 262 {
 263         int r;
 264
 265         mutex_lock(&chip->mutex);
 266         r = zd_ioread16_locked(chip, value, addr);
 267         mutex_unlock(&chip->mutex);
 268         return r;
 269 }
 270
 271 int zd_ioread32(struct zd_chip *chip, zd_addr_t addr, u32 *value)
 272 {
 273         int r;
 274
 275         mutex_lock(&chip->mutex);
 276         r = zd_ioread32_locked(chip, value, addr);
 277         mutex_unlock(&chip->mutex);
 278         return r;
 279 }
 280
 281 int zd_iowrite16(struct zd_chip *chip, zd_addr_t addr, u16 value)
 282 {
 283         int r;
 284
 285         mutex_lock(&chip->mutex);
 286         r = zd_iowrite16_locked(chip, value, addr);
 287         mutex_unlock(&chip->mutex);
 288         return r;
 289 }
 290
 291 int zd_iowrite32(struct zd_chip *chip, zd_addr_t addr, u32 value)
 292 {
 293         int r;
 294
 295         mutex_lock(&chip->mutex);
 296         r = zd_iowrite32_locked(chip, value, addr);
 297         mutex_unlock(&chip->mutex);
 298         return r;
 299 }
 300
 301 int zd_ioread32v(struct zd_chip *chip, const zd_addr_t *addresses,
 302                   u32 *values, unsigned int count)
 303 {
 304         int r;
 305
 306         mutex_lock(&chip->mutex);
 307         r = zd_ioread32v_locked(chip, values, addresses, count);
 308         mutex_unlock(&chip->mutex);
 309         return r;
 310 }
 311
 312 int zd_iowrite32a(struct zd_chip *chip, const struct zd_ioreq32 *ioreqs,
 313                   unsigned int count)
 314 {
 315         int r;
 316
 317         mutex_lock(&chip->mutex);
 318         r = zd_iowrite32a_locked(chip, ioreqs, count);
 319         mutex_unlock(&chip->mutex);
 320         return r;
 321 }
 322
 323 static int read_pod(struct zd_chip *chip, u8 *rf_type)
 324 {
 325         int r;
 326         u32 value;
 327
 328         ZD_ASSERT(mutex_is_locked(&chip->mutex));
 329         r = zd_ioread32_locked(chip, &value, E2P_POD);
 330         if (r)
 331                 goto error;
 332         dev_dbg_f(zd_chip_dev(chip), "E2P_POD %#010x\n", value);
 333
 334         /* FIXME: AL2230 handling (Bit 7 in POD) */
 335         *rf_type = value & 0x0f;
 336         chip->pa_type = (value >> 16) & 0x0f;
 337         chip->patch_cck_gain = (value >> 8) & 0x1;
 338         chip->patch_cr157 = (value >> 13) & 0x1;
 339         chip->patch_6m_band_edge = (value >> 21) & 0x1;
 340         chip->new_phy_layout = (value >> 31) & 0x1;
 341         chip->al2230s_bit = (value >> 7) & 0x1;
 342         chip->link_led = ((value >> 4) & 1) ? LED1 : LED2;
 343         chip->supports_tx_led = 1;
 344         if (value & (1 << 24)) { /* LED scenario */
 345                 if (value & (1 << 29))
 346                         chip->supports_tx_led = 0;
 347         }
 348
 349         dev_dbg_f(zd_chip_dev(chip),
 350                 "RF %s %#01x PA type %#01x patch CCK %d patch CR157 %d "
 351                 "patch 6M %d new PHY %d link LED%d tx led %d\n",
 352                 zd_rf_name(*rf_type), *rf_type,
 353                 chip->pa_type, chip->patch_cck_gain,
 354                 chip->patch_cr157, chip->patch_6m_band_edge,
 355                 chip->new_phy_layout,
 356                 chip->link_led == LED1 ? 1 : 2,
 357                 chip->supports_tx_led);
 358         return 0;
 359 error:
 360         *rf_type = 0;
 361         chip->pa_type = 0;
 362         chip->patch_cck_gain = 0;
 363         chip->patch_cr157 = 0;
 364         chip->patch_6m_band_edge = 0;
 365         chip->new_phy_layout = 0;
 366         return r;
 367 }
 368
 369 /* MAC address: if custom mac addresses are to to be used CR_MAC_ADDR_P1 and
 370  *              CR_MAC_ADDR_P2 must be overwritten
 371  */
 372 int zd_write_mac_addr(struct zd_chip *chip, const u8 *mac_addr)
 373 {
 374         int r;
 375         struct zd_ioreq32 reqs[2] = {
 376                 [0] = { .addr = CR_MAC_ADDR_P1 },
 377                 [1] = { .addr = CR_MAC_ADDR_P2 },
 378         };
 379         DECLARE_MAC_BUF(mac);
 380
 381         if (mac_addr) {
 382                 reqs[0].value = (mac_addr[3] << 24)
 383                               | (mac_addr[2] << 16)
 384                               | (mac_addr[1] <<  8)
 385                               |  mac_addr[0];
 386                 reqs[1].value = (mac_addr[5] <<  8)
 387                               |  mac_addr[4];
 388                 dev_dbg_f(zd_chip_dev(chip),
 389                         "mac addr %s\n", print_mac(mac, mac_addr));
 390         } else {
 391                 dev_dbg_f(zd_chip_dev(chip), "set NULL mac\n");
 392         }
 393
 394         mutex_lock(&chip->mutex);
 395         r = zd_iowrite32a_locked(chip, reqs, ARRAY_SIZE(reqs));
 396         mutex_unlock(&chip->mutex);
 397         return r;
 398 }
 399
 400 int zd_read_regdomain(struct zd_chip *chip, u8 *regdomain)
 401 {
 402         int r;
 403         u32 value;
 404
 405         mutex_lock(&chip->mutex);
 406         r = zd_ioread32_locked(chip, &value, E2P_SUBID);
 407         mutex_unlock(&chip->mutex);
 408         if (r)
 409                 return r;
 410
 411         *regdomain = value >> 16;
 412         dev_dbg_f(zd_chip_dev(chip), "regdomain: %#04x\n", *regdomain);
 413
 414         return 0;
 415 }
 416
 417 static int read_values(struct zd_chip *chip, u8 *values, size_t count,
 418                        zd_addr_t e2p_addr, u32 guard)
 419 {
 420         int r;
 421         int i;
 422         u32 v;
 423
 424         ZD_ASSERT(mutex_is_locked(&chip->mutex));
 425         for (i = 0;;) {
 426                 r = zd_ioread32_locked(chip, &v,
 427                                        (zd_addr_t)((u16)e2p_addr+i/2));
 428                 if (r)
 429                         return r;
 430                 v -= guard;
 431                 if (i+4 < count) {
 432                         values[i++] = v;
 433                         values[i++] = v >>  8;
 434                         values[i++] = v >> 16;
 435                         values[i++] = v >> 24;
 436                         continue;
 437                 }
 438                 for (;i < count; i++)
 439                         values[i] = v >> (8*(i%3));
 440                 return 0;
 441         }
 442 }
 443
 444 static int read_pwr_cal_values(struct zd_chip *chip)
 445 {
 446         return read_values(chip, chip->pwr_cal_values,
 447                         E2P_CHANNEL_COUNT, E2P_PWR_CAL_VALUE1,
 448                         0);
 449 }
 450
 451 static int read_pwr_int_values(struct zd_chip *chip)
 452 {
 453         return read_values(chip, chip->pwr_int_values,
 454                         E2P_CHANNEL_COUNT, E2P_PWR_INT_VALUE1,
 455                         E2P_PWR_INT_GUARD);
 456 }
 457
 458 static int read_ofdm_cal_values(struct zd_chip *chip)
 459 {
 460         int r;
 461         int i;
 462         static const zd_addr_t addresses[] = {
 463                 E2P_36M_CAL_VALUE1,
 464                 E2P_48M_CAL_VALUE1,
 465                 E2P_54M_CAL_VALUE1,
 466         };
 467
 468         for (i = 0; i < 3; i++) {
 469                 r = read_values(chip, chip->ofdm_cal_values[i],
 470                                 E2P_CHANNEL_COUNT, addresses[i], 0);
 471                 if (r)
 472                         return r;
 473         }
 474         return 0;
 475 }
 476
 477 static int read_cal_int_tables(struct zd_chip *chip)
 478 {
 479         int r;
 480
 481         r = read_pwr_cal_values(chip);
 482         if (r)
 483                 return r;
 484         r = read_pwr_int_values(chip);
 485         if (r)
 486                 return r;
 487         r = read_ofdm_cal_values(chip);
 488         if (r)
 489                 return r;
 490         return 0;
 491 }
 492
 493 /* phy means physical registers */
 494 int zd_chip_lock_phy_regs(struct zd_chip *chip)
 495 {
 496         int r;
 497         u32 tmp;
 498
 499         ZD_ASSERT(mutex_is_locked(&chip->mutex));
 500         r = zd_ioread32_locked(chip, &tmp, CR_REG1);
 501         if (r) {
 502                 dev_err(zd_chip_dev(chip), "error ioread32(CR_REG1): %d\n", r);
 503                 return r;
 504         }
 505
 506         tmp &= ~UNLOCK_PHY_REGS;
 507
 508         r = zd_iowrite32_locked(chip, tmp, CR_REG1);
 509         if (r)
 510                 dev_err(zd_chip_dev(chip), "error iowrite32(CR_REG1): %d\n", r);
 511         return r;
 512 }
 513
 514 int zd_chip_unlock_phy_regs(struct zd_chip *chip)
 515 {
 516         int r;
 517         u32 tmp;
 518
 519         ZD_ASSERT(mutex_is_locked(&chip->mutex));
 520         r = zd_ioread32_locked(chip, &tmp, CR_REG1);
 521         if (r) {
 522                 dev_err(zd_chip_dev(chip),
 523                         "error ioread32(CR_REG1): %d\n", r);
 524                 return r;
 525         }
 526
 527         tmp |= UNLOCK_PHY_REGS;
 528
 529         r = zd_iowrite32_locked(chip, tmp, CR_REG1);
 530         if (r)
 531                 dev_err(zd_chip_dev(chip), "error iowrite32(CR_REG1): %d\n", r);
 532         return r;
 533 }
 534
 535 /* CR157 can be optionally patched by the EEPROM for original ZD1211 */
 536 static int patch_cr157(struct zd_chip *chip)
 537 {
 538         int r;
 539         u16 value;
 540
 541         if (!chip->patch_cr157)
 542                 return 0;
 543
 544         r = zd_ioread16_locked(chip, &value, E2P_PHY_REG);
 545         if (r)
 546                 return r;
 547
 548         dev_dbg_f(zd_chip_dev(chip), "patching value %x\n", value >> 8);
 549         return zd_iowrite32_locked(chip, value >> 8, CR157);
 550 }
 551
 552 /*
 553  * 6M band edge can be optionally overwritten for certain RF's
 554  * Vendor driver says: for FCC regulation, enabled per HWFeature 6M band edge
 555  * bit (for AL2230, AL2230S)
 556  */
 557 static int patch_6m_band_edge(struct zd_chip *chip, u8 channel)
 558 {
 559         ZD_ASSERT(mutex_is_locked(&chip->mutex));
 560         if (!chip->patch_6m_band_edge)
 561                 return 0;
 562
 563         return zd_rf_patch_6m_band_edge(&chip->rf, channel);
 564 }
 565
 566 /* Generic implementation of 6M band edge patching, used by most RFs via
 567  * zd_rf_generic_patch_6m() */
 568 int zd_chip_generic_patch_6m_band(struct zd_chip *chip, int channel)
 569 {
 570         struct zd_ioreq16 ioreqs[] = {
 571                 { CR128, 0x14 }, { CR129, 0x12 }, { CR130, 0x10 },
 572                 { CR47,  0x1e },
 573         };
 574
 575         /* FIXME: Channel 11 is not the edge for all regulatory domains. */
 576         if (channel == 1 || channel == 11)
 577                 ioreqs[0].value = 0x12;
 578
 579         dev_dbg_f(zd_chip_dev(chip), "patching for channel %d\n", channel);
 580         return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
 581 }
 582
 583 static int zd1211_hw_reset_phy(struct zd_chip *chip)
 584 {
 585         static const struct zd_ioreq16 ioreqs[] = {
 586                 { CR0,   0x0a }, { CR1,   0x06 }, { CR2,   0x26 },
 587                 { CR3,   0x38 }, { CR4,   0x80 }, { CR9,   0xa0 },
 588                 { CR10,  0x81 }, { CR11,  0x00 }, { CR12,  0x7f },
 589                 { CR13,  0x8c }, { CR14,  0x80 }, { CR15,  0x3d },
 590                 { CR16,  0x20 }, { CR17,  0x1e }, { CR18,  0x0a },
 591                 { CR19,  0x48 }, { CR20,  0x0c }, { CR21,  0x0c },
 592                 { CR22,  0x23 }, { CR23,  0x90 }, { CR24,  0x14 },
 593                 { CR25,  0x40 }, { CR26,  0x10 }, { CR27,  0x19 },
 594                 { CR28,  0x7f }, { CR29,  0x80 }, { CR30,  0x4b },
 595                 { CR31,  0x60 }, { CR32,  0x43 }, { CR33,  0x08 },
 596                 { CR34,  0x06 }, { CR35,  0x0a }, { CR36,  0x00 },
 597                 { CR37,  0x00 }, { CR38,  0x38 }, { CR39,  0x0c },
 598                 { CR40,  0x84 }, { CR41,  0x2a }, { CR42,  0x80 },
 599                 { CR43,  0x10 }, { CR44,  0x12 }, { CR46,  0xff },
 600                 { CR47,  0x1E }, { CR48,  0x26 }, { CR49,  0x5b },
 601                 { CR64,  0xd0 }, { CR65,  0x04 }, { CR66,  0x58 },
 602                 { CR67,  0xc9 }, { CR68,  0x88 }, { CR69,  0x41 },
 603                 { CR70,  0x23 }, { CR71,  0x10 }, { CR72,  0xff },
 604                 { CR73,  0x32 }, { CR74,  0x30 }, { CR75,  0x65 },
 605                 { CR76,  0x41 }, { CR77,  0x1b }, { CR78,  0x30 },
 606                 { CR79,  0x68 }, { CR80,  0x64 }, { CR81,  0x64 },
 607                 { CR82,  0x00 }, { CR83,  0x00 }, { CR84,  0x00 },
 608                 { CR85,  0x02 }, { CR86,  0x00 }, { CR87,  0x00 },
 609                 { CR88,  0xff }, { CR89,  0xfc }, { CR90,  0x00 },
 610                 { CR91,  0x00 }, { CR92,  0x00 }, { CR93,  0x08 },
 611                 { CR94,  0x00 }, { CR95,  0x00 }, { CR96,  0xff },
 612                 { CR97,  0xe7 }, { CR98,  0x00 }, { CR99,  0x00 },
 613                 { CR100, 0x00 }, { CR101, 0xae }, { CR102, 0x02 },
 614                 { CR103, 0x00 }, { CR104, 0x03 }, { CR105, 0x65 },
 615                 { CR106, 0x04 }, { CR107, 0x00 }, { CR108, 0x0a },
 616                 { CR109, 0xaa }, { CR110, 0xaa }, { CR111, 0x25 },
 617                 { CR112, 0x25 }, { CR113, 0x00 }, { CR119, 0x1e },
 618                 { CR125, 0x90 }, { CR126, 0x00 }, { CR127, 0x00 },
 619                 { },
 620                 { CR5,   0x00 }, { CR6,   0x00 }, { CR7,   0x00 },
 621                 { CR8,   0x00 }, { CR9,   0x20 }, { CR12,  0xf0 },
 622                 { CR20,  0x0e }, { CR21,  0x0e }, { CR27,  0x10 },
 623                 { CR44,  0x33 }, { CR47,  0x1E }, { CR83,  0x24 },
 624                 { CR84,  0x04 }, { CR85,  0x00 }, { CR86,  0x0C },
 625                 { CR87,  0x12 }, { CR88,  0x0C }, { CR89,  0x00 },
 626                 { CR90,  0x10 }, { CR91,  0x08 }, { CR93,  0x00 },
 627                 { CR94,  0x01 }, { CR95,  0x00 }, { CR96,  0x50 },
 628                 { CR97,  0x37 }, { CR98,  0x35 }, { CR101, 0x13 },
 629                 { CR102, 0x27 }, { CR103, 0x27 }, { CR104, 0x18 },
 630                 { CR105, 0x12 }, { CR109, 0x27 }, { CR110, 0x27 },
 631                 { CR111, 0x27 }, { CR112, 0x27 }, { CR113, 0x27 },
 632                 { CR114, 0x27 }, { CR115, 0x26 }, { CR116, 0x24 },
 633                 { CR117, 0xfc }, { CR118, 0xfa }, { CR120, 0x4f },
 634                 { CR125, 0xaa }, { CR127, 0x03 }, { CR128, 0x14 },
 635                 { CR129, 0x12 }, { CR130, 0x10 }, { CR131, 0x0C },
 636                 { CR136, 0xdf }, { CR137, 0x40 }, { CR138, 0xa0 },
 637                 { CR139, 0xb0 }, { CR140, 0x99 }, { CR141, 0x82 },
 638                 { CR142, 0x54 }, { CR143, 0x1c }, { CR144, 0x6c },
 639                 { CR147, 0x07 }, { CR148, 0x4c }, { CR149, 0x50 },
 640                 { CR150, 0x0e }, { CR151, 0x18 }, { CR160, 0xfe },
 641                 { CR161, 0xee }, { CR162, 0xaa }, { CR163, 0xfa },
 642                 { CR164, 0xfa }, { CR165, 0xea }, { CR166, 0xbe },
 643                 { CR167, 0xbe }, { CR168, 0x6a }, { CR169, 0xba },
 644                 { CR170, 0xba }, { CR171, 0xba },
 645                 /* Note: CR204 must lead the CR203 */
 646                 { CR204, 0x7d },
 647                 { },
 648                 { CR203, 0x30 },
 649         };
 650
 651         int r, t;
 652
 653         dev_dbg_f(zd_chip_dev(chip), "\n");
 654
 655         r = zd_chip_lock_phy_regs(chip);
 656         if (r)
 657                 goto out;
 658
 659         r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
 660         if (r)
 661                 goto unlock;
 662
 663         r = patch_cr157(chip);
 664 unlock:
 665         t = zd_chip_unlock_phy_regs(chip);
 666         if (t && !r)
 667                 r = t;
 668 out:
 669         return r;
 670 }
 671
 672 static int zd1211b_hw_reset_phy(struct zd_chip *chip)
 673 {
 674         static const struct zd_ioreq16 ioreqs[] = {
 675                 { CR0,   0x14 }, { CR1,   0x06 }, { CR2,   0x26 },
 676                 { CR3,   0x38 }, { CR4,   0x80 }, { CR9,   0xe0 },
 677                 { CR10,  0x81 },
 678                 /* power control { { CR11,  1 << 6 }, */
 679                 { CR11,  0x00 },
 680                 { CR12,  0xf0 }, { CR13,  0x8c }, { CR14,  0x80 },
 681                 { CR15,  0x3d }, { CR16,  0x20 }, { CR17,  0x1e },
 682                 { CR18,  0x0a }, { CR19,  0x48 },
 683                 { CR20,  0x10 }, /* Org:0x0E, ComTrend:RalLink AP */
 684                 { CR21,  0x0e }, { CR22,  0x23 }, { CR23,  0x90 },
 685                 { CR24,  0x14 }, { CR25,  0x40 }, { CR26,  0x10 },
 686                 { CR27,  0x10 }, { CR28,  0x7f }, { CR29,  0x80 },
 687                 { CR30,  0x4b }, /* ASIC/FWT, no jointly decoder */
 688                 { CR31,  0x60 }, { CR32,  0x43 }, { CR33,  0x08 },
 689                 { CR34,  0x06 }, { CR35,  0x0a }, { CR36,  0x00 },
 690                 { CR37,  0x00 }, { CR38,  0x38 }, { CR39,  0x0c },
 691                 { CR40,  0x84 }, { CR41,  0x2a }, { CR42,  0x80 },
 692                 { CR43,  0x10 }, { CR44,  0x33 }, { CR46,  0xff },
 693                 { CR47,  0x1E }, { CR48,  0x26 }, { CR49,  0x5b },
 694                 { CR64,  0xd0 }, { CR65,  0x04 }, { CR66,  0x58 },
 695                 { CR67,  0xc9 }, { CR68,  0x88 }, { CR69,  0x41 },
 696                 { CR70,  0x23 }, { CR71,  0x10 }, { CR72,  0xff },
 697                 { CR73,  0x32 }, { CR74,  0x30 }, { CR75,  0x65 },
 698                 { CR76,  0x41 }, { CR77,  0x1b }, { CR78,  0x30 },
 699                 { CR79,  0xf0 }, { CR80,  0x64 }, { CR81,  0x64 },
 700                 { CR82,  0x00 }, { CR83,  0x24 }, { CR84,  0x04 },
 701                 { CR85,  0x00 }, { CR86,  0x0c }, { CR87,  0x12 },
 702                 { CR88,  0x0c }, { CR89,  0x00 }, { CR90,  0x58 },
 703                 { CR91,  0x04 }, { CR92,  0x00 }, { CR93,  0x00 },
 704                 { CR94,  0x01 },
 705                 { CR95,  0x20 }, /* ZD1211B */
 706                 { CR96,  0x50 }, { CR97,  0x37 }, { CR98,  0x35 },
 707                 { CR99,  0x00 }, { CR100, 0x01 }, { CR101, 0x13 },
 708                 { CR102, 0x27 }, { CR103, 0x27 }, { CR104, 0x18 },
 709                 { CR105, 0x12 }, { CR106, 0x04 }, { CR107, 0x00 },
 710                 { CR108, 0x0a }, { CR109, 0x27 }, { CR110, 0x27 },
 711                 { CR111, 0x27 }, { CR112, 0x27 }, { CR113, 0x27 },
 712                 { CR114, 0x27 }, { CR115, 0x26 }, { CR116, 0x24 },
 713                 { CR117, 0xfc }, { CR118, 0xfa }, { CR119, 0x1e },
 714                 { CR125, 0x90 }, { CR126, 0x00 }, { CR127, 0x00 },
 715                 { CR128, 0x14 }, { CR129, 0x12 }, { CR130, 0x10 },
 716                 { CR131, 0x0c }, { CR136, 0xdf }, { CR137, 0xa0 },
 717                 { CR138, 0xa8 }, { CR139, 0xb4 }, { CR140, 0x98 },
 718                 { CR141, 0x82 }, { CR142, 0x53 }, { CR143, 0x1c },
 719                 { CR144, 0x6c }, { CR147, 0x07 }, { CR148, 0x40 },
 720                 { CR149, 0x40 }, /* Org:0x50 ComTrend:RalLink AP */
 721                 { CR150, 0x14 }, /* Org:0x0E ComTrend:RalLink AP */
 722                 { CR151, 0x18 }, { CR159, 0x70 }, { CR160, 0xfe },
 723                 { CR161, 0xee }, { CR162, 0xaa }, { CR163, 0xfa },
 724                 { CR164, 0xfa }, { CR165, 0xea }, { CR166, 0xbe },
 725                 { CR167, 0xbe }, { CR168, 0x6a }, { CR169, 0xba },
 726                 { CR170, 0xba }, { CR171, 0xba },
 727                 /* Note: CR204 must lead the CR203 */
 728                 { CR204, 0x7d },
 729                 {},
 730                 { CR203, 0x30 },
 731         };
 732
 733         int r, t;
 734
 735         dev_dbg_f(zd_chip_dev(chip), "\n");
 736
 737         r = zd_chip_lock_phy_regs(chip);
 738         if (r)
 739                 goto out;
 740
 741         r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
 742         t = zd_chip_unlock_phy_regs(chip);
 743         if (t && !r)
 744                 r = t;
 745 out:
 746         return r;
 747 }
 748
 749 static int hw_reset_phy(struct zd_chip *chip)
 750 {
 751         return zd_chip_is_zd1211b(chip) ? zd1211b_hw_reset_phy(chip) :
 752                                   zd1211_hw_reset_phy(chip);
 753 }
 754
 755 static int zd1211_hw_init_hmac(struct zd_chip *chip)
 756 {
 757         static const struct zd_ioreq32 ioreqs[] = {
 758                 { CR_ZD1211_RETRY_MAX,          0x2 },
 759                 { CR_RX_THRESHOLD,              0x000c0640 },
 760         };
 761
 762         dev_dbg_f(zd_chip_dev(chip), "\n");
 763         ZD_ASSERT(mutex_is_locked(&chip->mutex));
 764         return zd_iowrite32a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
 765 }
 766
 767 static int zd1211b_hw_init_hmac(struct zd_chip *chip)
 768 {
 769         static const struct zd_ioreq32 ioreqs[] = {
 770                 { CR_ZD1211B_RETRY_MAX,         0x02020202 },
 771                 { CR_ZD1211B_TX_PWR_CTL4,       0x007f003f },
 772                 { CR_ZD1211B_TX_PWR_CTL3,       0x007f003f },
 773                 { CR_ZD1211B_TX_PWR_CTL2,       0x003f001f },
 774                 { CR_ZD1211B_TX_PWR_CTL1,       0x001f000f },
 775                 { CR_ZD1211B_AIFS_CTL1,         0x00280028 },
 776                 { CR_ZD1211B_AIFS_CTL2,         0x008C003C },
 777                 { CR_ZD1211B_TXOP,              0x01800824 },
 778                 { CR_RX_THRESHOLD,              0x000c0eff, },
 779         };
 780
 781         dev_dbg_f(zd_chip_dev(chip), "\n");
 782         ZD_ASSERT(mutex_is_locked(&chip->mutex));
 783         return zd_iowrite32a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
 784 }
 785
 786 static int hw_init_hmac(struct zd_chip *chip)
 787 {
 788         int r;
 789         static const struct zd_ioreq32 ioreqs[] = {
 790                 { CR_ACK_TIMEOUT_EXT,           0x20 },
 791                 { CR_ADDA_MBIAS_WARMTIME,       0x30000808 },
 792                 { CR_SNIFFER_ON,                0 },
 793                 { CR_RX_FILTER,                 STA_RX_FILTER },
 794                 { CR_GROUP_HASH_P1,             0x00 },
 795                 { CR_GROUP_HASH_P2,             0x80000000 },
 796                 { CR_REG1,                      0xa4 },
 797                 { CR_ADDA_PWR_DWN,              0x7f },
 798                 { CR_BCN_PLCP_CFG,              0x00f00401 },
 799                 { CR_PHY_DELAY,                 0x00 },
 800                 { CR_ACK_TIMEOUT_EXT,           0x80 },
 801                 { CR_ADDA_PWR_DWN,              0x00 },
 802                 { CR_ACK_TIME_80211,            0x100 },
 803                 { CR_RX_PE_DELAY,               0x70 },
 804                 { CR_PS_CTRL,                   0x10000000 },
 805                 { CR_RTS_CTS_RATE,              0x02030203 },
 806                 { CR_AFTER_PNP,                 0x1 },
 807                 { CR_WEP_PROTECT,               0x114 },
 808                 { CR_IFS_VALUE,                 IFS_VALUE_DEFAULT },
 809         };
 810
 811         ZD_ASSERT(mutex_is_locked(&chip->mutex));
 812         r = zd_iowrite32a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
 813         if (r)
 814                 return r;
 815
 816         return zd_chip_is_zd1211b(chip) ?
 817                 zd1211b_hw_init_hmac(chip) : zd1211_hw_init_hmac(chip);
 818 }
 819
 820 struct aw_pt_bi {
 821         u32 atim_wnd_period;
 822         u32 pre_tbtt;
 823         u32 beacon_interval;
 824 };
 825
 826 static int get_aw_pt_bi(struct zd_chip *chip, struct aw_pt_bi *s)
 827 {
 828         int r;
 829         static const zd_addr_t aw_pt_bi_addr[] =
 830                 { CR_ATIM_WND_PERIOD, CR_PRE_TBTT, CR_BCN_INTERVAL };
 831         u32 values[3];
 832
 833         r = zd_ioread32v_locked(chip, values, (const zd_addr_t *)aw_pt_bi_addr,
 834                          ARRAY_SIZE(aw_pt_bi_addr));
 835         if (r) {
 836                 memset(s, 0, sizeof(*s));
 837                 return r;
 838         }
 839
 840         s->atim_wnd_period = values[0];
 841         s->pre_tbtt = values[1];
 842         s->beacon_interval = values[2];
 843         return 0;
 844 }
 845
 846 static int set_aw_pt_bi(struct zd_chip *chip, struct aw_pt_bi *s)
 847 {
 848         struct zd_ioreq32 reqs[3];
 849
 850         if (s->beacon_interval <= 5)
 851                 s->beacon_interval = 5;
 852         if (s->pre_tbtt < 4 || s->pre_tbtt >= s->beacon_interval)
 853                 s->pre_tbtt = s->beacon_interval - 1;
 854         if (s->atim_wnd_period >= s->pre_tbtt)
 855                 s->atim_wnd_period = s->pre_tbtt - 1;
 856
 857         reqs[0].addr = CR_ATIM_WND_PERIOD;
 858         reqs[0].value = s->atim_wnd_period;
 859         reqs[1].addr = CR_PRE_TBTT;
 860         reqs[1].value = s->pre_tbtt;
 861         reqs[2].addr = CR_BCN_INTERVAL;
 862         reqs[2].value = s->beacon_interval;
 863
 864         return zd_iowrite32a_locked(chip, reqs, ARRAY_SIZE(reqs));
 865 }
 866
 867
 868 static int set_beacon_interval(struct zd_chip *chip, u32 interval)
 869 {
 870         int r;
 871         struct aw_pt_bi s;
 872
 873         ZD_ASSERT(mutex_is_locked(&chip->mutex));
 874         r = get_aw_pt_bi(chip, &s);
 875         if (r)
 876                 return r;
 877         s.beacon_interval = interval;
 878         return set_aw_pt_bi(chip, &s);
 879 }
 880
 881 int zd_set_beacon_interval(struct zd_chip *chip, u32 interval)
 882 {
 883         int r;
 884
 885         mutex_lock(&chip->mutex);
 886         r = set_beacon_interval(chip, interval);
 887         mutex_unlock(&chip->mutex);
 888         return r;
 889 }
 890
 891 static int hw_init(struct zd_chip *chip)
 892 {
 893         int r;
 894
 895         dev_dbg_f(zd_chip_dev(chip), "\n");
 896         ZD_ASSERT(mutex_is_locked(&chip->mutex));
 897         r = hw_reset_phy(chip);
 898         if (r)
 899                 return r;
 900
 901         r = hw_init_hmac(chip);
 902         if (r)
 903                 return r;
 904
 905         return set_beacon_interval(chip, 100);
 906 }
 907
 908 static zd_addr_t fw_reg_addr(struct zd_chip *chip, u16 offset)
 909 {
 910         return (zd_addr_t)((u16)chip->fw_regs_base + offset);
 911 }
 912
 913 #ifdef DEBUG
 914 static int dump_cr(struct zd_chip *chip, const zd_addr_t addr,
 915                    const char *addr_string)
 916 {
 917         int r;
 918         u32 value;
 919
 920         r = zd_ioread32_locked(chip, &value, addr);
 921         if (r) {
 922                 dev_dbg_f(zd_chip_dev(chip),
 923                         "error reading %s. Error number %d\n", addr_string, r);
 924                 return r;
 925         }
 926
 927         dev_dbg_f(zd_chip_dev(chip), "%s %#010x\n",
 928                 addr_string, (unsigned int)value);
 929         return 0;
 930 }
 931
 932 static int test_init(struct zd_chip *chip)
 933 {
 934         int r;
 935
 936         r = dump_cr(chip, CR_AFTER_PNP, "CR_AFTER_PNP");
 937         if (r)
 938                 return r;
 939         r = dump_cr(chip, CR_GPI_EN, "CR_GPI_EN");
 940         if (r)
 941                 return r;
 942         return dump_cr(chip, CR_INTERRUPT, "CR_INTERRUPT");
 943 }
 944
 945 static void dump_fw_registers(struct zd_chip *chip)
 946 {
 947         const zd_addr_t addr[4] = {
 948                 fw_reg_addr(chip, FW_REG_FIRMWARE_VER),
 949                 fw_reg_addr(chip, FW_REG_USB_SPEED),
 950                 fw_reg_addr(chip, FW_REG_FIX_TX_RATE),
 951                 fw_reg_addr(chip, FW_REG_LED_LINK_STATUS),
 952         };
 953
 954         int r;
 955         u16 values[4];
 956
 957         r = zd_ioread16v_locked(chip, values, (const zd_addr_t*)addr,
 958                          ARRAY_SIZE(addr));
 959         if (r) {
 960                 dev_dbg_f(zd_chip_dev(chip), "error %d zd_ioread16v_locked\n",
 961                          r);
 962                 return;
 963         }
 964
 965         dev_dbg_f(zd_chip_dev(chip), "FW_FIRMWARE_VER %#06hx\n", values[0]);
 966         dev_dbg_f(zd_chip_dev(chip), "FW_USB_SPEED %#06hx\n", values[1]);
 967         dev_dbg_f(zd_chip_dev(chip), "FW_FIX_TX_RATE %#06hx\n", values[2]);
 968         dev_dbg_f(zd_chip_dev(chip), "FW_LINK_STATUS %#06hx\n", values[3]);
 969 }
 970 #endif /* DEBUG */
 971
 972 static int print_fw_version(struct zd_chip *chip)
 973 {
 974         int r;
 975         u16 version;
 976
 977         r = zd_ioread16_locked(chip, &version,
 978                 fw_reg_addr(chip, FW_REG_FIRMWARE_VER));
 979         if (r)
 980                 return r;
 981
 982         dev_info(zd_chip_dev(chip),"firmware version %04hx\n", version);
 983         return 0;
 984 }
 985
 986 static int set_mandatory_rates(struct zd_chip *chip, int mode)
 987 {
 988         u32 rates;
 989         ZD_ASSERT(mutex_is_locked(&chip->mutex));
 990         /* This sets the mandatory rates, which only depend from the standard
 991          * that the device is supporting. Until further notice we should try
 992          * to support 802.11g also for full speed USB.
 993          */
 994         switch (mode) {
 995         case MODE_IEEE80211B:
 996                 rates = CR_RATE_1M|CR_RATE_2M|CR_RATE_5_5M|CR_RATE_11M;
 997                 break;
 998         case MODE_IEEE80211G:
 999                 rates = CR_RATE_1M|CR_RATE_2M|CR_RATE_5_5M|CR_RATE_11M|
1000                         CR_RATE_6M|CR_RATE_12M|CR_RATE_24M;
1001                 break;
1002         default:
1003                 return -EINVAL;
1004         }
1005         return zd_iowrite32_locked(chip, rates, CR_MANDATORY_RATE_TBL);
1006 }
1007
1008 int zd_chip_set_rts_cts_rate_locked(struct zd_chip *chip,
1009                                     int preamble)
1010 {
1011         u32 value = 0;
1012
1013         dev_dbg_f(zd_chip_dev(chip), "preamble=%x\n", preamble);
1014         value |= preamble << RTSCTS_SH_RTS_PMB_TYPE;
1015         value |= preamble << RTSCTS_SH_CTS_PMB_TYPE;
1016
1017         /* We always send 11M RTS/self-CTS messages, like the vendor driver. */
1018         value |= ZD_PURE_RATE(ZD_CCK_RATE_11M) << RTSCTS_SH_RTS_RATE;
1019         value |= ZD_RX_CCK << RTSCTS_SH_RTS_MOD_TYPE;
1020         value |= ZD_PURE_RATE(ZD_CCK_RATE_11M) << RTSCTS_SH_CTS_RATE;
1021         value |= ZD_RX_CCK << RTSCTS_SH_CTS_MOD_TYPE;
1022
1023         return zd_iowrite32_locked(chip, value, CR_RTS_CTS_RATE);
1024 }
1025
1026 int zd_chip_enable_hwint(struct zd_chip *chip)
1027 {
1028         int r;
1029
1030         mutex_lock(&chip->mutex);
1031         r = zd_iowrite32_locked(chip, HWINT_ENABLED, CR_INTERRUPT);
1032         mutex_unlock(&chip->mutex);
1033         return r;
1034 }
1035
1036 static int disable_hwint(struct zd_chip *chip)
1037 {
1038         return zd_iowrite32_locked(chip, HWINT_DISABLED, CR_INTERRUPT);
1039 }
1040
1041 int zd_chip_disable_hwint(struct zd_chip *chip)
1042 {
1043         int r;
1044
1045         mutex_lock(&chip->mutex);
1046         r = disable_hwint(chip);
1047         mutex_unlock(&chip->mutex);
1048         return r;
1049 }
1050
1051 static int read_fw_regs_offset(struct zd_chip *chip)
1052 {
1053         int r;
1054
1055         ZD_ASSERT(mutex_is_locked(&chip->mutex));
1056         r = zd_ioread16_locked(chip, (u16*)&chip->fw_regs_base,
1057                                FWRAW_REGS_ADDR);
1058         if (r)
1059                 return r;
1060         dev_dbg_f(zd_chip_dev(chip), "fw_regs_base: %#06hx\n",
1061                   (u16)chip->fw_regs_base);
1062
1063         return 0;
1064 }
1065
1066 /* Read mac address using pre-firmware interface */
1067 int zd_chip_read_mac_addr_fw(struct zd_chip *chip, u8 *addr)
1068 {
1069         dev_dbg_f(zd_chip_dev(chip), "\n");
1070         return zd_usb_read_fw(&chip->usb, E2P_MAC_ADDR_P1, addr,
1071                 ETH_ALEN);
1072 }
1073
1074 int zd_chip_init_hw(struct zd_chip *chip)
1075 {
1076         int r;
1077         u8 rf_type;
1078
1079         dev_dbg_f(zd_chip_dev(chip), "\n");
1080
1081         mutex_lock(&chip->mutex);
1082
1083 #ifdef DEBUG
1084         r = test_init(chip);
1085         if (r)
1086                 goto out;
1087 #endif
1088         r = zd_iowrite32_locked(chip, 1, CR_AFTER_PNP);
1089         if (r)
1090                 goto out;
1091
1092         r = read_fw_regs_offset(chip);
1093         if (r)
1094                 goto out;
1095
1096         /* GPI is always disabled, also in the other driver.
1097          */
1098         r = zd_iowrite32_locked(chip, 0, CR_GPI_EN);
1099         if (r)
1100                 goto out;
1101         r = zd_iowrite32_locked(chip, CWIN_SIZE, CR_CWMIN_CWMAX);
1102         if (r)
1103                 goto out;
1104         /* Currently we support IEEE 802.11g for full and high speed USB.
1105          * It might be discussed, whether we should suppport pure b mode for
1106          * full speed USB.
1107          */
1108         r = set_mandatory_rates(chip, MODE_IEEE80211G);
1109         if (r)
1110                 goto out;
1111         /* Disabling interrupts is certainly a smart thing here.
1112          */
1113         r = disable_hwint(chip);
1114         if (r)
1115                 goto out;
1116         r = read_pod(chip, &rf_type);
1117         if (r)
1118                 goto out;
1119         r = hw_init(chip);
1120         if (r)
1121                 goto out;
1122         r = zd_rf_init_hw(&chip->rf, rf_type);
1123         if (r)
1124                 goto out;
1125
1126         r = print_fw_version(chip);
1127         if (r)
1128                 goto out;
1129
1130 #ifdef DEBUG
1131         dump_fw_registers(chip);
1132         r = test_init(chip);
1133         if (r)
1134                 goto out;
1135 #endif /* DEBUG */
1136
1137         r = read_cal_int_tables(chip);
1138         if (r)
1139                 goto out;
1140
1141         print_id(chip);
1142 out:
1143         mutex_unlock(&chip->mutex);
1144         return r;
1145 }
1146
1147 static int update_pwr_int(struct zd_chip *chip, u8 channel)
1148 {
1149         u8 value = chip->pwr_int_values[channel - 1];
1150         return zd_iowrite16_locked(chip, value, CR31);
1151 }
1152
1153 static int update_pwr_cal(struct zd_chip *chip, u8 channel)
1154 {
1155         u8 value = chip->pwr_cal_values[channel-1];
1156         return zd_iowrite16_locked(chip, value, CR68);
1157 }
1158
1159 static int update_ofdm_cal(struct zd_chip *chip, u8 channel)
1160 {
1161         struct zd_ioreq16 ioreqs[3];
1162
1163         ioreqs[0].addr = CR67;
1164         ioreqs[0].value = chip->ofdm_cal_values[OFDM_36M_INDEX][channel-1];
1165         ioreqs[1].addr = CR66;
1166         ioreqs[1].value = chip->ofdm_cal_values[OFDM_48M_INDEX][channel-1];
1167         ioreqs[2].addr = CR65;
1168         ioreqs[2].value = chip->ofdm_cal_values[OFDM_54M_INDEX][channel-1];
1169
1170         return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
1171 }
1172
1173 static int update_channel_integration_and_calibration(struct zd_chip *chip,
1174                                                       u8 channel)
1175 {
1176         int r;
1177
1178         if (!zd_rf_should_update_pwr_int(&chip->rf))
1179                 return 0;
1180
1181         r = update_pwr_int(chip, channel);
1182         if (r)
1183                 return r;
1184         if (zd_chip_is_zd1211b(chip)) {
1185                 static const struct zd_ioreq16 ioreqs[] = {
1186                         { CR69, 0x28 },
1187                         {},
1188                         { CR69, 0x2a },
1189                 };
1190
1191                 r = update_ofdm_cal(chip, channel);
1192                 if (r)
1193                         return r;
1194                 r = update_pwr_cal(chip, channel);
1195                 if (r)
1196                         return r;
1197                 r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
1198                 if (r)
1199                         return r;
1200         }
1201
1202         return 0;
1203 }
1204
1205 /* The CCK baseband gain can be optionally patched by the EEPROM */
1206 static int patch_cck_gain(struct zd_chip *chip)
1207 {
1208         int r;
1209         u32 value;
1210
1211         if (!chip->patch_cck_gain || !zd_rf_should_patch_cck_gain(&chip->rf))
1212                 return 0;
1213
1214         ZD_ASSERT(mutex_is_locked(&chip->mutex));
1215         r = zd_ioread32_locked(chip, &value, E2P_PHY_REG);
1216         if (r)
1217                 return r;
1218         dev_dbg_f(zd_chip_dev(chip), "patching value %x\n", value & 0xff);
1219         return zd_iowrite16_locked(chip, value & 0xff, CR47);
1220 }
1221
1222 int zd_chip_set_channel(struct zd_chip *chip, u8 channel)
1223 {
1224         int r, t;
1225
1226         mutex_lock(&chip->mutex);
1227         r = zd_chip_lock_phy_regs(chip);
1228         if (r)
1229                 goto out;
1230         r = zd_rf_set_channel(&chip->rf, channel);
1231         if (r)
1232                 goto unlock;
1233         r = update_channel_integration_and_calibration(chip, channel);
1234         if (r)
1235                 goto unlock;
1236         r = patch_cck_gain(chip);
1237         if (r)
1238                 goto unlock;
1239         r = patch_6m_band_edge(chip, channel);
1240         if (r)
1241                 goto unlock;
1242         r = zd_iowrite32_locked(chip, 0, CR_CONFIG_PHILIPS);
1243 unlock:
1244         t = zd_chip_unlock_phy_regs(chip);
1245         if (t && !r)
1246                 r = t;
1247 out:
1248         mutex_unlock(&chip->mutex);
1249         return r;
1250 }
1251
1252 u8 zd_chip_get_channel(struct zd_chip *chip)
1253 {
1254         u8 channel;
1255
1256         mutex_lock(&chip->mutex);
1257         channel = chip->rf.channel;
1258         mutex_unlock(&chip->mutex);
1259         return channel;
1260 }
1261
1262 int zd_chip_control_leds(struct zd_chip *chip, enum led_status status)
1263 {
1264         const zd_addr_t a[] = {
1265                 fw_reg_addr(chip, FW_REG_LED_LINK_STATUS),
1266                 CR_LED,
1267         };
1268
1269         int r;
1270         u16 v[ARRAY_SIZE(a)];
1271         struct zd_ioreq16 ioreqs[ARRAY_SIZE(a)] = {
1272                 [0] = { fw_reg_addr(chip, FW_REG_LED_LINK_STATUS) },
1273                 [1] = { CR_LED },
1274         };
1275         u16 other_led;
1276
1277         mutex_lock(&chip->mutex);
1278         r = zd_ioread16v_locked(chip, v, (const zd_addr_t *)a, ARRAY_SIZE(a));
1279         if (r)
1280                 goto out;
1281
1282         other_led = chip->link_led == LED1 ? LED2 : LED1;
1283
1284         switch (status) {
1285         case LED_OFF:
1286                 ioreqs[0].value = FW_LINK_OFF;
1287                 ioreqs[1].value = v[1] & ~(LED1|LED2);
1288                 break;
1289         case LED_SCANNING:
1290                 ioreqs[0].value = FW_LINK_OFF;
1291                 ioreqs[1].value = v[1] & ~other_led;
1292                 if (get_seconds() % 3 == 0) {
1293                         ioreqs[1].value &= ~chip->link_led;
1294                 } else {
1295                         ioreqs[1].value |= chip->link_led;
1296                 }
1297                 break;
1298         case LED_ASSOCIATED:
1299                 ioreqs[0].value = FW_LINK_TX;
1300                 ioreqs[1].value = v[1] & ~other_led;
1301                 ioreqs[1].value |= chip->link_led;
1302                 break;
1303         default:
1304                 r = -EINVAL;
1305                 goto out;
1306         }
1307
1308         if (v[0] != ioreqs[0].value || v[1] != ioreqs[1].value) {
1309                 r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
1310                 if (r)
1311                         goto out;
1312         }
1313         r = 0;
1314 out:
1315         mutex_unlock(&chip->mutex);
1316         return r;
1317 }
1318
1319 int zd_chip_set_basic_rates(struct zd_chip *chip, u16 cr_rates)
1320 {
1321         int r;
1322
1323         if (cr_rates & ~(CR_RATES_80211B|CR_RATES_80211G))
1324                 return -EINVAL;
1325
1326         mutex_lock(&chip->mutex);
1327         r = zd_iowrite32_locked(chip, cr_rates, CR_BASIC_RATE_TBL);
1328         mutex_unlock(&chip->mutex);
1329         return r;
1330 }
1331
1332 static int ofdm_qual_db(u8 status_quality, u8 zd_rate, unsigned int size)
1333 {
1334         static const u16 constants[] = {
1335                 715, 655, 585, 540, 470, 410, 360, 315,
1336                 270, 235, 205, 175, 150, 125, 105,  85,
1337                  65,  50,  40,  25,  15
1338         };
1339
1340         int i;
1341         u32 x;
1342
1343         /* It seems that their quality parameter is somehow per signal
1344          * and is now transferred per bit.
1345          */
1346         switch (zd_rate) {
1347         case ZD_OFDM_RATE_6M:
1348         case ZD_OFDM_RATE_12M:
1349         case ZD_OFDM_RATE_24M:
1350                 size *= 2;
1351                 break;
1352         case ZD_OFDM_RATE_9M:
1353         case ZD_OFDM_RATE_18M:
1354         case ZD_OFDM_RATE_36M:
1355         case ZD_OFDM_RATE_54M:
1356                 size *= 4;
1357                 size /= 3;
1358                 break;
1359         case ZD_OFDM_RATE_48M:
1360                 size *= 3;
1361                 size /= 2;
1362                 break;
1363         default:
1364                 return -EINVAL;
1365         }
1366
1367         x = (10000 * status_quality)/size;
1368         for (i = 0; i < ARRAY_SIZE(constants); i++) {
1369                 if (x > constants[i])
1370                         break;
1371         }
1372
1373         switch (zd_rate) {
1374         case ZD_OFDM_RATE_6M:
1375         case ZD_OFDM_RATE_9M:
1376                 i += 3;
1377                 break;
1378         case ZD_OFDM_RATE_12M:
1379         case ZD_OFDM_RATE_18M:
1380                 i += 5;
1381                 break;
1382         case ZD_OFDM_RATE_24M:
1383         case ZD_OFDM_RATE_36M:
1384                 i += 9;
1385                 break;
1386         case ZD_OFDM_RATE_48M:
1387         case ZD_OFDM_RATE_54M:
1388                 i += 15;
1389                 break;
1390         default:
1391                 return -EINVAL;
1392         }
1393
1394         return i;
1395 }
1396
1397 static int ofdm_qual_percent(u8 status_quality, u8 zd_rate, unsigned int size)
1398 {
1399         int r;
1400
1401         r = ofdm_qual_db(status_quality, zd_rate, size);
1402         ZD_ASSERT(r >= 0);
1403         if (r < 0)
1404                 r = 0;
1405
1406         r = (r * 100)/29;
1407         return r <= 100 ? r : 100;
1408 }
1409
1410 static unsigned int log10times100(unsigned int x)
1411 {
1412         static const u8 log10[] = {
1413                   0,
1414                   0,   30,   47,   60,   69,   77,   84,   90,   95,  100,
1415                 104,  107,  111,  114,  117,  120,  123,  125,  127,  130,
1416                 132,  134,  136,  138,  139,  141,  143,  144,  146,  147,
1417                 149,  150,  151,  153,  154,  155,  156,  157,  159,  160,
1418                 161,  162,  163,  164,  165,  166,  167,  168,  169,  169,
1419                 170,  171,  172,  173,  174,  174,  175,  176,  177,  177,
1420                 178,  179,  179,  180,  181,  181,  182,  183,  183,  184,
1421                 185,  185,  186,  186,  187,  188,  188,  189,  189,  190,
1422                 190,  191,  191,  192,  192,  193,  193,  194,  194,  195,
1423                 195,  196,  196,  197,  197,  198,  198,  199,  199,  200,
1424                 200,  200,  201,  201,  202,  202,  202,  203,  203,  204,
1425                 204,  204,  205,  205,  206,  206,  206,  207,  207,  207,
1426                 208,  208,  208,  209,  209,  210,  210,  210,  211,  211,
1427                 211,  212,  212,  212,  213,  213,  213,  213,  214,  214,
1428                 214,  215,  215,  215,  216,  216,  216,  217,  217,  217,
1429                 217,  218,  218,  218,  219,  219,  219,  219,  220,  220,
1430                 220,  220,  221,  221,  221,  222,  222,  222,  222,  223,
1431                 223,  223,  223,  224,  224,  224,  224,
1432         };
1433
1434         return x < ARRAY_SIZE(log10) ? log10[x] : 225;
1435 }
1436
1437 enum {
1438         MAX_CCK_EVM_DB = 45,
1439 };
1440
1441 static int cck_evm_db(u8 status_quality)
1442 {
1443         return (20 * log10times100(status_quality)) / 100;
1444 }
1445
1446 static int cck_snr_db(u8 status_quality)
1447 {
1448         int r = MAX_CCK_EVM_DB - cck_evm_db(status_quality);
1449         ZD_ASSERT(r >= 0);
1450         return r;
1451 }
1452
1453 static int cck_qual_percent(u8 status_quality)
1454 {
1455         int r;
1456
1457         r = cck_snr_db(status_quality);
1458         r = (100*r)/17;
1459         return r <= 100 ? r : 100;
1460 }
1461
1462 static inline u8 zd_rate_from_ofdm_plcp_header(const void *rx_frame)
1463 {
1464         return ZD_OFDM | zd_ofdm_plcp_header_rate(rx_frame);
1465 }
1466
1467 u8 zd_rx_qual_percent(const void *rx_frame, unsigned int size,
1468                       const struct rx_status *status)
1469 {
1470         return (status->frame_status&ZD_RX_OFDM) ?
1471                 ofdm_qual_percent(status->signal_quality_ofdm,
1472                                   zd_rate_from_ofdm_plcp_header(rx_frame),
1473                                   size) :
1474                 cck_qual_percent(status->signal_quality_cck);
1475 }
1476
1477 /**
1478  * zd_rx_rate - report zd-rate
1479  * @rx_frame - received frame
1480  * @rx_status - rx_status as given by the device
1481  *
1482  * This function converts the rate as encoded in the received packet to the
1483  * zd-rate, we are using on other places in the driver.
1484  */
1485 u8 zd_rx_rate(const void *rx_frame, const struct rx_status *status)
1486 {
1487         u8 zd_rate;
1488         if (status->frame_status & ZD_RX_OFDM) {
1489                 zd_rate = zd_rate_from_ofdm_plcp_header(rx_frame);
1490         } else {
1491                 switch (zd_cck_plcp_header_signal(rx_frame)) {
1492                 case ZD_CCK_PLCP_SIGNAL_1M:
1493                         zd_rate = ZD_CCK_RATE_1M;
1494                         break;
1495                 case ZD_CCK_PLCP_SIGNAL_2M:
1496                         zd_rate = ZD_CCK_RATE_2M;
1497                         break;
1498                 case ZD_CCK_PLCP_SIGNAL_5M5:
1499                         zd_rate = ZD_CCK_RATE_5_5M;
1500                         break;
1501                 case ZD_CCK_PLCP_SIGNAL_11M:
1502                         zd_rate = ZD_CCK_RATE_11M;
1503                         break;
1504                 default:
1505                         zd_rate = 0;
1506                 }
1507         }
1508
1509         return zd_rate;
1510 }
1511
1512 int zd_chip_switch_radio_on(struct zd_chip *chip)
1513 {
1514         int r;
1515
1516         mutex_lock(&chip->mutex);
1517         r = zd_switch_radio_on(&chip->rf);
1518         mutex_unlock(&chip->mutex);
1519         return r;
1520 }
1521
1522 int zd_chip_switch_radio_off(struct zd_chip *chip)
1523 {
1524         int r;
1525
1526         mutex_lock(&chip->mutex);
1527         r = zd_switch_radio_off(&chip->rf);
1528         mutex_unlock(&chip->mutex);
1529         return r;
1530 }
1531
1532 int zd_chip_enable_int(struct zd_chip *chip)
1533 {
1534         int r;
1535
1536         mutex_lock(&chip->mutex);
1537         r = zd_usb_enable_int(&chip->usb);
1538         mutex_unlock(&chip->mutex);
1539         return r;
1540 }
1541
1542 void zd_chip_disable_int(struct zd_chip *chip)
1543 {
1544         mutex_lock(&chip->mutex);
1545         zd_usb_disable_int(&chip->usb);
1546         mutex_unlock(&chip->mutex);
1547 }
1548
1549 int zd_chip_enable_rxtx(struct zd_chip *chip)
1550 {
1551         int r;
1552
1553         mutex_lock(&chip->mutex);
1554         zd_usb_enable_tx(&chip->usb);
1555         r = zd_usb_enable_rx(&chip->usb);
1556         mutex_unlock(&chip->mutex);
1557         return r;
1558 }
1559
1560 void zd_chip_disable_rxtx(struct zd_chip *chip)
1561 {
1562         mutex_lock(&chip->mutex);
1563         zd_usb_disable_rx(&chip->usb);
1564         zd_usb_disable_tx(&chip->usb);
1565         mutex_unlock(&chip->mutex);
1566 }
1567
1568 int zd_rfwritev_locked(struct zd_chip *chip,
1569                        const u32* values, unsigned int count, u8 bits)
1570 {
1571         int r;
1572         unsigned int i;
1573
1574         for (i = 0; i < count; i++) {
1575                 r = zd_rfwrite_locked(chip, values[i], bits);
1576                 if (r)
1577                         return r;
1578         }
1579
1580         return 0;
1581 }
1582
1583 /*
1584  * We can optionally program the RF directly through CR regs, if supported by
1585  * the hardware. This is much faster than the older method.
1586  */
1587 int zd_rfwrite_cr_locked(struct zd_chip *chip, u32 value)
1588 {
1589         struct zd_ioreq16 ioreqs[] = {
1590                 { CR244, (value >> 16) & 0xff },
1591                 { CR243, (value >>  8) & 0xff },
1592                 { CR242,  value        & 0xff },
1593         };
1594         ZD_ASSERT(mutex_is_locked(&chip->mutex));
1595         return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
1596 }
1597
1598 int zd_rfwritev_cr_locked(struct zd_chip *chip,
1599                           const u32 *values, unsigned int count)
1600 {
1601         int r;
1602         unsigned int i;
1603
1604         for (i = 0; i < count; i++) {
1605                 r = zd_rfwrite_cr_locked(chip, values[i]);
1606                 if (r)
1607                         return r;
1608         }
1609
1610         return 0;
1611 }
1612
1613 int zd_chip_set_multicast_hash(struct zd_chip *chip,
1614                                struct zd_mc_hash *hash)
1615 {
1616         struct zd_ioreq32 ioreqs[] = {
1617                 { CR_GROUP_HASH_P1, hash->low },
1618                 { CR_GROUP_HASH_P2, hash->high },
1619         };
1620
1621         return zd_iowrite32a(chip, ioreqs, ARRAY_SIZE(ioreqs));
1622 }