[linux-2.6-block.git] / drivers / media / dvb-frontends / dvb_dummy_fe.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  Driver for Dummy Frontend
 *
 *  Written by Emard <emard@softhome.net>
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/slab.h>

#include <media/dvb_frontend.h>
#include "dvb_dummy_fe.h"


struct dvb_dummy_fe_state {
	struct dvb_frontend frontend;
};


static int dvb_dummy_fe_read_status(struct dvb_frontend *fe,
				    enum fe_status *status)
{
	*status = FE_HAS_SIGNAL
		| FE_HAS_CARRIER
		| FE_HAS_VITERBI
		| FE_HAS_SYNC
		| FE_HAS_LOCK;

	return 0;
}

static int dvb_dummy_fe_read_ber(struct dvb_frontend* fe, u32* ber)
{
	*ber = 0;
	return 0;
}

static int dvb_dummy_fe_read_signal_strength(struct dvb_frontend* fe, u16* strength)
{
	*strength = 0;
	return 0;
}

static int dvb_dummy_fe_read_snr(struct dvb_frontend* fe, u16* snr)
{
	*snr = 0;
	return 0;
}

static int dvb_dummy_fe_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
{
	*ucblocks = 0;
	return 0;
}

/*
 * Should only be implemented if it actually reads something from the hardware.
 * Also, it should check for the locks, in order to avoid report wrong data
 * to userspace.
 */
static int dvb_dummy_fe_get_frontend(struct dvb_frontend *fe,
				     struct dtv_frontend_properties *p)
{
	return 0;
}

static int dvb_dummy_fe_set_frontend(struct dvb_frontend *fe)
{
	if (fe->ops.tuner_ops.set_params) {
		fe->ops.tuner_ops.set_params(fe);
		if (fe->ops.i2c_gate_ctrl)
			fe->ops.i2c_gate_ctrl(fe, 0);
	}

	return 0;
}

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

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

static int dvb_dummy_fe_set_tone(struct dvb_frontend *fe,
				 enum fe_sec_tone_mode tone)
{
	return 0;
}

static int dvb_dummy_fe_set_voltage(struct dvb_frontend *fe,
				    enum fe_sec_voltage voltage)
{
	return 0;
}

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

static const struct dvb_frontend_ops dvb_dummy_fe_ofdm_ops;

struct dvb_frontend* dvb_dummy_fe_ofdm_attach(void)
{
	struct dvb_dummy_fe_state* state = NULL;

	/* allocate memory for the internal state */
	state = kzalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
	if (!state)
		return NULL;

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

static const struct dvb_frontend_ops dvb_dummy_fe_qpsk_ops;

struct dvb_frontend *dvb_dummy_fe_qpsk_attach(void)
{
	struct dvb_dummy_fe_state* state = NULL;

	/* allocate memory for the internal state */
	state = kzalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
	if (!state)
		return NULL;

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

static const struct dvb_frontend_ops dvb_dummy_fe_qam_ops;

struct dvb_frontend *dvb_dummy_fe_qam_attach(void)
{
	struct dvb_dummy_fe_state* state = NULL;

