mirror of
https://github.com/torvalds/linux.git
synced 2024-12-06 02:52:22 +00:00
bcb63314e2
Drop the FSF's postal address from the source code files that typically contain mostly the license text. Of the 628 removed instances, 578 are outdated. The patch has been created with the following command without manual edits: git grep -l "675 Mass Ave\|59 Temple Place\|51 Franklin St" -- \ drivers/media/ include/media|while read i; do i=$i perl -e ' open(F,"< $ENV{i}"); $a=join("", <F>); $a =~ s/[ \t]*\*\n.*You should.*\n.*along with.*\n.*(\n.*USA.*$)?\n//m && $a =~ s/(^.*)Or, (point your browser to) /$1To obtain the license, $2\n$1/m; close(F); open(F, "> $ENV{i}"); print F $a; close(F);'; done Signed-off-by: Sakari Ailus <sakari.ailus@linux.intel.com>
506 lines
11 KiB
C
506 lines
11 KiB
C
/*
|
|
* Support for AltoBeam GB20600 (a.k.a DMB-TH) demodulator
|
|
* ATBM8830, ATBM8831
|
|
*
|
|
* Copyright (C) 2009 David T.L. Wong <davidtlwong@gmail.com>
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#include <asm/div64.h>
|
|
#include "dvb_frontend.h"
|
|
|
|
#include "atbm8830.h"
|
|
#include "atbm8830_priv.h"
|
|
|
|
#define dprintk(args...) \
|
|
do { \
|
|
if (debug) \
|
|
printk(KERN_DEBUG "atbm8830: " args); \
|
|
} while (0)
|
|
|
|
static int debug;
|
|
|
|
module_param(debug, int, 0644);
|
|
MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
|
|
|
|
static int atbm8830_write_reg(struct atbm_state *priv, u16 reg, u8 data)
|
|
{
|
|
int ret = 0;
|
|
u8 dev_addr;
|
|
u8 buf1[] = { reg >> 8, reg & 0xFF };
|
|
u8 buf2[] = { data };
|
|
struct i2c_msg msg1 = { .flags = 0, .buf = buf1, .len = 2 };
|
|
struct i2c_msg msg2 = { .flags = 0, .buf = buf2, .len = 1 };
|
|
|
|
dev_addr = priv->config->demod_address;
|
|
msg1.addr = dev_addr;
|
|
msg2.addr = dev_addr;
|
|
|
|
if (debug >= 2)
|
|
dprintk("%s: reg=0x%04X, data=0x%02X\n", __func__, reg, data);
|
|
|
|
ret = i2c_transfer(priv->i2c, &msg1, 1);
|
|
if (ret != 1)
|
|
return -EIO;
|
|
|
|
ret = i2c_transfer(priv->i2c, &msg2, 1);
|
|
return (ret != 1) ? -EIO : 0;
|
|
}
|
|
|
|
static int atbm8830_read_reg(struct atbm_state *priv, u16 reg, u8 *p_data)
|
|
{
|
|
int ret;
|
|
u8 dev_addr;
|
|
|
|
u8 buf1[] = { reg >> 8, reg & 0xFF };
|
|
u8 buf2[] = { 0 };
|
|
struct i2c_msg msg1 = { .flags = 0, .buf = buf1, .len = 2 };
|
|
struct i2c_msg msg2 = { .flags = I2C_M_RD, .buf = buf2, .len = 1 };
|
|
|
|
dev_addr = priv->config->demod_address;
|
|
msg1.addr = dev_addr;
|
|
msg2.addr = dev_addr;
|
|
|
|
ret = i2c_transfer(priv->i2c, &msg1, 1);
|
|
if (ret != 1) {
|
|
dprintk("%s: error reg=0x%04x, ret=%i\n", __func__, reg, ret);
|
|
return -EIO;
|
|
}
|
|
|
|
ret = i2c_transfer(priv->i2c, &msg2, 1);
|
|
if (ret != 1)
|
|
return -EIO;
|
|
|
|
*p_data = buf2[0];
|
|
if (debug >= 2)
|
|
dprintk("%s: reg=0x%04X, data=0x%02X\n",
|
|
__func__, reg, buf2[0]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Lock register latch so that multi-register read is atomic */
|
|
static inline int atbm8830_reglatch_lock(struct atbm_state *priv, int lock)
|
|
{
|
|
return atbm8830_write_reg(priv, REG_READ_LATCH, lock ? 1 : 0);
|
|
}
|
|
|
|
static int set_osc_freq(struct atbm_state *priv, u32 freq /*in kHz*/)
|
|
{
|
|
u32 val;
|
|
u64 t;
|
|
|
|
/* 0x100000 * freq / 30.4MHz */
|
|
t = (u64)0x100000 * freq;
|
|
do_div(t, 30400);
|
|
val = t;
|
|
|
|
atbm8830_write_reg(priv, REG_OSC_CLK, val);
|
|
atbm8830_write_reg(priv, REG_OSC_CLK + 1, val >> 8);
|
|
atbm8830_write_reg(priv, REG_OSC_CLK + 2, val >> 16);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int set_if_freq(struct atbm_state *priv, u32 freq /*in kHz*/)
|
|
{
|
|
|
|
u32 fs = priv->config->osc_clk_freq;
|
|
u64 t;
|
|
u32 val;
|
|
u8 dat;
|
|
|
|
if (freq != 0) {
|
|
/* 2 * PI * (freq - fs) / fs * (2 ^ 22) */
|
|
t = (u64) 2 * 31416 * (freq - fs);
|
|
t <<= 22;
|
|
do_div(t, fs);
|
|
do_div(t, 1000);
|
|
val = t;
|
|
|
|
atbm8830_write_reg(priv, REG_TUNER_BASEBAND, 1);
|
|
atbm8830_write_reg(priv, REG_IF_FREQ, val);
|
|
atbm8830_write_reg(priv, REG_IF_FREQ+1, val >> 8);
|
|
atbm8830_write_reg(priv, REG_IF_FREQ+2, val >> 16);
|
|
|
|
atbm8830_read_reg(priv, REG_ADC_CONFIG, &dat);
|
|
dat &= 0xFC;
|
|
atbm8830_write_reg(priv, REG_ADC_CONFIG, dat);
|
|
} else {
|
|
/* Zero IF */
|
|
atbm8830_write_reg(priv, REG_TUNER_BASEBAND, 0);
|
|
|
|
atbm8830_read_reg(priv, REG_ADC_CONFIG, &dat);
|
|
dat &= 0xFC;
|
|
dat |= 0x02;
|
|
atbm8830_write_reg(priv, REG_ADC_CONFIG, dat);
|
|
|
|
if (priv->config->zif_swap_iq)
|
|
atbm8830_write_reg(priv, REG_SWAP_I_Q, 0x03);
|
|
else
|
|
atbm8830_write_reg(priv, REG_SWAP_I_Q, 0x01);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int is_locked(struct atbm_state *priv, u8 *locked)
|
|
{
|
|
u8 status;
|
|
|
|
atbm8830_read_reg(priv, REG_LOCK_STATUS, &status);
|
|
|
|
if (locked != NULL)
|
|
*locked = (status == 1);
|
|
return 0;
|
|
}
|
|
|
|
static int set_agc_config(struct atbm_state *priv,
|
|
u8 min, u8 max, u8 hold_loop)
|
|
{
|
|
/* no effect if both min and max are zero */
|
|
if (!min && !max)
|
|
return 0;
|
|
|
|
atbm8830_write_reg(priv, REG_AGC_MIN, min);
|
|
atbm8830_write_reg(priv, REG_AGC_MAX, max);
|
|
atbm8830_write_reg(priv, REG_AGC_HOLD_LOOP, hold_loop);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int set_static_channel_mode(struct atbm_state *priv)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 5; i++)
|
|
atbm8830_write_reg(priv, 0x099B + i, 0x08);
|
|
|
|
atbm8830_write_reg(priv, 0x095B, 0x7F);
|
|
atbm8830_write_reg(priv, 0x09CB, 0x01);
|
|
atbm8830_write_reg(priv, 0x09CC, 0x7F);
|
|
atbm8830_write_reg(priv, 0x09CD, 0x7F);
|
|
atbm8830_write_reg(priv, 0x0E01, 0x20);
|
|
|
|
/* For single carrier */
|
|
atbm8830_write_reg(priv, 0x0B03, 0x0A);
|
|
atbm8830_write_reg(priv, 0x0935, 0x10);
|
|
atbm8830_write_reg(priv, 0x0936, 0x08);
|
|
atbm8830_write_reg(priv, 0x093E, 0x08);
|
|
atbm8830_write_reg(priv, 0x096E, 0x06);
|
|
|
|
/* frame_count_max0 */
|
|
atbm8830_write_reg(priv, 0x0B09, 0x00);
|
|
/* frame_count_max1 */
|
|
atbm8830_write_reg(priv, 0x0B0A, 0x08);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int set_ts_config(struct atbm_state *priv)
|
|
{
|
|
const struct atbm8830_config *cfg = priv->config;
|
|
|
|
/*Set parallel/serial ts mode*/
|
|
atbm8830_write_reg(priv, REG_TS_SERIAL, cfg->serial_ts ? 1 : 0);
|
|
atbm8830_write_reg(priv, REG_TS_CLK_MODE, cfg->serial_ts ? 1 : 0);
|
|
/*Set ts sampling edge*/
|
|
atbm8830_write_reg(priv, REG_TS_SAMPLE_EDGE,
|
|
cfg->ts_sampling_edge ? 1 : 0);
|
|
/*Set ts clock freerun*/
|
|
atbm8830_write_reg(priv, REG_TS_CLK_FREERUN,
|
|
cfg->ts_clk_gated ? 0 : 1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int atbm8830_init(struct dvb_frontend *fe)
|
|
{
|
|
struct atbm_state *priv = fe->demodulator_priv;
|
|
const struct atbm8830_config *cfg = priv->config;
|
|
|
|
/*Set oscillator frequency*/
|
|
set_osc_freq(priv, cfg->osc_clk_freq);
|
|
|
|
/*Set IF frequency*/
|
|
set_if_freq(priv, cfg->if_freq);
|
|
|
|
/*Set AGC Config*/
|
|
set_agc_config(priv, cfg->agc_min, cfg->agc_max,
|
|
cfg->agc_hold_loop);
|
|
|
|
/*Set static channel mode*/
|
|
set_static_channel_mode(priv);
|
|
|
|
set_ts_config(priv);
|
|
/*Turn off DSP reset*/
|
|
atbm8830_write_reg(priv, 0x000A, 0);
|
|
|
|
/*SW version test*/
|
|
atbm8830_write_reg(priv, 0x020C, 11);
|
|
|
|
/* Run */
|
|
atbm8830_write_reg(priv, REG_DEMOD_RUN, 1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void atbm8830_release(struct dvb_frontend *fe)
|
|
{
|
|
struct atbm_state *state = fe->demodulator_priv;
|
|
dprintk("%s\n", __func__);
|
|
|
|
kfree(state);
|
|
}
|
|
|
|
static int atbm8830_set_fe(struct dvb_frontend *fe)
|
|
{
|
|
struct atbm_state *priv = fe->demodulator_priv;
|
|
int i;
|
|
u8 locked = 0;
|
|
dprintk("%s\n", __func__);
|
|
|
|
/* set frequency */
|
|
if (fe->ops.tuner_ops.set_params) {
|
|
if (fe->ops.i2c_gate_ctrl)
|
|
fe->ops.i2c_gate_ctrl(fe, 1);
|
|
fe->ops.tuner_ops.set_params(fe);
|
|
if (fe->ops.i2c_gate_ctrl)
|
|
fe->ops.i2c_gate_ctrl(fe, 0);
|
|
}
|
|
|
|
/* start auto lock */
|
|
for (i = 0; i < 10; i++) {
|
|
mdelay(100);
|
|
dprintk("Try %d\n", i);
|
|
is_locked(priv, &locked);
|
|
if (locked != 0) {
|
|
dprintk("ATBM8830 locked!\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int atbm8830_get_fe(struct dvb_frontend *fe,
|
|
struct dtv_frontend_properties *c)
|
|
{
|
|
dprintk("%s\n", __func__);
|
|
|
|
/* TODO: get real readings from device */
|
|
/* inversion status */
|
|
c->inversion = INVERSION_OFF;
|
|
|
|
/* bandwidth */
|
|
c->bandwidth_hz = 8000000;
|
|
|
|
c->code_rate_HP = FEC_AUTO;
|
|
c->code_rate_LP = FEC_AUTO;
|
|
|
|
c->modulation = QAM_AUTO;
|
|
|
|
/* transmission mode */
|
|
c->transmission_mode = TRANSMISSION_MODE_AUTO;
|
|
|
|
/* guard interval */
|
|
c->guard_interval = GUARD_INTERVAL_AUTO;
|
|
|
|
/* hierarchy */
|
|
c->hierarchy = HIERARCHY_NONE;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int atbm8830_get_tune_settings(struct dvb_frontend *fe,
|
|
struct dvb_frontend_tune_settings *fesettings)
|
|
{
|
|
fesettings->min_delay_ms = 0;
|
|
fesettings->step_size = 0;
|
|
fesettings->max_drift = 0;
|
|
return 0;
|
|
}
|
|
|
|
static int atbm8830_read_status(struct dvb_frontend *fe,
|
|
enum fe_status *fe_status)
|
|
{
|
|
struct atbm_state *priv = fe->demodulator_priv;
|
|
u8 locked = 0;
|
|
u8 agc_locked = 0;
|
|
|
|
dprintk("%s\n", __func__);
|
|
*fe_status = 0;
|
|
|
|
is_locked(priv, &locked);
|
|
if (locked) {
|
|
*fe_status |= FE_HAS_SIGNAL | FE_HAS_CARRIER |
|
|
FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK;
|
|
}
|
|
dprintk("%s: fe_status=0x%x\n", __func__, *fe_status);
|
|
|
|
atbm8830_read_reg(priv, REG_AGC_LOCK, &agc_locked);
|
|
dprintk("AGC Lock: %d\n", agc_locked);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int atbm8830_read_ber(struct dvb_frontend *fe, u32 *ber)
|
|
{
|
|
struct atbm_state *priv = fe->demodulator_priv;
|
|
u32 frame_err;
|
|
u8 t;
|
|
|
|
dprintk("%s\n", __func__);
|
|
|
|
atbm8830_reglatch_lock(priv, 1);
|
|
|
|
atbm8830_read_reg(priv, REG_FRAME_ERR_CNT + 1, &t);
|
|
frame_err = t & 0x7F;
|
|
frame_err <<= 8;
|
|
atbm8830_read_reg(priv, REG_FRAME_ERR_CNT, &t);
|
|
frame_err |= t;
|
|
|
|
atbm8830_reglatch_lock(priv, 0);
|
|
|
|
*ber = frame_err * 100 / 32767;
|
|
|
|
dprintk("%s: ber=0x%x\n", __func__, *ber);
|
|
return 0;
|
|
}
|
|
|
|
static int atbm8830_read_signal_strength(struct dvb_frontend *fe, u16 *signal)
|
|
{
|
|
struct atbm_state *priv = fe->demodulator_priv;
|
|
u32 pwm;
|
|
u8 t;
|
|
|
|
dprintk("%s\n", __func__);
|
|
atbm8830_reglatch_lock(priv, 1);
|
|
|
|
atbm8830_read_reg(priv, REG_AGC_PWM_VAL + 1, &t);
|
|
pwm = t & 0x03;
|
|
pwm <<= 8;
|
|
atbm8830_read_reg(priv, REG_AGC_PWM_VAL, &t);
|
|
pwm |= t;
|
|
|
|
atbm8830_reglatch_lock(priv, 0);
|
|
|
|
dprintk("AGC PWM = 0x%02X\n", pwm);
|
|
pwm = 0x400 - pwm;
|
|
|
|
*signal = pwm * 0x10000 / 0x400;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int atbm8830_read_snr(struct dvb_frontend *fe, u16 *snr)
|
|
{
|
|
dprintk("%s\n", __func__);
|
|
*snr = 0;
|
|
return 0;
|
|
}
|
|
|
|
static int atbm8830_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
|
|
{
|
|
dprintk("%s\n", __func__);
|
|
*ucblocks = 0;
|
|
return 0;
|
|
}
|
|
|
|
static int atbm8830_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
|
|
{
|
|
struct atbm_state *priv = fe->demodulator_priv;
|
|
|
|
return atbm8830_write_reg(priv, REG_I2C_GATE, enable ? 1 : 0);
|
|
}
|
|
|
|
static const struct dvb_frontend_ops atbm8830_ops = {
|
|
.delsys = { SYS_DTMB },
|
|
.info = {
|
|
.name = "AltoBeam ATBM8830/8831 DMB-TH",
|
|
.frequency_min = 474000000,
|
|
.frequency_max = 858000000,
|
|
.frequency_stepsize = 10000,
|
|
.caps =
|
|
FE_CAN_FEC_AUTO |
|
|
FE_CAN_QAM_AUTO |
|
|
FE_CAN_TRANSMISSION_MODE_AUTO |
|
|
FE_CAN_GUARD_INTERVAL_AUTO
|
|
},
|
|
|
|
.release = atbm8830_release,
|
|
|
|
.init = atbm8830_init,
|
|
.sleep = NULL,
|
|
.write = NULL,
|
|
.i2c_gate_ctrl = atbm8830_i2c_gate_ctrl,
|
|
|
|
.set_frontend = atbm8830_set_fe,
|
|
.get_frontend = atbm8830_get_fe,
|
|
.get_tune_settings = atbm8830_get_tune_settings,
|
|
|
|
.read_status = atbm8830_read_status,
|
|
.read_ber = atbm8830_read_ber,
|
|
.read_signal_strength = atbm8830_read_signal_strength,
|
|
.read_snr = atbm8830_read_snr,
|
|
.read_ucblocks = atbm8830_read_ucblocks,
|
|
};
|
|
|
|
struct dvb_frontend *atbm8830_attach(const struct atbm8830_config *config,
|
|
struct i2c_adapter *i2c)
|
|
{
|
|
struct atbm_state *priv = NULL;
|
|
u8 data = 0;
|
|
|
|
dprintk("%s()\n", __func__);
|
|
|
|
if (config == NULL || i2c == NULL)
|
|
return NULL;
|
|
|
|
priv = kzalloc(sizeof(struct atbm_state), GFP_KERNEL);
|
|
if (priv == NULL)
|
|
goto error_out;
|
|
|
|
priv->config = config;
|
|
priv->i2c = i2c;
|
|
|
|
/* check if the demod is there */
|
|
if (atbm8830_read_reg(priv, REG_CHIP_ID, &data) != 0) {
|
|
dprintk("%s atbm8830/8831 not found at i2c addr 0x%02X\n",
|
|
__func__, priv->config->demod_address);
|
|
goto error_out;
|
|
}
|
|
dprintk("atbm8830 chip id: 0x%02X\n", data);
|
|
|
|
memcpy(&priv->frontend.ops, &atbm8830_ops,
|
|
sizeof(struct dvb_frontend_ops));
|
|
priv->frontend.demodulator_priv = priv;
|
|
|
|
atbm8830_init(&priv->frontend);
|
|
|
|
atbm8830_i2c_gate_ctrl(&priv->frontend, 1);
|
|
|
|
return &priv->frontend;
|
|
|
|
error_out:
|
|
dprintk("%s() error_out\n", __func__);
|
|
kfree(priv);
|
|
return NULL;
|
|
|
|
}
|
|
EXPORT_SYMBOL(atbm8830_attach);
|
|
|
|
MODULE_DESCRIPTION("AltoBeam ATBM8830/8831 GB20600 demodulator driver");
|
|
MODULE_AUTHOR("David T. L. Wong <davidtlwong@gmail.com>");
|
|
MODULE_LICENSE("GPL");
|