URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [media/] [video/] [mt20xx.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 * i2c tv tuner chip device driver
 * controls microtune tuners, mt2032 + mt2050 at the moment.
 *
 * This "mt20xx" module was split apart from the original "tuner" module.
 */
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/videodev.h>
#include "tuner-i2c.h"
#include "mt20xx.h"
 
static int debug = 0;
module_param(debug, int, 0644);
MODULE_PARM_DESC(debug, "enable verbose debug messages");
 
#define PREFIX "mt20xx "
 
/* ---------------------------------------------------------------------- */
 
static unsigned int optimize_vco  = 1;
module_param(optimize_vco,      int, 0644);
 
static unsigned int tv_antenna    = 1;
module_param(tv_antenna,        int, 0644);
 
static unsigned int radio_antenna = 0;
module_param(radio_antenna,     int, 0644);
 
/* ---------------------------------------------------------------------- */
 
#define MT2032 0x04
#define MT2030 0x06
#define MT2040 0x07
#define MT2050 0x42
 
static char *microtune_part[] = {
        [ MT2030 ] = "MT2030",
        [ MT2032 ] = "MT2032",
        [ MT2040 ] = "MT2040",
        [ MT2050 ] = "MT2050",
};
 
struct microtune_priv {
        struct tuner_i2c_props i2c_props;
 
        unsigned int xogc;
        //unsigned int radio_if2;
 
        u32 frequency;
};
 
static int microtune_release(struct dvb_frontend *fe)
{
        kfree(fe->tuner_priv);
        fe->tuner_priv = NULL;
 
        return 0;
}
 
static int microtune_get_frequency(struct dvb_frontend *fe, u32 *frequency)
{
        struct microtune_priv *priv = fe->tuner_priv;
        *frequency = priv->frequency;
        return 0;
}
 
// IsSpurInBand()?
static int mt2032_spurcheck(struct dvb_frontend *fe,
                            int f1, int f2, int spectrum_from,int spectrum_to)
{
        struct microtune_priv *priv = fe->tuner_priv;
        int n1=1,n2,f;
 
        f1=f1/1000; //scale to kHz to avoid 32bit overflows
        f2=f2/1000;
        spectrum_from/=1000;
        spectrum_to/=1000;
 
        tuner_dbg("spurcheck f1=%d f2=%d  from=%d to=%d\n",
                  f1,f2,spectrum_from,spectrum_to);
 
        do {
            n2=-n1;
            f=n1*(f1-f2);
            do {
                n2--;
                f=f-f2;
                tuner_dbg("spurtest n1=%d n2=%d ftest=%d\n",n1,n2,f);
 
                if( (f>spectrum_from) && (f<spectrum_to))
                        tuner_dbg("mt2032 spurcheck triggered: %d\n",n1);
            } while ( (f>(f2-spectrum_to)) || (n2>-5));
            n1++;
        } while (n1<5);
 
        return 1;
}
 
static int mt2032_compute_freq(struct dvb_frontend *fe,
                               unsigned int rfin,
                               unsigned int if1, unsigned int if2,
                               unsigned int spectrum_from,
                               unsigned int spectrum_to,
                               unsigned char *buf,
                               int *ret_sel,
                               unsigned int xogc) //all in Hz
{
        struct microtune_priv *priv = fe->tuner_priv;
        unsigned int fref,lo1,lo1n,lo1a,s,sel,lo1freq, desired_lo1,
                desired_lo2,lo2,lo2n,lo2a,lo2num,lo2freq;
 
        fref= 5250 *1000; //5.25MHz
        desired_lo1=rfin+if1;
 
        lo1=(2*(desired_lo1/1000)+(fref/1000)) / (2*fref/1000);
        lo1n=lo1/8;
        lo1a=lo1-(lo1n*8);
 
        s=rfin/1000/1000+1090;
 
        if(optimize_vco) {
                if(s>1890) sel=0;
                else if(s>1720) sel=1;
                else if(s>1530) sel=2;
                else if(s>1370) sel=3;
                else sel=4; // >1090
        }
        else {
                if(s>1790) sel=0; // <1958
                else if(s>1617) sel=1;
                else if(s>1449) sel=2;
                else if(s>1291) sel=3;
                else sel=4; // >1090
        }
        *ret_sel=sel;
 
        lo1freq=(lo1a+8*lo1n)*fref;
 
        tuner_dbg("mt2032: rfin=%d lo1=%d lo1n=%d lo1a=%d sel=%d, lo1freq=%d\n",
                  rfin,lo1,lo1n,lo1a,sel,lo1freq);
 
        desired_lo2=lo1freq-rfin-if2;
        lo2=(desired_lo2)/fref;
        lo2n=lo2/8;
        lo2a=lo2-(lo2n*8);
        lo2num=((desired_lo2/1000)%(fref/1000))* 3780/(fref/1000); //scale to fit in 32bit arith
        lo2freq=(lo2a+8*lo2n)*fref + lo2num*(fref/1000)/3780*1000;
 
        tuner_dbg("mt2032: rfin=%d lo2=%d lo2n=%d lo2a=%d num=%d lo2freq=%d\n",
                  rfin,lo2,lo2n,lo2a,lo2num,lo2freq);
 
        if(lo1a<0 || lo1a>7 || lo1n<17 ||lo1n>48 || lo2a<0 ||lo2a >7 ||lo2n<17 || lo2n>30) {
                tuner_info("mt2032: frequency parameters out of range: %d %d %d %d\n",
                           lo1a, lo1n, lo2a,lo2n);
                return(-1);
        }
 
        mt2032_spurcheck(fe, lo1freq, desired_lo2,  spectrum_from, spectrum_to);
        // should recalculate lo1 (one step up/down)
 
        // set up MT2032 register map for transfer over i2c
        buf[0]=lo1n-1;
        buf[1]=lo1a | (sel<<4);
        buf[2]=0x86; // LOGC
        buf[3]=0x0f; //reserved
        buf[4]=0x1f;
        buf[5]=(lo2n-1) | (lo2a<<5);
        if(rfin >400*1000*1000)
                buf[6]=0xe4;
        else
                buf[6]=0xf4; // set PKEN per rev 1.2
        buf[7]=8+xogc;
        buf[8]=0xc3; //reserved
        buf[9]=0x4e; //reserved
        buf[10]=0xec; //reserved
        buf[11]=(lo2num&0xff);
        buf[12]=(lo2num>>8) |0x80; // Lo2RST
 
        return 0;
}
 
static int mt2032_check_lo_lock(struct dvb_frontend *fe)
{
        struct microtune_priv *priv = fe->tuner_priv;
        int try,lock=0;
        unsigned char buf[2];
 
        for(try=0;try<10;try++) {
                buf[0]=0x0e;
                tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
                tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
                tuner_dbg("mt2032 Reg.E=0x%02x\n",buf[0]);
                lock=buf[0] &0x06;
 
                if (lock==6)
                        break;
 
                tuner_dbg("mt2032: pll wait 1ms for lock (0x%2x)\n",buf[0]);
                udelay(1000);
        }
        return lock;
}
 
static int mt2032_optimize_vco(struct dvb_frontend *fe,int sel,int lock)
{
        struct microtune_priv *priv = fe->tuner_priv;
        unsigned char buf[2];
        int tad1;
 
        buf[0]=0x0f;
        tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
        tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
        tuner_dbg("mt2032 Reg.F=0x%02x\n",buf[0]);
        tad1=buf[0]&0x07;
 
        if(tad1 ==0) return lock;
        if(tad1 ==1) return lock;
 
        if(tad1==2) {
                if(sel==0)
                        return lock;
                else sel--;
        }
        else {
                if(sel<4)
                        sel++;
                else
                        return lock;
        }
 
        tuner_dbg("mt2032 optimize_vco: sel=%d\n",sel);
 
        buf[0]=0x0f;
        buf[1]=sel;
        tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
        lock=mt2032_check_lo_lock(fe);
        return lock;
}
 
 
static void mt2032_set_if_freq(struct dvb_frontend *fe, unsigned int rfin,
                               unsigned int if1, unsigned int if2,
                               unsigned int from, unsigned int to)
{
        unsigned char buf[21];
        int lint_try,ret,sel,lock=0;
        struct microtune_priv *priv = fe->tuner_priv;
 
        tuner_dbg("mt2032_set_if_freq rfin=%d if1=%d if2=%d from=%d to=%d\n",
                  rfin,if1,if2,from,to);
 
        buf[0]=0;
        ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
        tuner_i2c_xfer_recv(&priv->i2c_props,buf,21);
 
        buf[0]=0;
        ret=mt2032_compute_freq(fe,rfin,if1,if2,from,to,&buf[1],&sel,priv->xogc);
        if (ret<0)
                return;
 
        // send only the relevant registers per Rev. 1.2
        buf[0]=0;
        ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,4);
        buf[5]=5;
        ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+5,4);
        buf[11]=11;
        ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+11,3);
        if(ret!=3)
                tuner_warn("i2c i/o error: rc == %d (should be 3)\n",ret);
 
        // wait for PLLs to lock (per manual), retry LINT if not.
        for(lint_try=0; lint_try<2; lint_try++) {
                lock=mt2032_check_lo_lock(fe);
 
                if(optimize_vco)
                        lock=mt2032_optimize_vco(fe,sel,lock);
                if(lock==6) break;
 
                tuner_dbg("mt2032: re-init PLLs by LINT\n");
                buf[0]=7;
                buf[1]=0x80 +8+priv->xogc; // set LINT to re-init PLLs
                tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
                mdelay(10);
                buf[1]=8+priv->xogc;
                tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
        }
 
        if (lock!=6)
                tuner_warn("MT2032 Fatal Error: PLLs didn't lock.\n");
 
        buf[0]=2;
        buf[1]=0x20; // LOGC for optimal phase noise
        ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
        if (ret!=2)
                tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret);
}
 
 
static int mt2032_set_tv_freq(struct dvb_frontend *fe,
                              struct analog_parameters *params)
{
        int if2,from,to;
 
