drivers/media/dvb/dvb-usb/cinergyT2-fe.c - kernel/prism - Git at Google

 /*
  * TerraTec Cinergy T2/qanu USB2 DVB-T adapter.
  *
  * Copyright (C) 2007 Tomi Orava (tomimo@ncircle.nullnet.fi)
  *
  * Based on the dvb-usb-framework code and the
  * original Terratec Cinergy T2 driver by:
  *
  * Copyright (C) 2004 Daniel Mack <daniel@qanu.de> and
  *                  Holger Waechtler <holger@qanu.de>
  *
  *  Protocol Spec published on http://qanu.de/specs/terratec_cinergyT2.pdf
  *
  * 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 "cinergyT2.h"


 /**
  *  convert linux-dvb frontend parameter set into TPS.
  *  See ETSI ETS-300744, section 4.6.2, table 9 for details.
  *
  *  This function is probably reusable and may better get placed in a support
  *  library.
  *
  *  We replace errornous fields by default TPS fields (the ones with value 0).
  */

 static uint16_t compute_tps(struct dvb_frontend_parameters *p)
 {
 	struct dvb_ofdm_parameters *op = &p->u.ofdm;
 	uint16_t tps = 0;

 	switch (op->code_rate_HP) {
 	case FEC_2_3:
 		tps |= (1 << 7);
 		break;
 	case FEC_3_4:
 		tps |= (2 << 7);
 		break;
 	case FEC_5_6:
 		tps |= (3 << 7);
 		break;
 	case FEC_7_8:
 		tps |= (4 << 7);
 		break;
 	case FEC_1_2:
 	case FEC_AUTO:
 	default:
 		/* tps |= (0 << 7) */;
 	}

 	switch (op->code_rate_LP) {
 	case FEC_2_3:
 		tps |= (1 << 4);
 		break;
 	case FEC_3_4:
 		tps |= (2 << 4);
 		break;
 	case FEC_5_6:
 		tps |= (3 << 4);
 		break;
 	case FEC_7_8:
 		tps |= (4 << 4);
 		break;
 	case FEC_1_2:
 	case FEC_AUTO:
 	default:
 		/* tps |= (0 << 4) */;
 	}

 	switch (op->constellation) {
 	case QAM_16:
 		tps |= (1 << 13);
 		break;
 	case QAM_64:
 		tps |= (2 << 13);
 		break;
 	case QPSK:
 	default:
 		/* tps |= (0 << 13) */;
 	}

 	switch (op->transmission_mode) {
 	case TRANSMISSION_MODE_8K:
 		tps |= (1 << 0);
 		break;
 	case TRANSMISSION_MODE_2K:
 	default:
 		/* tps |= (0 << 0) */;
 	}

 	switch (op->guard_interval) {
 	case GUARD_INTERVAL_1_16:
 		tps |= (1 << 2);
 		break;
 	case GUARD_INTERVAL_1_8:
 		tps |= (2 << 2);
 		break;
 	case GUARD_INTERVAL_1_4:
 		tps |= (3 << 2);
 		break;
 	case GUARD_INTERVAL_1_32:
 	default:
 		/* tps |= (0 << 2) */;
 	}

 	switch (op->hierarchy_information) {
 	case HIERARCHY_1:
 		tps |= (1 << 10);
 		break;
 	case HIERARCHY_2:
 		tps |= (2 << 10);
 		break;
 	case HIERARCHY_4:
 		tps |= (3 << 10);
 		break;
 	case HIERARCHY_NONE:
 	default:
 		/* tps |= (0 << 10) */;
 	}

 	return tps;
 }

 struct cinergyt2_fe_state {
 	struct dvb_frontend fe;
 	struct dvb_usb_device *d;
 };

 static int cinergyt2_fe_read_status(struct dvb_frontend *fe,
 					fe_status_t *status)
 {
 	struct cinergyt2_fe_state *state = fe->demodulator_priv;
 	struct dvbt_get_status_msg result;
 	u8 cmd[] = { CINERGYT2_EP1_GET_TUNER_STATUS };
 	int ret;

 	ret = dvb_usb_generic_rw(state->d, cmd, sizeof(cmd), (u8 *)&result,
 			sizeof(result), 0);
 	if (ret < 0)
 		return ret;

 	*status = 0;

 	if (0xffff - le16_to_cpu(result.gain) > 30)
 		*status |= FE_HAS_SIGNAL;
 	if (result.lock_bits & (1 << 6))
 		*status |= FE_HAS_LOCK;
 	if (result.lock_bits & (1 << 5))
 		*status |= FE_HAS_SYNC;
 	if (result.lock_bits & (1 << 4))
 		*status |= FE_HAS_CARRIER;
 	if (result.lock_bits & (1 << 1))
 		*status |= FE_HAS_VITERBI;

 	if ((*status & (FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC)) !=
 			(FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC))
 		*status &= ~FE_HAS_LOCK;

 	return 0;
 }

 static int cinergyt2_fe_read_ber(struct dvb_frontend *fe, u32 *ber)
 {
 	struct cinergyt2_fe_state *state = fe->demodulator_priv;
 	struct dvbt_get_status_msg status;
 	char cmd[] = { CINERGYT2_EP1_GET_TUNER_STATUS };
 	int ret;

 	ret = dvb_usb_generic_rw(state->d, cmd, sizeof(cmd), (char *)&status,
 				sizeof(status), 0);
 	if (ret < 0)
 		return ret;

 	*ber = le32_to_cpu(status.viterbi_error_rate);
 	return 0;
 }

 static int cinergyt2_fe_read_unc_blocks(struct dvb_frontend *fe, u32 *unc)
 {
 	struct cinergyt2_fe_state *state = fe->demodulator_priv;
 	struct dvbt_get_status_msg status;
 	u8 cmd[] = { CINERGYT2_EP1_GET_TUNER_STATUS };
 	int ret;

 	ret = dvb_usb_generic_rw(state->d, cmd, sizeof(cmd), (u8 *)&status,
 				sizeof(status), 0);
 	if (ret < 0) {
 		err("cinergyt2_fe_read_unc_blocks() Failed! (Error=%d)\n",
 			ret);
 		return ret;
 	}
 	*unc = le32_to_cpu(status.uncorrected_block_count);
 	return 0;
 }

 static int cinergyt2_fe_read_signal_strength(struct dvb_frontend *fe,
 						u16 *strength)
 {
 	struct cinergyt2_fe_state *state = fe->demodulator_priv;
 	struct dvbt_get_status_msg status;
 	char cmd[] = { CINERGYT2_EP1_GET_TUNER_STATUS };
 	int ret;

 	ret = dvb_usb_generic_rw(state->d, cmd, sizeof(cmd), (char *)&status,
 				sizeof(status), 0);
 	if (ret < 0) {
 		err("cinergyt2_fe_read_signal_strength() Failed!"
 			" (Error=%d)\n", ret);
 		return ret;
 	}
 	*strength = (0xffff - le16_to_cpu(status.gain));
 	return 0;
 }

 static int cinergyt2_fe_read_snr(struct dvb_frontend *fe, u16 *snr)
 {
 	struct cinergyt2_fe_state *state = fe->demodulator_priv;
 	struct dvbt_get_status_msg status;
 	char cmd[] = { CINERGYT2_EP1_GET_TUNER_STATUS };
 	int ret;

 	ret = dvb_usb_generic_rw(state->d, cmd, sizeof(cmd), (char *)&status,
 				sizeof(status), 0);
 	if (ret < 0) {
 		err("cinergyt2_fe_read_snr() Failed! (Error=%d)\n", ret);
 		return ret;
 	}
 	*snr = (status.snr << 8) | status.snr;
 	return 0;
 }

 static int cinergyt2_fe_init(struct dvb_frontend *fe)
 {
 	return 0;
 }

 static int cinergyt2_fe_sleep(struct dvb_frontend *fe)
 {
 	deb_info("cinergyt2_fe_sleep() Called\n");
 	return 0;
 }

 static int cinergyt2_fe_get_tune_settings(struct dvb_frontend *fe,
 				struct dvb_frontend_tune_settings *tune)
 {
 	tune->min_delay_ms = 800;
 	return 0;
 }

 static int cinergyt2_fe_set_frontend(struct dvb_frontend *fe,
 				  struct dvb_frontend_parameters *fep)
 {
 	struct cinergyt2_fe_state *state = fe->demodulator_priv;
 	struct dvbt_set_parameters_msg param;
 	char result[2];
 	int err;

 	param.cmd = CINERGYT2_EP1_SET_TUNER_PARAMETERS;
 	param.tps = cpu_to_le16(compute_tps(fep));
 	param.freq = cpu_to_le32(fep->frequency / 1000);
 	param.bandwidth = 8 - fep->u.ofdm.bandwidth - BANDWIDTH_8_MHZ;
 	param.flags = 0;

 	err = dvb_usb_generic_rw(state->d,
 			(char *)&param, sizeof(param),
 			result, sizeof(result), 0);
 	if (err < 0)
 		err("cinergyt2_fe_set_frontend() Failed! err=%d\n", err);

 	return (err < 0) ? err : 0;
 }

 static int cinergyt2_fe_get_frontend(struct dvb_frontend *fe,
 				  struct dvb_frontend_parameters *fep)
 {
 	return 0;
 }

 static void cinergyt2_fe_release(struct dvb_frontend *fe)
 {
 	struct cinergyt2_fe_state *state = fe->demodulator_priv;
 	if (state != NULL)
 		kfree(state);
 }

 static struct dvb_frontend_ops cinergyt2_fe_ops;

 struct dvb_frontend *cinergyt2_fe_attach(struct dvb_usb_device *d)
 {
 	struct cinergyt2_fe_state *s = kzalloc(sizeof(
 					struct cinergyt2_fe_state), GFP_KERNEL);
 	if (s == NULL)
 		return NULL;

 	s->d = d;
 	memcpy(&s->fe.ops, &cinergyt2_fe_ops, sizeof(struct dvb_frontend_ops));
 	s->fe.demodulator_priv = s;
 	return &s->fe;
 }


 static struct dvb_frontend_ops cinergyt2_fe_ops = {
 	.info = {
 		.name			= DRIVER_NAME,
 		.type			= FE_OFDM,
 		.frequency_min		= 174000000,
 		.frequency_max		= 862000000,
 		.frequency_stepsize	= 166667,
 		.caps = FE_CAN_INVERSION_AUTO | 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
 			| 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
 			| FE_CAN_RECOVER
 			| FE_CAN_MUTE_TS
 	},

 	.release		= cinergyt2_fe_release,

 	.init			= cinergyt2_fe_init,
 	.sleep			= cinergyt2_fe_sleep,

 	.set_frontend		= cinergyt2_fe_set_frontend,
 	.get_frontend		= cinergyt2_fe_get_frontend,
 	.get_tune_settings	= cinergyt2_fe_get_tune_settings,

 	.read_status		= cinergyt2_fe_read_status,
 	.read_ber		= cinergyt2_fe_read_ber,
 	.read_signal_strength	= cinergyt2_fe_read_signal_strength,
 	.read_snr		= cinergyt2_fe_read_snr,
 	.read_ucblocks		= cinergyt2_fe_read_unc_blocks,
 };
	/*
	* TerraTec Cinergy T2/qanu USB2 DVB-T adapter.
	*
	* Copyright (C) 2007 Tomi Orava (tomimo@ncircle.nullnet.fi)
	*
	* Based on the dvb-usb-framework code and the
	* original Terratec Cinergy T2 driver by:
	*
	* Copyright (C) 2004 Daniel Mack <daniel@qanu.de> and
	* Holger Waechtler <holger@qanu.de>
	*
	* Protocol Spec published on http://qanu.de/specs/terratec_cinergyT2.pdf
	*
	* 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 "cinergyT2.h"


	/**
	* convert linux-dvb frontend parameter set into TPS.
	* See ETSI ETS-300744, section 4.6.2, table 9 for details.
	*
	* This function is probably reusable and may better get placed in a support
	* library.
	*
	* We replace errornous fields by default TPS fields (the ones with value 0).
	*/

	static uint16_t compute_tps(struct dvb_frontend_parameters *p)
	{
	struct dvb_ofdm_parameters *op = &p->u.ofdm;
	uint16_t tps = 0;

	switch (op->code_rate_HP) {
	case FEC_2_3:
	tps \|= (1 << 7);
	break;
	case FEC_3_4:
	tps \|= (2 << 7);
	break;
	case FEC_5_6:
	tps \|= (3 << 7);
	break;
	case FEC_7_8:
	tps \|= (4 << 7);
	break;
	case FEC_1_2:
	case FEC_AUTO:
	default:
	/* tps \|= (0 << 7) */;
	}

	switch (op->code_rate_LP) {
	case FEC_2_3:
	tps \|= (1 << 4);
	break;
	case FEC_3_4:
	tps \|= (2 << 4);
	break;
	case FEC_5_6:
	tps \|= (3 << 4);
	break;
	case FEC_7_8:
	tps \|= (4 << 4);
	break;
	case FEC_1_2:
	case FEC_AUTO:
	default:
	/* tps \|= (0 << 4) */;
	}

	switch (op->constellation) {
	case QAM_16:
	tps \|= (1 << 13);
	break;
	case QAM_64:
	tps \|= (2 << 13);
	break;
	case QPSK:
	default:
	/* tps \|= (0 << 13) */;
	}

	switch (op->transmission_mode) {
	case TRANSMISSION_MODE_8K:
	tps \|= (1 << 0);
	break;
	case TRANSMISSION_MODE_2K:
	default:
	/* tps \|= (0 << 0) */;
	}

	switch (op->guard_interval) {
	case GUARD_INTERVAL_1_16:
	tps \|= (1 << 2);
	break;
	case GUARD_INTERVAL_1_8:
	tps \|= (2 << 2);
	break;
	case GUARD_INTERVAL_1_4:
	tps \|= (3 << 2);
	break;
	case GUARD_INTERVAL_1_32:
	default:
	/* tps \|= (0 << 2) */;
	}

	switch (op->hierarchy_information) {
	case HIERARCHY_1:
	tps \|= (1 << 10);
	break;
	case HIERARCHY_2:
	tps \|= (2 << 10);
	break;
	case HIERARCHY_4:
	tps \|= (3 << 10);
	break;
	case HIERARCHY_NONE:
	default:
	/* tps \|= (0 << 10) */;
	}

	return tps;
	}

	struct cinergyt2_fe_state {
	struct dvb_frontend fe;
	struct dvb_usb_device *d;
	};

	static int cinergyt2_fe_read_status(struct dvb_frontend *fe,
	fe_status_t *status)
	{
	struct cinergyt2_fe_state *state = fe->demodulator_priv;
	struct dvbt_get_status_msg result;
	u8 cmd[] = { CINERGYT2_EP1_GET_TUNER_STATUS };
	int ret;

	ret = dvb_usb_generic_rw(state->d, cmd, sizeof(cmd), (u8 *)&result,
	sizeof(result), 0);
	if (ret < 0)
	return ret;

	*status = 0;

	if (0xffff - le16_to_cpu(result.gain) > 30)
	*status \|= FE_HAS_SIGNAL;
	if (result.lock_bits & (1 << 6))
	*status \|= FE_HAS_LOCK;
	if (result.lock_bits & (1 << 5))
	*status \|= FE_HAS_SYNC;
	if (result.lock_bits & (1 << 4))
	*status \|= FE_HAS_CARRIER;
	if (result.lock_bits & (1 << 1))
	*status \|= FE_HAS_VITERBI;

	if ((*status & (FE_HAS_CARRIER \| FE_HAS_VITERBI \| FE_HAS_SYNC)) !=
	(FE_HAS_CARRIER \| FE_HAS_VITERBI \| FE_HAS_SYNC))
	*status &= ~FE_HAS_LOCK;

	return 0;
	}

	static int cinergyt2_fe_read_ber(struct dvb_frontend fe, u32 ber)
	{
	struct cinergyt2_fe_state *state = fe->demodulator_priv;
	struct dvbt_get_status_msg status;
	char cmd[] = { CINERGYT2_EP1_GET_TUNER_STATUS };
	int ret;

	ret = dvb_usb_generic_rw(state->d, cmd, sizeof(cmd), (char *)&status,
	sizeof(status), 0);
	if (ret < 0)
	return ret;

	*ber = le32_to_cpu(status.viterbi_error_rate);
	return 0;
	}

	static int cinergyt2_fe_read_unc_blocks(struct dvb_frontend fe, u32 unc)
	{
	struct cinergyt2_fe_state *state = fe->demodulator_priv;
	struct dvbt_get_status_msg status;
	u8 cmd[] = { CINERGYT2_EP1_GET_TUNER_STATUS };
	int ret;

	ret = dvb_usb_generic_rw(state->d, cmd, sizeof(cmd), (u8 *)&status,
	sizeof(status), 0);
	if (ret < 0) {
	err("cinergyt2_fe_read_unc_blocks() Failed! (Error=%d)\n",
	ret);
	return ret;
	}
	*unc = le32_to_cpu(status.uncorrected_block_count);
	return 0;
	}

	static int cinergyt2_fe_read_signal_strength(struct dvb_frontend *fe,
	u16 *strength)
	{
	struct cinergyt2_fe_state *state = fe->demodulator_priv;
	struct dvbt_get_status_msg status;
	char cmd[] = { CINERGYT2_EP1_GET_TUNER_STATUS };
	int ret;

	ret = dvb_usb_generic_rw(state->d, cmd, sizeof(cmd), (char *)&status,
	sizeof(status), 0);
	if (ret < 0) {
	err("cinergyt2_fe_read_signal_strength() Failed!"
	" (Error=%d)\n", ret);
	return ret;
	}
	*strength = (0xffff - le16_to_cpu(status.gain));
	return 0;
	}

	static int cinergyt2_fe_read_snr(struct dvb_frontend fe, u16 snr)
	{
	struct cinergyt2_fe_state *state = fe->demodulator_priv;
	struct dvbt_get_status_msg status;
	char cmd[] = { CINERGYT2_EP1_GET_TUNER_STATUS };
	int ret;

	ret = dvb_usb_generic_rw(state->d, cmd, sizeof(cmd), (char *)&status,
	sizeof(status), 0);
	if (ret < 0) {
	err("cinergyt2_fe_read_snr() Failed! (Error=%d)\n", ret);
	return ret;
	}
	*snr = (status.snr << 8) \| status.snr;
	return 0;
	}

	static int cinergyt2_fe_init(struct dvb_frontend *fe)
	{
	return 0;
	}

	static int cinergyt2_fe_sleep(struct dvb_frontend *fe)
	{
	deb_info("cinergyt2_fe_sleep() Called\n");
	return 0;
	}

	static int cinergyt2_fe_get_tune_settings(struct dvb_frontend *fe,
	struct dvb_frontend_tune_settings *tune)
	{
	tune->min_delay_ms = 800;
	return 0;
	}

	static int cinergyt2_fe_set_frontend(struct dvb_frontend *fe,
	struct dvb_frontend_parameters *fep)
	{
	struct cinergyt2_fe_state *state = fe->demodulator_priv;
	struct dvbt_set_parameters_msg param;
	char result[2];
	int err;

	param.cmd = CINERGYT2_EP1_SET_TUNER_PARAMETERS;
	param.tps = cpu_to_le16(compute_tps(fep));
	param.freq = cpu_to_le32(fep->frequency / 1000);
	param.bandwidth = 8 - fep->u.ofdm.bandwidth - BANDWIDTH_8_MHZ;
	param.flags = 0;

	err = dvb_usb_generic_rw(state->d,
	(char *)&param, sizeof(param),
	result, sizeof(result), 0);
	if (err < 0)
	err("cinergyt2_fe_set_frontend() Failed! err=%d\n", err);

	return (err < 0) ? err : 0;
	}

	static int cinergyt2_fe_get_frontend(struct dvb_frontend *fe,
	struct dvb_frontend_parameters *fep)
	{
	return 0;
	}

	static void cinergyt2_fe_release(struct dvb_frontend *fe)
	{
	struct cinergyt2_fe_state *state = fe->demodulator_priv;
	if (state != NULL)
	kfree(state);
	}

	static struct dvb_frontend_ops cinergyt2_fe_ops;

	struct dvb_frontend cinergyt2_fe_attach(struct dvb_usb_device d)
	{
	struct cinergyt2_fe_state *s = kzalloc(sizeof(
	struct cinergyt2_fe_state), GFP_KERNEL);
	if (s == NULL)
	return NULL;

	s->d = d;
	memcpy(&s->fe.ops, &cinergyt2_fe_ops, sizeof(struct dvb_frontend_ops));
	s->fe.demodulator_priv = s;
	return &s->fe;
	}


	static struct dvb_frontend_ops cinergyt2_fe_ops = {
	.info = {
	.name = DRIVER_NAME,
	.type = FE_OFDM,
	.frequency_min = 174000000,
	.frequency_max = 862000000,
	.frequency_stepsize = 166667,
	.caps = FE_CAN_INVERSION_AUTO \| 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
	\| 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
	\| FE_CAN_RECOVER
	\| FE_CAN_MUTE_TS
	},

	.release = cinergyt2_fe_release,

	.init = cinergyt2_fe_init,
	.sleep = cinergyt2_fe_sleep,

	.set_frontend = cinergyt2_fe_set_frontend,
	.get_frontend = cinergyt2_fe_get_frontend,
	.get_tune_settings = cinergyt2_fe_get_tune_settings,

	.read_status = cinergyt2_fe_read_status,
	.read_ber = cinergyt2_fe_read_ber,
	.read_signal_strength = cinergyt2_fe_read_signal_strength,
	.read_snr = cinergyt2_fe_read_snr,
	.read_ucblocks = cinergyt2_fe_read_unc_blocks,
	};