	/* allocate memory for the internal state */
	state = kzalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
	if (!state)
		return NULL;

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

static const struct dvb_frontend_ops dvb_dummy_fe_ofdm_ops = {
	.delsys = { SYS_DVBT },
	.info = {
		.name			= "Dummy DVB-T",
		.frequency_min_hz	= 0,
		.frequency_max_hz	= 863250 * kHz,
		.frequency_stepsize_hz	= 62500,
		.caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
				FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 |
				FE_CAN_FEC_7_8 | FE_CAN_FEC_8_9 | 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 = dvb_dummy_fe_release,

	.init = dvb_dummy_fe_init,
	.sleep = dvb_dummy_fe_sleep,

	.set_frontend = dvb_dummy_fe_set_frontend,
	.get_frontend = dvb_dummy_fe_get_frontend,

	.read_status = dvb_dummy_fe_read_status,
	.read_ber = dvb_dummy_fe_read_ber,
	.read_signal_strength = dvb_dummy_fe_read_signal_strength,
	.read_snr = dvb_dummy_fe_read_snr,
	.read_ucblocks = dvb_dummy_fe_read_ucblocks,
};

static const struct dvb_frontend_ops dvb_dummy_fe_qam_ops = {
	.delsys = { SYS_DVBC_ANNEX_A },
	.info = {
		.name			= "Dummy DVB-C",
		.frequency_min_hz	=  51 * MHz,
		.frequency_max_hz	= 858 * MHz,
		.frequency_stepsize_hz	= 62500,
		.symbol_rate_min	= (57840000 / 2) / 64,  /* SACLK/64 == (XIN/2)/64 */
		.symbol_rate_max	= (57840000 / 2) / 4,   /* SACLK/4 */
		.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 | FE_CAN_INVERSION_AUTO
	},

	.release = dvb_dummy_fe_release,

	.init = dvb_dummy_fe_init,
	.sleep = dvb_dummy_fe_sleep,

	.set_frontend = dvb_dummy_fe_set_frontend,
	.get_frontend = dvb_dummy_fe_get_frontend,

	.read_status = dvb_dummy_fe_read_status,
	.read_ber = dvb_dummy_fe_read_ber,
	.read_signal_strength = dvb_dummy_fe_read_signal_strength,
	.read_snr = dvb_dummy_fe_read_snr,
	.read_ucblocks = dvb_dummy_fe_read_ucblocks,
};

static const struct dvb_frontend_ops dvb_dummy_fe_qpsk_ops = {
	.delsys = { SYS_DVBS },
	.info = {
		.name			= "Dummy DVB-S",
		.frequency_min_hz	=  950 * MHz,
		.frequency_max_hz	= 2150 * MHz,
		.frequency_stepsize_hz	= 250 * kHz,
		.frequency_tolerance_hz	= 29500 * kHz,
		.symbol_rate_min	= 1000000,
		.symbol_rate_max	= 45000000,
		.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
	},

	.release = dvb_dummy_fe_release,

	.init = dvb_dummy_fe_init,
	.sleep = dvb_dummy_fe_sleep,

	.set_frontend = dvb_dummy_fe_set_frontend,
	.get_frontend = dvb_dummy_fe_get_frontend,

	.read_status = dvb_dummy_fe_read_status,
	.read_ber = dvb_dummy_fe_read_ber,
	.read_signal_strength = dvb_dummy_fe_read_signal_strength,
	.read_snr = dvb_dummy_fe_read_snr,
	.read_ucblocks = dvb_dummy_fe_read_ucblocks,

	.set_voltage = dvb_dummy_fe_set_voltage,
	.set_tone = dvb_dummy_fe_set_tone,
};

MODULE_DESCRIPTION("DVB DUMMY Frontend");
MODULE_AUTHOR("Emard");
MODULE_LICENSE("GPL");

EXPORT_SYMBOL(dvb_dummy_fe_ofdm_attach);
EXPORT_SYMBOL(dvb_dummy_fe_qam_attach);
EXPORT_SYMBOL(dvb_dummy_fe_qpsk_attach);
Commit	Line	Data
c942fddf	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4 LT	2	/*
	3	* Driver for Dummy Frontend
	4	*
	5	* Written by Emard <emard@softhome.net>
1da177e4 LT	6	*/
	7
	8	#include <linux/module.h>
1da177e4	9	#include <linux/init.h>
4e57b681 TS	10	#include <linux/string.h>
4e57b681 TS	11	#include <linux/slab.h>
1da177e4	12
fada1935	13	#include <media/dvb_frontend.h>
1da177e4 LT	14	#include "dvb_dummy_fe.h"
	15
	16
	17	struct dvb_dummy_fe_state {
1da177e4 LT	18	struct dvb_frontend frontend;
	19	};
	20
	21
0df289a2 MCC	22	static int dvb_dummy_fe_read_status(struct dvb_frontend *fe,
0df289a2 MCC	23	enum fe_status *status)
1da177e4 LT	24	{
	25	*status = FE_HAS_SIGNAL
	26	\| FE_HAS_CARRIER
	27	\| FE_HAS_VITERBI
	28	\| FE_HAS_SYNC
	29	\| FE_HAS_LOCK;
	30
	31	return 0;
	32	}
	33
	34	static int dvb_dummy_fe_read_ber(struct dvb_frontend* fe, u32* ber)
	35	{
	36	*ber = 0;
	37	return 0;
	38	}
	39
	40	static int dvb_dummy_fe_read_signal_strength(struct dvb_frontend* fe, u16* strength)
	41	{
	42	*strength = 0;
	43	return 0;
	44	}
	45
	46	static int dvb_dummy_fe_read_snr(struct dvb_frontend* fe, u16* snr)
	47	{
	48	*snr = 0;
	49	return 0;
	50	}
	51
	52	static int dvb_dummy_fe_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
	53	{
	54	*ucblocks = 0;
	55	return 0;
	56	}
	57
7c61d80a	58	/*
7e3e68bc MCC	59	* Should only be implemented if it actually reads something from the hardware.
	60	* Also, it should check for the locks, in order to avoid report wrong data
	61	* to userspace.
7c61d80a	62	*/
7e3e68bc MCC	63	static int dvb_dummy_fe_get_frontend(struct dvb_frontend *fe,
7e3e68bc MCC	64	struct dtv_frontend_properties *p)
1da177e4 LT	65	{
	66	return 0;
	67	}
	68
d53b5102	69	static int dvb_dummy_fe_set_frontend(struct dvb_frontend *fe)
1da177e4	70	{
bccd7003	71	if (fe->ops.tuner_ops.set_params) {
14d24d14	72	fe->ops.tuner_ops.set_params(fe);
bccd7003 PB	73	if (fe->ops.i2c_gate_ctrl)
bccd7003 PB	74	fe->ops.i2c_gate_ctrl(fe, 0);
089e9809 AQ	75	}
089e9809 AQ	76
1da177e4 LT	77	return 0;
	78	}
	79
	80	static int dvb_dummy_fe_sleep(struct dvb_frontend* fe)
	81	{
	82	return 0;
	83	}
	84
	85	static int dvb_dummy_fe_init(struct dvb_frontend* fe)
	86	{
	87	return 0;
	88	}
	89
0df289a2 MCC	90	static int dvb_dummy_fe_set_tone(struct dvb_frontend *fe,
0df289a2 MCC	91	enum fe_sec_tone_mode tone)
1da177e4 LT	92	{
	93	return 0;
	94	}
	95
0df289a2 MCC	96	static int dvb_dummy_fe_set_voltage(struct dvb_frontend *fe,
0df289a2 MCC	97	enum fe_sec_voltage voltage)
1da177e4 LT	98	{
	99	return 0;
	100	}
	101
	102	static void dvb_dummy_fe_release(struct dvb_frontend* fe)
	103	{
b8742700	104	struct dvb_dummy_fe_state* state = fe->demodulator_priv;
1da177e4 LT	105	kfree(state);
	106	}
	107
bd336e63	108	static const struct dvb_frontend_ops dvb_dummy_fe_ofdm_ops;
1da177e4 LT	109
	110	struct dvb_frontend* dvb_dummy_fe_ofdm_attach(void)
	111	{
	112	struct dvb_dummy_fe_state* state = NULL;
	113
	114	/* allocate memory for the internal state */
084e24ac	115	state = kzalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
3f037426 PST	116	if (!state)
3f037426 PST	117	return NULL;
1da177e4	118
1da177e4	119	/* create dvb_frontend */
dea74869	120	memcpy(&state->frontend.ops, &dvb_dummy_fe_ofdm_ops, sizeof(struct dvb_frontend_ops));
1da177e4 LT	121	state->frontend.demodulator_priv = state;
1da177e4 LT	122	return &state->frontend;
1da177e4 LT	123	}
1da177e4 LT	124
bd336e63	125	static const struct dvb_frontend_ops dvb_dummy_fe_qpsk_ops;
1da177e4	126
d45b9b8a	127	struct dvb_frontend *dvb_dummy_fe_qpsk_attach(void)
1da177e4 LT	128	{
	129	struct dvb_dummy_fe_state* state = NULL;
	130
	131	/* allocate memory for the internal state */
084e24ac	132	state = kzalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
3f037426 PST	133	if (!state)
3f037426 PST	134	return NULL;
1da177e4	135
1da177e4	136	/* create dvb_frontend */
dea74869	137	memcpy(&state->frontend.ops, &dvb_dummy_fe_qpsk_ops, sizeof(struct dvb_frontend_ops));
1da177e4 LT	138	state->frontend.demodulator_priv = state;
1da177e4 LT	139	return &state->frontend;
1da177e4 LT	140	}
1da177e4 LT	141
bd336e63	142	static const struct dvb_frontend_ops dvb_dummy_fe_qam_ops;
1da177e4	143
d45b9b8a	144	struct dvb_frontend *dvb_dummy_fe_qam_attach(void)
1da177e4 LT	145	{
	146	struct dvb_dummy_fe_state* state = NULL;
	147
	148	/* allocate memory for the internal state */
084e24ac	149	state = kzalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
3f037426 PST	150	if (!state)
3f037426 PST	151	return NULL;
1da177e4	152
1da177e4	153	/* create dvb_frontend */
dea74869	154	memcpy(&state->frontend.ops, &dvb_dummy_fe_qam_ops, sizeof(struct dvb_frontend_ops));
1da177e4 LT	155	state->frontend.demodulator_priv = state;
1da177e4 LT	156	return &state->frontend;
1da177e4 LT	157	}
1da177e4 LT	158
bd336e63	159	static const struct dvb_frontend_ops dvb_dummy_fe_ofdm_ops = {
d53b5102	160	.delsys = { SYS_DVBT },
1da177e4 LT	161	.info = {
1da177e4 LT	162	.name = "Dummy DVB-T",
f1b1eabf MCC	163	.frequency_min_hz = 0,
	164	.frequency_max_hz = 863250 * kHz,
	165	.frequency_stepsize_hz = 62500,
1da177e4 LT	166	.caps = FE_CAN_FEC_1_2 \| FE_CAN_FEC_2_3 \| FE_CAN_FEC_3_4 \|
	167	FE_CAN_FEC_4_5 \| FE_CAN_FEC_5_6 \| FE_CAN_FEC_6_7 \|
	168	FE_CAN_FEC_7_8 \| FE_CAN_FEC_8_9 \| FE_CAN_FEC_AUTO \|
	169	FE_CAN_QAM_16 \| FE_CAN_QAM_64 \| FE_CAN_QAM_AUTO \|
	170	FE_CAN_TRANSMISSION_MODE_AUTO \|
	171	FE_CAN_GUARD_INTERVAL_AUTO \|
	172	FE_CAN_HIERARCHY_AUTO,
	173	},
	174
	175	.release = dvb_dummy_fe_release,
	176
	177	.init = dvb_dummy_fe_init,
	178	.sleep = dvb_dummy_fe_sleep,
	179
d53b5102 MCC	180	.set_frontend = dvb_dummy_fe_set_frontend,
d53b5102 MCC	181	.get_frontend = dvb_dummy_fe_get_frontend,
1da177e4 LT	182
	183	.read_status = dvb_dummy_fe_read_status,
	184	.read_ber = dvb_dummy_fe_read_ber,
	185	.read_signal_strength = dvb_dummy_fe_read_signal_strength,
	186	.read_snr = dvb_dummy_fe_read_snr,
	187	.read_ucblocks = dvb_dummy_fe_read_ucblocks,
	188	};
	189
bd336e63	190	static const struct dvb_frontend_ops dvb_dummy_fe_qam_ops = {
d53b5102	191	.delsys = { SYS_DVBC_ANNEX_A },
1da177e4 LT	192	.info = {
1da177e4 LT	193	.name = "Dummy DVB-C",
f1b1eabf MCC	194	.frequency_min_hz = 51 * MHz,
	195	.frequency_max_hz = 858 * MHz,
	196	.frequency_stepsize_hz = 62500,
	197	.symbol_rate_min = (57840000 / 2) / 64, /* SACLK/64 == (XIN/2)/64 */
	198	.symbol_rate_max = (57840000 / 2) / 4, /* SACLK/4 */
1da177e4 LT	199	.caps = FE_CAN_QAM_16 \| FE_CAN_QAM_32 \| FE_CAN_QAM_64 \|
	200	FE_CAN_QAM_128 \| FE_CAN_QAM_256 \|
	201	FE_CAN_FEC_AUTO \| FE_CAN_INVERSION_AUTO
	202	},
	203
	204	.release = dvb_dummy_fe_release,
	205
	206	.init = dvb_dummy_fe_init,
	207	.sleep = dvb_dummy_fe_sleep,
	208
d53b5102 MCC	209	.set_frontend = dvb_dummy_fe_set_frontend,
d53b5102 MCC	210	.get_frontend = dvb_dummy_fe_get_frontend,
1da177e4 LT	211
	212	.read_status = dvb_dummy_fe_read_status,
	213	.read_ber = dvb_dummy_fe_read_ber,
	214	.read_signal_strength = dvb_dummy_fe_read_signal_strength,
	215	.read_snr = dvb_dummy_fe_read_snr,
	216	.read_ucblocks = dvb_dummy_fe_read_ucblocks,
	217	};
	218
bd336e63	219	static const struct dvb_frontend_ops dvb_dummy_fe_qpsk_ops = {
d53b5102	220	.delsys = { SYS_DVBS },
1da177e4 LT	221	.info = {
1da177e4 LT	222	.name = "Dummy DVB-S",
f1b1eabf MCC	223	.frequency_min_hz = 950 * MHz,
	224	.frequency_max_hz = 2150 * MHz,
	225	.frequency_stepsize_hz = 250 * kHz,
	226	.frequency_tolerance_hz = 29500 * kHz,
1da177e4 LT	227	.symbol_rate_min = 1000000,
	228	.symbol_rate_max = 45000000,
	229	.caps = FE_CAN_INVERSION_AUTO \|
	230	FE_CAN_FEC_1_2 \| FE_CAN_FEC_2_3 \| FE_CAN_FEC_3_4 \|
	231	FE_CAN_FEC_5_6 \| FE_CAN_FEC_7_8 \| FE_CAN_FEC_AUTO \|
	232	FE_CAN_QPSK
	233	},
	234
	235	.release = dvb_dummy_fe_release,
	236
	237	.init = dvb_dummy_fe_init,
	238	.sleep = dvb_dummy_fe_sleep,
	239
d53b5102 MCC	240	.set_frontend = dvb_dummy_fe_set_frontend,
d53b5102 MCC	241	.get_frontend = dvb_dummy_fe_get_frontend,
1da177e4 LT	242
	243	.read_status = dvb_dummy_fe_read_status,
	244	.read_ber = dvb_dummy_fe_read_ber,
	245	.read_signal_strength = dvb_dummy_fe_read_signal_strength,
	246	.read_snr = dvb_dummy_fe_read_snr,
	247	.read_ucblocks = dvb_dummy_fe_read_ucblocks,
	248
	249	.set_voltage = dvb_dummy_fe_set_voltage,
	250	.set_tone = dvb_dummy_fe_set_tone,
	251	};
	252
	253	MODULE_DESCRIPTION("DVB DUMMY Frontend");
	254	MODULE_AUTHOR("Emard");
	255	MODULE_LICENSE("GPL");
	256
	257	EXPORT_SYMBOL(dvb_dummy_fe_ofdm_attach);
	258	EXPORT_SYMBOL(dvb_dummy_fe_qam_attach);
	259	EXPORT_SYMBOL(dvb_dummy_fe_qpsk_attach);