        // signal bandwidth and picture carrier
        if (params->std & V4L2_STD_525_60) {
                // NTSC
                from = 40750*1000;
                to   = 46750*1000;
                if2  = 45750*1000;
        } else {
                // PAL
                from = 32900*1000;
                to   = 39900*1000;
                if2  = 38900*1000;
        }
 
        mt2032_set_if_freq(fe, params->frequency*62500,
                           1090*1000*1000, if2, from, to);
 
        return 0;
}
 
static int mt2032_set_radio_freq(struct dvb_frontend *fe,
                                 struct analog_parameters *params)
{
        struct microtune_priv *priv = fe->tuner_priv;
        int if2;
 
        if (params->std & V4L2_STD_525_60) {
                tuner_dbg("pinnacle ntsc\n");
                if2 = 41300 * 1000;
        } else {
                tuner_dbg("pinnacle pal\n");
                if2 = 33300 * 1000;
        }
 
        // per Manual for FM tuning: first if center freq. 1085 MHz
        mt2032_set_if_freq(fe, params->frequency * 125 / 2,
                           1085*1000*1000,if2,if2,if2);
 
        return 0;
}
 
static int mt2032_set_params(struct dvb_frontend *fe,
                             struct analog_parameters *params)
{
        struct microtune_priv *priv = fe->tuner_priv;
        int ret = -EINVAL;
 
        switch (params->mode) {
        case V4L2_TUNER_RADIO:
                ret = mt2032_set_radio_freq(fe, params);
                priv->frequency = params->frequency * 125 / 2;
                break;
        case V4L2_TUNER_ANALOG_TV:
        case V4L2_TUNER_DIGITAL_TV:
                ret = mt2032_set_tv_freq(fe, params);
                priv->frequency = params->frequency * 62500;
                break;
        }
 
        return ret;
}
 
