2 Auvitek AU8522 QAM/8VSB demodulator driver
4 Copyright (C) 2008 Steven Toth <stoth@hauppauge.com>
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/slab.h>
27 #include <linux/delay.h>
28 #include "dvb_frontend.h"
33 struct i2c_adapter *i2c;
35 /* configuration settings */
36 const struct au8522_config *config;
38 struct dvb_frontend frontend;
40 u32 current_frequency;
41 fe_modulation_t current_modulation;
47 #define dprintk(arg...) do { \
52 /* 16 bit registers, 8 bit values */
53 static int au8522_writereg(struct au8522_state *state, u16 reg, u8 data)
56 u8 buf [] = { reg >> 8, reg & 0xff, data };
58 struct i2c_msg msg = { .addr = state->config->demod_address,
59 .flags = 0, .buf = buf, .len = 3 };
61 ret = i2c_transfer(state->i2c, &msg, 1);
64 printk("%s: writereg error (reg == 0x%02x, val == 0x%04x, "
65 "ret == %i)\n", __func__, reg, data, ret);
67 return (ret != 1) ? -1 : 0;
70 static u8 au8522_readreg(struct au8522_state *state, u16 reg)
73 u8 b0 [] = { reg >> 8, reg & 0xff };
76 struct i2c_msg msg [] = {
77 { .addr = state->config->demod_address, .flags = 0,
78 .buf = b0, .len = 2 },
79 { .addr = state->config->demod_address, .flags = I2C_M_RD,
80 .buf = b1, .len = 1 } };
82 ret = i2c_transfer(state->i2c, msg, 2);
85 printk(KERN_ERR "%s: readreg error (ret == %i)\n",
90 static int au8522_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
92 struct au8522_state *state = fe->demodulator_priv;
94 dprintk("%s(%d)\n", __func__, enable);
97 return au8522_writereg(state, 0x106, 1);
99 return au8522_writereg(state, 0x106, 0);
107 /* VSB SNR lookup table */
108 static struct mse2snr_tab vsb_mse2snr_tab[] = {
141 /* QAM64 SNR lookup table */
142 static struct mse2snr_tab qam64_mse2snr_tab[] = {
222 /* QAM256 SNR lookup table */
223 static struct mse2snr_tab qam256_mse2snr_tab[] = {
290 static int au8522_mse2snr_lookup(struct mse2snr_tab *tab, int sz, int mse,
293 int i, ret = -EINVAL;
294 dprintk("%s()\n", __func__);
296 for (i = 0; i < sz; i++) {
297 if (mse < tab[i].val) {
303 dprintk("%s() snr=%d\n", __func__, *snr);
307 static int au8522_set_if(struct dvb_frontend *fe, enum au8522_if_freq if_freq)
309 struct au8522_state *state = fe->demodulator_priv;
314 case AU8522_IF_3_25MHZ:
333 dprintk("%s() IF Frequency not supported\n", __func__);
336 dprintk("%s() %s MHz\n", __func__, ifmhz);
337 au8522_writereg(state, 0x80b5, r0b5);
338 au8522_writereg(state, 0x80b6, r0b6);
339 au8522_writereg(state, 0x80b7, r0b7);
344 /* VSB Modulation table */
381 /* QAM Modulation table */
463 static int au8522_enable_modulation(struct dvb_frontend *fe,
466 struct au8522_state *state = fe->demodulator_priv;
469 dprintk("%s(0x%08x)\n", __func__, m);
473 dprintk("%s() VSB_8\n", __func__);
474 for (i = 0; i < ARRAY_SIZE(VSB_mod_tab); i++)
475 au8522_writereg(state,
477 VSB_mod_tab[i].data);
478 au8522_set_if(fe, state->config->vsb_if);
482 dprintk("%s() QAM 64/256\n", __func__);
483 for (i = 0; i < ARRAY_SIZE(QAM_mod_tab); i++)
484 au8522_writereg(state,
486 QAM_mod_tab[i].data);
487 au8522_set_if(fe, state->config->qam_if);
490 dprintk("%s() Invalid modulation\n", __func__);
494 state->current_modulation = m;
499 /* Talk to the demod, set the FEC, GUARD, QAM settings etc */
500 static int au8522_set_frontend(struct dvb_frontend *fe,
501 struct dvb_frontend_parameters *p)
503 struct au8522_state *state = fe->demodulator_priv;
506 dprintk("%s(frequency=%d)\n", __func__, p->frequency);
508 if ((state->current_frequency == p->frequency) &&
509 (state->current_modulation == p->u.vsb.modulation))
512 au8522_enable_modulation(fe, p->u.vsb.modulation);
514 /* Allow the demod to settle */
517 if (fe->ops.tuner_ops.set_params) {
518 if (fe->ops.i2c_gate_ctrl)
519 fe->ops.i2c_gate_ctrl(fe, 1);
520 ret = fe->ops.tuner_ops.set_params(fe, p);
521 if (fe->ops.i2c_gate_ctrl)
522 fe->ops.i2c_gate_ctrl(fe, 0);
528 state->current_frequency = p->frequency;
533 /* Reset the demod hardware and reset all of the configuration registers
534 to a default state. */
535 static int au8522_init(struct dvb_frontend *fe)
537 struct au8522_state *state = fe->demodulator_priv;
538 dprintk("%s()\n", __func__);
540 au8522_writereg(state, 0xa4, 1 << 5);
542 au8522_i2c_gate_ctrl(fe, 1);
547 static int au8522_sleep(struct dvb_frontend *fe)
549 struct au8522_state *state = fe->demodulator_priv;
550 dprintk("%s()\n", __func__);
552 state->current_frequency = 0;
557 static int au8522_read_status(struct dvb_frontend *fe, fe_status_t *status)
559 struct au8522_state *state = fe->demodulator_priv;
561 u32 tuner_status = 0;
565 if (state->current_modulation == VSB_8) {
566 dprintk("%s() Checking VSB_8\n", __func__);
567 reg = au8522_readreg(state, 0x4088);
568 if ((reg & 0x03) == 0x03)
569 *status |= FE_HAS_LOCK | FE_HAS_SYNC | FE_HAS_VITERBI;
571 dprintk("%s() Checking QAM\n", __func__);
572 reg = au8522_readreg(state, 0x4541);
574 *status |= FE_HAS_VITERBI;
576 *status |= FE_HAS_LOCK | FE_HAS_SYNC;
579 switch (state->config->status_mode) {
580 case AU8522_DEMODLOCKING:
581 dprintk("%s() DEMODLOCKING\n", __func__);
582 if (*status & FE_HAS_VITERBI)
583 *status |= FE_HAS_CARRIER | FE_HAS_SIGNAL;
585 case AU8522_TUNERLOCKING:
586 /* Get the tuner status */
587 dprintk("%s() TUNERLOCKING\n", __func__);
588 if (fe->ops.tuner_ops.get_status) {
589 if (fe->ops.i2c_gate_ctrl)
590 fe->ops.i2c_gate_ctrl(fe, 1);
592 fe->ops.tuner_ops.get_status(fe, &tuner_status);
594 if (fe->ops.i2c_gate_ctrl)
595 fe->ops.i2c_gate_ctrl(fe, 0);
598 *status |= FE_HAS_CARRIER | FE_HAS_SIGNAL;
602 dprintk("%s() status 0x%08x\n", __func__, *status);
607 static int au8522_read_snr(struct dvb_frontend *fe, u16 *snr)
609 struct au8522_state *state = fe->demodulator_priv;
612 dprintk("%s()\n", __func__);
614 if (state->current_modulation == QAM_256)
615 ret = au8522_mse2snr_lookup(qam256_mse2snr_tab,
616 ARRAY_SIZE(qam256_mse2snr_tab),
617 au8522_readreg(state, 0x4522),
619 else if (state->current_modulation == QAM_64)
620 ret = au8522_mse2snr_lookup(qam64_mse2snr_tab,
621 ARRAY_SIZE(qam64_mse2snr_tab),
622 au8522_readreg(state, 0x4522),
625 ret = au8522_mse2snr_lookup(vsb_mse2snr_tab,
626 ARRAY_SIZE(vsb_mse2snr_tab),
627 au8522_readreg(state, 0x4311),
633 static int au8522_read_signal_strength(struct dvb_frontend *fe,
634 u16 *signal_strength)
636 return au8522_read_snr(fe, signal_strength);
639 static int au8522_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
641 struct au8522_state *state = fe->demodulator_priv;
643 if (state->current_modulation == VSB_8)
644 *ucblocks = au8522_readreg(state, 0x4087);
646 *ucblocks = au8522_readreg(state, 0x4543);
651 static int au8522_read_ber(struct dvb_frontend *fe, u32 *ber)
653 return au8522_read_ucblocks(fe, ber);
656 static int au8522_get_frontend(struct dvb_frontend *fe,
657 struct dvb_frontend_parameters *p)
659 struct au8522_state *state = fe->demodulator_priv;
661 p->frequency = state->current_frequency;
662 p->u.vsb.modulation = state->current_modulation;
667 static int au8522_get_tune_settings(struct dvb_frontend *fe,
668 struct dvb_frontend_tune_settings *tune)
670 tune->min_delay_ms = 1000;
674 static void au8522_release(struct dvb_frontend *fe)
676 struct au8522_state *state = fe->demodulator_priv;
680 static struct dvb_frontend_ops au8522_ops;
682 struct dvb_frontend *au8522_attach(const struct au8522_config *config,
683 struct i2c_adapter *i2c)
685 struct au8522_state *state = NULL;
687 /* allocate memory for the internal state */
688 state = kmalloc(sizeof(struct au8522_state), GFP_KERNEL);
692 /* setup the state */
693 state->config = config;
695 /* create dvb_frontend */
696 memcpy(&state->frontend.ops, &au8522_ops,
697 sizeof(struct dvb_frontend_ops));
698 state->frontend.demodulator_priv = state;
700 if (au8522_init(&state->frontend) != 0) {
701 printk(KERN_ERR "%s: Failed to initialize correctly\n",
706 /* Note: Leaving the I2C gate open here. */
707 au8522_i2c_gate_ctrl(&state->frontend, 1);
709 return &state->frontend;
715 EXPORT_SYMBOL(au8522_attach);
717 static struct dvb_frontend_ops au8522_ops = {
720 .name = "Auvitek AU8522 QAM/8VSB Frontend",
722 .frequency_min = 54000000,
723 .frequency_max = 858000000,
724 .frequency_stepsize = 62500,
725 .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
729 .sleep = au8522_sleep,
730 .i2c_gate_ctrl = au8522_i2c_gate_ctrl,
731 .set_frontend = au8522_set_frontend,
732 .get_frontend = au8522_get_frontend,
733 .get_tune_settings = au8522_get_tune_settings,
734 .read_status = au8522_read_status,
735 .read_ber = au8522_read_ber,
736 .read_signal_strength = au8522_read_signal_strength,
737 .read_snr = au8522_read_snr,
738 .read_ucblocks = au8522_read_ucblocks,
739 .release = au8522_release,
742 module_param(debug, int, 0644);
743 MODULE_PARM_DESC(debug, "Enable verbose debug messages");
745 MODULE_DESCRIPTION("Auvitek AU8522 QAM-B/ATSC Demodulator driver");
746 MODULE_AUTHOR("Steven Toth");
747 MODULE_LICENSE("GPL");