git.gag.com Git - debian/gnuradio/blob - usrp/host/lib/db_wbxng.cc

   1 //
   2 // Copyright 2008,2009 Free Software Foundation, Inc.
   3 //
   4 // This file is part of GNU Radio
   5 //
   6 // GNU Radio 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 asversion 3, or (at your option)
   9 // any later version.
  10 //
  11 // GNU Radio 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 GNU Radio; see the file COPYING.  If not, write to
  18 // the Free Software Foundation, Inc., 51 Franklin Street,
  19 // Boston, MA 02110-1301, USA.
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include <usrp/db_wbxng.h>
  26 #include "db_wbxng_adf4350.h"
  27 #include <db_base_impl.h>
  28 #include <stdio.h>
  29
  30 // d'board i/o pin defs
  31 // Tx and Rx have shared defs, but different i/o regs
  32 #define ENABLE_5        (1 << 7)         // enables 5.0V power supply
  33 #define ENABLE_33       (1 << 6)         // enables 3.3V supply
  34 //#define RX_TXN          (1 << 15)         // Tx only: T/R antenna switch for TX/RX port
  35 //#define RX2_RX1N        (1 << 15)         // Rx only: antenna switch between RX2 and TX/RX port
  36 #define RX_TXN          ((1 << 5)|(1 << 15))         // Tx only: T/R antenna switch for TX/RX port
  37 #define RX2_RX1N        ((1 << 5)|(1 << 15))         // Rx only: antenna switch between RX2 and TX/RX port
  38 #define RXBB_EN         (1 << 4)
  39 #define TXMOD_EN        (1 << 4)
  40 #define PLL_CE          (1 << 3)
  41 #define PLL_PDBRF       (1 << 2)
  42 #define PLL_MUXOUT      (1 << 1)
  43 #define PLL_LOCK_DETECT (1 << 0)
  44
  45 // RX Attenuator constants
  46 #define ATTN_SHIFT      8
  47 #define ATTN_MASK       (63 << ATTN_SHIFT)
  48
  49 wbxng_base::wbxng_base(usrp_basic_sptr _usrp, int which, int _power_on)
  50   : db_base(_usrp, which), d_power_on(_power_on)
  51 {
  52   /*
  53     @param usrp: instance of usrp.source_c
  54     @param which: which side: 0 or 1 corresponding to side A or B respectively
  55     @type which: int
  56   */
  57
  58   usrp()->_write_oe(d_which, 0, 0xffff);   // turn off all outputs
  59
  60   d_first = true;
  61   d_spi_format = SPI_FMT_MSB | SPI_FMT_HDR_0;
  62
  63   _enable_refclk(false);                // disable refclk
  64
  65   set_auto_tr(false);
  66 }
  67
  68 wbxng_base::~wbxng_base()
  69 {
  70   if (d_common)
  71     delete d_common;
  72 }
  73
  74 int
  75 wbxng_base::_refclk_divisor()
  76 {
  77   return 1;
  78 }
  79
  80 struct freq_result_t
  81 wbxng_base::set_freq(double freq)
  82 {
  83   /*
  84     @returns (ok, actual_baseband_freq) where:
  85     ok is True or False and indicates success or failure,
  86     actual_baseband_freq is the RF frequency that corresponds to DC in the IF.
  87   */
  88
  89   // clamp freq
  90   freq_t int_freq = freq_t(std::max(freq_min(), std::min(freq, freq_max())));
  91
  92   bool ok = d_common->_set_freq(int_freq*2, _refclk_freq());
  93   double freq_result = (double) d_common->_get_freq(_refclk_freq())/2.0;
  94   struct freq_result_t args = {ok, freq_result};
  95
  96   /* Wait before reading Lock Detect*/
  97   timespec t;
  98   t.tv_sec = 0;
  99   t.tv_nsec = 10000000;
 100   nanosleep(&t, NULL);
 101
 102   //fprintf(stderr,"Setting WBXNG frequency, requested %d, obtained %f, lock_detect %d\n",
 103   //        int_freq, freq_result, d_common->_get_locked());
 104
 105   // FIXME
 106   // Offsetting the LO helps get the Tx carrier leakage out of the way.
 107   // This also ensures that on Rx, we're not getting hosed by the
 108   // FPGA's DC removal loop's time constant.  We were seeing a
 109   // problem when running with discontinuous transmission.
 110   // Offsetting the LO made the problem go away.
 111   //freq += d_lo_offset;
 112
 113   return args;
 114 }
 115
 116 bool
 117 wbxng_base::_set_pga(float pga_gain)
 118 {
 119   if(d_which == 0) {
 120     usrp()->set_pga(0, pga_gain);
 121     usrp()->set_pga(1, pga_gain);
 122   }
 123   else {
 124     usrp()->set_pga(2, pga_gain);
 125     usrp()->set_pga(3, pga_gain);
 126   }
 127   return true;
 128 }
 129
 130 bool
 131 wbxng_base::is_quadrature()
 132 {
 133   /*
 134     Return True if this board requires both I & Q analog channels.
 135
 136     This bit of info is useful when setting up the USRP Rx mux register.
 137   */
 138   return true;
 139 }
 140
 141 double
 142 wbxng_base::freq_min()
 143 {
 144   return (double) d_common->_get_min_freq()/2.0;
 145 }
 146
 147 double
 148 wbxng_base::freq_max()
 149 {
 150   return (double) d_common->_get_max_freq()/2.0;
 151 }
 152
 153 // ----------------------------------------------------------------
 154
 155 wbxng_base_tx::wbxng_base_tx(usrp_basic_sptr _usrp, int which, int _power_on)
 156   : wbxng_base(_usrp, which, _power_on)
 157 {
 158   /*
 159     @param usrp: instance of usrp.sink_c
 160     @param which: 0 or 1 corresponding to side TX_A or TX_B respectively.
 161   */
 162
 163   if(which == 0) {
 164     d_spi_enable = SPI_ENABLE_TX_A;
 165   }
 166   else {
 167     d_spi_enable = SPI_ENABLE_TX_B;
 168   }
 169
 170   d_common = new adf4350(_usrp, d_which, d_spi_enable);
 171
 172   // power up the transmit side, but don't enable the mixer
 173   usrp()->_write_oe(d_which,(RX_TXN|TXMOD_EN|ENABLE_33|ENABLE_5), (RX_TXN|TXMOD_EN|ENABLE_33|ENABLE_5));
 174   usrp()->write_io(d_which, (power_on()|RX_TXN|ENABLE_33|ENABLE_5), (RX_TXN|ENABLE_33|ENABLE_5));
 175   //set_lo_offset(4e6);
 176
 177   // Disable VCO/PLL
 178   d_common->_enable(true);
 179
 180   set_gain((gain_min() + gain_max()) / 2.0);  // initialize gain
 181 }
 182
 183 wbxng_base_tx::~wbxng_base_tx()
 184 {
 185   shutdown();
 186 }
 187
 188
 189 void
 190 wbxng_base_tx::shutdown()
 191 {
 192   // fprintf(stderr, "wbxng_base_tx::shutdown  d_is_shutdown = %d\n", d_is_shutdown);
 193
 194   if (!d_is_shutdown){
 195     d_is_shutdown = true;
 196     // do whatever there is to do to shutdown
 197
 198     // Disable VCO/PLL
 199     d_common->_enable(false);
 200
 201     // Power down and leave the T/R switch in the R position
 202     usrp()->write_io(d_which, (power_off()|RX_TXN), (RX_TXN|ENABLE_33|ENABLE_5));
 203
 204
 205     /*
 206     _write_control(_compute_control_reg());
 207     */
 208     _enable_refclk(false);                       // turn off refclk
 209     set_auto_tr(false);
 210   }
 211 }
 212
 213 bool
 214 wbxng_base_tx::set_auto_tr(bool on)
 215 {
 216   bool ok = true;
 217   if(on) {
 218     ok &= set_atr_mask (RX_TXN | TXMOD_EN);
 219     ok &= set_atr_txval(0      | TXMOD_EN);
 220     ok &= set_atr_rxval(RX_TXN);
 221   }
 222   else {
 223     ok &= set_atr_mask (0);
 224     ok &= set_atr_txval(0);
 225     ok &= set_atr_rxval(0);
 226   }
 227   return ok;
 228 }
 229
 230 bool
 231 wbxng_base_tx::set_enable(bool on)
 232 {
 233   /*
 234     Enable transmitter if on is true
 235   */
 236
 237   int v;
 238   int mask = RX_TXN | TXMOD_EN;
 239   if(on) {
 240     v = TXMOD_EN;
 241     // Enable VCO/PLL
 242     //d_common->_enable(true);
 243   }
 244   else {
 245     v = RX_TXN;
 246     // Disable VCO/PLL
 247     //d_common->_enable(false);
 248   }
 249   return usrp()->write_io(d_which, v, mask);
 250 }
 251
 252 float
 253 wbxng_base_tx::gain_min()
 254 {
 255   return 0.0;
 256 }
 257
 258 float
 259 wbxng_base_tx::gain_max()
 260 {
 261   return 25.0;
 262 }
 263
 264 float
 265 wbxng_base_tx::gain_db_per_step()
 266 {
 267   return gain_max()/(1+(1.4-0.5)*4096/3.3);
 268 }
 269
 270 bool
 271 wbxng_base_tx::set_gain(float gain)
 272 {
 273   /*
 274     Set the gain.
 275
 276     @param gain:  gain in decibels
 277     @returns True/False
 278   */
 279
 280   // clamp gain
 281   gain = std::max(gain_min(), std::min(gain, gain_max()));
 282
 283   float pga_gain, agc_gain;
 284   float V_maxgain, V_mingain, V_fullscale, dac_value;
 285
 286   float maxgain = gain_max();
 287   float mingain = gain_min();
 288   pga_gain = 0;
 289   agc_gain = gain;
 290
 291   V_maxgain = 0.5;
 292   V_mingain = 1.4;
 293   V_fullscale = 3.3;
 294   dac_value = (agc_gain*(V_maxgain-V_mingain)/(maxgain-mingain) + V_mingain)*4096/V_fullscale;
 295
 296   //fprintf(stderr, "TXGAIN: %f dB, Dac Code: %d, Voltage: %f\n", gain, int(dac_value), float((dac_value/4096.0)*V_fullscale));
 297   assert(dac_value>=0 && dac_value<4096);
 298
 299   return (usrp()->write_aux_dac(d_which, 0, int(dac_value))
 300      && _set_pga(usrp()->pga_max()));
 301
 302 }
 303
 304
 305 /**************************************************************************/
 306
 307
 308 wbxng_base_rx::wbxng_base_rx(usrp_basic_sptr _usrp, int which, int _power_on)
 309   : wbxng_base(_usrp, which, _power_on)
 310 {
 311   /*
 312     @param usrp: instance of usrp.source_c
 313     @param which: 0 or 1 corresponding to side RX_A or RX_B respectively.
 314   */
 315
 316   if(which == 0) {
 317     d_spi_enable = SPI_ENABLE_RX_A;
 318   }
 319   else {
 320     d_spi_enable = SPI_ENABLE_RX_B;
 321   }
 322
 323   d_common = new adf4350(_usrp, d_which, d_spi_enable);
 324
 325   // Disable VCO/PLL
 326   d_common->_enable(true);
 327
 328   usrp()->_write_oe(d_which, (RX2_RX1N|RXBB_EN|ATTN_MASK|ENABLE_33|ENABLE_5), (RX2_RX1N|RXBB_EN|ATTN_MASK|ENABLE_33|ENABLE_5));
 329   usrp()->write_io(d_which,  (power_on()|RX2_RX1N|RXBB_EN|ENABLE_33|ENABLE_5), (RX2_RX1N|RXBB_EN|ATTN_MASK|ENABLE_33|ENABLE_5));
 330   //fprintf(stderr,"Setting WBXNG RXBB on");
 331
 332   // set up for RX on TX/RX port
 333   select_rx_antenna("TX/RX");
 334
 335   bypass_adc_buffers(true);
 336
 337   /*
 338   set_lo_offset(-4e6);
 339   */
 340 }
 341
 342 wbxng_base_rx::~wbxng_base_rx()
 343 {
 344   shutdown();
 345 }
 346
 347 void
 348 wbxng_base_rx::shutdown()
 349 {
 350   // fprintf(stderr, "wbxng_base_rx::shutdown  d_is_shutdown = %d\n", d_is_shutdown);
 351
 352   if (!d_is_shutdown){
 353     d_is_shutdown = true;
 354     // do whatever there is to do to shutdown
 355
 356     // Power down VCO/PLL
 357     d_common->_enable(false);
 358
 359     // fprintf(stderr, "wbxng_base_rx::shutdown  before _write_control\n");
 360     //_write_control(_compute_control_reg());
 361
 362     // fprintf(stderr, "wbxng_base_rx::shutdown  before _enable_refclk\n");
 363     _enable_refclk(false);                       // turn off refclk
 364
 365     // fprintf(stderr, "wbxng_base_rx::shutdown  before set_auto_tr\n");
 366     set_auto_tr(false);
 367
 368     // Power down
 369     usrp()->write_io(d_which, power_off(), (RX2_RX1N|RXBB_EN|ATTN_MASK|ENABLE_33|ENABLE_5));
 370
 371     // fprintf(stderr, "wbxng_base_rx::shutdown  after set_auto_tr\n");
 372   }
 373 }
 374
 375 bool
 376 wbxng_base_rx::set_auto_tr(bool on)
 377 {
 378   bool ok = true;
 379   if(on) {
 380     ok &= set_atr_mask (RXBB_EN|RX2_RX1N);
 381     ok &= set_atr_txval(      0|RX2_RX1N);
 382     ok &= set_atr_rxval(RXBB_EN|       0);
 383   }
 384   else {
 385     ok &= set_atr_mask (0);
 386     ok &= set_atr_txval(0);
 387     ok &= set_atr_rxval(0);
 388   }
 389   return true;
 390 }
 391
 392 bool
 393 wbxng_base_rx::select_rx_antenna(int which_antenna)
 394 {
 395   /*
 396     Specify which antenna port to use for reception.
 397     @param which_antenna: either 'TX/RX' or 'RX2'
 398   */
 399
 400   if(which_antenna == 0) {
 401     usrp()->write_io(d_which, 0,RX2_RX1N);
 402   }
 403   else if(which_antenna == 1) {
 404     usrp()->write_io(d_which, RX2_RX1N, RX2_RX1N);
 405   }
 406   else {
 407     return false;
 408   }
 409   return true;
 410 }
 411
 412 bool
 413 wbxng_base_rx::select_rx_antenna(const std::string &which_antenna)
 414 {
 415   /*
 416     Specify which antenna port to use for reception.
 417     @param which_antenna: either 'TX/RX' or 'RX2'
 418   */
 419
 420
 421   if(which_antenna == "TX/RX") {
 422     usrp()->write_io(d_which, 0, RX2_RX1N);
 423   }
 424   else if(which_antenna == "RX2") {
 425     usrp()->write_io(d_which, RX2_RX1N, RX2_RX1N);
 426   }
 427   else {
 428     return false;
 429   }
 430
 431   return true;
 432 }
 433
 434 bool
 435 wbxng_base_rx::set_gain(float gain)
 436 {
 437   /*
 438     Set the gain.
 439
 440     @param gain:  gain in decibels
 441     @returns True/False
 442   */
 443
 444   // clamp gain
 445   gain = std::max(gain_min(), std::min(gain, gain_max()));
 446
 447   float pga_gain, agc_gain;
 448
 449   float maxgain = gain_max() - usrp()->pga_max();
 450   float mingain = gain_min();
 451   if(gain > maxgain) {
 452     pga_gain = gain-maxgain;
 453     assert(pga_gain <= usrp()->pga_max());
 454     agc_gain = maxgain;
 455   }
 456   else {
 457     pga_gain = 0;
 458     agc_gain = gain;
 459   }
 460
 461   return _set_attn(maxgain-agc_gain) && _set_pga(int(pga_gain));
 462 }
 463
 464 bool
 465 wbxng_base_rx::_set_attn(float attn)
 466 {
 467   int attn_code = int(floor(attn/0.5));
 468   unsigned int iobits = (~attn_code) << ATTN_SHIFT;
 469   //fprintf(stderr, "Attenuation: %f dB, Code: %d, IO Bits %x, Mask: %x \n", attn, attn_code, iobits & ATTN_MASK, ATTN_MASK);
 470   return usrp()->write_io(d_which, iobits, ATTN_MASK);
 471 }
 472
 473 // ----------------------------------------------------------------
 474
 475 db_wbxng_tx::db_wbxng_tx(usrp_basic_sptr usrp, int which)
 476   : wbxng_base_tx(usrp, which)
 477 {
 478 }
 479
 480 db_wbxng_tx::~db_wbxng_tx()
 481 {
 482 }
 483
 484 db_wbxng_rx::db_wbxng_rx(usrp_basic_sptr usrp, int which)
 485   : wbxng_base_rx(usrp, which)
 486 {
 487   set_gain((gain_min() + gain_max()) / 2.0);  // initialize gain
 488 }
 489
 490 db_wbxng_rx::~db_wbxng_rx()
 491 {
 492 }
 493
 494 float
 495 db_wbxng_rx::gain_min()
 496 {
 497   return usrp()->pga_min();
 498 }
 499
 500 float
 501 db_wbxng_rx::gain_max()
 502 {
 503   return usrp()->pga_max()+30.5;
 504 }
 505
 506 float
 507 db_wbxng_rx::gain_db_per_step()
 508 {
 509   return 0.05;
 510 }
 511
 512
 513 bool
 514 db_wbxng_rx::i_and_q_swapped()
 515 {
 516   return false;
 517 }