[linux-2.6-block.git] / drivers / media / dvb / ttusb-dec / ttusbdecfe.c

/*
 * TTUSB DEC Frontend Driver
 *
 * Copyright (C) 2003-2004 Alex Woods <linux-dvb@giblets.org>
 *
 * 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.
 *
 */

#include "dvb_frontend.h"
#include "ttusbdecfe.h"


#define LOF_HI			10600000
#define LOF_LO			9750000

struct ttusbdecfe_state {

	/* configuration settings */
	const struct ttusbdecfe_config* config;

	struct dvb_frontend frontend;

	u8 hi_band;
	u8 voltage;
};


static int ttusbdecfe_dvbs_read_status(struct dvb_frontend *fe,
	fe_status_t *status)
{
	*status = FE_HAS_SIGNAL | FE_HAS_VITERBI |
		FE_HAS_SYNC | FE_HAS_CARRIER | FE_HAS_LOCK;
	return 0;
}


static int ttusbdecfe_dvbt_read_status(struct dvb_frontend *fe,
	fe_status_t *status)
{
	struct ttusbdecfe_state* state = fe->demodulator_priv;
	u8 b[] = { 0x00, 0x00, 0x00, 0x00,
		   0x00, 0x00, 0x00, 0x00 };
	u8 result[4];
	int len, ret;

	*status=0;

	ret=state->config->send_command(fe, 0x73, sizeof(b), b, &len, result);
	if(ret)
		return ret;

	if(len != 4) {
		printk(KERN_ERR "%s: unexpected reply\n", __func__);
		return -EIO;
	}

	switch(result[3]) {
		case 1:  /* not tuned yet */
		case 2:  /* no signal/no lock*/
			break;
		case 3:	 /* signal found and locked*/
			*status = FE_HAS_SIGNAL | FE_HAS_VITERBI |
			FE_HAS_SYNC | FE_HAS_CARRIER | FE_HAS_LOCK;
			break;
		case 4:
			*status = FE_TIMEDOUT;
			break;
		default:
			pr_info("%s: returned unknown value: %d\n",
				__func__, result[3]);
			return -EIO;
	}

	return 0;
}

static int ttusbdecfe_dvbt_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
{
	struct ttusbdecfe_state* state = (struct ttusbdecfe_state*) fe->demodulator_priv;
	u8 b[] = { 0x00, 0x00, 0x00, 0x03,
		   0x00, 0x00, 0x00, 0x00,
		   0x00, 0x00, 0x00, 0x01,
		   0x00, 0x00, 0x00, 0xff,
		   0x00, 0x00, 0x00, 0xff };

	__be32 freq = htonl(p->frequency / 1000);
	memcpy(&b[4], &freq, sizeof (u32));
	state->config->send_command(fe, 0x71, sizeof(b), b, NULL, NULL);

	return 0;
}

static int ttusbdecfe_dvbt_get_tune_settings(struct dvb_frontend* fe,
					struct dvb_frontend_tune_settings* fesettings)
{
		fesettings->min_delay_ms = 1500;
		/* Drift compensation makes no sense for DVB-T */
		fesettings->step_size = 0;
		fesettings->max_drift = 0;
		return 0;
}

static int ttusbdecfe_dvbs_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
{
	struct ttusbdecfe_state* state = (struct ttusbdecfe_state*) fe->demodulator_priv;

	u8 b[] = { 0x00, 0x00, 0x00, 0x01,
		   0x00, 0x00, 0x00, 0x00,
		   0x00, 0x00, 0x00, 0x01,
		   0x00, 0x00, 0x00, 0x00,
		   0x00, 0x00, 0x00, 0x00,
		   0x00, 0x00, 0x00, 0x00,
		   0x00, 0x00, 0x00, 0x00,
		   0x00, 0x00, 0x00, 0x00,
		   0x00, 0x00, 0x00, 0x00,
		   0x00, 0x00, 0x00, 0x00 };
	__be32 freq;
	__be32 sym_rate;
	__be32 band;
	__be32 lnb_voltage;

	freq = htonl(p->frequency +
	       (state->hi_band ? LOF_HI : LOF_LO));
	memcpy(&b[4], &freq, sizeof(u32));
	sym_rate = htonl(p->u.qam.symbol_rate);
	memcpy(&b[12], &sym_rate, sizeof(u32));
	band = htonl(state->hi_band ? LOF_HI : LOF_LO);
	memcpy(&b[24], &band, sizeof(u32));
	lnb_voltage = htonl(state->voltage);
	memcpy(&b[28], &lnb_voltage, sizeof(u32));

	state->config->send_command(fe, 0x71, sizeof(b), b, NULL, NULL);

	return 0;
}

