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

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright 2003,2004 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GNU Radio
   6  *
   7  * GNU Radio is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3, or (at your option)
  10  * any later version.
  11  *
  12  * GNU Radio is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with GNU Radio; see the file COPYING.  If not, write to
  19  * the Free Software Foundation, Inc., 51 Franklin Street,
  20  * Boston, MA 02110-1301, USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include "usrp_basic.h"
  28 #include "usrp_prims.h"
  29 #include "usrp_interfaces.h"
  30 #include "fpga_regs_common.h"
  31 #include "fusb.h"
  32 #include <usb.h>
  33 #include <stdexcept>
  34 #include <assert.h>
  35 #include <math.h>
  36 #include <ad9862.h>
  37
  38 using namespace ad9862;
  39
  40 #define NELEM(x) (sizeof (x) / sizeof (x[0]))
  41
  42 // These set the buffer size used for each end point using the fast
  43 // usb interface.  The kernel ends up locking down this much memory.
  44
  45 static const int FUSB_BUFFER_SIZE = fusb_sysconfig::default_buffer_size();
  46 static const int FUSB_BLOCK_SIZE = fusb_sysconfig::max_block_size();
  47 static const int FUSB_NBLOCKS    = FUSB_BUFFER_SIZE / FUSB_BLOCK_SIZE;
  48
  49
  50 static const double POLLING_INTERVAL = 0.1;     // seconds
  51
  52 ////////////////////////////////////////////////////////////////
  53
  54 static struct usb_dev_handle *
  55 open_rx_interface (struct usb_device *dev)
  56 {
  57   struct usb_dev_handle *udh = usrp_open_rx_interface (dev);
  58   if (udh == 0){
  59     fprintf (stderr, "usrp_basic_rx: can't open rx interface\n");
  60     usb_strerror ();
  61   }
  62   return udh;
  63 }
  64
  65 static struct usb_dev_handle *
  66 open_tx_interface (struct usb_device *dev)
  67 {
  68   struct usb_dev_handle *udh = usrp_open_tx_interface (dev);
  69   if (udh == 0){
  70     fprintf (stderr, "usrp_basic_tx: can't open tx interface\n");
  71     usb_strerror ();
  72   }
  73   return udh;
  74 }
  75
  76
  77 //////////////////////////////////////////////////////////////////
  78 //
  79 //                      usrp_basic
  80 //
  81 ////////////////////////////////////////////////////////////////
  82
  83
  84 // Given:
  85 //   CLKIN = 64 MHz
  86 //   CLKSEL pin = high
  87 //
  88 // These settings give us:
  89 //   CLKOUT1 = CLKIN = 64 MHz
  90 //   CLKOUT2 = CLKIN = 64 MHz
  91 //   ADC is clocked at  64 MHz
  92 //   DAC is clocked at 128 MHz
  93
  94 static unsigned char common_regs[] = {
  95   REG_GENERAL,          0,
  96   REG_DLL,              (DLL_DISABLE_INTERNAL_XTAL_OSC
  97                          | DLL_MULT_2X
  98                          | DLL_FAST),
  99   REG_CLKOUT,           CLKOUT2_EQ_DLL_OVER_2,
 100   REG_AUX_ADC_CLK,      AUX_ADC_CLK_CLK_OVER_4
 101 };
 102
 103
 104 usrp_basic::usrp_basic (int which_board,
 105                         struct usb_dev_handle *
 106                         open_interface (struct usb_device *dev),
 107                         const std::string fpga_filename,
 108                         const std::string firmware_filename)
 109   : d_udh (0),
 110     d_usb_data_rate (16000000), // SWAG, see below
 111     d_bytes_per_poll ((int) (POLLING_INTERVAL * d_usb_data_rate)),
 112     d_verbose (false)
 113 {
 114   /*
 115    * SWAG: Scientific Wild Ass Guess.
 116    *
 117    * d_usb_data_rate is used only to determine how often to poll for over- and under-runs.
 118    * We defualt it to 1/2  of our best case.  Classes derived from usrp_basic (e.g.,
 119    * usrp_standard_tx and usrp_standard_rx) call set_usb_data_rate() to tell us the
 120    * actual rate.  This doesn't change our throughput, that's determined by the signal
 121    * processing code in the FPGA (which we know nothing about), and the system limits
 122    * determined by libusb, fusb_*, and the underlying drivers.
 123    */
 124   memset (d_fpga_shadows, 0, sizeof (d_fpga_shadows));
 125
 126   usrp_one_time_init ();
 127
 128   if (!usrp_load_standard_bits (which_board, false, fpga_filename, firmware_filename))
 129     throw std::runtime_error ("usrp_basic/usrp_load_standard_bits");
 130
 131   struct usb_device *dev = usrp_find_device (which_board);
 132   if (dev == 0){
 133     fprintf (stderr, "usrp_basic: can't find usrp[%d]\n", which_board);
 134     throw std::runtime_error ("usrp_basic/usrp_find_device");
 135   }
 136
 137   if (!(usrp_usrp_p(dev) && usrp_hw_rev(dev) >= 1)){
 138     fprintf (stderr, "usrp_basic: sorry, this code only works with USRP revs >= 1\n");
 139     throw std::runtime_error ("usrp_basic/bad_rev");
 140   }
 141
 142   if ((d_udh = open_interface (dev)) == 0)
 143     throw std::runtime_error ("usrp_basic/open_interface");
 144
 145   // initialize registers that are common to rx and tx
 146
 147   if (!usrp_9862_write_many_all (d_udh, common_regs, sizeof (common_regs))){
 148     fprintf (stderr, "usrp_basic: failed to init common AD9862 regs\n");
 149     throw std::runtime_error ("usrp_basic/init_9862");
 150   }
 151
 152   _write_fpga_reg (FR_MODE, 0);         // ensure we're in normal mode
 153   _write_fpga_reg (FR_DEBUG_EN, 0);     // disable debug outputs
 154 }
 155
 156 usrp_basic::~usrp_basic ()
 157 {
 158   if (d_udh)
 159     usb_close (d_udh);
 160 }
 161
 162 bool
 163 usrp_basic::start ()
 164 {
 165   return true;          // nop
 166 }
 167
 168 bool
 169 usrp_basic::stop ()
 170 {
 171   return true;          // nop
 172 }
 173
 174 void
 175 usrp_basic::set_usb_data_rate (int usb_data_rate)
 176 {
 177   d_usb_data_rate = usb_data_rate;
 178   d_bytes_per_poll = (int) (usb_data_rate * POLLING_INTERVAL);
 179 }
 180
 181 bool
 182 usrp_basic::write_aux_dac (int slot, int which_dac, int value)
 183 {
 184   return usrp_write_aux_dac (d_udh, slot, which_dac, value);
 185 }
 186
 187 bool
 188 usrp_basic::read_aux_adc (int slot, int which_adc, int *value)
 189 {
 190   return usrp_read_aux_adc (d_udh, slot, which_adc, value);
 191 }
 192
 193 int
 194 usrp_basic::read_aux_adc (int slot, int which_adc)
 195 {
 196   int   value;
 197   if (!read_aux_adc (slot, which_adc, &value))
 198     return READ_FAILED;
 199
 200   return value;
 201 }
 202
 203 bool
 204 usrp_basic::write_eeprom (int i2c_addr, int eeprom_offset, const std::string buf)
 205 {
 206   return usrp_eeprom_write (d_udh, i2c_addr, eeprom_offset, buf.data (), buf.size ());
 207 }
 208
 209 std::string
 210 usrp_basic::read_eeprom (int i2c_addr, int eeprom_offset, int len)
 211 {
 212   if (len <= 0)
 213     return "";
 214
 215   char buf[len];
 216
 217   if (!usrp_eeprom_read (d_udh, i2c_addr, eeprom_offset, buf, len))
 218     return "";
 219
 220   return std::string (buf, len);
 221 }
 222
 223 bool
 224 usrp_basic::write_i2c (int i2c_addr, const std::string buf)
 225 {
 226   return usrp_i2c_write (d_udh, i2c_addr, buf.data (), buf.size ());
 227 }
 228
 229 std::string
 230 usrp_basic::read_i2c (int i2c_addr, int len)
 231 {
 232   if (len <= 0)
 233     return "";
 234
 235   char buf[len];
 236
 237   if (!usrp_i2c_read (d_udh, i2c_addr, buf, len))
 238     return "";
 239
 240   return std::string (buf, len);
 241 }
 242
 243 std::string
 244 usrp_basic::serial_number()
 245 {
 246   return usrp_serial_number(d_udh);
 247 }
 248
 249 // ----------------------------------------------------------------
 250
 251 bool
 252 usrp_basic::set_adc_offset (int which, int offset)
 253 {
 254   if (which < 0 || which > 3)
 255     return false;
 256
 257   return _write_fpga_reg (FR_ADC_OFFSET_0 + which, offset);
 258 }
 259
 260 bool
 261 usrp_basic::set_dac_offset (int which, int offset, int offset_pin)
 262 {
 263   if (which < 0 || which > 3)
 264     return false;
 265
 266   int which_codec = which >> 1;
 267   int tx_a = (which & 0x1) == 0;
 268   int lo = ((offset & 0x3) << 6) | (offset_pin & 0x1);
 269   int hi = (offset >> 2);
 270   bool ok;
 271
 272   if (tx_a){
 273     ok =  _write_9862 (which_codec, REG_TX_A_OFFSET_LO, lo);
 274     ok &= _write_9862 (which_codec, REG_TX_A_OFFSET_HI, hi);
 275   }
 276   else {
 277     ok =  _write_9862 (which_codec, REG_TX_B_OFFSET_LO, lo);
 278     ok &= _write_9862 (which_codec, REG_TX_B_OFFSET_HI, hi);
 279   }
 280   return ok;
 281 }
 282
 283 bool
 284 usrp_basic::set_adc_buffer_bypass (int which, bool bypass)
 285 {
 286   if (which < 0 || which > 3)
 287     return false;
 288
 289   int codec = which >> 1;
 290   int reg = (which & 1) == 0 ? REG_RX_A : REG_RX_B;
 291
 292   unsigned char cur_rx;
 293   unsigned char cur_pwr_dn;
 294
 295   // If the input buffer is bypassed, we need to power it down too.
 296
 297   bool ok = _read_9862 (codec, reg, &cur_rx);
 298   ok &= _read_9862 (codec, REG_RX_PWR_DN, &cur_pwr_dn);
 299   if (!ok)
 300     return false;
 301
 302   if (bypass){
 303     cur_rx |= RX_X_BYPASS_INPUT_BUFFER;
 304     cur_pwr_dn |= ((which & 1) == 0) ? RX_PWR_DN_BUF_A : RX_PWR_DN_BUF_B;
 305   }
 306   else {
 307     cur_rx &= ~RX_X_BYPASS_INPUT_BUFFER;
 308     cur_pwr_dn &= ~(((which & 1) == 0) ? RX_PWR_DN_BUF_A : RX_PWR_DN_BUF_B);
 309   }
 310
 311   ok &= _write_9862 (codec, reg, cur_rx);
 312   ok &= _write_9862 (codec, REG_RX_PWR_DN, cur_pwr_dn);
 313   return ok;
 314 }
 315
 316 // ----------------------------------------------------------------
 317
 318 bool
 319 usrp_basic::_write_fpga_reg (int regno, int value)
 320 {
 321   if (d_verbose){
 322     fprintf (stdout, "_write_fpga_reg(%3d, 0x%08x)\n", regno, value);
 323     fflush (stdout);
 324   }
 325
 326   if (regno >= 0 && regno < MAX_REGS)
 327     d_fpga_shadows[regno] = value;
 328
 329   return usrp_write_fpga_reg (d_udh, regno, value);
 330 }
 331
 332 bool
 333 usrp_basic::_write_fpga_reg_masked (int regno, int value, int mask)
 334 {
 335   //Only use this for registers who actually use a mask in the verilog firmware, like FR_RX_MASTER_SLAVE
 336   //value is a 16 bits value and mask is a 16 bits mask
 337   if (d_verbose){
 338     fprintf (stdout, "_write_fpga_reg_masked(%3d, 0x%04x,0x%04x)\n", regno, value, mask);
 339     fflush (stdout);
 340   }
 341
 342   if (regno >= 0 && regno < MAX_REGS)
 343     d_fpga_shadows[regno] = value;
 344
 345   return usrp_write_fpga_reg (d_udh, regno, (value & 0xffff) | ((mask & 0xffff)<<16));
 346 }
 347
 348
 349 bool
 350 usrp_basic::_read_fpga_reg (int regno, int *value)
 351 {
 352   return usrp_read_fpga_reg (d_udh, regno, value);
 353 }
 354
 355 int
 356 usrp_basic::_read_fpga_reg (int regno)
 357 {
 358   int value;
 359   if (!_read_fpga_reg (regno, &value))
 360     return READ_FAILED;
 361   return value;
 362 }
 363
 364 bool
 365 usrp_basic::_write_9862 (int which_codec, int regno, unsigned char value)
 366 {
 367   if (0 && d_verbose){
 368     // FIXME really want to enable logging in usrp_prims:usrp_9862_write
 369     fprintf(stdout, "_write_9862(codec = %d, regno = %2d, val = 0x%02x)\n", which_codec, regno, value);
 370     fflush(stdout);
 371   }
 372
 373   return usrp_9862_write (d_udh, which_codec, regno, value);
 374 }
 375
 376
 377 bool
 378 usrp_basic::_read_9862 (int which_codec, int regno, unsigned char *value) const
 379 {
 380   return usrp_9862_read (d_udh, which_codec, regno, value);
 381 }
 382
 383 int
 384 usrp_basic::_read_9862 (int which_codec, int regno) const
 385 {
 386   unsigned char value;
 387   if (!_read_9862 (which_codec, regno, &value))
 388     return READ_FAILED;
 389   return value;
 390 }
 391
 392 bool
 393 usrp_basic::_write_spi (int optional_header, int enables, int format, std::string buf)
 394 {
 395   return usrp_spi_write (d_udh, optional_header, enables, format,
 396                          buf.data(), buf.size());
 397 }
 398
 399 std::string
 400 usrp_basic::_read_spi (int optional_header, int enables, int format, int len)
 401 {
 402   if (len <= 0)
 403     return "";
 404
 405   char buf[len];
 406
 407   if (!usrp_spi_read (d_udh, optional_header, enables, format, buf, len))
 408     return "";
 409
 410   return std::string (buf, len);
 411 }
 412
 413
 414 bool
 415 usrp_basic::_set_led (int which, bool on)
 416 {
 417   return usrp_set_led (d_udh, which, on);
 418 }
 419
 420 ////////////////////////////////////////////////////////////////
 421 //
 422 //                         usrp_basic_rx
 423 //
 424 ////////////////////////////////////////////////////////////////
 425
 426 static unsigned char rx_init_regs[] = {
 427   REG_RX_PWR_DN,        0,
 428   REG_RX_A,             0,      // minimum gain = 0x00 (max gain = 0x14)
 429   REG_RX_B,             0,      // minimum gain = 0x00 (max gain = 0x14)
 430   REG_RX_MISC,          (RX_MISC_HS_DUTY_CYCLE | RX_MISC_CLK_DUTY),
 431   REG_RX_IF,            (RX_IF_USE_CLKOUT1
 432                          | RX_IF_2S_COMP),
 433   REG_RX_DIGITAL,       (RX_DIGITAL_2_CHAN)
 434 };
 435
 436
 437 usrp_basic_rx::usrp_basic_rx (int which_board, int fusb_block_size, int fusb_nblocks,
 438                               const std::string fpga_filename,
 439                               const std::string firmware_filename
 440                               )
 441   : usrp_basic (which_board, open_rx_interface, fpga_filename, firmware_filename),
 442     d_devhandle (0), d_ephandle (0),
 443     d_bytes_seen (0), d_first_read (true),
 444     d_rx_enable (false)
 445 {
 446   // initialize rx specific registers
 447
 448   if (!usrp_9862_write_many_all (d_udh, rx_init_regs, sizeof (rx_init_regs))){
 449     fprintf (stderr, "usrp_basic_rx: failed to init AD9862 RX regs\n");
 450     throw std::runtime_error ("usrp_basic_rx/init_9862");
 451   }
 452
 453   if (0){
 454     // FIXME power down 2nd codec rx path
 455     usrp_9862_write (d_udh, 1, REG_RX_PWR_DN, 0x1);     // power down everything
 456   }
 457
 458   // Reset the rx path and leave it disabled.
 459   set_rx_enable (false);
 460   usrp_set_fpga_rx_reset (d_udh, true);
 461   usrp_set_fpga_rx_reset (d_udh, false);
 462
 463   set_fpga_rx_sample_rate_divisor (2);  // usually correct
 464
 465   set_dc_offset_cl_enable(0xf, 0xf);    // enable DC offset removal control loops
 466
 467   probe_rx_slots (false);
 468
 469   // check fusb buffering parameters
 470
 471   if (fusb_block_size < 0 || fusb_block_size > FUSB_BLOCK_SIZE)
 472     throw std::out_of_range ("usrp_basic_rx: invalid fusb_block_size");
 473
 474   if (fusb_nblocks < 0)
 475     throw std::out_of_range ("usrp_basic_rx: invalid fusb_nblocks");
 476
 477   if (fusb_block_size == 0)
 478     fusb_block_size = fusb_sysconfig::default_block_size();
 479
 480   if (fusb_nblocks == 0)
 481     fusb_nblocks = std::max (1, FUSB_BUFFER_SIZE / fusb_block_size);
 482
 483   d_devhandle = fusb_sysconfig::make_devhandle (d_udh);
 484   d_ephandle = d_devhandle->make_ephandle (USRP_RX_ENDPOINT, true,
 485                                            fusb_block_size, fusb_nblocks);
 486
 487   _write_fpga_reg(FR_ATR_MASK_1, 0);    // zero Rx side Auto Transmit/Receive regs
 488   _write_fpga_reg(FR_ATR_TXVAL_1, 0);
 489   _write_fpga_reg(FR_ATR_RXVAL_1, 0);
 490   _write_fpga_reg(FR_ATR_MASK_3, 0);
 491   _write_fpga_reg(FR_ATR_TXVAL_3, 0);
 492   _write_fpga_reg(FR_ATR_RXVAL_3, 0);
 493 }
 494
 495 static unsigned char rx_fini_regs[] = {
 496   REG_RX_PWR_DN,        0x1                             // power down everything
 497 };
 498
 499 usrp_basic_rx::~usrp_basic_rx ()
 500 {
 501   if (!set_rx_enable (false)){
 502     fprintf (stderr, "usrp_basic_rx: set_fpga_rx_enable failed\n");
 503     usb_strerror ();
 504   }
 505
 506   d_ephandle->stop ();
 507   delete d_ephandle;
 508   delete d_devhandle;
 509
 510   if (!usrp_9862_write_many_all (d_udh, rx_fini_regs, sizeof (rx_fini_regs))){
 511     fprintf (stderr, "usrp_basic_rx: failed to fini AD9862 RX regs\n");
 512   }
 513 }
 514
 515
 516 bool
 517 usrp_basic_rx::start ()
 518 {
 519   if (!usrp_basic::start ())    // invoke parent's method
 520     return false;
 521
 522   // fire off reads before asserting rx_enable
 523
 524   if (!d_ephandle->start ()){
 525     fprintf (stderr, "usrp_basic_rx: failed to start end point streaming");
 526     usb_strerror ();
 527     return false;
 528   }
 529
 530   if (!set_rx_enable (true)){
 531     fprintf (stderr, "usrp_basic_rx: set_rx_enable failed\n");
 532     usb_strerror ();
 533     return false;
 534   }
 535
 536   return true;
 537 }
 538
 539 bool
 540 usrp_basic_rx::stop ()
 541 {
 542   bool ok = usrp_basic::stop();
 543
 544   if (!set_rx_enable(false)){
 545     fprintf (stderr, "usrp_basic_rx: set_rx_enable(false) failed\n");
 546     usb_strerror ();
 547     ok = false;
 548   }
 549
 550   if (!d_ephandle->stop()){
 551     fprintf (stderr, "usrp_basic_rx: failed to stop end point streaming");
 552     usb_strerror ();
 553     ok = false;
 554   }
 555
 556   return ok;
 557 }
 558
 559 usrp_basic_rx *
 560 usrp_basic_rx::make (int which_board, int fusb_block_size, int fusb_nblocks,
 561                      const std::string fpga_filename,
 562                      const std::string firmware_filename)
 563 {
 564   usrp_basic_rx *u = 0;
 565
 566   try {
 567     u = new usrp_basic_rx (which_board, fusb_block_size, fusb_nblocks,
 568                            fpga_filename, firmware_filename);
 569     return u;
 570   }
 571   catch (...){
 572     delete u;
 573     return 0;
 574   }
 575
 576   return u;
 577 }
 578
 579 bool
 580 usrp_basic_rx::set_fpga_rx_sample_rate_divisor (unsigned int div)
 581 {
 582   return _write_fpga_reg (FR_RX_SAMPLE_RATE_DIV, div - 1);
 583 }
 584
 585
 586 /*
 587  * \brief read data from the D/A's via the FPGA.
 588  * \p len must be a multiple of 512 bytes.
 589  *
 590  * \returns the number of bytes read, or -1 on error.
 591  *
 592  * If overrun is non-NULL it will be set true iff an RX overrun is detected.
 593  */
 594 int
 595 usrp_basic_rx::read (void *buf, int len, bool *overrun)
 596 {
 597   int   r;
 598
 599   if (overrun)
 600     *overrun = false;
 601
 602   if (len < 0 || (len % 512) != 0){
 603     fprintf (stderr, "usrp_basic_rx::read: invalid length = %d\n", len);
 604     return -1;
 605   }
 606
 607   r = d_ephandle->read (buf, len);
 608   if (r > 0)
 609     d_bytes_seen += r;
 610
 611   /*
 612    * In many cases, the FPGA reports an rx overrun right after we
 613    * enable the Rx path.  If this is our first read, check for the
 614    * overrun to clear the condition, then ignore the result.
 615    */
 616   if (0 && d_first_read){       // FIXME
 617     d_first_read = false;
 618     bool bogus_overrun;
 619     usrp_check_rx_overrun (d_udh, &bogus_overrun);
 620   }
 621
 622   if (overrun != 0 && d_bytes_seen >= d_bytes_per_poll){
 623     d_bytes_seen = 0;
 624     if (!usrp_check_rx_overrun (d_udh, overrun)){
 625       fprintf (stderr, "usrp_basic_rx: usrp_check_rx_overrun failed\n");
 626       usb_strerror ();
 627     }
 628   }
 629
 630   return r;
 631 }
 632
 633 bool
 634 usrp_basic_rx::set_rx_enable (bool on)
 635 {
 636   d_rx_enable = on;
 637   return usrp_set_fpga_rx_enable (d_udh, on);
 638 }
 639
 640 // conditional disable, return prev state
 641 bool
 642 usrp_basic_rx::disable_rx ()
 643 {
 644   bool enabled = rx_enable ();
 645   if (enabled)
 646     set_rx_enable (false);
 647   return enabled;
 648 }
 649
 650 // conditional set
 651 void
 652 usrp_basic_rx::restore_rx (bool on)
 653 {
 654   if (on != rx_enable ())
 655     set_rx_enable (on);
 656 }
 657
 658 bool
 659 usrp_basic_rx::set_pga (int which, double gain)
 660 {
 661   if (which < 0 || which > 3)
 662     return false;
 663
 664   gain = std::max (pga_min (), gain);
 665   gain = std::min (pga_max (), gain);
 666
 667   int codec = which >> 1;
 668   int reg = (which & 1) == 0 ? REG_RX_A : REG_RX_B;
 669
 670   // read current value to get input buffer bypass flag.
 671   unsigned char cur_rx;
 672   if (!_read_9862 (codec, reg, &cur_rx))
 673     return false;
 674
 675   int int_gain = (int) rint ((gain - pga_min ()) / pga_db_per_step());
 676
 677   cur_rx = (cur_rx & RX_X_BYPASS_INPUT_BUFFER) | (int_gain & 0x7f);
 678   return _write_9862 (codec, reg, cur_rx);
 679 }
 680
 681 double
 682 usrp_basic_rx::pga (int which) const
 683 {
 684   if (which < 0 || which > 3)
 685     return READ_FAILED;
 686
 687   int codec = which >> 1;
 688   int reg = (which & 1) == 0 ? REG_RX_A : REG_RX_B;
 689   unsigned char v;
 690   bool ok = _read_9862 (codec, reg, &v);
 691   if (!ok)
 692     return READ_FAILED;
 693
 694   return (pga_db_per_step() * (v & 0x1f)) + pga_min();
 695 }
 696
 697 static int
 698 slot_id_to_oe_reg (int slot_id)
 699 {
 700   static int reg[4]  = { FR_OE_0, FR_OE_1, FR_OE_2, FR_OE_3 };
 701   assert (0 <= slot_id && slot_id < 4);
 702   return reg[slot_id];
 703 }
 704
 705 static int
 706 slot_id_to_io_reg (int slot_id)
 707 {
 708   static int reg[4]  = { FR_IO_0, FR_IO_1, FR_IO_2, FR_IO_3 };
 709   assert (0 <= slot_id && slot_id < 4);
 710   return reg[slot_id];
 711 }
 712
 713 void
 714 usrp_basic_rx::probe_rx_slots (bool verbose)
 715 {
 716   struct usrp_dboard_eeprom     eeprom;
 717   static int slot_id_map[2] = { SLOT_RX_A, SLOT_RX_B };
 718   static const char *slot_name[2] = { "RX d'board A", "RX d'board B" };
 719
 720   for (int i = 0; i < 2; i++){
 721     int slot_id = slot_id_map [i];
 722     const char *msg = 0;
 723     usrp_dbeeprom_status_t s = usrp_read_dboard_eeprom (d_udh, slot_id, &eeprom);
 724
 725     switch (s){
 726     case UDBE_OK:
 727       d_dbid[i] = eeprom.id;
 728       msg = usrp_dbid_to_string (eeprom.id).c_str ();
 729       set_adc_offset (2*i+0, eeprom.offset[0]);
 730       set_adc_offset (2*i+1, eeprom.offset[1]);
 731       _write_fpga_reg (slot_id_to_oe_reg(slot_id), (0xffff << 16) | eeprom.oe);
 732       _write_fpga_reg (slot_id_to_io_reg(slot_id), (0xffff << 16) | 0x0000);
 733       break;
 734
 735     case UDBE_NO_EEPROM:
 736       d_dbid[i] = -1;
 737       msg = "<none>";
 738       _write_fpga_reg (slot_id_to_oe_reg(slot_id), (0xffff << 16) | 0x0000);
 739       _write_fpga_reg (slot_id_to_io_reg(slot_id), (0xffff << 16) | 0x0000);
 740       break;
 741
 742     case UDBE_INVALID_EEPROM:
 743       d_dbid[i] = -2;
 744       msg = "Invalid EEPROM contents";
 745       _write_fpga_reg (slot_id_to_oe_reg(slot_id), (0xffff << 16) | 0x0000);
 746       _write_fpga_reg (slot_id_to_io_reg(slot_id), (0xffff << 16) | 0x0000);
 747       break;
 748
 749     case UDBE_BAD_SLOT:
 750     default:
 751       assert (0);
 752     }
 753
 754     if (verbose){
 755       fflush (stdout);
 756       fprintf (stderr, "%s: %s\n", slot_name[i], msg);
 757     }
 758   }
 759 }
 760
 761 bool
 762 usrp_basic_rx::_write_oe (int which_dboard, int value, int mask)
 763 {
 764   if (! (0 <= which_dboard && which_dboard <= 1))
 765     return false;
 766
 767   return _write_fpga_reg (slot_id_to_oe_reg (dboard_to_slot (which_dboard)),
 768                           (mask << 16) | (value & 0xffff));
 769 }
 770
 771 bool
 772 usrp_basic_rx::write_io (int which_dboard, int value, int mask)
 773 {
 774   if (! (0 <= which_dboard && which_dboard <= 1))
 775     return false;
 776
 777   return _write_fpga_reg (slot_id_to_io_reg (dboard_to_slot (which_dboard)),
 778                           (mask << 16) | (value & 0xffff));
 779 }
 780
 781 bool
 782 usrp_basic_rx::read_io (int which_dboard, int *value)
 783 {
 784   if (! (0 <= which_dboard && which_dboard <= 1))
 785     return false;
 786
 787   int t;
 788   int reg = which_dboard + 1;   // FIXME, *very* magic number (fix in serial_io.v)
 789   bool ok = _read_fpga_reg (reg, &t);
 790   if (!ok)
 791     return false;
 792
 793   *value = (t >> 16) & 0xffff;  // FIXME, more magic
 794   return true;
 795 }
 796
 797 int
 798 usrp_basic_rx::read_io (int which_dboard)
 799 {
 800   int   value;
 801   if (!read_io (which_dboard, &value))
 802     return READ_FAILED;
 803   return value;
 804 }
 805
 806 bool
 807 usrp_basic_rx::write_aux_dac (int which_dboard, int which_dac, int value)
 808 {
 809   return usrp_basic::write_aux_dac (dboard_to_slot (which_dboard),
 810                                     which_dac, value);
 811 }
 812
 813 bool
 814 usrp_basic_rx::read_aux_adc (int which_dboard, int which_adc, int *value)
 815 {
 816   return usrp_basic::read_aux_adc (dboard_to_slot (which_dboard),
 817                                    which_adc, value);
 818 }
 819
 820 int
 821 usrp_basic_rx::read_aux_adc (int which_dboard, int which_adc)
 822 {
 823   return usrp_basic::read_aux_adc (dboard_to_slot (which_dboard), which_adc);
 824 }
 825
 826 int
 827 usrp_basic_rx::block_size () const { return d_ephandle->block_size(); }
 828
 829 bool
 830 usrp_basic_rx::set_dc_offset_cl_enable(int bits, int mask)
 831 {
 832   return _write_fpga_reg(FR_DC_OFFSET_CL_EN,
 833                          (d_fpga_shadows[FR_DC_OFFSET_CL_EN] & ~mask) | (bits & mask));
 834 }
 835
 836 ////////////////////////////////////////////////////////////////
 837 //
 838 //                         usrp_basic_tx
 839 //
 840 ////////////////////////////////////////////////////////////////
 841
 842
 843 //
 844 // DAC input rate 64 MHz interleaved for a total input rate of 128 MHz
 845 // DAC input is latched on rising edge of CLKOUT2
 846 // NCO is disabled
 847 // interpolate 2x
 848 // coarse modulator disabled
 849 //
 850
 851 static unsigned char tx_init_regs[] = {
 852   REG_TX_PWR_DN,        0,
 853   REG_TX_A_OFFSET_LO,   0,
 854   REG_TX_A_OFFSET_HI,   0,
 855   REG_TX_B_OFFSET_LO,   0,
 856   REG_TX_B_OFFSET_HI,   0,
 857   REG_TX_A_GAIN,        (TX_X_GAIN_COARSE_FULL | 0),
 858   REG_TX_B_GAIN,        (TX_X_GAIN_COARSE_FULL | 0),
 859   REG_TX_PGA,           0xff,                   // maximum gain (0 dB)
 860   REG_TX_MISC,          0,
 861   REG_TX_IF,            (TX_IF_USE_CLKOUT1
 862                          | TX_IF_I_FIRST
 863                          | TX_IF_INV_TX_SYNC
 864                          | TX_IF_2S_COMP
 865                          | TX_IF_INTERLEAVED),
 866   REG_TX_DIGITAL,       (TX_DIGITAL_2_DATA_PATHS
 867                          | TX_DIGITAL_INTERPOLATE_4X),
 868   REG_TX_MODULATOR,     (TX_MODULATOR_DISABLE_NCO
 869                          | TX_MODULATOR_COARSE_MODULATION_NONE),
 870   REG_TX_NCO_FTW_7_0,   0,
 871   REG_TX_NCO_FTW_15_8,  0,
 872   REG_TX_NCO_FTW_23_16, 0
 873 };
 874
 875 usrp_basic_tx::usrp_basic_tx (int which_board, int fusb_block_size, int fusb_nblocks,
 876                               const std::string fpga_filename,
 877                               const std::string firmware_filename)
 878   : usrp_basic (which_board, open_tx_interface, fpga_filename, firmware_filename),
 879     d_devhandle (0), d_ephandle (0),
 880     d_bytes_seen (0), d_first_write (true),
 881     d_tx_enable (false)
 882 {
 883   if (!usrp_9862_write_many_all (d_udh, tx_init_regs, sizeof (tx_init_regs))){
 884     fprintf (stderr, "usrp_basic_tx: failed to init AD9862 TX regs\n");
 885     throw std::runtime_error ("usrp_basic_tx/init_9862");
 886   }
 887
 888   if (0){
 889     // FIXME power down 2nd codec tx path
 890     usrp_9862_write (d_udh, 1, REG_TX_PWR_DN,
 891                      (TX_PWR_DN_TX_DIGITAL
 892                       | TX_PWR_DN_TX_ANALOG_BOTH));
 893   }
 894
 895   // Reset the tx path and leave it disabled.
 896   set_tx_enable (false);
 897   usrp_set_fpga_tx_reset (d_udh, true);
 898   usrp_set_fpga_tx_reset (d_udh, false);
 899
 900   set_fpga_tx_sample_rate_divisor (4);  // we're using interp x4
 901
 902   probe_tx_slots (false);
 903
 904   // check fusb buffering parameters
 905
 906   if (fusb_block_size < 0 || fusb_block_size > FUSB_BLOCK_SIZE)
 907     throw std::out_of_range ("usrp_basic_rx: invalid fusb_block_size");
 908
 909   if (fusb_nblocks < 0)
 910     throw std::out_of_range ("usrp_basic_rx: invalid fusb_nblocks");
 911
 912   if (fusb_block_size == 0)
 913     fusb_block_size = FUSB_BLOCK_SIZE;
 914
 915   if (fusb_nblocks == 0)
 916     fusb_nblocks = std::max (1, FUSB_BUFFER_SIZE / fusb_block_size);
 917
 918   d_devhandle = fusb_sysconfig::make_devhandle (d_udh);
 919   d_ephandle = d_devhandle->make_ephandle (USRP_TX_ENDPOINT, false,
 920                                            fusb_block_size, fusb_nblocks);
 921
 922   _write_fpga_reg(FR_ATR_MASK_0, 0); // zero Tx side Auto Transmit/Receive regs
 923   _write_fpga_reg(FR_ATR_TXVAL_0, 0);
 924   _write_fpga_reg(FR_ATR_RXVAL_0, 0);
 925   _write_fpga_reg(FR_ATR_MASK_2, 0);
 926   _write_fpga_reg(FR_ATR_TXVAL_2, 0);
 927   _write_fpga_reg(FR_ATR_RXVAL_2, 0);
 928 }
 929
 930
 931 static unsigned char tx_fini_regs[] = {
 932   REG_TX_PWR_DN,        (TX_PWR_DN_TX_DIGITAL
 933                          | TX_PWR_DN_TX_ANALOG_BOTH),
 934   REG_TX_MODULATOR,     (TX_MODULATOR_DISABLE_NCO
 935                          | TX_MODULATOR_COARSE_MODULATION_NONE)
 936 };
 937
 938 usrp_basic_tx::~usrp_basic_tx ()
 939 {
 940   d_ephandle->stop ();
 941   delete d_ephandle;
 942   delete d_devhandle;
 943
 944   if (!usrp_9862_write_many_all (d_udh, tx_fini_regs, sizeof (tx_fini_regs))){
 945     fprintf (stderr, "usrp_basic_tx: failed to fini AD9862 TX regs\n");
 946   }
 947 }
 948
 949 bool
 950 usrp_basic_tx::start ()
 951 {
 952   if (!usrp_basic::start ())
 953     return false;
 954
 955   if (!set_tx_enable (true)){
 956     fprintf (stderr, "usrp_basic_tx: set_tx_enable failed\n");
 957     usb_strerror ();
 958     return false;
 959   }
 960
 961   if (!d_ephandle->start ()){
 962     fprintf (stderr, "usrp_basic_tx: failed to start end point streaming");
 963     usb_strerror ();
 964     return false;
 965   }
 966
 967   return true;
 968 }
 969
 970 bool
 971 usrp_basic_tx::stop ()
 972 {
 973   bool ok = usrp_basic::stop ();
 974
 975   if (!d_ephandle->stop ()){
 976     fprintf (stderr, "usrp_basic_tx: failed to stop end point streaming");
 977     usb_strerror ();
 978     ok = false;
 979   }
 980
 981   if (!set_tx_enable (false)){
 982     fprintf (stderr, "usrp_basic_tx: set_tx_enable(false) failed\n");
 983     usb_strerror ();
 984     ok = false;
 985   }
 986
 987   return ok;
 988 }
 989
 990 usrp_basic_tx *
 991 usrp_basic_tx::make (int which_board, int fusb_block_size, int fusb_nblocks,
 992                      const std::string fpga_filename,
 993                      const std::string firmware_filename)
 994 {
 995   usrp_basic_tx *u = 0;
 996
 997   try {
 998     u = new usrp_basic_tx (which_board, fusb_block_size, fusb_nblocks,
 999                            fpga_filename, firmware_filename);
1000     return u;
1001   }
1002   catch (...){
1003     delete u;
1004     return 0;
1005   }
1006
1007   return u;
1008 }
1009
1010 bool
1011 usrp_basic_tx::set_fpga_tx_sample_rate_divisor (unsigned int div)
1012 {
1013   return _write_fpga_reg (FR_TX_SAMPLE_RATE_DIV, div - 1);
1014 }
1015
1016 /*!
1017  * \brief Write data to the A/D's via the FPGA.
1018  *
1019  * \p len must be a multiple of 512 bytes.
1020  * \returns number of bytes written or -1 on error.
1021  *
1022  * if \p underrun is non-NULL, it will be set to true iff
1023  * a transmit underrun condition is detected.
1024  */
1025 int
1026 usrp_basic_tx::write (const void *buf, int len, bool *underrun)
1027 {
1028   int   r;
1029
1030   if (underrun)
1031     *underrun = false;
1032
1033   if (len < 0 || (len % 512) != 0){
1034     fprintf (stderr, "usrp_basic_tx::write: invalid length = %d\n", len);
1035     return -1;
1036   }
1037
1038   r = d_ephandle->write (buf, len);
1039   if (r > 0)
1040     d_bytes_seen += r;
1041
1042   /*
1043    * In many cases, the FPGA reports an tx underrun right after we
1044    * enable the Tx path.  If this is our first write, check for the
1045    * underrun to clear the condition, then ignore the result.
1046    */
1047   if (d_first_write && d_bytes_seen >= 4 * FUSB_BLOCK_SIZE){
1048     d_first_write = false;
1049     bool bogus_underrun;
1050     usrp_check_tx_underrun (d_udh, &bogus_underrun);
1051   }
1052
1053   if (underrun != 0 && d_bytes_seen >= d_bytes_per_poll){
1054     d_bytes_seen = 0;
1055     if (!usrp_check_tx_underrun (d_udh, underrun)){
1056       fprintf (stderr, "usrp_basic_tx: usrp_check_tx_underrun failed\n");
1057       usb_strerror ();
1058     }
1059   }
1060
1061   return r;
1062 }
1063
1064 void
1065 usrp_basic_tx::wait_for_completion ()
1066 {
1067   d_ephandle->wait_for_completion ();
1068 }
1069
1070 bool
1071 usrp_basic_tx::set_tx_enable (bool on)
1072 {
1073   d_tx_enable = on;
1074   // fprintf (stderr, "set_tx_enable %d\n", on);
1075   return usrp_set_fpga_tx_enable (d_udh, on);
1076 }
1077
1078 // conditional disable, return prev state
1079 bool
1080 usrp_basic_tx::disable_tx ()
1081 {
1082   bool enabled = tx_enable ();
1083   if (enabled)
1084     set_tx_enable (false);
1085   return enabled;
1086 }
1087
1088 // conditional set
1089 void
1090 usrp_basic_tx::restore_tx (bool on)
1091 {
1092   if (on != tx_enable ())
1093     set_tx_enable (on);
1094 }
1095
1096 bool
1097 usrp_basic_tx::set_pga (int which, double gain)
1098 {
1099   if (which < 0 || which > 3)
1100     return false;
1101
1102   gain = std::max (pga_min (), gain);
1103   gain = std::min (pga_max (), gain);
1104
1105   int codec = which >> 1;       // 0 and 1 are same, as are 2 and 3
1106
1107   int int_gain = (int) rint ((gain - pga_min ()) / pga_db_per_step());
1108
1109   return _write_9862 (codec, REG_TX_PGA, int_gain);
1110 }
1111
1112 double
1113 usrp_basic_tx::pga (int which) const
1114 {
1115   if (which < 0 || which > 3)
1116     return READ_FAILED;
1117
1118   int codec = which >> 1;
1119   unsigned char v;
1120   bool ok = _read_9862 (codec, REG_TX_PGA, &v);
1121   if (!ok)
1122     return READ_FAILED;
1123
1124   return (pga_db_per_step() * v) + pga_min();
1125 }
1126
1127 void
1128 usrp_basic_tx::probe_tx_slots (bool verbose)
1129 {
1130   struct usrp_dboard_eeprom     eeprom;
1131   static int slot_id_map[2] = { SLOT_TX_A, SLOT_TX_B };
1132   static const char *slot_name[2] = { "TX d'board A", "TX d'board B" };
1133
1134   for (int i = 0; i < 2; i++){
1135     int slot_id = slot_id_map [i];
1136     const char *msg = 0;
1137     usrp_dbeeprom_status_t s = usrp_read_dboard_eeprom (d_udh, slot_id, &eeprom);
1138
1139     switch (s){
1140     case UDBE_OK:
1141       d_dbid[i] = eeprom.id;
1142       msg = usrp_dbid_to_string (eeprom.id).c_str ();
1143       // FIXME, figure out interpretation of dc offset for TX d'boards
1144       // offset = (eeprom.offset[1] << 16) | (eeprom.offset[0] & 0xffff);
1145       _write_fpga_reg (slot_id_to_oe_reg(slot_id), (0xffff << 16) | eeprom.oe);
1146       _write_fpga_reg (slot_id_to_io_reg(slot_id), (0xffff << 16) | 0x0000);
1147       break;
1148
1149     case UDBE_NO_EEPROM:
1150       d_dbid[i] = -1;
1151       msg = "<none>";
1152       _write_fpga_reg (slot_id_to_oe_reg(slot_id), (0xffff << 16) | 0x0000);
1153       _write_fpga_reg (slot_id_to_io_reg(slot_id), (0xffff << 16) | 0x0000);
1154       break;
1155
1156     case UDBE_INVALID_EEPROM:
1157       d_dbid[i] = -2;
1158       msg = "Invalid EEPROM contents";
1159       _write_fpga_reg (slot_id_to_oe_reg(slot_id), (0xffff << 16) | 0x0000);
1160       _write_fpga_reg (slot_id_to_io_reg(slot_id), (0xffff << 16) | 0x0000);
1161       break;
1162
1163     case UDBE_BAD_SLOT:
1164     default:
1165       assert (0);
1166     }
1167
1168     if (verbose){
1169       fflush (stdout);
1170       fprintf (stderr, "%s: %s\n", slot_name[i], msg);
1171     }
1172   }
1173 }
1174
1175 bool
1176 usrp_basic_tx::_write_oe (int which_dboard, int value, int mask)
1177 {
1178   if (! (0 <= which_dboard && which_dboard <= 1))
1179     return false;
1180
1181   return _write_fpga_reg (slot_id_to_oe_reg (dboard_to_slot (which_dboard)),
1182                           (mask << 16) | (value & 0xffff));
1183 }
1184
1185 bool
1186 usrp_basic_tx::write_io (int which_dboard, int value, int mask)
1187 {
1188   if (! (0 <= which_dboard && which_dboard <= 1))
1189     return false;
1190
1191   return _write_fpga_reg (slot_id_to_io_reg (dboard_to_slot (which_dboard)),
1192                           (mask << 16) | (value & 0xffff));
1193 }
1194
1195 bool
1196 usrp_basic_tx::read_io (int which_dboard, int *value)
1197 {
1198   if (! (0 <= which_dboard && which_dboard <= 1))
1199     return false;
1200
1201   int t;
1202   int reg = which_dboard + 1;   // FIXME, *very* magic number (fix in serial_io.v)
1203   bool ok = _read_fpga_reg (reg, &t);
1204   if (!ok)
1205     return false;
1206
1207   *value = t & 0xffff;          // FIXME, more magic
1208   return true;
1209 }
1210
1211 int
1212 usrp_basic_tx::read_io (int which_dboard)
1213 {
1214   int   value;
1215   if (!read_io (which_dboard, &value))
1216     return READ_FAILED;
1217   return value;
1218 }
1219
1220 bool
1221 usrp_basic_tx::write_aux_dac (int which_dboard, int which_dac, int value)
1222 {
1223   return usrp_basic::write_aux_dac (dboard_to_slot (which_dboard),
1224                                     which_dac, value);
1225 }
1226
1227 bool
1228 usrp_basic_tx::read_aux_adc (int which_dboard, int which_adc, int *value)
1229 {
1230   return usrp_basic::read_aux_adc (dboard_to_slot (which_dboard),
1231                                    which_adc, value);
1232 }
1233
1234 int
1235 usrp_basic_tx::read_aux_adc (int which_dboard, int which_adc)
1236 {
1237   return usrp_basic::read_aux_adc (dboard_to_slot (which_dboard), which_adc);
1238 }
1239
1240 int
1241 usrp_basic_tx::block_size () const { return d_ephandle->block_size(); }
1242