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

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [media/] [video/] [tuner-simple.c] - Blame information for rev 65

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * i2c tv tuner chip device driver
 * controls all those simple 4-control-bytes style tuners.
 *
 * This "tuner-simple" module was split apart from the original "tuner" module.
 */
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/videodev.h>
#include <media/tuner.h>
#include <media/v4l2-common.h>
#include <media/tuner-types.h>
#include "tuner-i2c.h"
#include "tuner-simple.h"
 
static int debug = 0;
module_param(debug, int, 0644);
MODULE_PARM_DESC(debug, "enable verbose debug messages");
 
#define PREFIX "tuner-simple "
 
static int offset = 0;
module_param(offset, int, 0664);
MODULE_PARM_DESC(offset,"Allows to specify an offset for tuner");
 
/* ---------------------------------------------------------------------- */
 
/* tv standard selection for Temic 4046 FM5
   this value takes the low bits of control byte 2
   from datasheet Rev.01, Feb.00
     standard     BG      I       L       L2      D
     picture IF   38.9    38.9    38.9    33.95   38.9
     sound 1      33.4    32.9    32.4    40.45   32.4
     sound 2      33.16
     NICAM        33.05   32.348  33.05           33.05
 */
#define TEMIC_SET_PAL_I         0x05
#define TEMIC_SET_PAL_DK        0x09
#define TEMIC_SET_PAL_L         0x0a // SECAM ?
#define TEMIC_SET_PAL_L2        0x0b // change IF !
#define TEMIC_SET_PAL_BG        0x0c
 
/* tv tuner system standard selection for Philips FQ1216ME
   this value takes the low bits of control byte 2
   from datasheet "1999 Nov 16" (supersedes "1999 Mar 23")
     standard           BG      DK      I       L       L`
     picture carrier    38.90   38.90   38.90   38.90   33.95
     colour             34.47   34.47   34.47   34.47   38.38
     sound 1            33.40   32.40   32.90   32.40   40.45
     sound 2            33.16   -       -       -       -
     NICAM              33.05   33.05   32.35   33.05   39.80
 */
#define PHILIPS_SET_PAL_I       0x01 /* Bit 2 always zero !*/
#define PHILIPS_SET_PAL_BGDK    0x09
#define PHILIPS_SET_PAL_L2      0x0a
#define PHILIPS_SET_PAL_L       0x0b
 
/* system switching for Philips FI1216MF MK2
   from datasheet "1996 Jul 09",
    standard         BG     L      L'
    picture carrier  38.90  38.90  33.95
    colour           34.47  34.37  38.38
    sound 1          33.40  32.40  40.45
    sound 2          33.16  -      -
    NICAM            33.05  33.05  39.80
 */
#define PHILIPS_MF_SET_STD_BG   0x01 /* Bit 2 must be zero, Bit 3 is system output */
#define PHILIPS_MF_SET_STD_L    0x03 /* Used on Secam France */
#define PHILIPS_MF_SET_STD_LC   0x02 /* Used on SECAM L' */
 
/* Control byte */
 
#define TUNER_RATIO_MASK        0x06 /* Bit cb1:cb2 */
#define TUNER_RATIO_SELECT_50   0x00
#define TUNER_RATIO_SELECT_32   0x02
#define TUNER_RATIO_SELECT_166  0x04
#define TUNER_RATIO_SELECT_62   0x06
 
#define TUNER_CHARGE_PUMP       0x40  /* Bit cb6 */
 
/* Status byte */
 
#define TUNER_POR         0x80
#define TUNER_FL          0x40
#define TUNER_MODE        0x38
#define TUNER_AFC         0x07
#define TUNER_SIGNAL      0x07
#define TUNER_STEREO      0x10
 
#define TUNER_PLL_LOCKED   0x40
#define TUNER_STEREO_MK3   0x04
 
struct tuner_simple_priv {
        u16 last_div;
        struct tuner_i2c_props i2c_props;
 
        unsigned int type;
        struct tunertype *tun;
 
        u32 frequency;
};
 
/* ---------------------------------------------------------------------- */
 
static int tuner_read_status(struct dvb_frontend *fe)
{
        struct tuner_simple_priv *priv = fe->tuner_priv;
        unsigned char byte;
 
        if (1 != tuner_i2c_xfer_recv(&priv->i2c_props,&byte,1))
                return 0;
 
        return byte;
}
 
static inline int tuner_signal(const int status)
{
        return (status & TUNER_SIGNAL) << 13;
}
 
static inline int tuner_stereo(const int type, const int status)
{
        switch (type) {
                case TUNER_PHILIPS_FM1216ME_MK3:
                case TUNER_PHILIPS_FM1236_MK3:
                case TUNER_PHILIPS_FM1256_IH3:
                case TUNER_LG_NTSC_TAPE:
                        return ((status & TUNER_SIGNAL) == TUNER_STEREO_MK3);
                default:
                        return status & TUNER_STEREO;
        }
}
 
static inline int tuner_islocked(const int status)
{
        return (status & TUNER_FL);
}
 
static inline int tuner_afcstatus(const int status)
{
        return (status & TUNER_AFC) - 2;
}
 
 
static int simple_get_status(struct dvb_frontend *fe, u32 *status)
{
        struct tuner_simple_priv *priv = fe->tuner_priv;
        int tuner_status = tuner_read_status(fe);
 
        *status = 0;
 
        if (tuner_islocked(tuner_status))
                *status = TUNER_STATUS_LOCKED;
        if (tuner_stereo(priv->type, tuner_status))
                *status |= TUNER_STATUS_STEREO;
 
        tuner_dbg("AFC Status: %d\n", tuner_afcstatus(tuner_status));
 
        return 0;
}
 
static int simple_get_rf_strength(struct dvb_frontend *fe, u16 *strength)
{
        struct tuner_simple_priv *priv = fe->tuner_priv;
        int signal = tuner_signal(tuner_read_status(fe));
 
        *strength = signal;
 
        tuner_dbg("Signal strength: %d\n", signal);
 
        return 0;
}
 
/* ---------------------------------------------------------------------- */
 
static int simple_set_tv_freq(struct dvb_frontend *fe,
                              struct analog_parameters *params)
{
        struct tuner_simple_priv *priv = fe->tuner_priv;
        u8 config, cb, tuneraddr;
        u16 div;
        struct tunertype *tun;
        u8 buffer[4];
        int rc, IFPCoff, i, j;
        enum param_type desired_type;
        struct tuner_params *t_params;
 
        tun = priv->tun;
 
