Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 14c03862 authored by Manu Abraham's avatar Manu Abraham Committed by Mauro Carvalho Chehab
Browse files

[media] CXD2820r: Query DVB frontend delivery capabilities 



Override default delivery system information provided by FE_GET_INFO,
so that applications can enumerate delivery systems provided by the
frontend.

Signed-off-by: default avatarManu Abraham <abraham.manu@gmail.com>
Acked-by: default avatarAntti Palosaari <crope@iki.fi>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent 1ca8dde8

drivers/media/dvb/frontends/cxd2820r_core.c

+217 −434
Original line number Diff line number Diff line
@@ -240,43 +240,6 @@ error: 
	return ret;

}



/* lock FE */

static int cxd2820r_lock(struct cxd2820r_priv *priv, int active_fe)

{

	int ret = 0;

	dbg("%s: active_fe=%d", __func__, active_fe);



	mutex_lock(&priv->fe_lock);



	/* -1=NONE, 0=DVB-T/T2, 1=DVB-C */

	if (priv->active_fe == active_fe)

		;

	else if (priv->active_fe == -1)

		priv->active_fe = active_fe;

	else

		ret = -EBUSY;



	mutex_unlock(&priv->fe_lock);



	return ret;

}



/* unlock FE */

static void cxd2820r_unlock(struct cxd2820r_priv *priv, int active_fe)

{

	dbg("%s: active_fe=%d", __func__, active_fe);



	mutex_lock(&priv->fe_lock);



	/* -1=NONE, 0=DVB-T/T2, 1=DVB-C */

	if (priv->active_fe == active_fe)

		priv->active_fe = -1;



	mutex_unlock(&priv->fe_lock);



	return;

}



/* 64 bit div with round closest, like DIV_ROUND_CLOSEST but 64 bit */

u32 cxd2820r_div_u64_round_closest(u64 dividend, u32 divisor)

{
@@ -286,80 +249,48 @@ u32 cxd2820r_div_u64_round_closest(u64 dividend, u32 divisor) 
static int cxd2820r_set_frontend(struct dvb_frontend *fe,

				 struct dvb_frontend_parameters *p)

{

	struct cxd2820r_priv *priv = fe->demodulator_priv;

	struct dtv_frontend_properties *c = &fe->dtv_property_cache;

	int ret;

	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);



	if (fe->ops.info.type == FE_OFDM) {

		/* DVB-T/T2 */

		ret = cxd2820r_lock(priv, 0);

		if (ret)

			return ret;



		switch (priv->delivery_system) {

		case SYS_UNDEFINED:

			if (c->delivery_system == SYS_DVBT) {

				/* SLEEP => DVB-T */

				ret = cxd2820r_set_frontend_t(fe, p);

			} else {

				/* SLEEP => DVB-T2 */

				ret = cxd2820r_set_frontend_t2(fe, p);

			}

			break;

	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);

	switch (c->delivery_system) {

	case SYS_DVBT:

			if (c->delivery_system == SYS_DVBT) {

				/* DVB-T => DVB-T */

		ret = cxd2820r_init_t(fe);

		if (ret < 0)

			goto err;

		ret = cxd2820r_set_frontend_t(fe, p);

			} else if (c->delivery_system == SYS_DVBT2) {

				/* DVB-T => DVB-T2 */

				ret = cxd2820r_sleep_t(fe);

				if (ret)

					break;

				ret = cxd2820r_set_frontend_t2(fe, p);

			}

		if (ret < 0)

			goto err;

		break;

	case SYS_DVBT2:

			if (c->delivery_system == SYS_DVBT2) {

				/* DVB-T2 => DVB-T2 */

		ret = cxd2820r_init_t(fe);

		if (ret < 0)

			goto err;

		ret = cxd2820r_set_frontend_t2(fe, p);

			} else if (c->delivery_system == SYS_DVBT) {

				/* DVB-T2 => DVB-T */

				ret = cxd2820r_sleep_t2(fe);

				if (ret)

		if (ret < 0)

			goto err;

		break;

				ret = cxd2820r_set_frontend_t(fe, p);

			}

	case SYS_DVBC_ANNEX_AC:

		ret = cxd2820r_init_c(fe);

		if (ret < 0)

			goto err;

		ret = cxd2820r_set_frontend_c(fe, p);

		if (ret < 0)

			goto err;

		break;

	default:

			dbg("%s: error state=%d", __func__,

				priv->delivery_system);

		dbg("%s: error state=%d", __func__, fe->dtv_property_cache.delivery_system);

		ret = -EINVAL;

		break;

	}

	} else {

		/* DVB-C */

		ret = cxd2820r_lock(priv, 1);

		if (ret)

			return ret;



		ret = cxd2820r_set_frontend_c(fe, p);

	}



err:

	return ret;

}



