Commit 42afd061 authored by Patrick Boettcher's avatar Patrick Boettcher Committed by Mauro Carvalho Chehab
Browse files

V4L/DVB (4461): Added missing dibx000-common code and headers 



The first commit omitted the common-code and header-files.

Signed-off-by: default avatarPatrick Boettcher <pb@linuxtv.org>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@infradead.org>
parent b7571f8d

drivers/media/dvb/frontends/dib3000mc.h

0 → 100644
+58 −0
Original line number Diff line number Diff line 
/*

 * Driver for DiBcom DiB3000MC/P-demodulator.

 *

 * Copyright (C) 2004-6 DiBcom (http://www.dibcom.fr/)

 * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher\@desy.de)

 *

 * This code is partially based on the previous dib3000mc.c .

 *

 * 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, version 2.

 */

#ifndef DIB3000MC_H

#define DIB3000MC_H



#include "dibx000_common.h"



struct dib3000mc_config {

	struct dibx000_agc_config *agc;



	u8 phase_noise_mode;

	u8 impulse_noise_mode;



	u8  pwm3_inversion;

	u8  use_pwm3;

	u16 pwm3_value;



	u16 max_time;

	u16 ln_adc_level;



	u8 mobile_mode;



	u8 output_mpeg2_in_188_bytes;

};



#define DEFAULT_DIB3000MC_I2C_ADDRESS 16

#define DEFAULT_DIB3000P_I2C_ADDRESS  24



#if defined(CONFIG_DVB_DIB3000MC) || defined(CONFIG_DVB_DIB3000MC_MODULE)

extern int dib3000mc_attach(struct i2c_adapter *i2c_adap, int no_of_demods, u8 default_addr,

    u8 do_i2c_enum, struct dib3000mc_config cfg[], struct dvb_frontend *demod[]);

#else

static inline struct dvb_frontend* dib3000mc_attach(const struct dib3000_config* config,

					     struct i2c_adapter* i2c, struct dib_fe_xfer_ops *xfer_ops)

{

	printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);

	return NULL;

}

#endif // CONFIG_DVB_DIB3000MC



extern struct i2c_adapter * dib3000mc_get_tuner_i2c_master(struct dvb_frontend *demod, int gating);



extern int dib3000mc_pid_control(struct dvb_frontend *fe, int index, int pid,int onoff);

extern int dib3000mc_pid_parse(struct dvb_frontend *fe, int onoff);



extern void dib3000mc_set_config(struct dvb_frontend *, struct dib3000mc_config *);



#endif

drivers/media/dvb/frontends/dibx000_common.c

0 → 100644
+148 −0
Original line number Diff line number Diff line 
#include <linux/i2c.h>



#include "dibx000_common.h"



static int debug;

module_param(debug, int, 0644);

MODULE_PARM_DESC(debug, "turn on debugging (default: 0)");



#define dprintk(args...) do { if (debug) { printk(KERN_DEBUG "DiBX000: "); printk(args); } } while (0)



static int dibx000_write_word(struct dibx000_i2c_master *mst, u16 reg, u16 val)

{

	u8 b[4] = {

		(reg >> 8) & 0xff, reg & 0xff,

		(val >> 8) & 0xff, val & 0xff,

	};

	struct i2c_msg msg = {

		.addr = mst->i2c_addr, .flags = 0, .buf = b, .len = 4

	};

	return i2c_transfer(mst->i2c_adap, &msg, 1) != 1 ? -EREMOTEIO : 0;

}





static int dibx000_i2c_select_interface(struct dibx000_i2c_master *mst, enum dibx000_i2c_interface intf)

{

	if (mst->device_rev > DIB3000MC && mst->selected_interface != intf) {

		dprintk("selecting interface: %d\n",intf);

		mst->selected_interface = intf;

		return dibx000_write_word(mst, mst->base_reg + 4, intf);

	}

	return 0;

}



static int dibx000_i2c_gate_ctrl(struct dibx000_i2c_master *mst, u8 tx[4], u8 addr, int onoff)

{

	u16 val;





	if (onoff)

		val = addr << 8; // bit 7 = use master or not, if 0, the gate is open

	else

		val = 1 << 7;



	if (mst->device_rev > DIB7000)

		val <<= 1;



	tx[0] = (((mst->base_reg + 1) >> 8) & 0xff);

	tx[1] = ( (mst->base_reg + 1)       & 0xff);

	tx[2] = val >> 8;

	tx[3] = val & 0xff;



	return 0;

}



static u32 dibx000_i2c_func(struct i2c_adapter *adapter)

{

	return I2C_FUNC_I2C;

}



static int dibx000_i2c_gated_tuner_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)

