src/librtlsdr.c

   1 /*
   2  * rtl-sdr, turns your Realtek RTL2832 based DVB dongle into a SDR receiver
   3  * Copyright (C) 2012 by Steve Markgraf <steve@steve-m.de>
   4  * Copyright (C) 2012 by Dimitri Stolnikov <horiz0n@gmx.net>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <errno.h>
  21 #include <signal.h>
  22 #include <string.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #ifndef _WIN32
  26 #include <unistd.h>
  27 #define min(a, b) (((a) < (b)) ? (a) : (b))
  28 #endif
  29
  30 #include <libusb.h>
  31
  32 /*
  33  * All libusb callback functions should be marked with the LIBUSB_CALL macro
  34  * to ensure that they are compiled with the same calling convention as libusb.
  35  *
  36  * If the macro isn't available in older libusb versions, we simply define it.
  37  */
  38 #ifndef LIBUSB_CALL
  39 #define LIBUSB_CALL
  40 #endif
  41
  42 /* two raised to the power of n */
  43 #define TWO_POW(n)              ((double)(1ULL<<(n)))
  44
  45 #include "rtl-sdr.h"
  46 #include "tuner_e4k.h"
  47 #include "tuner_fc0012.h"
  48 #include "tuner_fc0013.h"
  49 #include "tuner_fc2580.h"
  50 #include "tuner_r820t.h"
  51
  52 typedef struct rtlsdr_tuner_iface {
  53         /* tuner interface */
  54         int (*init)(void *);
  55         int (*exit)(void *);
  56         int (*set_freq)(void *, uint32_t freq /* Hz */);
  57         int (*set_bw)(void *, int bw /* Hz */);
  58         int (*set_gain)(void *, int gain /* tenth dB */);
  59         int (*set_if_gain)(void *, int stage, int gain /* tenth dB */);
  60         int (*set_gain_mode)(void *, int manual);
  61 } rtlsdr_tuner_iface_t;
  62
  63 enum rtlsdr_async_status {
  64         RTLSDR_INACTIVE = 0,
  65         RTLSDR_CANCELING,
  66         RTLSDR_RUNNING
  67 };
  68
  69 struct rtlsdr_dev {
  70         libusb_context *ctx;
  71         struct libusb_device_handle *devh;
  72         uint32_t xfer_buf_num;
  73         uint32_t xfer_buf_len;
  74         struct libusb_transfer **xfer;
  75         unsigned char **xfer_buf;
  76         rtlsdr_read_async_cb_t cb;
  77         void *cb_ctx;
  78         enum rtlsdr_async_status async_status;
  79         /* rtl demod context */
  80         uint32_t rate; /* Hz */
  81         uint32_t rtl_xtal; /* Hz */
  82         int direct_sampling;
  83         /* tuner context */
  84         enum rtlsdr_tuner tuner_type;
  85         rtlsdr_tuner_iface_t *tuner;
  86         uint32_t tun_xtal; /* Hz */
  87         uint32_t freq; /* Hz */
  88         uint32_t offs_freq; /* Hz */
  89         int corr; /* ppm */
  90         int gain; /* tenth dB */
  91         struct e4k_state e4k_s;
  92 };
  93
  94 void rtlsdr_set_gpio_bit(rtlsdr_dev_t *dev, uint8_t gpio, int val);
  95
  96 /* generic tuner interface functions, shall be moved to the tuner implementations */
  97 int e4000_init(void *dev) {
  98         rtlsdr_dev_t* devt = (rtlsdr_dev_t*)dev;
  99         devt->e4k_s.i2c_addr = E4K_I2C_ADDR;
 100         rtlsdr_get_xtal_freq(devt, NULL, &devt->e4k_s.vco.fosc);
 101         devt->e4k_s.rtl_dev = dev;
 102         return e4k_init(&devt->e4k_s);
 103 }
 104 int e4000_exit(void *dev) { return 0; }
 105 int e4000_set_freq(void *dev, uint32_t freq) {
 106         rtlsdr_dev_t* devt = (rtlsdr_dev_t*)dev;
 107         return e4k_tune_freq(&devt->e4k_s, freq);
 108 }
 109
 110 int e4000_set_bw(void *dev, int bw) {
 111         int r = 0;
 112         rtlsdr_dev_t* devt = (rtlsdr_dev_t*)dev;
 113
 114         r |= e4k_if_filter_bw_set(&devt->e4k_s, E4K_IF_FILTER_MIX, bw);
 115         r |= e4k_if_filter_bw_set(&devt->e4k_s, E4K_IF_FILTER_RC, bw);
 116         r |= e4k_if_filter_bw_set(&devt->e4k_s, E4K_IF_FILTER_CHAN, bw);
 117
 118         return r;
 119 }
 120
 121 int e4000_set_gain(void *dev, int gain) {
 122         rtlsdr_dev_t* devt = (rtlsdr_dev_t*)dev;
 123         int mixgain = (gain > 340) ? 12 : 4;
 124 #if 0
 125         int enhgain = (gain - 420);
 126 #endif
 127         if(e4k_set_lna_gain(&devt->e4k_s, min(300, gain - mixgain * 10)) == -EINVAL)
 128                 return -1;
 129         if(e4k_mixer_gain_set(&devt->e4k_s, mixgain) == -EINVAL)
 130                 return -1;
 131 #if 0 /* enhanced mixer gain seems to have no effect */
 132         if(enhgain >= 0)
 133                 if(e4k_set_enh_gain(&devt->e4k_s, enhgain) == -EINVAL)
 134                         return -1;
 135 #endif
 136         return 0;
 137 }
 138 int e4000_set_if_gain(void *dev, int stage, int gain) {
 139         rtlsdr_dev_t* devt = (rtlsdr_dev_t*)dev;
 140         return e4k_if_gain_set(&devt->e4k_s, (uint8_t)stage, (int8_t)(gain / 10));
 141 }
 142 int e4000_set_gain_mode(void *dev, int manual) {
 143         rtlsdr_dev_t* devt = (rtlsdr_dev_t*)dev;
 144         return e4k_enable_manual_gain(&devt->e4k_s, manual);
 145 }
 146
 147 int _fc0012_init(void *dev) { return fc0012_init(dev); }
 148 int fc0012_exit(void *dev) { return 0; }
 149 int fc0012_set_freq(void *dev, uint32_t freq) {
 150         /* select V-band/U-band filter */
 151         rtlsdr_set_gpio_bit(dev, 6, (freq > 300000000) ? 1 : 0);
 152         return fc0012_set_params(dev, freq, 6000000);
 153 }
 154 int fc0012_set_bw(void *dev, int bw) { return 0; }
 155 int _fc0012_set_gain(void *dev, int gain) { return fc0012_set_gain(dev, gain); }
 156 int fc0012_set_gain_mode(void *dev, int manual) { return 0; }
 157
 158 int _fc0013_init(void *dev) { return fc0013_init(dev); }
 159 int fc0013_exit(void *dev) { return 0; }
 160 int fc0013_set_freq(void *dev, uint32_t freq) {
 161         return fc0013_set_params(dev, freq, 6000000);
 162 }
 163 int fc0013_set_bw(void *dev, int bw) { return 0; }
 164 int _fc0013_set_gain(void *dev, int gain) { return fc0013_set_lna_gain(dev, gain); }
 165
 166 int fc2580_init(void *dev) { return fc2580_Initialize(dev); }
 167 int fc2580_exit(void *dev) { return 0; }
 168 int _fc2580_set_freq(void *dev, uint32_t freq) {
 169         return fc2580_SetRfFreqHz(dev, freq);
 170 }
 171 int fc2580_set_bw(void *dev, int bw) { return fc2580_SetBandwidthMode(dev, 1); }
 172 int fc2580_set_gain(void *dev, int gain) { return 0; }
 173 int fc2580_set_gain_mode(void *dev, int manual) { return 0; }
 174
 175 int r820t_init(void *dev) {
 176         int r = R828_Init(dev);
 177         r820t_SetStandardMode(dev, DVB_T_6M);
 178         return r;
 179 }
 180 int r820t_exit(void *dev) { return 0; }
 181 int r820t_set_freq(void *dev, uint32_t freq) { return r820t_SetRfFreqHz(dev, freq); }
 182 int r820t_set_bw(void *dev, int bw) { return 0; }
 183 int r820t_set_gain(void *dev, int gain) { return R828_SetRfGain(dev, gain); }
 184 int r820t_set_gain_mode(void *dev, int manual) { return R828_RfGainMode(dev, manual); }
 185
 186 /* definition order must match enum rtlsdr_tuner */
 187 static rtlsdr_tuner_iface_t tuners[] = {
 188         {
 189                 NULL, NULL, NULL, NULL, NULL, NULL, NULL /* dummy for unknown tuners */
 190         },
 191         {
 192                 e4000_init, e4000_exit,
 193                 e4000_set_freq, e4000_set_bw, e4000_set_gain, e4000_set_if_gain,
 194                 e4000_set_gain_mode
 195         },
 196         {
 197                 _fc0012_init, fc0012_exit,
 198                 fc0012_set_freq, fc0012_set_bw, _fc0012_set_gain, NULL,
 199                 fc0012_set_gain_mode
 200         },
 201         {
 202                 _fc0013_init, fc0013_exit,
 203                 fc0013_set_freq, fc0013_set_bw, _fc0013_set_gain, NULL,
 204                 fc0013_set_gain_mode
 205         },
 206         {
 207                 fc2580_init, fc2580_exit,
 208                 _fc2580_set_freq, fc2580_set_bw, fc2580_set_gain, NULL,
 209                 fc2580_set_gain_mode
 210         },
 211         {
 212                 r820t_init, r820t_exit,
 213                 r820t_set_freq, r820t_set_bw, r820t_set_gain, NULL,
 214                 r820t_set_gain_mode
 215         },
 216 };
 217
 218 typedef struct rtlsdr_dongle {
 219         uint16_t vid;
 220         uint16_t pid;
 221         const char *name;
 222 } rtlsdr_dongle_t;
 223
 224 /*
 225  * Please add your device here and send a patch to osmocom-sdr@lists.osmocom.org
 226  */
 227 static rtlsdr_dongle_t known_devices[] = {
 228         { 0x0bda, 0x2832, "Generic RTL2832U (e.g. hama nano)" },
 229         { 0x0bda, 0x2838, "ezcap USB 2.0 DVB-T/DAB/FM dongle" },
 230         { 0x0ccd, 0x00a9, "Terratec Cinergy T Stick Black (rev 1)" },
 231         { 0x0ccd, 0x00b3, "Terratec NOXON DAB/DAB+ USB dongle (rev 1)" },
 232         { 0x0ccd, 0x00b4, "Terratec NOXON DAB/DAB+ USB dongle (rev 1)" },
 233         { 0x0ccd, 0x00b7, "Terratec NOXON DAB/DAB+ USB dongle (rev 1)" },
 234         { 0x0ccd, 0x00c6, "Terratec NOXON DAB/DAB+ USB dongle (rev 1)" },
 235         { 0x0ccd, 0x00d3, "Terratec Cinergy T Stick RC (Rev.3)" },
 236         { 0x0ccd, 0x00d7, "Terratec T Stick PLUS" },
 237         { 0x0ccd, 0x00e0, "Terratec NOXON DAB/DAB+ USB dongle (rev 2)" },
 238         { 0x1554, 0x5020, "PixelView PV-DT235U(RN)" },
 239         { 0x185b, 0x0620, "Compro Videomate U620F"},
 240         { 0x185b, 0x0650, "Compro Videomate U650F"},
 241         { 0x185b, 0x0680, "Compro Videomate U680F"},
 242         { 0x1f4d, 0xa803, "Sweex DVB-T USB" },
 243         { 0x1f4d, 0xb803, "GTek T803" },
 244         { 0x1f4d, 0xc803, "Lifeview LV5TDeluxe" },
 245         { 0x1f4d, 0xd286, "MyGica TD312" },
 246         { 0x1f4d, 0xd803, "PROlectrix DV107669" },
 247         { 0x1b80, 0xd398, "Zaapa ZT-MINDVBZP" },
 248         { 0x1b80, 0xd3a4, "Twintech UT-40" },
 249         { 0x1d19, 0x1101, "Dexatek DK DVB-T Dongle (Logilink VG0002A)" },
 250         { 0x1d19, 0x1102, "Dexatek DK DVB-T Dongle (MSI DigiVox mini II V3.0)" },
 251         { 0x1d19, 0x1103, "Dexatek Technology Ltd. DK 5217 DVB-T Dongle" },
 252         { 0x1d19, 0x1104, "MSI DigiVox Micro HD" },
 253         { 0x0458, 0x707f, "Genius TVGo DVB-T03 USB dongle (Ver. B)" },
 254         { 0x1b80, 0xd393, "GIGABYTE GT-U7300" },
 255         { 0x1b80, 0xd394, "DIKOM USB-DVBT HD" },
 256         { 0x1b80, 0xd395, "Peak 102569AGPK" },
 257         { 0x1b80, 0xd39d, "SVEON STV20 DVB-T USB & FM" },
 258 };
 259
 260 #define DEFAULT_BUF_NUMBER      32
 261 #define DEFAULT_BUF_LENGTH      (16 * 32 * 512)
 262
 263 #define DEF_RTL_XTAL_FREQ       28800000
 264 #define MIN_RTL_XTAL_FREQ       (DEF_RTL_XTAL_FREQ - 1000)
 265 #define MAX_RTL_XTAL_FREQ       (DEF_RTL_XTAL_FREQ + 1000)
 266
 267 #define MAX_SAMP_RATE           3200000
 268
 269 #define CTRL_IN         (LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_IN)
 270 #define CTRL_OUT        (LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT)
 271 #define CTRL_TIMEOUT    300
 272 #define BULK_TIMEOUT    0
 273
 274 #define EEPROM_ADDR     0xa0
 275
 276 enum usb_reg {
 277         USB_SYSCTL              = 0x2000,
 278         USB_CTRL                = 0x2010,
 279         USB_STAT                = 0x2014,
 280         USB_EPA_CFG             = 0x2144,
 281         USB_EPA_CTL             = 0x2148,
 282         USB_EPA_MAXPKT          = 0x2158,
 283         USB_EPA_MAXPKT_2        = 0x215a,
 284         USB_EPA_FIFO_CFG        = 0x2160,
 285 };
 286
 287 enum sys_reg {
 288         DEMOD_CTL               = 0x3000,
 289         GPO                     = 0x3001,
 290         GPI                     = 0x3002,
 291         GPOE                    = 0x3003,
 292         GPD                     = 0x3004,
 293         SYSINTE                 = 0x3005,
 294         SYSINTS                 = 0x3006,
 295         GP_CFG0                 = 0x3007,
 296         GP_CFG1                 = 0x3008,
 297         SYSINTE_1               = 0x3009,
 298         SYSINTS_1               = 0x300a,
 299         DEMOD_CTL_1             = 0x300b,
 300         IR_SUSPEND              = 0x300c,
 301 };
 302
 303 enum blocks {
 304         DEMODB                  = 0,
 305         USBB                    = 1,
 306         SYSB                    = 2,
 307         TUNB                    = 3,
 308         ROMB                    = 4,
 309         IRB                     = 5,
 310         IICB                    = 6,
 311 };
 312
 313 int rtlsdr_read_array(rtlsdr_dev_t *dev, uint8_t block, uint16_t addr, uint8_t *array, uint8_t len)
 314 {
 315         int r;
 316         uint16_t index = (block << 8);
 317
 318         r = libusb_control_transfer(dev->devh, CTRL_IN, 0, addr, index, array, len, CTRL_TIMEOUT);
 319 #if 0
 320         if (r < 0)
 321                 fprintf(stderr, "%s failed with %d\n", __FUNCTION__, r);
 322 #endif
 323         return r;
 324 }
 325
 326 int rtlsdr_write_array(rtlsdr_dev_t *dev, uint8_t block, uint16_t addr, uint8_t *array, uint8_t len)
 327 {
 328         int r;
 329         uint16_t index = (block << 8) | 0x10;
 330
 331         r = libusb_control_transfer(dev->devh, CTRL_OUT, 0, addr, index, array, len, CTRL_TIMEOUT);
 332 #if 0
 333         if (r < 0)
 334                 fprintf(stderr, "%s failed with %d\n", __FUNCTION__, r);
 335 #endif
 336         return r;
 337 }
 338
 339 int rtlsdr_i2c_write_reg(rtlsdr_dev_t *dev, uint8_t i2c_addr, uint8_t reg, uint8_t val)
 340 {
 341         uint16_t addr = i2c_addr;
 342         uint8_t data[2];
 343
 344         data[0] = reg;
 345         data[1] = val;
 346         return rtlsdr_write_array(dev, IICB, addr, (uint8_t *)&data, 2);
 347 }
 348
 349 uint8_t rtlsdr_i2c_read_reg(rtlsdr_dev_t *dev, uint8_t i2c_addr, uint8_t reg)
 350 {
 351         uint16_t addr = i2c_addr;
 352         uint8_t data = 0;
 353
 354         rtlsdr_write_array(dev, IICB, addr, &reg, 1);
 355         rtlsdr_read_array(dev, IICB, addr, &data, 1);
 356
 357         return data;
 358 }
 359
 360 /* TODO clean this up again */
 361 int e4k_reg_write(struct e4k_state *e4k, uint8_t reg, uint8_t val)
 362 {
 363         return rtlsdr_i2c_write_reg((rtlsdr_dev_t*)e4k->rtl_dev, e4k->i2c_addr, reg, val);}
 364
 365 uint8_t e4k_reg_read(struct e4k_state *e4k, uint8_t reg)
 366 {
 367         return rtlsdr_i2c_read_reg((rtlsdr_dev_t*)e4k->rtl_dev, e4k->i2c_addr, reg);
 368 }
 369
 370 int rtlsdr_i2c_write(rtlsdr_dev_t *dev, uint8_t i2c_addr, uint8_t *buffer, int len)
 371 {
 372         uint16_t addr = i2c_addr;
 373
 374         if (!dev)
 375                 return -1;
 376
 377         return rtlsdr_write_array(dev, IICB, addr, buffer, len);
 378 }
 379
 380 int rtlsdr_i2c_read(rtlsdr_dev_t *dev, uint8_t i2c_addr, uint8_t *buffer, int len)
 381 {
 382         uint16_t addr = i2c_addr;
 383
 384         if (!dev)
 385                 return -1;
 386
 387         return rtlsdr_read_array(dev, IICB, addr, buffer, len);
 388 }
 389
 390 uint16_t rtlsdr_read_reg(rtlsdr_dev_t *dev, uint8_t block, uint16_t addr, uint8_t len)
 391 {
 392         int r;
 393         unsigned char data[2];
 394         uint16_t index = (block << 8);
 395         uint16_t reg;
 396
 397         r = libusb_control_transfer(dev->devh, CTRL_IN, 0, addr, index, data, len, CTRL_TIMEOUT);
 398
 399         if (r < 0)
 400                 fprintf(stderr, "%s failed with %d\n", __FUNCTION__, r);
 401
 402         reg = (data[1] << 8) | data[0];
 403
 404         return reg;
 405 }
 406
 407 int rtlsdr_write_reg(rtlsdr_dev_t *dev, uint8_t block, uint16_t addr, uint16_t val, uint8_t len)
 408 {
 409         int r;
 410         unsigned char data[2];
 411
 412         uint16_t index = (block << 8) | 0x10;
 413
 414         if (len == 1)
 415                 data[0] = val & 0xff;
 416         else
 417                 data[0] = val >> 8;
 418
 419         data[1] = val & 0xff;
 420
 421         r = libusb_control_transfer(dev->devh, CTRL_OUT, 0, addr, index, data, len, CTRL_TIMEOUT);
 422
 423         if (r < 0)
 424                 fprintf(stderr, "%s failed with %d\n", __FUNCTION__, r);
 425
 426         return r;
 427 }
 428
 429 uint16_t rtlsdr_demod_read_reg(rtlsdr_dev_t *dev, uint8_t page, uint16_t addr, uint8_t len)
 430 {
 431         int r;
 432         unsigned char data[2];
 433
 434         uint16_t index = page;
 435         uint16_t reg;
 436         addr = (addr << 8) | 0x20;
 437
 438         r = libusb_control_transfer(dev->devh, CTRL_IN, 0, addr, index, data, len, CTRL_TIMEOUT);
 439
 440         if (r < 0)
 441                 fprintf(stderr, "%s failed with %d\n", __FUNCTION__, r);
 442
 443         reg = (data[1] << 8) | data[0];
 444
 445         return reg;
 446 }
 447
 448 int rtlsdr_demod_write_reg(rtlsdr_dev_t *dev, uint8_t page, uint16_t addr, uint16_t val, uint8_t len)
 449 {
 450         int r;
 451         unsigned char data[2];
 452         uint16_t index = 0x10 | page;
 453         addr = (addr << 8) | 0x20;
 454
 455         if (len == 1)
 456                 data[0] = val & 0xff;
 457         else
 458                 data[0] = val >> 8;
 459
 460         data[1] = val & 0xff;
 461
 462         r = libusb_control_transfer(dev->devh, CTRL_OUT, 0, addr, index, data, len, CTRL_TIMEOUT);
 463
 464         if (r < 0)
 465                 fprintf(stderr, "%s failed with %d\n", __FUNCTION__, r);
 466
 467         rtlsdr_demod_read_reg(dev, 0x0a, 0x01, 1);
 468
 469         return (r == len) ? 0 : -1;
 470 }
 471
 472 void rtlsdr_set_gpio_bit(rtlsdr_dev_t *dev, uint8_t gpio, int val)
 473 {
 474         uint8_t r;
 475
 476         gpio = 1 << gpio;
 477         r = rtlsdr_read_reg(dev, SYSB, GPO, 1);
 478         r = val ? (r | gpio) : (r & ~gpio);
 479         rtlsdr_write_reg(dev, SYSB, GPO, r, 1);
 480 }
 481
 482 void rtlsdr_set_gpio_output(rtlsdr_dev_t *dev, uint8_t gpio)
 483 {
 484         int r;
 485         gpio = 1 << gpio;
 486
 487         r = rtlsdr_read_reg(dev, SYSB, GPD, 1);
 488         rtlsdr_write_reg(dev, SYSB, GPO, r & ~gpio, 1);
 489         r = rtlsdr_read_reg(dev, SYSB, GPOE, 1);
 490         rtlsdr_write_reg(dev, SYSB, GPOE, r | gpio, 1);
 491 }
 492
 493 void rtlsdr_set_i2c_repeater(rtlsdr_dev_t *dev, int on)
 494 {
 495         rtlsdr_demod_write_reg(dev, 1, 0x01, on ? 0x18 : 0x10, 1);
 496 }
 497
 498 void rtlsdr_init_baseband(rtlsdr_dev_t *dev)
 499 {
 500         unsigned int i;
 501
 502         /* default FIR coefficients used for DAB/FM by the Windows driver,
 503          * the DVB driver uses different ones */
 504         uint8_t fir_coeff[] = {
 505                 0xca, 0xdc, 0xd7, 0xd8, 0xe0, 0xf2, 0x0e, 0x35, 0x06, 0x50,
 506                 0x9c, 0x0d, 0x71, 0x11, 0x14, 0x71, 0x74, 0x19, 0x41, 0xa5,
 507         };
 508
 509         /* initialize USB */
 510         rtlsdr_write_reg(dev, USBB, USB_SYSCTL, 0x09, 1);
 511         rtlsdr_write_reg(dev, USBB, USB_EPA_MAXPKT, 0x0002, 2);
 512         rtlsdr_write_reg(dev, USBB, USB_EPA_CTL, 0x1002, 2);
 513
 514         /* poweron demod */
 515         rtlsdr_write_reg(dev, SYSB, DEMOD_CTL_1, 0x22, 1);
 516         rtlsdr_write_reg(dev, SYSB, DEMOD_CTL, 0xe8, 1);
 517
 518         /* reset demod (bit 3, soft_rst) */
 519         rtlsdr_demod_write_reg(dev, 1, 0x01, 0x14, 1);
 520         rtlsdr_demod_write_reg(dev, 1, 0x01, 0x10, 1);
 521
 522         /* disable spectrum inversion and adjacent channel rejection */
 523         rtlsdr_demod_write_reg(dev, 1, 0x15, 0x00, 1);
 524         rtlsdr_demod_write_reg(dev, 1, 0x16, 0x0000, 2);
 525
 526         /* clear both DDC shift and IF frequency registers  */
 527         for (i = 0; i < 6; i++)
 528                 rtlsdr_demod_write_reg(dev, 1, 0x16 + i, 0x00, 1);
 529
 530         /* set FIR coefficients */
 531         for (i = 0; i < sizeof (fir_coeff); i++)
 532                 rtlsdr_demod_write_reg(dev, 1, 0x1c + i, fir_coeff[i], 1);
 533
 534         /* enable SDR mode, disable DAGC (bit 5) */
 535         rtlsdr_demod_write_reg(dev, 0, 0x19, 0x05, 1);
 536
 537         /* init FSM state-holding register */
 538         rtlsdr_demod_write_reg(dev, 1, 0x93, 0xf0, 1);
 539         rtlsdr_demod_write_reg(dev, 1, 0x94, 0x0f, 1);
 540
 541         /* disable AGC (en_dagc, bit 0) (this seems to have no effect) */
 542         rtlsdr_demod_write_reg(dev, 1, 0x11, 0x00, 1);
 543
 544         /* disable RF and IF AGC loop */
 545         rtlsdr_demod_write_reg(dev, 1, 0x04, 0x00, 1);
 546
 547         /* disable PID filter (enable_PID = 0) */
 548         rtlsdr_demod_write_reg(dev, 0, 0x61, 0x60, 1);
 549
 550         /* opt_adc_iq = 0, default ADC_I/ADC_Q datapath */
 551         rtlsdr_demod_write_reg(dev, 0, 0x06, 0x80, 1);
 552
 553         /* Enable Zero-IF mode (en_bbin bit), DC cancellation (en_dc_est),
 554          * IQ estimation/compensation (en_iq_comp, en_iq_est) */
 555         rtlsdr_demod_write_reg(dev, 1, 0xb1, 0x1b, 1);
 556
 557         /* disable 4.096 MHz clock output on pin TP_CK0 */
 558         rtlsdr_demod_write_reg(dev, 0, 0x0d, 0x83, 1);
 559 }
 560
 561 int rtlsdr_deinit_baseband(rtlsdr_dev_t *dev)
 562 {
 563         int r = 0;
 564
 565         if (!dev)
 566                 return -1;
 567
 568         if (dev->tuner && dev->tuner->exit) {
 569                 rtlsdr_set_i2c_repeater(dev, 1);
 570                 r = dev->tuner->exit(dev); /* deinitialize tuner */
 571                 rtlsdr_set_i2c_repeater(dev, 0);
 572         }
 573
 574         /* poweroff demodulator and ADCs */
 575         rtlsdr_write_reg(dev, SYSB, DEMOD_CTL, 0x20, 1);
 576
 577         return r;
 578 }
 579
 580 int rtlsdr_set_if_freq(rtlsdr_dev_t *dev, uint32_t freq)
 581 {
 582         uint32_t rtl_xtal;
 583         int32_t if_freq;
 584         uint8_t tmp;
 585         int r;
 586
 587         if (!dev)
 588                 return -1;
 589
 590         /* read corrected clock value */
 591         if (rtlsdr_get_xtal_freq(dev, &rtl_xtal, NULL))
 592                 return -2;
 593
 594         if_freq = ((freq * TWO_POW(22)) / rtl_xtal) * (-1);
 595
 596         tmp = (if_freq >> 16) & 0x3f;
 597         r = rtlsdr_demod_write_reg(dev, 1, 0x19, tmp, 1);
 598         tmp = (if_freq >> 8) & 0xff;
 599         r |= rtlsdr_demod_write_reg(dev, 1, 0x1a, tmp, 1);
 600         tmp = if_freq & 0xff;
 601         r |= rtlsdr_demod_write_reg(dev, 1, 0x1b, tmp, 1);
 602
 603         return r;
 604 }
 605
 606 int rtlsdr_set_sample_freq_correction(rtlsdr_dev_t *dev, int ppm)
 607 {
 608         int r = 0;
 609         uint8_t tmp;
 610         int16_t offs = ppm * (-1) * TWO_POW(24) / 1000000;
 611
 612         tmp = offs & 0xff;
 613         r |= rtlsdr_demod_write_reg(dev, 1, 0x3f, tmp, 1);
 614         tmp = (offs >> 8) & 0x3f;
 615         r |= rtlsdr_demod_write_reg(dev, 1, 0x3e, tmp, 1);
 616
 617         return r;
 618 }
 619
 620 int rtlsdr_set_xtal_freq(rtlsdr_dev_t *dev, uint32_t rtl_freq, uint32_t tuner_freq)
 621 {
 622         int r = 0;
 623
 624         if (!dev)
 625                 return -1;
 626
 627         if (rtl_freq > 0 &&
 628                 (rtl_freq < MIN_RTL_XTAL_FREQ || rtl_freq > MAX_RTL_XTAL_FREQ))
 629                 return -2;
 630
 631         if (rtl_freq > 0 && dev->rtl_xtal != rtl_freq) {
 632                 dev->rtl_xtal = rtl_freq;
 633
 634                 /* update xtal-dependent settings */
 635                 if (dev->rate)
 636                         r = rtlsdr_set_sample_rate(dev, dev->rate);
 637         }
 638
 639         if (dev->tun_xtal != tuner_freq) {
 640                 if (0 == tuner_freq)
 641                         dev->tun_xtal = dev->rtl_xtal;
 642                 else
 643                         dev->tun_xtal = tuner_freq;
 644
 645                 /* read corrected clock value into e4k structure */
 646                 if (rtlsdr_get_xtal_freq(dev, NULL, &dev->e4k_s.vco.fosc))
 647                         return -3;
 648
 649                 /* update xtal-dependent settings */
 650                 if (dev->freq)
 651                         r = rtlsdr_set_center_freq(dev, dev->freq);
 652         }
 653
 654         return r;
 655 }
 656
 657 int rtlsdr_get_xtal_freq(rtlsdr_dev_t *dev, uint32_t *rtl_freq, uint32_t *tuner_freq)
 658 {
 659         if (!dev)
 660                 return -1;
 661
 662         #define APPLY_PPM_CORR(val,ppm) (((val) * (1.0 + (ppm) / 1e6)))
 663
 664         if (rtl_freq)
 665                 *rtl_freq = (uint32_t) APPLY_PPM_CORR(dev->rtl_xtal, dev->corr);
 666
 667         if (tuner_freq)
 668                 *tuner_freq = (uint32_t) APPLY_PPM_CORR(dev->tun_xtal, dev->corr);
 669
 670         return 0;
 671 }
 672
 673 int rtlsdr_get_usb_strings(rtlsdr_dev_t *dev, char *manufact, char *product,
 674                             char *serial)
 675 {
 676         struct libusb_device_descriptor dd;
 677         libusb_device *device = NULL;
 678         const int buf_max = 256;
 679         int r = 0;
 680
 681         if (!dev || !dev->devh)
 682                 return -1;
 683
 684         device = libusb_get_device(dev->devh);
 685
 686         r = libusb_get_device_descriptor(device, &dd);
 687         if (r < 0)
 688                 return -1;
 689
 690         if (manufact) {
 691                 memset(manufact, 0, buf_max);
 692                 libusb_get_string_descriptor_ascii(dev->devh, dd.iManufacturer,
 693                                                    (unsigned char *)manufact,
 694                                                    buf_max);
 695         }
 696
 697         if (product) {
 698                 memset(product, 0, buf_max);
 699                 libusb_get_string_descriptor_ascii(dev->devh, dd.iProduct,
 700                                                    (unsigned char *)product,
 701                                                    buf_max);
 702         }
 703
 704         if (serial) {
 705                 memset(serial, 0, buf_max);
 706                 libusb_get_string_descriptor_ascii(dev->devh, dd.iSerialNumber,
 707                                                    (unsigned char *)serial,
 708                                                    buf_max);
 709         }
 710
 711         return 0;
 712 }
 713
 714 int rtlsdr_write_eeprom(rtlsdr_dev_t *dev, uint8_t *data, uint8_t offset, uint16_t len)
 715 {
 716         int r = 0;
 717         int i;
 718         uint8_t cmd[2];
 719
 720         if (!dev)
 721                 return -1;
 722
 723         if ((len + offset) > 256)
 724                 return -2;
 725
 726         for (i = 0; i < len; i++) {
 727                 cmd[0] = i + offset;
 728                 r = rtlsdr_write_array(dev, IICB, EEPROM_ADDR, cmd, 1);
 729                 r = rtlsdr_read_array(dev, IICB, EEPROM_ADDR, &cmd[1], 1);
 730
 731                 /* only write the byte if it differs */
 732                 if (cmd[1] == data[i])
 733                         continue;
 734
 735                 cmd[1] = data[i];
 736                 r = rtlsdr_write_array(dev, IICB, EEPROM_ADDR, cmd, 2);
 737                 if (r != sizeof(cmd))
 738                         return -3;
 739
 740                 /* for some EEPROMs (e.g. ATC 240LC02) we need a delay
 741                  * between write operations, otherwise they will fail */
 742 #ifdef _WIN32
 743                 Sleep(5);
 744 #else
 745                 usleep(5000);
 746 #endif
 747         }
 748
 749         return 0;
 750 }
 751
 752 int rtlsdr_read_eeprom(rtlsdr_dev_t *dev, uint8_t *data, uint8_t offset, uint16_t len)
 753 {
 754         int r = 0;
 755         int i;
 756
 757         if (!dev)
 758                 return -1;
 759
 760         if ((len + offset) > 256)
 761                 return -2;
 762
 763         r = rtlsdr_write_array(dev, IICB, EEPROM_ADDR, &offset, 1);
 764         if (r < 0)
 765                 return -3;
 766
 767         for (i = 0; i < len; i++) {
 768                 r = rtlsdr_read_array(dev, IICB, EEPROM_ADDR, data + i, 1);
 769
 770                 if (r < 0)
 771                         return -3;
 772         }
 773
 774         return r;
 775 }
 776
 777 int rtlsdr_set_center_freq(rtlsdr_dev_t *dev, uint32_t freq)
 778 {
 779         int r = -1;
 780
 781         if (!dev || !dev->tuner)
 782                 return -1;
 783
 784         if (dev->direct_sampling) {
 785                 r = rtlsdr_set_if_freq(dev, freq);
 786         } else if (dev->tuner && dev->tuner->set_freq) {
 787                 rtlsdr_set_i2c_repeater(dev, 1);
 788                 r = dev->tuner->set_freq(dev, freq - dev->offs_freq);
 789                 rtlsdr_set_i2c_repeater(dev, 0);
 790         }
 791
 792         if (!r)
 793                 dev->freq = freq;
 794         else
 795                 dev->freq = 0;
 796
 797         return r;
 798 }
 799
 800 uint32_t rtlsdr_get_center_freq(rtlsdr_dev_t *dev)
 801 {
 802         if (!dev)
 803                 return 0;
 804
 805         return dev->freq;
 806 }
 807
 808 int rtlsdr_set_freq_correction(rtlsdr_dev_t *dev, int ppm)
 809 {
 810         int r = 0;
 811
 812         if (!dev)
 813                 return -1;
 814
 815         if (dev->corr == ppm)
 816                 return -2;
 817
 818         dev->corr = ppm;
 819
 820         r |= rtlsdr_set_sample_freq_correction(dev, ppm);
 821
 822         /* read corrected clock value into e4k structure */
 823         if (rtlsdr_get_xtal_freq(dev, NULL, &dev->e4k_s.vco.fosc))
 824                 return -3;
 825
 826         if (dev->freq) /* retune to apply new correction value */
 827                 r |= rtlsdr_set_center_freq(dev, dev->freq);
 828
 829         return r;
 830 }
 831
 832 int rtlsdr_get_freq_correction(rtlsdr_dev_t *dev)
 833 {
 834         if (!dev)
 835                 return 0;
 836
 837         return dev->corr;
 838 }
 839
 840 enum rtlsdr_tuner rtlsdr_get_tuner_type(rtlsdr_dev_t *dev)
 841 {
 842         if (!dev)
 843                 return RTLSDR_TUNER_UNKNOWN;
 844
 845         return dev->tuner_type;
 846 }
 847
 848 int rtlsdr_get_tuner_gains(rtlsdr_dev_t *dev, int *gains)
 849 {
 850         /* all gain values are expressed in tenths of a dB */
 851         const int e4k_gains[] = { -10, 15, 40, 65, 90, 115, 140, 165, 190, 215,
 852                                   240, 290, 340, 420 };
 853         const int fc0012_gains[] = { -99, -40, 71, 179, 192 };
 854         const int fc0013_gains[] = { -99, -73, -65, -63, -60, -58, -54, 58, 61,
 855                                        63, 65, 67, 68, 70, 71, 179, 181, 182,
 856                                        184, 186, 188, 191, 197 };
 857         const int fc2580_gains[] = { 0 /* no gain values */ };
 858         const int r820t_gains[] = { 0, 9, 14, 27, 37, 77, 87, 125, 144, 157,
 859                                      166, 197, 207, 229, 254, 280, 297, 328,
 860                                      338, 364, 372, 386, 402, 421, 434, 439,
 861                                      445, 480, 496 };
 862         const int unknown_gains[] = { 0 /* no gain values */ };
 863
 864         const int *ptr = NULL;
 865         int len = 0;
 866
 867         if (!dev)
 868                 return -1;
 869
 870         switch (dev->tuner_type) {
 871         case RTLSDR_TUNER_E4000:
 872                 ptr = e4k_gains; len = sizeof(e4k_gains);
 873                 break;
 874         case RTLSDR_TUNER_FC0012:
 875                 ptr = fc0012_gains; len = sizeof(fc0012_gains);
 876                 break;
 877         case RTLSDR_TUNER_FC0013:
 878                 ptr = fc0013_gains; len = sizeof(fc0013_gains);
 879                 break;
 880         case RTLSDR_TUNER_FC2580:
 881                 ptr = fc2580_gains; len = sizeof(fc2580_gains);
 882                 break;
 883         case RTLSDR_TUNER_R820T:
 884                 ptr = r820t_gains; len = sizeof(r820t_gains);
 885                 break;
 886         default:
 887                 ptr = unknown_gains; len = sizeof(unknown_gains);
 888                 break;
 889         }
 890
 891         if (!gains) { /* no buffer provided, just return the count */
 892                 return len / sizeof(int);
 893         } else {
 894                 if (len)
 895                         memcpy(gains, ptr, len);
 896
 897                 return len / sizeof(int);
 898         }
 899 }
 900
 901 int rtlsdr_set_tuner_gain(rtlsdr_dev_t *dev, int gain)
 902 {
 903         int r = 0;
 904
 905         if (!dev || !dev->tuner)
 906                 return -1;
 907
 908         if (dev->tuner->set_gain) {
 909                 rtlsdr_set_i2c_repeater(dev, 1);
 910                 r = dev->tuner->set_gain((void *)dev, gain);
 911                 rtlsdr_set_i2c_repeater(dev, 0);
 912         }
 913
 914         if (!r)
 915                 dev->gain = gain;
 916         else
 917                 dev->gain = 0;
 918
 919         return r;
 920 }
 921
 922 int rtlsdr_get_tuner_gain(rtlsdr_dev_t *dev)
 923 {
 924         if (!dev)
 925                 return 0;
 926
 927         return dev->gain;
 928 }
 929
 930 int rtlsdr_set_tuner_if_gain(rtlsdr_dev_t *dev, int stage, int gain)
 931 {
 932         int r = 0;
 933
 934         if (!dev || !dev->tuner)
 935                 return -1;
 936
 937         if (dev->tuner->set_if_gain) {
 938                 rtlsdr_set_i2c_repeater(dev, 1);
 939                 r = dev->tuner->set_if_gain(dev, stage, gain);
 940                 rtlsdr_set_i2c_repeater(dev, 0);
 941         }
 942
 943         return r;
 944 }
 945
 946 int rtlsdr_set_tuner_gain_mode(rtlsdr_dev_t *dev, int mode)
 947 {
 948         int r = 0;
 949
 950         if (!dev || !dev->tuner)
 951                 return -1;
 952
 953         if (dev->tuner->set_gain_mode) {
 954                 rtlsdr_set_i2c_repeater(dev, 1);
 955                 r = dev->tuner->set_gain_mode((void *)dev, mode);
 956                 rtlsdr_set_i2c_repeater(dev, 0);
 957         }
 958
 959         return r;
 960 }
 961
 962 int rtlsdr_set_sample_rate(rtlsdr_dev_t *dev, uint32_t samp_rate)
 963 {
 964         int r = 0;
 965         uint16_t tmp;
 966         uint32_t rsamp_ratio;
 967         double real_rate;
 968
 969         if (!dev)
 970                 return -1;
 971
 972         /* check for the maximum rate the resampler supports */
 973         if (samp_rate > MAX_SAMP_RATE)
 974                 samp_rate = MAX_SAMP_RATE;
 975
 976         rsamp_ratio = (dev->rtl_xtal * TWO_POW(22)) / samp_rate;
 977         rsamp_ratio &= ~3;
 978
 979         real_rate = (dev->rtl_xtal * TWO_POW(22)) / rsamp_ratio;
 980
 981         if ( ((double)samp_rate) != real_rate )
 982                 fprintf(stderr, "Exact sample rate is: %f Hz\n", real_rate);
 983
 984         if (dev->tuner && dev->tuner->set_bw) {
 985                 rtlsdr_set_i2c_repeater(dev, 1);
 986                 dev->tuner->set_bw(dev, (int)real_rate);
 987                 rtlsdr_set_i2c_repeater(dev, 0);
 988         }
 989
 990         dev->rate = (uint32_t)real_rate;
 991
 992         tmp = (rsamp_ratio >> 16);
 993         r |= rtlsdr_demod_write_reg(dev, 1, 0x9f, tmp, 2);
 994         tmp = rsamp_ratio & 0xffff;
 995         r |= rtlsdr_demod_write_reg(dev, 1, 0xa1, tmp, 2);
 996
 997         r |= rtlsdr_set_sample_freq_correction(dev, dev->corr);
 998
 999         /* reset demod (bit 3, soft_rst) */
1000         r |= rtlsdr_demod_write_reg(dev, 1, 0x01, 0x14, 1);
1001         r |= rtlsdr_demod_write_reg(dev, 1, 0x01, 0x10, 1);
1002
1003         /* recalculate offset frequency if offset tuning is enabled */
1004         if (dev->offs_freq)
1005                 rtlsdr_set_offset_tuning(dev, 1);
1006
1007         return r;
1008 }
1009
1010 uint32_t rtlsdr_get_sample_rate(rtlsdr_dev_t *dev)
1011 {
1012         if (!dev)
1013                 return 0;
1014
1015         return dev->rate;
1016 }
1017
1018 int rtlsdr_set_testmode(rtlsdr_dev_t *dev, int on)
1019 {
1020         if (!dev)
1021                 return -1;
1022
1023         return rtlsdr_demod_write_reg(dev, 0, 0x19, on ? 0x03 : 0x05, 1);
1024 }
1025
1026 int rtlsdr_set_agc_mode(rtlsdr_dev_t *dev, int on)
1027 {
1028         if (!dev)
1029                 return -1;
1030
1031         return rtlsdr_demod_write_reg(dev, 0, 0x19, on ? 0x25 : 0x05, 1);
1032 }
1033
1034 int rtlsdr_set_direct_sampling(rtlsdr_dev_t *dev, int on)
1035 {
1036         int r = 0;
1037
1038         if (!dev)
1039                 return -1;
1040
1041         if (on) {
1042                 if (dev->tuner && dev->tuner->exit) {
1043                         rtlsdr_set_i2c_repeater(dev, 1);
1044                         r = dev->tuner->exit(dev);
1045                         rtlsdr_set_i2c_repeater(dev, 0);
1046                 }
1047
1048                 /* disable Zero-IF mode */
1049                 r |= rtlsdr_demod_write_reg(dev, 1, 0xb1, 0x1a, 1);
1050
1051                 /* disable spectrum inversion */
1052                 r |= rtlsdr_demod_write_reg(dev, 1, 0x15, 0x00, 1);
1053
1054                 /* only enable In-phase ADC input */
1055                 r |= rtlsdr_demod_write_reg(dev, 0, 0x08, 0x4d, 1);
1056
1057                 /* swap I and Q ADC, this allows to select between two inputs */
1058                 r |= rtlsdr_demod_write_reg(dev, 0, 0x06, (on > 1) ? 0x90 : 0x80, 1);
1059
1060                 fprintf(stderr, "Enabled direct sampling mode, input %i\n", on);
1061                 dev->direct_sampling = on;
1062         } else {
1063                 if (dev->tuner && dev->tuner->init) {
1064                         rtlsdr_set_i2c_repeater(dev, 1);
1065                         r |= dev->tuner->init(dev);
1066                         rtlsdr_set_i2c_repeater(dev, 0);
1067                 }
1068
1069                 if (dev->tuner_type == RTLSDR_TUNER_R820T) {
1070                         r |= rtlsdr_set_if_freq(dev, R820T_IF_FREQ);
1071
1072                         /* enable spectrum inversion */
1073                         r |= rtlsdr_demod_write_reg(dev, 1, 0x15, 0x01, 1);
1074                 } else {
1075                         r |= rtlsdr_set_if_freq(dev, 0);
1076
1077                         /* enable In-phase + Quadrature ADC input */
1078                         r |= rtlsdr_demod_write_reg(dev, 0, 0x08, 0xcd, 1);
1079
1080                         /* Enable Zero-IF mode */
1081                         r |= rtlsdr_demod_write_reg(dev, 1, 0xb1, 0x1b, 1);
1082                 }
1083
1084                 /* opt_adc_iq = 0, default ADC_I/ADC_Q datapath */
1085                 r |= rtlsdr_demod_write_reg(dev, 0, 0x06, 0x80, 1);
1086
1087                 fprintf(stderr, "Disabled direct sampling mode\n");
1088                 dev->direct_sampling = 0;
1089         }
1090
1091         r |= rtlsdr_set_center_freq(dev, dev->freq);
1092
1093         return r;
1094 }
1095
1096 int rtlsdr_get_direct_sampling(rtlsdr_dev_t *dev)
1097 {
1098         if (!dev)
1099                 return -1;
1100
1101         return dev->direct_sampling;
1102 }
1103
1104 int rtlsdr_set_offset_tuning(rtlsdr_dev_t *dev, int on)
1105 {
1106         int r = 0;
1107
1108         if (!dev)
1109                 return -1;
1110
1111         if (dev->tuner_type == RTLSDR_TUNER_R820T)
1112                 return -2;
1113
1114         if (dev->direct_sampling)
1115                 return -3;
1116
1117         /* based on keenerds 1/f noise measurements */
1118         dev->offs_freq = on ? ((dev->rate / 2) * 170 / 100) : 0;
1119         r |= rtlsdr_set_if_freq(dev, dev->offs_freq);
1120
1121         if (dev->tuner && dev->tuner->set_bw) {
1122                 rtlsdr_set_i2c_repeater(dev, 1);
1123                 dev->tuner->set_bw(dev, on ? (2 * dev->offs_freq) : dev->rate);
1124                 rtlsdr_set_i2c_repeater(dev, 0);
1125         }
1126
1127         if (dev->freq > dev->offs_freq)
1128                 r |= rtlsdr_set_center_freq(dev, dev->freq);
1129
1130         return r;
1131 }
1132
1133 int rtlsdr_get_offset_tuning(rtlsdr_dev_t *dev)
1134 {
1135         if (!dev)
1136                 return -1;
1137
1138         return (dev->offs_freq) ? 1 : 0;
1139 }
1140
1141 static rtlsdr_dongle_t *find_known_device(uint16_t vid, uint16_t pid)
1142 {
1143         unsigned int i;
1144         rtlsdr_dongle_t *device = NULL;
1145
1146         for (i = 0; i < sizeof(known_devices)/sizeof(rtlsdr_dongle_t); i++ ) {
1147                 if (known_devices[i].vid == vid && known_devices[i].pid == pid) {
1148                         device = &known_devices[i];
1149                         break;
1150                 }
1151         }
1152
1153         return device;
1154 }
1155
1156 uint32_t rtlsdr_get_device_count(void)
1157 {
1158         int i;
1159         libusb_context *ctx;
1160         libusb_device **list;
1161         uint32_t device_count = 0;
1162         struct libusb_device_descriptor dd;
1163         ssize_t cnt;
1164
1165         libusb_init(&ctx);
1166
1167         cnt = libusb_get_device_list(ctx, &list);
1168
1169         for (i = 0; i < cnt; i++) {
1170                 libusb_get_device_descriptor(list[i], &dd);
1171
1172                 if (find_known_device(dd.idVendor, dd.idProduct))
1173                         device_count++;
1174         }
1175
1176         libusb_free_device_list(list, 1);
1177
1178         libusb_exit(ctx);
1179
1180         return device_count;
1181 }
1182
1183 const char *rtlsdr_get_device_name(uint32_t index)
1184 {
1185         int i;
1186         libusb_context *ctx;
1187         libusb_device **list;
1188         struct libusb_device_descriptor dd;
1189         rtlsdr_dongle_t *device = NULL;
1190         uint32_t device_count = 0;
1191         ssize_t cnt;
1192
1193         libusb_init(&ctx);
1194
1195         cnt = libusb_get_device_list(ctx, &list);
1196
1197         for (i = 0; i < cnt; i++) {
1198                 libusb_get_device_descriptor(list[i], &dd);
1199
1200                 device = find_known_device(dd.idVendor, dd.idProduct);
1201
1202                 if (device) {
1203                         device_count++;
1204
1205                         if (index == device_count - 1)
1206                                 break;
1207                 }
1208         }
1209
1210         libusb_free_device_list(list, 1);
1211
1212         libusb_exit(ctx);
1213
1214         if (device)
1215                 return device->name;
1216         else
1217                 return "";
1218 }
1219
1220 int rtlsdr_get_device_usb_strings(uint32_t index, char *manufact,
1221                                    char *product, char *serial)
1222 {
1223         int r = -2;
1224         int i;
1225         libusb_context *ctx;
1226         libusb_device **list;
1227         struct libusb_device_descriptor dd;
1228         rtlsdr_dongle_t *device = NULL;
1229         rtlsdr_dev_t devt;
1230         uint32_t device_count = 0;
1231         ssize_t cnt;
1232
1233         libusb_init(&ctx);
1234
1235         cnt = libusb_get_device_list(ctx, &list);
1236
1237         for (i = 0; i < cnt; i++) {
1238                 libusb_get_device_descriptor(list[i], &dd);
1239
1240                 device = find_known_device(dd.idVendor, dd.idProduct);
1241
1242                 if (device) {
1243                         device_count++;
1244
1245                         if (index == device_count - 1) {
1246                                 r = libusb_open(list[i], &devt.devh);
1247                                 if (!r) {
1248                                         r = rtlsdr_get_usb_strings(&devt,
1249                                                                    manufact,
1250                                                                    product,
1251                                                                    serial);
1252                                         libusb_close(devt.devh);
1253                                 }
1254                                 break;
1255                         }
1256                 }
1257         }
1258
1259         libusb_free_device_list(list, 1);
1260
1261         libusb_exit(ctx);
1262
1263         return r;
1264 }
1265
1266 int rtlsdr_get_index_by_serial(const char *serial)
1267 {
1268         int i, cnt, r;
1269         char str[256];
1270
1271         if (!serial)
1272                 return -1;
1273
1274         cnt = rtlsdr_get_device_count();
1275
1276         if (!cnt)
1277                 return -2;
1278
1279         for (i = 0; i < cnt; i++) {
1280                 r = rtlsdr_get_device_usb_strings(i, NULL, NULL, str);
1281                 if (!r && !strcmp(serial, str))
1282                         return i;
1283         }
1284
1285         return -3;
1286 }
1287
1288 int rtlsdr_open(rtlsdr_dev_t **out_dev, uint32_t index)
1289 {
1290         int r;
1291         int i;
1292         libusb_device **list;
1293         rtlsdr_dev_t *dev = NULL;
1294         libusb_device *device = NULL;
1295         uint32_t device_count = 0;
1296         struct libusb_device_descriptor dd;
1297         uint8_t reg;
1298         ssize_t cnt;
1299
1300         dev = malloc(sizeof(rtlsdr_dev_t));
1301         if (NULL == dev)
1302                 return -ENOMEM;
1303
1304         memset(dev, 0, sizeof(rtlsdr_dev_t));
1305
1306         libusb_init(&dev->ctx);
1307
1308         cnt = libusb_get_device_list(dev->ctx, &list);
1309
1310         for (i = 0; i < cnt; i++) {
1311                 device = list[i];
1312
1313                 libusb_get_device_descriptor(list[i], &dd);
1314
1315                 if (find_known_device(dd.idVendor, dd.idProduct)) {
1316                         device_count++;
1317                 }
1318
1319                 if (index == device_count - 1)
1320                         break;
1321
1322                 device = NULL;
1323         }
1324
1325         if (!device) {
1326                 r = -1;
1327                 goto err;
1328         }
1329
1330         r = libusb_open(device, &dev->devh);
1331         if (r < 0) {
1332                 libusb_free_device_list(list, 1);
1333                 fprintf(stderr, "usb_open error %d\n", r);
1334                 goto err;
1335         }
1336
1337         libusb_free_device_list(list, 1);
1338
1339         r = libusb_claim_interface(dev->devh, 0);
1340         if (r < 0) {
1341                 fprintf(stderr, "usb_claim_interface error %d\n", r);
1342                 goto err;
1343         }
1344
1345         dev->rtl_xtal = DEF_RTL_XTAL_FREQ;
1346
1347         /* perform a dummy write, if it fails, reset the device */
1348         if (rtlsdr_write_reg(dev, USBB, USB_SYSCTL, 0x09, 1) < 0) {
1349                 fprintf(stderr, "Resetting device...\n");
1350                 libusb_reset_device(dev->devh);
1351         }
1352
1353         rtlsdr_init_baseband(dev);
1354
1355         /* Probe tuners */
1356         rtlsdr_set_i2c_repeater(dev, 1);
1357
1358         reg = rtlsdr_i2c_read_reg(dev, E4K_I2C_ADDR, E4K_CHECK_ADDR);
1359         if (reg == E4K_CHECK_VAL) {
1360                 fprintf(stderr, "Found Elonics E4000 tuner\n");
1361                 dev->tuner_type = RTLSDR_TUNER_E4000;
1362                 goto found;
1363         }
1364
1365         reg = rtlsdr_i2c_read_reg(dev, FC0013_I2C_ADDR, FC0013_CHECK_ADDR);
1366         if (reg == FC0013_CHECK_VAL) {
1367                 fprintf(stderr, "Found Fitipower FC0013 tuner\n");
1368                 dev->tuner_type = RTLSDR_TUNER_FC0013;
1369                 goto found;
1370         }
1371
1372         reg = rtlsdr_i2c_read_reg(dev, R820T_I2C_ADDR, R820T_CHECK_ADDR);
1373         if (reg == R820T_CHECK_VAL) {
1374                 fprintf(stderr, "Found Rafael Micro R820T tuner\n");
1375                 dev->tuner_type = RTLSDR_TUNER_R820T;
1376
1377                 /* disable Zero-IF mode */
1378                 rtlsdr_demod_write_reg(dev, 1, 0xb1, 0x1a, 1);
1379
1380                 /* only enable In-phase ADC input */
1381                 rtlsdr_demod_write_reg(dev, 0, 0x08, 0x4d, 1);
1382
1383                 /* the R820T uses 3.57 MHz IF for the DVB-T 6 MHz mode, and
1384                  * 4.57 MHz for the 8 MHz mode */
1385                 rtlsdr_set_if_freq(dev, R820T_IF_FREQ);
1386
1387                 /* enable spectrum inversion */
1388                 rtlsdr_demod_write_reg(dev, 1, 0x15, 0x01, 1);
1389
1390                 goto found;
1391         }
1392
1393         /* initialise GPIOs */
1394         rtlsdr_set_gpio_output(dev, 5);
1395
1396         /* reset tuner before probing */
1397         rtlsdr_set_gpio_bit(dev, 5, 1);
1398         rtlsdr_set_gpio_bit(dev, 5, 0);
1399
1400         reg = rtlsdr_i2c_read_reg(dev, FC2580_I2C_ADDR, FC2580_CHECK_ADDR);
1401         if ((reg & 0x7f) == FC2580_CHECK_VAL) {
1402                 fprintf(stderr, "Found FCI 2580 tuner\n");
1403                 dev->tuner_type = RTLSDR_TUNER_FC2580;
1404                 goto found;
1405         }
1406
1407         reg = rtlsdr_i2c_read_reg(dev, FC0012_I2C_ADDR, FC0012_CHECK_ADDR);
1408         if (reg == FC0012_CHECK_VAL) {
1409                 fprintf(stderr, "Found Fitipower FC0012 tuner\n");
1410                 rtlsdr_set_gpio_output(dev, 6);
1411                 dev->tuner_type = RTLSDR_TUNER_FC0012;
1412                 goto found;
1413         }
1414
1415 found:
1416         if (dev->tuner_type == RTLSDR_TUNER_UNKNOWN) {
1417                 fprintf(stderr, "No supported tuner found\n");
1418                 rtlsdr_set_direct_sampling(dev, 1);
1419         }
1420
1421         dev->tuner = &tuners[dev->tuner_type];
1422         dev->tun_xtal = dev->rtl_xtal; /* use the rtl clock value by default */
1423
1424         if (dev->tuner->init)
1425                 r = dev->tuner->init(dev);
1426
1427         rtlsdr_set_i2c_repeater(dev, 0);
1428
1429         *out_dev = dev;
1430
1431         return 0;
1432 err:
1433         if (dev) {
1434                 if (dev->ctx)
1435                         libusb_exit(dev->ctx);
1436
1437                 free(dev);
1438         }
1439
1440         return r;
1441 }
1442
1443 int rtlsdr_close(rtlsdr_dev_t *dev)
1444 {
1445         if (!dev)
1446                 return -1;
1447
1448         /* block until all async operations have been completed (if any) */
1449         while (RTLSDR_INACTIVE != dev->async_status) {
1450 #ifdef _WIN32
1451                 Sleep(1);
1452 #else
1453                 usleep(1000);
1454 #endif
1455         }
1456
1457         rtlsdr_deinit_baseband(dev);
1458
1459         libusb_release_interface(dev->devh, 0);
1460         libusb_close(dev->devh);
1461
1462         libusb_exit(dev->ctx);
1463
1464         free(dev);
1465
1466         return 0;
1467 }
1468
1469 int rtlsdr_reset_buffer(rtlsdr_dev_t *dev)
1470 {
1471         if (!dev)
1472                 return -1;
1473
1474         rtlsdr_write_reg(dev, USBB, USB_EPA_CTL, 0x1002, 2);
1475         rtlsdr_write_reg(dev, USBB, USB_EPA_CTL, 0x0000, 2);
1476
1477         return 0;
1478 }
1479
1480 int rtlsdr_read_sync(rtlsdr_dev_t *dev, void *buf, int len, int *n_read)
1481 {
1482         if (!dev)
1483                 return -1;
1484
1485         return libusb_bulk_transfer(dev->devh, 0x81, buf, len, n_read, BULK_TIMEOUT);
1486 }
1487
1488 static void LIBUSB_CALL _libusb_callback(struct libusb_transfer *xfer)
1489 {
1490         rtlsdr_dev_t *dev = (rtlsdr_dev_t *)xfer->user_data;
1491
1492         if (LIBUSB_TRANSFER_COMPLETED == xfer->status) {
1493                 if (dev->cb)
1494                         dev->cb(xfer->buffer, xfer->actual_length, dev->cb_ctx);
1495
1496                 libusb_submit_transfer(xfer); /* resubmit transfer */
1497         } else if (LIBUSB_TRANSFER_CANCELLED == xfer->status) {
1498                 /* nothing to do */
1499         } else {
1500                 /*fprintf(stderr, "transfer status: %d\n", xfer->status);*/
1501         }
1502 }
1503
1504 int rtlsdr_wait_async(rtlsdr_dev_t *dev, rtlsdr_read_async_cb_t cb, void *ctx)
1505 {
1506         return rtlsdr_read_async(dev, cb, ctx, 0, 0);
1507 }
1508
1509 static int _rtlsdr_alloc_async_buffers(rtlsdr_dev_t *dev)
1510 {
1511         unsigned int i;
1512
1513         if (!dev)
1514                 return -1;
1515
1516         if (!dev->xfer) {
1517                 dev->xfer = malloc(dev->xfer_buf_num *
1518                                    sizeof(struct libusb_transfer *));
1519
1520                 for(i = 0; i < dev->xfer_buf_num; ++i)
1521                         dev->xfer[i] = libusb_alloc_transfer(0);
1522         }
1523
1524         if (!dev->xfer_buf) {
1525                 dev->xfer_buf = malloc(dev->xfer_buf_num *
1526                                            sizeof(unsigned char *));
1527
1528                 for(i = 0; i < dev->xfer_buf_num; ++i)
1529                         dev->xfer_buf[i] = malloc(dev->xfer_buf_len);
1530         }
1531
1532         return 0;
1533 }
1534
1535 static int _rtlsdr_free_async_buffers(rtlsdr_dev_t *dev)
1536 {
1537         unsigned int i;
1538
1539         if (!dev)
1540                 return -1;
1541
1542         if (dev->xfer) {
1543                 for(i = 0; i < dev->xfer_buf_num; ++i) {
1544                         if (dev->xfer[i]) {
1545                                 libusb_free_transfer(dev->xfer[i]);
1546                         }
1547                 }
1548
1549                 free(dev->xfer);
1550                 dev->xfer = NULL;
1551         }
1552
1553         if (dev->xfer_buf) {
1554                 for(i = 0; i < dev->xfer_buf_num; ++i) {
1555                         if (dev->xfer_buf[i])
1556                                 free(dev->xfer_buf[i]);
1557                 }
1558
1559                 free(dev->xfer_buf);
1560                 dev->xfer_buf = NULL;
1561         }
1562
1563         return 0;
1564 }
1565
1566 int rtlsdr_read_async(rtlsdr_dev_t *dev, rtlsdr_read_async_cb_t cb, void *ctx,
1567                           uint32_t buf_num, uint32_t buf_len)
1568 {
1569         unsigned int i;
1570         int r = 0;
1571         struct timeval tv = { 1, 0 };
1572         enum rtlsdr_async_status next_status = RTLSDR_INACTIVE;
1573
1574         if (!dev)
1575                 return -1;
1576
1577         if (RTLSDR_INACTIVE != dev->async_status)
1578                 return -2;
1579
1580         dev->async_status = RTLSDR_RUNNING;
1581
1582         dev->cb = cb;
1583         dev->cb_ctx = ctx;
1584
1585         if (buf_num > 0)
1586                 dev->xfer_buf_num = buf_num;
1587         else
1588                 dev->xfer_buf_num = DEFAULT_BUF_NUMBER;
1589
1590         if (buf_len > 0 && buf_len % 512 == 0) /* len must be multiple of 512 */
1591                 dev->xfer_buf_len = buf_len;
1592         else
1593                 dev->xfer_buf_len = DEFAULT_BUF_LENGTH;
1594
1595         _rtlsdr_alloc_async_buffers(dev);
1596
1597         for(i = 0; i < dev->xfer_buf_num; ++i) {
1598                 libusb_fill_bulk_transfer(dev->xfer[i],
1599                                           dev->devh,
1600                                           0x81,
1601                                           dev->xfer_buf[i],
1602                                           dev->xfer_buf_len,
1603                                           _libusb_callback,
1604                                           (void *)dev,
1605                                           BULK_TIMEOUT);
1606
1607                 libusb_submit_transfer(dev->xfer[i]);
1608         }
1609
1610         while (RTLSDR_INACTIVE != dev->async_status) {
1611                 r = libusb_handle_events_timeout(dev->ctx, &tv);
1612                 if (r < 0) {
1613                         /*fprintf(stderr, "handle_events returned: %d\n", r);*/
1614                         if (r == LIBUSB_ERROR_INTERRUPTED) /* stray signal */
1615                                 continue;
1616                         break;
1617                 }
1618
1619                 if (RTLSDR_CANCELING == dev->async_status) {
1620                         next_status = RTLSDR_INACTIVE;
1621
1622                         if (!dev->xfer)
1623                                 break;
1624
1625                         for(i = 0; i < dev->xfer_buf_num; ++i) {
1626                                 if (!dev->xfer[i])
1627                                         continue;
1628
1629                                 if (LIBUSB_TRANSFER_CANCELLED !=
1630                                                 dev->xfer[i]->status) {
1631                                         libusb_cancel_transfer(dev->xfer[i]);
1632                                         next_status = RTLSDR_CANCELING;
1633                                 }
1634                         }
1635
1636                         if (RTLSDR_INACTIVE == next_status)
1637                                 break;
1638                 }
1639         }
1640
1641         _rtlsdr_free_async_buffers(dev);
1642
1643         dev->async_status = next_status;
1644
1645         return r;
1646 }
1647
1648 int rtlsdr_cancel_async(rtlsdr_dev_t *dev)
1649 {
1650         if (!dev)
1651                 return -1;
1652
1653         /* if streaming, try to cancel gracefully */
1654         if (RTLSDR_RUNNING == dev->async_status) {
1655                 dev->async_status = RTLSDR_CANCELING;
1656                 return 0;
1657         }
1658
1659         /* if called while in pending state, change the state forcefully */
1660         if (RTLSDR_INACTIVE != dev->async_status) {
1661                 dev->async_status = RTLSDR_INACTIVE;
1662                 return 0;
1663         }
1664
1665         return -2;
1666 }
1667
1668 uint32_t rtlsdr_get_tuner_clock(void *dev)
1669 {
1670         uint32_t tuner_freq;
1671
1672         if (!dev)
1673                 return 0;
1674
1675         /* read corrected clock value */
1676         if (rtlsdr_get_xtal_freq((rtlsdr_dev_t *)dev, NULL, &tuner_freq))
1677                 return 0;
1678
1679         return tuner_freq;
1680 }
1681
1682 int rtlsdr_i2c_write_fn(void *dev, uint8_t addr, uint8_t *buf, int len)
1683 {
1684         if (dev)
1685                 return rtlsdr_i2c_write(((rtlsdr_dev_t *)dev), addr, buf, len);
1686
1687         return -1;
1688 }
1689
1690 int rtlsdr_i2c_read_fn(void *dev, uint8_t addr, uint8_t *buf, int len)
1691 {
1692         if (dev)
1693                 return rtlsdr_i2c_read(((rtlsdr_dev_t *)dev), addr, buf, len);
1694
1695         return -1;
1696 }