static int cxd2820r_read_status(struct dvb_frontend *fe, fe_status_t *status)

{

	struct cxd2820r_priv *priv = fe->demodulator_priv;

	int ret;

	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);



	if (fe->ops.info.type == FE_OFDM) {

		/* DVB-T/T2 */

		ret = cxd2820r_lock(priv, 0);

		if (ret)

			return ret;



	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);

	switch (fe->dtv_property_cache.delivery_system) {

	case SYS_DVBT:

		ret = cxd2820r_read_status_t(fe, status);
@@ -367,34 +298,22 @@ static int cxd2820r_read_status(struct dvb_frontend *fe, fe_status_t *status) 
	case SYS_DVBT2:

		ret = cxd2820r_read_status_t2(fe, status);

		break;

	case SYS_DVBC_ANNEX_AC:

		ret = cxd2820r_read_status_c(fe, status);

		break;

	default:

		ret = -EINVAL;

		break;

	}

	} else {

		/* DVB-C */

		ret = cxd2820r_lock(priv, 1);

		if (ret)

			return ret;



		ret = cxd2820r_read_status_c(fe, status);

	}



	return ret;

}



static int cxd2820r_get_frontend(struct dvb_frontend *fe,

				 struct dvb_frontend_parameters *p)

{

	struct cxd2820r_priv *priv = fe->demodulator_priv;

	int ret;

	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);



	if (fe->ops.info.type == FE_OFDM) {

		/* DVB-T/T2 */

		ret = cxd2820r_lock(priv, 0);

		if (ret)

			return ret;



	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);

	switch (fe->dtv_property_cache.delivery_system) {

	case SYS_DVBT:

		ret = cxd2820r_get_frontend_t(fe, p);
@@ -402,33 +321,21 @@ static int cxd2820r_get_frontend(struct dvb_frontend *fe, 
	case SYS_DVBT2:

		ret = cxd2820r_get_frontend_t2(fe, p);

		break;

	case SYS_DVBC_ANNEX_AC:

		ret = cxd2820r_get_frontend_c(fe, p);

		break;

	default:

		ret = -EINVAL;

		break;

	}

	} else {

		/* DVB-C */

		ret = cxd2820r_lock(priv, 1);

		if (ret)

			return ret;



		ret = cxd2820r_get_frontend_c(fe, p);

	}



	return ret;

}



static int cxd2820r_read_ber(struct dvb_frontend *fe, u32 *ber)

{

	struct cxd2820r_priv *priv = fe->demodulator_priv;

	int ret;

	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);



	if (fe->ops.info.type == FE_OFDM) {

		/* DVB-T/T2 */

		ret = cxd2820r_lock(priv, 0);

		if (ret)

			return ret;



	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);

	switch (fe->dtv_property_cache.delivery_system) {

	case SYS_DVBT:

		ret = cxd2820r_read_ber_t(fe, ber);
@@ -436,33 +343,21 @@ static int cxd2820r_read_ber(struct dvb_frontend *fe, u32 *ber) 
	case SYS_DVBT2:

		ret = cxd2820r_read_ber_t2(fe, ber);

		break;

	case SYS_DVBC_ANNEX_AC:

		ret = cxd2820r_read_ber_c(fe, ber);

		break;

	default:

		ret = -EINVAL;

		break;

	}

	} else {

		/* DVB-C */

		ret = cxd2820r_lock(priv, 1);

		if (ret)

			return ret;



		ret = cxd2820r_read_ber_c(fe, ber);

	}



	return ret;

}



static int cxd2820r_read_signal_strength(struct dvb_frontend *fe, u16 *strength)

{

	struct cxd2820r_priv *priv = fe->demodulator_priv;

	int ret;

	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);



	if (fe->ops.info.type == FE_OFDM) {

		/* DVB-T/T2 */

		ret = cxd2820r_lock(priv, 0);

		if (ret)

			return ret;



	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);

	switch (fe->dtv_property_cache.delivery_system) {

	case SYS_DVBT:

		ret = cxd2820r_read_signal_strength_t(fe, strength);
@@ -470,33 +365,21 @@ static int cxd2820r_read_signal_strength(struct dvb_frontend *fe, u16 *strength) 
	case SYS_DVBT2:

		ret = cxd2820r_read_signal_strength_t2(fe, strength);

		break;

	case SYS_DVBC_ANNEX_AC:

		ret = cxd2820r_read_signal_strength_c(fe, strength);

		break;

	default:

		ret = -EINVAL;

		break;

	}

	} else {

		/* DVB-C */

		ret = cxd2820r_lock(priv, 1);

		if (ret)

			return ret;



		ret = cxd2820r_read_signal_strength_c(fe, strength);

	}



	return ret;

}