{

	struct dibx000_i2c_master *mst = i2c_get_adapdata(i2c_adap);

	struct i2c_msg m[2 + num];

	u8 tx_open[4], tx_close[4];



	memset(m,0, sizeof(struct i2c_msg) * (2 + num)),



	dibx000_i2c_select_interface(mst, DIBX000_I2C_INTERFACE_TUNER);



	dibx000_i2c_gate_ctrl(mst, tx_open,  msg[0].addr, 1);

	m[0].addr = mst->i2c_addr;

	m[0].buf  = tx_open;

	m[0].len  = 4;



	memcpy(&m[1], msg, sizeof(struct i2c_msg) * num);



	dibx000_i2c_gate_ctrl(mst, tx_close, 0, 0);

	m[num+1].addr = mst->i2c_addr;

	m[num+1].buf  = tx_close;

	m[num+1].len  = 4;



	return i2c_transfer(mst->i2c_adap, m, 2+num) == 2 + num ? num : -EIO;

}



static struct i2c_algorithm dibx000_i2c_gated_tuner_algo = {

	.master_xfer   = dibx000_i2c_gated_tuner_xfer,

	.functionality = dibx000_i2c_func,

};



struct i2c_adapter * dibx000_get_i2c_adapter(struct dibx000_i2c_master *mst, enum dibx000_i2c_interface intf, int gating)

{

	struct i2c_adapter *i2c = NULL;



	switch (intf) {

		case DIBX000_I2C_INTERFACE_TUNER:

			if (gating)

				i2c = &mst->gated_tuner_i2c_adap;

			break;

		default:

			printk(KERN_ERR "DiBX000: incorrect I2C interface selected\n");

			break;

	}



	return i2c;

}

EXPORT_SYMBOL(dibx000_get_i2c_adapter);



static int i2c_adapter_init(struct i2c_adapter *i2c_adap, struct i2c_algorithm *algo, const char name[I2C_NAME_SIZE], struct dibx000_i2c_master *mst)

{

	strncpy(i2c_adap->name, name, I2C_NAME_SIZE);

	i2c_adap->class     = I2C_CLASS_TV_DIGITAL,

	i2c_adap->algo      = algo;

	i2c_adap->algo_data = NULL;

	i2c_set_adapdata(i2c_adap, mst);

	if (i2c_add_adapter(i2c_adap) < 0)

		return -ENODEV;

	return 0;

}



int dibx000_init_i2c_master(struct dibx000_i2c_master *mst, u16 device_rev, struct i2c_adapter *i2c_adap, u8 i2c_addr)

{

	u8 tx[4];

	struct i2c_msg m = { .addr = i2c_addr >> 1, .buf = tx, .len = 4 };



	mst->device_rev = device_rev;

	mst->i2c_adap   = i2c_adap;

	mst->i2c_addr   = i2c_addr >> 1;



	if (device_rev == DIB7000P)

		mst->base_reg = 1024;

	else

		mst->base_reg = 768;



    if (i2c_adapter_init(&mst->gated_tuner_i2c_adap, &dibx000_i2c_gated_tuner_algo, "DiBX000 tuner I2C bus", mst) != 0)

		printk(KERN_ERR "DiBX000: could not initialize the tuner i2c_adapter\n");



	/* initialize the i2c-master by closing the gate */

	dibx000_i2c_gate_ctrl(mst, tx, 0, 0);



	return i2c_transfer(i2c_adap, &m, 1) == 1;

}

EXPORT_SYMBOL(dibx000_init_i2c_master);



void dibx000_exit_i2c_master(struct dibx000_i2c_master *mst)

{

	i2c_del_adapter(&mst->gated_tuner_i2c_adap);

}

EXPORT_SYMBOL(dibx000_exit_i2c_master);

drivers/media/dvb/frontends/dibx000_common.h

0 → 100644
+166 −0
Original line number Diff line number Diff line 
#ifndef DIBX000_COMMON_H

#define DIBX000_COMMON_H



enum dibx000_i2c_interface {

	DIBX000_I2C_INTERFACE_TUNER    = 0,

	DIBX000_I2C_INTERFACE_GPIO_1_2 = 1,

	DIBX000_I2C_INTERFACE_GPIO_3_4 = 2

};



struct dibx000_i2c_master {

#define DIB3000MC 1

#define DIB7000   2

#define DIB7000P  11

#define DIB7000MC 12

	u16 device_rev;



	enum dibx000_i2c_interface selected_interface;



//	struct i2c_adapter  tuner_i2c_adap;

	struct i2c_adapter  gated_tuner_i2c_adap;



	struct i2c_adapter *i2c_adap;

	u8                  i2c_addr;



	u16 base_reg;

};



extern int dibx000_init_i2c_master(struct dibx000_i2c_master *mst, u16 device_rev, struct i2c_adapter *i2c_adap, u8 i2c_addr);

extern struct i2c_adapter * dibx000_get_i2c_adapter(struct dibx000_i2c_master *mst, enum dibx000_i2c_interface intf, int gating);

