git.gag.com Git - debian/gnuradio/blob - usrp2/firmware/lib/db_init.c

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright 2008,2009 Free Software Foundation, Inc.
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19
  20 #include <memory_map.h>
  21 #include <i2c.h>
  22 #include <usrp2_i2c_addr.h>
  23 #include <string.h>
  24 #include <stdio.h>
  25 #include <db.h>
  26 #include <db_base.h>
  27 #include <hal_io.h>
  28 #include <nonstdio.h>
  29
  30
  31 struct db_base *tx_dboard;      // the tx daughterboard that's installed
  32 struct db_base *rx_dboard;      // the rx daughterboard that's installed
  33
  34 extern struct db_base db_basic_tx;
  35 extern struct db_base db_basic_rx;
  36 extern struct db_base db_lf_tx;
  37 extern struct db_base db_lf_rx;
  38 extern struct db_base db_rfx_400_tx;
  39 extern struct db_base db_rfx_400_rx;
  40 extern struct db_base db_rfx_900_tx;
  41 extern struct db_base db_rfx_900_rx;
  42 extern struct db_base db_rfx_1200_tx;
  43 extern struct db_base db_rfx_1200_rx;
  44 extern struct db_base db_rfx_1800_tx;
  45 extern struct db_base db_rfx_1800_rx;
  46 extern struct db_base db_rfx_2400_tx;
  47 extern struct db_base db_rfx_2400_rx;
  48 extern struct db_base db_wbxng_rx;
  49 extern struct db_base db_wbxng_tx;
  50 extern struct db_base db_tvrx1;
  51 extern struct db_base db_tvrx2;
  52 extern struct db_base db_tvrx3;
  53 extern struct db_base db_dbsrx;
  54
  55 extern struct db_base db_xcvr2450_tx;
  56 extern struct db_base db_xcvr2450_rx;
  57
  58 struct db_base *all_dboards[] = {
  59   &db_basic_tx,
  60   &db_basic_rx,
  61   &db_lf_tx,
  62   &db_lf_rx,
  63   &db_rfx_400_tx,
  64   &db_rfx_400_rx,
  65   &db_rfx_900_tx,
  66   &db_rfx_900_rx,
  67   &db_rfx_1200_tx,
  68   &db_rfx_1200_rx,
  69   &db_rfx_1800_tx,
  70   &db_rfx_1800_rx,
  71   &db_rfx_2400_tx,
  72   &db_rfx_2400_rx,
  73   &db_tvrx1,
  74 #if 0
  75   &db_tvrx2,
  76 #endif
  77   &db_tvrx3,
  78   &db_dbsrx,
  79   &db_xcvr2450_tx,
  80   &db_xcvr2450_rx,
  81   0
  82 };
  83
  84
  85 typedef enum { UDBE_OK, UDBE_NO_EEPROM, UDBE_INVALID_EEPROM } usrp_dbeeprom_status_t;
  86
  87 static usrp_dbeeprom_status_t
  88 read_raw_dboard_eeprom (unsigned char *buf, int i2c_addr)
  89 {
  90   if (!eeprom_read (i2c_addr, 0, buf, DB_EEPROM_CLEN))
  91     return UDBE_NO_EEPROM;
  92
  93   if (buf[DB_EEPROM_MAGIC] != DB_EEPROM_MAGIC_VALUE)
  94     return UDBE_INVALID_EEPROM;
  95
  96   int sum = 0;
  97   unsigned int i;
  98   for (i = 0; i < DB_EEPROM_CLEN; i++)
  99     sum += buf[i];
 100
 101   if ((sum & 0xff) != 0)
 102     return UDBE_INVALID_EEPROM;
 103
 104   return UDBE_OK;
 105 }
 106
 107
 108 /*
 109  * Return DBID, -1 <none> or -2 <invalid eeprom contents>
 110  */
 111 int
 112 read_dboard_eeprom(int i2c_addr)
 113 {
 114   unsigned char buf[DB_EEPROM_CLEN];
 115
 116   usrp_dbeeprom_status_t s = read_raw_dboard_eeprom (buf, i2c_addr);
 117
 118   //printf("\nread_raw_dboard_eeprom: %d\n", s);
 119
 120   switch (s){
 121   case UDBE_OK:
 122     return (buf[DB_EEPROM_ID_MSB] << 8) | buf[DB_EEPROM_ID_LSB];
 123
 124   case UDBE_NO_EEPROM:
 125   default:
 126     return -1;
 127
 128   case UDBE_INVALID_EEPROM:
 129     return -2;
 130   }
 131 }
 132
 133
 134 static struct db_base *
 135 lookup_dbid(int dbid)
 136 {
 137   if (dbid < 0)
 138     return 0;
 139
 140   int i;
 141   for (i = 0; all_dboards[i]; i++)
 142     if (all_dboards[i]->dbid == dbid)
 143       return all_dboards[i];
 144
 145   return 0;
 146 }
 147
 148 static struct db_base *
 149 lookup_dboard(int i2c_addr, struct db_base *default_db, char *msg)
 150 {
 151   struct db_base *db;
 152   int dbid = read_dboard_eeprom(i2c_addr);
 153
 154   // FIXME removing this printf has the system hang if there are two d'boards
 155   // installed.  (I think the problem is in i2c_read/write or the way
 156   // I kludge the zero-byte write to set the read address in eeprom_read.)
 157   printf("%s dbid: 0x%x\n", msg, dbid);
 158
 159   if (dbid < 0){        // there was some kind of problem.  Treat as Basic Tx
 160     return default_db;
 161   }
 162   else if ((db = lookup_dbid(dbid)) == 0){
 163     printf("No daugherboard code for dbid = 0x%x\n", dbid);
 164     return default_db;
 165   }
 166   return db;
 167 }
 168
 169 void
 170 set_atr_regs(int bank, struct db_base *db)
 171 {
 172   uint32_t      val[4];
 173   int           shift;
 174   int           mask;
 175   int           i;
 176
 177   val[ATR_IDLE] = db->atr_rxval;
 178   val[ATR_RX]   = db->atr_rxval;
 179   val[ATR_TX]   = db->atr_txval;
 180   val[ATR_FULL] = db->atr_txval;
 181
 182   if (bank == GPIO_TX_BANK){
 183     mask = 0xffff0000;
 184     shift = 16;
 185   }
 186   else {
 187     mask = 0x0000ffff;
 188     shift = 0;
 189   }
 190
 191   for (i = 0; i < 4; i++){
 192     int t = (atr_regs->v[i] & ~mask) | ((val[i] << shift) & mask);
 193     //printf("atr_regs[%d] = 0x%x\n", i, t);
 194     atr_regs->v[i] = t;
 195   }
 196 }
 197
 198 static void
 199 set_gpio_mode(int bank, struct db_base *db)
 200 {
 201   int   i;
 202
 203   hal_gpio_set_ddr(bank, db->output_enables, 0xffff);
 204   set_atr_regs(bank, db);
 205
 206   for (i = 0; i < 16; i++){
 207     if (db->used_pins & (1 << i)){
 208       // set to either GPIO_SEL_SW or GPIO_SEL_ATR
 209       hal_gpio_set_sel(bank, i, (db->atr_mask & (1 << i)) ? 'a' : 's');
 210     }
 211   }
 212 }
 213
 214 static int __attribute__((unused))
 215 determine_tx_mux_value(struct db_base *db)
 216 {
 217   if (db->i_and_q_swapped)
 218     return 0x01;
 219   else
 220     return 0x10;
 221 }
 222
 223 static int
 224 determine_rx_mux_value(struct db_base *db)
 225 {
 226 #define ADC0 0x0
 227 #define ADC1 0x1
 228 #define ZERO 0x2
 229
 230   static int truth_table[8] = {
 231     /* swap_iq, uses */
 232     /* 0, 0x0 */    (ZERO << 2) | ZERO,         // N/A
 233     /* 0, 0x1 */    (ZERO << 2) | ADC0,
 234     /* 0, 0x2 */    (ZERO << 2) | ADC1,
 235     /* 0, 0x3 */    (ADC1 << 2) | ADC0,
 236     /* 1, 0x0 */    (ZERO << 2) | ZERO,         // N/A
 237     /* 1, 0x1 */    (ZERO << 2) | ADC0,
 238     /* 1, 0x2 */    (ZERO << 2) | ADC1,
 239     /* 1, 0x3 */    (ADC0 << 2) | ADC1,
 240   };
 241
 242   int   subdev0_uses;
 243   int   subdev1_uses;
 244   int   uses;
 245
 246   if (db->is_quadrature)
 247     subdev0_uses = 0x3;         // uses A/D 0 and 1
 248   else
 249     subdev0_uses = 0x1;         // uses A/D 0 only
 250
 251   // FIXME second subdev on Basic Rx, LF RX
 252   // if subdev2 exists
 253   // subdev1_uses = 0x2;
 254   subdev1_uses = 0;
 255
 256   uses = subdev0_uses;
 257
 258   int swap_iq = db->i_and_q_swapped & 0x1;
 259   int index = (swap_iq << 2) | uses;
 260
 261   return truth_table[index];
 262 }
 263
 264
 265 void
 266 db_init(void)
 267 {
 268   int   m;
 269
 270   tx_dboard = lookup_dboard(I2C_ADDR_TX_A, &db_basic_tx, "Tx");
 271   //printf("db_init: tx dbid = 0x%x\n", tx_dboard->dbid);
 272   set_gpio_mode(GPIO_TX_BANK, tx_dboard);
 273   tx_dboard->init(tx_dboard);
 274   m = determine_tx_mux_value(tx_dboard);
 275   dsp_tx_regs->tx_mux = m;
 276   //printf("tx_mux = 0x%x\n", m);
 277   tx_dboard->current_lo_offset = tx_dboard->default_lo_offset;
 278
 279   rx_dboard = lookup_dboard(I2C_ADDR_RX_A, &db_basic_rx, "Rx");
 280   //printf("db_init: rx dbid = 0x%x\n", rx_dboard->dbid);
 281   set_gpio_mode(GPIO_RX_BANK, rx_dboard);
 282   rx_dboard->init(rx_dboard);
 283   m = determine_rx_mux_value(rx_dboard);
 284   dsp_rx_regs->rx_mux = m;
 285   //printf("rx_mux = 0x%x\n", m);
 286   rx_dboard->current_lo_offset = rx_dboard->default_lo_offset;
 287 }
 288
 289 /*!
 290  *  Calculate the frequency to use for setting the digital down converter.
 291  *
 292  *  \param[in] target_freq   desired RF frequency (Hz)
 293  *  \param[in] baseband_freq the RF frequency that corresponds to DC in the IF.
 294  *
 295  *  \param[out] dxc_freq is the value for the ddc
 296  *  \param[out] inverted is true if we're operating in an inverted Nyquist zone.
 297 */
 298 void
 299 calc_dxc_freq(u2_fxpt_freq_t target_freq, u2_fxpt_freq_t baseband_freq,
 300               u2_fxpt_freq_t *dxc_freq, bool *inverted)
 301 {
 302   u2_fxpt_freq_t fs = U2_DOUBLE_TO_FXPT_FREQ(100e6);    // converter sample rate
 303   u2_fxpt_freq_t delta = target_freq - baseband_freq;
 304
 305 #if 0
 306   printf("calc_dxc_freq\n");
 307   printf("  fs       = "); print_fxpt_freq(fs); newline();
 308   printf("  target   = "); print_fxpt_freq(target_freq); newline();
 309   printf("  baseband = "); print_fxpt_freq(baseband_freq); newline();
 310   printf("  delta    = "); print_fxpt_freq(delta); newline();
 311 #endif
 312
 313   if (delta >= 0){
 314     while (delta > fs)
 315       delta -= fs;
 316     if (delta <= fs/2){         // non-inverted region
 317       *dxc_freq = -delta;
 318       *inverted = false;
 319     }
 320     else {                      // inverted region
 321       *dxc_freq = delta - fs;
 322       *inverted = true;
 323     }
 324   }
 325   else {
 326     while (delta < -fs)
 327       delta += fs;
 328     if (delta >= -fs/2){        // non-inverted region
 329       *dxc_freq = -delta;
 330       *inverted = false;
 331     }
 332     else {                      // inverted region
 333       *dxc_freq = delta + fs;
 334       *inverted = true;
 335     }
 336   }
 337 }
 338
 339 bool
 340 db_set_lo_offset(struct db_base *db, u2_fxpt_freq_t offset)
 341 {
 342   db->current_lo_offset = offset;
 343   return true;
 344 }
 345
 346 bool
 347 db_tune(struct db_base *db, u2_fxpt_freq_t target_freq, struct tune_result *result)
 348 {
 349   memset(result, 0, sizeof(*result));
 350   bool inverted = false;
 351   u2_fxpt_freq_t dxc_freq;
 352   u2_fxpt_freq_t actual_dxc_freq;
 353
 354   // Ask the d'board to tune as closely as it can to target_freq+lo_offset
 355   bool ok = db->set_freq(db, target_freq+db->current_lo_offset, &result->baseband_freq);
 356
 357   // Calculate the DDC setting that will downconvert the baseband from the
 358   // daughterboard to our target frequency.
 359   calc_dxc_freq(target_freq, result->baseband_freq, &dxc_freq, &inverted);
 360
 361   // If the spectrum is inverted, and the daughterboard doesn't do
 362   // quadrature downconversion, we can fix the inversion by flipping the
 363   // sign of the dxc_freq...  (This only happens using the basic_rx board)
 364
 365   if (db->spectrum_inverted)
 366     inverted = !inverted;
 367
 368   if (inverted && !db->is_quadrature){
 369     dxc_freq = -dxc_freq;
 370     inverted = !inverted;
 371   }
 372
 373   if (db->is_tx){
 374     dxc_freq = -dxc_freq;       // down conversion versus up conversion
 375     ok &= db_set_duc_freq(dxc_freq, &actual_dxc_freq);
 376   }
 377   else {
 378     ok &= db_set_ddc_freq(dxc_freq, &actual_dxc_freq);
 379   }
 380
 381   result->dxc_freq = dxc_freq;
 382   result->residual_freq = dxc_freq - actual_dxc_freq;
 383   result->inverted = inverted;
 384   return ok;
 385 }
 386
 387 static int32_t
 388 compute_freq_control_word(u2_fxpt_freq_t target_freq, u2_fxpt_freq_t *actual_freq)
 389 {
 390   // If we were using floating point, we'd calculate
 391   //   master = 100e6;
 392   //   v = (int) rint(target_freq / master_freq) * pow(2.0, 32.0);
 393
 394   //printf("compute_freq_control_word\n");
 395   //printf("  target_freq = "); print_fxpt_freq(target_freq); newline();
 396
 397   int32_t master_freq = 100000000;      // 100M
 398
 399   int32_t v = ((target_freq << 12)) / master_freq;
 400   //printf("  fcw = %d\n", v);
 401
 402   *actual_freq = (v * (int64_t) master_freq) >> 12;
 403
 404   //printf("  actual = "); print_fxpt_freq(*actual_freq); newline();
 405
 406   return v;
 407 }
 408
 409
 410 bool
 411 db_set_ddc_freq(u2_fxpt_freq_t dxc_freq, u2_fxpt_freq_t *actual_dxc_freq)
 412 {
 413   int32_t v = compute_freq_control_word(dxc_freq, actual_dxc_freq);
 414   dsp_rx_regs->freq = v;
 415   return true;
 416 }
 417
 418 bool
 419 db_set_duc_freq(u2_fxpt_freq_t dxc_freq, u2_fxpt_freq_t *actual_dxc_freq)
 420 {
 421   int32_t v = compute_freq_control_word(dxc_freq, actual_dxc_freq);
 422   dsp_tx_regs->freq = v;
 423   return true;
 424 }
 425
 426 bool
 427 db_set_gain(struct db_base *db, u2_fxpt_gain_t gain)
 428 {
 429   return db->set_gain(db, gain);
 430 }