Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Frontend driver for the GENPIX 8pks/qpsk/DCII USB2.0 DVB-S module
0004  *
0005  * Copyright (C) 2006,2007 Alan Nisota (alannisota@gmail.com)
0006  * Copyright (C) 2006,2007 Genpix Electronics (genpix@genpix-electronics.com)
0007  *
0008  * Thanks to GENPIX for the sample code used to implement this module.
0009  *
0010  * This module is based off the vp7045 and vp702x modules
0011  */
0012 
0013 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0014 
0015 #include "gp8psk-fe.h"
0016 #include <media/dvb_frontend.h>
0017 
0018 static int debug;
0019 module_param(debug, int, 0644);
0020 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
0021 
0022 #define dprintk(fmt, arg...) do {                   \
0023     if (debug)                          \
0024         printk(KERN_DEBUG pr_fmt("%s: " fmt),           \
0025                __func__, ##arg);                \
0026 } while (0)
0027 
0028 struct gp8psk_fe_state {
0029     struct dvb_frontend fe;
0030     void *priv;
0031     const struct gp8psk_fe_ops *ops;
0032     bool is_rev1;
0033     u8 lock;
0034     u16 snr;
0035     unsigned long next_status_check;
0036     unsigned long status_check_interval;
0037 };
0038 
0039 static int gp8psk_tuned_to_DCII(struct dvb_frontend *fe)
0040 {
0041     struct gp8psk_fe_state *st = fe->demodulator_priv;
0042     u8 status;
0043 
0044     st->ops->in(st->priv, GET_8PSK_CONFIG, 0, 0, &status, 1);
0045     return status & bmDCtuned;
0046 }
0047 
0048 static int gp8psk_set_tuner_mode(struct dvb_frontend *fe, int mode)
0049 {
0050     struct gp8psk_fe_state *st = fe->demodulator_priv;
0051 
0052     return st->ops->out(st->priv, SET_8PSK_CONFIG, mode, 0, NULL, 0);
0053 }
0054 
0055 static int gp8psk_fe_update_status(struct gp8psk_fe_state *st)
0056 {
0057     u8 buf[6];
0058     if (time_after(jiffies,st->next_status_check)) {
0059         st->ops->in(st->priv, GET_SIGNAL_LOCK, 0, 0, &st->lock, 1);
0060         st->ops->in(st->priv, GET_SIGNAL_STRENGTH, 0, 0, buf, 6);
0061         st->snr = (buf[1]) << 8 | buf[0];
0062         st->next_status_check = jiffies + (st->status_check_interval*HZ)/1000;
0063     }
0064     return 0;
0065 }
0066 
0067 static int gp8psk_fe_read_status(struct dvb_frontend *fe,
0068                  enum fe_status *status)
0069 {
0070     struct gp8psk_fe_state *st = fe->demodulator_priv;
0071     gp8psk_fe_update_status(st);
0072 
0073     if (st->lock)
0074         *status = FE_HAS_LOCK | FE_HAS_SYNC | FE_HAS_VITERBI | FE_HAS_SIGNAL | FE_HAS_CARRIER;
0075     else
0076         *status = 0;
0077 
0078     if (*status & FE_HAS_LOCK)
0079         st->status_check_interval = 1000;
0080     else
0081         st->status_check_interval = 100;
0082     return 0;
0083 }
0084 
0085 /* not supported by this Frontend */
0086 static int gp8psk_fe_read_ber(struct dvb_frontend* fe, u32 *ber)
0087 {
0088     (void) fe;
0089     *ber = 0;
0090     return 0;
0091 }
0092 
0093 /* not supported by this Frontend */
0094 static int gp8psk_fe_read_unc_blocks(struct dvb_frontend* fe, u32 *unc)
0095 {
0096     (void) fe;
0097     *unc = 0;
0098     return 0;
0099 }
0100 
0101 static int gp8psk_fe_read_snr(struct dvb_frontend* fe, u16 *snr)
0102 {
0103     struct gp8psk_fe_state *st = fe->demodulator_priv;
0104     gp8psk_fe_update_status(st);
0105     /* snr is reported in dBu*256 */
0106     *snr = st->snr;
0107     return 0;
0108 }
0109 
0110 static int gp8psk_fe_read_signal_strength(struct dvb_frontend* fe, u16 *strength)
0111 {
0112     struct gp8psk_fe_state *st = fe->demodulator_priv;
0113     gp8psk_fe_update_status(st);
0114     /* snr is reported in dBu*256 */
0115     /* snr / 38.4 ~= 100% strength */
0116     /* snr * 17 returns 100% strength as 65535 */
0117     if (st->snr > 0xf00)
0118         *strength = 0xffff;
0119     else
0120         *strength = (st->snr << 4) + st->snr; /* snr*17 */
0121     return 0;
0122 }
0123 
0124 static int gp8psk_fe_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings *tune)
0125 {
0126     tune->min_delay_ms = 800;
0127     return 0;
0128 }
0129 
0130 static int gp8psk_fe_set_frontend(struct dvb_frontend *fe)
0131 {
0132     struct gp8psk_fe_state *st = fe->demodulator_priv;
0133     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0134     u8 cmd[10];
0135     u32 freq = c->frequency * 1000;
0136 
0137     dprintk("%s()\n", __func__);
0138 
0139     cmd[4] = freq         & 0xff;
0140     cmd[5] = (freq >> 8)  & 0xff;
0141     cmd[6] = (freq >> 16) & 0xff;
0142     cmd[7] = (freq >> 24) & 0xff;
0143 
0144     /* backwards compatibility: DVB-S + 8-PSK were used for Turbo-FEC */
0145     if (c->delivery_system == SYS_DVBS && c->modulation == PSK_8)
0146         c->delivery_system = SYS_TURBO;
0147 
0148     switch (c->delivery_system) {
0149     case SYS_DVBS:
0150         if (c->modulation != QPSK) {
0151             dprintk("%s: unsupported modulation selected (%d)\n",
0152                 __func__, c->modulation);
0153             return -EOPNOTSUPP;
0154         }
0155         c->fec_inner = FEC_AUTO;
0156         break;
0157     case SYS_DVBS2: /* kept for backwards compatibility */
0158         dprintk("%s: DVB-S2 delivery system selected\n", __func__);
0159         break;
0160     case SYS_TURBO:
0161         dprintk("%s: Turbo-FEC delivery system selected\n", __func__);
0162         break;
0163 
0164     default:
0165         dprintk("%s: unsupported delivery system selected (%d)\n",
0166             __func__, c->delivery_system);
0167         return -EOPNOTSUPP;
0168     }
0169 
0170     cmd[0] =  c->symbol_rate        & 0xff;
0171     cmd[1] = (c->symbol_rate >>  8) & 0xff;
0172     cmd[2] = (c->symbol_rate >> 16) & 0xff;
0173     cmd[3] = (c->symbol_rate >> 24) & 0xff;
0174     switch (c->modulation) {
0175     case QPSK:
0176         if (st->is_rev1)
0177             if (gp8psk_tuned_to_DCII(fe))
0178                 st->ops->reload(st->priv);
0179         switch (c->fec_inner) {
0180         case FEC_1_2:
0181             cmd[9] = 0; break;
0182         case FEC_2_3:
0183             cmd[9] = 1; break;
0184         case FEC_3_4:
0185             cmd[9] = 2; break;
0186         case FEC_5_6:
0187             cmd[9] = 3; break;
0188         case FEC_7_8:
0189             cmd[9] = 4; break;
0190         case FEC_AUTO:
0191             cmd[9] = 5; break;
0192         default:
0193             cmd[9] = 5; break;
0194         }
0195         if (c->delivery_system == SYS_TURBO)
0196             cmd[8] = ADV_MOD_TURBO_QPSK;
0197         else
0198             cmd[8] = ADV_MOD_DVB_QPSK;
0199         break;
0200     case PSK_8: /* PSK_8 is for compatibility with DN */
0201         cmd[8] = ADV_MOD_TURBO_8PSK;
0202         switch (c->fec_inner) {
0203         case FEC_2_3:
0204             cmd[9] = 0; break;
0205         case FEC_3_4:
0206             cmd[9] = 1; break;
0207         case FEC_3_5:
0208             cmd[9] = 2; break;
0209         case FEC_5_6:
0210             cmd[9] = 3; break;
0211         case FEC_8_9:
0212             cmd[9] = 4; break;
0213         default:
0214             cmd[9] = 0; break;
0215         }
0216         break;
0217     case QAM_16: /* QAM_16 is for compatibility with DN */
0218         cmd[8] = ADV_MOD_TURBO_16QAM;
0219         cmd[9] = 0;
0220         break;
0221     default: /* Unknown modulation */
0222         dprintk("%s: unsupported modulation selected (%d)\n",
0223             __func__, c->modulation);
0224         return -EOPNOTSUPP;
0225     }
0226 
0227     if (st->is_rev1)
0228         gp8psk_set_tuner_mode(fe, 0);
0229     st->ops->out(st->priv, TUNE_8PSK, 0, 0, cmd, 10);
0230 
0231     st->lock = 0;
0232     st->next_status_check = jiffies;
0233     st->status_check_interval = 200;
0234 
0235     return 0;
0236 }
0237 
0238 static int gp8psk_fe_send_diseqc_msg (struct dvb_frontend* fe,
0239                     struct dvb_diseqc_master_cmd *m)
0240 {
0241     struct gp8psk_fe_state *st = fe->demodulator_priv;
0242 
0243     dprintk("%s\n", __func__);
0244 
0245     if (st->ops->out(st->priv, SEND_DISEQC_COMMAND, m->msg[0], 0,
0246             m->msg, m->msg_len)) {
0247         return -EINVAL;
0248     }
0249     return 0;
0250 }
0251 
0252 static int gp8psk_fe_send_diseqc_burst(struct dvb_frontend *fe,
0253                        enum fe_sec_mini_cmd burst)
0254 {
0255     struct gp8psk_fe_state *st = fe->demodulator_priv;
0256     u8 cmd;
0257 
0258     dprintk("%s\n", __func__);
0259 
0260     /* These commands are certainly wrong */
0261     cmd = (burst == SEC_MINI_A) ? 0x00 : 0x01;
0262 
0263     if (st->ops->out(st->priv, SEND_DISEQC_COMMAND, cmd, 0,
0264             &cmd, 0)) {
0265         return -EINVAL;
0266     }
0267     return 0;
0268 }
0269 
0270 static int gp8psk_fe_set_tone(struct dvb_frontend *fe,
0271                   enum fe_sec_tone_mode tone)
0272 {
0273     struct gp8psk_fe_state *st = fe->demodulator_priv;
0274 
0275     if (st->ops->out(st->priv, SET_22KHZ_TONE,
0276              (tone == SEC_TONE_ON), 0, NULL, 0)) {
0277         return -EINVAL;
0278     }
0279     return 0;
0280 }
0281 
0282 static int gp8psk_fe_set_voltage(struct dvb_frontend *fe,
0283                  enum fe_sec_voltage voltage)
0284 {
0285     struct gp8psk_fe_state *st = fe->demodulator_priv;
0286 
0287     if (st->ops->out(st->priv, SET_LNB_VOLTAGE,
0288              voltage == SEC_VOLTAGE_18, 0, NULL, 0)) {
0289         return -EINVAL;
0290     }
0291     return 0;
0292 }
0293 
0294 static int gp8psk_fe_enable_high_lnb_voltage(struct dvb_frontend* fe, long onoff)
0295 {
0296     struct gp8psk_fe_state *st = fe->demodulator_priv;
0297 
0298     return st->ops->out(st->priv, USE_EXTRA_VOLT, onoff, 0, NULL, 0);
0299 }
0300 
0301 static int gp8psk_fe_send_legacy_dish_cmd (struct dvb_frontend* fe, unsigned long sw_cmd)
0302 {
0303     struct gp8psk_fe_state *st = fe->demodulator_priv;
0304     u8 cmd = sw_cmd & 0x7f;
0305 
0306     if (st->ops->out(st->priv, SET_DN_SWITCH, cmd, 0, NULL, 0))
0307         return -EINVAL;
0308 
0309     if (st->ops->out(st->priv, SET_LNB_VOLTAGE, !!(sw_cmd & 0x80),
0310             0, NULL, 0))
0311         return -EINVAL;
0312 
0313     return 0;
0314 }
0315 
0316 static void gp8psk_fe_release(struct dvb_frontend* fe)
0317 {
0318     struct gp8psk_fe_state *st = fe->demodulator_priv;
0319 
0320     kfree(st);
0321 }
0322 
0323 static const struct dvb_frontend_ops gp8psk_fe_ops;
0324 
0325 struct dvb_frontend *gp8psk_fe_attach(const struct gp8psk_fe_ops *ops,
0326                       void *priv, bool is_rev1)
0327 {
0328     struct gp8psk_fe_state *st;
0329 
0330     if (!ops || !ops->in || !ops->out || !ops->reload) {
0331         pr_err("Error! gp8psk-fe ops not defined.\n");
0332         return NULL;
0333     }
0334 
0335     st = kzalloc(sizeof(struct gp8psk_fe_state), GFP_KERNEL);
0336     if (!st)
0337         return NULL;
0338 
0339     memcpy(&st->fe.ops, &gp8psk_fe_ops, sizeof(struct dvb_frontend_ops));
0340     st->fe.demodulator_priv = st;
0341     st->ops = ops;
0342     st->priv = priv;
0343     st->is_rev1 = is_rev1;
0344 
0345     pr_info("Frontend %sattached\n", is_rev1 ? "revision 1 " : "");
0346 
0347     return &st->fe;
0348 }
0349 EXPORT_SYMBOL_GPL(gp8psk_fe_attach);
0350 
0351 static const struct dvb_frontend_ops gp8psk_fe_ops = {
0352     .delsys = { SYS_DVBS },
0353     .info = {
0354         .name           = "Genpix DVB-S",
0355         .frequency_min_hz   =  800 * MHz,
0356         .frequency_max_hz   = 2250 * MHz,
0357         .frequency_stepsize_hz  =  100 * kHz,
0358         .symbol_rate_min        = 1000000,
0359         .symbol_rate_max        = 45000000,
0360         .symbol_rate_tolerance  = 500,  /* ppm */
0361         .caps = FE_CAN_INVERSION_AUTO |
0362             FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
0363             FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
0364             /*
0365              * FE_CAN_QAM_16 is for compatibility
0366              * (Myth incorrectly detects Turbo-QPSK as plain QAM-16)
0367              */
0368             FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_TURBO_FEC
0369     },
0370 
0371     .release = gp8psk_fe_release,
0372 
0373     .init = NULL,
0374     .sleep = NULL,
0375 
0376     .set_frontend = gp8psk_fe_set_frontend,
0377 
0378     .get_tune_settings = gp8psk_fe_get_tune_settings,
0379 
0380     .read_status = gp8psk_fe_read_status,
0381     .read_ber = gp8psk_fe_read_ber,
0382     .read_signal_strength = gp8psk_fe_read_signal_strength,
0383     .read_snr = gp8psk_fe_read_snr,
0384     .read_ucblocks = gp8psk_fe_read_unc_blocks,
0385 
0386     .diseqc_send_master_cmd = gp8psk_fe_send_diseqc_msg,
0387     .diseqc_send_burst = gp8psk_fe_send_diseqc_burst,
0388     .set_tone = gp8psk_fe_set_tone,
0389     .set_voltage = gp8psk_fe_set_voltage,
0390     .dishnetwork_send_legacy_command = gp8psk_fe_send_legacy_dish_cmd,
0391     .enable_high_lnb_voltage = gp8psk_fe_enable_high_lnb_voltage
0392 };
0393 
0394 MODULE_AUTHOR("Alan Nisota <alannisota@gamil.com>");
0395 MODULE_DESCRIPTION("Frontend Driver for Genpix DVB-S");
0396 MODULE_VERSION("1.1");
0397 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!