static int cxd2820r_read_snr(struct dvb_frontend *fe, u16 *snr)

{

	struct cxd2820r_priv *priv = fe->demodulator_priv;

	int ret;

	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);



	if (fe->ops.info.type == FE_OFDM) {

		/* DVB-T/T2 */

		ret = cxd2820r_lock(priv, 0);

		if (ret)

			return ret;



	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);

	switch (fe->dtv_property_cache.delivery_system) {

	case SYS_DVBT:

		ret = cxd2820r_read_snr_t(fe, snr);
@@ -504,33 +387,21 @@ static int cxd2820r_read_snr(struct dvb_frontend *fe, u16 *snr) 
	case SYS_DVBT2:

		ret = cxd2820r_read_snr_t2(fe, snr);

		break;

	case SYS_DVBC_ANNEX_AC:

		ret = cxd2820r_read_snr_c(fe, snr);

		break;

	default:

		ret = -EINVAL;

		break;

	}

	} else {

		/* DVB-C */

		ret = cxd2820r_lock(priv, 1);

		if (ret)

			return ret;



		ret = cxd2820r_read_snr_c(fe, snr);

	}



	return ret;

}



static int cxd2820r_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)

{

	struct cxd2820r_priv *priv = fe->demodulator_priv;

	int ret;

	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);



	if (fe->ops.info.type == FE_OFDM) {

		/* DVB-T/T2 */

		ret = cxd2820r_lock(priv, 0);

		if (ret)

			return ret;



	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);

	switch (fe->dtv_property_cache.delivery_system) {

	case SYS_DVBT:

		ret = cxd2820r_read_ucblocks_t(fe, ucblocks);
@@ -538,61 +409,26 @@ static int cxd2820r_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks) 
	case SYS_DVBT2:

		ret = cxd2820r_read_ucblocks_t2(fe, ucblocks);

		break;

	case SYS_DVBC_ANNEX_AC:

		ret = cxd2820r_read_ucblocks_c(fe, ucblocks);

		break;

	default:

		ret = -EINVAL;

		break;

	}

	} else {

		/* DVB-C */

		ret = cxd2820r_lock(priv, 1);

		if (ret)

			return ret;



		ret = cxd2820r_read_ucblocks_c(fe, ucblocks);

	}



	return ret;

}



static int cxd2820r_init(struct dvb_frontend *fe)

{

	struct cxd2820r_priv *priv = fe->demodulator_priv;

	int ret;

	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);



	priv->delivery_system = SYS_UNDEFINED;

	/* delivery system is unknown at that (init) phase */



	if (fe->ops.info.type == FE_OFDM) {

		/* DVB-T/T2 */

		ret = cxd2820r_lock(priv, 0);

		if (ret)

			return ret;



		ret = cxd2820r_init_t(fe);

	} else {

		/* DVB-C */

		ret = cxd2820r_lock(priv, 1);

		if (ret)

			return ret;



		ret = cxd2820r_init_c(fe);

	}



	return ret;

	return 0;

}



static int cxd2820r_sleep(struct dvb_frontend *fe)

{

	struct cxd2820r_priv *priv = fe->demodulator_priv;

	int ret;

	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);



	if (fe->ops.info.type == FE_OFDM) {

		/* DVB-T/T2 */

		ret = cxd2820r_lock(priv, 0);

		if (ret)

			return ret;



	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);

	switch (fe->dtv_property_cache.delivery_system) {

	case SYS_DVBT:

		ret = cxd2820r_sleep_t(fe);
@@ -600,38 +436,22 @@ static int cxd2820r_sleep(struct dvb_frontend *fe) 
	case SYS_DVBT2:

		ret = cxd2820r_sleep_t2(fe);

		break;

	case SYS_DVBC_ANNEX_AC:

		ret = cxd2820r_sleep_c(fe);

		break;

	default:

		ret = -EINVAL;

		break;

	}



		cxd2820r_unlock(priv, 0);

	} else {

		/* DVB-C */

		ret = cxd2820r_lock(priv, 1);

		if (ret)

			return ret;



		ret = cxd2820r_sleep_c(fe);



		cxd2820r_unlock(priv, 1);

	}



	return ret;

}



