cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

as102_fe.c (10577B)

      1// SPDX-License-Identifier: GPL-2.0-or-later
      2/*
      3 * Abilis Systems Single DVB-T Receiver
      4 * Copyright (C) 2008 Pierrick Hascoet <pierrick.hascoet@abilis.com>
      5 * Copyright (C) 2010 Devin Heitmueller <dheitmueller@kernellabs.com>
      6 */
      7
      8#include <media/dvb_frontend.h>
      9
     10#include "as102_fe.h"
     11
     12struct as102_state {
     13	struct dvb_frontend frontend;
     14	struct as10x_demod_stats demod_stats;
     15
     16	const struct as102_fe_ops *ops;
     17	void *priv;
     18	uint8_t elna_cfg;
     19
     20	/* signal strength */
     21	uint16_t signal_strength;
     22	/* bit error rate */
     23	uint32_t ber;
     24};
     25
     26static uint8_t as102_fe_get_code_rate(enum fe_code_rate arg)
     27{
     28	uint8_t c;
     29
     30	switch (arg) {
     31	case FEC_1_2:
     32		c = CODE_RATE_1_2;
     33		break;
     34	case FEC_2_3:
     35		c = CODE_RATE_2_3;
     36		break;
     37	case FEC_3_4:
     38		c = CODE_RATE_3_4;
     39		break;
     40	case FEC_5_6:
     41		c = CODE_RATE_5_6;
     42		break;
     43	case FEC_7_8:
     44		c = CODE_RATE_7_8;
     45		break;
     46	default:
     47		c = CODE_RATE_UNKNOWN;
     48		break;
     49	}
     50
     51	return c;
     52}
     53
     54static int as102_fe_set_frontend(struct dvb_frontend *fe)
     55{
     56	struct as102_state *state = fe->demodulator_priv;
     57	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
     58	struct as10x_tune_args tune_args = { 0 };
     59
     60	/* set frequency */
     61	tune_args.freq = c->frequency / 1000;
     62
     63	/* fix interleaving_mode */
     64	tune_args.interleaving_mode = INTLV_NATIVE;
     65
     66	switch (c->bandwidth_hz) {
     67	case 8000000:
     68		tune_args.bandwidth = BW_8_MHZ;
     69		break;
     70	case 7000000:
     71		tune_args.bandwidth = BW_7_MHZ;
     72		break;
     73	case 6000000:
     74		tune_args.bandwidth = BW_6_MHZ;
     75		break;
     76	default:
     77		tune_args.bandwidth = BW_8_MHZ;
     78	}
     79
     80	switch (c->guard_interval) {
     81	case GUARD_INTERVAL_1_32:
     82		tune_args.guard_interval = GUARD_INT_1_32;
     83		break;
     84	case GUARD_INTERVAL_1_16:
     85		tune_args.guard_interval = GUARD_INT_1_16;
     86		break;
     87	case GUARD_INTERVAL_1_8:
     88		tune_args.guard_interval = GUARD_INT_1_8;
     89		break;
     90	case GUARD_INTERVAL_1_4:
     91		tune_args.guard_interval = GUARD_INT_1_4;
     92		break;
     93	case GUARD_INTERVAL_AUTO:
     94	default:
     95		tune_args.guard_interval = GUARD_UNKNOWN;
     96		break;
     97	}
     98
     99	switch (c->modulation) {
    100	case QPSK:
    101		tune_args.modulation = CONST_QPSK;
    102		break;
    103	case QAM_16:
    104		tune_args.modulation = CONST_QAM16;
    105		break;
    106	case QAM_64:
    107		tune_args.modulation = CONST_QAM64;
    108		break;
    109	default:
    110		tune_args.modulation = CONST_UNKNOWN;
    111		break;
    112	}
    113
    114	switch (c->transmission_mode) {
    115	case TRANSMISSION_MODE_2K:
    116		tune_args.transmission_mode = TRANS_MODE_2K;
    117		break;
    118	case TRANSMISSION_MODE_8K:
    119		tune_args.transmission_mode = TRANS_MODE_8K;
    120		break;
    121	default:
    122		tune_args.transmission_mode = TRANS_MODE_UNKNOWN;
    123	}
    124
    125	switch (c->hierarchy) {
    126	case HIERARCHY_NONE:
    127		tune_args.hierarchy = HIER_NONE;
    128		break;
    129	case HIERARCHY_1:
    130		tune_args.hierarchy = HIER_ALPHA_1;
    131		break;
    132	case HIERARCHY_2:
    133		tune_args.hierarchy = HIER_ALPHA_2;
    134		break;
    135	case HIERARCHY_4:
    136		tune_args.hierarchy = HIER_ALPHA_4;
    137		break;
    138	case HIERARCHY_AUTO:
    139		tune_args.hierarchy = HIER_UNKNOWN;
    140		break;
    141	}
    142
    143	pr_debug("as102: tuner parameters: freq: %d  bw: 0x%02x  gi: 0x%02x\n",
    144			c->frequency,
    145			tune_args.bandwidth,
    146			tune_args.guard_interval);
    147
    148	/*
    149	 * Detect a hierarchy selection
    150	 * if HP/LP are both set to FEC_NONE, HP will be selected.
    151	 */
    152	if ((tune_args.hierarchy != HIER_NONE) &&
    153		       ((c->code_rate_LP == FEC_NONE) ||
    154			(c->code_rate_HP == FEC_NONE))) {
    155
    156		if (c->code_rate_LP == FEC_NONE) {
    157			tune_args.hier_select = HIER_HIGH_PRIORITY;
    158			tune_args.code_rate =
    159			   as102_fe_get_code_rate(c->code_rate_HP);
    160		}
    161
    162		if (c->code_rate_HP == FEC_NONE) {
    163			tune_args.hier_select = HIER_LOW_PRIORITY;
    164			tune_args.code_rate =
    165			   as102_fe_get_code_rate(c->code_rate_LP);
    166		}
    167
    168		pr_debug("as102: \thierarchy: 0x%02x  selected: %s  code_rate_%s: 0x%02x\n",
    169			tune_args.hierarchy,
    170			tune_args.hier_select == HIER_HIGH_PRIORITY ?
    171			"HP" : "LP",
    172			tune_args.hier_select == HIER_HIGH_PRIORITY ?
    173			"HP" : "LP",
    174			tune_args.code_rate);
    175	} else {
    176		tune_args.code_rate =
    177			as102_fe_get_code_rate(c->code_rate_HP);
    178	}
    179
    180	/* Set frontend arguments */
    181	return state->ops->set_tune(state->priv, &tune_args);
    182}
    183
    184static int as102_fe_get_frontend(struct dvb_frontend *fe,
    185				 struct dtv_frontend_properties *c)
    186{
    187	struct as102_state *state = fe->demodulator_priv;
    188	int ret = 0;
    189	struct as10x_tps tps = { 0 };
    190
    191	/* send abilis command: GET_TPS */
    192	ret = state->ops->get_tps(state->priv, &tps);
    193	if (ret < 0)
    194		return ret;
    195
    196	/* extract constellation */
    197	switch (tps.modulation) {
    198	case CONST_QPSK:
    199		c->modulation = QPSK;
    200		break;
    201	case CONST_QAM16:
    202		c->modulation = QAM_16;
    203		break;
    204	case CONST_QAM64:
    205		c->modulation = QAM_64;
    206		break;
    207	}
    208
    209	/* extract hierarchy */
    210	switch (tps.hierarchy) {
    211	case HIER_NONE:
    212		c->hierarchy = HIERARCHY_NONE;
    213		break;
    214	case HIER_ALPHA_1:
    215		c->hierarchy = HIERARCHY_1;
    216		break;
    217	case HIER_ALPHA_2:
    218		c->hierarchy = HIERARCHY_2;
    219		break;
    220	case HIER_ALPHA_4:
    221		c->hierarchy = HIERARCHY_4;
    222		break;
    223	}
    224
    225	/* extract code rate HP */
    226	switch (tps.code_rate_HP) {
    227	case CODE_RATE_1_2:
    228		c->code_rate_HP = FEC_1_2;
    229		break;
    230	case CODE_RATE_2_3:
    231		c->code_rate_HP = FEC_2_3;
    232		break;
    233	case CODE_RATE_3_4:
    234		c->code_rate_HP = FEC_3_4;
    235		break;
    236	case CODE_RATE_5_6:
    237		c->code_rate_HP = FEC_5_6;
    238		break;
    239	case CODE_RATE_7_8:
    240		c->code_rate_HP = FEC_7_8;
    241		break;
    242	}
    243
    244	/* extract code rate LP */
    245	switch (tps.code_rate_LP) {
    246	case CODE_RATE_1_2:
    247		c->code_rate_LP = FEC_1_2;
    248		break;
    249	case CODE_RATE_2_3:
    250		c->code_rate_LP = FEC_2_3;
    251		break;
    252	case CODE_RATE_3_4:
    253		c->code_rate_LP = FEC_3_4;
    254		break;
    255	case CODE_RATE_5_6:
    256		c->code_rate_LP = FEC_5_6;
    257		break;
    258	case CODE_RATE_7_8:
    259		c->code_rate_LP = FEC_7_8;
    260		break;
    261	}
    262
    263	/* extract guard interval */
    264	switch (tps.guard_interval) {
    265	case GUARD_INT_1_32:
    266		c->guard_interval = GUARD_INTERVAL_1_32;
    267		break;
    268	case GUARD_INT_1_16:
    269		c->guard_interval = GUARD_INTERVAL_1_16;
    270		break;
    271	case GUARD_INT_1_8:
    272		c->guard_interval = GUARD_INTERVAL_1_8;
    273		break;
    274	case GUARD_INT_1_4:
    275		c->guard_interval = GUARD_INTERVAL_1_4;
    276		break;
    277	}
    278
    279	/* extract transmission mode */
    280	switch (tps.transmission_mode) {
    281	case TRANS_MODE_2K:
    282		c->transmission_mode = TRANSMISSION_MODE_2K;
    283		break;
    284	case TRANS_MODE_8K:
    285		c->transmission_mode = TRANSMISSION_MODE_8K;
    286		break;
    287	}
    288
    289	return 0;
    290}
    291
    292static int as102_fe_get_tune_settings(struct dvb_frontend *fe,
    293			struct dvb_frontend_tune_settings *settings)
    294{
    295
    296	settings->min_delay_ms = 1000;
    297
    298	return 0;
    299}
    300
    301static int as102_fe_read_status(struct dvb_frontend *fe, enum fe_status *status)
    302{
    303	int ret = 0;
    304	struct as102_state *state = fe->demodulator_priv;
    305	struct as10x_tune_status tstate = { 0 };
    306
    307	/* send abilis command: GET_TUNE_STATUS */
    308	ret = state->ops->get_status(state->priv, &tstate);
    309	if (ret < 0)
    310		return ret;
    311
    312	state->signal_strength  = tstate.signal_strength;
    313	state->ber  = tstate.BER;
    314
    315	switch (tstate.tune_state) {
    316	case TUNE_STATUS_SIGNAL_DVB_OK:
    317		*status = FE_HAS_SIGNAL | FE_HAS_CARRIER;
    318		break;
    319	case TUNE_STATUS_STREAM_DETECTED:
    320		*status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_SYNC |
    321			  FE_HAS_VITERBI;
    322		break;
    323	case TUNE_STATUS_STREAM_TUNED:
    324		*status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_SYNC |
    325			  FE_HAS_LOCK | FE_HAS_VITERBI;
    326		break;
    327	default:
    328		*status = TUNE_STATUS_NOT_TUNED;
    329	}
    330
    331	pr_debug("as102: tuner status: 0x%02x, strength %d, per: %d, ber: %d\n",
    332		 tstate.tune_state, tstate.signal_strength,
    333		 tstate.PER, tstate.BER);
    334
    335	if (!(*status & FE_HAS_LOCK)) {
    336		memset(&state->demod_stats, 0, sizeof(state->demod_stats));
    337		return 0;
    338	}
    339
    340	ret = state->ops->get_stats(state->priv, &state->demod_stats);
    341	if (ret < 0)
    342		memset(&state->demod_stats, 0, sizeof(state->demod_stats));
    343
    344	return ret;
    345}
    346
    347/*
    348 * Note:
    349 * - in AS102 SNR=MER
    350 *   - the SNR will be returned in linear terms, i.e. not in dB
    351 *   - the accuracy equals ±2dB for a SNR range from 4dB to 30dB
    352 *   - the accuracy is >2dB for SNR values outside this range
    353 */
    354static int as102_fe_read_snr(struct dvb_frontend *fe, u16 *snr)
    355{
    356	struct as102_state *state = fe->demodulator_priv;
    357
    358	*snr = state->demod_stats.mer;
    359
    360	return 0;
    361}
    362
    363static int as102_fe_read_ber(struct dvb_frontend *fe, u32 *ber)
    364{
    365	struct as102_state *state = fe->demodulator_priv;
    366
    367	*ber = state->ber;
    368
    369	return 0;
    370}
    371
    372static int as102_fe_read_signal_strength(struct dvb_frontend *fe,
    373					 u16 *strength)
    374{
    375	struct as102_state *state = fe->demodulator_priv;
    376
    377	*strength = (((0xffff * 400) * state->signal_strength + 41000) * 2);
    378
    379	return 0;
    380}
    381
    382static int as102_fe_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
    383{
    384	struct as102_state *state = fe->demodulator_priv;
    385
    386	if (state->demod_stats.has_started)
    387		*ucblocks = state->demod_stats.bad_frame_count;
    388	else
    389		*ucblocks = 0;
    390
    391	return 0;
    392}
    393
    394static int as102_fe_ts_bus_ctrl(struct dvb_frontend *fe, int acquire)
    395{
    396	struct as102_state *state = fe->demodulator_priv;
    397
    398	return state->ops->stream_ctrl(state->priv, acquire,
    399				      state->elna_cfg);
    400}
    401
    402static void as102_fe_release(struct dvb_frontend *fe)
    403{
    404	struct as102_state *state = fe->demodulator_priv;
    405
    406	kfree(state);
    407}
    408
    409
    410static const struct dvb_frontend_ops as102_fe_ops = {
    411	.delsys = { SYS_DVBT },
    412	.info = {
    413		.name			= "Abilis AS102 DVB-T",
    414		.frequency_min_hz	= 174 * MHz,
    415		.frequency_max_hz	= 862 * MHz,
    416		.frequency_stepsize_hz	= 166667,
    417		.caps = FE_CAN_INVERSION_AUTO
    418			| FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4
    419			| FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO
    420			| FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QPSK
    421			| FE_CAN_QAM_AUTO
    422			| FE_CAN_TRANSMISSION_MODE_AUTO
    423			| FE_CAN_GUARD_INTERVAL_AUTO
    424			| FE_CAN_HIERARCHY_AUTO
    425			| FE_CAN_RECOVER
    426			| FE_CAN_MUTE_TS
    427	},
    428
    429	.set_frontend		= as102_fe_set_frontend,
    430	.get_frontend		= as102_fe_get_frontend,
    431	.get_tune_settings	= as102_fe_get_tune_settings,
    432
    433	.read_status		= as102_fe_read_status,
    434	.read_snr		= as102_fe_read_snr,
    435	.read_ber		= as102_fe_read_ber,
    436	.read_signal_strength	= as102_fe_read_signal_strength,
    437	.read_ucblocks		= as102_fe_read_ucblocks,
    438	.ts_bus_ctrl		= as102_fe_ts_bus_ctrl,
    439	.release		= as102_fe_release,
    440};
    441
    442struct dvb_frontend *as102_attach(const char *name,
    443				  const struct as102_fe_ops *ops,
    444				  void *priv,
    445				  uint8_t elna_cfg)
    446{
    447	struct as102_state *state;
    448	struct dvb_frontend *fe;
    449
    450	state = kzalloc(sizeof(*state), GFP_KERNEL);
    451	if (!state)
    452		return NULL;
    453
    454	fe = &state->frontend;
    455	fe->demodulator_priv = state;
    456	state->ops = ops;
    457	state->priv = priv;
    458	state->elna_cfg = elna_cfg;
    459
    460	/* init frontend callback ops */
    461	memcpy(&fe->ops, &as102_fe_ops, sizeof(struct dvb_frontend_ops));
    462	strscpy(fe->ops.info.name, name, sizeof(fe->ops.info.name));
    463
    464	return fe;
    465
    466}
    467EXPORT_SYMBOL_GPL(as102_attach);
    468
    469MODULE_DESCRIPTION("as102-fe");
    470MODULE_LICENSE("GPL");
    471MODULE_AUTHOR("Pierrick Hascoet <pierrick.hascoet@abilis.com>");