static int ttusbdecfe_dvbs_diseqc_send_master_cmd(struct dvb_frontend* fe, struct dvb_diseqc_master_cmd *cmd)
{
	struct ttusbdecfe_state* state = (struct ttusbdecfe_state*) fe->demodulator_priv;
	u8 b[] = { 0x00, 0xff, 0x00, 0x00,
		   0x00, 0x00, 0x00, 0x00,
		   0x00, 0x00 };

	memcpy(&b[4], cmd->msg, cmd->msg_len);

	state->config->send_command(fe, 0x72,
				    sizeof(b) - (6 - cmd->msg_len), b,
				    NULL, NULL);

	return 0;
}


static int ttusbdecfe_dvbs_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
{
	struct ttusbdecfe_state* state = (struct ttusbdecfe_state*) fe->demodulator_priv;

	state->hi_band = (SEC_TONE_ON == tone);

	return 0;
}


static int ttusbdecfe_dvbs_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
{
	struct ttusbdecfe_state* state = (struct ttusbdecfe_state*) fe->demodulator_priv;

	switch (voltage) {
	case SEC_VOLTAGE_13:
		state->voltage = 13;
		break;
	case SEC_VOLTAGE_18:
		state->voltage = 18;
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static void ttusbdecfe_release(struct dvb_frontend* fe)
{
	struct ttusbdecfe_state* state = (struct ttusbdecfe_state*) fe->demodulator_priv;
	kfree(state);
}

static struct dvb_frontend_ops ttusbdecfe_dvbt_ops;

struct dvb_frontend* ttusbdecfe_dvbt_attach(const struct ttusbdecfe_config* config)
{
	struct ttusbdecfe_state* state = NULL;

	/* allocate memory for the internal state */
	state = kmalloc(sizeof(struct ttusbdecfe_state), GFP_KERNEL);
	if (state == NULL)
		return NULL;

	/* setup the state */
	state->config = config;

	/* create dvb_frontend */
	memcpy(&state->frontend.ops, &ttusbdecfe_dvbt_ops, sizeof(struct dvb_frontend_ops));
	state->frontend.demodulator_priv = state;
	return &state->frontend;
}

static struct dvb_frontend_ops ttusbdecfe_dvbs_ops;

struct dvb_frontend* ttusbdecfe_dvbs_attach(const struct ttusbdecfe_config* config)
{
	struct ttusbdecfe_state* state = NULL;

	/* allocate memory for the internal state */
	state = kmalloc(sizeof(struct ttusbdecfe_state), GFP_KERNEL);
	if (state == NULL)
		return NULL;

	/* setup the state */
	state->config = config;
	state->voltage = 0;
	state->hi_band = 0;

	/* create dvb_frontend */
	memcpy(&state->frontend.ops, &ttusbdecfe_dvbs_ops, sizeof(struct dvb_frontend_ops));
	state->frontend.demodulator_priv = state;
	return &state->frontend;
}

static struct dvb_frontend_ops ttusbdecfe_dvbt_ops = {

	.info = {
		.name			= "TechnoTrend/Hauppauge DEC2000-t Frontend",
		.type			= FE_OFDM,
		.frequency_min		= 51000000,
		.frequency_max		= 858000000,
		.frequency_stepsize	= 62500,
		.caps =	FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
			FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
			FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
			FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO |
			FE_CAN_HIERARCHY_AUTO,
	},

	.release = ttusbdecfe_release,

	.set_frontend = ttusbdecfe_dvbt_set_frontend,

	.get_tune_settings = ttusbdecfe_dvbt_get_tune_settings,

	.read_status = ttusbdecfe_dvbt_read_status,
};

static struct dvb_frontend_ops ttusbdecfe_dvbs_ops = {

	.info = {
		.name			= "TechnoTrend/Hauppauge DEC3000-s Frontend",
		.type			= FE_QPSK,
		.frequency_min		= 950000,
		.frequency_max		= 2150000,
		.frequency_stepsize	= 125,
		.symbol_rate_min        = 1000000,  /* guessed */
		.symbol_rate_max        = 45000000, /* guessed */
		.caps =	FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
			FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
			FE_CAN_QPSK
	},

	.release = ttusbdecfe_release,

	.set_frontend = ttusbdecfe_dvbs_set_frontend,

	.read_status = ttusbdecfe_dvbs_read_status,

	.diseqc_send_master_cmd = ttusbdecfe_dvbs_diseqc_send_master_cmd,
	.set_voltage = ttusbdecfe_dvbs_set_voltage,
	.set_tone = ttusbdecfe_dvbs_set_tone,
};

MODULE_DESCRIPTION("TTUSB DEC DVB-T/S Demodulator driver");
MODULE_AUTHOR("Alex Woods/Andrew de Quincey");
MODULE_LICENSE("GPL");

EXPORT_SYMBOL(ttusbdecfe_dvbt_attach);
EXPORT_SYMBOL(ttusbdecfe_dvbs_attach);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* TTUSB DEC Frontend Driver
	3	*
	4	* Copyright (C) 2003-2004 Alex Woods <linux-dvb@giblets.org>
	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, write to the Free Software
	18	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	19	*
	20	*/
	21
	22	#include "dvb_frontend.h"
	23	#include "ttusbdecfe.h"
	24
	25
	26	#define LOF_HI 10600000
	27	#define LOF_LO 9750000
	28
	29	struct ttusbdecfe_state {
	30
1da177e4 LT	31	/* configuration settings */
	32	const struct ttusbdecfe_config* config;
	33
	34	struct dvb_frontend frontend;
	35
	36	u8 hi_band;
	37	u8 voltage;
	38	};
	39
	40
4d2858c6 PB	41	static int ttusbdecfe_dvbs_read_status(struct dvb_frontend *fe,
	42	fe_status_t *status)
	43	{
	44	*status = FE_HAS_SIGNAL \| FE_HAS_VITERBI \|
	45	FE_HAS_SYNC \| FE_HAS_CARRIER \| FE_HAS_LOCK;
	46	return 0;
	47	}
	48
	49
	50	static int ttusbdecfe_dvbt_read_status(struct dvb_frontend *fe,
	51	fe_status_t *status)
1da177e4	52	{
f961e71a AW	53	struct ttusbdecfe_state* state = fe->demodulator_priv;
	54	u8 b[] = { 0x00, 0x00, 0x00, 0x00,
	55	0x00, 0x00, 0x00, 0x00 };
	56	u8 result[4];
	57	int len, ret;
	58
	59	*status=0;
	60
	61	ret=state->config->send_command(fe, 0x73, sizeof(b), b, &len, result);
	62	if(ret)
	63	return ret;
	64
	65	if(len != 4) {
e9815cee	66	printk(KERN_ERR "%s: unexpected reply\n", __func__);
f961e71a AW	67	return -EIO;
	68	}
	69
	70	switch(result[3]) {
	71	case 1: /* not tuned yet */
	72	case 2: /* no signal/no lock*/
	73	break;
	74	case 3: /* signal found and locked*/
	75	*status = FE_HAS_SIGNAL \| FE_HAS_VITERBI \|
	76	FE_HAS_SYNC \| FE_HAS_CARRIER \| FE_HAS_LOCK;
	77	break;
	78	case 4:
	79	*status = FE_TIMEDOUT;
	80	break;
	81	default:
	82	pr_info("%s: returned unknown value: %d\n",
e9815cee	83	__func__, result[3]);
f961e71a AW	84	return -EIO;
f961e71a AW	85	}
1da177e4 LT	86
	87	return 0;
	88	}
	89
	90	static int ttusbdecfe_dvbt_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
	91	{
	92	struct ttusbdecfe_state* state = (struct ttusbdecfe_state*) fe->demodulator_priv;
	93	u8 b[] = { 0x00, 0x00, 0x00, 0x03,
	94	0x00, 0x00, 0x00, 0x00,
	95	0x00, 0x00, 0x00, 0x01,
	96	0x00, 0x00, 0x00, 0xff,
	97	0x00, 0x00, 0x00, 0xff };
	98
d4f979a9	99	__be32 freq = htonl(p->frequency / 1000);
1da177e4 LT	100	memcpy(&b[4], &freq, sizeof (u32));
	101	state->config->send_command(fe, 0x71, sizeof(b), b, NULL, NULL);
	102
	103	return 0;
	104	}
	105
f961e71a AW	106	static int ttusbdecfe_dvbt_get_tune_settings(struct dvb_frontend* fe,
	107	struct dvb_frontend_tune_settings* fesettings)
	108	{
	109	fesettings->min_delay_ms = 1500;
	110	/* Drift compensation makes no sense for DVB-T */
	111	fesettings->step_size = 0;
	112	fesettings->max_drift = 0;
	113	return 0;
	114	}
	115
1da177e4 LT	116	static int ttusbdecfe_dvbs_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
	117	{
	118	struct ttusbdecfe_state* state = (struct ttusbdecfe_state*) fe->demodulator_priv;
	119
	120	u8 b[] = { 0x00, 0x00, 0x00, 0x01,
	121	0x00, 0x00, 0x00, 0x00,
	122	0x00, 0x00, 0x00, 0x01,
	123	0x00, 0x00, 0x00, 0x00,
	124	0x00, 0x00, 0x00, 0x00,
	125	0x00, 0x00, 0x00, 0x00,
	126	0x00, 0x00, 0x00, 0x00,
	127	0x00, 0x00, 0x00, 0x00,
	128	0x00, 0x00, 0x00, 0x00,
	129	0x00, 0x00, 0x00, 0x00 };
d4f979a9 AV	130	__be32 freq;
	131	__be32 sym_rate;
	132	__be32 band;
	133	__be32 lnb_voltage;
1da177e4 LT	134
	135	freq = htonl(p->frequency +
	136	(state->hi_band ? LOF_HI : LOF_LO));
	137	memcpy(&b[4], &freq, sizeof(u32));
	138	sym_rate = htonl(p->u.qam.symbol_rate);
	139	memcpy(&b[12], &sym_rate, sizeof(u32));
	140	band = htonl(state->hi_band ? LOF_HI : LOF_LO);
	141	memcpy(&b[24], &band, sizeof(u32));
	142	lnb_voltage = htonl(state->voltage);
	143	memcpy(&b[28], &lnb_voltage, sizeof(u32));
	144
	145	state->config->send_command(fe, 0x71, sizeof(b), b, NULL, NULL);
	146
	147	return 0;
	148	}
	149
	150	static int ttusbdecfe_dvbs_diseqc_send_master_cmd(struct dvb_frontend* fe, struct dvb_diseqc_master_cmd *cmd)
	151	{
	152	struct ttusbdecfe_state* state = (struct ttusbdecfe_state*) fe->demodulator_priv;
	153	u8 b[] = { 0x00, 0xff, 0x00, 0x00,
	154	0x00, 0x00, 0x00, 0x00,
	155	0x00, 0x00 };
	156
	157	memcpy(&b[4], cmd->msg, cmd->msg_len);
	158
	159	state->config->send_command(fe, 0x72,
	160	sizeof(b) - (6 - cmd->msg_len), b,
	161	NULL, NULL);
	162
	163	return 0;
	164	}
	165
	166
	167	static int ttusbdecfe_dvbs_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
	168	{
	169	struct ttusbdecfe_state* state = (struct ttusbdecfe_state*) fe->demodulator_priv;
	170
	171	state->hi_band = (SEC_TONE_ON == tone);
	172
	173	return 0;
	174	}
	175
	176
	177	static int ttusbdecfe_dvbs_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
	178	{
	179	struct ttusbdecfe_state* state = (struct ttusbdecfe_state*) fe->demodulator_priv;
	180
	181	switch (voltage) {
	182	case SEC_VOLTAGE_13:
	183	state->voltage = 13;
	184	break;
	185	case SEC_VOLTAGE_18:
	186	state->voltage = 18;
	187	break;
	188	default:
	189	return -EINVAL;
	190	}
	191
	192	return 0;
	193	}
	194
	195	static void ttusbdecfe_release(struct dvb_frontend* fe)
	196	{
	197	struct ttusbdecfe_state* state = (struct ttusbdecfe_state*) fe->demodulator_priv;
198	kfree(state);
199	}
200
201	static struct dvb_frontend_ops ttusbdecfe_dvbt_ops;
202
203	struct dvb_frontend* ttusbdecfe_dvbt_attach(const struct ttusbdecfe_config* config)
204	{
205	struct ttusbdecfe_state* state = NULL;
206
207	/* allocate memory for the internal state */
5cbded58	208	state = kmalloc(sizeof(struct ttusbdecfe_state), GFP_KERNEL);
771e7157 AB	209	if (state == NULL)
771e7157 AB	210	return NULL;
1da177e4 LT	211
	212	/* setup the state */
	213	state->config = config;
1da177e4 LT	214
1da177e4 LT	215	/* create dvb_frontend */
dea74869	216	memcpy(&state->frontend.ops, &ttusbdecfe_dvbt_ops, sizeof(struct dvb_frontend_ops));
1da177e4 LT	217	state->frontend.demodulator_priv = state;
1da177e4 LT	218	return &state->frontend;
1da177e4 LT	219	}
	220
	221	static struct dvb_frontend_ops ttusbdecfe_dvbs_ops;
	222
	223	struct dvb_frontend* ttusbdecfe_dvbs_attach(const struct ttusbdecfe_config* config)
	224	{
	225	struct ttusbdecfe_state* state = NULL;
	226
	227	/* allocate memory for the internal state */
5cbded58	228	state = kmalloc(sizeof(struct ttusbdecfe_state), GFP_KERNEL);
771e7157 AB	229	if (state == NULL)
771e7157 AB	230	return NULL;
1da177e4 LT	231
	232	/* setup the state */
	233	state->config = config;
	234	state->voltage = 0;
	235	state->hi_band = 0;
1da177e4 LT	236
1da177e4 LT	237	/* create dvb_frontend */
dea74869	238	memcpy(&state->frontend.ops, &ttusbdecfe_dvbs_ops, sizeof(struct dvb_frontend_ops));
1da177e4 LT	239	state->frontend.demodulator_priv = state;
1da177e4 LT	240	return &state->frontend;
1da177e4 LT	241	}
	242
	243	static struct dvb_frontend_ops ttusbdecfe_dvbt_ops = {
	244
	245	.info = {
	246	.name = "TechnoTrend/Hauppauge DEC2000-t Frontend",
	247	.type = FE_OFDM,
	248	.frequency_min = 51000000,
	249	.frequency_max = 858000000,
	250	.frequency_stepsize = 62500,
	251	.caps = FE_CAN_FEC_1_2 \| FE_CAN_FEC_2_3 \| FE_CAN_FEC_3_4 \|
	252	FE_CAN_FEC_5_6 \| FE_CAN_FEC_7_8 \| FE_CAN_FEC_AUTO \|
	253	FE_CAN_QAM_16 \| FE_CAN_QAM_64 \| FE_CAN_QAM_AUTO \|
	254	FE_CAN_TRANSMISSION_MODE_AUTO \| FE_CAN_GUARD_INTERVAL_AUTO \|
	255	FE_CAN_HIERARCHY_AUTO,
	256	},
	257
	258	.release = ttusbdecfe_release,
	259
	260	.set_frontend = ttusbdecfe_dvbt_set_frontend,
	261
f961e71a AW	262	.get_tune_settings = ttusbdecfe_dvbt_get_tune_settings,
f961e71a AW	263
4d2858c6	264	.read_status = ttusbdecfe_dvbt_read_status,
1da177e4 LT	265	};
	266
	267	static struct dvb_frontend_ops ttusbdecfe_dvbs_ops = {
	268
	269	.info = {
	270	.name = "TechnoTrend/Hauppauge DEC3000-s Frontend",
	271	.type = FE_QPSK,
	272	.frequency_min = 950000,
	273	.frequency_max = 2150000,
	274	.frequency_stepsize = 125,
f961e71a AW	275	.symbol_rate_min = 1000000, /* guessed */
f961e71a AW	276	.symbol_rate_max = 45000000, /* guessed */
1da177e4 LT	277	.caps = FE_CAN_FEC_1_2 \| FE_CAN_FEC_2_3 \| FE_CAN_FEC_3_4 \|
1da177e4 LT	278	FE_CAN_FEC_5_6 \| FE_CAN_FEC_7_8 \| FE_CAN_FEC_AUTO \|
f961e71a	279	FE_CAN_QPSK
1da177e4 LT	280	},
	281
	282	.release = ttusbdecfe_release,
	283
	284	.set_frontend = ttusbdecfe_dvbs_set_frontend,
	285
4d2858c6	286	.read_status = ttusbdecfe_dvbs_read_status,
1da177e4 LT	287
	288	.diseqc_send_master_cmd = ttusbdecfe_dvbs_diseqc_send_master_cmd,
	289	.set_voltage = ttusbdecfe_dvbs_set_voltage,
	290	.set_tone = ttusbdecfe_dvbs_set_tone,
	291	};
	292
	293	MODULE_DESCRIPTION("TTUSB DEC DVB-T/S Demodulator driver");
	294	MODULE_AUTHOR("Alex Woods/Andrew de Quincey");
	295	MODULE_LICENSE("GPL");
	296
	297	EXPORT_SYMBOL(ttusbdecfe_dvbt_attach);
	298	EXPORT_SYMBOL(ttusbdecfe_dvbs_attach);