2 Auvitek AU8522 QAM/8VSB demodulator driver
4 Copyright (C) 2008 Steven Toth <stoth@linuxtv.org>
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 #include <linux/kernel.h>
23 #include <linux/init.h>
24 #include <linux/module.h>
25 #include <linux/string.h>
26 #include <linux/delay.h>
27 #include "dvb_frontend.h"
29 #include "au8522_priv.h"
32 static int zv_mode = 1; /* default to on */
34 #define dprintk(arg...)\
44 /* VSB SNR lookup table */
45 static struct mse2snr_tab vsb_mse2snr_tab[] = {
78 /* QAM64 SNR lookup table */
79 static struct mse2snr_tab qam64_mse2snr_tab[] = {
159 /* QAM256 SNR lookup table */
160 static struct mse2snr_tab qam256_mse2snr_tab[] = {
227 static int au8522_mse2snr_lookup(struct mse2snr_tab *tab, int sz, int mse,
230 int i, ret = -EINVAL;
231 dprintk("%s()\n", __func__);
233 for (i = 0; i < sz; i++) {
234 if (mse < tab[i].val) {
240 dprintk("%s() snr=%d\n", __func__, *snr);
244 static int au8522_set_if(struct dvb_frontend *fe, enum au8522_if_freq if_freq)
246 struct au8522_state *state = fe->demodulator_priv;
251 case AU8522_IF_3_25MHZ:
270 dprintk("%s() IF Frequency not supported\n", __func__);
273 dprintk("%s() %s MHz\n", __func__, ifmhz);
274 au8522_writereg(state, 0x00b5, r0b5);
275 au8522_writereg(state, 0x00b6, r0b6);
276 au8522_writereg(state, 0x00b7, r0b7);
281 /* VSB Modulation table */
314 /* QAM64 Modulation table */
318 } QAM64_mod_tab[] = {
393 /* QAM256 Modulation table */
397 } QAM256_mod_tab[] = {
475 } QAM256_mod_tab_zv_mode[] = {
553 static int au8522_enable_modulation(struct dvb_frontend *fe,
554 enum fe_modulation m)
556 struct au8522_state *state = fe->demodulator_priv;
559 dprintk("%s(0x%08x)\n", __func__, m);
563 dprintk("%s() VSB_8\n", __func__);
564 for (i = 0; i < ARRAY_SIZE(VSB_mod_tab); i++)
565 au8522_writereg(state,
567 VSB_mod_tab[i].data);
568 au8522_set_if(fe, state->config.vsb_if);
571 dprintk("%s() QAM 64\n", __func__);
572 for (i = 0; i < ARRAY_SIZE(QAM64_mod_tab); i++)
573 au8522_writereg(state,
574 QAM64_mod_tab[i].reg,
575 QAM64_mod_tab[i].data);
576 au8522_set_if(fe, state->config.qam_if);
580 dprintk("%s() QAM 256 (zv_mode)\n", __func__);
581 for (i = 0; i < ARRAY_SIZE(QAM256_mod_tab_zv_mode); i++)
582 au8522_writereg(state,
583 QAM256_mod_tab_zv_mode[i].reg,
584 QAM256_mod_tab_zv_mode[i].data);
585 au8522_set_if(fe, state->config.qam_if);
587 au8522_writereg(state, 0x821a, 0x00);
589 dprintk("%s() QAM 256\n", __func__);
590 for (i = 0; i < ARRAY_SIZE(QAM256_mod_tab); i++)
591 au8522_writereg(state,
592 QAM256_mod_tab[i].reg,
593 QAM256_mod_tab[i].data);
594 au8522_set_if(fe, state->config.qam_if);
598 dprintk("%s() Invalid modulation\n", __func__);
602 state->current_modulation = m;
607 /* Talk to the demod, set the FEC, GUARD, QAM settings etc */
608 static int au8522_set_frontend(struct dvb_frontend *fe)
610 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
611 struct au8522_state *state = fe->demodulator_priv;
614 dprintk("%s(frequency=%d)\n", __func__, c->frequency);
616 if ((state->current_frequency == c->frequency) &&
617 (state->current_modulation == c->modulation))
620 if (fe->ops.tuner_ops.set_params) {
621 if (fe->ops.i2c_gate_ctrl)
622 fe->ops.i2c_gate_ctrl(fe, 1);
623 ret = fe->ops.tuner_ops.set_params(fe);
624 if (fe->ops.i2c_gate_ctrl)
625 fe->ops.i2c_gate_ctrl(fe, 0);
631 /* Allow the tuner to settle */
633 dprintk("%s() increase tuner settling time for zv_mode\n",
639 au8522_enable_modulation(fe, c->modulation);
641 state->current_frequency = c->frequency;
646 static int au8522_read_status(struct dvb_frontend *fe, enum fe_status *status)
648 struct au8522_state *state = fe->demodulator_priv;
650 u32 tuner_status = 0;
654 if (state->current_modulation == VSB_8) {
655 dprintk("%s() Checking VSB_8\n", __func__);
656 reg = au8522_readreg(state, 0x0088);
657 if ((reg & 0x03) == 0x03)
658 *status |= FE_HAS_LOCK | FE_HAS_SYNC | FE_HAS_VITERBI;
660 dprintk("%s() Checking QAM\n", __func__);
661 reg = au8522_readreg(state, 0x0541);
663 *status |= FE_HAS_VITERBI;
665 *status |= FE_HAS_LOCK | FE_HAS_SYNC;
668 switch (state->config.status_mode) {
669 case AU8522_DEMODLOCKING:
670 dprintk("%s() DEMODLOCKING\n", __func__);
671 if (*status & FE_HAS_VITERBI)
672 *status |= FE_HAS_CARRIER | FE_HAS_SIGNAL;
674 case AU8522_TUNERLOCKING:
675 /* Get the tuner status */
676 dprintk("%s() TUNERLOCKING\n", __func__);
677 if (fe->ops.tuner_ops.get_status) {
678 if (fe->ops.i2c_gate_ctrl)
679 fe->ops.i2c_gate_ctrl(fe, 1);
681 fe->ops.tuner_ops.get_status(fe, &tuner_status);
683 if (fe->ops.i2c_gate_ctrl)
684 fe->ops.i2c_gate_ctrl(fe, 0);
687 *status |= FE_HAS_CARRIER | FE_HAS_SIGNAL;
690 state->fe_status = *status;
692 if (*status & FE_HAS_LOCK)
693 /* turn on LED, if it isn't on already */
694 au8522_led_ctrl(state, -1);
697 au8522_led_ctrl(state, 0);
699 dprintk("%s() status 0x%08x\n", __func__, *status);
704 static int au8522_led_status(struct au8522_state *state, const u16 *snr)
706 struct au8522_led_config *led_config = state->config.led_cfg;
710 /* bail out if we can't control an LED */
714 if (0 == (state->fe_status & FE_HAS_LOCK))
715 return au8522_led_ctrl(state, 0);
716 else if (state->current_modulation == QAM_256)
717 strong = led_config->qam256_strong;
718 else if (state->current_modulation == QAM_64)
719 strong = led_config->qam64_strong;
720 else /* (state->current_modulation == VSB_8) */
721 strong = led_config->vsb8_strong;
728 if ((state->led_state) &&
729 (((strong < *snr) ? (*snr - strong) : (strong - *snr)) <= 10))
730 /* snr didn't change enough to bother
731 * changing the color of the led */
734 return au8522_led_ctrl(state, led);
737 static int au8522_read_snr(struct dvb_frontend *fe, u16 *snr)
739 struct au8522_state *state = fe->demodulator_priv;
742 dprintk("%s()\n", __func__);
744 if (state->current_modulation == QAM_256)
745 ret = au8522_mse2snr_lookup(qam256_mse2snr_tab,
746 ARRAY_SIZE(qam256_mse2snr_tab),
747 au8522_readreg(state, 0x0522),
749 else if (state->current_modulation == QAM_64)
750 ret = au8522_mse2snr_lookup(qam64_mse2snr_tab,
751 ARRAY_SIZE(qam64_mse2snr_tab),
752 au8522_readreg(state, 0x0522),
755 ret = au8522_mse2snr_lookup(vsb_mse2snr_tab,
756 ARRAY_SIZE(vsb_mse2snr_tab),
757 au8522_readreg(state, 0x0311),
760 if (state->config.led_cfg)
761 au8522_led_status(state, snr);
766 static int au8522_read_signal_strength(struct dvb_frontend *fe,
767 u16 *signal_strength)
769 /* borrowed from lgdt330x.c
771 * Calculate strength from SNR up to 35dB
772 * Even though the SNR can go higher than 35dB,
773 * there is some comfort factor in having a range of
774 * strong signals that can show at 100%
778 int ret = au8522_read_snr(fe, &snr);
780 *signal_strength = 0;
783 /* The following calculation method was chosen
784 * purely for the sake of code re-use from the
785 * other demod drivers that use this method */
787 /* Convert from SNR in dB * 10 to 8.24 fixed-point */
788 tmp = (snr * ((1 << 24) / 10));
790 /* Convert from 8.24 fixed-point to
791 * scale the range 0 - 35*2^24 into 0 - 65535*/
792 if (tmp >= 8960 * 0x10000)
793 *signal_strength = 0xffff;
795 *signal_strength = tmp / 8960;
801 static int au8522_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
803 struct au8522_state *state = fe->demodulator_priv;
805 if (state->current_modulation == VSB_8)
806 *ucblocks = au8522_readreg(state, 0x0087);
808 *ucblocks = au8522_readreg(state, 0x0543);
813 static int au8522_read_ber(struct dvb_frontend *fe, u32 *ber)
815 return au8522_read_ucblocks(fe, ber);
818 static int au8522_get_frontend(struct dvb_frontend *fe,
819 struct dtv_frontend_properties *c)
821 struct au8522_state *state = fe->demodulator_priv;
823 c->frequency = state->current_frequency;
824 c->modulation = state->current_modulation;
829 static int au8522_get_tune_settings(struct dvb_frontend *fe,
830 struct dvb_frontend_tune_settings *tune)
832 tune->min_delay_ms = 1000;
836 static const struct dvb_frontend_ops au8522_ops;
839 static void au8522_release(struct dvb_frontend *fe)
841 struct au8522_state *state = fe->demodulator_priv;
842 au8522_release_state(state);
845 struct dvb_frontend *au8522_attach(const struct au8522_config *config,
846 struct i2c_adapter *i2c)
848 struct au8522_state *state = NULL;
851 /* allocate memory for the internal state */
852 instance = au8522_get_state(&state, i2c, config->demod_address);
855 dprintk("%s state allocation failed\n", __func__);
858 /* new demod instance */
859 dprintk("%s using new instance\n", __func__);
862 /* existing demod instance */
863 dprintk("%s using existing instance\n", __func__);
867 /* setup the state */
868 state->config = *config;
870 state->operational_mode = AU8522_DIGITAL_MODE;
872 /* create dvb_frontend */
873 memcpy(&state->frontend.ops, &au8522_ops,
874 sizeof(struct dvb_frontend_ops));
875 state->frontend.demodulator_priv = state;
877 state->frontend.ops.analog_ops.i2c_gate_ctrl = au8522_analog_i2c_gate_ctrl;
879 if (au8522_init(&state->frontend) != 0) {
880 printk(KERN_ERR "%s: Failed to initialize correctly\n",
885 /* Note: Leaving the I2C gate open here. */
886 au8522_i2c_gate_ctrl(&state->frontend, 1);
888 return &state->frontend;
891 au8522_release_state(state);
894 EXPORT_SYMBOL(au8522_attach);
896 static const struct dvb_frontend_ops au8522_ops = {
897 .delsys = { SYS_ATSC, SYS_DVBC_ANNEX_B },
899 .name = "Auvitek AU8522 QAM/8VSB Frontend",
900 .frequency_min = 54000000,
901 .frequency_max = 858000000,
902 .frequency_stepsize = 62500,
903 .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
907 .sleep = au8522_sleep,
908 .i2c_gate_ctrl = au8522_i2c_gate_ctrl,
909 .set_frontend = au8522_set_frontend,
910 .get_frontend = au8522_get_frontend,
911 .get_tune_settings = au8522_get_tune_settings,
912 .read_status = au8522_read_status,
913 .read_ber = au8522_read_ber,
914 .read_signal_strength = au8522_read_signal_strength,
915 .read_snr = au8522_read_snr,
916 .read_ucblocks = au8522_read_ucblocks,
917 .release = au8522_release,
920 module_param(debug, int, 0644);
921 MODULE_PARM_DESC(debug, "Enable verbose debug messages");
923 module_param(zv_mode, int, 0644);
924 MODULE_PARM_DESC(zv_mode, "Turn on/off ZeeVee modulator compatibility mode (default:on).\n"
925 "\t\ton - modified AU8522 QAM256 initialization.\n"
926 "\t\tProvides faster lock when using ZeeVee modulator based sources");
928 MODULE_DESCRIPTION("Auvitek AU8522 QAM-B/ATSC Demodulator driver");
929 MODULE_AUTHOR("Steven Toth");
930 MODULE_LICENSE("GPL");