Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *    Support for LG2160 - ATSC/MH
0004  *
0005  *    Copyright (C) 2010 Michael Krufky <mkrufky@linuxtv.org>
0006  */
0007 
0008 #include <linux/jiffies.h>
0009 #include <linux/dvb/frontend.h>
0010 #include "lg2160.h"
0011 
0012 static int debug;
0013 module_param(debug, int, 0644);
0014 MODULE_PARM_DESC(debug, "set debug level (info=1, reg=2 (or-able))");
0015 
0016 #define DBG_INFO 1
0017 #define DBG_REG  2
0018 
0019 #define lg_printk(kern, fmt, arg...)                    \
0020     printk(kern "%s: " fmt, __func__, ##arg)
0021 
0022 #define lg_info(fmt, arg...)    printk(KERN_INFO "lg2160: " fmt, ##arg)
0023 #define lg_warn(fmt, arg...)    lg_printk(KERN_WARNING,       fmt, ##arg)
0024 #define lg_err(fmt, arg...) lg_printk(KERN_ERR,           fmt, ##arg)
0025 #define lg_dbg(fmt, arg...) if (debug & DBG_INFO)           \
0026                 lg_printk(KERN_DEBUG,         fmt, ##arg)
0027 #define lg_reg(fmt, arg...) if (debug & DBG_REG)            \
0028                 lg_printk(KERN_DEBUG,         fmt, ##arg)
0029 
0030 #define lg_fail(ret)                            \
0031 ({                                  \
0032     int __ret;                          \
0033     __ret = (ret < 0);                      \
0034     if (__ret)                          \
0035         lg_err("error %d on line %d\n", ret, __LINE__);     \
0036     __ret;                              \
0037 })
0038 
0039 struct lg216x_state {
0040     struct i2c_adapter *i2c_adap;
0041     const struct lg2160_config *cfg;
0042 
0043     struct dvb_frontend frontend;
0044 
0045     u32 current_frequency;
0046     u8 parade_id;
0047     u8 fic_ver;
0048     unsigned int last_reset;
0049 };
0050 
0051 /* ------------------------------------------------------------------------ */
0052 
0053 static int lg216x_write_reg(struct lg216x_state *state, u16 reg, u8 val)
0054 {
0055     int ret;
0056     u8 buf[] = { reg >> 8, reg & 0xff, val };
0057     struct i2c_msg msg = {
0058         .addr = state->cfg->i2c_addr, .flags = 0,
0059         .buf = buf, .len = 3,
0060     };
0061 
0062     lg_reg("reg: 0x%04x, val: 0x%02x\n", reg, val);
0063 
0064     ret = i2c_transfer(state->i2c_adap, &msg, 1);
0065 
0066     if (ret != 1) {
0067         lg_err("error (addr %02x %02x <- %02x, err = %i)\n",
0068                msg.buf[0], msg.buf[1], msg.buf[2], ret);
0069         if (ret < 0)
0070             return ret;
0071         else
0072             return -EREMOTEIO;
0073     }
0074     return 0;
0075 }
0076 
0077 static int lg216x_read_reg(struct lg216x_state *state, u16 reg, u8 *val)
0078 {
0079     int ret;
0080     u8 reg_buf[] = { reg >> 8, reg & 0xff };
0081     struct i2c_msg msg[] = {
0082         { .addr = state->cfg->i2c_addr,
0083           .flags = 0, .buf = reg_buf, .len = 2 },
0084         { .addr = state->cfg->i2c_addr,
0085           .flags = I2C_M_RD, .buf = val, .len = 1 },
0086     };
0087 
0088     lg_reg("reg: 0x%04x\n", reg);
0089 
0090     ret = i2c_transfer(state->i2c_adap, msg, 2);
0091 
0092     if (ret != 2) {
0093         lg_err("error (addr %02x reg %04x error (ret == %i)\n",
0094                state->cfg->i2c_addr, reg, ret);
0095         if (ret < 0)
0096             return ret;
0097         else
0098             return -EREMOTEIO;
0099     }
0100     return 0;
0101 }
0102 
0103 struct lg216x_reg {
0104     u16 reg;
0105     u8 val;
0106 };
0107 
0108 static int lg216x_write_regs(struct lg216x_state *state,
0109                  struct lg216x_reg *regs, int len)
0110 {
0111     int i, ret;
0112 
0113     lg_reg("writing %d registers...\n", len);
0114 
0115     for (i = 0; i < len; i++) {
0116         ret = lg216x_write_reg(state, regs[i].reg, regs[i].val);
0117         if (lg_fail(ret))
0118             return ret;
0119     }
0120     return 0;
0121 }
0122 
0123 static int lg216x_set_reg_bit(struct lg216x_state *state,
0124                   u16 reg, int bit, int onoff)
0125 {
0126     u8 val;
0127     int ret;
0128 
0129     lg_reg("reg: 0x%04x, bit: %d, level: %d\n", reg, bit, onoff);
0130 
0131     ret = lg216x_read_reg(state, reg, &val);
0132     if (lg_fail(ret))
0133         goto fail;
0134 
0135     val &= ~(1 << bit);
0136     val |= (onoff & 1) << bit;
0137 
0138     ret = lg216x_write_reg(state, reg, val);
0139     lg_fail(ret);
0140 fail:
0141     return ret;
0142 }
0143 
0144 /* ------------------------------------------------------------------------ */
0145 
0146 static int lg216x_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
0147 {
0148     struct lg216x_state *state = fe->demodulator_priv;
0149     int ret;
0150 
0151     if (state->cfg->deny_i2c_rptr)
0152         return 0;
0153 
0154     lg_dbg("(%d)\n", enable);
0155 
0156     ret = lg216x_set_reg_bit(state, 0x0000, 0, enable ? 0 : 1);
0157 
0158     msleep(1);
0159 
0160     return ret;
0161 }
0162 
0163 static int lg216x_soft_reset(struct lg216x_state *state)
0164 {
0165     int ret;
0166 
0167     lg_dbg("\n");
0168 
0169     ret = lg216x_write_reg(state, 0x0002, 0x00);
0170     if (lg_fail(ret))
0171         goto fail;
0172 
0173     msleep(20);
0174     ret = lg216x_write_reg(state, 0x0002, 0x01);
0175     if (lg_fail(ret))
0176         goto fail;
0177 
0178     state->last_reset = jiffies_to_msecs(jiffies);
0179 fail:
0180     return ret;
0181 }
0182 
0183 static int lg216x_initialize(struct lg216x_state *state)
0184 {
0185     int ret;
0186 
0187     static struct lg216x_reg lg2160_init[] = {
0188 #if 0
0189         { .reg = 0x0015, .val = 0xe6 },
0190 #else
0191         { .reg = 0x0015, .val = 0xf7 },
0192         { .reg = 0x001b, .val = 0x52 },
0193         { .reg = 0x0208, .val = 0x00 },
0194         { .reg = 0x0209, .val = 0x82 },
0195         { .reg = 0x0210, .val = 0xf9 },
0196         { .reg = 0x020a, .val = 0x00 },
0197         { .reg = 0x020b, .val = 0x82 },
0198         { .reg = 0x020d, .val = 0x28 },
0199         { .reg = 0x020f, .val = 0x14 },
0200 #endif
0201     };
0202 
0203     static struct lg216x_reg lg2161_init[] = {
0204         { .reg = 0x0000, .val = 0x41 },
0205         { .reg = 0x0001, .val = 0xfb },
0206         { .reg = 0x0216, .val = 0x00 },
0207         { .reg = 0x0219, .val = 0x00 },
0208         { .reg = 0x021b, .val = 0x55 },
0209         { .reg = 0x0606, .val = 0x0a },
0210     };
0211 
0212     switch (state->cfg->lg_chip) {
0213     case LG2160:
0214         ret = lg216x_write_regs(state,
0215                     lg2160_init, ARRAY_SIZE(lg2160_init));
0216         break;
0217     case LG2161:
0218         ret = lg216x_write_regs(state,
0219                     lg2161_init, ARRAY_SIZE(lg2161_init));
0220         break;
0221     default:
0222         ret = -EINVAL;
0223         break;
0224     }
0225     if (lg_fail(ret))
0226         goto fail;
0227 
0228     ret = lg216x_soft_reset(state);
0229     lg_fail(ret);
0230 fail:
0231     return ret;
0232 }
0233 
0234 /* ------------------------------------------------------------------------ */
0235 
0236 static int lg216x_set_if(struct lg216x_state *state)
0237 {
0238     u8 val;
0239     int ret;
0240 
0241     lg_dbg("%d KHz\n", state->cfg->if_khz);
0242 
0243     ret = lg216x_read_reg(state, 0x0132, &val);
0244     if (lg_fail(ret))
0245         goto fail;
0246 
0247     val &= 0xfb;
0248     val |= (0 == state->cfg->if_khz) ? 0x04 : 0x00;
0249 
0250     ret = lg216x_write_reg(state, 0x0132, val);
0251     lg_fail(ret);
0252 
0253     /* if NOT zero IF, 6 MHz is the default */
0254 fail:
0255     return ret;
0256 }
0257 
0258 /* ------------------------------------------------------------------------ */
0259 
0260 static int lg2160_agc_fix(struct lg216x_state *state,
0261               int if_agc_fix, int rf_agc_fix)
0262 {
0263     u8 val;
0264     int ret;
0265 
0266     ret = lg216x_read_reg(state, 0x0100, &val);
0267     if (lg_fail(ret))
0268         goto fail;
0269 
0270     val &= 0xf3;
0271     val |= (if_agc_fix) ? 0x08 : 0x00;
0272     val |= (rf_agc_fix) ? 0x04 : 0x00;
0273 
0274     ret = lg216x_write_reg(state, 0x0100, val);
0275     lg_fail(ret);
0276 fail:
0277     return ret;
0278 }
0279 
0280 #if 0
0281 static int lg2160_agc_freeze(struct lg216x_state *state,
0282                  int if_agc_freeze, int rf_agc_freeze)
0283 {
0284     u8 val;
0285     int ret;
0286 
0287     ret = lg216x_read_reg(state, 0x0100, &val);
0288     if (lg_fail(ret))
0289         goto fail;
0290 
0291     val &= 0xcf;
0292     val |= (if_agc_freeze) ? 0x20 : 0x00;
0293     val |= (rf_agc_freeze) ? 0x10 : 0x00;
0294 
0295     ret = lg216x_write_reg(state, 0x0100, val);
0296     lg_fail(ret);
0297 fail:
0298     return ret;
0299 }
0300 #endif
0301 
0302 static int lg2160_agc_polarity(struct lg216x_state *state,
0303                    int if_agc_polarity, int rf_agc_polarity)
0304 {
0305     u8 val;
0306     int ret;
0307 
0308     ret = lg216x_read_reg(state, 0x0100, &val);
0309     if (lg_fail(ret))
0310         goto fail;
0311 
0312     val &= 0xfc;
0313     val |= (if_agc_polarity) ? 0x02 : 0x00;
0314     val |= (rf_agc_polarity) ? 0x01 : 0x00;
0315 
0316     ret = lg216x_write_reg(state, 0x0100, val);
0317     lg_fail(ret);
0318 fail:
0319     return ret;
0320 }
0321 
0322 static int lg2160_tuner_pwr_save_polarity(struct lg216x_state *state,
0323                       int polarity)
0324 {
0325     u8 val;
0326     int ret;
0327 
0328     ret = lg216x_read_reg(state, 0x0008, &val);
0329     if (lg_fail(ret))
0330         goto fail;
0331 
0332     val &= 0xfe;
0333     val |= (polarity) ? 0x01 : 0x00;
0334 
0335     ret = lg216x_write_reg(state, 0x0008, val);
0336     lg_fail(ret);
0337 fail:
0338     return ret;
0339 }
0340 
0341 static int lg2160_spectrum_polarity(struct lg216x_state *state,
0342                     int inverted)
0343 {
0344     u8 val;
0345     int ret;
0346 
0347     ret = lg216x_read_reg(state, 0x0132, &val);
0348     if (lg_fail(ret))
0349         goto fail;
0350 
0351     val &= 0xfd;
0352     val |= (inverted) ? 0x02 : 0x00;
0353 
0354     ret = lg216x_write_reg(state, 0x0132, val);
0355     lg_fail(ret);
0356 fail:
0357     return lg216x_soft_reset(state);
0358 }
0359 
0360 static int lg2160_tuner_pwr_save(struct lg216x_state *state, int onoff)
0361 {
0362     u8 val;
0363     int ret;
0364 
0365     ret = lg216x_read_reg(state, 0x0007, &val);
0366     if (lg_fail(ret))
0367         goto fail;
0368 
0369     val &= 0xbf;
0370     val |= (onoff) ? 0x40 : 0x00;
0371 
0372     ret = lg216x_write_reg(state, 0x0007, val);
0373     lg_fail(ret);
0374 fail:
0375     return ret;
0376 }
0377 
0378 static int lg216x_set_parade(struct lg216x_state *state, int id)
0379 {
0380     int ret;
0381 
0382     ret = lg216x_write_reg(state, 0x013e, id & 0x7f);
0383     if (lg_fail(ret))
0384         goto fail;
0385 
0386     state->parade_id = id & 0x7f;
0387 fail:
0388     return ret;
0389 }
0390 
0391 static int lg216x_set_ensemble(struct lg216x_state *state, int id)
0392 {
0393     int ret;
0394     u16 reg;
0395     u8 val;
0396 
0397     switch (state->cfg->lg_chip) {
0398     case LG2160:
0399         reg = 0x0400;
0400         break;
0401     case LG2161:
0402     default:
0403         reg = 0x0500;
0404         break;
0405     }
0406 
0407     ret = lg216x_read_reg(state, reg, &val);
0408     if (lg_fail(ret))
0409         goto fail;
0410 
0411     val &= 0xfe;
0412     val |= (id) ? 0x01 : 0x00;
0413 
0414     ret = lg216x_write_reg(state, reg, val);
0415     lg_fail(ret);
0416 fail:
0417     return ret;
0418 }
0419 
0420 static int lg2160_set_spi_clock(struct lg216x_state *state)
0421 {
0422     u8 val;
0423     int ret;
0424 
0425     ret = lg216x_read_reg(state, 0x0014, &val);
0426     if (lg_fail(ret))
0427         goto fail;
0428 
0429     val &= 0xf3;
0430     val |= (state->cfg->spi_clock << 2);
0431 
0432     ret = lg216x_write_reg(state, 0x0014, val);
0433     lg_fail(ret);
0434 fail:
0435     return ret;
0436 }
0437 
0438 static int lg2161_set_output_interface(struct lg216x_state *state)
0439 {
0440     u8 val;
0441     int ret;
0442 
0443     ret = lg216x_read_reg(state, 0x0014, &val);
0444     if (lg_fail(ret))
0445         goto fail;
0446 
0447     val &= ~0x07;
0448     val |= state->cfg->output_if; /* FIXME: needs sanity check */
0449 
0450     ret = lg216x_write_reg(state, 0x0014, val);
0451     lg_fail(ret);
0452 fail:
0453     return ret;
0454 }
0455 
0456 static int lg216x_enable_fic(struct lg216x_state *state, int onoff)
0457 {
0458     int ret;
0459 
0460     ret = lg216x_write_reg(state, 0x0017, 0x23);
0461     if (lg_fail(ret))
0462         goto fail;
0463 
0464     ret = lg216x_write_reg(state, 0x0016, 0xfc);
0465     if (lg_fail(ret))
0466         goto fail;
0467 
0468     switch (state->cfg->lg_chip) {
0469     case LG2160:
0470         ret = lg216x_write_reg(state, 0x0016,
0471                        0xfc | ((onoff) ? 0x02 : 0x00));
0472         break;
0473     case LG2161:
0474         ret = lg216x_write_reg(state, 0x0016, (onoff) ? 0x10 : 0x00);
0475         break;
0476     }
0477     if (lg_fail(ret))
0478         goto fail;
0479 
0480     ret = lg216x_initialize(state);
0481     if (lg_fail(ret))
0482         goto fail;
0483 
0484     if (onoff) {
0485         ret = lg216x_write_reg(state, 0x0017, 0x03);
0486         lg_fail(ret);
0487     }
0488 fail:
0489     return ret;
0490 }
0491 
0492 /* ------------------------------------------------------------------------ */
0493 
0494 static int lg216x_get_fic_version(struct lg216x_state *state, u8 *ficver)
0495 {
0496     u8 val;
0497     int ret;
0498 
0499     *ficver = 0xff; /* invalid value */
0500 
0501     ret = lg216x_read_reg(state, 0x0128, &val);
0502     if (lg_fail(ret))
0503         goto fail;
0504 
0505     *ficver = (val >> 3) & 0x1f;
0506 fail:
0507     return ret;
0508 }
0509 
0510 #if 0
0511 static int lg2160_get_parade_id(struct lg216x_state *state, u8 *id)
0512 {
0513     u8 val;
0514     int ret;
0515 
0516     *id = 0xff; /* invalid value */
0517 
0518     ret = lg216x_read_reg(state, 0x0123, &val);
0519     if (lg_fail(ret))
0520         goto fail;
0521 
0522     *id = val & 0x7f;
0523 fail:
0524     return ret;
0525 }
0526 #endif
0527 
0528 static int lg216x_get_nog(struct lg216x_state *state, u8 *nog)
0529 {
0530     u8 val;
0531     int ret;
0532 
0533     *nog = 0xff; /* invalid value */
0534 
0535     ret = lg216x_read_reg(state, 0x0124, &val);
0536     if (lg_fail(ret))
0537         goto fail;
0538 
0539     *nog = ((val >> 4) & 0x07) + 1;
0540 fail:
0541     return ret;
0542 }
0543 
0544 static int lg216x_get_tnog(struct lg216x_state *state, u8 *tnog)
0545 {
0546     u8 val;
0547     int ret;
0548 
0549     *tnog = 0xff; /* invalid value */
0550 
0551     ret = lg216x_read_reg(state, 0x0125, &val);
0552     if (lg_fail(ret))
0553         goto fail;
0554 
0555     *tnog = val & 0x1f;
0556 fail:
0557     return ret;
0558 }
0559 
0560 static int lg216x_get_sgn(struct lg216x_state *state, u8 *sgn)
0561 {
0562     u8 val;
0563     int ret;
0564 
0565     *sgn = 0xff; /* invalid value */
0566 
0567     ret = lg216x_read_reg(state, 0x0124, &val);
0568     if (lg_fail(ret))
0569         goto fail;
0570 
0571     *sgn = val & 0x0f;
0572 fail:
0573     return ret;
0574 }
0575 
0576 static int lg216x_get_prc(struct lg216x_state *state, u8 *prc)
0577 {
0578     u8 val;
0579     int ret;
0580 
0581     *prc = 0xff; /* invalid value */
0582 
0583     ret = lg216x_read_reg(state, 0x0125, &val);
0584     if (lg_fail(ret))
0585         goto fail;
0586 
0587     *prc = ((val >> 5) & 0x07) + 1;
0588 fail:
0589     return ret;
0590 }
0591 
0592 /* ------------------------------------------------------------------------ */
0593 
0594 static int lg216x_get_rs_frame_mode(struct lg216x_state *state,
0595                     enum atscmh_rs_frame_mode *rs_framemode)
0596 {
0597     u8 val;
0598     int ret;
0599 
0600     switch (state->cfg->lg_chip) {
0601     case LG2160:
0602         ret = lg216x_read_reg(state, 0x0410, &val);
0603         break;
0604     case LG2161:
0605         ret = lg216x_read_reg(state, 0x0513, &val);
0606         break;
0607     default:
0608         ret = -EINVAL;
0609     }
0610     if (lg_fail(ret))
0611         goto fail;
0612 
0613     switch ((val >> 4) & 0x03) {
0614 #if 1
0615     default:
0616 #endif
0617     case 0x00:
0618         *rs_framemode = ATSCMH_RSFRAME_PRI_ONLY;
0619         break;
0620     case 0x01:
0621         *rs_framemode = ATSCMH_RSFRAME_PRI_SEC;
0622         break;
0623 #if 0
0624     default:
0625         *rs_framemode = ATSCMH_RSFRAME_RES;
0626         break;
0627 #endif
0628     }
0629 fail:
0630     return ret;
0631 }
0632 
0633 static
0634 int lg216x_get_rs_frame_ensemble(struct lg216x_state *state,
0635                  enum atscmh_rs_frame_ensemble *rs_frame_ens)
0636 {
0637     u8 val;
0638     int ret;
0639 
0640     switch (state->cfg->lg_chip) {
0641     case LG2160:
0642         ret = lg216x_read_reg(state, 0x0400, &val);
0643         break;
0644     case LG2161:
0645         ret = lg216x_read_reg(state, 0x0500, &val);
0646         break;
0647     default:
0648         ret = -EINVAL;
0649     }
0650     if (lg_fail(ret))
0651         goto fail;
0652 
0653     val &= 0x01;
0654     *rs_frame_ens = (enum atscmh_rs_frame_ensemble) val;
0655 fail:
0656     return ret;
0657 }
0658 
0659 static int lg216x_get_rs_code_mode(struct lg216x_state *state,
0660                    enum atscmh_rs_code_mode *rs_code_pri,
0661                    enum atscmh_rs_code_mode *rs_code_sec)
0662 {
0663     u8 val;
0664     int ret;
0665 
0666     switch (state->cfg->lg_chip) {
0667     case LG2160:
0668         ret = lg216x_read_reg(state, 0x0410, &val);
0669         break;
0670     case LG2161:
0671         ret = lg216x_read_reg(state, 0x0513, &val);
0672         break;
0673     default:
0674         ret = -EINVAL;
0675     }
0676     if (lg_fail(ret))
0677         goto fail;
0678 
0679     *rs_code_pri = (enum atscmh_rs_code_mode) ((val >> 2) & 0x03);
0680     *rs_code_sec = (enum atscmh_rs_code_mode) (val & 0x03);
0681 fail:
0682     return ret;
0683 }
0684 
0685 static int lg216x_get_sccc_block_mode(struct lg216x_state *state,
0686                       enum atscmh_sccc_block_mode *sccc_block)
0687 {
0688     u8 val;
0689     int ret;
0690 
0691     switch (state->cfg->lg_chip) {
0692     case LG2160:
0693         ret = lg216x_read_reg(state, 0x0315, &val);
0694         break;
0695     case LG2161:
0696         ret = lg216x_read_reg(state, 0x0511, &val);
0697         break;
0698     default:
0699         ret = -EINVAL;
0700     }
0701     if (lg_fail(ret))
0702         goto fail;
0703 
0704     switch (val & 0x03) {
0705     case 0x00:
0706         *sccc_block = ATSCMH_SCCC_BLK_SEP;
0707         break;
0708     case 0x01:
0709         *sccc_block = ATSCMH_SCCC_BLK_COMB;
0710         break;
0711     default:
0712         *sccc_block = ATSCMH_SCCC_BLK_RES;
0713         break;
0714     }
0715 fail:
0716     return ret;
0717 }
0718 
0719 static int lg216x_get_sccc_code_mode(struct lg216x_state *state,
0720                      enum atscmh_sccc_code_mode *mode_a,
0721                      enum atscmh_sccc_code_mode *mode_b,
0722                      enum atscmh_sccc_code_mode *mode_c,
0723                      enum atscmh_sccc_code_mode *mode_d)
0724 {
0725     u8 val;
0726     int ret;
0727 
0728     switch (state->cfg->lg_chip) {
0729     case LG2160:
0730         ret = lg216x_read_reg(state, 0x0316, &val);
0731         break;
0732     case LG2161:
0733         ret = lg216x_read_reg(state, 0x0512, &val);
0734         break;
0735     default:
0736         ret = -EINVAL;
0737     }
0738     if (lg_fail(ret))
0739         goto fail;
0740 
0741     switch ((val >> 6) & 0x03) {
0742     case 0x00:
0743         *mode_a = ATSCMH_SCCC_CODE_HLF;
0744         break;
0745     case 0x01:
0746         *mode_a = ATSCMH_SCCC_CODE_QTR;
0747         break;
0748     default:
0749         *mode_a = ATSCMH_SCCC_CODE_RES;
0750         break;
0751     }
0752 
0753     switch ((val >> 4) & 0x03) {
0754     case 0x00:
0755         *mode_b = ATSCMH_SCCC_CODE_HLF;
0756         break;
0757     case 0x01:
0758         *mode_b = ATSCMH_SCCC_CODE_QTR;
0759         break;
0760     default:
0761         *mode_b = ATSCMH_SCCC_CODE_RES;
0762         break;
0763     }
0764 
0765     switch ((val >> 2) & 0x03) {
0766     case 0x00:
0767         *mode_c = ATSCMH_SCCC_CODE_HLF;
0768         break;
0769     case 0x01:
0770         *mode_c = ATSCMH_SCCC_CODE_QTR;
0771         break;
0772     default:
0773         *mode_c = ATSCMH_SCCC_CODE_RES;
0774         break;
0775     }
0776 
0777     switch (val & 0x03) {
0778     case 0x00:
0779         *mode_d = ATSCMH_SCCC_CODE_HLF;
0780         break;
0781     case 0x01:
0782         *mode_d = ATSCMH_SCCC_CODE_QTR;
0783         break;
0784     default:
0785         *mode_d = ATSCMH_SCCC_CODE_RES;
0786         break;
0787     }
0788 fail:
0789     return ret;
0790 }
0791 
0792 /* ------------------------------------------------------------------------ */
0793 
0794 #if 0
0795 static int lg216x_read_fic_err_count(struct lg216x_state *state, u8 *err)
0796 {
0797     u8 fic_err;
0798     int ret;
0799 
0800     *err = 0;
0801 
0802     switch (state->cfg->lg_chip) {
0803     case LG2160:
0804         ret = lg216x_read_reg(state, 0x0012, &fic_err);
0805         break;
0806     case LG2161:
0807         ret = lg216x_read_reg(state, 0x001e, &fic_err);
0808         break;
0809     }
0810     if (lg_fail(ret))
0811         goto fail;
0812 
0813     *err = fic_err;
0814 fail:
0815     return ret;
0816 }
0817 
0818 static int lg2160_read_crc_err_count(struct lg216x_state *state, u16 *err)
0819 {
0820     u8 crc_err1, crc_err2;
0821     int ret;
0822 
0823     *err = 0;
0824 
0825     ret = lg216x_read_reg(state, 0x0411, &crc_err1);
0826     if (lg_fail(ret))
0827         goto fail;
0828 
0829     ret = lg216x_read_reg(state, 0x0412, &crc_err2);
0830     if (lg_fail(ret))
0831         goto fail;
0832 
0833     *err = (u16)(((crc_err2 & 0x0f) << 8) | crc_err1);
0834 fail:
0835     return ret;
0836 }
0837 
0838 static int lg2161_read_crc_err_count(struct lg216x_state *state, u16 *err)
0839 {
0840     u8 crc_err;
0841     int ret;
0842 
0843     *err = 0;
0844 
0845     ret = lg216x_read_reg(state, 0x0612, &crc_err);
0846     if (lg_fail(ret))
0847         goto fail;
0848 
0849     *err = (u16)crc_err;
0850 fail:
0851     return ret;
0852 }
0853 
0854 static int lg216x_read_crc_err_count(struct lg216x_state *state, u16 *err)
0855 {
0856     int ret;
0857     switch (state->cfg->lg_chip) {
0858     case LG2160:
0859         ret = lg2160_read_crc_err_count(state, err);
0860         break;
0861     case LG2161:
0862         ret = lg2161_read_crc_err_count(state, err);
0863         break;
0864     default:
0865         ret = -EINVAL;
0866         break;
0867     }
0868     return ret;
0869 }
0870 
0871 static int lg2160_read_rs_err_count(struct lg216x_state *state, u16 *err)
0872 {
0873     u8 rs_err1, rs_err2;
0874     int ret;
0875 
0876     *err = 0;
0877 
0878     ret = lg216x_read_reg(state, 0x0413, &rs_err1);
0879     if (lg_fail(ret))
0880         goto fail;
0881 
0882     ret = lg216x_read_reg(state, 0x0414, &rs_err2);
0883     if (lg_fail(ret))
0884         goto fail;
0885 
0886     *err = (u16)(((rs_err2 & 0x0f) << 8) | rs_err1);
0887 fail:
0888     return ret;
0889 }
0890 
0891 static int lg2161_read_rs_err_count(struct lg216x_state *state, u16 *err)
0892 {
0893     u8 rs_err1, rs_err2;
0894     int ret;
0895 
0896     *err = 0;
0897 
0898     ret = lg216x_read_reg(state, 0x0613, &rs_err1);
0899     if (lg_fail(ret))
0900         goto fail;
0901 
0902     ret = lg216x_read_reg(state, 0x0614, &rs_err2);
0903     if (lg_fail(ret))
0904         goto fail;
0905 
0906     *err = (u16)((rs_err1 << 8) | rs_err2);
0907 fail:
0908     return ret;
0909 }
0910 
0911 static int lg216x_read_rs_err_count(struct lg216x_state *state, u16 *err)
0912 {
0913     int ret;
0914     switch (state->cfg->lg_chip) {
0915     case LG2160:
0916         ret = lg2160_read_rs_err_count(state, err);
0917         break;
0918     case LG2161:
0919         ret = lg2161_read_rs_err_count(state, err);
0920         break;
0921     default:
0922         ret = -EINVAL;
0923         break;
0924     }
0925     return ret;
0926 }
0927 #endif
0928 
0929 /* ------------------------------------------------------------------------ */
0930 
0931 static int lg216x_get_frontend(struct dvb_frontend *fe,
0932                    struct dtv_frontend_properties *c)
0933 {
0934     struct lg216x_state *state = fe->demodulator_priv;
0935     int ret;
0936 
0937     lg_dbg("\n");
0938 
0939     c->modulation = VSB_8;
0940     c->frequency = state->current_frequency;
0941     c->delivery_system = SYS_ATSCMH;
0942 
0943     ret = lg216x_get_fic_version(state,
0944                      &c->atscmh_fic_ver);
0945     if (lg_fail(ret))
0946         goto fail;
0947     if (state->fic_ver != c->atscmh_fic_ver) {
0948         state->fic_ver = c->atscmh_fic_ver;
0949 
0950 #if 0
0951         ret = lg2160_get_parade_id(state,
0952                 &c->atscmh_parade_id);
0953         if (lg_fail(ret))
0954             goto fail;
0955 /* #else */
0956         c->atscmh_parade_id = state->parade_id;
0957 #endif
0958         ret = lg216x_get_nog(state,
0959                      &c->atscmh_nog);
0960         if (lg_fail(ret))
0961             goto fail;
0962         ret = lg216x_get_tnog(state,
0963                       &c->atscmh_tnog);
0964         if (lg_fail(ret))
0965             goto fail;
0966         ret = lg216x_get_sgn(state,
0967                      &c->atscmh_sgn);
0968         if (lg_fail(ret))
0969             goto fail;
0970         ret = lg216x_get_prc(state,
0971                      &c->atscmh_prc);
0972         if (lg_fail(ret))
0973             goto fail;
0974 
0975         ret = lg216x_get_rs_frame_mode(state,
0976             (enum atscmh_rs_frame_mode *)
0977             &c->atscmh_rs_frame_mode);
0978         if (lg_fail(ret))
0979             goto fail;
0980         ret = lg216x_get_rs_frame_ensemble(state,
0981             (enum atscmh_rs_frame_ensemble *)
0982             &c->atscmh_rs_frame_ensemble);
0983         if (lg_fail(ret))
0984             goto fail;
0985         ret = lg216x_get_rs_code_mode(state,
0986             (enum atscmh_rs_code_mode *)
0987             &c->atscmh_rs_code_mode_pri,
0988             (enum atscmh_rs_code_mode *)
0989             &c->atscmh_rs_code_mode_sec);
0990         if (lg_fail(ret))
0991             goto fail;
0992         ret = lg216x_get_sccc_block_mode(state,
0993             (enum atscmh_sccc_block_mode *)
0994             &c->atscmh_sccc_block_mode);
0995         if (lg_fail(ret))
0996             goto fail;
0997         ret = lg216x_get_sccc_code_mode(state,
0998             (enum atscmh_sccc_code_mode *)
0999             &c->atscmh_sccc_code_mode_a,
1000             (enum atscmh_sccc_code_mode *)
1001             &c->atscmh_sccc_code_mode_b,
1002             (enum atscmh_sccc_code_mode *)
1003             &c->atscmh_sccc_code_mode_c,
1004             (enum atscmh_sccc_code_mode *)
1005             &c->atscmh_sccc_code_mode_d);
1006         if (lg_fail(ret))
1007             goto fail;
1008     }
1009 #if 0
1010     ret = lg216x_read_fic_err_count(state,
1011                 (u8 *)&c->atscmh_fic_err);
1012     if (lg_fail(ret))
1013         goto fail;
1014     ret = lg216x_read_crc_err_count(state,
1015                 &c->atscmh_crc_err);
1016     if (lg_fail(ret))
1017         goto fail;
1018     ret = lg216x_read_rs_err_count(state,
1019                 &c->atscmh_rs_err);
1020     if (lg_fail(ret))
1021         goto fail;
1022 
1023     switch (state->cfg->lg_chip) {
1024     case LG2160:
1025         if (((c->atscmh_rs_err >= 240) &&
1026              (c->atscmh_crc_err >= 240)) &&
1027             ((jiffies_to_msecs(jiffies) - state->last_reset) > 6000))
1028             ret = lg216x_soft_reset(state);
1029         break;
1030     case LG2161:
1031         /* no fix needed here (as far as we know) */
1032         ret = 0;
1033         break;
1034     }
1035     lg_fail(ret);
1036 #endif
1037 fail:
1038     return ret;
1039 }
1040 
1041 static int lg2160_set_frontend(struct dvb_frontend *fe)
1042 {
1043     struct lg216x_state *state = fe->demodulator_priv;
1044     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1045     int ret;
1046 
1047     lg_dbg("(%d)\n", fe->dtv_property_cache.frequency);
1048 
1049     if (fe->ops.tuner_ops.set_params) {
1050         ret = fe->ops.tuner_ops.set_params(fe);
1051         if (fe->ops.i2c_gate_ctrl)
1052             fe->ops.i2c_gate_ctrl(fe, 0);
1053         if (lg_fail(ret))
1054             goto fail;
1055         state->current_frequency = fe->dtv_property_cache.frequency;
1056     }
1057 
1058     ret = lg2160_agc_fix(state, 0, 0);
1059     if (lg_fail(ret))
1060         goto fail;
1061     ret = lg2160_agc_polarity(state, 0, 0);
1062     if (lg_fail(ret))
1063         goto fail;
1064     ret = lg2160_tuner_pwr_save_polarity(state, 1);
1065     if (lg_fail(ret))
1066         goto fail;
1067     ret = lg216x_set_if(state);
1068     if (lg_fail(ret))
1069         goto fail;
1070     ret = lg2160_spectrum_polarity(state, state->cfg->spectral_inversion);
1071     if (lg_fail(ret))
1072         goto fail;
1073 
1074     /* be tuned before this point */
1075     ret = lg216x_soft_reset(state);
1076     if (lg_fail(ret))
1077         goto fail;
1078 
1079     ret = lg2160_tuner_pwr_save(state, 0);
1080     if (lg_fail(ret))
1081         goto fail;
1082 
1083     switch (state->cfg->lg_chip) {
1084     case LG2160:
1085         ret = lg2160_set_spi_clock(state);
1086         if (lg_fail(ret))
1087             goto fail;
1088         break;
1089     case LG2161:
1090         ret = lg2161_set_output_interface(state);
1091         if (lg_fail(ret))
1092             goto fail;
1093         break;
1094     }
1095 
1096     ret = lg216x_set_parade(state, fe->dtv_property_cache.atscmh_parade_id);
1097     if (lg_fail(ret))
1098         goto fail;
1099 
1100     ret = lg216x_set_ensemble(state,
1101             fe->dtv_property_cache.atscmh_rs_frame_ensemble);
1102     if (lg_fail(ret))
1103         goto fail;
1104 
1105     ret = lg216x_initialize(state);
1106     if (lg_fail(ret))
1107         goto fail;
1108 
1109     ret = lg216x_enable_fic(state, 1);
1110     lg_fail(ret);
1111 
1112     lg216x_get_frontend(fe, c);
1113 fail:
1114     return ret;
1115 }
1116 
1117 /* ------------------------------------------------------------------------ */
1118 
1119 static int lg2160_read_lock_status(struct lg216x_state *state,
1120                    int *acq_lock, int *sync_lock)
1121 {
1122     u8 val;
1123     int ret;
1124 
1125     *acq_lock = 0;
1126     *sync_lock = 0;
1127 
1128     ret = lg216x_read_reg(state, 0x011b, &val);
1129     if (lg_fail(ret))
1130         goto fail;
1131 
1132     *sync_lock = (val & 0x20) ? 0 : 1;
1133     *acq_lock  = (val & 0x40) ? 0 : 1;
1134 fail:
1135     return ret;
1136 }
1137 
1138 #ifdef USE_LG2161_LOCK_BITS
1139 static int lg2161_read_lock_status(struct lg216x_state *state,
1140                    int *acq_lock, int *sync_lock)
1141 {
1142     u8 val;
1143     int ret;
1144 
1145     *acq_lock = 0;
1146     *sync_lock = 0;
1147 
1148     ret = lg216x_read_reg(state, 0x0304, &val);
1149     if (lg_fail(ret))
1150         goto fail;
1151 
1152     *sync_lock = (val & 0x80) ? 0 : 1;
1153 
1154     ret = lg216x_read_reg(state, 0x011b, &val);
1155     if (lg_fail(ret))
1156         goto fail;
1157 
1158     *acq_lock  = (val & 0x40) ? 0 : 1;
1159 fail:
1160     return ret;
1161 }
1162 #endif
1163 
1164 static int lg216x_read_lock_status(struct lg216x_state *state,
1165                    int *acq_lock, int *sync_lock)
1166 {
1167 #ifdef USE_LG2161_LOCK_BITS
1168     int ret;
1169     switch (state->cfg->lg_chip) {
1170     case LG2160:
1171         ret = lg2160_read_lock_status(state, acq_lock, sync_lock);
1172         break;
1173     case LG2161:
1174         ret = lg2161_read_lock_status(state, acq_lock, sync_lock);
1175         break;
1176     default:
1177         ret = -EINVAL;
1178         break;
1179     }
1180     return ret;
1181 #else
1182     return lg2160_read_lock_status(state, acq_lock, sync_lock);
1183 #endif
1184 }
1185 
1186 static int lg216x_read_status(struct dvb_frontend *fe, enum fe_status *status)
1187 {
1188     struct lg216x_state *state = fe->demodulator_priv;
1189     int ret, acq_lock, sync_lock;
1190 
1191     *status = 0;
1192 
1193     ret = lg216x_read_lock_status(state, &acq_lock, &sync_lock);
1194     if (lg_fail(ret))
1195         goto fail;
1196 
1197     lg_dbg("%s%s\n",
1198            acq_lock  ? "SIGNALEXIST " : "",
1199            sync_lock ? "SYNCLOCK"     : "");
1200 
1201     if (acq_lock)
1202         *status |= FE_HAS_SIGNAL;
1203     if (sync_lock)
1204         *status |= FE_HAS_SYNC;
1205 
1206     if (*status)
1207         *status |= FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_LOCK;
1208 
1209 fail:
1210     return ret;
1211 }
1212 
1213 /* ------------------------------------------------------------------------ */
1214 
1215 static int lg2160_read_snr(struct dvb_frontend *fe, u16 *snr)
1216 {
1217     struct lg216x_state *state = fe->demodulator_priv;
1218     u8 snr1, snr2;
1219     int ret;
1220 
1221     *snr = 0;
1222 
1223     ret = lg216x_read_reg(state, 0x0202, &snr1);
1224     if (lg_fail(ret))
1225         goto fail;
1226 
1227     ret = lg216x_read_reg(state, 0x0203, &snr2);
1228     if (lg_fail(ret))
1229         goto fail;
1230 
1231     if ((snr1 == 0xba) || (snr2 == 0xdf))
1232         *snr = 0;
1233     else
1234 #if 1
1235     *snr =  ((snr1 >> 4) * 100) + ((snr1 & 0x0f) * 10) + (snr2 >> 4);
1236 #else /* BCD */
1237     *snr =  (snr2 | (snr1 << 8));
1238 #endif
1239 fail:
1240     return ret;
1241 }
1242 
1243 static int lg2161_read_snr(struct dvb_frontend *fe, u16 *snr)
1244 {
1245     struct lg216x_state *state = fe->demodulator_priv;
1246     u8 snr1, snr2;
1247     int ret;
1248 
1249     *snr = 0;
1250 
1251     ret = lg216x_read_reg(state, 0x0302, &snr1);
1252     if (lg_fail(ret))
1253         goto fail;
1254 
1255     ret = lg216x_read_reg(state, 0x0303, &snr2);
1256     if (lg_fail(ret))
1257         goto fail;
1258 
1259     if ((snr1 == 0xba) || (snr2 == 0xfd))
1260         *snr = 0;
1261     else
1262 
1263     *snr =  ((snr1 >> 4) * 100) + ((snr1 & 0x0f) * 10) + (snr2 & 0x0f);
1264 fail:
1265     return ret;
1266 }
1267 
1268 static int lg216x_read_signal_strength(struct dvb_frontend *fe,
1269                        u16 *strength)
1270 {
1271 #if 0
1272     /* borrowed from lgdt330x.c
1273      *
1274      * Calculate strength from SNR up to 35dB
1275      * Even though the SNR can go higher than 35dB,
1276      * there is some comfort factor in having a range of
1277      * strong signals that can show at 100%
1278      */
1279     struct lg216x_state *state = fe->demodulator_priv;
1280     u16 snr;
1281     int ret;
1282 #endif
1283     *strength = 0;
1284 #if 0
1285     ret = fe->ops.read_snr(fe, &snr);
1286     if (lg_fail(ret))
1287         goto fail;
1288     /* Rather than use the 8.8 value snr, use state->snr which is 8.24 */
1289     /* scale the range 0 - 35*2^24 into 0 - 65535 */
1290     if (state->snr >= 8960 * 0x10000)
1291         *strength = 0xffff;
1292     else
1293         *strength = state->snr / 8960;
1294 fail:
1295     return ret;
1296 #else
1297     return 0;
1298 #endif
1299 }
1300 
1301 /* ------------------------------------------------------------------------ */
1302 
1303 static int lg216x_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
1304 {
1305 #if 0
1306     struct lg216x_state *state = fe->demodulator_priv;
1307     int ret;
1308 
1309     ret = lg216x_read_rs_err_count(state,
1310                        &fe->dtv_property_cache.atscmh_rs_err);
1311     if (lg_fail(ret))
1312         goto fail;
1313 
1314     *ucblocks = fe->dtv_property_cache.atscmh_rs_err;
1315 fail:
1316 #else
1317     *ucblocks = 0;
1318 #endif
1319     return 0;
1320 }
1321 
1322 static int lg216x_get_tune_settings(struct dvb_frontend *fe,
1323                     struct dvb_frontend_tune_settings
1324                     *fe_tune_settings)
1325 {
1326     fe_tune_settings->min_delay_ms = 500;
1327     lg_dbg("\n");
1328     return 0;
1329 }
1330 
1331 static void lg216x_release(struct dvb_frontend *fe)
1332 {
1333     struct lg216x_state *state = fe->demodulator_priv;
1334     lg_dbg("\n");
1335     kfree(state);
1336 }
1337 
1338 static const struct dvb_frontend_ops lg2160_ops = {
1339     .delsys = { SYS_ATSCMH },
1340     .info = {
1341         .name = "LG Electronics LG2160 ATSC/MH Frontend",
1342         .frequency_min_hz      =  54 * MHz,
1343         .frequency_max_hz      = 858 * MHz,
1344         .frequency_stepsize_hz = 62500,
1345     },
1346     .i2c_gate_ctrl        = lg216x_i2c_gate_ctrl,
1347 #if 0
1348     .init                 = lg216x_init,
1349     .sleep                = lg216x_sleep,
1350 #endif
1351     .set_frontend         = lg2160_set_frontend,
1352     .get_frontend         = lg216x_get_frontend,
1353     .get_tune_settings    = lg216x_get_tune_settings,
1354     .read_status          = lg216x_read_status,
1355 #if 0
1356     .read_ber             = lg216x_read_ber,
1357 #endif
1358     .read_signal_strength = lg216x_read_signal_strength,
1359     .read_snr             = lg2160_read_snr,
1360     .read_ucblocks        = lg216x_read_ucblocks,
1361     .release              = lg216x_release,
1362 };
1363 
1364 static const struct dvb_frontend_ops lg2161_ops = {
1365     .delsys = { SYS_ATSCMH },
1366     .info = {
1367         .name = "LG Electronics LG2161 ATSC/MH Frontend",
1368         .frequency_min_hz      =  54 * MHz,
1369         .frequency_max_hz      = 858 * MHz,
1370         .frequency_stepsize_hz = 62500,
1371     },
1372     .i2c_gate_ctrl        = lg216x_i2c_gate_ctrl,
1373 #if 0
1374     .init                 = lg216x_init,
1375     .sleep                = lg216x_sleep,
1376 #endif
1377     .set_frontend         = lg2160_set_frontend,
1378     .get_frontend         = lg216x_get_frontend,
1379     .get_tune_settings    = lg216x_get_tune_settings,
1380     .read_status          = lg216x_read_status,
1381 #if 0
1382     .read_ber             = lg216x_read_ber,
1383 #endif
1384     .read_signal_strength = lg216x_read_signal_strength,
1385     .read_snr             = lg2161_read_snr,
1386     .read_ucblocks        = lg216x_read_ucblocks,
1387     .release              = lg216x_release,
1388 };
1389 
1390 struct dvb_frontend *lg2160_attach(const struct lg2160_config *config,
1391                    struct i2c_adapter *i2c_adap)
1392 {
1393     struct lg216x_state *state = NULL;
1394 
1395     lg_dbg("(%d-%04x)\n",
1396            i2c_adap ? i2c_adapter_id(i2c_adap) : 0,
1397            config ? config->i2c_addr : 0);
1398 
1399     state = kzalloc(sizeof(struct lg216x_state), GFP_KERNEL);
1400     if (!state)
1401         return NULL;
1402 
1403     state->cfg = config;
1404     state->i2c_adap = i2c_adap;
1405     state->fic_ver = 0xff;
1406     state->parade_id = 0xff;
1407 
1408     switch (config->lg_chip) {
1409     default:
1410         lg_warn("invalid chip requested, defaulting to LG2160");
1411         fallthrough;
1412     case LG2160:
1413         memcpy(&state->frontend.ops, &lg2160_ops,
1414                sizeof(struct dvb_frontend_ops));
1415         break;
1416     case LG2161:
1417         memcpy(&state->frontend.ops, &lg2161_ops,
1418                sizeof(struct dvb_frontend_ops));
1419         break;
1420     }
1421 
1422     state->frontend.demodulator_priv = state;
1423     state->current_frequency = -1;
1424     /* parade 1 by default */
1425     state->frontend.dtv_property_cache.atscmh_parade_id = 1;
1426 
1427     return &state->frontend;
1428 }
1429 EXPORT_SYMBOL(lg2160_attach);
1430 
1431 MODULE_DESCRIPTION("LG Electronics LG216x ATSC/MH Demodulator Driver");
1432 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
1433 MODULE_LICENSE("GPL");
1434 MODULE_VERSION("0.3");
[ 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!