        /* IFPCoff = Video Intermediate Frequency - Vif:
                940  =16*58.75  NTSC/J (Japan)
                732  =16*45.75  M/N STD
                704  =16*44     ATSC (at DVB code)
                632  =16*39.50  I U.K.
                622.4=16*38.90  B/G D/K I, L STD
                592  =16*37.00  D China
                590  =16.36.875 B Australia
                543.2=16*33.95  L' STD
                171.2=16*10.70  FM Radio (at set_radio_freq)
        */
 
        if (params->std == V4L2_STD_NTSC_M_JP) {
                IFPCoff      = 940;
                desired_type = TUNER_PARAM_TYPE_NTSC;
        } else if ((params->std & V4L2_STD_MN) &&
                  !(params->std & ~V4L2_STD_MN)) {
                IFPCoff      = 732;
                desired_type = TUNER_PARAM_TYPE_NTSC;
        } else if (params->std == V4L2_STD_SECAM_LC) {
                IFPCoff      = 543;
                desired_type = TUNER_PARAM_TYPE_SECAM;
        } else {
                IFPCoff      = 623;
                desired_type = TUNER_PARAM_TYPE_PAL;
        }
 
        for (j = 0; j < tun->count-1; j++) {
                if (desired_type != tun->params[j].type)
                        continue;
                break;
        }
        /* use default tuner_t_params if desired_type not available */
        if (desired_type != tun->params[j].type) {
                tuner_dbg("IFPCoff = %d: tuner_t_params undefined for tuner %d\n",
                          IFPCoff, priv->type);
                j = 0;
        }
        t_params = &tun->params[j];
 
        for (i = 0; i < t_params->count; i++) {
                if (params->frequency > t_params->ranges[i].limit)
                        continue;
                break;
        }
        if (i == t_params->count) {
                tuner_dbg("TV frequency out of range (%d > %d)",
                                params->frequency, t_params->ranges[i - 1].limit);
                params->frequency = t_params->ranges[--i].limit;
        }
        config = t_params->ranges[i].config;
        cb     = t_params->ranges[i].cb;
        /*  i == 0 -> VHF_LO
         *  i == 1 -> VHF_HI
         *  i == 2 -> UHF     */
        tuner_dbg("tv: param %d, range %d\n",j,i);
 
        div=params->frequency + IFPCoff + offset;
 
        tuner_dbg("Freq= %d.%02d MHz, V_IF=%d.%02d MHz, Offset=%d.%02d MHz, div=%0d\n",
                                        params->frequency / 16, params->frequency % 16 * 100 / 16,
                                        IFPCoff / 16, IFPCoff % 16 * 100 / 16,
                                        offset / 16, offset % 16 * 100 / 16,
                                        div);
 
        /* tv norm specific stuff for multi-norm tuners */
        switch (priv->type) {
        case TUNER_PHILIPS_SECAM: // FI1216MF
                /* 0x01 -> ??? no change ??? */
                /* 0x02 -> PAL BDGHI / SECAM L */
                /* 0x04 -> ??? PAL others / SECAM others ??? */
                cb &= ~0x03;
                if (params->std & V4L2_STD_SECAM_L) //also valid for V4L2_STD_SECAM
                        cb |= PHILIPS_MF_SET_STD_L;
                else if (params->std & V4L2_STD_SECAM_LC)
                        cb |= PHILIPS_MF_SET_STD_LC;
                else /* V4L2_STD_B|V4L2_STD_GH */
                        cb |= PHILIPS_MF_SET_STD_BG;
                break;
 
        case TUNER_TEMIC_4046FM5:
                cb &= ~0x0f;
 
                if (params->std & V4L2_STD_PAL_BG) {
                        cb |= TEMIC_SET_PAL_BG;
 
                } else if (params->std & V4L2_STD_PAL_I) {
                        cb |= TEMIC_SET_PAL_I;
 
                } else if (params->std & V4L2_STD_PAL_DK) {
                        cb |= TEMIC_SET_PAL_DK;
 
                } else if (params->std & V4L2_STD_SECAM_L) {
                        cb |= TEMIC_SET_PAL_L;
 
                }
                break;
 
        case TUNER_PHILIPS_FQ1216ME:
                cb &= ~0x0f;
 
                if (params->std & (V4L2_STD_PAL_BG|V4L2_STD_PAL_DK)) {
                        cb |= PHILIPS_SET_PAL_BGDK;
 
                } else if (params->std & V4L2_STD_PAL_I) {
                        cb |= PHILIPS_SET_PAL_I;
 
                } else if (params->std & V4L2_STD_SECAM_L) {
                        cb |= PHILIPS_SET_PAL_L;
 
                }
                break;
 
        case TUNER_PHILIPS_ATSC:
                /* 0x00 -> ATSC antenna input 1 */
                /* 0x01 -> ATSC antenna input 2 */
                /* 0x02 -> NTSC antenna input 1 */
                /* 0x03 -> NTSC antenna input 2 */
                cb &= ~0x03;
                if (!(params->std & V4L2_STD_ATSC))
                        cb |= 2;
                /* FIXME: input */
                break;
 
        case TUNER_MICROTUNE_4042FI5:
                /* Set the charge pump for fast tuning */
                config |= TUNER_CHARGE_PUMP;
                break;
 
        case TUNER_PHILIPS_TUV1236D:
                /* 0x40 -> ATSC antenna input 1 */
                /* 0x48 -> ATSC antenna input 2 */
                /* 0x00 -> NTSC antenna input 1 */
                /* 0x08 -> NTSC antenna input 2 */
                buffer[0] = 0x14;
                buffer[1] = 0x00;
                buffer[2] = 0x17;
                buffer[3] = 0x00;
                cb &= ~0x40;
                if (params->std & V4L2_STD_ATSC) {
                        cb |= 0x40;
                        buffer[1] = 0x04;
                }
                /* set to the correct mode (analog or digital) */
                tuneraddr = priv->i2c_props.addr;
                priv->i2c_props.addr = 0x0a;
                if (2 != (rc = tuner_i2c_xfer_send(&priv->i2c_props,&buffer[0],2)))
                        tuner_warn("i2c i/o error: rc == %d (should be 2)\n",rc);
                if (2 != (rc = tuner_i2c_xfer_send(&priv->i2c_props,&buffer[2],2)))
                        tuner_warn("i2c i/o error: rc == %d (should be 2)\n",rc);
                priv->i2c_props.addr = tuneraddr;
                /* FIXME: input */
                break;
        }
 
