From 32f46389be3509b24fdb42fe136bb03db84b07a7 Mon Sep 17 00:00:00 2001 From: Ralph Metzler Date: Sat, 23 Jun 2018 16:52:22 +0200 Subject: [PATCH] adjust to latest MCI upstream drivers --- ddbridge/ddbridge-m4.c | 369 ++++++++++++++++++++++++++++++++++++++-- ddbridge/ddbridge-max.c | 36 +++- ddbridge/ddbridge-mci.c | 46 +++++ ddbridge/ddbridge-mci.h | 228 ++++++++++++++++++++----- ddbridge/ddbridge-sx8.c | 69 ++------ ddbridge/ddbridge.h | 9 - 6 files changed, 632 insertions(+), 125 deletions(-) diff --git a/ddbridge/ddbridge-m4.c b/ddbridge/ddbridge-m4.c index 75b1d7e..88f0be0 100644 --- a/ddbridge/ddbridge-m4.c +++ b/ddbridge/ddbridge-m4.c @@ -27,24 +27,376 @@ #include "ddbridge-mci.h" struct m4_base { - struct mci_base mci_base; + struct mci_base mci_base; }; struct m4 { - struct mci mci; + struct mci mci; + int started; + int t2_signalling_valid; + int iq_constellation_point; + int iq_constellation_point_max; + int iq_constellation_tap; + int first_time_lock; }; +static int stop(struct dvb_frontend *fe) +{ + struct m4 *state = fe->demodulator_priv; + struct mci_command cmd; + struct mci_base *mci_base = state->mci.base; + + if (!state->started) + return -1; + state->started = 0; + state->t2_signalling_valid = 0; + memset(&cmd, 0, sizeof(cmd)); + cmd.command = MCI_CMD_STOP; + cmd.demod = state->mci.demod; + ddb_mci_cmd(&state->mci, &cmd, NULL); + return 0; +} + +static int search_s2(struct dvb_frontend *fe) +{ + struct m4 *state = fe->demodulator_priv; + struct mci_base *mci_base = state->mci.base; + struct m4_base *m4_base = (struct m4_base *) mci_base; + struct dtv_frontend_properties *p = &fe->dtv_property_cache; + struct mci_command cmd; + int stat; + + memset(&cmd, 0, sizeof(cmd)); + cmd.command = MCI_CMD_SEARCH_DVBS; + cmd.dvbs2_search.flags = 3; + cmd.dvbs2_search.s2_modulation_mask = 3; + cmd.dvbs2_search.retry = 2; + cmd.dvbs2_search.frequency = p->frequency * 1000; + cmd.dvbs2_search.symbol_rate = p->symbol_rate; + cmd.dvbs2_search.scrambling_sequence_index = 0; //p->scrambling_sequence_index; + cmd.dvbs2_search.input_stream_id = p->stream_id; + cmd.tuner = state->mci.nr; + cmd.demod = state->mci.tuner; + cmd.output = state->mci.nr; + + stat = ddb_mci_cmd(&state->mci, &cmd, NULL); + if (stat) + stop(fe); + return stat; +} + +static int search_c(struct dvb_frontend *fe) +{ + struct m4 *state = fe->demodulator_priv; + struct mci_base *mci_base = state->mci.base; + struct m4_base *m4_base = (struct m4_base *) mci_base; + struct dtv_frontend_properties *p = &fe->dtv_property_cache; + struct mci_command cmd; + int stat; + + memset(&cmd, 0, sizeof(cmd)); + cmd.command = MCI_CMD_SEARCH_DVBC; + switch (p->bandwidth_hz) { + case 6000000: + cmd.dvbc_search.bandwidth = MCI_BANDWIDTH_6MHZ; + break; + case 7000000: + cmd.dvbc_search.bandwidth = MCI_BANDWIDTH_7MHZ; + break; + default: + cmd.dvbc_search.bandwidth = MCI_BANDWIDTH_8MHZ; + break; + } + cmd.dvbc_search.retry = 2; + cmd.dvbc_search.frequency = p->frequency; + cmd.tuner = state->mci.tuner; + cmd.demod = state->mci.demod; + cmd.output = state->mci.nr; + + stat = ddb_mci_cmd(&state->mci, &cmd, NULL); + if (stat) + stop(fe); + return stat; +} + +static int search_t(struct dvb_frontend *fe) +{ + struct m4 *state = fe->demodulator_priv; + struct mci_base *mci_base = state->mci.base; + struct m4_base *m4_base = (struct m4_base *) mci_base; + struct dtv_frontend_properties *p = &fe->dtv_property_cache; + struct mci_command cmd; + int stat; + + memset(&cmd, 0, sizeof(cmd)); + cmd.command = MCI_CMD_SEARCH_DVBT; + switch (p->bandwidth_hz) { + case 5000000: + cmd.dvbt_search.bandwidth = MCI_BANDWIDTH_5MHZ; + break; + case 6000000: + cmd.dvbt_search.bandwidth = MCI_BANDWIDTH_6MHZ; + break; + case 7000000: + cmd.dvbt_search.bandwidth = MCI_BANDWIDTH_7MHZ; + break; + default: + cmd.dvbt_search.bandwidth = MCI_BANDWIDTH_8MHZ; + break; + } + cmd.dvbt_search.retry = 2; + cmd.dvbt_search.frequency = p->frequency; + cmd.tuner = state->mci.tuner; + cmd.demod = state->mci.demod; + cmd.output = state->mci.nr; + + stat = ddb_mci_cmd(&state->mci, &cmd, NULL); + if (stat) + stop(fe); + return stat; +} + +static int search_t2(struct dvb_frontend *fe) +{ + struct m4 *state = fe->demodulator_priv; + struct mci_base *mci_base = state->mci.base; + struct m4_base *m4_base = (struct m4_base *) mci_base; + struct dtv_frontend_properties *p = &fe->dtv_property_cache; + struct mci_command cmd; + int stat; + u32 flags = 0; + + memset(&cmd, 0, sizeof(cmd)); + cmd.command = MCI_CMD_SEARCH_DVBT2; + switch (p->bandwidth_hz) { + case 1700000: + cmd.dvbt_search.bandwidth = MCI_BANDWIDTH_1_7MHZ; + break; + case 5000000: + cmd.dvbt_search.bandwidth = MCI_BANDWIDTH_5MHZ; + break; + case 6000000: + cmd.dvbt_search.bandwidth = MCI_BANDWIDTH_6MHZ; + break; + case 7000000: + cmd.dvbt_search.bandwidth = MCI_BANDWIDTH_7MHZ; + break; + default: + cmd.dvbt_search.bandwidth = MCI_BANDWIDTH_8MHZ; + break; + } + cmd.dvbt2_search.retry = 2; + cmd.dvbt2_search.frequency = p->frequency; + if (p->stream_id != NO_STREAM_ID_FILTER) { + cmd.dvbt2_search.plp = p->stream_id & 0xff; + cmd.dvbt2_search.flags |= 0x80; + cmd.dvbt2_search.flags |= (p->stream_id >> 8) & 1; + } + cmd.tuner = state->mci.tuner; + cmd.demod = state->mci.demod; + cmd.output = state->mci.nr; + + stat = ddb_mci_cmd(&state->mci, &cmd, NULL); + if (stat) + stop(fe); + return stat; +} + +static int search_c2(struct dvb_frontend *fe) +{ + struct m4 *state = fe->demodulator_priv; + struct mci_base *mci_base = state->mci.base; + struct m4_base *m4_base = (struct m4_base *) mci_base; + struct dtv_frontend_properties *p = &fe->dtv_property_cache; + struct mci_command cmd; + int stat; + u32 flags = 0; + + memset(&cmd, 0, sizeof(cmd)); + cmd.command = MCI_CMD_SEARCH_DVBC2; + switch (p->bandwidth_hz) { + case 6000000: + cmd.dvbc2_search.bandwidth = MCI_BANDWIDTH_6MHZ; + break; + default: + cmd.dvbc2_search.bandwidth = MCI_BANDWIDTH_8MHZ; + break; + } + cmd.dvbc2_search.retry = 2; + cmd.dvbc2_search.frequency = p->frequency; + if (p->stream_id != NO_STREAM_ID_FILTER) { + cmd.dvbc2_search.plp = p->stream_id & 0xff; + cmd.dvbc2_search.data_slice = (p->stream_id >> 8) & 0xff; + } + cmd.tuner = state->mci.tuner; + cmd.demod = state->mci.demod; + cmd.output = state->mci.nr; + + stat = ddb_mci_cmd(&state->mci, &cmd, NULL); + if (stat) + stop(fe); + return stat; +} + +static int search_isdbt(struct dvb_frontend *fe) +{ + struct m4 *state = fe->demodulator_priv; + struct mci_base *mci_base = state->mci.base; + struct m4_base *m4_base = (struct m4_base *) mci_base; + struct dtv_frontend_properties *p = &fe->dtv_property_cache; + struct mci_command cmd; + int stat; + u32 flags = 0; + + memset(&cmd, 0, sizeof(cmd)); + cmd.command = MCI_CMD_SEARCH_ISDBT; + switch (p->bandwidth_hz) { + case 8000000: + cmd.isdbt_search.bandwidth = MCI_BANDWIDTH_8MHZ; + break; + case 7000000: + cmd.isdbt_search.bandwidth = MCI_BANDWIDTH_7MHZ; + break; + default: + cmd.isdbt_search.bandwidth = MCI_BANDWIDTH_6MHZ; + break; + } + cmd.isdbt_search.retry = 2; + cmd.isdbt_search.frequency = p->frequency; + cmd.tuner = state->mci.tuner; + cmd.demod = state->mci.demod; + cmd.output = state->mci.nr; + + stat = ddb_mci_cmd(&state->mci, &cmd, NULL); + if (stat) + stop(fe); + return stat; +} + + +static int set_parameters(struct dvb_frontend *fe) +{ + struct m4 *state = fe->demodulator_priv; + int res; + + stop(fe); + + state->t2_signalling_valid = 0; + state->iq_constellation_point = 0; + state->iq_constellation_point_max = 0; + + state->iq_constellation_tap = 0; + switch (fe->dtv_property_cache.delivery_system) { + case SYS_DVBS: + case SYS_DVBS2: + res = search_s2(fe); + break; + case SYS_DVBC_ANNEX_A: + res = search_c(fe); + break; + case SYS_DVBT: + state->iq_constellation_tap = 5; + res = search_t(fe); + break; + case SYS_DVBT2: + res = search_t2(fe); + break; + case SYS_DVBC2: + res = search_c2(fe); + break; + case SYS_ISDBT: + res = search_isdbt(fe); + break; + default: + return -EINVAL; + } + if (!res) { + state->started = 1; + state->first_time_lock = 1; + } + return res; +} + +static int read_status(struct dvb_frontend *fe, enum fe_status *status) +{ + int stat; + struct m4 *state = fe->demodulator_priv; + struct mci_result res; + + stat = ddb_mci_get_status(&state->mci, &res); + if (stat) + return stat; + *status = 0x00; + ddb_mci_get_info(&state->mci); + ddb_mci_get_strength(fe); + if (res.status == M4_DEMOD_WAIT_SIGNAL) + *status = 0x01; + if (res.status == M4_DEMOD_LOCKED) { + *status = 0x1f; + ddb_mci_get_snr(fe); + } + return stat; +} + +static int tune(struct dvb_frontend *fe, bool re_tune, + unsigned int mode_flags, + unsigned int *delay, enum fe_status *status) +{ + int r; + + if (re_tune) { + r = set_parameters(fe); + if (r) + return r; + } + r = read_status(fe, status); + if (r) + return r; + + if (*status & FE_HAS_LOCK) + return 0; + *delay = HZ / 10; + return 0; +} + +static int sleep(struct dvb_frontend *fe) +{ + struct m4 *state = fe->demodulator_priv; + + if (state->started) + stop(fe); + return 0; +} + +static void release(struct dvb_frontend *fe) +{ + struct m4 *state = fe->demodulator_priv; + struct mci_base *mci_base = state->mci.base; + + mci_base->count--; + if (mci_base->count == 0) { + list_del(&mci_base->mci_list); + kfree(mci_base); + } + kfree(state); +} + +static int get_algo(struct dvb_frontend *fe) +{ + return DVBFE_ALGO_HW; +} + static struct dvb_frontend_ops m4_ops = { .delsys = { SYS_DVBC_ANNEX_A, SYS_DVBT, SYS_DVBT2, SYS_DVBC2, SYS_ISDBT, SYS_DVBS, SYS_DVBS2, }, .info = { .name = "M4", - .frequency_min = 47000000, /* DVB-T: 47125000 */ + .frequency_min = 950000, /* DVB-T: 47125000 */ .frequency_max = 865000000, /* DVB-C: 862000000 */ - .symbol_rate_min = 870000, - .symbol_rate_max = 11700000, + .symbol_rate_min = 100000, + .symbol_rate_max = 100000000, .frequency_stepsize = 0, .frequency_tolerance = 0, .caps = FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_32 | @@ -57,14 +409,11 @@ static struct dvb_frontend_ops m4_ops = { FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_HIERARCHY_AUTO | FE_CAN_RECOVER | FE_CAN_MUTE_TS | FE_CAN_2G_MODULATION }, -#if 0 - .get_frontend_algo = get_algo, - .tune = tune, .release = release, + .get_frontend_algo = get_algo, .read_status = read_status, - .set_input = set_input, + .tune = tune, .sleep = sleep, -#endif }; static int init(struct mci *mci) diff --git a/ddbridge/ddbridge-max.c b/ddbridge/ddbridge-max.c index 155252a..2effee7 100644 --- a/ddbridge/ddbridge-max.c +++ b/ddbridge/ddbridge-max.c @@ -60,6 +60,24 @@ static int lnb_command(struct ddb *dev, u32 link, u32 lnb, u32 cmd) return 0; } +static int max_set_input_unlocked(struct dvb_frontend *fe, int in); + +static int max_emulate_switch(struct dvb_frontend *fe, + u8 *cmd, u32 len) +{ + int input; + + if (len !=4) + return -1; + + if ((cmd[0] != 0xe0) || (cmd[1] != 0x10) || (cmd[2] != 0x39)) + return -1; + + input = cmd[3] & 3; + max_set_input_unlocked(fe, input); + return 0; +} + static int max_send_master_cmd(struct dvb_frontend *fe, struct dvb_diseqc_master_cmd *cmd) { @@ -73,6 +91,10 @@ static int max_send_master_cmd(struct dvb_frontend *fe, if (fmode == 2 || fmode == 1) return 0; + + if (fmode == 4) + max_emulate_switch(fe, cmd->msg, cmd->msg_len); + if (dvb->diseqc_send_master_cmd) dvb->diseqc_send_master_cmd(fe, cmd); @@ -181,7 +203,8 @@ static int max_set_input_unlocked(struct dvb_frontend *fe, int in) dvb->input = in; dev->link[port->lnr].lnb.voltage[dvb->input] |= obit; } - res = dvb->set_input(fe, in); + if (dvb->set_input) + res = dvb->set_input(fe, in); return res; } @@ -416,7 +439,7 @@ int ddb_fe_attach_mxl5xx(struct ddb_input *input) demod = input->nr; tuner = demod & 3; - if (fmode == 3) + if (fmode >= 3) tuner = 0; dvb->fe = dvb_attach(mxl5xx_attach, i2c, &cfg, demod, tuner); if (!dvb->fe) { @@ -456,16 +479,18 @@ int ddb_fe_attach_mci(struct ddb_input *input, u32 type) struct ddb_link *link = &dev->link[port->lnr]; int demod, tuner; struct mci_cfg cfg; - + int fm = fmode; + demod = input->nr; tuner = demod & 3; switch (type) { case DDB_TUNER_MCI_SX8: cfg = ddb_max_sx8_cfg; - if (fmode == 3) + if (fm >= 3) tuner = 0; break; case DDB_TUNER_MCI_M4: + fm = 0; cfg = ddb_max_m4_cfg; break; default: @@ -480,7 +505,7 @@ int ddb_fe_attach_mci(struct ddb_input *input, u32 type) lnb_command(dev, port->lnr, input->nr, LNB_CMD_INIT); lnb_set_voltage(dev, port->lnr, input->nr, SEC_VOLTAGE_OFF); } - ddb_lnb_init_fmode(dev, link, fmode); + ddb_lnb_init_fmode(dev, link, fm); dvb->fe->ops.set_voltage = max_set_voltage; dvb->fe->ops.enable_high_lnb_voltage = max_enable_high_lnb_voltage; @@ -494,4 +519,3 @@ int ddb_fe_attach_mci(struct ddb_input *input, u32 type) dvb->input = tuner; return 0; } - diff --git a/ddbridge/ddbridge-mci.c b/ddbridge/ddbridge-mci.c index e170556..107c776 100644 --- a/ddbridge/ddbridge-mci.c +++ b/ddbridge/ddbridge-mci.c @@ -149,6 +149,52 @@ static int ddb_mci_get_iq(struct mci *mci, u32 demod, s16 *i, s16 *q) return stat; } +int ddb_mci_get_status(struct mci *mci, struct mci_result *res) +{ + struct mci_command cmd; + + cmd.command = MCI_CMD_GETSTATUS; + cmd.demod = mci->demod; + return ddb_mci_cmd_raw(mci, &cmd, 1, res, 1); +} + +int ddb_mci_get_snr(struct dvb_frontend *fe) +{ + struct mci *mci = fe->demodulator_priv; + struct dtv_frontend_properties *p = &fe->dtv_property_cache; + + p->cnr.len = 1; + p->cnr.stat[0].scale = FE_SCALE_DECIBEL; + p->cnr.stat[0].svalue = (s64) mci-> + signal_info.dvbs2_signal_info.signal_to_noise * 10; + return 0; +} + +int ddb_mci_get_strength(struct dvb_frontend *fe) +{ + struct mci *mci = fe->demodulator_priv; + struct dtv_frontend_properties *p = &fe->dtv_property_cache; + s32 str; + + str = mci->signal_info.dvbs2_signal_info.channel_power * 10; + p->strength.len = 1; + p->strength.stat[0].scale = FE_SCALE_DECIBEL; + p->strength.stat[0].svalue = str; + return 0; +} + +int ddb_mci_get_info(struct mci *mci) +{ + int stat; + struct mci_command cmd; + + memset(&cmd, 0, sizeof(cmd)); + cmd.command = MCI_CMD_GETSIGNALINFO; + cmd.demod = mci->demod; + stat = ddb_mci_cmd(mci, &cmd, &mci->signal_info); + return stat; +} + static void mci_handler(void *priv) { struct mci_base *base = (struct mci_base *)priv; diff --git a/ddbridge/ddbridge-mci.h b/ddbridge/ddbridge-mci.h index 52a0049..7c9e3c6 100644 --- a/ddbridge/ddbridge-mci.h +++ b/ddbridge/ddbridge-mci.h @@ -97,8 +97,6 @@ #define SX8_DEMOD_IQ_MODE (1) #define SX8_DEMOD_WAIT_SIGNAL (2) #define SX8_DEMOD_WAIT_MATYPE (3) -#define SX8_DEMOD_WAIT_FEC (4) -#define SX8_DEMOD_WAIT_FEC_S1 (5) #define SX8_DEMOD_TIMEOUT (14) #define SX8_DEMOD_LOCKED (15) @@ -116,19 +114,24 @@ #define MCI_CMD_SEARCH_DVBC (0x20) #define MCI_CMD_SEARCH_DVBT (0x21) #define MCI_CMD_SEARCH_DVBT2 (0x22) +#define MCI_CMD_SEARCH_DVBC2 (0x23) +#define MCI_CMD_SEARCH_ISDBT (0x24) #define MCI_CMD_GET_IQSYMBOL (0x30) -#define MCI_BANDWIDTH_1_7MHZ (0) -#define MCI_BANDWIDTH_5MHZ (1) -#define MCI_BANDWIDTH_6MHZ (2) -#define MCI_BANDWIDTH_7MHZ (3) -#define MCI_BANDWIDTH_8MHZ (4) +#define MCI_BANDWIDTH_UNKNOWN (0) +#define MCI_BANDWIDTH_1_7MHZ (1) +#define MCI_BANDWIDTH_5MHZ (5) +#define MCI_BANDWIDTH_6MHZ (6) +#define MCI_BANDWIDTH_7MHZ (7) +#define MCI_BANDWIDTH_8MHZ (8) -#define M4_MODE_SX (2) -#define M4_MODE_C (3) -#define M4_MODE_T (4) -#define M4_MODE_T2 (5) +#define M4_MODE_DVBSX (2) +#define M4_MODE_DVBC (3) +#define M4_MODE_DVBT (4) +#define M4_MODE_DVBT2 (5) +#define M4_MODE_DVBC2 (6) +#define M4_MODE_ISDBT (7) #define SX8_CMD_INPUT_ENABLE (0x40) #define SX8_CMD_INPUT_DISABLE (0x41) @@ -138,6 +141,8 @@ #define SX8_CMD_DISABLE_IQOUTPUT (0x45) #define M4_CMD_GET_T2_L1INFO (0x50) +#define M4_CMD_GET_C2_L1P2 (0x50) +#define M4_CMD_GET_IDS (0x51) #define MCI_STATUS_OK (0x00) #define MCI_STATUS_UNSUPPORTED (0x80) @@ -175,52 +180,85 @@ struct mci_command { u32 scrambling_sequence_index; u32 frequency_range; } dvbs2_search; + struct { - uint8_t flags; - uint8_t bandwidth; - uint8_t rsvd1; - uint8_t retry; - uint32_t frequency; + u8 flags; + u8 bandwidth; + u8 rsvd1; + u8 retry; + u32 frequency; } dvbc_search; struct { - uint8_t flags; /* Bit 0: LP Stream */ - uint8_t bandwidth; - uint8_t rsvd1; - uint8_t retry; - uint32_t frequency; + u8 flags; /* Bit 0: LP Stream */ + u8 bandwidth; + u8 rsvd1; + u8 retry; + u32 frequency; } dvbt_search; struct { - uint8_t flags; /* Bit 0: T2 Lite Profile, 7: PLP, */ - uint8_t bandwidth; - uint8_t rsvd1; - uint8_t retry; - uint32_t frequency; - uint32_t reserved; - uint8_t plp; - uint8_t rsvd2[3]; + u8 flags; /* Bit 0: T2 Lite Profile, 7: PLP, */ + u8 bandwidth; + u8 rsvd1; + u8 retry; + u32 frequency; + u32 reserved; + u8 plp; + u8 rsvd2[3]; } dvbt2_search; struct { - uint8_t Tap; - uint8_t Rsvd; - uint16_t Point; + u8 flags; + u8 bandwidth; + u8 rsvd1; + u8 retry; + u32 frequency; + u32 reserved; + u8 plp; + u8 data_slice; + u8 rsvd2[2]; + } dvbc2_search; + + struct { + u8 flags; + u8 bandwidth; + u8 rsvd1; + u8 retry; + u32 frequency; + } isdbt_search; + + struct { + u8 tap; + u8 rsvd; + u16 point; } get_iq_symbol; struct { - uint8_t flags; /* Bit 0 : 0 = VTM, 1 = SCAN. Bit 1: Set Gain */ - uint8_t roll_off; - uint8_t rsvd1; - uint8_t rsvd2; - uint32_t frequency; - uint32_t symbol_rate; /* Only in VTM mode. */ - uint16_t gain; + u8 flags; /* Bit 0 : 0 = VTM, 1 = SCAN. Bit 1: Set Gain */ + u8 roll_off; + u8 rsvd1; + u8 rsvd2; + u32 frequency; + u32 symbol_rate; /* Only in VTM mode. */ + u16 gain; } sx8_start_iq; struct { - uint8_t flags; /* Bit 1:0 = STVVGLNA Gain. 0 = AGC, 1 = 0dB, 2 = Minimum, 3 = Maximum */ + u8 flags; /* Bit 1:0 = STVVGLNA Gain. 0 = AGC, 1 = 0dB, 2 = Minimum, 3 = Maximum */ } sx8_input_enable; + + struct { + u8 Offset; // Offset into list, must be multiple of 64 + u8 Select; // 0 = Slices, 1 = PLPs (C2 Only) + u8 DataSlice; // DataSlice to get PLPList (C2 Only) + } Get_IDs; + + struct { + u8 Select; // 0 = Base, 1 = DataSilce, 2 = PLP, Bit 7: Set new ID + u8 ID; // DataSliceID, PLPId + } Get_L1Info; + }; }; @@ -250,6 +288,7 @@ struct mci_result { u32 ber_numerator; /* Bit error rate: PreRS in DVB-S, PreBCH in DVB-S2X */ u32 ber_denominator; } dvbs2_signal_info; + struct { u8 modulation; u8 rsvd1[3]; @@ -260,9 +299,10 @@ struct mci_result { s16 signal_to_noise; /* SNR in dB x 100, Note: negativ values are valid in DVB-S2 */ s16 rsvd2; u32 packet_errors; /* Counter for packet errors. (set to 0 on Start command) */ - u32 ber_numerator; /* Bit error rate: PreRS in DVB-S, PreBCH in DVB-S2X */ + u32 ber_numerator; /* Bit error rate: PreRS */ u32 ber_denominator; } dvbc_signal_info; + struct { u8 tps_25_32; /* Constellation (2), Hierarchy (3), Coderate HP (3) */ u8 tps_33_39; /* Coderate LP (3), Guardinterval (2), FFT (2), 0 (1) */ @@ -274,9 +314,10 @@ struct mci_result { s16 signal_to_noise; /* SNR in dB x 100, Note: negativ values are valid in DVB-S2 */ s16 rsvd2; u32 packet_errors; /* Counter for packet errors. (set to 0 on Start command) */ - u32 ber_numerator; /* Bit error rate: PreRS in DVB-S, PreBCH in DVB-S2X */ + u32 ber_numerator; /* Bit error rate: PreRS */ u32 ber_denominator; } dvbt_signal_info; + struct { u32 rsvd0; u32 frequency; /* actual frequency in Hz */ @@ -286,9 +327,40 @@ struct mci_result { s16 signal_to_noise; /* SNR in dB x 100, Note: negativ values are valid in DVB-S2 */ s16 rsvd2; u32 packet_errors; /* Counter for packet errors. (set to 0 on Start command) */ - u32 ber_numerator; /* Bit error rate: PreRS in DVB-S, PreBCH in DVB-S2X */ + u32 ber_numerator; /* Bit error rate: PreRS */ u32 ber_denominator; } dvbt2_signal_info; + + struct { // Work in Progress + u32 rsvd0 ; // Cell Identifier + + u32 frequency; // actual frequency in Hz + u32 rsvd1; // + s16 channel_power; // channel power in dBm x 100 + s16 band_power; // band power in dBm x 100 + s16 signal_to_noise; // SNR in dB x 100, Note: negativ values are valid in DVB-S2 + s16 rsvd2; + u32 packet_errors; // Counter for packet errors. (set to 0 on Start command) + u32 ber_numerator; // Bit error rate: PreBCH + u32 ber_denominator; + } DVBC2_SignalInfo; + + struct { + u32 rsvd0; + + u32 frequency; // actual frequency in Hz + u32 rsvd1; // + s16 channel_power; // channel power in dBm x 100 + s16 band_power; // band power in dBm x 100 + s16 signal_to_noise; // SNR in dB x 100, Note: negativ values are valid in DVB-S2 + s16 rsvd2; + u32 packet_errors; // Counter for packet errors. (set to 0 on Start command) + u32 ber_numerator; // Bit error rate: PreRS + u32 ber_denominator; + + u8 tmcc_info[13]; // TMCC B20 - B121 + } isdbt_signal_info; + struct { s16 i; s16 q; @@ -299,6 +371,61 @@ struct mci_result { u8 t2_l1_post_d[19]; u8 t2_l1_post_c[19]; } dvbt2_l1_info; + + struct { + u8 NetworkID[2]; + u8 C2SystemID[2]; + u8 StartFrequency[3]; + u8 C2BandWidth[2]; + u8 GuardInterval; + u8 C2FrameLength[2]; + u8 L1P2ChangeCounter; + u8 NumDataSlices; + u8 NumNotches; + struct { + u8 Start[2]; + u8 Width[2]; + u8 Reserved3; + } NotchData[15]; + u8 ReservedTone; + u8 Reserved4[2]; // EWS 1 bit, C2_Version 4 bit, Rsvd 11 bit + } DVBC2_L1Part2; + + struct { + u8 NumIDs; + u8 Offset; + u8 IDs[64]; + } DVBC2_IDList; + + struct { + u8 SliceID; + u8 TunePosition[2]; + u8 OffsetLeft[2]; + u8 OffsetRight[2]; + u8 TIDepth; + u8 Type; + u8 FECHeaderType; + u8 ConstConf; + u8 LeftNotch; + u8 NumPLP; + u8 Reserved2; + } DVBC2_SliceInfo; + + struct { + u8 PLPID; + u8 Bundled; + u8 Type; + u8 PayloadType; + u8 GroupID; + u8 Start[2]; + u8 FEC_Type; + u8 Mod; + u8 Cod; + u8 PSISIReprocessing; + u8 TransportstreamID[2]; + u8 OrginalNetworkID[2]; + u8 Reserved1; + } DVBC2_PLPInfo; }; u32 version[4]; }; @@ -391,11 +518,26 @@ struct mci { int nr; int demod; int tuner; + + struct mci_result signal_info; +}; + +struct mci_cfg { + int type; + struct dvb_frontend_ops *fe_ops; + u32 base_size; + u32 state_size; + int (*init)(struct mci *mci); + int (*base_init)(struct mci_base *mci_base); }; int ddb_mci_cmd(struct mci *state, struct mci_command *command, struct mci_result *result); int ddb_mci_cmd_raw(struct mci *state, struct mci_command *command, u32 command_len, struct mci_result *result, u32 result_len); int ddb_mci_config(struct mci *state, u32 config); +int ddb_mci_get_status(struct mci *mci, struct mci_result *res); +int ddb_mci_get_snr(struct dvb_frontend *fe); +int ddb_mci_get_info(struct mci *mci); +int ddb_mci_get_strength(struct dvb_frontend *fe); #endif diff --git a/ddbridge/ddbridge-sx8.c b/ddbridge/ddbridge-sx8.c index ecee7da..4bd24e6 100644 --- a/ddbridge/ddbridge-sx8.c +++ b/ddbridge/ddbridge-sx8.c @@ -52,7 +52,6 @@ struct sx8 { int first_time_lock; int started; - struct mci_result signal_info; u32 bb_mode; u32 local_frequency; @@ -108,64 +107,23 @@ static void release(struct dvb_frontend *fe) kfree(state); } -static int get_info(struct dvb_frontend *fe) -{ - int stat; - struct sx8 *state = fe->demodulator_priv; - struct mci_command cmd; - - memset(&cmd, 0, sizeof(cmd)); - cmd.command = MCI_CMD_GETSIGNALINFO; - cmd.demod = state->mci.demod; - stat = ddb_mci_cmd(&state->mci, &cmd, &state->signal_info); - return stat; -} - -static int get_snr(struct dvb_frontend *fe) -{ - struct sx8 *state = fe->demodulator_priv; - struct dtv_frontend_properties *p = &fe->dtv_property_cache; - - p->cnr.len = 1; - p->cnr.stat[0].scale = FE_SCALE_DECIBEL; - p->cnr.stat[0].svalue = (s64) state->signal_info.dvbs2_signal_info.signal_to_noise * 10; - return 0; -} - -static int get_strength(struct dvb_frontend *fe) -{ - struct sx8 *state = fe->demodulator_priv; - struct dtv_frontend_properties *p = &fe->dtv_property_cache; - s32 str; - - str = state->signal_info.dvbs2_signal_info.channel_power * 10; - p->strength.len = 1; - p->strength.stat[0].scale = FE_SCALE_DECIBEL; - p->strength.stat[0].svalue = str; - return 0; -} - static int read_status(struct dvb_frontend *fe, enum fe_status *status) { int stat; struct sx8 *state = fe->demodulator_priv; - struct mci_command cmd; - u32 val; - struct mci_result *res = (struct mci_result *)&val; + struct mci_result res; - cmd.command = MCI_CMD_GETSTATUS; - cmd.demod = state->mci.demod; - stat = ddb_mci_cmd_raw(&state->mci, &cmd, 1, res, 1); + stat = ddb_mci_get_status(&state->mci, &res); if (stat) return stat; *status = 0x00; - get_info(fe); - get_strength(fe); - if (res->status == SX8_DEMOD_WAIT_MATYPE) + ddb_mci_get_info(&state->mci); + ddb_mci_get_strength(fe); + if (res.status == SX8_DEMOD_WAIT_MATYPE) *status = 0x0f; - if (res->status == SX8_DEMOD_LOCKED) { + if (res.status == SX8_DEMOD_LOCKED) { *status = 0x1f; - get_snr(fe); + ddb_mci_get_snr(fe); } return stat; } @@ -346,7 +304,8 @@ unlock: } -static int start_iq(struct dvb_frontend *fe, u32 flags, u32 roll_off, u32 ts_config) +static int start_iq(struct dvb_frontend *fe, u32 flags, + u32 roll_off, u32 ts_config) { struct sx8 *state = fe->demodulator_priv; struct mci_base *mci_base = state->mci.base; @@ -408,7 +367,7 @@ static int set_parameters(struct dvb_frontend *fe) } if (iq_mode) ts_config = (SX8_TSCONFIG_TSHEADER | SX8_TSCONFIG_MODE_IQ); - if (iq_mode < 3) { + if (iq_mode < 2) { u32 mask; switch (p->modulation) { @@ -433,14 +392,12 @@ static int set_parameters(struct dvb_frontend *fe) } stat = start(fe, 3, mask, ts_config); } else { - u32 flags = (iq_mode == 2) ? 1 : 0; - - stat = start_iq(fe, flags, 4, ts_config); + stat = start_iq(fe, iq_mode & 1, 4, ts_config); } if (!stat) { state->started = 1; state->first_time_lock = 1; - state->signal_info.status = SX8_DEMOD_WAIT_SIGNAL; + state->mci.signal_info.status = SX8_DEMOD_WAIT_SIGNAL; } return stat; } @@ -489,8 +446,6 @@ static int set_input(struct dvb_frontend *fe, int input) static int sleep(struct dvb_frontend *fe) { - struct sx8 *state = fe->demodulator_priv; - stop(fe); return 0; } diff --git a/ddbridge/ddbridge.h b/ddbridge/ddbridge.h index c9b42e9..a772fee 100644 --- a/ddbridge/ddbridge.h +++ b/ddbridge/ddbridge.h @@ -567,15 +567,6 @@ int ddb_lnb_init_fmode(struct ddb *dev, struct ddb_link *link, u32 fm); struct ddb_irq *ddb_irq_set(struct ddb *dev, u32 link, u32 nr, void (*handler)(void *), void *data); -struct mci_cfg { - int type; - struct dvb_frontend_ops *fe_ops; - u32 base_size; - u32 state_size; - int (*init)(struct mci *mci); - int (*base_init)(struct mci_base *mci_base); -}; - struct dvb_frontend *ddb_mci_attach(struct ddb_input *input, struct mci_cfg *cfg, int nr, int tuner); #endif