static struct dvb_tuner_ops mt2032_tuner_ops = {
        .set_analog_params = mt2032_set_params,
        .release           = microtune_release,
        .get_frequency     = microtune_get_frequency,
};
 
// Initalization as described in "MT203x Programming Procedures", Rev 1.2, Feb.2001
static int mt2032_init(struct dvb_frontend *fe)
{
        struct microtune_priv *priv = fe->tuner_priv;
        unsigned char buf[21];
        int ret,xogc,xok=0;
 
        // Initialize Registers per spec.
        buf[1]=2; // Index to register 2
        buf[2]=0xff;
        buf[3]=0x0f;
        buf[4]=0x1f;
        ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+1,4);
 
        buf[5]=6; // Index register 6
        buf[6]=0xe4;
        buf[7]=0x8f;
        buf[8]=0xc3;
        buf[9]=0x4e;
        buf[10]=0xec;
        ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+5,6);
 
        buf[12]=13;  // Index register 13
        buf[13]=0x32;
        ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+12,2);
 
        // Adjust XOGC (register 7), wait for XOK
        xogc=7;
        do {
                tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07);
                mdelay(10);
                buf[0]=0x0e;
                tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
                tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
                xok=buf[0]&0x01;
                tuner_dbg("mt2032: xok = 0x%02x\n",xok);
                if (xok == 1) break;
 
                xogc--;
                tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07);
                if (xogc == 3) {
                        xogc=4; // min. 4 per spec
                        break;
                }
                buf[0]=0x07;
                buf[1]=0x88 + xogc;
                ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
                if (ret!=2)
                        tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret);
        } while (xok != 1 );
        priv->xogc=xogc;
 
        memcpy(&fe->ops.tuner_ops, &mt2032_tuner_ops, sizeof(struct dvb_tuner_ops));
 
        return(1);
}
 
static void mt2050_set_antenna(struct dvb_frontend *fe, unsigned char antenna)
{
        struct microtune_priv *priv = fe->tuner_priv;
        unsigned char buf[2];
        int ret;
 
        buf[0] = 6;
        buf[1] = antenna ? 0x11 : 0x10;
        ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
        tuner_dbg("mt2050: enabled antenna connector %d\n", antenna);
}
 
static void mt2050_set_if_freq(struct dvb_frontend *fe,unsigned int freq, unsigned int if2)
{
        struct microtune_priv *priv = fe->tuner_priv;
        unsigned int if1=1218*1000*1000;
        unsigned int f_lo1,f_lo2,lo1,lo2,f_lo1_modulo,f_lo2_modulo,num1,num2,div1a,div1b,div2a,div2b;
        int ret;
        unsigned char buf[6];
 
        tuner_dbg("mt2050_set_if_freq freq=%d if1=%d if2=%d\n",
                  freq,if1,if2);
 
        f_lo1=freq+if1;
        f_lo1=(f_lo1/1000000)*1000000;
 
        f_lo2=f_lo1-freq-if2;
        f_lo2=(f_lo2/50000)*50000;
 
        lo1=f_lo1/4000000;
        lo2=f_lo2/4000000;
 
        f_lo1_modulo= f_lo1-(lo1*4000000);
        f_lo2_modulo= f_lo2-(lo2*4000000);
 
        num1=4*f_lo1_modulo/4000000;
        num2=4096*(f_lo2_modulo/1000)/4000;
 
        // todo spurchecks
 
        div1a=(lo1/12)-1;
        div1b=lo1-(div1a+1)*12;
 
        div2a=(lo2/8)-1;
        div2b=lo2-(div2a+1)*8;
 
        if (debug > 1) {
                tuner_dbg("lo1 lo2 = %d %d\n", lo1, lo2);
                tuner_dbg("num1 num2 div1a div1b div2a div2b= %x %x %x %x %x %x\n",
                          num1,num2,div1a,div1b,div2a,div2b);
        }
 
        buf[0]=1;
        buf[1]= 4*div1b + num1;
        if(freq<275*1000*1000) buf[1] = buf[1]|0x80;
 
        buf[2]=div1a;
        buf[3]=32*div2b + num2/256;
        buf[4]=num2-(num2/256)*256;
        buf[5]=div2a;
        if(num2!=0) buf[5]=buf[5]|0x40;
 
        if (debug > 1) {
                int i;
                tuner_dbg("bufs is: ");
                for(i=0;i<6;i++)
                        printk("%x ",buf[i]);
                printk("\n");
        }
 
        ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,6);
        if (ret!=6)
                tuner_warn("i2c i/o error: rc == %d (should be 6)\n",ret);
}
 
static int mt2050_set_tv_freq(struct dvb_frontend *fe,
                              struct analog_parameters *params)
{
        unsigned int if2;
 
        if (params->std & V4L2_STD_525_60) {
                // NTSC
                if2 = 45750*1000;
        } else {
                // PAL
                if2 = 38900*1000;
        }
        if (V4L2_TUNER_DIGITAL_TV == params->mode) {
                // DVB (pinnacle 300i)
                if2 = 36150*1000;
        }
        mt2050_set_if_freq(fe, params->frequency*62500, if2);
        mt2050_set_antenna(fe, tv_antenna);
 
        return 0;
}
 
static int mt2050_set_radio_freq(struct dvb_frontend *fe,
                                 struct analog_parameters *params)
{
        struct microtune_priv *priv = fe->tuner_priv;
        int if2;
 
        if (params->std & V4L2_STD_525_60) {
                tuner_dbg("pinnacle ntsc\n");
                if2 = 41300 * 1000;
        } else {
                tuner_dbg("pinnacle pal\n");
                if2 = 33300 * 1000;
        }
 
        mt2050_set_if_freq(fe, params->frequency * 125 / 2, if2);
        mt2050_set_antenna(fe, radio_antenna);
 
        return 0;
}
 
static int mt2050_set_params(struct dvb_frontend *fe,
                             struct analog_parameters *params)
{
        struct microtune_priv *priv = fe->tuner_priv;
        int ret = -EINVAL;
 