        if (t_params->cb_first_if_lower_freq && div < priv->last_div) {
                buffer[0] = config;
                buffer[1] = cb;
                buffer[2] = (div>>8) & 0x7f;
                buffer[3] = div      & 0xff;
        } else {
                buffer[0] = (div>>8) & 0x7f;
                buffer[1] = div      & 0xff;
                buffer[2] = config;
                buffer[3] = cb;
        }
        priv->last_div = div;
        if (t_params->has_tda9887) {
                int config = 0;
                int is_secam_l = (params->std & (V4L2_STD_SECAM_L | V4L2_STD_SECAM_LC)) &&
                        !(params->std & ~(V4L2_STD_SECAM_L | V4L2_STD_SECAM_LC));
 
                if (params->std == V4L2_STD_SECAM_LC) {
                        if (t_params->port1_active ^ t_params->port1_invert_for_secam_lc)
                                config |= TDA9887_PORT1_ACTIVE;
                        if (t_params->port2_active ^ t_params->port2_invert_for_secam_lc)
                                config |= TDA9887_PORT2_ACTIVE;
                }
                else {
                        if (t_params->port1_active)
                                config |= TDA9887_PORT1_ACTIVE;
                        if (t_params->port2_active)
                                config |= TDA9887_PORT2_ACTIVE;
                }
                if (t_params->intercarrier_mode)
                        config |= TDA9887_INTERCARRIER;
                if (is_secam_l) {
                        if (i == 0 && t_params->default_top_secam_low)
                                config |= TDA9887_TOP(t_params->default_top_secam_low);
                        else if (i == 1 && t_params->default_top_secam_mid)
                                config |= TDA9887_TOP(t_params->default_top_secam_mid);
                        else if (t_params->default_top_secam_high)
                                config |= TDA9887_TOP(t_params->default_top_secam_high);
                }
                else {
                        if (i == 0 && t_params->default_top_low)
                                config |= TDA9887_TOP(t_params->default_top_low);
                        else if (i == 1 && t_params->default_top_mid)
                                config |= TDA9887_TOP(t_params->default_top_mid);
                        else if (t_params->default_top_high)
                                config |= TDA9887_TOP(t_params->default_top_high);
                }
                if (t_params->default_pll_gating_18)
                        config |= TDA9887_GATING_18;
                i2c_clients_command(priv->i2c_props.adap, TDA9887_SET_CONFIG, &config);
        }
        tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n",
                  buffer[0],buffer[1],buffer[2],buffer[3]);
 
        if (4 != (rc = tuner_i2c_xfer_send(&priv->i2c_props,buffer,4)))
                tuner_warn("i2c i/o error: rc == %d (should be 4)\n",rc);
 
        switch (priv->type) {
        case TUNER_LG_TDVS_H06XF:
                /* Set the Auxiliary Byte. */
                buffer[0] = buffer[2];
                buffer[0] &= ~0x20;
                buffer[0] |= 0x18;
                buffer[1] = 0x20;
                tuner_dbg("tv 0x%02x 0x%02x\n",buffer[0],buffer[1]);
 
                if (2 != (rc = tuner_i2c_xfer_send(&priv->i2c_props,buffer,2)))
                        tuner_warn("i2c i/o error: rc == %d (should be 2)\n",rc);
                break;
        case TUNER_MICROTUNE_4042FI5:
        {
                // FIXME - this may also work for other tuners
                unsigned long timeout = jiffies + msecs_to_jiffies(1);
                u8 status_byte = 0;
 
                /* Wait until the PLL locks */
                for (;;) {
                        if (time_after(jiffies,timeout))
                                return 0;
                        if (1 != (rc = tuner_i2c_xfer_recv(&priv->i2c_props,&status_byte,1))) {
                                tuner_warn("i2c i/o read error: rc == %d (should be 1)\n",rc);
                                break;
                        }
                        if (status_byte & TUNER_PLL_LOCKED)
                                break;
                        udelay(10);
                }
 
                /* Set the charge pump for optimized phase noise figure */
                config &= ~TUNER_CHARGE_PUMP;
                buffer[0] = (div>>8) & 0x7f;
                buffer[1] = div      & 0xff;
                buffer[2] = config;
                buffer[3] = cb;
                tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n",
                          buffer[0],buffer[1],buffer[2],buffer[3]);
 
                if (4 != (rc = tuner_i2c_xfer_send(&priv->i2c_props,buffer,4)))
                        tuner_warn("i2c i/o error: rc == %d (should be 4)\n",rc);
                break;
        }
        }
        return 0;
}
 
static int simple_set_radio_freq(struct dvb_frontend *fe,
                                 struct analog_parameters *params)
{
        struct tunertype *tun;
        struct tuner_simple_priv *priv = fe->tuner_priv;
        u8 buffer[4];
        u16 div;
        int rc, j;
        struct tuner_params *t_params;
        unsigned int freq = params->frequency;
 
        tun = priv->tun;
 
        for (j = tun->count-1; j > 0; j--)
                if (tun->params[j].type == TUNER_PARAM_TYPE_RADIO)
                        break;
        /* default t_params (j=0) will be used if desired type wasn't found */
        t_params = &tun->params[j];
 
        /* Select Radio 1st IF used */
        switch (t_params->radio_if) {
        case 0: /* 10.7 MHz */
                freq += (unsigned int)(10.7*16000);
                break;
        case 1: /* 33.3 MHz */
                freq += (unsigned int)(33.3*16000);
                break;
        case 2: /* 41.3 MHz */
                freq += (unsigned int)(41.3*16000);
                break;
        default:
                tuner_warn("Unsupported radio_if value %d\n", t_params->radio_if);
                return 0;
        }
 
        /* Bandswitch byte */
        switch (priv->type) {
        case TUNER_TENA_9533_DI:
        case TUNER_YMEC_TVF_5533MF:
                tuner_dbg("This tuner doesn't have FM. Most cards have a TEA5767 for FM\n");
                return 0;
        case TUNER_PHILIPS_FM1216ME_MK3:
        case TUNER_PHILIPS_FM1236_MK3:
        case TUNER_PHILIPS_FMD1216ME_MK3:
        case TUNER_LG_NTSC_TAPE:
        case TUNER_PHILIPS_FM1256_IH3:
                buffer[3] = 0x19;
                break;
        case TUNER_TNF_5335MF:
                buffer[3] = 0x11;
                break;
        case TUNER_LG_PAL_FM:
                buffer[3] = 0xa5;
                break;
        case TUNER_THOMSON_DTT761X:
                buffer[3] = 0x39;
                break;
        case TUNER_MICROTUNE_4049FM5:
        default:
                buffer[3] = 0xa4;
                break;
        }
 
