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 2, 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_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 (!d_ephandle->stop()){
 545     fprintf (stderr, "usrp_basic_rx: failed to stop end point streaming");
 546     usb_strerror ();
 547     ok = false;
 548   }
 549   if (!set_rx_enable(false)){
 550     fprintf (stderr, "usrp_basic_rx: set_rx_enable(false) failed\n");
 551     usb_strerror ();
 552     ok = false;
 553   }
 554   return false;
 555 }
 556
 557 usrp_basic_rx *
 558 usrp_basic_rx::make (int which_board, int fusb_block_size, int fusb_nblocks,
 559                      const std::string fpga_filename,
 560                      const std::string firmware_filename)
 561 {
 562   usrp_basic_rx *u = 0;
 563
 564   try {
 565     u = new usrp_basic_rx (which_board, fusb_block_size, fusb_nblocks,
 566                            fpga_filename, firmware_filename);
 567     return u;
 568   }
 569   catch (...){
 570     delete u;
 571     return 0;
 572   }
 573
 574   return u;
 575 }
 576
 577 bool
 578 usrp_basic_rx::set_fpga_rx_sample_rate_divisor (unsigned int div)
 579 {
 580   return _write_fpga_reg (FR_RX_SAMPLE_RATE_DIV, div - 1);
 581 }
 582
 583
 584 /*
 585  * \brief read data from the D/A's via the FPGA.
 586  * \p len must be a multiple of 512 bytes.
 587  *
 588  * \returns the number of bytes read, or -1 on error.
 589  *
 590  * If overrun is non-NULL it will be set true iff an RX overrun is detected.
 591  */
 592 int
 593 usrp_basic_rx::read (void *buf, int len, bool *overrun)
 594 {
 595   int   r;
 596
 597   if (overrun)
 598     *overrun = false;
 599
 600   if (len < 0 || (len % 512) != 0){
 601     fprintf (stderr, "usrp_basic_rx::read: invalid length = %d\n", len);
 602     return -1;
 603   }
 604
 605   r = d_ephandle->read (buf, len);
 606   if (r > 0)
 607     d_bytes_seen += r;
 608
 609   /*
 610    * In many cases, the FPGA reports an rx overrun right after we
 611    * enable the Rx path.  If this is our first read, check for the
 612    * overrun to clear the condition, then ignore the result.
 613    */
 614   if (0 && d_first_read){       // FIXME
 615     d_first_read = false;
 616     bool bogus_overrun;
 617     usrp_check_rx_overrun (d_udh, &bogus_overrun);
 618   }
 619
 620   if (overrun != 0 && d_bytes_seen >= d_bytes_per_poll){
 621     d_bytes_seen = 0;
 622     if (!usrp_check_rx_overrun (d_udh, overrun)){
 623       fprintf (stderr, "usrp_basic_rx: usrp_check_rx_overrun failed\n");
 624       usb_strerror ();
 625     }
 626   }
 627
 628   return r;
 629 }
 630
 631 bool
 632 usrp_basic_rx::set_rx_enable (bool on)
 633 {
 634   d_rx_enable = on;
 635   return usrp_set_fpga_rx_enable (d_udh, on);
 636 }
 637
 638 // conditional disable, return prev state
 639 bool
 640 usrp_basic_rx::disable_rx ()
 641 {
 642   bool enabled = rx_enable ();
 643   if (enabled)
 644     set_rx_enable (false);
 645   return enabled;
 646 }
 647
 648 // conditional set
 649 void
 650 usrp_basic_rx::restore_rx (bool on)
 651 {
 652   if (on != rx_enable ())
 653     set_rx_enable (on);
 654 }
 655
 656 bool
 657 usrp_basic_rx::set_pga (int which, double gain)
 658 {
 659   if (which < 0 || which > 3)
 660     return false;
 661
 662   gain = std::max (pga_min (), gain);
 663   gain = std::min (pga_max (), gain);
 664
 665   int codec = which >> 1;
 666   int reg = (which & 1) == 0 ? REG_RX_A : REG_RX_B;
 667
 668   // read current value to get input buffer bypass flag.
 669   unsigned char cur_rx;
 670   if (!_read_9862 (codec, reg, &cur_rx))
 671     return false;
 672
 673   int int_gain = (int) rint ((gain - pga_min ()) / pga_db_per_step());
 674
 675   cur_rx = (cur_rx & RX_X_BYPASS_INPUT_BUFFER) | (int_gain & 0x7f);
 676   return _write_9862 (codec, reg, cur_rx);
 677 }
 678
 679 double
 680 usrp_basic_rx::pga (int which) const
 681 {
 682   if (which < 0 || which > 3)
 683     return READ_FAILED;
 684
 685   int codec = which >> 1;
 686   int reg = (which & 1) == 0 ? REG_RX_A : REG_RX_B;
 687   unsigned char v;
 688   bool ok = _read_9862 (codec, reg, &v);
 689   if (!ok)
 690     return READ_FAILED;
 691
 692   return (pga_db_per_step() * (v & 0x1f)) + pga_min();
 693 }
 694
 695 static int
 696 slot_id_to_oe_reg (int slot_id)
 697 {
 698   static int reg[4]  = { FR_OE_0, FR_OE_1, FR_OE_2, FR_OE_3 };
 699   assert (0 <= slot_id && slot_id < 4);
 700   return reg[slot_id];
 701 }
 702
 703 static int
 704 slot_id_to_io_reg (int slot_id)
 705 {
 706   static int reg[4]  = { FR_IO_0, FR_IO_1, FR_IO_2, FR_IO_3 };
 707   assert (0 <= slot_id && slot_id < 4);
 708   return reg[slot_id];
 709 }
 710
 711 void
 712 usrp_basic_rx::probe_rx_slots (bool verbose)
 713 {
 714   struct usrp_dboard_eeprom     eeprom;
 715   static int slot_id_map[2] = { SLOT_RX_A, SLOT_RX_B };
 716   static const char *slot_name[2] = { "RX d'board A", "RX d'board B" };
 717
 718   for (int i = 0; i < 2; i++){
 719     int slot_id = slot_id_map [i];
 720     const char *msg = 0;
 721     usrp_dbeeprom_status_t s = usrp_read_dboard_eeprom (d_udh, slot_id, &eeprom);
 722
 723     switch (s){
 724     case UDBE_OK:
 725       d_dbid[i] = eeprom.id;
 726       msg = usrp_dbid_to_string (eeprom.id).c_str ();
 727       set_adc_offset (2*i+0, eeprom.offset[0]);
 728       set_adc_offset (2*i+1, eeprom.offset[1]);
 729       _write_fpga_reg (slot_id_to_oe_reg(slot_id), (0xffff << 16) | eeprom.oe);
 730       _write_fpga_reg (slot_id_to_io_reg(slot_id), (0xffff << 16) | 0x0000);
 731       break;
 732
 733     case UDBE_NO_EEPROM:
 734       d_dbid[i] = -1;
 735       msg = "<none>";
 736       _write_fpga_reg (slot_id_to_oe_reg(slot_id), (0xffff << 16) | 0x0000);
 737       _write_fpga_reg (slot_id_to_io_reg(slot_id), (0xffff << 16) | 0x0000);
 738       break;
 739
 740     case UDBE_INVALID_EEPROM:
 741       d_dbid[i] = -2;
 742       msg = "Invalid EEPROM contents";
 743       _write_fpga_reg (slot_id_to_oe_reg(slot_id), (0xffff << 16) | 0x0000);
 744       _write_fpga_reg (slot_id_to_io_reg(slot_id), (0xffff << 16) | 0x0000);
 745       break;
 746
 747     case UDBE_BAD_SLOT:
 748     default:
 749       assert (0);
 750     }
 751
 752     if (verbose){
 753       fflush (stdout);
 754       fprintf (stderr, "%s: %s\n", slot_name[i], msg);
 755     }
 756   }
 757 }
 758
 759 bool
 760 usrp_basic_rx::_write_oe (int which_dboard, int value, int mask)
 761 {
 762   if (! (0 <= which_dboard && which_dboard <= 1))
 763     return false;
 764
 765   return _write_fpga_reg (slot_id_to_oe_reg (dboard_to_slot (which_dboard)),
 766                           (mask << 16) | (value & 0xffff));
 767 }
 768
 769 bool
 770 usrp_basic_rx::write_io (int which_dboard, int value, int mask)
 771 {
 772   if (! (0 <= which_dboard && which_dboard <= 1))
 773     return false;
 774
 775   return _write_fpga_reg (slot_id_to_io_reg (dboard_to_slot (which_dboard)),
 776                           (mask << 16) | (value & 0xffff));
 777 }
 778
 779 bool
 780 usrp_basic_rx::read_io (int which_dboard, int *value)
 781 {
 782   if (! (0 <= which_dboard && which_dboard <= 1))
 783     return false;
 784
 785   int t;
 786   int reg = which_dboard + 1;   // FIXME, *very* magic number (fix in serial_io.v)
 787   bool ok = _read_fpga_reg (reg, &t);
 788   if (!ok)
 789     return false;
 790
 791   *value = (t >> 16) & 0xffff;  // FIXME, more magic
 792   return true;
 793 }
 794
 795 int
 796 usrp_basic_rx::read_io (int which_dboard)
 797 {
 798   int   value;
 799   if (!read_io (which_dboard, &value))
 800     return READ_FAILED;
 801   return value;
 802 }
 803
 804 bool
 805 usrp_basic_rx::write_aux_dac (int which_dboard, int which_dac, int value)
 806 {
 807   return usrp_basic::write_aux_dac (dboard_to_slot (which_dboard),
 808                                     which_dac, value);
 809 }
 810
 811 bool
 812 usrp_basic_rx::read_aux_adc (int which_dboard, int which_adc, int *value)
 813 {
 814   return usrp_basic::read_aux_adc (dboard_to_slot (which_dboard),
 815                                    which_adc, value);
 816 }
 817
 818 int
 819 usrp_basic_rx::read_aux_adc (int which_dboard, int which_adc)
 820 {
 821   return usrp_basic::read_aux_adc (dboard_to_slot (which_dboard), which_adc);
 822 }
 823
 824 int
 825 usrp_basic_rx::block_size () const { return d_ephandle->block_size(); }
 826
 827 bool
 828 usrp_basic_rx::set_dc_offset_cl_enable(int bits, int mask)
 829 {
 830   return _write_fpga_reg(FR_DC_OFFSET_CL_EN,
 831                          (d_fpga_shadows[FR_DC_OFFSET_CL_EN] & ~mask) | (bits & mask));
 832 }
 833
 834 ////////////////////////////////////////////////////////////////
 835 //
 836 //                         usrp_basic_tx
 837 //
 838 ////////////////////////////////////////////////////////////////
 839
 840
 841 //
 842 // DAC input rate 64 MHz interleaved for a total input rate of 128 MHz
 843 // DAC input is latched on rising edge of CLKOUT2
 844 // NCO is disabled
 845 // interpolate 2x
 846 // coarse modulator disabled
 847 //
 848
 849 static unsigned char tx_init_regs[] = {
 850   REG_TX_PWR_DN,        0,
 851   REG_TX_A_OFFSET_LO,   0,
 852   REG_TX_A_OFFSET_HI,   0,
 853   REG_TX_B_OFFSET_LO,   0,
 854   REG_TX_B_OFFSET_HI,   0,
 855   REG_TX_A_GAIN,        (TX_X_GAIN_COARSE_FULL | 0),
 856   REG_TX_B_GAIN,        (TX_X_GAIN_COARSE_FULL | 0),
 857   REG_TX_PGA,           0xff,                   // maximum gain (0 dB)
 858   REG_TX_MISC,          0,
 859   REG_TX_IF,            (TX_IF_USE_CLKOUT1
 860                          | TX_IF_I_FIRST
 861                          | TX_IF_INV_TX_SYNC
 862                          | TX_IF_2S_COMP
 863                          | TX_IF_INTERLEAVED),
 864   REG_TX_DIGITAL,       (TX_DIGITAL_2_DATA_PATHS
 865                          | TX_DIGITAL_INTERPOLATE_4X),
 866   REG_TX_MODULATOR,     (TX_MODULATOR_DISABLE_NCO
 867                          | TX_MODULATOR_COARSE_MODULATION_NONE),
 868   REG_TX_NCO_FTW_7_0,   0,
 869   REG_TX_NCO_FTW_15_8,  0,
 870   REG_TX_NCO_FTW_23_16, 0
 871 };
 872
 873 usrp_basic_tx::usrp_basic_tx (int which_board, int fusb_block_size, int fusb_nblocks,
 874                               const std::string fpga_filename,
 875                               const std::string firmware_filename)
 876   : usrp_basic (which_board, open_tx_interface, fpga_filename, firmware_filename),
 877     d_devhandle (0), d_ephandle (0),
 878     d_bytes_seen (0), d_first_write (true),
 879     d_tx_enable (false)
 880 {
 881   if (!usrp_9862_write_many_all (d_udh, tx_init_regs, sizeof (tx_init_regs))){
 882     fprintf (stderr, "usrp_basic_tx: failed to init AD9862 TX regs\n");
 883     throw std::runtime_error ("usrp_basic_tx/init_9862");
 884   }
 885
 886   if (0){
 887     // FIXME power down 2nd codec tx path
 888     usrp_9862_write (d_udh, 1, REG_TX_PWR_DN,
 889                      (TX_PWR_DN_TX_DIGITAL
 890                       | TX_PWR_DN_TX_ANALOG_BOTH));
 891   }
 892
 893   // Reset the tx path and leave it disabled.
 894   set_tx_enable (false);
 895   usrp_set_fpga_tx_reset (d_udh, true);
 896   usrp_set_fpga_tx_reset (d_udh, false);
 897
 898   set_fpga_tx_sample_rate_divisor (4);  // we're using interp x4
 899
 900   probe_tx_slots (false);
 901
 902   // check fusb buffering parameters
 903
 904   if (fusb_block_size < 0 || fusb_block_size > FUSB_BLOCK_SIZE)
 905     throw std::out_of_range ("usrp_basic_rx: invalid fusb_block_size");
 906
 907   if (fusb_nblocks < 0)
 908     throw std::out_of_range ("usrp_basic_rx: invalid fusb_nblocks");
 909
 910   if (fusb_block_size == 0)
 911     fusb_block_size = FUSB_BLOCK_SIZE;
 912
 913   if (fusb_nblocks == 0)
 914     fusb_nblocks = std::max (1, FUSB_BUFFER_SIZE / fusb_block_size);
 915
 916   d_devhandle = fusb_sysconfig::make_devhandle (d_udh);
 917   d_ephandle = d_devhandle->make_ephandle (USRP_TX_ENDPOINT, false,
 918                                            fusb_block_size, fusb_nblocks);
 919
 920   _write_fpga_reg(FR_ATR_MASK_0, 0); // zero Tx side Auto Transmit/Receive regs
 921   _write_fpga_reg(FR_ATR_TXVAL_0, 0);
 922   _write_fpga_reg(FR_ATR_RXVAL_0, 0);
 923   _write_fpga_reg(FR_ATR_MASK_2, 0);
 924   _write_fpga_reg(FR_ATR_TXVAL_2, 0);
 925   _write_fpga_reg(FR_ATR_RXVAL_2, 0);
 926 }
 927
 928
 929 static unsigned char tx_fini_regs[] = {
 930   REG_TX_PWR_DN,        (TX_PWR_DN_TX_DIGITAL
 931                          | TX_PWR_DN_TX_ANALOG_BOTH),
 932   REG_TX_MODULATOR,     (TX_MODULATOR_DISABLE_NCO
 933                          | TX_MODULATOR_COARSE_MODULATION_NONE)
 934 };
 935
 936 usrp_basic_tx::~usrp_basic_tx ()
 937 {
 938   d_ephandle->stop ();
 939   delete d_ephandle;
 940   delete d_devhandle;
 941
 942   if (!usrp_9862_write_many_all (d_udh, tx_fini_regs, sizeof (tx_fini_regs))){
 943     fprintf (stderr, "usrp_basic_tx: failed to fini AD9862 TX regs\n");
 944   }
 945 }
 946
 947 bool
 948 usrp_basic_tx::start ()
 949 {
 950   if (!usrp_basic::start ())
 951     return false;
 952
 953   if (!set_tx_enable (true)){
 954     fprintf (stderr, "usrp_basic_tx: set_tx_enable failed\n");
 955     usb_strerror ();
 956     return false;
 957   }
 958
 959   if (!d_ephandle->start ()){
 960     fprintf (stderr, "usrp_basic_tx: failed to start end point streaming");
 961     usb_strerror ();
 962     return false;
 963   }
 964
 965   return true;
 966 }
 967
 968 bool
 969 usrp_basic_tx::stop ()
 970 {
 971   bool ok = usrp_basic::stop ();
 972
 973   if (!set_tx_enable (false)){
 974     fprintf (stderr, "usrp_basic_tx: set_tx_enable(false) failed\n");
 975     usb_strerror ();
 976     ok = false;
 977   }
 978   if (!d_ephandle->stop ()){
 979     fprintf (stderr, "usrp_basic_tx: failed to stop end point streaming");
 980     usb_strerror ();
 981     ok = false;
 982   }
 983   return ok;
 984 }
 985
 986 usrp_basic_tx *
 987 usrp_basic_tx::make (int which_board, int fusb_block_size, int fusb_nblocks,
 988                      const std::string fpga_filename,
 989                      const std::string firmware_filename)
 990 {
 991   usrp_basic_tx *u = 0;
 992
 993   try {
 994     u = new usrp_basic_tx (which_board, fusb_block_size, fusb_nblocks,
 995                            fpga_filename, firmware_filename);
 996     return u;
 997   }
 998   catch (...){
 999     delete u;
1000     return 0;
1001   }
1002
1003   return u;
1004 }
1005
1006 bool
1007 usrp_basic_tx::set_fpga_tx_sample_rate_divisor (unsigned int div)
1008 {
1009   return _write_fpga_reg (FR_TX_SAMPLE_RATE_DIV, div - 1);
1010 }
1011
1012 /*!
1013  * \brief Write data to the A/D's via the FPGA.
1014  *
1015  * \p len must be a multiple of 512 bytes.
1016  * \returns number of bytes written or -1 on error.
1017  *
1018  * if \p underrun is non-NULL, it will be set to true iff
1019  * a transmit underrun condition is detected.
1020  */
1021 int
1022 usrp_basic_tx::write (const void *buf, int len, bool *underrun)
1023 {
1024   int   r;
1025
1026   if (underrun)
1027     *underrun = false;
1028
1029   if (len < 0 || (len % 512) != 0){
1030     fprintf (stderr, "usrp_basic_tx::write: invalid length = %d\n", len);
1031     return -1;
1032   }
1033
1034   r = d_ephandle->write (buf, len);
1035   if (r > 0)
1036     d_bytes_seen += r;
1037
1038   /*
1039    * In many cases, the FPGA reports an tx underrun right after we
1040    * enable the Tx path.  If this is our first write, check for the
1041    * underrun to clear the condition, then ignore the result.
1042    */
1043   if (d_first_write && d_bytes_seen >= 4 * FUSB_BLOCK_SIZE){
1044     d_first_write = false;
1045     bool bogus_underrun;
1046     usrp_check_tx_underrun (d_udh, &bogus_underrun);
1047   }
1048
1049   if (underrun != 0 && d_bytes_seen >= d_bytes_per_poll){
1050     d_bytes_seen = 0;
1051     if (!usrp_check_tx_underrun (d_udh, underrun)){
1052       fprintf (stderr, "usrp_basic_tx: usrp_check_tx_underrun failed\n");
1053       usb_strerror ();
1054     }
1055   }
1056
1057   return r;
1058 }
1059
1060 void
1061 usrp_basic_tx::wait_for_completion ()
1062 {
1063   d_ephandle->wait_for_completion ();
1064 }
1065
1066 bool
1067 usrp_basic_tx::set_tx_enable (bool on)
1068 {
1069   d_tx_enable = on;
1070   // fprintf (stderr, "set_tx_enable %d\n", on);
1071   return usrp_set_fpga_tx_enable (d_udh, on);
1072 }
1073
1074 // conditional disable, return prev state
1075 bool
1076 usrp_basic_tx::disable_tx ()
1077 {
1078   bool enabled = tx_enable ();
1079   if (enabled)
1080     set_tx_enable (false);
1081   return enabled;
1082 }
1083
1084 // conditional set
1085 void
1086 usrp_basic_tx::restore_tx (bool on)
1087 {
1088   if (on != tx_enable ())
1089     set_tx_enable (on);
1090 }
1091
1092 bool
1093 usrp_basic_tx::set_pga (int which, double gain)
1094 {
1095   if (which < 0 || which > 3)
1096     return false;
1097
1098   gain = std::max (pga_min (), gain);
1099   gain = std::min (pga_max (), gain);
1100
1101   int codec = which >> 1;       // 0 and 1 are same, as are 2 and 3
1102
1103   int int_gain = (int) rint ((gain - pga_min ()) / pga_db_per_step());
1104
1105   return _write_9862 (codec, REG_TX_PGA, int_gain);
1106 }
1107
1108 double
1109 usrp_basic_tx::pga (int which) const
1110 {
1111   if (which < 0 || which > 3)
1112     return READ_FAILED;
1113
1114   int codec = which >> 1;
1115   unsigned char v;
1116   bool ok = _read_9862 (codec, REG_TX_PGA, &v);
1117   if (!ok)
1118     return READ_FAILED;
1119
1120   return (pga_db_per_step() * v) + pga_min();
1121 }
1122
1123 void
1124 usrp_basic_tx::probe_tx_slots (bool verbose)
1125 {
1126   struct usrp_dboard_eeprom     eeprom;
1127   static int slot_id_map[2] = { SLOT_TX_A, SLOT_TX_B };
1128   static const char *slot_name[2] = { "TX d'board A", "TX d'board B" };
1129
1130   for (int i = 0; i < 2; i++){
1131     int slot_id = slot_id_map [i];
1132     const char *msg = 0;
1133     usrp_dbeeprom_status_t s = usrp_read_dboard_eeprom (d_udh, slot_id, &eeprom);
1134
1135     switch (s){
1136     case UDBE_OK:
1137       d_dbid[i] = eeprom.id;
1138       msg = usrp_dbid_to_string (eeprom.id).c_str ();
1139       // FIXME, figure out interpretation of dc offset for TX d'boards
1140       // offset = (eeprom.offset[1] << 16) | (eeprom.offset[0] & 0xffff);
1141       _write_fpga_reg (slot_id_to_oe_reg(slot_id), (0xffff << 16) | eeprom.oe);
1142       _write_fpga_reg (slot_id_to_io_reg(slot_id), (0xffff << 16) | 0x0000);
1143       break;
1144
1145     case UDBE_NO_EEPROM:
1146       d_dbid[i] = -1;
1147       msg = "<none>";
1148       _write_fpga_reg (slot_id_to_oe_reg(slot_id), (0xffff << 16) | 0x0000);
1149       _write_fpga_reg (slot_id_to_io_reg(slot_id), (0xffff << 16) | 0x0000);
1150       break;
1151
1152     case UDBE_INVALID_EEPROM:
1153       d_dbid[i] = -2;
1154       msg = "Invalid EEPROM contents";
1155       _write_fpga_reg (slot_id_to_oe_reg(slot_id), (0xffff << 16) | 0x0000);
1156       _write_fpga_reg (slot_id_to_io_reg(slot_id), (0xffff << 16) | 0x0000);
1157       break;
1158
1159     case UDBE_BAD_SLOT:
1160     default:
1161       assert (0);
1162     }
1163
1164     if (verbose){
1165       fflush (stdout);
1166       fprintf (stderr, "%s: %s\n", slot_name[i], msg);
1167     }
1168   }
1169 }
1170
1171 bool
1172 usrp_basic_tx::_write_oe (int which_dboard, int value, int mask)
1173 {
1174   if (! (0 <= which_dboard && which_dboard <= 1))
1175     return false;
1176
1177   return _write_fpga_reg (slot_id_to_oe_reg (dboard_to_slot (which_dboard)),
1178                           (mask << 16) | (value & 0xffff));
1179 }
1180
1181 bool
1182 usrp_basic_tx::write_io (int which_dboard, int value, int mask)
1183 {
1184   if (! (0 <= which_dboard && which_dboard <= 1))
1185     return false;
1186
1187   return _write_fpga_reg (slot_id_to_io_reg (dboard_to_slot (which_dboard)),
1188                           (mask << 16) | (value & 0xffff));
1189 }
1190
1191 bool
1192 usrp_basic_tx::read_io (int which_dboard, int *value)
1193 {
1194   if (! (0 <= which_dboard && which_dboard <= 1))
1195     return false;
1196
1197   int t;
1198   int reg = which_dboard + 1;   // FIXME, *very* magic number (fix in serial_io.v)
1199   bool ok = _read_fpga_reg (reg, &t);
1200   if (!ok)
1201     return false;
1202
1203   *value = t & 0xffff;          // FIXME, more magic
1204   return true;
1205 }
1206
1207 int
1208 usrp_basic_tx::read_io (int which_dboard)
1209 {
1210   int   value;
1211   if (!read_io (which_dboard, &value))
1212     return READ_FAILED;
1213   return value;
1214 }
1215
1216 bool
1217 usrp_basic_tx::write_aux_dac (int which_dboard, int which_dac, int value)
1218 {
1219   return usrp_basic::write_aux_dac (dboard_to_slot (which_dboard),
1220                                     which_dac, value);
1221 }
1222
1223 bool
1224 usrp_basic_tx::read_aux_adc (int which_dboard, int which_adc, int *value)
1225 {
1226   return usrp_basic::read_aux_adc (dboard_to_slot (which_dboard),
1227                                    which_adc, value);
1228 }
1229
1230 int
1231 usrp_basic_tx::read_aux_adc (int which_dboard, int which_adc)
1232 {
1233   return usrp_basic::read_aux_adc (dboard_to_slot (which_dboard), which_adc);
1234 }
1235
1236 int
1237 usrp_basic_tx::block_size () const { return d_ephandle->block_size(); }
1238