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

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright 2003,2004,2006,2009 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/usrp_prims.h"
  28 #include "usrp_commands.h"
  29 #include "usrp_ids.h"
  30 #include "usrp_i2c_addr.h"
  31 #include "fpga_regs_common.h"
  32 #include "fpga_regs_standard.h"
  33 #include <errno.h>
  34 #include <stdio.h>
  35 #include <unistd.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <ctype.h>
  39 #include <time.h>               // FIXME should check with autoconf (nanosleep)
  40 #include <algorithm>
  41 #include <ad9862.h>
  42 #include <assert.h>
  43
  44 #ifdef HAVE_LIBUSB_1
  45 #include <libusb-1.0/libusb.h>
  46 #else
  47 #include <usb.h>
  48 #endif
  49
  50 extern "C" {
  51 #include "md5.h"
  52 };
  53
  54 #define VERBOSE 0
  55
  56 using namespace ad9862;
  57
  58 static const int FIRMWARE_HASH_SLOT     = 0;
  59 static const int FPGA_HASH_SLOT         = 1;
  60
  61 static const int hash_slot_addr[2] = {
  62   USRP_HASH_SLOT_0_ADDR,
  63   USRP_HASH_SLOT_1_ADDR
  64 };
  65
  66 static const char *default_firmware_filename = "std.ihx";
  67 static const char *default_fpga_filename     = "std_2rxhb_2tx.rbf";
  68
  69
  70 #include "std_paths.h"
  71 #include <stdio.h>
  72
  73 char *
  74 find_file (const char *filename, int hw_rev)
  75 {
  76   const char **sp = std_paths;
  77   static char path[1000];
  78   char *s;
  79
  80   s = getenv("USRP_PATH");
  81   if (s) {
  82     snprintf (path, sizeof (path), "%s/rev%d/%s", s, hw_rev, filename);
  83     if (access (path, R_OK) == 0)
  84       return path;
  85   }
  86
  87   while (*sp){
  88     snprintf (path, sizeof (path), "%s/rev%d/%s", *sp, hw_rev, filename);
  89     if (access (path, R_OK) == 0)
  90       return path;
  91     sp++;
  92   }
  93   return 0;
  94 }
  95
  96 const char *
  97 get_proto_filename(const std::string user_filename, const char *env_var, const char *def)
  98 {
  99   if (user_filename.length() != 0)
 100     return user_filename.c_str();
 101
 102   char *s = getenv(env_var);
 103   if (s && *s)
 104     return s;
 105
 106   return def;
 107 }
 108
 109
 110 void power_down_9862s (libusb_device_handle *udh);
 111
 112 // ----------------------------------------------------------------
 113
 114 bool
 115 usrp_usrp0_p (libusb_device *q)
 116 {
 117   return usrp_usrp_p (q) && usrp_hw_rev (q) == 0;
 118 }
 119
 120 bool
 121 usrp_usrp1_p (libusb_device *q)
 122 {
 123   return usrp_usrp_p (q) && usrp_hw_rev (q) == 1;
 124 }
 125
 126 bool
 127 usrp_usrp2_p (libusb_device *q)
 128 {
 129   return usrp_usrp_p (q) && usrp_hw_rev (q) == 2;
 130 }
 131
 132
 133 bool
 134 usrp_unconfigured_usrp_p (libusb_device *q)
 135 {
 136   return usrp_usrp_p (q) && !_usrp_configured_p (q);
 137 }
 138
 139 bool
 140 usrp_configured_usrp_p (libusb_device *q)
 141 {
 142   return usrp_usrp_p (q) && _usrp_configured_p (q);
 143 }
 144
 145 libusb_device_handle *
 146 usrp_open_cmd_interface (libusb_device *dev)
 147 {
 148   return usrp_open_interface (dev, USRP_CMD_INTERFACE, USRP_CMD_ALTINTERFACE);
 149 }
 150
 151 libusb_device_handle *
 152 usrp_open_rx_interface (libusb_device *dev)
 153 {
 154   return usrp_open_interface (dev, USRP_RX_INTERFACE, USRP_RX_ALTINTERFACE);
 155 }
 156
 157 libusb_device_handle *
 158 usrp_open_tx_interface (libusb_device *dev)
 159 {
 160   return usrp_open_interface (dev, USRP_TX_INTERFACE, USRP_TX_ALTINTERFACE);
 161 }
 162
 163
 164 // ----------------------------------------------------------------
 165 // whack the CPUCS register using the upload RAM vendor extension
 166
 167 static bool
 168 reset_cpu (libusb_device_handle *udh, bool reset_p)
 169 {
 170   unsigned char v;
 171
 172   if (reset_p)
 173     v = 1;              // hold processor in reset
 174   else
 175     v = 0;              // release reset
 176
 177   return write_internal_ram (udh, &v, 0xE600, 1);
 178 }
 179
 180 // ----------------------------------------------------------------
 181 // Load intel format file into cypress FX2 (8051)
 182
 183 static bool
 184 _usrp_load_firmware (libusb_device_handle *udh, const char *filename,
 185                      unsigned char hash[USRP_HASH_SIZE])
 186 {
 187   FILE  *f = fopen (filename, "ra");
 188   if (f == 0){
 189     perror (filename);
 190     return false;
 191   }
 192
 193   if (!reset_cpu (udh, true))   // hold CPU in reset while loading firmware
 194     goto fail;
 195
 196
 197   char s[1024];
 198   int length;
 199   int addr;
 200   int type;
 201   unsigned char data[256];
 202   unsigned char checksum, a;
 203   unsigned int b;
 204   int i;
 205
 206   while (!feof(f)){
 207     fgets(s, sizeof (s), f); /* we should not use more than 263 bytes normally */
 208     if(s[0]!=':'){
 209       fprintf(stderr,"%s: invalid line: \"%s\"\n", filename, s);
 210       goto fail;
 211     }
 212     sscanf(s+1, "%02x", &length);
 213     sscanf(s+3, "%04x", &addr);
 214     sscanf(s+7, "%02x", &type);
 215
 216     if(type==0){
 217
 218       a=length+(addr &0xff)+(addr>>8)+type;
 219       for(i=0;i<length;i++){
 220         sscanf (s+9+i*2,"%02x", &b);
 221         data[i]=b;
 222         a=a+data[i];
 223       }
 224
 225       sscanf (s+9+length*2,"%02x", &b);
 226       checksum=b;
 227       if (((a+checksum)&0xff)!=0x00){
 228         fprintf (stderr, "  ** Checksum failed: got 0x%02x versus 0x%02x\n", (-a)&0xff, checksum);
 229         goto fail;
 230       }
 231       if (!write_internal_ram (udh, data, addr, length))
 232         goto fail;
 233     }
 234     else if (type == 0x01){      // EOF
 235       break;
 236     }
 237     else if (type == 0x02){
 238       fprintf(stderr, "Extended address: whatever I do with it?\n");
 239       fprintf (stderr, "%s: invalid line: \"%s\"\n", filename, s);
 240       goto fail;
 241     }
 242   }
 243
 244   // we jam the hash value into the FX2 memory before letting
 245   // the cpu out of reset.  When it comes out of reset it
 246   // may renumerate which will invalidate udh.
 247
 248   if (!usrp_set_hash (udh, FIRMWARE_HASH_SLOT, hash))
 249     fprintf (stderr, "usrp: failed to write firmware hash slot\n");
 250
 251   if (!reset_cpu (udh, false))          // take CPU out of reset
 252     goto fail;
 253
 254   fclose (f);
 255   return true;
 256
 257  fail:
 258   fclose (f);
 259   return false;
 260 }
 261
 262 // ----------------------------------------------------------------
 263 // load fpga
 264
 265 static bool
 266 _usrp_load_fpga (libusb_device_handle *udh, const char *filename,
 267                  unsigned char hash[USRP_HASH_SIZE])
 268 {
 269   bool ok = true;
 270
 271   FILE  *fp = fopen (filename, "rb");
 272   if (fp == 0){
 273     perror (filename);
 274     return false;
 275   }
 276
 277   unsigned char buf[MAX_EP0_PKTSIZE];   // 64 is max size of EP0 packet on FX2
 278   int n;
 279
 280   usrp_set_led (udh, 1, 1);             // led 1 on
 281
 282
 283   // reset FPGA (and on rev1 both AD9862's, thus killing clock)
 284   usrp_set_fpga_reset (udh, 1);         // hold fpga in reset
 285
 286   if (write_cmd (udh, VRQ_FPGA_LOAD, 0, FL_BEGIN, 0, 0) != 0)
 287     goto fail;
 288
 289   while ((n = fread (buf, 1, sizeof (buf), fp)) > 0){
 290     if (write_cmd (udh, VRQ_FPGA_LOAD, 0, FL_XFER, buf, n) != n)
 291       goto fail;
 292   }
 293
 294   if (write_cmd (udh, VRQ_FPGA_LOAD, 0, FL_END, 0, 0) != 0)
 295     goto fail;
 296
 297   fclose (fp);
 298
 299   if (!usrp_set_hash (udh, FPGA_HASH_SLOT, hash))
 300     fprintf (stderr, "usrp: failed to write fpga hash slot\n");
 301
 302   // On the rev1 USRP, the {tx,rx}_{enable,reset} bits are
 303   // controlled over the serial bus, and hence aren't observed until
 304   // we've got a good fpga bitstream loaded.
 305
 306   usrp_set_fpga_reset (udh, 0);         // fpga out of master reset
 307
 308   // now these commands will work
 309
 310   ok &= usrp_set_fpga_tx_enable (udh, 0);
 311   ok &= usrp_set_fpga_rx_enable (udh, 0);
 312
 313   ok &= usrp_set_fpga_tx_reset (udh, 1);        // reset tx and rx paths
 314   ok &= usrp_set_fpga_rx_reset (udh, 1);
 315   ok &= usrp_set_fpga_tx_reset (udh, 0);        // reset tx and rx paths
 316   ok &= usrp_set_fpga_rx_reset (udh, 0);
 317
 318   if (!ok)
 319     fprintf (stderr, "usrp: failed to reset tx and/or rx path\n");
 320
 321   // Manually reset all regs except master control to zero.
 322   // FIXME may want to remove this when we rework FPGA reset strategy.
 323   // In the mean while, this gets us reproducible behavior.
 324   for (int i = 0; i < FR_USER_0; i++){
 325     if (i == FR_MASTER_CTRL)
 326       continue;
 327     usrp_write_fpga_reg(udh, i, 0);
 328   }
 329
 330   power_down_9862s (udh);               // on the rev1, power these down!
 331   usrp_set_led (udh, 1, 0);             // led 1 off
 332
 333   return true;
 334
 335  fail:
 336   power_down_9862s (udh);               // on the rev1, power these down!
 337   fclose (fp);
 338   return false;
 339 }
 340
 341 // ----------------------------------------------------------------
 342
 343 bool
 344 usrp_set_led (libusb_device_handle *udh, int which, bool on)
 345 {
 346   int r = write_cmd (udh, VRQ_SET_LED, on, which, 0, 0);
 347
 348   return r == 0;
 349 }
 350
 351
 352 bool
 353 usrp_set_switch (libusb_device_handle *udh, int cmd_byte, bool on)
 354 {
 355   return write_cmd (udh, cmd_byte, on, 0, 0, 0) == 0;
 356 }
 357
 358 bool
 359 usrp1_fpga_write (libusb_device_handle *udh,
 360                   int regno, int value)
 361 {
 362   // on the rev1 usrp, we use the generic spi_write interface
 363
 364   unsigned char buf[4];
 365
 366   buf[0] = (value >> 24) & 0xff;        // MSB first
 367   buf[1] = (value >> 16) & 0xff;
 368   buf[2] = (value >>  8) & 0xff;
 369   buf[3] = (value >>  0) & 0xff;
 370
 371   return usrp_spi_write (udh, 0x00 | (regno & 0x7f),
 372                          SPI_ENABLE_FPGA,
 373                          SPI_FMT_MSB | SPI_FMT_HDR_1,
 374                          buf, sizeof (buf));
 375 }
 376
 377 bool
 378 usrp1_fpga_read (libusb_device_handle *udh,
 379                  int regno, int *value)
 380 {
 381   *value = 0;
 382   unsigned char buf[4];
 383
 384   bool ok = usrp_spi_read (udh, 0x80 | (regno & 0x7f),
 385                            SPI_ENABLE_FPGA,
 386                            SPI_FMT_MSB | SPI_FMT_HDR_1,
 387                            buf, sizeof (buf));
 388
 389   if (ok)
 390     *value = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
 391
 392   return ok;
 393 }
 394
 395
 396 bool
 397 usrp_set_fpga_reset (libusb_device_handle *udh, bool on)
 398 {
 399   return usrp_set_switch (udh, VRQ_FPGA_SET_RESET, on);
 400 }
 401
 402 bool
 403 usrp_set_fpga_tx_enable (libusb_device_handle *udh, bool on)
 404 {
 405   return usrp_set_switch (udh, VRQ_FPGA_SET_TX_ENABLE, on);
 406 }
 407
 408 bool
 409 usrp_set_fpga_rx_enable (libusb_device_handle *udh, bool on)
 410 {
 411   return usrp_set_switch (udh, VRQ_FPGA_SET_RX_ENABLE, on);
 412 }
 413
 414 bool
 415 usrp_set_fpga_tx_reset (libusb_device_handle *udh, bool on)
 416 {
 417   return usrp_set_switch (udh, VRQ_FPGA_SET_TX_RESET, on);
 418 }
 419
 420 bool
 421 usrp_set_fpga_rx_reset (libusb_device_handle *udh, bool on)
 422 {
 423   return usrp_set_switch (udh, VRQ_FPGA_SET_RX_RESET, on);
 424 }
 425
 426
 427 // ----------------------------------------------------------------
 428 // conditional load stuff
 429
 430 static bool
 431 compute_hash (const char *filename, unsigned char hash[USRP_HASH_SIZE])
 432 {
 433   assert (USRP_HASH_SIZE == 16);
 434   memset (hash, 0, USRP_HASH_SIZE);
 435
 436   FILE *fp = fopen (filename, "rb");
 437   if (fp == 0){
 438     perror (filename);
 439     return false;
 440   }
 441   int r = md5_stream (fp, hash);
 442   fclose (fp);
 443
 444   return r == 0;
 445 }
 446
 447 static usrp_load_status_t
 448 usrp_conditionally_load_something (libusb_device_handle *udh,
 449                                    const char *filename,
 450                                    bool force,
 451                                    int slot,
 452                                    bool loader (libusb_device_handle *,
 453                                                 const char *,
 454                                                 unsigned char [USRP_HASH_SIZE]))
 455 {
 456   unsigned char file_hash[USRP_HASH_SIZE];
 457   unsigned char usrp_hash[USRP_HASH_SIZE];
 458
 459   if (access (filename, R_OK) != 0){
 460     perror (filename);
 461     return ULS_ERROR;
 462   }
 463
 464   if (!compute_hash (filename, file_hash))
 465     return ULS_ERROR;
 466
 467   if (!force
 468       && usrp_get_hash (udh, slot, usrp_hash)
 469       && memcmp (file_hash, usrp_hash, USRP_HASH_SIZE) == 0)
 470     return ULS_ALREADY_LOADED;
 471
 472   bool r = loader (udh, filename, file_hash);
 473
 474   if (!r)
 475     return ULS_ERROR;
 476
 477   return ULS_OK;
 478 }
 479
 480 usrp_load_status_t
 481 usrp_load_firmware (libusb_device_handle *udh,
 482                     const char *filename,
 483                     bool force)
 484 {
 485   return usrp_conditionally_load_something (udh, filename, force,
 486                                             FIRMWARE_HASH_SLOT,
 487                                             _usrp_load_firmware);
 488 }
 489
 490 usrp_load_status_t
 491 usrp_load_fpga (libusb_device_handle *udh,
 492                 const char *filename,
 493                 bool force)
 494 {
 495   return usrp_conditionally_load_something (udh, filename, force,
 496                                             FPGA_HASH_SLOT,
 497                                             _usrp_load_fpga);
 498 }
 499
 500 bool
 501 our_nanosleep (const struct timespec *delay)
 502 {
 503   struct timespec       new_delay = *delay;
 504   struct timespec       remainder;
 505
 506   while (1){
 507     int r = nanosleep (&new_delay, &remainder);
 508     if (r == 0)
 509       return true;
 510     if (errno == EINTR)
 511       new_delay = remainder;
 512     else {
 513       perror ("nanosleep");
 514       return false;
 515     }
 516   }
 517 }
 518
 519 static bool
 520 mdelay (int millisecs)
 521 {
 522   struct timespec       ts;
 523   ts.tv_sec = millisecs / 1000;
 524   ts.tv_nsec = (millisecs - (1000 * ts.tv_sec)) * 1000000;
 525   return our_nanosleep (&ts);
 526 }
 527
 528 void
 529 load_status_msg (usrp_load_status_t s, const char *type, const char *filename)
 530 {
 531   char *e = getenv("USRP_VERBOSE");
 532   bool verbose = e != 0;
 533
 534   switch (s){
 535   case ULS_ERROR:
 536     fprintf (stderr, "usrp: failed to load %s %s.\n", type, filename);
 537     break;
 538
 539   case ULS_ALREADY_LOADED:
 540     if (verbose)
 541       fprintf (stderr, "usrp: %s %s already loaded.\n", type, filename);
 542     break;
 543
 544   case ULS_OK:
 545     if (verbose)
 546       fprintf (stderr, "usrp: %s %s loaded successfully.\n", type, filename);
 547     break;
 548   }
 549 }
 550
 551 bool
 552 _usrp_get_status (libusb_device_handle *udh, int which, bool *trouble)
 553 {
 554   unsigned char status;
 555   *trouble = true;
 556
 557   if (write_cmd (udh, VRQ_GET_STATUS, 0, which,
 558                  &status, sizeof (status)) != sizeof (status))
 559     return false;
 560
 561   *trouble = status;
 562   return true;
 563 }
 564
 565 bool
 566 usrp_check_rx_overrun (libusb_device_handle *udh, bool *overrun_p)
 567 {
 568   return _usrp_get_status (udh, GS_RX_OVERRUN, overrun_p);
 569 }
 570
 571 bool
 572 usrp_check_tx_underrun (libusb_device_handle *udh, bool *underrun_p)
 573 {
 574   return _usrp_get_status (udh, GS_TX_UNDERRUN, underrun_p);
 575 }
 576
 577
 578 bool
 579 usrp_i2c_write (libusb_device_handle *udh, int i2c_addr,
 580                 const void *buf, int len)
 581 {
 582   if (len < 1 || len > MAX_EP0_PKTSIZE)
 583     return false;
 584
 585   return write_cmd (udh, VRQ_I2C_WRITE, i2c_addr, 0,
 586                     (unsigned char *) buf, len) == len;
 587 }
 588
 589
 590 bool
 591 usrp_i2c_read (libusb_device_handle *udh, int i2c_addr,
 592                void *buf, int len)
 593 {
 594   if (len < 1 || len > MAX_EP0_PKTSIZE)
 595     return false;
 596
 597   return write_cmd (udh, VRQ_I2C_READ, i2c_addr, 0,
 598                     (unsigned char *) buf, len) == len;
 599 }
 600
 601 bool
 602 usrp_spi_write (libusb_device_handle *udh,
 603                 int optional_header, int enables, int format,
 604                 const void *buf, int len)
 605 {
 606   if (len < 0 || len > MAX_EP0_PKTSIZE)
 607     return false;
 608
 609   return write_cmd (udh, VRQ_SPI_WRITE,
 610                     optional_header,
 611                     ((enables & 0xff) << 8) | (format & 0xff),
 612                     (unsigned char *) buf, len) == len;
 613 }
 614
 615
 616 bool
 617 usrp_spi_read (libusb_device_handle *udh,
 618                int optional_header, int enables, int format,
 619                void *buf, int len)
 620 {
 621   if (len < 0 || len > MAX_EP0_PKTSIZE)
 622     return false;
 623
 624   return write_cmd (udh, VRQ_SPI_READ,
 625                     optional_header,
 626                     ((enables & 0xff) << 8) | (format & 0xff),
 627                     (unsigned char *) buf, len) == len;
 628 }
 629
 630 bool
 631 usrp_9862_write (libusb_device_handle *udh, int which_codec,
 632                  int regno, int value)
 633 {
 634   if (0)
 635     fprintf (stderr, "usrp_9862_write which = %d, reg = %2d, val = %3d (0x%02x)\n",
 636              which_codec, regno, value, value);
 637
 638   unsigned char buf[1];
 639
 640   buf[0] = value;
 641
 642   return usrp_spi_write (udh, 0x00 | (regno & 0x3f),
 643                          which_codec == 0 ? SPI_ENABLE_CODEC_A : SPI_ENABLE_CODEC_B,
 644                          SPI_FMT_MSB | SPI_FMT_HDR_1,
 645                          buf, 1);
 646 }
 647
 648 bool
 649 usrp_9862_read (libusb_device_handle *udh, int which_codec,
 650                 int regno, unsigned char *value)
 651 {
 652   return usrp_spi_read (udh, 0x80 | (regno & 0x3f),
 653                         which_codec == 0 ? SPI_ENABLE_CODEC_A : SPI_ENABLE_CODEC_B,
 654                         SPI_FMT_MSB | SPI_FMT_HDR_1,
 655                         value, 1);
 656 }
 657
 658 bool
 659 usrp_9862_write_many (libusb_device_handle *udh,
 660                       int which_codec,
 661                       const unsigned char *buf,
 662                       int len)
 663 {
 664   if (len & 0x1)
 665     return false;               // must be even
 666
 667   bool result = true;
 668
 669   while (len > 0){
 670     result &= usrp_9862_write (udh, which_codec, buf[0], buf[1]);
 671     len -= 2;
 672     buf += 2;
 673   }
 674
 675   return result;
 676 }
 677
 678
 679 bool
 680 usrp_9862_write_many_all (libusb_device_handle *udh,
 681                            const unsigned char *buf, int len)
 682 {
 683   // FIXME handle 2/2 and 4/4 versions
 684
 685   bool result;
 686   result  = usrp_9862_write_many (udh, 0, buf, len);
 687   result &= usrp_9862_write_many (udh, 1, buf, len);
 688   return result;
 689 }
 690
 691
 692 static const int EEPROM_PAGESIZE = 16;
 693
 694 bool
 695 usrp_eeprom_write (libusb_device_handle *udh, int i2c_addr,
 696                    int eeprom_offset, const void *buf, int len)
 697 {
 698   unsigned char cmd[2];
 699   const unsigned char *p = (unsigned char *) buf;
 700
 701   // The simplest thing that could possibly work:
 702   //   all writes are single byte writes.
 703   //
 704   // We could speed this up using the page write feature,
 705   // but we write so infrequently, why bother...
 706
 707   while (len-- > 0){
 708     cmd[0] = eeprom_offset++;
 709     cmd[1] = *p++;
 710     bool r = usrp_i2c_write (udh, i2c_addr, cmd, sizeof (cmd));
 711     mdelay (10);                // delay 10ms worst case write time
 712     if (!r)
 713       return false;
 714   }
 715
 716   return true;
 717 }
 718
 719 bool
 720 usrp_eeprom_read (libusb_device_handle *udh, int i2c_addr,
 721                   int eeprom_offset, void *buf, int len)
 722 {
 723   unsigned char *p = (unsigned char *) buf;
 724
 725   // We setup a random read by first doing a "zero byte write".
 726   // Writes carry an address.  Reads use an implicit address.
 727
 728   unsigned char cmd[1];
 729   cmd[0] = eeprom_offset;
 730   if (!usrp_i2c_write (udh, i2c_addr, cmd, sizeof (cmd)))
 731     return false;
 732
 733   while (len > 0){
 734     int n = std::min (len, MAX_EP0_PKTSIZE);
 735     if (!usrp_i2c_read (udh, i2c_addr, p, n))
 736       return false;
 737     len -= n;
 738     p += n;
 739   }
 740   return true;
 741 }
 742
 743 // ----------------------------------------------------------------
 744
 745 static bool
 746 slot_to_codec (int slot, int *which_codec)
 747 {
 748   *which_codec = 0;
 749
 750   switch (slot){
 751   case SLOT_TX_A:
 752   case SLOT_RX_A:
 753     *which_codec = 0;
 754     break;
 755
 756   case SLOT_TX_B:
 757   case SLOT_RX_B:
 758     *which_codec = 1;
 759     break;
 760
 761   default:
 762     fprintf (stderr, "usrp_prims:slot_to_codec: invalid slot = %d\n", slot);
 763     return false;
 764   }
 765   return true;
 766 }
 767
 768 static bool
 769 tx_slot_p (int slot)
 770 {
 771   switch (slot){
 772   case SLOT_TX_A:
 773   case SLOT_TX_B:
 774     return true;
 775
 776   default:
 777     return false;
 778   }
 779 }
 780
 781 bool
 782 usrp_write_aux_dac (libusb_device_handle *udh, int slot,
 783                     int which_dac, int value)
 784 {
 785   int which_codec;
 786
 787   if (!slot_to_codec (slot, &which_codec))
 788     return false;
 789
 790   if (!(0 <= which_dac && which_dac < 4)){
 791     fprintf (stderr, "usrp_write_aux_dac: invalid dac = %d\n", which_dac);
 792     return false;
 793   }
 794
 795   value &= 0x0fff;      // mask to 12-bits
 796
 797   if (which_dac == 3){
 798     // dac 3 is really 12-bits.  Use value as is.
 799     bool r = true;
 800     r &= usrp_9862_write (udh, which_codec, 43, (value >> 4));       // most sig
 801     r &= usrp_9862_write (udh, which_codec, 42, (value & 0xf) << 4); // least sig
 802     return r;
 803   }
 804   else {
 805     // dac 0, 1, and 2 are really 8 bits.
 806     value = value >> 4;         // shift value appropriately
 807     return usrp_9862_write (udh, which_codec, 36 + which_dac, value);
 808   }
 809 }
 810
 811
 812 bool
 813 usrp_read_aux_adc (libusb_device_handle *udh, int slot,
 814                    int which_adc, int *value)
 815 {
 816   *value = 0;
 817   int   which_codec;
 818
 819   if (!slot_to_codec (slot, &which_codec))
 820     return false;
 821
 822   if (!(0 <= which_codec && which_codec < 2)){
 823     fprintf (stderr, "usrp_read_aux_adc: invalid adc = %d\n", which_adc);
 824     return false;
 825   }
 826
 827   unsigned char aux_adc_control =
 828     AUX_ADC_CTRL_REFSEL_A               // on chip reference
 829     | AUX_ADC_CTRL_REFSEL_B;            // on chip reference
 830
 831   int   rd_reg = 26;    // base address of two regs to read for result
 832
 833   // program the ADC mux bits
 834   if (tx_slot_p (slot))
 835     aux_adc_control |= AUX_ADC_CTRL_SELECT_A2 | AUX_ADC_CTRL_SELECT_B2;
 836   else {
 837     rd_reg += 2;
 838     aux_adc_control |= AUX_ADC_CTRL_SELECT_A1 | AUX_ADC_CTRL_SELECT_B1;
 839   }
 840
 841   // I'm not sure if we can set the mux and issue a start conversion
 842   // in the same cycle, so let's do them one at a time.
 843
 844   usrp_9862_write (udh, which_codec, 34, aux_adc_control);
 845
 846   if (which_adc == 0)
 847     aux_adc_control |= AUX_ADC_CTRL_START_A;
 848   else {
 849     rd_reg += 4;
 850     aux_adc_control |= AUX_ADC_CTRL_START_B;
 851   }
 852
 853   // start the conversion
 854   usrp_9862_write (udh, which_codec, 34, aux_adc_control);
 855
 856   // read the 10-bit result back
 857   unsigned char v_lo = 0;
 858   unsigned char v_hi = 0;
 859   bool r = usrp_9862_read (udh, which_codec, rd_reg, &v_lo);
 860   r &= usrp_9862_read (udh, which_codec, rd_reg + 1, &v_hi);
 861
 862   if (r)
 863     *value = ((v_hi << 2) | ((v_lo >> 6) & 0x3)) << 2;  // format as 12-bit
 864
 865   return r;
 866 }
 867
 868 // ----------------------------------------------------------------
 869
 870 static int slot_to_i2c_addr (int slot)
 871 {
 872   switch (slot){
 873   case SLOT_TX_A:       return I2C_ADDR_TX_A;
 874   case SLOT_RX_A:       return I2C_ADDR_RX_A;
 875   case SLOT_TX_B:       return I2C_ADDR_TX_B;
 876   case SLOT_RX_B:       return I2C_ADDR_RX_B;
 877   default:              return -1;
 878   }
 879 }
 880
 881 static void
 882 set_chksum (unsigned char *buf)
 883 {
 884   int sum = 0;
 885   unsigned int i;
 886   for (i = 0; i < DB_EEPROM_CLEN - 1; i++)
 887     sum += buf[i];
 888   buf[i] = -sum;
 889 }
 890
 891 static usrp_dbeeprom_status_t
 892 read_dboard_eeprom (libusb_device_handle *udh,
 893                     int slot_id, unsigned char *buf)
 894 {
 895   int i2c_addr = slot_to_i2c_addr (slot_id);
 896   if (i2c_addr == -1)
 897     return UDBE_BAD_SLOT;
 898
 899   if (!usrp_eeprom_read (udh, i2c_addr, 0, buf, DB_EEPROM_CLEN))
 900     return UDBE_NO_EEPROM;
 901
 902   if (buf[DB_EEPROM_MAGIC] != DB_EEPROM_MAGIC_VALUE)
 903     return UDBE_INVALID_EEPROM;
 904
 905   int sum = 0;
 906   for (unsigned int i = 0; i < DB_EEPROM_CLEN; i++)
 907     sum += buf[i];
 908
 909   if ((sum & 0xff) != 0)
 910     return UDBE_INVALID_EEPROM;
 911
 912   return UDBE_OK;
 913 }
 914
 915 usrp_dbeeprom_status_t
 916 usrp_read_dboard_eeprom (libusb_device_handle *udh,
 917                          int slot_id, usrp_dboard_eeprom *eeprom)
 918 {
 919   unsigned char buf[DB_EEPROM_CLEN];
 920
 921   memset (eeprom, 0, sizeof (*eeprom));
 922
 923   usrp_dbeeprom_status_t s = read_dboard_eeprom (udh, slot_id, buf);
 924   if (s != UDBE_OK)
 925     return s;
 926
 927   eeprom->id = (buf[DB_EEPROM_ID_MSB] << 8) | buf[DB_EEPROM_ID_LSB];
 928   eeprom->oe = (buf[DB_EEPROM_OE_MSB] << 8) | buf[DB_EEPROM_OE_LSB];
 929   eeprom->offset[0] = (buf[DB_EEPROM_OFFSET_0_MSB] << 8) | buf[DB_EEPROM_OFFSET_0_LSB];
 930   eeprom->offset[1] = (buf[DB_EEPROM_OFFSET_1_MSB] << 8) | buf[DB_EEPROM_OFFSET_1_LSB];
 931
 932   return UDBE_OK;
 933 }
 934
 935 bool
 936 usrp_write_dboard_offsets (libusb_device_handle *udh, int slot_id,
 937                            short offset0, short offset1)
 938 {
 939   unsigned char buf[DB_EEPROM_CLEN];
 940
 941   usrp_dbeeprom_status_t s = read_dboard_eeprom (udh, slot_id, buf);
 942   if (s != UDBE_OK)
 943     return false;
 944
 945   buf[DB_EEPROM_OFFSET_0_LSB] = (offset0 >> 0) & 0xff;
 946   buf[DB_EEPROM_OFFSET_0_MSB] = (offset0 >> 8) & 0xff;
 947   buf[DB_EEPROM_OFFSET_1_LSB] = (offset1 >> 0) & 0xff;
 948   buf[DB_EEPROM_OFFSET_1_MSB] = (offset1 >> 8) & 0xff;
 949   set_chksum (buf);
 950
 951   return usrp_eeprom_write (udh, slot_to_i2c_addr (slot_id),
 952                             0, buf, sizeof (buf));
 953 }