        buffer[2] = (t_params->ranges[0].config & ~TUNER_RATIO_MASK) |
                    TUNER_RATIO_SELECT_50; /* 50 kHz step */
 
        /* Convert from 1/16 kHz V4L steps to 1/20 MHz (=50 kHz) PLL steps
           freq * (1 Mhz / 16000 V4L steps) * (20 PLL steps / 1 MHz) =
           freq * (1/800) */
        div = (freq + 400) / 800;
 
        if (t_params->cb_first_if_lower_freq && div < priv->last_div) {
                buffer[0] = buffer[2];
                buffer[1] = buffer[3];
                buffer[2] = (div>>8) & 0x7f;
                buffer[3] = div      & 0xff;
        } else {
                buffer[0] = (div>>8) & 0x7f;
                buffer[1] = div      & 0xff;
        }
 
        tuner_dbg("radio 0x%02x 0x%02x 0x%02x 0x%02x\n",
               buffer[0],buffer[1],buffer[2],buffer[3]);
        priv->last_div = div;
 
        if (t_params->has_tda9887) {
                int config = 0;
                if (t_params->port1_active && !t_params->port1_fm_high_sensitivity)
                        config |= TDA9887_PORT1_ACTIVE;
                if (t_params->port2_active && !t_params->port2_fm_high_sensitivity)
                        config |= TDA9887_PORT2_ACTIVE;
                if (t_params->intercarrier_mode)
                        config |= TDA9887_INTERCARRIER;
/*              if (t_params->port1_set_for_fm_mono)
                        config &= ~TDA9887_PORT1_ACTIVE;*/
                if (t_params->fm_gain_normal)
                        config |= TDA9887_GAIN_NORMAL;
                if (t_params->radio_if == 2)
                        config |= TDA9887_RIF_41_3;
                i2c_clients_command(priv->i2c_props.adap, TDA9887_SET_CONFIG, &config);
        }
        if (4 != (rc = tuner_i2c_xfer_send(&priv->i2c_props,buffer,4)))
                tuner_warn("i2c i/o error: rc == %d (should be 4)\n",rc);
 
        return 0;
}
 
static int simple_set_params(struct dvb_frontend *fe,
                             struct analog_parameters *params)
{
        struct tuner_simple_priv *priv = fe->tuner_priv;
        int ret = -EINVAL;
 
        switch (params->mode) {
        case V4L2_TUNER_RADIO:
                ret = simple_set_radio_freq(fe, params);
                priv->frequency = params->frequency * 125 / 2;
                break;
        case V4L2_TUNER_ANALOG_TV:
        case V4L2_TUNER_DIGITAL_TV:
                ret = simple_set_tv_freq(fe, params);
                priv->frequency = params->frequency * 62500;
                break;
        }
 
        return ret;
}
 
 
static int simple_release(struct dvb_frontend *fe)
{
        kfree(fe->tuner_priv);
        fe->tuner_priv = NULL;
 
        return 0;
}
 
static int simple_get_frequency(struct dvb_frontend *fe, u32 *frequency)
{
        struct tuner_simple_priv *priv = fe->tuner_priv;
        *frequency = priv->frequency;
        return 0;
}
 
static struct dvb_tuner_ops simple_tuner_ops = {
        .set_analog_params = simple_set_params,
        .release           = simple_release,
        .get_frequency     = simple_get_frequency,
        .get_status        = simple_get_status,
        .get_rf_strength   = simple_get_rf_strength,
};
 
struct dvb_frontend *simple_tuner_attach(struct dvb_frontend *fe,
                                         struct i2c_adapter *i2c_adap,
                                         u8 i2c_addr,
                                         struct simple_tuner_config *cfg)
{
        struct tuner_simple_priv *priv = NULL;
 