extern void dibx000_exit_i2c_master(struct dibx000_i2c_master *mst);



#define BAND_LBAND 0x01

#define BAND_UHF   0x02

#define BAND_VHF   0x04



struct dibx000_agc_config {

	/* defines the capabilities of this AGC-setting - using the BAND_-defines*/

	u8  band_caps;



	u16 setup;



	u16 inv_gain;

	u16 time_stabiliz;



	u8  alpha_level;

	u16 thlock;



	u8  wbd_inv;

	u16 wbd_ref;

	u8 wbd_sel;

	u8 wbd_alpha;



	u16 agc1_max;

	u16 agc1_min;

	u16 agc2_max;

	u16 agc2_min;



	u8 agc1_pt1;

	u8 agc1_pt2;

	u8 agc1_pt3;



	u8 agc1_slope1;

	u8 agc1_slope2;



	u8 agc2_pt1;

	u8 agc2_pt2;



	u8 agc2_slope1;

	u8 agc2_slope2;



	u8 alpha_mant;

	u8 alpha_exp;



	u8 beta_mant;

	u8 beta_exp;



	u8 perform_agc_softsplit;



	struct {

		u16 min;

		u16 max;

		u16 min_thres;

		u16 max_thres;

	} split;

};



struct dibx000_bandwidth_config {

	u32   internal;

	u32   sampling;



	u8 pll_prediv;

	u8 pll_ratio;

	u8 pll_range;

	u8 pll_reset;

	u8 pll_bypass;



	u8 enable_refdiv;

	u8 bypclk_div;

	u8 IO_CLK_en_core;

	u8 ADClkSrc;

	u8 modulo;



	u16 sad_cfg;



	u32 ifreq;

	u32 timf;

};



enum dibx000_adc_states {

	DIBX000_SLOW_ADC_ON = 0,

	DIBX000_SLOW_ADC_OFF,

	DIBX000_ADC_ON,

	DIBX000_ADC_OFF,

	DIBX000_VBG_ENABLE,

	DIBX000_VBG_DISABLE,

};



#define BW_INDEX_TO_KHZ(v) ( (v) == BANDWIDTH_8_MHZ  ? 8000 : \

			     (v) == BANDWIDTH_7_MHZ  ? 7000 : \

			     (v) == BANDWIDTH_6_MHZ  ? 6000 : 8000 )



/* Chip output mode. */

#define OUTMODE_HIGH_Z                      0

#define OUTMODE_MPEG2_PAR_GATED_CLK         1

#define OUTMODE_MPEG2_PAR_CONT_CLK          2

#define OUTMODE_MPEG2_SERIAL                7

#define OUTMODE_DIVERSITY                   4

#define OUTMODE_MPEG2_FIFO                  5



/* I hope I can get rid of the following kludge in the near future */

struct dibx000_ofdm_channel {

	u8  Bw;

	s16 nfft;

	s16 guard;

	s16 nqam;

	s16 vit_hrch;

	s16 vit_select_hp;

	s16 vit_alpha;

	s16 vit_code_rate_hp;

	s16 vit_code_rate_lp;

};



#define FEP2DIB(fep,ch) \

	(ch)->Bw               = (fep)->u.ofdm.bandwidth; \

	(ch)->nfft             = (fep)->u.ofdm.transmission_mode == TRANSMISSION_MODE_AUTO ? -1 : (fep)->u.ofdm.transmission_mode; \

	(ch)->guard            = (fep)->u.ofdm.guard_interval == GUARD_INTERVAL_AUTO ? -1 : (fep)->u.ofdm.guard_interval; \

	(ch)->nqam             = (fep)->u.ofdm.constellation == QAM_AUTO ? -1 : (fep)->u.ofdm.constellation == QAM_64 ? 2 : (fep)->u.ofdm.constellation; \

	(ch)->vit_hrch         = 0; /* linux-dvb is not prepared for HIERARCHICAL TRANSMISSION */ \

	(ch)->vit_select_hp    = 1; \

	(ch)->vit_alpha        = 1; \

	(ch)->vit_code_rate_hp = (fep)->u.ofdm.code_rate_HP == FEC_AUTO ? -1 : (fep)->u.ofdm.code_rate_HP; \

	(ch)->vit_code_rate_lp = (fep)->u.ofdm.code_rate_LP == FEC_AUTO ? -1 : (fep)->u.ofdm.code_rate_LP;



#define INIT_OFDM_CHANNEL(ch) do {\

	(ch)->Bw               = 0;  \

	(ch)->nfft             = -1; \

	(ch)->guard            = -1; \

	(ch)->nqam             = -1; \

	(ch)->vit_hrch         = -1; \

	(ch)->vit_select_hp    = -1; \

	(ch)->vit_alpha        = -1; \

	(ch)->vit_code_rate_hp = -1; \

	(ch)->vit_code_rate_lp = -1; \

} while (0)



#endif