static int cxd2820r_get_tune_settings(struct dvb_frontend *fe,

				      struct dvb_frontend_tune_settings *s)

{

	struct cxd2820r_priv *priv = fe->demodulator_priv;

	int ret;

	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);



	if (fe->ops.info.type == FE_OFDM) {

		/* DVB-T/T2 */

		ret = cxd2820r_lock(priv, 0);

		if (ret)

			return ret;



	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);

	switch (fe->dtv_property_cache.delivery_system) {

	case SYS_DVBT:

		ret = cxd2820r_get_tune_settings_t(fe, s);
@@ -639,18 +459,13 @@ static int cxd2820r_get_tune_settings(struct dvb_frontend *fe, 
	case SYS_DVBT2:

		ret = cxd2820r_get_tune_settings_t2(fe, s);

		break;

	case SYS_DVBC_ANNEX_AC:

		ret = cxd2820r_get_tune_settings_c(fe, s);

		break;

	default:

		ret = -EINVAL;

		break;

	}

	} else {

		/* DVB-C */

		ret = cxd2820r_lock(priv, 1);

		if (ret)

			return ret;



		ret = cxd2820r_get_tune_settings_c(fe, s);

	}



	return ret;

}
@@ -664,7 +479,7 @@ static enum dvbfe_search cxd2820r_search(struct dvb_frontend *fe, 
	dbg("%s: delsys=%d", __func__, fe->dtv_property_cache.delivery_system);



	/* switch between DVB-T and DVB-T2 when tune fails */

	if (priv->last_tune_failed) {

	if (priv->last_tune_failed && (priv->delivery_system != SYS_DVBC_ANNEX_AC)) {

		if (priv->delivery_system == SYS_DVBT)

			c->delivery_system = SYS_DVBT2;

		else
@@ -727,9 +542,7 @@ static void cxd2820r_release(struct dvb_frontend *fe) 
	struct cxd2820r_priv *priv = fe->demodulator_priv;

	dbg("%s", __func__);



	if (fe->ops.info.type == FE_OFDM)

	kfree(priv);



	return;

}
@@ -742,72 +555,39 @@ static int cxd2820r_i2c_gate_ctrl(struct dvb_frontend *fe, int enable) 
	return cxd2820r_wr_reg_mask(priv, 0xdb, enable ? 1 : 0, 0x1);

}



static const struct dvb_frontend_ops cxd2820r_ops[2];



struct dvb_frontend *cxd2820r_attach(const struct cxd2820r_config *cfg,

	struct i2c_adapter *i2c, struct dvb_frontend *fe)

static int cxd2820r_get_property(struct dvb_frontend *fe, struct dtv_property *p)

{

	int ret;

	struct cxd2820r_priv *priv = NULL;

	u8 tmp;



	if (fe == NULL) {

		/* FE0 */

		/* allocate memory for the internal priv */

		priv = kzalloc(sizeof(struct cxd2820r_priv), GFP_KERNEL);

		if (priv == NULL)

			goto error;



		/* setup the priv */

		priv->i2c = i2c;

		memcpy(&priv->cfg, cfg, sizeof(struct cxd2820r_config));

		mutex_init(&priv->fe_lock);



		priv->active_fe = -1; /* NONE */



		/* check if the demod is there */

		priv->bank[0] = priv->bank[1] = 0xff;

		ret = cxd2820r_rd_reg(priv, 0x000fd, &tmp);

		dbg("%s: chip id=%02x", __func__, tmp);

		if (ret || tmp != 0xe1)

			goto error;



		/* create frontends */

		memcpy(&priv->fe[0].ops, &cxd2820r_ops[0],

			sizeof(struct dvb_frontend_ops));

		memcpy(&priv->fe[1].ops, &cxd2820r_ops[1],

			sizeof(struct dvb_frontend_ops));



		priv->fe[0].demodulator_priv = priv;

		priv->fe[1].demodulator_priv = priv;



		return &priv->fe[0];



	} else {

		/* FE1: FE0 given as pointer, just return FE1 we have

		 * already created */

		priv = fe->demodulator_priv;

		return &priv->fe[1];

	dbg("%s()\n", __func__);



	switch (p->cmd) {

	case DTV_ENUM_DELSYS:

		p->u.buffer.data[0] = SYS_DVBT;

		p->u.buffer.data[1] = SYS_DVBT2;

		p->u.buffer.data[2] = SYS_DVBC_ANNEX_AC;

		p->u.buffer.len = 3;

		break;

	default:

		break;

	}



error:

	kfree(priv);

	return NULL;

	return 0;

}

EXPORT_SYMBOL(cxd2820r_attach);



static const struct dvb_frontend_ops cxd2820r_ops[2] = {

	{

		/* DVB-T/T2 */

static const struct dvb_frontend_ops cxd2820r_ops = {

	/* default: DVB-T/T2 */

	.info = {

		.name = "Sony CXD2820R (DVB-T/T2)",

		.type = FE_OFDM,

			.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 | FE_CAN_QAM_16 |

				FE_CAN_QAM_64 | FE_CAN_QAM_256 |



		.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			|

			FE_CAN_QAM_16			|

			FE_CAN_QAM_64			|

			FE_CAN_QAM_256			|

			FE_CAN_QAM_AUTO			|

			FE_CAN_TRANSMISSION_MODE_AUTO	|

			FE_CAN_GUARD_INTERVAL_AUTO	|
@@ -833,36 +613,39 @@ static const struct dvb_frontend_ops cxd2820r_ops[2] = { 
	.read_ber		= cxd2820r_read_ber,

	.read_ucblocks		= cxd2820r_read_ucblocks,

	.read_signal_strength	= cxd2820r_read_signal_strength,

	},

	{

		/* DVB-C */

		.info = {

			.name = "Sony CXD2820R (DVB-C)",

			.type = FE_QAM,

			.caps =

				FE_CAN_QAM_16 | FE_CAN_QAM_32 | FE_CAN_QAM_64 |

				FE_CAN_QAM_128 | FE_CAN_QAM_256 |

				FE_CAN_FEC_AUTO

		},



		.release = cxd2820r_release,

		.init = cxd2820r_init,

		.sleep = cxd2820r_sleep,

	.get_property		= cxd2820r_get_property,

};



		.get_tune_settings = cxd2820r_get_tune_settings,

		.i2c_gate_ctrl = cxd2820r_i2c_gate_ctrl,

struct dvb_frontend *cxd2820r_attach(const struct cxd2820r_config *cfg,

				     struct i2c_adapter *i2c,

				     struct dvb_frontend *fe)

{

	struct cxd2820r_priv *priv = NULL;

	int ret;

	u8 tmp;



		.set_frontend = cxd2820r_set_frontend,

		.get_frontend = cxd2820r_get_frontend,

	priv = kzalloc(sizeof (struct cxd2820r_priv), GFP_KERNEL);

	if (!priv)

		goto error;



		.read_status = cxd2820r_read_status,

		.read_snr = cxd2820r_read_snr,

		.read_ber = cxd2820r_read_ber,

		.read_ucblocks = cxd2820r_read_ucblocks,

		.read_signal_strength = cxd2820r_read_signal_strength,

	},

};

	priv->i2c = i2c;

	memcpy(&priv->cfg, cfg, sizeof (struct cxd2820r_config));



	priv->bank[0] = priv->bank[1] = 0xff;

	ret = cxd2820r_rd_reg(priv, 0x000fd, &tmp);

	dbg("%s: chip id=%02x", __func__, tmp);

	if (ret || tmp != 0xe1)

		goto error;



	memcpy(&priv->fe.ops, &cxd2820r_ops, sizeof (struct dvb_frontend_ops));

	priv->fe.demodulator_priv = priv;

	return &priv->fe;

error:

	kfree(priv);

	return NULL;

}

EXPORT_SYMBOL(cxd2820r_attach);



MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");

MODULE_DESCRIPTION("Sony CXD2820R demodulator driver");

drivers/media/dvb/frontends/cxd2820r_priv.h

+1 −4
Original line number Diff line number Diff line
@@ -48,12 +48,9 @@ struct reg_val_mask { 


struct cxd2820r_priv {

	struct i2c_adapter *i2c;

	struct dvb_frontend fe[2];

	struct dvb_frontend fe;

	struct cxd2820r_config cfg;



	struct mutex fe_lock; /* FE lock */

	int active_fe:2; /* FE lock, -1=NONE, 0=DVB-T/T2, 1=DVB-C */



	bool ber_running;



	u8 bank[2];

drivers/media/dvb/frontends/cxd2820r_c.c

+1 −1

File changed.

Contains only whitespace changes.

drivers/media/dvb/frontends/cxd2820r_t.c

+1 −1

File changed.

Contains only whitespace changes.

drivers/media/dvb/frontends/cxd2820r_t2.c

+1 −1

File changed.

Contains only whitespace changes.