        priv = kzalloc(sizeof(struct tuner_simple_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->type = cfg->type;
        priv->tun  = cfg->tun;
 
        memcpy(&fe->ops.tuner_ops, &simple_tuner_ops, sizeof(struct dvb_tuner_ops));
 
        tuner_info("type set to %d (%s)\n", cfg->type, cfg->tun->name);
 
        strlcpy(fe->ops.tuner_ops.info.name, cfg->tun->name, sizeof(fe->ops.tuner_ops.info.name));
 
        return fe;
}
 
 
EXPORT_SYMBOL_GPL(simple_tuner_attach);
 
MODULE_DESCRIPTION("Simple 4-control-bytes style 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/] [tuner-simple.c] - Blame information for rev 65

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* i2c tv tuner chip device driver`
3			`* controls all those simple 4-control-bytes style tuners.`
4			`*`
5			`* This "tuner-simple" 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 <media/tuner.h>`
11			`#include <media/v4l2-common.h>`
12			`#include <media/tuner-types.h>`
13			`#include "tuner-i2c.h"`
14			`#include "tuner-simple.h"`
15
16			`static int debug = 0;`
17			`module_param(debug, int, 0644);`
18			`MODULE_PARM_DESC(debug, "enable verbose debug messages");`
19
20			`#define PREFIX "tuner-simple "`
21
22			`static int offset = 0;`
23			`module_param(offset, int, 0664);`
24			`MODULE_PARM_DESC(offset,"Allows to specify an offset for tuner");`
25
26			`/* ---------------------------------------------------------------------- */`
27
28			`/* tv standard selection for Temic 4046 FM5`
29			`this value takes the low bits of control byte 2`
30			`from datasheet Rev.01, Feb.00`
31			`standard BG I L L2 D`
32			`picture IF 38.9 38.9 38.9 33.95 38.9`
33			`sound 1 33.4 32.9 32.4 40.45 32.4`
34			`sound 2 33.16`
35			`NICAM 33.05 32.348 33.05 33.05`
36			`*/`
37			`#define TEMIC_SET_PAL_I 0x05`
38			`#define TEMIC_SET_PAL_DK 0x09`
39			`#define TEMIC_SET_PAL_L 0x0a // SECAM ?`
40			`#define TEMIC_SET_PAL_L2 0x0b // change IF !`
41			`#define TEMIC_SET_PAL_BG 0x0c`
42
43			`/* tv tuner system standard selection for Philips FQ1216ME`
44			`this value takes the low bits of control byte 2`
45			`from datasheet "1999 Nov 16" (supersedes "1999 Mar 23")`
46			standard BG DK I L L`
47			`picture carrier 38.90 38.90 38.90 38.90 33.95`
48			`colour 34.47 34.47 34.47 34.47 38.38`
49			`sound 1 33.40 32.40 32.90 32.40 40.45`
50			`sound 2 33.16 - - - -`
51			`NICAM 33.05 33.05 32.35 33.05 39.80`
52			`*/`
53			`#define PHILIPS_SET_PAL_I 0x01 /* Bit 2 always zero !*/`
54			`#define PHILIPS_SET_PAL_BGDK 0x09`
55			`#define PHILIPS_SET_PAL_L2 0x0a`
56			`#define PHILIPS_SET_PAL_L 0x0b`
57
58			`/* system switching for Philips FI1216MF MK2`
59			`from datasheet "1996 Jul 09",`
60			`standard BG L L'`
61			`picture carrier 38.90 38.90 33.95`
62			`colour 34.47 34.37 38.38`
63			`sound 1 33.40 32.40 40.45`
64			`sound 2 33.16 - -`
65			`NICAM 33.05 33.05 39.80`
66			`*/`
67			`#define PHILIPS_MF_SET_STD_BG 0x01 /* Bit 2 must be zero, Bit 3 is system output */`
68			`#define PHILIPS_MF_SET_STD_L 0x03 /* Used on Secam France */`
69			`#define PHILIPS_MF_SET_STD_LC 0x02 /* Used on SECAM L' */`
70
71			`/* Control byte */`
72
73			`#define TUNER_RATIO_MASK 0x06 /* Bit cb1:cb2 */`
74			`#define TUNER_RATIO_SELECT_50 0x00`
75			`#define TUNER_RATIO_SELECT_32 0x02`
76			`#define TUNER_RATIO_SELECT_166 0x04`
77			`#define TUNER_RATIO_SELECT_62 0x06`
78
79			`#define TUNER_CHARGE_PUMP 0x40 /* Bit cb6 */`
80
81			`/* Status byte */`
82
83			`#define TUNER_POR 0x80`
84			`#define TUNER_FL 0x40`
85			`#define TUNER_MODE 0x38`
86			`#define TUNER_AFC 0x07`
87			`#define TUNER_SIGNAL 0x07`
88			`#define TUNER_STEREO 0x10`
89
90			`#define TUNER_PLL_LOCKED 0x40`
91			`#define TUNER_STEREO_MK3 0x04`
92
93			`struct tuner_simple_priv {`
94			`u16 last_div;`
95			`struct tuner_i2c_props i2c_props;`
96
97			`unsigned int type;`
98			`struct tunertype *tun;`
99
100			`u32 frequency;`
101			`};`
102
103			`/* ---------------------------------------------------------------------- */`
104
105			`static int tuner_read_status(struct dvb_frontend *fe)`
106			`{`
107			`struct tuner_simple_priv *priv = fe->tuner_priv;`
108			`unsigned char byte;`
109
110			`if (1 != tuner_i2c_xfer_recv(&priv->i2c_props,&byte,1))`
111			`return 0;`
112
113			`return byte;`
114			`}`
115
116			`static inline int tuner_signal(const int status)`
117			`{`
118			`return (status & TUNER_SIGNAL) << 13;`
119			`}`
120
121			`static inline int tuner_stereo(const int type, const int status)`
122			`{`
123			`switch (type) {`
124			`case TUNER_PHILIPS_FM1216ME_MK3:`
125			`case TUNER_PHILIPS_FM1236_MK3:`
126			`case TUNER_PHILIPS_FM1256_IH3:`
127			`case TUNER_LG_NTSC_TAPE:`
128			`return ((status & TUNER_SIGNAL) == TUNER_STEREO_MK3);`
129			`default:`
130			`return status & TUNER_STEREO;`
131			`}`
132			`}`
133
134			`static inline int tuner_islocked(const int status)`
135			`{`
136			`return (status & TUNER_FL);`
137			`}`
138
139			`static inline int tuner_afcstatus(const int status)`
140			`{`
141			`return (status & TUNER_AFC) - 2;`
142			`}`
143
144
145			`static int simple_get_status(struct dvb_frontend fe, u32 status)`
146			`{`
147			`struct tuner_simple_priv *priv = fe->tuner_priv;`
148			`int tuner_status = tuner_read_status(fe);`
149
150			`*status = 0;`
151
152			`if (tuner_islocked(tuner_status))`
153			`*status = TUNER_STATUS_LOCKED;`
154			`if (tuner_stereo(priv->type, tuner_status))`
155			`*status \|= TUNER_STATUS_STEREO;`
156
157			`tuner_dbg("AFC Status: %d\n", tuner_afcstatus(tuner_status));`
158
159			`return 0;`
160			`}`
161
162			`static int simple_get_rf_strength(struct dvb_frontend fe, u16 strength)`
163			`{`
164			`struct tuner_simple_priv *priv = fe->tuner_priv;`
165			`int signal = tuner_signal(tuner_read_status(fe));`
166
167			`*strength = signal;`
168
169			`tuner_dbg("Signal strength: %d\n", signal);`
170
171			`return 0;`
172			`}`
173
174			`/* ---------------------------------------------------------------------- */`
175
176			`static int simple_set_tv_freq(struct dvb_frontend *fe,`
177			`struct analog_parameters *params)`
178			`{`
179			`struct tuner_simple_priv *priv = fe->tuner_priv;`
180			`u8 config, cb, tuneraddr;`
181			`u16 div;`
182			`struct tunertype *tun;`
183			`u8 buffer[4];`
184			`int rc, IFPCoff, i, j;`
185			`enum param_type desired_type;`
186			`struct tuner_params *t_params;`
187
188			`tun = priv->tun;`
189
190			`/* IFPCoff = Video Intermediate Frequency - Vif:`
191			`940 =16*58.75 NTSC/J (Japan)`
192			`732 =16*45.75 M/N STD`
193			`704 =16*44 ATSC (at DVB code)`
194			`632 =16*39.50 I U.K.`
195			`622.4=16*38.90 B/G D/K I, L STD`
196			`592 =16*37.00 D China`
197			`590 =16.36.875 B Australia`
198			`543.2=16*33.95 L' STD`
199			`171.2=16*10.70 FM Radio (at set_radio_freq)`
200			`*/`
201
202			`if (params->std == V4L2_STD_NTSC_M_JP) {`
203			`IFPCoff = 940;`
204			`desired_type = TUNER_PARAM_TYPE_NTSC;`
205			`} else if ((params->std & V4L2_STD_MN) &&`
206			`!(params->std & ~V4L2_STD_MN)) {`
207			`IFPCoff = 732;`
208			`desired_type = TUNER_PARAM_TYPE_NTSC;`
209			`} else if (params->std == V4L2_STD_SECAM_LC) {`
210			`IFPCoff = 543;`
211			`desired_type = TUNER_PARAM_TYPE_SECAM;`
212			`} else {`
213			`IFPCoff = 623;`
214			`desired_type = TUNER_PARAM_TYPE_PAL;`
215			`}`
216
217			`for (j = 0; j < tun->count-1; j++) {`
218			`if (desired_type != tun->params[j].type)`
219			`continue;`
220			`break;`
221			`}`
222			`/* use default tuner_t_params if desired_type not available */`
223			`if (desired_type != tun->params[j].type) {`
224			`tuner_dbg("IFPCoff = %d: tuner_t_params undefined for tuner %d\n",`
225			`IFPCoff, priv->type);`
226			`j = 0;`
227			`}`
228			`t_params = &tun->params[j];`
229
230			`for (i = 0; i < t_params->count; i++) {`
231			`if (params->frequency > t_params->ranges[i].limit)`
232			`continue;`
233			`break;`
234			`}`
235			`if (i == t_params->count) {`
236			`tuner_dbg("TV frequency out of range (%d > %d)",`
237			`params->frequency, t_params->ranges[i - 1].limit);`
238			`params->frequency = t_params->ranges[--i].limit;`
239			`}`
240			`config = t_params->ranges[i].config;`
241			`cb = t_params->ranges[i].cb;`
242			`/* i == 0 -> VHF_LO`
243			`* i == 1 -> VHF_HI`
244			`* i == 2 -> UHF */`
245			`tuner_dbg("tv: param %d, range %d\n",j,i);`
246
247			`div=params->frequency + IFPCoff + offset;`
248
249			`tuner_dbg("Freq= %d.%02d MHz, V_IF=%d.%02d MHz, Offset=%d.%02d MHz, div=%0d\n",`
250			`params->frequency / 16, params->frequency % 16 * 100 / 16,`
251			`IFPCoff / 16, IFPCoff % 16 * 100 / 16,`
252			`offset / 16, offset % 16 * 100 / 16,`
253			`div);`
254
255			`/* tv norm specific stuff for multi-norm tuners */`
256			`switch (priv->type) {`
257			`case TUNER_PHILIPS_SECAM: // FI1216MF`
258			`/* 0x01 -> ??? no change ??? */`
259			`/* 0x02 -> PAL BDGHI / SECAM L */`
260			`/* 0x04 -> ??? PAL others / SECAM others ??? */`
261			`cb &= ~0x03;`
262			`if (params->std & V4L2_STD_SECAM_L) //also valid for V4L2_STD_SECAM`
263			`cb \|= PHILIPS_MF_SET_STD_L;`
264			`else if (params->std & V4L2_STD_SECAM_LC)`
265			`cb \|= PHILIPS_MF_SET_STD_LC;`
266			`else /* V4L2_STD_B\|V4L2_STD_GH */`
267			`cb \|= PHILIPS_MF_SET_STD_BG;`
268			`break;`
269
270			`case TUNER_TEMIC_4046FM5:`
271			`cb &= ~0x0f;`
272
273			`if (params->std & V4L2_STD_PAL_BG) {`
274			`cb \|= TEMIC_SET_PAL_BG;`
275
276			`} else if (params->std & V4L2_STD_PAL_I) {`
277			`cb \|= TEMIC_SET_PAL_I;`
278
279			`} else if (params->std & V4L2_STD_PAL_DK) {`
280			`cb \|= TEMIC_SET_PAL_DK;`
281
282			`} else if (params->std & V4L2_STD_SECAM_L) {`
283			`cb \|= TEMIC_SET_PAL_L;`
284
285			`}`
286			`break;`
287
288			`case TUNER_PHILIPS_FQ1216ME:`
289			`cb &= ~0x0f;`
290
291			`if (params->std & (V4L2_STD_PAL_BG\|V4L2_STD_PAL_DK)) {`
292			`cb \|= PHILIPS_SET_PAL_BGDK;`
293
294			`} else if (params->std & V4L2_STD_PAL_I) {`
295			`cb \|= PHILIPS_SET_PAL_I;`
296
297			`} else if (params->std & V4L2_STD_SECAM_L) {`
298			`cb \|= PHILIPS_SET_PAL_L;`
299
300			`}`
301			`break;`
302
303			`case TUNER_PHILIPS_ATSC:`
304			`/* 0x00 -> ATSC antenna input 1 */`
305			`/* 0x01 -> ATSC antenna input 2 */`
306			`/* 0x02 -> NTSC antenna input 1 */`
307			`/* 0x03 -> NTSC antenna input 2 */`
308			`cb &= ~0x03;`
309			`if (!(params->std & V4L2_STD_ATSC))`
310			`cb \|= 2;`
311			`/* FIXME: input */`
312			`break;`
313
314			`case TUNER_MICROTUNE_4042FI5:`
315			`/* Set the charge pump for fast tuning */`
316			`config \|= TUNER_CHARGE_PUMP;`
317			`break;`
318
319			`case TUNER_PHILIPS_TUV1236D:`
320			`/* 0x40 -> ATSC antenna input 1 */`
321			`/* 0x48 -> ATSC antenna input 2 */`
322			`/* 0x00 -> NTSC antenna input 1 */`
323			`/* 0x08 -> NTSC antenna input 2 */`
324			`buffer[0] = 0x14;`
325			`buffer[1] = 0x00;`
326			`buffer[2] = 0x17;`
327			`buffer[3] = 0x00;`
328			`cb &= ~0x40;`
329			`if (params->std & V4L2_STD_ATSC) {`
330			`cb \|= 0x40;`
331			`buffer[1] = 0x04;`
332			`}`
333			`/* set to the correct mode (analog or digital) */`
334			`tuneraddr = priv->i2c_props.addr;`
335			`priv->i2c_props.addr = 0x0a;`
336			`if (2 != (rc = tuner_i2c_xfer_send(&priv->i2c_props,&buffer[0],2)))`
337			`tuner_warn("i2c i/o error: rc == %d (should be 2)\n",rc);`
338			`if (2 != (rc = tuner_i2c_xfer_send(&priv->i2c_props,&buffer[2],2)))`
339			`tuner_warn("i2c i/o error: rc == %d (should be 2)\n",rc);`
340			`priv->i2c_props.addr = tuneraddr;`
341			`/* FIXME: input */`
342			`break;`
343			`}`
344
345			`if (t_params->cb_first_if_lower_freq && div < priv->last_div) {`
346			`buffer[0] = config;`
347			`buffer[1] = cb;`
348			`buffer[2] = (div>>8) & 0x7f;`
349			`buffer[3] = div & 0xff;`
350			`} else {`
351			`buffer[0] = (div>>8) & 0x7f;`
352			`buffer[1] = div & 0xff;`
353			`buffer[2] = config;`
354			`buffer[3] = cb;`
355			`}`
356			`priv->last_div = div;`
357			`if (t_params->has_tda9887) {`
358			`int config = 0;`
359			`int is_secam_l = (params->std & (V4L2_STD_SECAM_L \| V4L2_STD_SECAM_LC)) &&`
360			`!(params->std & ~(V4L2_STD_SECAM_L \| V4L2_STD_SECAM_LC));`
361
362			`if (params->std == V4L2_STD_SECAM_LC) {`
363			`if (t_params->port1_active ^ t_params->port1_invert_for_secam_lc)`
364			`config \|= TDA9887_PORT1_ACTIVE;`
365			`if (t_params->port2_active ^ t_params->port2_invert_for_secam_lc)`
366			`config \|= TDA9887_PORT2_ACTIVE;`
367			`}`
368			`else {`
369			`if (t_params->port1_active)`
370			`config \|= TDA9887_PORT1_ACTIVE;`
371			`if (t_params->port2_active)`
372			`config \|= TDA9887_PORT2_ACTIVE;`
373			`}`
374			`if (t_params->intercarrier_mode)`
375			`config \|= TDA9887_INTERCARRIER;`
376			`if (is_secam_l) {`
377			`if (i == 0 && t_params->default_top_secam_low)`
378			`config \|= TDA9887_TOP(t_params->default_top_secam_low);`
379			`else if (i == 1 && t_params->default_top_secam_mid)`
380			`config \|= TDA9887_TOP(t_params->default_top_secam_mid);`
381			`else if (t_params->default_top_secam_high)`
382			`config \|= TDA9887_TOP(t_params->default_top_secam_high);`
383			`}`
384			`else {`
385			`if (i == 0 && t_params->default_top_low)`
386			`config \|= TDA9887_TOP(t_params->default_top_low);`
387			`else if (i == 1 && t_params->default_top_mid)`
388			`config \|= TDA9887_TOP(t_params->default_top_mid);`
389			`else if (t_params->default_top_high)`
390			`config \|= TDA9887_TOP(t_params->default_top_high);`
391			`}`
392			`if (t_params->default_pll_gating_18)`
393			`config \|= TDA9887_GATING_18;`
394			`i2c_clients_command(priv->i2c_props.adap, TDA9887_SET_CONFIG, &config);`
395			`}`
396			`tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n",`
397			`buffer[0],buffer[1],buffer[2],buffer[3]);`
398
399			`if (4 != (rc = tuner_i2c_xfer_send(&priv->i2c_props,buffer,4)))`
400			`tuner_warn("i2c i/o error: rc == %d (should be 4)\n",rc);`
401
402			`switch (priv->type) {`
403			`case TUNER_LG_TDVS_H06XF:`
404			`/* Set the Auxiliary Byte. */`
405			`buffer[0] = buffer[2];`
406			`buffer[0] &= ~0x20;`
407			`buffer[0] \|= 0x18;`
408			`buffer[1] = 0x20;`
409			`tuner_dbg("tv 0x%02x 0x%02x\n",buffer[0],buffer[1]);`
410
411			`if (2 != (rc = tuner_i2c_xfer_send(&priv->i2c_props,buffer,2)))`
412			`tuner_warn("i2c i/o error: rc == %d (should be 2)\n",rc);`
413			`break;`
414			`case TUNER_MICROTUNE_4042FI5:`
415			`{`
416			`// FIXME - this may also work for other tuners`
417			`unsigned long timeout = jiffies + msecs_to_jiffies(1);`
418			`u8 status_byte = 0;`
419
420			`/* Wait until the PLL locks */`
421			`for (;;) {`
422			`if (time_after(jiffies,timeout))`
423			`return 0;`
424			`if (1 != (rc = tuner_i2c_xfer_recv(&priv->i2c_props,&status_byte,1))) {`
425			`tuner_warn("i2c i/o read error: rc == %d (should be 1)\n",rc);`
426			`break;`
427			`}`
428			`if (status_byte & TUNER_PLL_LOCKED)`
429			`break;`
430			`udelay(10);`
431			`}`
432
433			`/* Set the charge pump for optimized phase noise figure */`
434			`config &= ~TUNER_CHARGE_PUMP;`
435			`buffer[0] = (div>>8) & 0x7f;`
436			`buffer[1] = div & 0xff;`
437			`buffer[2] = config;`
438			`buffer[3] = cb;`
439			`tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n",`
440			`buffer[0],buffer[1],buffer[2],buffer[3]);`
441
442			`if (4 != (rc = tuner_i2c_xfer_send(&priv->i2c_props,buffer,4)))`
443			`tuner_warn("i2c i/o error: rc == %d (should be 4)\n",rc);`
444			`break;`
445			`}`
446			`}`
447			`return 0;`
448			`}`
449
450			`static int simple_set_radio_freq(struct dvb_frontend *fe,`
451			`struct analog_parameters *params)`
452			`{`
453			`struct tunertype *tun;`
454			`struct tuner_simple_priv *priv = fe->tuner_priv;`
455			`u8 buffer[4];`
456			`u16 div;`
457			`int rc, j;`
458			`struct tuner_params *t_params;`
459			`unsigned int freq = params->frequency;`
460
461			`tun = priv->tun;`
462
463			`for (j = tun->count-1; j > 0; j--)`
464			`if (tun->params[j].type == TUNER_PARAM_TYPE_RADIO)`
465			`break;`
466			`/* default t_params (j=0) will be used if desired type wasn't found */`
467			`t_params = &tun->params[j];`
468
469			`/* Select Radio 1st IF used */`
470			`switch (t_params->radio_if) {`
471			`case 0: /* 10.7 MHz */`
472			`freq += (unsigned int)(10.7*16000);`
473			`break;`
474			`case 1: /* 33.3 MHz */`
475			`freq += (unsigned int)(33.3*16000);`
476			`break;`
477			`case 2: /* 41.3 MHz */`
478			`freq += (unsigned int)(41.3*16000);`
479			`break;`
480			`default:`
481			`tuner_warn("Unsupported radio_if value %d\n", t_params->radio_if);`
482			`return 0;`
483			`}`
484
485			`/* Bandswitch byte */`
486			`switch (priv->type) {`
487			`case TUNER_TENA_9533_DI:`
488			`case TUNER_YMEC_TVF_5533MF:`
489			`tuner_dbg("This tuner doesn't have FM. Most cards have a TEA5767 for FM\n");`
490			`return 0;`
491			`case TUNER_PHILIPS_FM1216ME_MK3:`
492			`case TUNER_PHILIPS_FM1236_MK3:`
493			`case TUNER_PHILIPS_FMD1216ME_MK3:`
494			`case TUNER_LG_NTSC_TAPE:`
495			`case TUNER_PHILIPS_FM1256_IH3:`
496			`buffer[3] = 0x19;`
497			`break;`
498			`case TUNER_TNF_5335MF:`
499			`buffer[3] = 0x11;`
500			`break;`
501			`case TUNER_LG_PAL_FM:`
502			`buffer[3] = 0xa5;`
503			`break;`
504			`case TUNER_THOMSON_DTT761X:`
505			`buffer[3] = 0x39;`
506			`break;`
507			`case TUNER_MICROTUNE_4049FM5:`
508			`default:`
509			`buffer[3] = 0xa4;`
510			`break;`
511			`}`
512
513			`buffer[2] = (t_params->ranges[0].config & ~TUNER_RATIO_MASK) \|`
514			`TUNER_RATIO_SELECT_50; /* 50 kHz step */`
515
516			`/* Convert from 1/16 kHz V4L steps to 1/20 MHz (=50 kHz) PLL steps`
517			`freq * (1 Mhz / 16000 V4L steps) * (20 PLL steps / 1 MHz) =`
518			`freq * (1/800) */`
519			`div = (freq + 400) / 800;`
520
521			`if (t_params->cb_first_if_lower_freq && div < priv->last_div) {`
522			`buffer[0] = buffer[2];`
523			`buffer[1] = buffer[3];`
524			`buffer[2] = (div>>8) & 0x7f;`
525			`buffer[3] = div & 0xff;`
526			`} else {`
527			`buffer[0] = (div>>8) & 0x7f;`
528			`buffer[1] = div & 0xff;`
529			`}`
530
531			`tuner_dbg("radio 0x%02x 0x%02x 0x%02x 0x%02x\n",`
532			`buffer[0],buffer[1],buffer[2],buffer[3]);`
533			`priv->last_div = div;`
534
535			`if (t_params->has_tda9887) {`
536			`int config = 0;`
537			`if (t_params->port1_active && !t_params->port1_fm_high_sensitivity)`
538			`config \|= TDA9887_PORT1_ACTIVE;`
539			`if (t_params->port2_active && !t_params->port2_fm_high_sensitivity)`
540			`config \|= TDA9887_PORT2_ACTIVE;`
541			`if (t_params->intercarrier_mode)`
542			`config \|= TDA9887_INTERCARRIER;`
543			`/* if (t_params->port1_set_for_fm_mono)`
544			`config &= ~TDA9887_PORT1_ACTIVE;*/`
545			`if (t_params->fm_gain_normal)`
546			`config \|= TDA9887_GAIN_NORMAL;`
547			`if (t_params->radio_if == 2)`
548			`config \|= TDA9887_RIF_41_3;`
549			`i2c_clients_command(priv->i2c_props.adap, TDA9887_SET_CONFIG, &config);`
550			`}`
551			`if (4 != (rc = tuner_i2c_xfer_send(&priv->i2c_props,buffer,4)))`
552			`tuner_warn("i2c i/o error: rc == %d (should be 4)\n",rc);`
553
554			`return 0;`
555			`}`
556
557			`static int simple_set_params(struct dvb_frontend *fe,`
558			`struct analog_parameters *params)`
559			`{`
560			`struct tuner_simple_priv *priv = fe->tuner_priv;`
561			`int ret = -EINVAL;`
562
563			`switch (params->mode) {`
564			`case V4L2_TUNER_RADIO:`
565			`ret = simple_set_radio_freq(fe, params);`
566			`priv->frequency = params->frequency * 125 / 2;`
567			`break;`
568			`case V4L2_TUNER_ANALOG_TV:`
569			`case V4L2_TUNER_DIGITAL_TV:`
570			`ret = simple_set_tv_freq(fe, params);`
571			`priv->frequency = params->frequency * 62500;`
572			`break;`
573			`}`
574
575			`return ret;`
576			`}`
577
578
579			`static int simple_release(struct dvb_frontend *fe)`
580			`{`
581			`kfree(fe->tuner_priv);`
582			`fe->tuner_priv = NULL;`
583
584			`return 0;`
585			`}`
586
587			`static int simple_get_frequency(struct dvb_frontend fe, u32 frequency)`
588			`{`
589			`struct tuner_simple_priv *priv = fe->tuner_priv;`
590			`*frequency = priv->frequency;`
591			`return 0;`
592			`}`
593
594			`static struct dvb_tuner_ops simple_tuner_ops = {`
595			`.set_analog_params = simple_set_params,`
596			`.release = simple_release,`
597			`.get_frequency = simple_get_frequency,`
598			`.get_status = simple_get_status,`
599			`.get_rf_strength = simple_get_rf_strength,`
600			`};`
601
602			`struct dvb_frontend simple_tuner_attach(struct dvb_frontend fe,`
603			`struct i2c_adapter *i2c_adap,`
604			`u8 i2c_addr,`
605			`struct simple_tuner_config *cfg)`
606			`{`
607			`struct tuner_simple_priv *priv = NULL;`
608
609			`priv = kzalloc(sizeof(struct tuner_simple_priv), GFP_KERNEL);`
610			`if (priv == NULL)`
611			`return NULL;`
612			`fe->tuner_priv = priv;`
613
614			`priv->i2c_props.addr = i2c_addr;`
615			`priv->i2c_props.adap = i2c_adap;`
616			`priv->type = cfg->type;`
617			`priv->tun = cfg->tun;`
618
619			`memcpy(&fe->ops.tuner_ops, &simple_tuner_ops, sizeof(struct dvb_tuner_ops));`
620
621			`tuner_info("type set to %d (%s)\n", cfg->type, cfg->tun->name);`
622
623			`strlcpy(fe->ops.tuner_ops.info.name, cfg->tun->name, sizeof(fe->ops.tuner_ops.info.name));`
624
625			`return fe;`
626			`}`
627
628
629			`EXPORT_SYMBOL_GPL(simple_tuner_attach);`
630
631			`MODULE_DESCRIPTION("Simple 4-control-bytes style tuner driver");`
632			`MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");`
633			`MODULE_LICENSE("GPL");`
634
635			`/*`
636			`* Overrides for Emacs so that we follow Linus's tabbing style.`
637			`* ---------------------------------------------------------------------------`
638			`* Local variables:`
639			`* c-basic-offset: 8`
640			`* End:`
641			`*/`