        switch (params->mode) {
        case V4L2_TUNER_RADIO:
                ret = mt2050_set_radio_freq(fe, params);
                priv->frequency = params->frequency * 125 / 2;
                break;
        case V4L2_TUNER_ANALOG_TV:
        case V4L2_TUNER_DIGITAL_TV:
                ret = mt2050_set_tv_freq(fe, params);
                priv->frequency = params->frequency * 62500;
                break;
        }
 
        return ret;
}
 
static struct dvb_tuner_ops mt2050_tuner_ops = {
        .set_analog_params = mt2050_set_params,
        .release           = microtune_release,
        .get_frequency     = microtune_get_frequency,
};
 
static int mt2050_init(struct dvb_frontend *fe)
{
        struct microtune_priv *priv = fe->tuner_priv;
        unsigned char buf[2];
        int ret;
 
        buf[0]=6;
        buf[1]=0x10;
        ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2); //  power
 
        buf[0]=0x0f;
        buf[1]=0x0f;
        ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2); // m1lo
 
        buf[0]=0x0d;
        ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
        tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
 
        tuner_dbg("mt2050: sro is %x\n",buf[0]);
 
        memcpy(&fe->ops.tuner_ops, &mt2050_tuner_ops, sizeof(struct dvb_tuner_ops));
 
        return 0;
}
 
struct dvb_frontend *microtune_attach(struct dvb_frontend *fe,
                                      struct i2c_adapter* i2c_adap,
                                      u8 i2c_addr)
{
        struct microtune_priv *priv = NULL;
        char *name;
        unsigned char buf[21];
        int company_code;
 
        priv = kzalloc(sizeof(struct microtune_priv), GFP_KERNEL);
        if (priv == NULL)
                return NULL;
        fe->tuner_priv = priv;
 
        priv->i2c_props.addr = i2c_addr;
        priv->i2c_props.adap = i2c_adap;
 
        //priv->radio_if2 = 10700 * 1000;       /* 10.7MHz - FM radio */
 
        memset(buf,0,sizeof(buf));
 
        name = "unknown";
 
        tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
        tuner_i2c_xfer_recv(&priv->i2c_props,buf,21);
        if (debug) {
                int i;
                tuner_dbg("MT20xx hexdump:");
                for(i=0;i<21;i++) {
                        printk(" %02x",buf[i]);
                        if(((i+1)%8)==0) printk(" ");
                }
                printk("\n");
        }
        company_code = buf[0x11] << 8 | buf[0x12];
        tuner_info("microtune: companycode=%04x part=%02x rev=%02x\n",
                   company_code,buf[0x13],buf[0x14]);
 
 
        if (buf[0x13] < ARRAY_SIZE(microtune_part) &&
            NULL != microtune_part[buf[0x13]])
                name = microtune_part[buf[0x13]];
        switch (buf[0x13]) {
        case MT2032:
                mt2032_init(fe);
                break;
        case MT2050:
                mt2050_init(fe);
                break;
        default:
                tuner_info("microtune %s found, not (yet?) supported, sorry :-/\n",
                           name);
                return 0;
        }
 
        strlcpy(fe->ops.tuner_ops.info.name, name,
                sizeof(fe->ops.tuner_ops.info.name));
        tuner_info("microtune %s found, OK\n",name);
        return fe;
}
 
EXPORT_SYMBOL_GPL(microtune_attach);
 
MODULE_DESCRIPTION("Microtune tuner driver");
MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
MODULE_LICENSE("GPL");
 
