MightyPork
/
rtl-sdr
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

tuner_fc0013: use new cleaned-up driver

Browse Source 
The driver was taken from http://git.linuxtv.org/ and adapted
for librtlsdr. Also, fc0013_set_gain() was added.

Signed-off-by: Steve Markgraf <steve@steve-m.de>
master
Steve Markgraf 13 years ago
parent c4c48a69ea
commit 6d34b04b42
3 changed files with 450 additions and 533 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 181
      include/tuner_fc0013.h
  2. 17
      src/librtlsdr.c
  3. 785
      src/tuner_fc0013.c

181
include/tuner_fc0013.h
Unescape View File

@ -1,159 +1,36 @@
#ifndef __TUNER_FC0013_H /*
#define __TUNER_FC0013_H * Fitipower FC0013 tuner driver
*
/** * Copyright (C) 2012 Hans-Frieder Vogt <hfvogt@gmx.net>
*
@file * modified for use in librtlsdr
* Copyright (C) 2012 Steve Markgraf <steve@steve-m.de>
@brief FC0013 tuner module declaration *
* This program is free software; you can redistribute it and/or modify
One can manipulate FC0013 tuner through FC0013 module. * it under the terms of the GNU General Public License as published by
FC0013 module is derived from tuner module. * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
// The following context is implemented for FC0013 source code. * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
**/ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#ifndef _FC0013_H_
#define _FC0013_H_
#define FC0013_I2C_ADDR 0xc6 #define FC0013_I2C_ADDR 0xc6
#define FC0013_CHECK_ADDR 0x00 #define FC0013_CHECK_ADDR 0x00
#define FC0013_CHECK_VAL 0xa3 #define FC0013_CHECK_VAL 0xa3
// Definitions int fc0013_init(void *dev);
enum FC0013_TRUE_FALSE_STATUS int fc0013_set_params(void *dev, uint32_t frequency, uint32_t bw);
{ int fc0013_set_gain(void *dev, int gain);
FC0013_FALSE,
FC0013_TRUE,
};
enum FC0013_I2C_STATUS
{
FC0013_I2C_SUCCESS,
FC0013_I2C_ERROR,
};
enum FC0013_FUNCTION_STATUS
{
FC0013_FUNCTION_SUCCESS,
FC0013_FUNCTION_ERROR,
};
// Functions
int FC0013_Read(void *pTuner, unsigned char RegAddr, unsigned char *pByte);
int FC0013_Write(void *pTuner, unsigned char RegAddr, unsigned char Byte);
int
fc0013_SetRegMaskBits(
void *pTuner,
unsigned char RegAddr,
unsigned char Msb,
unsigned char Lsb,
const unsigned char WritingValue
);
int
fc0013_GetRegMaskBits(
void *pTuner,
unsigned char RegAddr,
unsigned char Msb,
unsigned char Lsb,
unsigned char *pReadingValue
);
int FC0013_Open(void *pTuner);
int FC0013_SetFrequency(void *pTuner, unsigned long Frequency, unsigned short Bandwidth);
// Set VHF Track depends on input frequency
int FC0013_SetVhfTrack(void *pTuner, unsigned long Frequency);
// The following context is FC0013 tuner API source code
// Definitions
// Bandwidth mode
enum FC0013_BANDWIDTH_MODE
{
FC0013_BANDWIDTH_6000000HZ = 6,
FC0013_BANDWIDTH_7000000HZ = 7,
FC0013_BANDWIDTH_8000000HZ = 8,
};
// Default for initialing
#define FC0013_RF_FREQ_HZ_DEFAULT 50000000
#define FC0013_BANDWIDTH_MODE_DEFAULT FC0013_BANDWIDTH_8000000HZ
// Tuner LNA
enum FC0013_LNA_GAIN_VALUE
{
FC0013_LNA_GAIN_LOW = 0x00, // -6.3dB
FC0013_LNA_GAIN_MIDDLE = 0x08, // 7.1dB
FC0013_LNA_GAIN_HIGH_17 = 0x11, // 19.1dB
FC0013_LNA_GAIN_HIGH_19 = 0x10, // 19.7dB
};
// Manipulaing functions
void
fc0013_GetTunerType(
void *pTuner,
int *pTunerType
);
void
fc0013_GetDeviceAddr(
void *pTuner,
unsigned char *pDeviceAddr
);
int
fc0013_Initialize(
void *pTuner
);
int
fc0013_SetRfFreqHz(
void *pTuner,
unsigned long RfFreqHz
);
int
fc0013_GetRfFreqHz(
void *pTuner,
unsigned long *pRfFreqHz
);
// Extra manipulaing functions
int
fc0013_SetBandwidthMode(
void *pTuner,
int BandwidthMode
);
int
fc0013_GetBandwidthMode(
void *pTuner,
int *pBandwidthMode
);
int
fc0013_RcCalReset(
void *pTuner
);
int
fc0013_RcCalAdd(
void *pTuner,
int RcValue
);
#endif #endif

