sys/dev/netif/rtw/rtwphy.c

   1 /*
   2  * Copyright (c) 2004, 2005 David Young.  All rights reserved.
   3  *
   4  * Programmed for NetBSD by David Young.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. The name of David Young may not be used to endorse or promote
  15  *    products derived from this software without specific prior
  16  *    written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY David Young ``AS IS'' AND ANY
  19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  20  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  21  * PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL David
  22  * Young BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  23  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  24  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  26  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  27  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  29  * OF SUCH DAMAGE.
  30  *
  31  * $NetBSD: rtwphy.c,v 1.9 2006/03/08 00:24:06 dyoung Exp $
  32  * $DragonFly: src/sys/dev/netif/rtw/rtwphy.c,v 1.3 2006/10/25 20:55:58 dillon Exp $
  33  */
  34
  35 /*
  36  * Control the Philips SA2400 RF front-end and the baseband processor
  37  * built into the Realtek RTL8180.
  38  */
  39
  40 #include <sys/param.h>
  41 #include <sys/bus.h>
  42 #include <sys/socket.h>
  43
  44 #include <net/if.h>
  45 #include <net/if_arp.h>
  46 #include <net/if_media.h>
  47
  48 #include <netproto/802_11/ieee80211_var.h>
  49 #include <netproto/802_11/ieee80211_radiotap.h>
  50
  51 #include "rtwbitop.h"
  52 #include "rtwreg.h"
  53 #include "max2820reg.h"
  54 #include "sa2400reg.h"
  55 #include "rtwvar.h"
  56 #include "rtwphyio.h"
  57 #include "rtwphy.h"
  58
  59 static int      rtw_max2820_pwrstate(struct rtw_rf *, enum rtw_pwrstate);
  60 static int      rtw_sa2400_pwrstate(struct rtw_rf *, enum rtw_pwrstate);
  61
  62 #define GCT_WRITE(__gr, __addr, __val, __label)                 \
  63 do {                                                            \
  64         if (rtw_rfbus_write(&(__gr)->gr_bus, RTW_RFCHIPID_GCT,  \
  65             (__addr), (__val)) == -1)                           \
  66                 goto __label;                                   \
  67 } while(0)
  68
  69 static int
  70 rtw_bbp_preinit(struct rtw_regs *regs, u_int antatten0, int dflantb, u_int freq)
  71 {
  72         u_int antatten = antatten0;
  73
  74         if (dflantb)
  75                 antatten |= RTW_BBP_ANTATTEN_DFLANTB;
  76         if (freq == 2484) /* channel 14 */
  77                 antatten |= RTW_BBP_ANTATTEN_CHAN14;
  78         return rtw_bbp_write(regs, RTW_BBP_ANTATTEN, antatten);
  79 }
  80
  81 static int
  82 rtw_bbp_init(struct rtw_regs *regs, struct rtw_bbpset *bb, int antdiv,
  83              int dflantb, uint8_t cs_threshold, u_int freq)
  84 {
  85         int rc;
  86         uint32_t sys2, sys3;
  87
  88         sys2 = bb->bb_sys2;
  89         if (antdiv)
  90                 sys2 |= RTW_BBP_SYS2_ANTDIV;
  91         sys3 = bb->bb_sys3 | SHIFTIN(cs_threshold, RTW_BBP_SYS3_CSTHRESH_MASK);
  92
  93 #define RTW_BBP_WRITE_OR_RETURN(reg, val) \
  94         if ((rc = rtw_bbp_write(regs, reg, val)) != 0) \
  95                 return rc;
  96
  97         RTW_BBP_WRITE_OR_RETURN(RTW_BBP_SYS1,           bb->bb_sys1);
  98         RTW_BBP_WRITE_OR_RETURN(RTW_BBP_TXAGC,          bb->bb_txagc);
  99         RTW_BBP_WRITE_OR_RETURN(RTW_BBP_LNADET,         bb->bb_lnadet);
 100         RTW_BBP_WRITE_OR_RETURN(RTW_BBP_IFAGCINI,       bb->bb_ifagcini);
 101         RTW_BBP_WRITE_OR_RETURN(RTW_BBP_IFAGCLIMIT,     bb->bb_ifagclimit);
 102         RTW_BBP_WRITE_OR_RETURN(RTW_BBP_IFAGCDET,       bb->bb_ifagcdet);
 103
 104         if ((rc = rtw_bbp_preinit(regs, bb->bb_antatten, dflantb, freq)) != 0)
 105                 return rc;
 106
 107         RTW_BBP_WRITE_OR_RETURN(RTW_BBP_TRL,            bb->bb_trl);
 108         RTW_BBP_WRITE_OR_RETURN(RTW_BBP_SYS2,           sys2);
 109         RTW_BBP_WRITE_OR_RETURN(RTW_BBP_SYS3,           sys3);
 110         RTW_BBP_WRITE_OR_RETURN(RTW_BBP_CHESTLIM,       bb->bb_chestlim);
 111         RTW_BBP_WRITE_OR_RETURN(RTW_BBP_CHSQLIM,        bb->bb_chsqlim);
 112         return 0;
 113 }
 114
 115 static int
 116 rtw_sa2400_txpower(struct rtw_rf *rf, uint8_t opaque_txpower)
 117 {
 118         struct rtw_sa2400 *sa = (struct rtw_sa2400 *)rf;
 119         struct rtw_rfbus *bus = &sa->sa_bus;
 120
 121         return rtw_rfbus_write(bus, RTW_RFCHIPID_PHILIPS, SA2400_TX,
 122                                opaque_txpower);
 123 }
 124
 125 /* make sure we're using the same settings as the reference driver */
 126 static void
 127 verify_syna(u_int freq, uint32_t val)
 128 {
 129         uint32_t expected_val = ~val;
 130
 131         switch (freq) {
 132         case 2412:
 133                 expected_val = 0x0000096c; /* ch 1 */
 134                 break;
 135         case 2417:
 136                 expected_val = 0x00080970; /* ch 2 */
 137                 break;
 138         case 2422:
 139                 expected_val = 0x00100974; /* ch 3 */
 140                 break;
 141         case 2427:
 142                 expected_val = 0x00180978; /* ch 4 */
 143                 break;
 144         case 2432:
 145                 expected_val = 0x00000980; /* ch 5 */
 146                 break;
 147         case 2437:
 148                 expected_val = 0x00080984; /* ch 6 */
 149                 break;
 150         case 2442:
 151                 expected_val = 0x00100988; /* ch 7 */
 152                 break;
 153         case 2447:
 154                 expected_val = 0x0018098c; /* ch 8 */
 155                 break;
 156         case 2452:
 157                 expected_val = 0x00000994; /* ch 9 */
 158                 break;
 159         case 2457:
 160                 expected_val = 0x00080998; /* ch 10 */
 161                 break;
 162         case 2462:
 163                 expected_val = 0x0010099c; /* ch 11 */
 164                 break;
 165         case 2467:
 166                 expected_val = 0x001809a0; /* ch 12 */
 167                 break;
 168         case 2472:
 169                 expected_val = 0x000009a8; /* ch 13 */
 170                 break;
 171         case 2484:
 172                 expected_val = 0x000009b4; /* ch 14 */
 173                 break;
 174         }
 175         KKASSERT(val == expected_val);
 176 }
 177
 178 /* freq is in MHz */
 179 static int
 180 rtw_sa2400_tune(struct rtw_rf *rf, u_int freq)
 181 {
 182         struct rtw_sa2400 *sa = (struct rtw_sa2400 *)rf;
 183         struct rtw_rfbus *bus = &sa->sa_bus;
 184         int rc;
 185         uint32_t syna, synb, sync;
 186         int n, nf;
 187
 188         /*
 189          * XO = 44MHz, R = 11, hence N is in units of XO / R = 4MHz.
 190          *
 191          * The channel spacing (5MHz) is not divisible by 4MHz, so
 192          * we set the fractional part of N to compensate.
 193          */
 194         n = freq / 4;
 195         nf = (freq % 4) * 2;
 196
 197         syna = SHIFTIN(nf, SA2400_SYNA_NF_MASK) |
 198                SHIFTIN(n, SA2400_SYNA_N_MASK);
 199         verify_syna(freq, syna);
 200
 201         /*
 202          * Divide the 44MHz crystal down to 4MHz. Set the fractional
 203          * compensation charge pump value to agree with the fractional
 204          * modulus.
 205          */
 206         synb = SHIFTIN(11, SA2400_SYNB_R_MASK) | SA2400_SYNB_L_NORMAL |
 207                SA2400_SYNB_ON | SA2400_SYNB_ONE |
 208                SHIFTIN(80, SA2400_SYNB_FC_MASK); /* agrees w/ SA2400_SYNA_FM = 0 */
 209
 210         sync = SA2400_SYNC_CP_NORMAL;
 211
 212         rc = rtw_rfbus_write(bus, RTW_RFCHIPID_PHILIPS, SA2400_SYNA, syna);
 213         if (rc != 0)
 214                 return rc;
 215
 216         rc = rtw_rfbus_write(bus, RTW_RFCHIPID_PHILIPS, SA2400_SYNB, synb);
 217         if (rc != 0)
 218                 return rc;
 219
 220         rc = rtw_rfbus_write(bus, RTW_RFCHIPID_PHILIPS, SA2400_SYNC, sync);
 221         if (rc != 0)
 222                 return rc;
 223
 224         return rtw_rfbus_write(bus, RTW_RFCHIPID_PHILIPS, SA2400_SYND, 0x0);
 225 }
 226
 227 static int
 228 rtw_sa2400_pwrstate(struct rtw_rf *rf, enum rtw_pwrstate power)
 229 {
 230         struct rtw_sa2400 *sa = (struct rtw_sa2400 *)rf;
 231         struct rtw_rfbus *bus = &sa->sa_bus;
 232         uint32_t opmode;
 233
 234         opmode = SA2400_OPMODE_DEFAULTS;
 235         switch (power) {
 236         case RTW_ON:
 237                 opmode |= SA2400_OPMODE_MODE_TXRX;
 238                 break;
 239         case RTW_SLEEP:
 240                 opmode |= SA2400_OPMODE_MODE_WAIT;
 241                 break;
 242         case RTW_OFF:
 243                 opmode |= SA2400_OPMODE_MODE_SLEEP;
 244                 break;
 245         }
 246
 247         if (sa->sa_digphy)
 248                 opmode |= SA2400_OPMODE_DIGIN;
 249
 250         return rtw_rfbus_write(bus, RTW_RFCHIPID_PHILIPS, SA2400_OPMODE,
 251                                opmode);
 252 }
 253
 254 static int
 255 rtw_sa2400_manrx_init(struct rtw_sa2400 *sa)
 256 {
 257         uint32_t manrx;
 258
 259         /*
 260          * XXX we are not supposed to be in RXMGC mode when we do this?
 261          */
 262         manrx = SA2400_MANRX_AHSN;
 263         manrx |= SA2400_MANRX_TEN;
 264         manrx |= SHIFTIN(1023, SA2400_MANRX_RXGAIN_MASK);
 265
 266         return rtw_rfbus_write(&sa->sa_bus, RTW_RFCHIPID_PHILIPS, SA2400_MANRX,
 267                                manrx);
 268 }
 269
 270 static int
 271 rtw_sa2400_vcocal_start(struct rtw_sa2400 *sa, int start)
 272 {
 273         uint32_t opmode;
 274
 275         opmode = SA2400_OPMODE_DEFAULTS;
 276         if (start)
 277                 opmode |= SA2400_OPMODE_MODE_VCOCALIB;
 278         else
 279                 opmode |= SA2400_OPMODE_MODE_SLEEP;
 280
 281         if (sa->sa_digphy)
 282                 opmode |= SA2400_OPMODE_DIGIN;
 283
 284         return rtw_rfbus_write(&sa->sa_bus, RTW_RFCHIPID_PHILIPS, SA2400_OPMODE,
 285                                opmode);
 286 }
 287
 288 static int
 289 rtw_sa2400_vco_calibration(struct rtw_sa2400 *sa)
 290 {
 291         int rc;
 292
 293         /* calibrate VCO */
 294         if ((rc = rtw_sa2400_vcocal_start(sa, 1)) != 0)
 295                 return rc;
 296         DELAY(2200);    /* 2.2 milliseconds */
 297         /* XXX superfluous: SA2400 automatically entered SLEEP mode. */
 298         return rtw_sa2400_vcocal_start(sa, 0);
 299 }
 300
 301 static int
 302 rtw_sa2400_filter_calibration(struct rtw_sa2400 *sa)
 303 {
 304         uint32_t opmode;
 305
 306         opmode = SA2400_OPMODE_DEFAULTS | SA2400_OPMODE_MODE_FCALIB;
 307         if (sa->sa_digphy)
 308                 opmode |= SA2400_OPMODE_DIGIN;
 309
 310         return rtw_rfbus_write(&sa->sa_bus, RTW_RFCHIPID_PHILIPS, SA2400_OPMODE,
 311                                opmode);
 312 }
 313
 314 static int
 315 rtw_sa2400_dc_calibration(struct rtw_sa2400 *sa)
 316 {
 317         struct rtw_rf *rf = &sa->sa_rf;
 318         int rc;
 319         uint32_t dccal;
 320
 321         rf->rf_continuous_tx_cb(rf->rf_continuous_tx_arg, 1);
 322
 323         dccal = SA2400_OPMODE_DEFAULTS | SA2400_OPMODE_MODE_TXRX;
 324
 325         rc = rtw_rfbus_write(&sa->sa_bus, RTW_RFCHIPID_PHILIPS, SA2400_OPMODE,
 326                              dccal);
 327         if (rc != 0)
 328                 return rc;
 329
 330         /*
 331          * DCALIB after being in Tx mode for 5 microseconds
 332          */
 333         DELAY(5);
 334
 335         dccal &= ~SA2400_OPMODE_MODE_MASK;
 336         dccal |= SA2400_OPMODE_MODE_DCALIB;
 337
 338         rc = rtw_rfbus_write(&sa->sa_bus, RTW_RFCHIPID_PHILIPS, SA2400_OPMODE,
 339                              dccal);
 340         if (rc != 0)
 341                 return rc;
 342
 343         DELAY(20);      /* calibration takes at most 20 microseconds */
 344
 345         rf->rf_continuous_tx_cb(rf->rf_continuous_tx_arg, 0);
 346         return 0;
 347 }
 348
 349 static int
 350 rtw_sa2400_agc_init(struct rtw_sa2400 *sa)
 351 {
 352         uint32_t agc;
 353
 354         agc = SHIFTIN(25, SA2400_AGC_MAXGAIN_MASK);
 355         agc |= SHIFTIN(7, SA2400_AGC_BBPDELAY_MASK);
 356         agc |= SHIFTIN(15, SA2400_AGC_LNADELAY_MASK);
 357         agc |= SHIFTIN(27, SA2400_AGC_RXONDELAY_MASK);
 358
 359         return rtw_rfbus_write(&sa->sa_bus, RTW_RFCHIPID_PHILIPS, SA2400_AGC,
 360                                agc);
 361 }
 362
 363 static void
 364 rtw_sa2400_destroy(struct rtw_rf *rf)
 365 {
 366         struct rtw_sa2400 *sa = (struct rtw_sa2400 *)rf;
 367
 368         memset(sa, 0, sizeof(*sa));
 369         kfree(sa, M_DEVBUF);
 370 }
 371
 372 static int
 373 rtw_sa2400_calibrate(struct rtw_rf *rf, u_int freq)
 374 {
 375         struct rtw_sa2400 *sa = (struct rtw_sa2400 *)rf;
 376         int i, rc;
 377
 378         /* XXX reference driver calibrates VCO twice. Is it a bug? */
 379         for (i = 0; i < 2; i++) {
 380                 if ((rc = rtw_sa2400_vco_calibration(sa)) != 0)
 381                         return rc;
 382         }
 383         /* VCO calibration erases synthesizer registers, so re-tune */
 384         if ((rc = rtw_sa2400_tune(rf, freq)) != 0)
 385                 return rc;
 386         if ((rc = rtw_sa2400_filter_calibration(sa)) != 0)
 387                 return rc;
 388         /* analog PHY needs DC calibration */
 389         if (!sa->sa_digphy)
 390                 return rtw_sa2400_dc_calibration(sa);
 391         return 0;
 392 }
 393
 394 static int
 395 rtw_sa2400_init(struct rtw_rf *rf, u_int freq, uint8_t opaque_txpower,
 396                 enum rtw_pwrstate power)
 397 {
 398         struct rtw_sa2400 *sa = (struct rtw_sa2400 *)rf;
 399         int rc;
 400
 401         if ((rc = rtw_sa2400_txpower(rf, opaque_txpower)) != 0)
 402                 return rc;
 403
 404         /* skip configuration if it's time to sleep or to power-down. */
 405         if (power == RTW_SLEEP || power == RTW_OFF)
 406                 return rtw_sa2400_pwrstate(rf, power);
 407
 408         /* go to sleep for configuration */
 409         if ((rc = rtw_sa2400_pwrstate(rf, RTW_SLEEP)) != 0)
 410                 return rc;
 411
 412         if ((rc = rtw_sa2400_tune(rf, freq)) != 0)
 413                 return rc;
 414         if ((rc = rtw_sa2400_agc_init(sa)) != 0)
 415                 return rc;
 416         if ((rc = rtw_sa2400_manrx_init(sa)) != 0)
 417                 return rc;
 418         if ((rc = rtw_sa2400_calibrate(rf, freq)) != 0)
 419                 return rc;
 420
 421         /* enter Tx/Rx mode */
 422         return rtw_sa2400_pwrstate(rf, power);
 423 }
 424
 425 struct rtw_rf *
 426 rtw_sa2400_create(struct rtw_regs *regs, rtw_rf_write_t rf_write, int digphy)
 427 {
 428         struct rtw_sa2400 *sa;
 429         struct rtw_rfbus *bus;
 430         struct rtw_rf *rf;
 431         struct rtw_bbpset *bb;
 432
 433         sa = kmalloc(sizeof(*sa), M_DEVBUF, M_WAITOK | M_ZERO);
 434
 435         sa->sa_digphy = digphy;
 436
 437         rf = &sa->sa_rf;
 438         bus = &sa->sa_bus;
 439
 440         rf->rf_init = rtw_sa2400_init;
 441         rf->rf_destroy = rtw_sa2400_destroy;
 442         rf->rf_txpower = rtw_sa2400_txpower;
 443         rf->rf_tune = rtw_sa2400_tune;
 444         rf->rf_pwrstate = rtw_sa2400_pwrstate;
 445         bb = &rf->rf_bbpset;
 446
 447         /* XXX magic */
 448         bb->bb_antatten = RTW_BBP_ANTATTEN_PHILIPS_MAGIC;
 449         bb->bb_chestlim =       0x00;
 450         bb->bb_chsqlim =        0xa0;
 451         bb->bb_ifagcdet =       0x64;
 452         bb->bb_ifagcini =       0x90;
 453         bb->bb_ifagclimit =     0x1a;
 454         bb->bb_lnadet =         0xe0;
 455         bb->bb_sys1 =           0x98;
 456         bb->bb_sys2 =           0x47;
 457         bb->bb_sys3 =           0x90;
 458         bb->bb_trl =            0x88;
 459         bb->bb_txagc =          0x38;
 460
 461         bus->b_regs = regs;
 462         bus->b_write = rf_write;
 463
 464         return &sa->sa_rf;
 465 }
 466
 467 static int
 468 rtw_grf5101_txpower(struct rtw_rf *rf, uint8_t opaque_txpower)
 469 {
 470         struct rtw_grf5101 *gr = (struct rtw_grf5101 *)rf;
 471
 472         GCT_WRITE(gr, 0x15, 0, err);
 473         GCT_WRITE(gr, 0x06, opaque_txpower, err);
 474         GCT_WRITE(gr, 0x15, 0x10, err);
 475         GCT_WRITE(gr, 0x15, 0x00, err);
 476         return 0;
 477 err:
 478         return -1;
 479 }
 480
 481 static int
 482 rtw_grf5101_pwrstate(struct rtw_rf *rf, enum rtw_pwrstate power)
 483 {
 484         struct rtw_grf5101 *gr = (struct rtw_grf5101 *)rf;
 485
 486         switch (power) {
 487         case RTW_OFF:
 488         case RTW_SLEEP:
 489                 GCT_WRITE(gr, 0x07, 0x0000, err);
 490                 GCT_WRITE(gr, 0x1f, 0x0045, err);
 491                 GCT_WRITE(gr, 0x1f, 0x0005, err);
 492                 GCT_WRITE(gr, 0x00, 0x08e4, err);
 493         default:
 494                 break;
 495         case RTW_ON:
 496                 GCT_WRITE(gr, 0x1f, 0x0001, err);
 497                 DELAY(10);
 498                 GCT_WRITE(gr, 0x1f, 0x0001, err);
 499                 DELAY(10);
 500                 GCT_WRITE(gr, 0x1f, 0x0041, err);
 501                 DELAY(10);
 502                 GCT_WRITE(gr, 0x1f, 0x0061, err);
 503                 DELAY(10);
 504                 GCT_WRITE(gr, 0x00, 0x0ae4, err);
 505                 DELAY(10);
 506                 GCT_WRITE(gr, 0x07, 0x1000, err);
 507                 DELAY(100);
 508                 break;
 509         }
 510
 511         return 0;
 512 err:
 513         return -1;
 514 }
 515
 516 static int
 517 rtw_grf5101_tune(struct rtw_rf *rf, u_int freq)
 518 {
 519         int channel;
 520         struct rtw_grf5101 *gr = (struct rtw_grf5101 *)rf;
 521
 522         if (freq == 2484) {
 523                 channel = 14;
 524         } else if ((channel = (freq - 2412) / 5 + 1) < 1 || channel > 13) {
 525                 RTW_DPRINTF(RTW_DEBUG_PHY,
 526                     ("%s: invalid channel %d (freq %d)\n", __func__, channel,
 527                      freq));
 528                 return -1;
 529         }
 530
 531         GCT_WRITE(gr, 0x07, 0, err);
 532         GCT_WRITE(gr, 0x0b, channel - 1, err);
 533         GCT_WRITE(gr, 0x07, 0x1000, err);
 534         return 0;
 535 err:
 536         return -1;
 537 }
 538
 539 static int
 540 rtw_grf5101_init(struct rtw_rf *rf, u_int freq, uint8_t opaque_txpower,
 541                  enum rtw_pwrstate power)
 542 {
 543         int rc;
 544         struct rtw_grf5101 *gr = (struct rtw_grf5101 *)rf;
 545
 546         /*
 547          * These values have been derived from the rtl8180-sa2400
 548          * Linux driver.  It is unknown what they all do, GCT refuse
 549          * to release any documentation so these are more than
 550          * likely sub optimal settings
 551          */
 552
 553         GCT_WRITE(gr, 0x01, 0x1a23, err);
 554         GCT_WRITE(gr, 0x02, 0x4971, err);
 555         GCT_WRITE(gr, 0x03, 0x41de, err);
 556         GCT_WRITE(gr, 0x04, 0x2d80, err);
 557
 558         GCT_WRITE(gr, 0x05, 0x61ff, err);
 559
 560         GCT_WRITE(gr, 0x06, 0x0, err);
 561
 562         GCT_WRITE(gr, 0x08, 0x7533, err);
 563         GCT_WRITE(gr, 0x09, 0xc401, err);
 564         GCT_WRITE(gr, 0x0a, 0x0, err);
 565         GCT_WRITE(gr, 0x0c, 0x1c7, err);
 566         GCT_WRITE(gr, 0x0d, 0x29d3, err);
 567         GCT_WRITE(gr, 0x0e, 0x2e8, err);
 568         GCT_WRITE(gr, 0x10, 0x192, err);
 569         GCT_WRITE(gr, 0x11, 0x248, err);
 570         GCT_WRITE(gr, 0x12, 0x0, err);
 571         GCT_WRITE(gr, 0x13, 0x20c4, err);
 572         GCT_WRITE(gr, 0x14, 0xf4fc, err);
 573         GCT_WRITE(gr, 0x15, 0x0, err);
 574         GCT_WRITE(gr, 0x16, 0x1500, err);
 575
 576         if ((rc = rtw_grf5101_txpower(rf, opaque_txpower)) != 0)
 577                 return rc;
 578
 579         if ((rc = rtw_grf5101_tune(rf, freq)) != 0)
 580                 return rc;
 581
 582         return 0;
 583 err:
 584         return -1;
 585 }
 586
 587 static void
 588 rtw_grf5101_destroy(struct rtw_rf *rf)
 589 {
 590         struct rtw_grf5101 *gr = (struct rtw_grf5101 *)rf;
 591
 592         memset(gr, 0, sizeof(*gr));
 593         kfree(gr, M_DEVBUF);
 594 }
 595
 596 struct rtw_rf *
 597 rtw_grf5101_create(struct rtw_regs *regs, rtw_rf_write_t rf_write, int digphy)
 598 {
 599         struct rtw_grf5101 *gr;
 600         struct rtw_rfbus *bus;
 601         struct rtw_rf *rf;
 602         struct rtw_bbpset *bb;
 603
 604         gr = kmalloc(sizeof(*gr), M_DEVBUF, M_WAITOK | M_ZERO);
 605
 606         rf = &gr->gr_rf;
 607         bus = &gr->gr_bus;
 608
 609         rf->rf_init = rtw_grf5101_init;
 610         rf->rf_destroy = rtw_grf5101_destroy;
 611         rf->rf_txpower = rtw_grf5101_txpower;
 612         rf->rf_tune = rtw_grf5101_tune;
 613         rf->rf_pwrstate = rtw_grf5101_pwrstate;
 614         bb = &rf->rf_bbpset;
 615
 616         /* XXX magic */
 617         bb->bb_antatten = RTW_BBP_ANTATTEN_GCT_MAGIC;
 618         bb->bb_chestlim =       0x00;
 619         bb->bb_chsqlim =        0xa0;
 620         bb->bb_ifagcdet =       0x64;
 621         bb->bb_ifagcini =       0x90;
 622         bb->bb_ifagclimit =     0x1e;
 623         bb->bb_lnadet =         0xc0;
 624         bb->bb_sys1 =           0xa8;
 625         bb->bb_sys2 =           0x47;
 626         bb->bb_sys3 =           0x9b;
 627         bb->bb_trl =            0x88;
 628         bb->bb_txagc =          0x08;
 629
 630         bus->b_regs = regs;
 631         bus->b_write = rf_write;
 632
 633         return &gr->gr_rf;
 634 }
 635
 636 /* freq is in MHz */
 637 static int
 638 rtw_max2820_tune(struct rtw_rf *rf, u_int freq)
 639 {
 640         struct rtw_max2820 *mx = (struct rtw_max2820 *)rf;
 641         struct rtw_rfbus *bus = &mx->mx_bus;
 642
 643         if (freq < 2400 || freq > 2499)
 644                 return -1;
 645
 646         return rtw_rfbus_write(bus, RTW_RFCHIPID_MAXIM, MAX2820_CHANNEL,
 647                                SHIFTIN(freq - 2400, MAX2820_CHANNEL_CF_MASK));
 648 }
 649
 650 static void
 651 rtw_max2820_destroy(struct rtw_rf *rf)
 652 {
 653         struct rtw_max2820 *mx = (struct rtw_max2820 *)rf;
 654
 655         memset(mx, 0, sizeof(*mx));
 656         kfree(mx, M_DEVBUF);
 657 }
 658
 659 static int
 660 rtw_max2820_init(struct rtw_rf *rf, u_int freq, uint8_t opaque_txpower,
 661                  enum rtw_pwrstate power)
 662 {
 663         struct rtw_max2820 *mx = (struct rtw_max2820 *)rf;
 664         struct rtw_rfbus *bus = &mx->mx_bus;
 665         int rc;
 666
 667         rc = rtw_rfbus_write(bus, RTW_RFCHIPID_MAXIM, MAX2820_TEST,
 668                              MAX2820_TEST_DEFAULT);
 669         if (rc != 0)
 670                 return rc;
 671
 672         rc = rtw_rfbus_write(bus, RTW_RFCHIPID_MAXIM, MAX2820_ENABLE,
 673                              MAX2820_ENABLE_DEFAULT);
 674         if (rc != 0)
 675                 return rc;
 676
 677         /* skip configuration if it's time to sleep or to power-down. */
 678         if ((rc = rtw_max2820_pwrstate(rf, power)) != 0)
 679                 return rc;
 680         else if (power == RTW_OFF || power == RTW_SLEEP)
 681                 return 0;
 682
 683         rc = rtw_rfbus_write(bus, RTW_RFCHIPID_MAXIM, MAX2820_SYNTH,
 684                              MAX2820_SYNTH_R_44MHZ);
 685         if (rc != 0)
 686                 return rc;
 687
 688         if ((rc = rtw_max2820_tune(rf, freq)) != 0)
 689                 return rc;
 690
 691         /*
 692          * XXX The MAX2820 datasheet indicates that 1C and 2C should not
 693          * be changed from 7, however, the reference driver sets them
 694          * to 4 and 1, respectively.
 695          */
 696         rc = rtw_rfbus_write(bus, RTW_RFCHIPID_MAXIM, MAX2820_RECEIVE,
 697                              MAX2820_RECEIVE_DL_DEFAULT |
 698                              SHIFTIN(4, MAX2820A_RECEIVE_1C_MASK) |
 699                              SHIFTIN(1, MAX2820A_RECEIVE_2C_MASK));
 700         if (rc != 0)
 701                 return rc;
 702
 703         return rtw_rfbus_write(bus, RTW_RFCHIPID_MAXIM, MAX2820_TRANSMIT,
 704                                MAX2820_TRANSMIT_PA_DEFAULT);
 705 }
 706
 707 static int
 708 rtw_max2820_txpower(struct rtw_rf *rf, uint8_t opaque_txpower)
 709 {
 710         /* TBD */
 711         return 0;
 712 }
 713
 714 static int
 715 rtw_max2820_pwrstate(struct rtw_rf *rf, enum rtw_pwrstate power)
 716 {
 717         uint32_t enable;
 718         struct rtw_max2820 *mx;
 719         struct rtw_rfbus *bus;
 720
 721         mx = (struct rtw_max2820 *)rf;
 722         bus = &mx->mx_bus;
 723
 724         switch (power) {
 725         case RTW_OFF:
 726         case RTW_SLEEP:
 727         default:
 728                 enable = 0x0;
 729                 break;
 730         case RTW_ON:
 731                 enable = MAX2820_ENABLE_DEFAULT;
 732                 break;
 733         }
 734         return rtw_rfbus_write(bus, RTW_RFCHIPID_MAXIM, MAX2820_ENABLE, enable);
 735 }
 736
 737 struct rtw_rf *
 738 rtw_max2820_create(struct rtw_regs *regs, rtw_rf_write_t rf_write, int is_a)
 739 {
 740         struct rtw_max2820 *mx;
 741         struct rtw_rfbus *bus;
 742         struct rtw_rf *rf;
 743         struct rtw_bbpset *bb;
 744
 745         mx = kmalloc(sizeof(*mx), M_DEVBUF, M_WAITOK | M_ZERO);
 746
 747         mx->mx_is_a = is_a;
 748
 749         rf = &mx->mx_rf;
 750         bus = &mx->mx_bus;
 751
 752         rf->rf_init = rtw_max2820_init;
 753         rf->rf_destroy = rtw_max2820_destroy;
 754         rf->rf_txpower = rtw_max2820_txpower;
 755         rf->rf_tune = rtw_max2820_tune;
 756         rf->rf_pwrstate = rtw_max2820_pwrstate;
 757         bb = &rf->rf_bbpset;
 758
 759         /* XXX magic */
 760         bb->bb_antatten = RTW_BBP_ANTATTEN_MAXIM_MAGIC;
 761         bb->bb_chestlim =       0;
 762         bb->bb_chsqlim =        159;
 763         bb->bb_ifagcdet =       100;
 764         bb->bb_ifagcini =       144;
 765         bb->bb_ifagclimit =     26;
 766         bb->bb_lnadet =         248;
 767         bb->bb_sys1 =           136;
 768         bb->bb_sys2 =           71;
 769         bb->bb_sys3 =           155;
 770         bb->bb_trl =            136;
 771         bb->bb_txagc =          8;
 772
 773         bus->b_regs = regs;
 774         bus->b_write = rf_write;
 775
 776         return &mx->mx_rf;
 777 }
 778
 779 /* freq is in MHz */
 780 int
 781 rtw_phy_init(struct rtw_regs *regs, struct rtw_rf *rf, uint8_t opaque_txpower,
 782              uint8_t cs_threshold, u_int freq, int antdiv, int dflantb,
 783              enum rtw_pwrstate power)
 784 {
 785         int rc;
 786         RTW_DPRINTF(RTW_DEBUG_PHY,
 787             ("%s: txpower %u csthresh %u freq %u antdiv %u dflantb %u "
 788              "pwrstate %s\n", __func__, opaque_txpower, cs_threshold, freq,
 789              antdiv, dflantb, rtw_pwrstate_string(power)));
 790
 791         /* XXX is this really necessary? */
 792         if ((rc = rtw_rf_txpower(rf, opaque_txpower)) != 0)
 793                 return rc;
 794
 795         rc = rtw_bbp_preinit(regs, rf->rf_bbpset.bb_antatten, dflantb, freq);
 796         if (rc != 0)
 797                 return rc;
 798
 799         if ((rc = rtw_rf_tune(rf, freq)) != 0)
 800                 return rc;
 801
 802         /* initialize RF  */
 803         if ((rc = rtw_rf_init(rf, freq, opaque_txpower, power)) != 0)
 804                 return rc;
 805 #if 0   /* what is this redundant tx power setting here for? */
 806         if ((rc = rtw_rf_txpower(rf, opaque_txpower)) != 0)
 807                 return rc;
 808 #endif
 809         return rtw_bbp_init(regs, &rf->rf_bbpset, antdiv, dflantb, cs_threshold,                            freq);
 810 }