/*
 * Overrides for Emacs so that we follow Linus's tabbing style.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-basic-offset: 8
 * End:
 */

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [media/] [video/] [mt20xx.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* i2c tv tuner chip device driver`
3			`* controls microtune tuners, mt2032 + mt2050 at the moment.`
4			`*`
5			`* This "mt20xx" module was split apart from the original "tuner" module.`
6			`*/`
7			`#include <linux/delay.h>`
8			`#include <linux/i2c.h>`
9			`#include <linux/videodev.h>`
10			`#include "tuner-i2c.h"`
11			`#include "mt20xx.h"`
12
13			`static int debug = 0;`
14			`module_param(debug, int, 0644);`
15			`MODULE_PARM_DESC(debug, "enable verbose debug messages");`
16
17			`#define PREFIX "mt20xx "`
18
19			`/* ---------------------------------------------------------------------- */`
20
21			`static unsigned int optimize_vco = 1;`
22			`module_param(optimize_vco, int, 0644);`
23
24			`static unsigned int tv_antenna = 1;`
25			`module_param(tv_antenna, int, 0644);`
26
27			`static unsigned int radio_antenna = 0;`
28			`module_param(radio_antenna, int, 0644);`
29
30			`/* ---------------------------------------------------------------------- */`
31
32			`#define MT2032 0x04`
33			`#define MT2030 0x06`
34			`#define MT2040 0x07`
35			`#define MT2050 0x42`
36
37			`static char *microtune_part[] = {`
38			`[ MT2030 ] = "MT2030",`
39			`[ MT2032 ] = "MT2032",`
40			`[ MT2040 ] = "MT2040",`
41			`[ MT2050 ] = "MT2050",`
42			`};`
43
44			`struct microtune_priv {`
45			`struct tuner_i2c_props i2c_props;`
46
47			`unsigned int xogc;`
48			`//unsigned int radio_if2;`
49
50			`u32 frequency;`
51			`};`
52
53			`static int microtune_release(struct dvb_frontend *fe)`
54			`{`
55			`kfree(fe->tuner_priv);`
56			`fe->tuner_priv = NULL;`
57
58			`return 0;`
59			`}`
60
61			`static int microtune_get_frequency(struct dvb_frontend fe, u32 frequency)`
62			`{`
63			`struct microtune_priv *priv = fe->tuner_priv;`
64			`*frequency = priv->frequency;`
65			`return 0;`
66			`}`
67
68			`// IsSpurInBand()?`
69			`static int mt2032_spurcheck(struct dvb_frontend *fe,`
70			`int f1, int f2, int spectrum_from,int spectrum_to)`
71			`{`
72			`struct microtune_priv *priv = fe->tuner_priv;`
73			`int n1=1,n2,f;`
74
75			`f1=f1/1000; //scale to kHz to avoid 32bit overflows`
76			`f2=f2/1000;`
77			`spectrum_from/=1000;`
78			`spectrum_to/=1000;`
79
80			`tuner_dbg("spurcheck f1=%d f2=%d from=%d to=%d\n",`
81			`f1,f2,spectrum_from,spectrum_to);`
82
83			`do {`
84			`n2=-n1;`
85			`f=n1*(f1-f2);`
86			`do {`
87			`n2--;`
88			`f=f-f2;`
89			`tuner_dbg("spurtest n1=%d n2=%d ftest=%d\n",n1,n2,f);`
90
91			`if( (f>spectrum_from) && (f<spectrum_to))`
92			`tuner_dbg("mt2032 spurcheck triggered: %d\n",n1);`
93			`} while ( (f>(f2-spectrum_to)) \|\| (n2>-5));`
94			`n1++;`
95			`} while (n1<5);`
96
97			`return 1;`
98			`}`
99
100			`static int mt2032_compute_freq(struct dvb_frontend *fe,`
101			`unsigned int rfin,`
102			`unsigned int if1, unsigned int if2,`
103			`unsigned int spectrum_from,`
104			`unsigned int spectrum_to,`
105			`unsigned char *buf,`
106			`int *ret_sel,`
107			`unsigned int xogc) //all in Hz`
108			`{`
109			`struct microtune_priv *priv = fe->tuner_priv;`
110			`unsigned int fref,lo1,lo1n,lo1a,s,sel,lo1freq, desired_lo1,`
111			`desired_lo2,lo2,lo2n,lo2a,lo2num,lo2freq;`
112
113			`fref= 5250 *1000; //5.25MHz`
114			`desired_lo1=rfin+if1;`
115
116			`lo1=(2(desired_lo1/1000)+(fref/1000)) / (2fref/1000);`
117			`lo1n=lo1/8;`
118			`lo1a=lo1-(lo1n*8);`
119
120			`s=rfin/1000/1000+1090;`
121
122			`if(optimize_vco) {`
123			`if(s>1890) sel=0;`
124			`else if(s>1720) sel=1;`
125			`else if(s>1530) sel=2;`
126			`else if(s>1370) sel=3;`
127			`else sel=4; // >1090`
128			`}`
129			`else {`
130			`if(s>1790) sel=0; // <1958`
131			`else if(s>1617) sel=1;`
132			`else if(s>1449) sel=2;`
133			`else if(s>1291) sel=3;`
134			`else sel=4; // >1090`
135			`}`
136			`*ret_sel=sel;`
137
138			`lo1freq=(lo1a+8lo1n)fref;`
139
140			`tuner_dbg("mt2032: rfin=%d lo1=%d lo1n=%d lo1a=%d sel=%d, lo1freq=%d\n",`
141			`rfin,lo1,lo1n,lo1a,sel,lo1freq);`
142
143			`desired_lo2=lo1freq-rfin-if2;`
144			`lo2=(desired_lo2)/fref;`
145			`lo2n=lo2/8;`
146			`lo2a=lo2-(lo2n*8);`
147			`lo2num=((desired_lo2/1000)%(fref/1000))* 3780/(fref/1000); //scale to fit in 32bit arith`
148			`lo2freq=(lo2a+8lo2n)fref + lo2num(fref/1000)/37801000;`
149
150			`tuner_dbg("mt2032: rfin=%d lo2=%d lo2n=%d lo2a=%d num=%d lo2freq=%d\n",`
151			`rfin,lo2,lo2n,lo2a,lo2num,lo2freq);`
152
153			`if(lo1a<0 \|\| lo1a>7 \|\| lo1n<17 \|\|lo1n>48 \|\| lo2a<0 \|\|lo2a >7 \|\|lo2n<17 \|\| lo2n>30) {`
154			`tuner_info("mt2032: frequency parameters out of range: %d %d %d %d\n",`
155			`lo1a, lo1n, lo2a,lo2n);`
156			`return(-1);`
157			`}`
158
159			`mt2032_spurcheck(fe, lo1freq, desired_lo2, spectrum_from, spectrum_to);`
160			`// should recalculate lo1 (one step up/down)`
161
162			`// set up MT2032 register map for transfer over i2c`
163			`buf[0]=lo1n-1;`
164			`buf[1]=lo1a \| (sel<<4);`
165			`buf[2]=0x86; // LOGC`
166			`buf[3]=0x0f; //reserved`
167			`buf[4]=0x1f;`
168			`buf[5]=(lo2n-1) \| (lo2a<<5);`
169			`if(rfin >40010001000)`
170			`buf[6]=0xe4;`
171			`else`
172			`buf[6]=0xf4; // set PKEN per rev 1.2`
173			`buf[7]=8+xogc;`
174			`buf[8]=0xc3; //reserved`
175			`buf[9]=0x4e; //reserved`
176			`buf[10]=0xec; //reserved`
177			`buf[11]=(lo2num&0xff);`
178			`buf[12]=(lo2num>>8) \|0x80; // Lo2RST`
179
180			`return 0;`
181			`}`
182
183			`static int mt2032_check_lo_lock(struct dvb_frontend *fe)`
184			`{`
185			`struct microtune_priv *priv = fe->tuner_priv;`
186			`int try,lock=0;`
187			`unsigned char buf[2];`
188
189			`for(try=0;try<10;try++) {`
190			`buf[0]=0x0e;`
191			`tuner_i2c_xfer_send(&priv->i2c_props,buf,1);`
192			`tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);`
193			`tuner_dbg("mt2032 Reg.E=0x%02x\n",buf[0]);`
194			`lock=buf[0] &0x06;`
195
196			`if (lock==6)`
197			`break;`
198
199			`tuner_dbg("mt2032: pll wait 1ms for lock (0x%2x)\n",buf[0]);`
200			`udelay(1000);`
201			`}`
202			`return lock;`
203			`}`
204
205			`static int mt2032_optimize_vco(struct dvb_frontend *fe,int sel,int lock)`
206			`{`
207			`struct microtune_priv *priv = fe->tuner_priv;`
208			`unsigned char buf[2];`
209			`int tad1;`
210
211			`buf[0]=0x0f;`
212			`tuner_i2c_xfer_send(&priv->i2c_props,buf,1);`
213			`tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);`
214			`tuner_dbg("mt2032 Reg.F=0x%02x\n",buf[0]);`
215			`tad1=buf[0]&0x07;`
216
217			`if(tad1 ==0) return lock;`
218			`if(tad1 ==1) return lock;`
219
220			`if(tad1==2) {`
221			`if(sel==0)`
222			`return lock;`
223			`else sel--;`
224			`}`
225			`else {`
226			`if(sel<4)`
227			`sel++;`
228			`else`
229			`return lock;`
230			`}`
231
232			`tuner_dbg("mt2032 optimize_vco: sel=%d\n",sel);`
233
234			`buf[0]=0x0f;`
235			`buf[1]=sel;`
236			`tuner_i2c_xfer_send(&priv->i2c_props,buf,2);`
237			`lock=mt2032_check_lo_lock(fe);`
238			`return lock;`
239			`}`
240
241
242			`static void mt2032_set_if_freq(struct dvb_frontend *fe, unsigned int rfin,`
243			`unsigned int if1, unsigned int if2,`
244			`unsigned int from, unsigned int to)`
245			`{`
246			`unsigned char buf[21];`
247			`int lint_try,ret,sel,lock=0;`
248			`struct microtune_priv *priv = fe->tuner_priv;`
249
250			`tuner_dbg("mt2032_set_if_freq rfin=%d if1=%d if2=%d from=%d to=%d\n",`
251			`rfin,if1,if2,from,to);`
252
253			`buf[0]=0;`
254			`ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,1);`
255			`tuner_i2c_xfer_recv(&priv->i2c_props,buf,21);`
256
257			`buf[0]=0;`
258			`ret=mt2032_compute_freq(fe,rfin,if1,if2,from,to,&buf[1],&sel,priv->xogc);`
259			`if (ret<0)`
260			`return;`
261
262			`// send only the relevant registers per Rev. 1.2`
263			`buf[0]=0;`
264			`ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,4);`
265			`buf[5]=5;`
266			`ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+5,4);`
267			`buf[11]=11;`
268			`ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+11,3);`
269			`if(ret!=3)`
270			`tuner_warn("i2c i/o error: rc == %d (should be 3)\n",ret);`
271
272			`// wait for PLLs to lock (per manual), retry LINT if not.`
273			`for(lint_try=0; lint_try<2; lint_try++) {`
274			`lock=mt2032_check_lo_lock(fe);`
275
276			`if(optimize_vco)`
277			`lock=mt2032_optimize_vco(fe,sel,lock);`
278			`if(lock==6) break;`
279
280			`tuner_dbg("mt2032: re-init PLLs by LINT\n");`
281			`buf[0]=7;`
282			`buf[1]=0x80 +8+priv->xogc; // set LINT to re-init PLLs`
283			`tuner_i2c_xfer_send(&priv->i2c_props,buf,2);`
284			`mdelay(10);`
285			`buf[1]=8+priv->xogc;`
286			`tuner_i2c_xfer_send(&priv->i2c_props,buf,2);`
287			`}`
288
289			`if (lock!=6)`
290			`tuner_warn("MT2032 Fatal Error: PLLs didn't lock.\n");`
291
292			`buf[0]=2;`
293			`buf[1]=0x20; // LOGC for optimal phase noise`
294			`ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);`
295			`if (ret!=2)`
296			`tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret);`
297			`}`
298
299
300			`static int mt2032_set_tv_freq(struct dvb_frontend *fe,`
301			`struct analog_parameters *params)`
302			`{`
303			`int if2,from,to;`
304
305			`// signal bandwidth and picture carrier`
306			`if (params->std & V4L2_STD_525_60) {`
307			`// NTSC`
308			`from = 40750*1000;`
309			`to = 46750*1000;`
310			`if2 = 45750*1000;`
311			`} else {`
312			`// PAL`
313			`from = 32900*1000;`
314			`to = 39900*1000;`
315			`if2 = 38900*1000;`
316			`}`
317
318			`mt2032_set_if_freq(fe, params->frequency*62500,`
319			`109010001000, if2, from, to);`
320
321			`return 0;`
322			`}`
323
324			`static int mt2032_set_radio_freq(struct dvb_frontend *fe,`
325			`struct analog_parameters *params)`
326			`{`
327			`struct microtune_priv *priv = fe->tuner_priv;`
328			`int if2;`
329
330			`if (params->std & V4L2_STD_525_60) {`
331			`tuner_dbg("pinnacle ntsc\n");`
332			`if2 = 41300 * 1000;`
333			`} else {`
334			`tuner_dbg("pinnacle pal\n");`
335			`if2 = 33300 * 1000;`
336			`}`
337
338			`// per Manual for FM tuning: first if center freq. 1085 MHz`
339			`mt2032_set_if_freq(fe, params->frequency * 125 / 2,`
340			`108510001000,if2,if2,if2);`
341
342			`return 0;`
343			`}`
344
345			`static int mt2032_set_params(struct dvb_frontend *fe,`
346			`struct analog_parameters *params)`
347			`{`
348			`struct microtune_priv *priv = fe->tuner_priv;`
349			`int ret = -EINVAL;`
350
351			`switch (params->mode) {`
352			`case V4L2_TUNER_RADIO:`
353			`ret = mt2032_set_radio_freq(fe, params);`
354			`priv->frequency = params->frequency * 125 / 2;`
355			`break;`
356			`case V4L2_TUNER_ANALOG_TV:`
357			`case V4L2_TUNER_DIGITAL_TV:`
358			`ret = mt2032_set_tv_freq(fe, params);`
359			`priv->frequency = params->frequency * 62500;`
360			`break;`
361			`}`
362
363			`return ret;`
364			`}`
365
366			`static struct dvb_tuner_ops mt2032_tuner_ops = {`
367			`.set_analog_params = mt2032_set_params,`
368			`.release = microtune_release,`
369			`.get_frequency = microtune_get_frequency,`
370			`};`
371
372			`// Initalization as described in "MT203x Programming Procedures", Rev 1.2, Feb.2001`
373			`static int mt2032_init(struct dvb_frontend *fe)`
374			`{`
375			`struct microtune_priv *priv = fe->tuner_priv;`
376			`unsigned char buf[21];`
377			`int ret,xogc,xok=0;`
378
379			`// Initialize Registers per spec.`
380			`buf[1]=2; // Index to register 2`
381			`buf[2]=0xff;`
382			`buf[3]=0x0f;`
383			`buf[4]=0x1f;`
384			`ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+1,4);`
385
386			`buf[5]=6; // Index register 6`
387			`buf[6]=0xe4;`
388			`buf[7]=0x8f;`
389			`buf[8]=0xc3;`
390			`buf[9]=0x4e;`
391			`buf[10]=0xec;`
392			`ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+5,6);`
393
394			`buf[12]=13; // Index register 13`
395			`buf[13]=0x32;`
396			`ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+12,2);`
397
398			`// Adjust XOGC (register 7), wait for XOK`
399			`xogc=7;`
400			`do {`
401			`tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07);`
402			`mdelay(10);`
403			`buf[0]=0x0e;`
404			`tuner_i2c_xfer_send(&priv->i2c_props,buf,1);`
405			`tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);`
406			`xok=buf[0]&0x01;`
407			`tuner_dbg("mt2032: xok = 0x%02x\n",xok);`
408			`if (xok == 1) break;`
409
410			`xogc--;`
411			`tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07);`
412			`if (xogc == 3) {`
413			`xogc=4; // min. 4 per spec`
414			`break;`
415			`}`
416			`buf[0]=0x07;`
417			`buf[1]=0x88 + xogc;`
418			`ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);`
419			`if (ret!=2)`
420			`tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret);`
421			`} while (xok != 1 );`
422			`priv->xogc=xogc;`
423
424			`memcpy(&fe->ops.tuner_ops, &mt2032_tuner_ops, sizeof(struct dvb_tuner_ops));`
425
426			`return(1);`
427			`}`
428
429			`static void mt2050_set_antenna(struct dvb_frontend *fe, unsigned char antenna)`
430			`{`
431			`struct microtune_priv *priv = fe->tuner_priv;`
432			`unsigned char buf[2];`
433			`int ret;`
434
435			`buf[0] = 6;`
436			`buf[1] = antenna ? 0x11 : 0x10;`
437			`ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);`
438			`tuner_dbg("mt2050: enabled antenna connector %d\n", antenna);`
439			`}`
440
441			`static void mt2050_set_if_freq(struct dvb_frontend *fe,unsigned int freq, unsigned int if2)`
442			`{`
443			`struct microtune_priv *priv = fe->tuner_priv;`
444			`unsigned int if1=121810001000;`
445			`unsigned int f_lo1,f_lo2,lo1,lo2,f_lo1_modulo,f_lo2_modulo,num1,num2,div1a,div1b,div2a,div2b;`
446			`int ret;`
447			`unsigned char buf[6];`
448
449			`tuner_dbg("mt2050_set_if_freq freq=%d if1=%d if2=%d\n",`
450			`freq,if1,if2);`
451
452			`f_lo1=freq+if1;`
453			`f_lo1=(f_lo1/1000000)*1000000;`
454
455			`f_lo2=f_lo1-freq-if2;`
456			`f_lo2=(f_lo2/50000)*50000;`
457
458			`lo1=f_lo1/4000000;`
459			`lo2=f_lo2/4000000;`
460
461			`f_lo1_modulo= f_lo1-(lo1*4000000);`
462			`f_lo2_modulo= f_lo2-(lo2*4000000);`
463
464			`num1=4*f_lo1_modulo/4000000;`
465			`num2=4096*(f_lo2_modulo/1000)/4000;`
466
467			`// todo spurchecks`
468
469			`div1a=(lo1/12)-1;`
470			`div1b=lo1-(div1a+1)*12;`
471
472			`div2a=(lo2/8)-1;`
473			`div2b=lo2-(div2a+1)*8;`
474
475			`if (debug > 1) {`
476			`tuner_dbg("lo1 lo2 = %d %d\n", lo1, lo2);`
477			`tuner_dbg("num1 num2 div1a div1b div2a div2b= %x %x %x %x %x %x\n",`
478			`num1,num2,div1a,div1b,div2a,div2b);`
479			`}`
480
481			`buf[0]=1;`
482			`buf[1]= 4*div1b + num1;`
483			`if(freq<27510001000) buf[1] = buf[1]\|0x80;`
484
485			`buf[2]=div1a;`
486			`buf[3]=32*div2b + num2/256;`
487			`buf[4]=num2-(num2/256)*256;`
488			`buf[5]=div2a;`
489			`if(num2!=0) buf[5]=buf[5]\|0x40;`
490
491			`if (debug > 1) {`
492			`int i;`
493			`tuner_dbg("bufs is: ");`
494			`for(i=0;i<6;i++)`
495			`printk("%x ",buf[i]);`
496			`printk("\n");`
497			`}`
498
499			`ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,6);`
500			`if (ret!=6)`
501			`tuner_warn("i2c i/o error: rc == %d (should be 6)\n",ret);`
502			`}`
503
504			`static int mt2050_set_tv_freq(struct dvb_frontend *fe,`
505			`struct analog_parameters *params)`
506			`{`
507			`unsigned int if2;`
508
509			`if (params->std & V4L2_STD_525_60) {`
510			`// NTSC`
511			`if2 = 45750*1000;`
512			`} else {`
513			`// PAL`
514			`if2 = 38900*1000;`
515			`}`
516			`if (V4L2_TUNER_DIGITAL_TV == params->mode) {`
517			`// DVB (pinnacle 300i)`
518			`if2 = 36150*1000;`
519			`}`
520			`mt2050_set_if_freq(fe, params->frequency*62500, if2);`
521			`mt2050_set_antenna(fe, tv_antenna);`
522
523			`return 0;`
524			`}`
525
526			`static int mt2050_set_radio_freq(struct dvb_frontend *fe,`
527			`struct analog_parameters *params)`
528			`{`
529			`struct microtune_priv *priv = fe->tuner_priv;`
530			`int if2;`
531
532			`if (params->std & V4L2_STD_525_60) {`
533			`tuner_dbg("pinnacle ntsc\n");`
534			`if2 = 41300 * 1000;`
535			`} else {`
536			`tuner_dbg("pinnacle pal\n");`
537			`if2 = 33300 * 1000;`
538			`}`
539
540			`mt2050_set_if_freq(fe, params->frequency * 125 / 2, if2);`
541			`mt2050_set_antenna(fe, radio_antenna);`
542
543			`return 0;`
544			`}`
545
546			`static int mt2050_set_params(struct dvb_frontend *fe,`
547			`struct analog_parameters *params)`
548			`{`
549			`struct microtune_priv *priv = fe->tuner_priv;`
550			`int ret = -EINVAL;`
551
552			`switch (params->mode) {`
553			`case V4L2_TUNER_RADIO:`
554			`ret = mt2050_set_radio_freq(fe, params);`
555			`priv->frequency = params->frequency * 125 / 2;`
556			`break;`
557			`case V4L2_TUNER_ANALOG_TV:`
558			`case V4L2_TUNER_DIGITAL_TV:`
559			`ret = mt2050_set_tv_freq(fe, params);`
560			`priv->frequency = params->frequency * 62500;`
561			`break;`
562			`}`
563
564			`return ret;`
565			`}`
566
567			`static struct dvb_tuner_ops mt2050_tuner_ops = {`
568			`.set_analog_params = mt2050_set_params,`
569			`.release = microtune_release,`
570			`.get_frequency = microtune_get_frequency,`
571			`};`
572
573			`static int mt2050_init(struct dvb_frontend *fe)`
574			`{`
575			`struct microtune_priv *priv = fe->tuner_priv;`
576			`unsigned char buf[2];`
577			`int ret;`
578
579			`buf[0]=6;`
580			`buf[1]=0x10;`
581			`ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2); // power`
582
583			`buf[0]=0x0f;`
584			`buf[1]=0x0f;`
585			`ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2); // m1lo`
586
587			`buf[0]=0x0d;`
588			`ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,1);`
589			`tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);`
590
591			`tuner_dbg("mt2050: sro is %x\n",buf[0]);`
592
593			`memcpy(&fe->ops.tuner_ops, &mt2050_tuner_ops, sizeof(struct dvb_tuner_ops));`
594
595			`return 0;`
596			`}`
597
598			`struct dvb_frontend microtune_attach(struct dvb_frontend fe,`
599			`struct i2c_adapter* i2c_adap,`
600			`u8 i2c_addr)`
601			`{`
602			`struct microtune_priv *priv = NULL;`
603			`char *name;`
604			`unsigned char buf[21];`
605			`int company_code;`
606
607			`priv = kzalloc(sizeof(struct microtune_priv), GFP_KERNEL);`
608			`if (priv == NULL)`
609			`return NULL;`
610			`fe->tuner_priv = priv;`
611
612			`priv->i2c_props.addr = i2c_addr;`
613			`priv->i2c_props.adap = i2c_adap;`
614
615			`//priv->radio_if2 = 10700 * 1000; /* 10.7MHz - FM radio */`
616
617			`memset(buf,0,sizeof(buf));`
618
619			`name = "unknown";`
620
621			`tuner_i2c_xfer_send(&priv->i2c_props,buf,1);`
622			`tuner_i2c_xfer_recv(&priv->i2c_props,buf,21);`
623			`if (debug) {`
624			`int i;`
625			`tuner_dbg("MT20xx hexdump:");`
626			`for(i=0;i<21;i++) {`
627			`printk(" %02x",buf[i]);`
628			`if(((i+1)%8)==0) printk(" ");`
629			`}`
630			`printk("\n");`
631			`}`
632			`company_code = buf[0x11] << 8 \| buf[0x12];`
633			`tuner_info("microtune: companycode=%04x part=%02x rev=%02x\n",`
634			`company_code,buf[0x13],buf[0x14]);`
635
636
637			`if (buf[0x13] < ARRAY_SIZE(microtune_part) &&`
638			`NULL != microtune_part[buf[0x13]])`
639			`name = microtune_part[buf[0x13]];`
640			`switch (buf[0x13]) {`
641			`case MT2032:`
642			`mt2032_init(fe);`
643			`break;`
644			`case MT2050:`
645			`mt2050_init(fe);`
646			`break;`
647			`default:`
648			`tuner_info("microtune %s found, not (yet?) supported, sorry :-/\n",`
649			`name);`
650			`return 0;`
651			`}`
652
653			`strlcpy(fe->ops.tuner_ops.info.name, name,`
654			`sizeof(fe->ops.tuner_ops.info.name));`
655			`tuner_info("microtune %s found, OK\n",name);`
656			`return fe;`
657			`}`
658
659			`EXPORT_SYMBOL_GPL(microtune_attach);`
660
661			`MODULE_DESCRIPTION("Microtune tuner driver");`
662			`MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");`
663			`MODULE_LICENSE("GPL");`
664
665			`/*`
666			`* Overrides for Emacs so that we follow Linus's tabbing style.`
667			`* ---------------------------------------------------------------------------`
668			`* Local variables:`
669			`* c-basic-offset: 8`
670			`* End:`
671			`*/`