17
src/librtlsdr.c
Unescape View File

@ -136,15 +136,17 @@ int fc0012_set_bw(void *dev, int bw) {
int fc0012_set_gain(void *dev, int gain) { return 0; } int fc0012_set_gain(void *dev, int gain) { return 0; }
int fc0012_set_gain_mode(void *dev, int manual) { return 0; } int fc0012_set_gain_mode(void *dev, int manual) { return 0; }
int fc0013_init(void *dev) { return FC0013_Open(dev); } int _fc0013_init(void *dev) { return fc0013_init(dev); }
int fc0013_exit(void *dev) { return 0; } int fc0013_exit(void *dev) { return 0; }
int fc0013_set_freq(void *dev, uint32_t freq) { int fc0013_set_freq(void *dev, uint32_t freq) {
return FC0013_SetFrequency(dev, freq/1000, 6); /* select V-band/U-band filter */
rtlsdr_set_gpio_bit(dev, 6, (freq > 300000000) ? 1 : 0);
return fc0013_set_params(dev, freq, 6000000);
} }
int fc0013_set_bw(void *dev, int bw) { int fc0013_set_bw(void *dev, int bw) { return 0; }
return FC0013_SetFrequency(dev, ((rtlsdr_dev_t *) dev)->freq/1000, 6); int _fc0013_set_gain(void *dev, int gain) {
return fc0013_set_gain(dev, gain);
} }
int fc0013_set_gain(void *dev, int gain) { return 0; }
int fc0013_set_gain_mode(void *dev, int manual) { return 0; } int fc0013_set_gain_mode(void *dev, int manual) { return 0; }
int fc2580_init(void *dev) { return fc2580_Initialize(dev); } int fc2580_init(void *dev) { return fc2580_Initialize(dev); }
@ -177,8 +179,8 @@ static rtlsdr_tuner_t tuners[] = {
fc0012_set_gain_mode fc0012_set_gain_mode
}, },
{ {
fc0013_init, fc0013_exit, _fc0013_init, fc0013_exit,
fc0013_set_freq, fc0013_set_bw, fc0013_set_gain, fc0013_set_freq, fc0013_set_bw, _fc0013_set_gain,
fc0013_set_gain_mode fc0013_set_gain_mode
}, },
{ {
@ -977,6 +979,7 @@ int rtlsdr_open(rtlsdr_dev_t **out_dev, uint32_t index)
reg = rtlsdr_i2c_read_reg(dev, FC0013_I2C_ADDR, FC0013_CHECK_ADDR); reg = rtlsdr_i2c_read_reg(dev, FC0013_I2C_ADDR, FC0013_CHECK_ADDR);
if (reg == FC0013_CHECK_VAL) { if (reg == FC0013_CHECK_VAL) {
fprintf(stderr, "Found Fitipower FC0013 tuner\n"); fprintf(stderr, "Found Fitipower FC0013 tuner\n");
rtlsdr_set_gpio_output(dev, 6);
dev->tuner = &tuners[RTLSDR_TUNER_FC0013]; dev->tuner = &tuners[RTLSDR_TUNER_FC0013];
goto found; goto found;
} }

785
src/tuner_fc0013.c
Unescape View File

@ -1,8 +1,26 @@
/* /*
* Fitipower FC0013 tuner driver, taken from the kernel driver that can be found * Fitipower FC0013 tuner driver
* on http://linux.terratec.de/tv_en.html
* *
* This driver is a mess, and should be cleaned up/rewritten. * Copyright (C) 2012 Hans-Frieder Vogt <hfvogt@gmx.net>
* partially based on driver code from Fitipower
* Copyright (C) 2010 Fitipower Integrated Technology Inc
*
* modified for use in librtlsdr
* Copyright (C) 2012 Steve Markgraf <steve@steve-m.de>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
* *
*/ */
@ -11,424 +29,443 @@
#include "rtlsdr_i2c.h" #include "rtlsdr_i2c.h"
#include "tuner_fc0013.h" #include "tuner_fc0013.h"
#define CRYSTAL_FREQ 28800000 static int fc0013_writereg(void *dev, uint8_t reg, uint8_t val)
/* glue functions to rtl-sdr code */
int FC0013_Write(void *pTuner, unsigned char RegAddr, unsigned char Byte)
{ {
uint8_t data[2]; uint8_t data[2];
data[0] = reg;
data[1] = val;
data[0] = RegAddr; if (rtlsdr_i2c_write_fn(dev, FC0013_I2C_ADDR, data, 2) < 0)
data[1] = Byte; return -1;
if (rtlsdr_i2c_write_fn(pTuner, FC0013_I2C_ADDR, data, 2) < 0) return 0;
return FC0013_I2C_ERROR;
return FC0013_I2C_SUCCESS;
} }
int FC0013_Read(void *pTuner, unsigned char RegAddr, unsigned char *pByte) static int fc0013_readreg(void *dev, uint8_t reg, uint8_t *val)
{ {
uint8_t data = RegAddr; uint8_t data = reg;
if (rtlsdr_i2c_write_fn(pTuner, FC0013_I2C_ADDR, &data, 1) < 0) if (rtlsdr_i2c_write_fn(dev, FC0013_I2C_ADDR, &data, 1) < 0)
return FC0013_I2C_ERROR; return -1;
if (rtlsdr_i2c_read_fn(pTuner, FC0013_I2C_ADDR, &data, 1) < 0) if (rtlsdr_i2c_read_fn(dev, FC0013_I2C_ADDR, &data, 1) < 0)
return FC0013_I2C_ERROR; return -1;
*pByte = data; *val = data;
return FC0013_I2C_SUCCESS; return 0;
} }
int FC0013_SetVhfTrack(void *pTuner, unsigned long FrequencyKHz) int fc0013_init(void *dev)
{ {
unsigned char read_byte; int ret = 0;
unsigned int i;
if (FrequencyKHz <= 177500) // VHF Track: 7 uint8_t reg[] = {
{ 0x00, /* reg. 0x00: dummy */
if(FC0013_Read(pTuner, 0x1D, &read_byte) != FC0013_I2C_SUCCESS) goto error_status; 0x09, /* reg. 0x01 */
if(FC0013_Write(pTuner, 0x1D, (read_byte & 0xE3) | 0x1C) != FC0013_I2C_SUCCESS) goto error_status; 0x16, /* reg. 0x02 */
0x00, /* reg. 0x03 */
} 0x00, /* reg. 0x04 */
else if (FrequencyKHz <= 184500) // VHF Track: 6 0x17, /* reg. 0x05 */
{ 0x02, /* reg. 0x06: LPF bandwidth */
if(FC0013_Read(pTuner, 0x1D, &read_byte) != FC0013_I2C_SUCCESS) goto error_status; 0x0a, /* reg. 0x07: CHECK */
if(FC0013_Write(pTuner, 0x1D, (read_byte & 0xE3) | 0x18) != FC0013_I2C_SUCCESS) goto error_status; 0xff, /* reg. 0x08: AGC Clock divide by 256, AGC gain 1/256,
Loop Bw 1/8 */
} 0x6f, /* reg. 0x09: enable LoopThrough */
else if (FrequencyKHz <= 191500) // VHF Track: 5 0xb8, /* reg. 0x0a: Disable LO Test Buffer */
{ 0x82, /* reg. 0x0b: CHECK */
if(FC0013_Read(pTuner, 0x1D, &read_byte) != FC0013_I2C_SUCCESS) goto error_status; 0xfc, /* reg. 0x0c: depending on AGC Up-Down mode, may need 0xf8 */
if(FC0013_Write(pTuner, 0x1D, (read_byte & 0xE3) | 0x14) != FC0013_I2C_SUCCESS) goto error_status; 0x01, /* reg. 0x0d: AGC Not Forcing & LNA Forcing, may need 0x02 */
0x00, /* reg. 0x0e */
} 0x00, /* reg. 0x0f */
else if (FrequencyKHz <= 198500) // VHF Track: 4 0x00, /* reg. 0x10 */
{ 0x00, /* reg. 0x11 */
if(FC0013_Read(pTuner, 0x1D, &read_byte) != FC0013_I2C_SUCCESS) goto error_status; 0x00, /* reg. 0x12 */
if(FC0013_Write(pTuner, 0x1D, (read_byte & 0xE3) | 0x10) != FC0013_I2C_SUCCESS) goto error_status; 0x00, /* reg. 0x13 */
0x50, /* reg. 0x14: DVB-t High Gain, UHF.
} Middle Gain: 0x48, Low Gain: 0x40 */
else if (FrequencyKHz <= 205500) // VHF Track: 3 0x01, /* reg. 0x15 */
{ };
if(FC0013_Read(pTuner, 0x1D, &read_byte) != FC0013_I2C_SUCCESS) goto error_status; #if 0
if(FC0013_Write(pTuner, 0x1D, (read_byte & 0xE3) | 0x0C) != FC0013_I2C_SUCCESS) goto error_status; switch (rtlsdr_get_tuner_clock(dev)) {
case FC_XTAL_27_MHZ:
} case FC_XTAL_28_8_MHZ:
else if (FrequencyKHz <= 212500) // VHF Track: 2 reg[0x07] |= 0x20;
{ break;
if(FC0013_Read(pTuner, 0x1D, &read_byte) != FC0013_I2C_SUCCESS) goto error_status; case FC_XTAL_36_MHZ:
if(FC0013_Write(pTuner, 0x1D, (read_byte & 0xE3) | 0x08) != FC0013_I2C_SUCCESS) goto error_status; default:
break;
} }
else if (FrequencyKHz <= 219500) // VHF Track: 2 #endif
{ reg[0x07] |= 0x20;
if(FC0013_Read(pTuner, 0x1D, &read_byte) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x1D, (read_byte & 0xE3) | 0x08) != FC0013_I2C_SUCCESS) goto error_status;
}
else if (FrequencyKHz <= 226500) // VHF Track: 1
{
if(FC0013_Read(pTuner, 0x1D, &read_byte) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x1D, (read_byte & 0xE3) | 0x04) != FC0013_I2C_SUCCESS) goto error_status;
}
else // VHF Track: 1
{
if(FC0013_Read(pTuner, 0x1D, &read_byte) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x1D, (read_byte & 0xE3) | 0x04) != FC0013_I2C_SUCCESS) goto error_status;
}
//------------------------------------------------ arios modify 2010-12-24
// " | 0x10" ==> " | 0x30" (make sure reg[0x07] bit5 = 1)
// Enable VHF filter.
if(FC0013_Read(pTuner, 0x07, &read_byte) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x07, read_byte | 0x10) != FC0013_I2C_SUCCESS) goto error_status;
// Disable UHF & GPS.
if(FC0013_Read(pTuner, 0x14, &read_byte) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x14, read_byte & 0x1F) != FC0013_I2C_SUCCESS) goto error_status;
return FC0013_FUNCTION_SUCCESS;
error_status:
return FC0013_FUNCTION_ERROR;
}
// if (dev->dual_master)
reg[0x0c] |= 0x02;
// FC0013 Open Function, includes enable/reset pin control and registers initialization. for (i = 1; i < sizeof(reg); i++) {
//void FC0013_Open() ret = fc0013_writereg(dev, i, reg[i]);
int FC0013_Open(void *pTuner) if (ret < 0)
{ break;
// Enable FC0013 Power }
// (...)
// FC0013 Enable = High
// (...)
// FC0013 Reset = High -> Low
// (...)
/* FIXME added to fix replug-bug with rtl-sdr */
if(FC0013_Write(pTuner, 0x0C, 0x00) != FC0013_I2C_SUCCESS) goto error_status;
//================================ update base on new FC0013 register bank
if(FC0013_Write(pTuner, 0x01, 0x09) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x02, 0x16) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x03, 0x00) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x04, 0x00) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x05, 0x17) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x06, 0x02) != FC0013_I2C_SUCCESS) goto error_status;
// if(FC0013_Write(pTuner, 0x07, 0x27) != FC0013_I2C_SUCCESS) goto error_status; // 28.8MHz, GainShift: 15
if(FC0013_Write(pTuner, 0x07, 0x2A) != FC0013_I2C_SUCCESS) goto error_status; // 28.8MHz, modified by Realtek
if(FC0013_Write(pTuner, 0x08, 0xFF) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x09, 0x6F) != FC0013_I2C_SUCCESS) goto error_status; // Enable Loop Through
if(FC0013_Write(pTuner, 0x0A, 0xB8) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x0B, 0x82) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x0C, 0xFE) != FC0013_I2C_SUCCESS) goto error_status; // Modified for up-dowm AGC by Realtek(for master, and for 2836BU dongle).
// if(FC0013_Write(pTuner, 0x0C, 0xFC) != FC0013_I2C_SUCCESS) goto error_status; // Modified for up-dowm AGC by Realtek(for slave, and for 2832 mini dongle).
// if(FC0013_Write(pTuner, 0x0D, 0x09) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x0D, 0x01) != FC0013_I2C_SUCCESS) goto error_status; // Modified for AGC non-forcing by Realtek.
if(FC0013_Write(pTuner, 0x0E, 0x00) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x0F, 0x00) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x10, 0x00) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x11, 0x00) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x12, 0x00) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x13, 0x00) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x14, 0x50) != FC0013_I2C_SUCCESS) goto error_status; // DVB-T, High Gain
// if(FC0013_Write(pTuner, 0x14, 0x48) != FC0013_I2C_SUCCESS) goto error_status; // DVB-T, Middle Gain
// if(FC0013_Write(pTuner, 0x14, 0x40) != FC0013_I2C_SUCCESS) goto error_status; // DVB-T, Low Gain
if(FC0013_Write(pTuner, 0x15, 0x01) != FC0013_I2C_SUCCESS) goto error_status;
return FC0013_FUNCTION_SUCCESS;
error_status:
return FC0013_FUNCTION_ERROR;
}
return ret;
}
int FC0013_SetFrequency(void *pTuner, unsigned long Frequency, unsigned short Bandwidth) int fc0013_rc_cal_add(void *dev, int rc_val)
{ {
// bool VCO1 = false; int ret;
// unsigned int doubleVCO; uint8_t rc_cal;
// unsigned short xin, xdiv; int val;
// unsigned char reg[21], am, pm, multi;
int VCO1 = FC0013_FALSE; /* push rc_cal value, get rc_cal value */
unsigned long doubleVCO; ret = fc0013_writereg(dev, 0x10, 0x00);
unsigned short xin, xdiv; if (ret)
unsigned char reg[21], am, pm, multi; goto error_out;
/* get rc_cal value */
ret = fc0013_readreg(dev, 0x10, &rc_cal);
if (ret)
goto error_out;
rc_cal &= 0x0f;
val = (int)rc_cal + rc_val;
/* forcing rc_cal */
ret = fc0013_writereg(dev, 0x0d, 0x11);
if (ret)
goto error_out;
/* modify rc_cal value */
if (val > 15)
ret = fc0013_writereg(dev, 0x10, 0x0f);
else if (val < 0)
ret = fc0013_writereg(dev, 0x10, 0x00);
else
ret = fc0013_writereg(dev, 0x10, (uint8_t)val);
unsigned char read_byte; error_out:
return ret;
}
unsigned long CrystalFreqKhz; int fc0013_rc_cal_reset(void *dev)
{
int ret;
int CrystalFreqHz = rtlsdr_get_tuner_clock(pTuner); ret = fc0013_writereg(dev, 0x0d, 0x01);
if (!ret)
ret = fc0013_writereg(dev, 0x10, 0x00);
// Get tuner crystal frequency in KHz. return ret;
// Note: CrystalFreqKhz = round(CrystalFreqHz / 1000) }
CrystalFreqKhz = (CrystalFreqHz + 500) / 1000;
// modified 2011-02-09: for D-Book test static int fc0013_set_vhf_track(void *dev, uint32_t freq)
// set VHF_Track = 7 {
if(FC0013_Read(pTuner, 0x1D, &read_byte) != FC0013_I2C_SUCCESS) goto error_status; int ret;
uint8_t tmp;
ret = fc0013_readreg(dev, 0x1d, &tmp);
if (ret)
goto error_out;
tmp &= 0xe3;
if (freq <= 177500) { /* VHF Track: 7 */
ret = fc0013_writereg(dev, 0x1d, tmp | 0x1c);
} else if (freq <= 184500) { /* VHF Track: 6 */
ret = fc0013_writereg(dev, 0x1d, tmp | 0x18);
} else if (freq <= 191500) { /* VHF Track: 5 */
ret = fc0013_writereg(dev, 0x1d, tmp | 0x14);
} else if (freq <= 198500) { /* VHF Track: 4 */
ret = fc0013_writereg(dev, 0x1d, tmp | 0x10);
} else if (freq <= 205500) { /* VHF Track: 3 */
ret = fc0013_writereg(dev, 0x1d, tmp | 0x0c);
} else if (freq <= 219500) { /* VHF Track: 2 */
ret = fc0013_writereg(dev, 0x1d, tmp | 0x08);
} else if (freq < 300000) { /* VHF Track: 1 */
ret = fc0013_writereg(dev, 0x1d, tmp | 0x04);
} else { /* UHF and GPS */
ret = fc0013_writereg(dev, 0x1d, tmp | 0x1c);
}
// VHF Track: 7 error_out:
if(FC0013_Write(pTuner, 0x1D, (read_byte & 0xE3) | 0x1C) != FC0013_I2C_SUCCESS) goto error_status; return ret;
}
int fc0013_set_params(void *dev, uint32_t frequency, uint32_t bandwidth)
{
int i, ret = 0;
uint32_t freq = frequency / 1000;
uint8_t reg[7], am, pm, multi, tmp;
unsigned long f_vco;
uint16_t xtal_freq_khz_2, xin, xdiv;
int vco_select = 0;
xtal_freq_khz_2 = rtlsdr_get_tuner_clock(dev) / 1000 / 2;
/* set VHF track */
ret = fc0013_set_vhf_track(dev, freq);
if (ret)
goto exit;
if (freq < 300000) {
/* enable VHF filter */
ret = fc0013_readreg(dev, 0x07, &tmp);
if (ret)
goto exit;
ret = fc0013_writereg(dev, 0x07, tmp | 0x10);
if (ret)
goto exit;
/* disable UHF & disable GPS */
ret = fc0013_readreg(dev, 0x14, &tmp);
if (ret)
goto exit;
ret = fc0013_writereg(dev, 0x14, tmp & 0x1f);
if (ret)
goto exit;
} else if (freq <= 862000) {
/* disable VHF filter */
ret = fc0013_readreg(dev, 0x07, &tmp);
if (ret)
goto exit;
ret = fc0013_writereg(dev, 0x07, tmp & 0xef);
if (ret)
goto exit;
/* enable UHF & disable GPS */
ret = fc0013_readreg(dev, 0x14, &tmp);
if (ret)
goto exit;
ret = fc0013_writereg(dev, 0x14, (tmp & 0x1f) | 0x40);
if (ret)
goto exit;
} else {
/* disable VHF filter */
ret = fc0013_readreg(dev, 0x07, &tmp);
if (ret)
goto exit;
ret = fc0013_writereg(dev, 0x07, tmp & 0xef);
if (ret)
goto exit;
/* disable UHF & enable GPS */
ret = fc0013_readreg(dev, 0x14, &tmp);
if (ret)
goto exit;
ret = fc0013_writereg(dev, 0x14, (tmp & 0x1f) | 0x20);
if (ret)
goto exit;
}
if( Frequency < 300000 ) /* select frequency divider and the frequency of VCO */
{ if (freq < 37084) { /* freq * 96 < 3560000 */
// Set VHF Track. multi = 96;
if(FC0013_SetVhfTrack(pTuner, Frequency) != FC0013_I2C_SUCCESS) goto error_status; reg[5] = 0x82;
reg[6] = 0x00;
} else if (freq < 55625) { /* freq * 64 < 3560000 */
multi = 64;
reg[5] = 0x02;
reg[6] = 0x02;
} else if (freq < 74167) { /* freq * 48 < 3560000 */
multi = 48;
reg[5] = 0x42;
reg[6] = 0x00;
} else if (freq < 111250) { /* freq * 32 < 3560000 */
multi = 32;
reg[5] = 0x82;
reg[6] = 0x02;
} else if (freq < 148334) { /* freq * 24 < 3560000 */
multi = 24;
reg[5] = 0x22;
reg[6] = 0x00;
} else if (freq < 222500) { /* freq * 16 < 3560000 */
multi = 16;
reg[5] = 0x42;
reg[6] = 0x02;
} else if (freq < 296667) { /* freq * 12 < 3560000 */
multi = 12;
reg[5] = 0x12;
reg[6] = 0x00;
} else if (freq < 445000) { /* freq * 8 < 3560000 */
multi = 8;
reg[5] = 0x22;
reg[6] = 0x02;
} else if (freq < 593334) { /* freq * 6 < 3560000 */
multi = 6;
reg[5] = 0x0a;
reg[6] = 0x00;
} else if (freq < 950000) { /* freq * 4 < 3800000 */
multi = 4;
reg[5] = 0x12;
reg[6] = 0x02;
} else {
multi = 2;
reg[5] = 0x0a;
reg[6] = 0x02;
}
// Enable VHF filter. f_vco = freq * multi;
if(FC0013_Read(pTuner, 0x07, &read_byte) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x07, read_byte | 0x10) != FC0013_I2C_SUCCESS) goto error_status;
// Disable UHF & disable GPS. if (f_vco >= 3060000) {
if(FC0013_Read(pTuner, 0x14, &read_byte) != FC0013_I2C_SUCCESS) goto error_status; reg[6] |= 0x08;
if(FC0013_Write(pTuner, 0x14, read_byte & 0x1F) != FC0013_I2C_SUCCESS) goto error_status; vco_select = 1;
}
else if ( (Frequency >= 300000) && (Frequency <= 862000) )
{
// Disable VHF filter.
if(FC0013_Read(pTuner, 0x07, &read_byte) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x07, read_byte & 0xEF) != FC0013_I2C_SUCCESS) goto error_status;
// enable UHF & disable GPS.
if(FC0013_Read(pTuner, 0x14, &read_byte) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x14, (read_byte & 0x1F) | 0x40) != FC0013_I2C_SUCCESS) goto error_status;
}
else if (Frequency > 862000)
{
// Disable VHF filter
if(FC0013_Read(pTuner, 0x07, &read_byte) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x07, read_byte & 0xEF) != FC0013_I2C_SUCCESS) goto error_status;
// Disable UHF & enable GPS
if(FC0013_Read(pTuner, 0x14, &read_byte) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x14, (read_byte & 0x1F) | 0x20) != FC0013_I2C_SUCCESS) goto error_status;
} }
if (Frequency * 96 < 3560000) if (freq >= 45000) {
{ /* From divided value (XDIV) determined the FA and FP value */
multi = 96; xdiv = (uint16_t)(f_vco / xtal_freq_khz_2);
reg[5] = 0x82; if ((f_vco - xdiv * xtal_freq_khz_2) >= (xtal_freq_khz_2 / 2))
reg[6] = 0x00; xdiv++;
}
else if (Frequency * 64 < 3560000) pm = (uint8_t)(xdiv / 8);
{ am = (uint8_t)(xdiv - (8 * pm));
multi = 64;
reg[5] = 0x02; if (am < 2) {
reg[6] = 0x02; reg[1] = am + 8;
} reg[2] = pm - 1;
else if (Frequency * 48 < 3560000) } else {
{ reg[1] = am;
multi = 48; reg[2] = pm;
reg[5] = 0x42; }
reg[6] = 0x00; } else {
} /* fix for frequency less than 45 MHz */
else if (Frequency * 32 < 3560000) reg[1] = 0x06;
{ reg[2] = 0x11;
multi = 32;
reg[5] = 0x82;
reg[6] = 0x02;
}
else if (Frequency * 24 < 3560000)
{
multi = 24;
reg[5] = 0x22;
reg[6] = 0x00;
}
else if (Frequency * 16 < 3560000)
{
multi = 16;
reg[5] = 0x42;
reg[6] = 0x02;
}
else if (Frequency * 12 < 3560000)
{
multi = 12;
reg[5] = 0x12;
reg[6] = 0x00;
}
else if (Frequency * 8 < 3560000)
{
multi = 8;
reg[5] = 0x22;
reg[6] = 0x02;
}
else if (Frequency * 6 < 3560000)
{
multi = 6;
reg[5] = 0x0A;
reg[6] = 0x00;
}
else if (Frequency * 4 < 3800000)
{
multi = 4;
reg[5] = 0x12;
reg[6] = 0x02;
}
else
{
Frequency = Frequency / 2;
multi = 4;
reg[5] = 0x0A;
reg[6] = 0x02;
} }
doubleVCO = Frequency * multi; /* fix clock out */
reg[6] |= 0x20;
/* From VCO frequency determines the XIN ( fractional part of Delta
Sigma PLL) and divided value (XDIV) */
xin = (uint16_t)(f_vco - (f_vco / xtal_freq_khz_2) * xtal_freq_khz_2);
xin = (xin << 15) / xtal_freq_khz_2;
if (xin >= 16384)
xin += 32768;
reg[3] = xin >> 8;
reg[4] = xin & 0xff;
reg[6] &= 0x3f; /* bits 6 and 7 describe the bandwidth */
switch (bandwidth) {
case 6000000:
reg[6] |= 0x80;
break;
case 7000000:
reg[6] |= 0x40;
break;
case 8000000:
default:
break;
}
reg[6] = reg[6] | 0x08; /* modified for Realtek demod */
// VCO1 = true; reg[5] |= 0x07;
VCO1 = FC0013_TRUE;
// Calculate VCO parameters: ap & pm & xin. for (i = 1; i <= 6; i++) {
// xdiv = (unsigned short)(doubleVCO / (Crystal_Frequency/2)); ret = fc0013_writereg(dev, i, reg[i]);
xdiv = (unsigned short)(doubleVCO / (CrystalFreqKhz/2)); if (ret)
// if( (doubleVCO - xdiv * (Crystal_Frequency/2)) >= (Crystal_Frequency/4) ) goto exit;
if( (doubleVCO - xdiv * (CrystalFreqKhz/2)) >= (CrystalFreqKhz/4) )
{
xdiv = xdiv + 1;
} }
pm = (unsigned char)( xdiv / 8 ); ret = fc0013_readreg(dev, 0x11, &tmp);
am = (unsigned char)( xdiv - (8 * pm)); if (ret)
goto exit;
if (am < 2)
{
reg[1] = am + 8;
reg[2] = pm - 1;
}
else
{
reg[1] = am;
reg[2] = pm;
}
// xin = (unsigned short)(doubleVCO - ((unsigned short)(doubleVCO / (Crystal_Frequency/2))) * (Crystal_Frequency/2));
xin = (unsigned short)(doubleVCO - ((unsigned short)(doubleVCO / (CrystalFreqKhz/2))) * (CrystalFreqKhz/2));
// xin = ((xin << 15)/(Crystal_Frequency/2));
xin = (unsigned short)((xin << 15)/(CrystalFreqKhz/2));
// if( xin >= (unsigned short) pow( (double)2, (double)14) )
// {
// xin = xin + (unsigned short) pow( (double)2, (double)15);
// }
if( xin >= (unsigned short) 16384 )
xin = xin + (unsigned short) 32768;
reg[3] = (unsigned char)(xin >> 8);
reg[4] = (unsigned char)(xin & 0x00FF);
//===================================== Only for testing
// printf("Frequency: %d, Fa: %d, Fp: %d, Xin:%d \n", Frequency, am, pm, xin);
// Set Low-Pass Filter Bandwidth.
switch(Bandwidth)
{
case 6:
reg[6] = 0x80 | reg[6];
break;
case 7:
reg[6] = ~0x80 & reg[6];
reg[6] = 0x40 | reg[6];
break;
case 8:
default:
reg[6] = ~0xC0 & reg[6];
break;
}
reg[5] = reg[5] | 0x07;
if(FC0013_Write(pTuner, 0x01, reg[1]) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x02, reg[2]) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x03, reg[3]) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x04, reg[4]) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x05, reg[5]) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x06, reg[6]) != FC0013_I2C_SUCCESS) goto error_status;
if (multi == 64) if (multi == 64)
{ ret = fc0013_writereg(dev, 0x11, tmp | 0x04);
// FC0013_Write(0x11, FC0013_Read(0x11) | 0x04);
if(FC0013_Read(pTuner, 0x11, &read_byte) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x11, read_byte | 0x04) != FC0013_I2C_SUCCESS) goto error_status;
}
else else
{ ret = fc0013_writereg(dev, 0x11, tmp & 0xfb);
// FC0013_Write(0x11, FC0013_Read(0x11) & 0xFB); if (ret)
if(FC0013_Read(pTuner, 0x11, &read_byte) != FC0013_I2C_SUCCESS) goto error_status; goto exit;
if(FC0013_Write(pTuner, 0x11, read_byte & 0xFB) != FC0013_I2C_SUCCESS) goto error_status;
/* VCO Calibration */
ret = fc0013_writereg(dev, 0x0e, 0x80);
if (!ret)
ret = fc0013_writereg(dev, 0x0e, 0x00);
/* VCO Re-Calibration if needed */
if (!ret)
ret = fc0013_writereg(dev, 0x0e, 0x00);
if (!ret) {
// msleep(10);
ret = fc0013_readreg(dev, 0x0e, &tmp);
}
if (ret)
goto exit;
/* vco selection */
tmp &= 0x3f;
if (vco_select) {
if (tmp > 0x3c) {
reg[6] &= ~0x08;
ret = fc0013_writereg(dev, 0x06, reg[6]);
if (!ret)
ret = fc0013_writereg(dev, 0x0e, 0x80);
if (!ret)
ret = fc0013_writereg(dev, 0x0e, 0x00);
}
} else {
if (tmp < 0x02) {
reg[6] |= 0x08;
ret = fc0013_writereg(dev, 0x06, reg[6]);
if (!ret)
ret = fc0013_writereg(dev, 0x0e, 0x80);
if (!ret)
ret = fc0013_writereg(dev, 0x0e, 0x00);
}
} }
if(FC0013_Write(pTuner, 0x0E, 0x80) != FC0013_I2C_SUCCESS) goto error_status; exit:
if(FC0013_Write(pTuner, 0x0E, 0x00) != FC0013_I2C_SUCCESS) goto error_status; return ret;
}
if(FC0013_Write(pTuner, 0x0E, 0x00) != FC0013_I2C_SUCCESS) goto error_status; int fc0013_set_gain(void *dev, int gain)
// reg[14] = 0x3F & FC0013_Read(0x0E); {
if(FC0013_Read(pTuner, 0x0E, &read_byte) != FC0013_I2C_SUCCESS) goto error_status; int ret, gainshift = 0, en_in_chg = 0;
reg[14] = 0x3F & read_byte; uint8_t tmp = 0;
ret = fc0013_readreg(dev, 0x14, &tmp);
/* mask bits off */
tmp &= 0xe0;
switch (gain) {
case -63: /* -6.3 dB */
break;
case 71:
tmp |= 0x08; /* 7.1 dB */
break;
case 191:
gainshift = 1;
tmp |= 0x11; /* 19.1 dB */
break;
case 197:
default:
en_in_chg = 1;
gainshift = 1;
tmp |= 0x10; /* 19.7 dB */
break;
}
if (VCO1) /* set gain */
{ ret = fc0013_writereg(dev, 0x14, tmp);
if (reg[14] > 0x3C)
{
reg[6] = ~0x08 & reg[6];
if(FC0013_Write(pTuner, 0x06, reg[6]) != FC0013_I2C_SUCCESS) goto error_status; /* set en_in_chg */
ret = fc0013_readreg(dev, 0x0a, &tmp);
if(FC0013_Write(pTuner, 0x0E, 0x80) != FC0013_I2C_SUCCESS) goto error_status; if (en_in_chg)
if(FC0013_Write(pTuner, 0x0E, 0x00) != FC0013_I2C_SUCCESS) goto error_status; tmp |= 0x20;
}
}
else else
{ tmp &= ~0x20;
if (reg[14] < 0x02)
{
reg[6] = 0x08 | reg[6];
if(FC0013_Write(pTuner, 0x06, reg[6]) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x0E, 0x80) != FC0013_I2C_SUCCESS) goto error_status;
if(FC0013_Write(pTuner, 0x0E, 0x00) != FC0013_I2C_SUCCESS) goto error_status;
}
}
ret = fc0013_writereg(dev, 0x0a, tmp);
return 1; /* set gain shift */
ret = fc0013_readreg(dev, 0x07, &tmp);
tmp &= 0xf0;
tmp |= gainshift ? 0x0a : 0x07;
ret = fc0013_writereg(dev, 0x07, tmp);
error_status: return ret;
return 0;
} }

Write Preview
Loading…
Cancel
Save