Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * i2c tv tuner chip device driver
0004  * core core, i.e. kernel interfaces, registering and so on
0005  *
0006  * Copyright(c) by Ralph Metzler, Gerd Knorr, Gunther Mayer
0007  *
0008  * Copyright(c) 2005-2011 by Mauro Carvalho Chehab
0009  *  - Added support for a separate Radio tuner
0010  *  - Major rework and cleanups at the code
0011  *
0012  * This driver supports many devices and the idea is to let the driver
0013  * detect which device is present. So rather than listing all supported
0014  * devices here, we pretend to support a single, fake device type that will
0015  * handle both radio and analog TV tuning.
0016  */
0017 
0018 #include <linux/module.h>
0019 #include <linux/kernel.h>
0020 #include <linux/string.h>
0021 #include <linux/timer.h>
0022 #include <linux/delay.h>
0023 #include <linux/errno.h>
0024 #include <linux/slab.h>
0025 #include <linux/poll.h>
0026 #include <linux/i2c.h>
0027 #include <linux/types.h>
0028 #include <linux/init.h>
0029 #include <linux/videodev2.h>
0030 #include <media/tuner.h>
0031 #include <media/tuner-types.h>
0032 #include <media/v4l2-device.h>
0033 #include <media/v4l2-ioctl.h>
0034 #include "mt20xx.h"
0035 #include "tda8290.h"
0036 #include "tea5761.h"
0037 #include "tea5767.h"
0038 #include "xc2028.h"
0039 #include "tuner-simple.h"
0040 #include "tda9887.h"
0041 #include "xc5000.h"
0042 #include "tda18271.h"
0043 #include "xc4000.h"
0044 
0045 #define UNSET (-1U)
0046 
0047 /*
0048  * Driver modprobe parameters
0049  */
0050 
0051 /* insmod options used at init time => read/only */
0052 static unsigned int addr;
0053 static unsigned int no_autodetect;
0054 static unsigned int show_i2c;
0055 
0056 module_param(addr, int, 0444);
0057 module_param(no_autodetect, int, 0444);
0058 module_param(show_i2c, int, 0444);
0059 
0060 /* insmod options used at runtime => read/write */
0061 static int tuner_debug;
0062 static unsigned int tv_range[2] = { 44, 958 };
0063 static unsigned int radio_range[2] = { 65, 108 };
0064 static char pal[] = "--";
0065 static char secam[] = "--";
0066 static char ntsc[] = "-";
0067 
0068 module_param_named(debug, tuner_debug, int, 0644);
0069 module_param_array(tv_range, int, NULL, 0644);
0070 module_param_array(radio_range, int, NULL, 0644);
0071 module_param_string(pal, pal, sizeof(pal), 0644);
0072 module_param_string(secam, secam, sizeof(secam), 0644);
0073 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
0074 
0075 /*
0076  * Static vars
0077  */
0078 
0079 static LIST_HEAD(tuner_list);
0080 static const struct v4l2_subdev_ops tuner_ops;
0081 
0082 /*
0083  * Debug macros
0084  */
0085 
0086 #undef pr_fmt
0087 
0088 #define pr_fmt(fmt) KBUILD_MODNAME ": %d-%04x: " fmt,       \
0089     i2c_adapter_id(t->i2c->adapter), t->i2c->addr
0090 
0091 
0092 #define dprintk(fmt, arg...) do {                   \
0093     if (tuner_debug)                        \
0094         printk(KERN_DEBUG pr_fmt("%s: " fmt), __func__, ##arg); \
0095 } while (0)
0096 
0097 /*
0098  * Internal enums/struct used inside the driver
0099  */
0100 
0101 /**
0102  * enum tuner_pad_index - tuner pad index for MEDIA_ENT_F_TUNER
0103  *
0104  * @TUNER_PAD_RF_INPUT:
0105  *  Radiofrequency (RF) sink pad, usually linked to a RF connector entity.
0106  * @TUNER_PAD_OUTPUT:
0107  *  tuner video output source pad. Contains the video chrominance
0108  *  and luminance or the hole bandwidth of the signal converted to
0109  *  an Intermediate Frequency (IF) or to baseband (on zero-IF tuners).
0110  * @TUNER_PAD_AUD_OUT:
0111  *  Tuner audio output source pad. Tuners used to decode analog TV
0112  *  signals have an extra pad for audio output. Old tuners use an
0113  *  analog stage with a saw filter for the audio IF frequency. The
0114  *  output of the pad is, in this case, the audio IF, with should be
0115  *  decoded either by the bridge chipset (that's the case of cx2388x
0116  *  chipsets) or may require an external IF sound processor, like
0117  *  msp34xx. On modern silicon tuners, the audio IF decoder is usually
0118  *  incorporated at the tuner. On such case, the output of this pad
0119  *  is an audio sampled data.
0120  * @TUNER_NUM_PADS:
0121  *  Number of pads of the tuner.
0122  */
0123 enum tuner_pad_index {
0124     TUNER_PAD_RF_INPUT,
0125     TUNER_PAD_OUTPUT,
0126     TUNER_PAD_AUD_OUT,
0127     TUNER_NUM_PADS
0128 };
0129 
0130 /**
0131  * enum if_vid_dec_pad_index - video IF-PLL pad index
0132  *  for MEDIA_ENT_F_IF_VID_DECODER
0133  *
0134  * @IF_VID_DEC_PAD_IF_INPUT:
0135  *  video Intermediate Frequency (IF) sink pad
0136  * @IF_VID_DEC_PAD_OUT:
0137  *  IF-PLL video output source pad. Contains the video chrominance
0138  *  and luminance IF signals.
0139  * @IF_VID_DEC_PAD_NUM_PADS:
0140  *  Number of pads of the video IF-PLL.
0141  */
0142 enum if_vid_dec_pad_index {
0143     IF_VID_DEC_PAD_IF_INPUT,
0144     IF_VID_DEC_PAD_OUT,
0145     IF_VID_DEC_PAD_NUM_PADS
0146 };
0147 
0148 struct tuner {
0149     /* device */
0150     struct dvb_frontend fe;
0151     struct i2c_client   *i2c;
0152     struct v4l2_subdev  sd;
0153     struct list_head    list;
0154 
0155     /* keep track of the current settings */
0156     v4l2_std_id         std;
0157     unsigned int        tv_freq;
0158     unsigned int        radio_freq;
0159     unsigned int        audmode;
0160 
0161     enum v4l2_tuner_type mode;
0162     unsigned int        mode_mask; /* Combination of allowable modes */
0163 
0164     bool                standby;    /* Standby mode */
0165 
0166     unsigned int        type; /* chip type id */
0167     void                *config;
0168     const char          *name;
0169 
0170 #if defined(CONFIG_MEDIA_CONTROLLER)
0171     struct media_pad    pad[TUNER_NUM_PADS];
0172 #endif
0173 };
0174 
0175 /*
0176  * Function prototypes
0177  */
0178 
0179 static void set_tv_freq(struct i2c_client *c, unsigned int freq);
0180 static void set_radio_freq(struct i2c_client *c, unsigned int freq);
0181 
0182 /*
0183  * tuner attach/detach logic
0184  */
0185 
0186 /* This macro allows us to probe dynamically, avoiding static links */
0187 #ifdef CONFIG_MEDIA_ATTACH
0188 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
0189     int __r = -EINVAL; \
0190     typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
0191     if (__a) { \
0192         __r = (int) __a(ARGS); \
0193         symbol_put(FUNCTION); \
0194     } else { \
0195         printk(KERN_ERR "TUNER: Unable to find " \
0196                 "symbol "#FUNCTION"()\n"); \
0197     } \
0198     __r; \
0199 })
0200 
0201 static void tuner_detach(struct dvb_frontend *fe)
0202 {
0203     if (fe->ops.tuner_ops.release) {
0204         fe->ops.tuner_ops.release(fe);
0205         symbol_put_addr(fe->ops.tuner_ops.release);
0206     }
0207     if (fe->ops.analog_ops.release) {
0208         fe->ops.analog_ops.release(fe);
0209         symbol_put_addr(fe->ops.analog_ops.release);
0210     }
0211 }
0212 #else
0213 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
0214     FUNCTION(ARGS); \
0215 })
0216 
0217 static void tuner_detach(struct dvb_frontend *fe)
0218 {
0219     if (fe->ops.tuner_ops.release)
0220         fe->ops.tuner_ops.release(fe);
0221     if (fe->ops.analog_ops.release)
0222         fe->ops.analog_ops.release(fe);
0223 }
0224 #endif
0225 
0226 
0227 static inline struct tuner *to_tuner(struct v4l2_subdev *sd)
0228 {
0229     return container_of(sd, struct tuner, sd);
0230 }
0231 
0232 /*
0233  * struct analog_demod_ops callbacks
0234  */
0235 
0236 static void fe_set_params(struct dvb_frontend *fe,
0237               struct analog_parameters *params)
0238 {
0239     struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
0240     struct tuner *t = fe->analog_demod_priv;
0241 
0242     if (NULL == fe_tuner_ops->set_analog_params) {
0243         pr_warn("Tuner frontend module has no way to set freq\n");
0244         return;
0245     }
0246     fe_tuner_ops->set_analog_params(fe, params);
0247 }
0248 
0249 static void fe_standby(struct dvb_frontend *fe)
0250 {
0251     struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
0252 
0253     if (fe_tuner_ops->sleep)
0254         fe_tuner_ops->sleep(fe);
0255 }
0256 
0257 static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
0258 {
0259     struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
0260     struct tuner *t = fe->analog_demod_priv;
0261 
0262     if (fe_tuner_ops->set_config)
0263         return fe_tuner_ops->set_config(fe, priv_cfg);
0264 
0265     pr_warn("Tuner frontend module has no way to set config\n");
0266 
0267     return 0;
0268 }
0269 
0270 static void tuner_status(struct dvb_frontend *fe);
0271 
0272 static const struct analog_demod_ops tuner_analog_ops = {
0273     .set_params     = fe_set_params,
0274     .standby        = fe_standby,
0275     .set_config     = fe_set_config,
0276     .tuner_status   = tuner_status
0277 };
0278 
0279 /*
0280  * Functions to select between radio and TV and tuner probe/remove functions
0281  */
0282 
0283 /**
0284  * set_type - Sets the tuner type for a given device
0285  *
0286  * @c:          i2c_client descriptor
0287  * @type:       type of the tuner (e. g. tuner number)
0288  * @new_mode_mask:  Indicates if tuner supports TV and/or Radio
0289  * @new_config:     an optional parameter used by a few tuners to adjust
0290  *          internal parameters, like LNA mode
0291  * @tuner_callback: an optional function to be called when switching
0292  *          to analog mode
0293  *
0294  * This function applies the tuner config to tuner specified
0295  * by tun_setup structure. It contains several per-tuner initialization "magic"
0296  */
0297 static void set_type(struct i2c_client *c, unsigned int type,
0298              unsigned int new_mode_mask, void *new_config,
0299              int (*tuner_callback) (void *dev, int component, int cmd, int arg))
0300 {
0301     struct tuner *t = to_tuner(i2c_get_clientdata(c));
0302     struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
0303     struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
0304     unsigned char buffer[4];
0305     int tune_now = 1;
0306 
0307     if (type == UNSET || type == TUNER_ABSENT) {
0308         dprintk("tuner 0x%02x: Tuner type absent\n", c->addr);
0309         return;
0310     }
0311 
0312     t->type = type;
0313     t->config = new_config;
0314     if (tuner_callback != NULL) {
0315         dprintk("defining GPIO callback\n");
0316         t->fe.callback = tuner_callback;
0317     }
0318 
0319     /* discard private data, in case set_type() was previously called */
0320     tuner_detach(&t->fe);
0321     t->fe.analog_demod_priv = NULL;
0322 
0323     switch (t->type) {
0324     case TUNER_MT2032:
0325         if (!dvb_attach(microtune_attach,
0326                &t->fe, t->i2c->adapter, t->i2c->addr))
0327             goto attach_failed;
0328         break;
0329     case TUNER_PHILIPS_TDA8290:
0330     {
0331         if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
0332                 t->i2c->addr, t->config))
0333             goto attach_failed;
0334         break;
0335     }
0336     case TUNER_TEA5767:
0337         if (!dvb_attach(tea5767_attach, &t->fe,
0338                 t->i2c->adapter, t->i2c->addr))
0339             goto attach_failed;
0340         t->mode_mask = T_RADIO;
0341         break;
0342     case TUNER_TEA5761:
0343         if (!dvb_attach(tea5761_attach, &t->fe,
0344                 t->i2c->adapter, t->i2c->addr))
0345             goto attach_failed;
0346         t->mode_mask = T_RADIO;
0347         break;
0348     case TUNER_PHILIPS_FMD1216ME_MK3:
0349     case TUNER_PHILIPS_FMD1216MEX_MK3:
0350         buffer[0] = 0x0b;
0351         buffer[1] = 0xdc;
0352         buffer[2] = 0x9c;
0353         buffer[3] = 0x60;
0354         i2c_master_send(c, buffer, 4);
0355         mdelay(1);
0356         buffer[2] = 0x86;
0357         buffer[3] = 0x54;
0358         i2c_master_send(c, buffer, 4);
0359         if (!dvb_attach(simple_tuner_attach, &t->fe,
0360                 t->i2c->adapter, t->i2c->addr, t->type))
0361             goto attach_failed;
0362         break;
0363     case TUNER_PHILIPS_TD1316:
0364         buffer[0] = 0x0b;
0365         buffer[1] = 0xdc;
0366         buffer[2] = 0x86;
0367         buffer[3] = 0xa4;
0368         i2c_master_send(c, buffer, 4);
0369         if (!dvb_attach(simple_tuner_attach, &t->fe,
0370                 t->i2c->adapter, t->i2c->addr, t->type))
0371             goto attach_failed;
0372         break;
0373     case TUNER_XC2028:
0374     {
0375         struct xc2028_config cfg = {
0376             .i2c_adap  = t->i2c->adapter,
0377             .i2c_addr  = t->i2c->addr,
0378         };
0379         if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
0380             goto attach_failed;
0381         tune_now = 0;
0382         break;
0383     }
0384     case TUNER_TDA9887:
0385         if (!dvb_attach(tda9887_attach,
0386                &t->fe, t->i2c->adapter, t->i2c->addr))
0387             goto attach_failed;
0388         break;
0389     case TUNER_XC5000:
0390     {
0391         struct xc5000_config xc5000_cfg = {
0392             .i2c_address = t->i2c->addr,
0393             /* if_khz will be set at dvb_attach() */
0394             .if_khz   = 0,
0395         };
0396 
0397         if (!dvb_attach(xc5000_attach,
0398                 &t->fe, t->i2c->adapter, &xc5000_cfg))
0399             goto attach_failed;
0400         tune_now = 0;
0401         break;
0402     }
0403     case TUNER_XC5000C:
0404     {
0405         struct xc5000_config xc5000c_cfg = {
0406             .i2c_address = t->i2c->addr,
0407             /* if_khz will be set at dvb_attach() */
0408             .if_khz   = 0,
0409             .chip_id  = XC5000C,
0410         };
0411 
0412         if (!dvb_attach(xc5000_attach,
0413                 &t->fe, t->i2c->adapter, &xc5000c_cfg))
0414             goto attach_failed;
0415         tune_now = 0;
0416         break;
0417     }
0418     case TUNER_NXP_TDA18271:
0419     {
0420         struct tda18271_config cfg = {
0421             .small_i2c = TDA18271_03_BYTE_CHUNK_INIT,
0422         };
0423 
0424         if (!dvb_attach(tda18271_attach, &t->fe, t->i2c->addr,
0425                 t->i2c->adapter, &cfg))
0426             goto attach_failed;
0427         tune_now = 0;
0428         break;
0429     }
0430     case TUNER_XC4000:
0431     {
0432         struct xc4000_config xc4000_cfg = {
0433             .i2c_address      = t->i2c->addr,
0434             /* FIXME: the correct parameters will be set */
0435             /* only when the digital dvb_attach() occurs */
0436             .default_pm   = 0,
0437             .dvb_amplitude    = 0,
0438             .set_smoothedcvbs = 0,
0439             .if_khz       = 0
0440         };
0441         if (!dvb_attach(xc4000_attach,
0442                 &t->fe, t->i2c->adapter, &xc4000_cfg))
0443             goto attach_failed;
0444         tune_now = 0;
0445         break;
0446     }
0447     default:
0448         if (!dvb_attach(simple_tuner_attach, &t->fe,
0449                 t->i2c->adapter, t->i2c->addr, t->type))
0450             goto attach_failed;
0451 
0452         break;
0453     }
0454 
0455     if ((NULL == analog_ops->set_params) &&
0456         (fe_tuner_ops->set_analog_params)) {
0457 
0458         t->name = fe_tuner_ops->info.name;
0459 
0460         t->fe.analog_demod_priv = t;
0461         memcpy(analog_ops, &tuner_analog_ops,
0462                sizeof(struct analog_demod_ops));
0463 
0464         if (fe_tuner_ops->get_rf_strength)
0465             analog_ops->has_signal = fe_tuner_ops->get_rf_strength;
0466         if (fe_tuner_ops->get_afc)
0467             analog_ops->get_afc = fe_tuner_ops->get_afc;
0468 
0469     } else {
0470         t->name = analog_ops->info.name;
0471     }
0472 
0473 #ifdef CONFIG_MEDIA_CONTROLLER
0474     t->sd.entity.name = t->name;
0475 #endif
0476 
0477     dprintk("type set to %s\n", t->name);
0478 
0479     t->mode_mask = new_mode_mask;
0480 
0481     /* Some tuners require more initialization setup before use,
0482        such as firmware download or device calibration.
0483        trying to set a frequency here will just fail
0484        FIXME: better to move set_freq to the tuner code. This is needed
0485        on analog tuners for PLL to properly work
0486      */
0487     if (tune_now) {
0488         if (V4L2_TUNER_RADIO == t->mode)
0489             set_radio_freq(c, t->radio_freq);
0490         else
0491             set_tv_freq(c, t->tv_freq);
0492     }
0493 
0494     dprintk("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
0495           c->adapter->name, c->dev.driver->name, c->addr << 1, type,
0496           t->mode_mask);
0497     return;
0498 
0499 attach_failed:
0500     dprintk("Tuner attach for type = %d failed.\n", t->type);
0501     t->type = TUNER_ABSENT;
0502 
0503     return;
0504 }
0505 
0506 /**
0507  * tuner_s_type_addr - Sets the tuner type for a device
0508  *
0509  * @sd:     subdev descriptor
0510  * @tun_setup:  type to be associated to a given tuner i2c address
0511  *
0512  * This function applies the tuner config to tuner specified
0513  * by tun_setup structure.
0514  * If tuner I2C address is UNSET, then it will only set the device
0515  * if the tuner supports the mode specified in the call.
0516  * If the address is specified, the change will be applied only if
0517  * tuner I2C address matches.
0518  * The call can change the tuner number and the tuner mode.
0519  */
0520 static int tuner_s_type_addr(struct v4l2_subdev *sd,
0521                  struct tuner_setup *tun_setup)
0522 {
0523     struct tuner *t = to_tuner(sd);
0524     struct i2c_client *c = v4l2_get_subdevdata(sd);
0525 
0526     dprintk("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=%p\n",
0527             tun_setup->type,
0528             tun_setup->addr,
0529             tun_setup->mode_mask,
0530             tun_setup->config);
0531 
0532     if ((t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
0533         (t->mode_mask & tun_setup->mode_mask))) ||
0534         (tun_setup->addr == c->addr)) {
0535         set_type(c, tun_setup->type, tun_setup->mode_mask,
0536              tun_setup->config, tun_setup->tuner_callback);
0537     } else
0538         dprintk("set addr discarded for type %i, mask %x. Asked to change tuner at addr 0x%02x, with mask %x\n",
0539               t->type, t->mode_mask,
0540               tun_setup->addr, tun_setup->mode_mask);
0541 
0542     return 0;
0543 }
0544 
0545 /**
0546  * tuner_s_config - Sets tuner configuration
0547  *
0548  * @sd:     subdev descriptor
0549  * @cfg:    tuner configuration
0550  *
0551  * Calls tuner set_config() private function to set some tuner-internal
0552  * parameters
0553  */
0554 static int tuner_s_config(struct v4l2_subdev *sd,
0555               const struct v4l2_priv_tun_config *cfg)
0556 {
0557     struct tuner *t = to_tuner(sd);
0558     struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
0559 
0560     if (t->type != cfg->tuner)
0561         return 0;
0562 
0563     if (analog_ops->set_config) {
0564         analog_ops->set_config(&t->fe, cfg->priv);
0565         return 0;
0566     }
0567 
0568     dprintk("Tuner frontend module has no way to set config\n");
0569     return 0;
0570 }
0571 
0572 /**
0573  * tuner_lookup - Seek for tuner adapters
0574  *
0575  * @adap:   i2c_adapter struct
0576  * @radio:  pointer to be filled if the adapter is radio
0577  * @tv:     pointer to be filled if the adapter is TV
0578  *
0579  * Search for existing radio and/or TV tuners on the given I2C adapter,
0580  * discarding demod-only adapters (tda9887).
0581  *
0582  * Note that when this function is called from tuner_probe you can be
0583  * certain no other devices will be added/deleted at the same time, I2C
0584  * core protects against that.
0585  */
0586 static void tuner_lookup(struct i2c_adapter *adap,
0587         struct tuner **radio, struct tuner **tv)
0588 {
0589     struct tuner *pos;
0590 
0591     *radio = NULL;
0592     *tv = NULL;
0593 
0594     list_for_each_entry(pos, &tuner_list, list) {
0595         int mode_mask;
0596 
0597         if (pos->i2c->adapter != adap ||
0598             strcmp(pos->i2c->dev.driver->name, "tuner"))
0599             continue;
0600 
0601         mode_mask = pos->mode_mask;
0602         if (*radio == NULL && mode_mask == T_RADIO)
0603             *radio = pos;
0604         /* Note: currently TDA9887 is the only demod-only
0605            device. If other devices appear then we need to
0606            make this test more general. */
0607         else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
0608              (pos->mode_mask & T_ANALOG_TV))
0609             *tv = pos;
0610     }
0611 }
0612 
0613 /**
0614  *tuner_probe - Probes the existing tuners on an I2C bus
0615  *
0616  * @client: i2c_client descriptor
0617  * @id:     not used
0618  *
0619  * This routine probes for tuners at the expected I2C addresses. On most
0620  * cases, if a device answers to a given I2C address, it assumes that the
0621  * device is a tuner. On a few cases, however, an additional logic is needed
0622  * to double check if the device is really a tuner, or to identify the tuner
0623  * type, like on tea5767/5761 devices.
0624  *
0625  * During client attach, set_type is called by adapter's attach_inform callback.
0626  * set_type must then be completed by tuner_probe.
0627  */
0628 static int tuner_probe(struct i2c_client *client,
0629                const struct i2c_device_id *id)
0630 {
0631     struct tuner *t;
0632     struct tuner *radio;
0633     struct tuner *tv;
0634 #ifdef CONFIG_MEDIA_CONTROLLER
0635     int ret;
0636 #endif
0637 
0638     t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
0639     if (NULL == t)
0640         return -ENOMEM;
0641     v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
0642     t->i2c = client;
0643     t->name = "(tuner unset)";
0644     t->type = UNSET;
0645     t->audmode = V4L2_TUNER_MODE_STEREO;
0646     t->standby = true;
0647     t->radio_freq = 87.5 * 16000;   /* Initial freq range */
0648     t->tv_freq = 400 * 16; /* Sets freq to VHF High - needed for some PLL's to properly start */
0649 
0650     if (show_i2c) {
0651         unsigned char buffer[16];
0652         int rc;
0653 
0654         memset(buffer, 0, sizeof(buffer));
0655         rc = i2c_master_recv(client, buffer, sizeof(buffer));
0656         if (rc >= 0)
0657             pr_info("I2C RECV = %*ph\n", rc, buffer);
0658     }
0659 
0660     /* autodetection code based on the i2c addr */
0661     if (!no_autodetect) {
0662         switch (client->addr) {
0663         case 0x10:
0664             if (tuner_symbol_probe(tea5761_autodetection,
0665                            t->i2c->adapter,
0666                            t->i2c->addr) >= 0) {
0667                 t->type = TUNER_TEA5761;
0668                 t->mode_mask = T_RADIO;
0669                 tuner_lookup(t->i2c->adapter, &radio, &tv);
0670                 if (tv)
0671                     tv->mode_mask &= ~T_RADIO;
0672 
0673                 goto register_client;
0674             }
0675             kfree(t);
0676             return -ENODEV;
0677         case 0x42:
0678         case 0x43:
0679         case 0x4a:
0680         case 0x4b:
0681             /* If chip is not tda8290, don't register.
0682                since it can be tda9887*/
0683             if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
0684                            t->i2c->addr) >= 0) {
0685                 dprintk("tda829x detected\n");
0686             } else {
0687                 /* Default is being tda9887 */
0688                 t->type = TUNER_TDA9887;
0689                 t->mode_mask = T_RADIO | T_ANALOG_TV;
0690                 goto register_client;
0691             }
0692             break;
0693         case 0x60:
0694             if (tuner_symbol_probe(tea5767_autodetection,
0695                            t->i2c->adapter, t->i2c->addr)
0696                     >= 0) {
0697                 t->type = TUNER_TEA5767;
0698                 t->mode_mask = T_RADIO;
0699                 /* Sets freq to FM range */
0700                 tuner_lookup(t->i2c->adapter, &radio, &tv);
0701                 if (tv)
0702                     tv->mode_mask &= ~T_RADIO;
0703 
0704                 goto register_client;
0705             }
0706             break;
0707         }
0708     }
0709 
0710     /* Initializes only the first TV tuner on this adapter. Why only the
0711        first? Because there are some devices (notably the ones with TI
0712        tuners) that have more than one i2c address for the *same* device.
0713        Experience shows that, except for just one case, the first
0714        address is the right one. The exception is a Russian tuner
0715        (ACORP_Y878F). So, the desired behavior is just to enable the
0716        first found TV tuner. */
0717     tuner_lookup(t->i2c->adapter, &radio, &tv);
0718     if (tv == NULL) {
0719         t->mode_mask = T_ANALOG_TV;
0720         if (radio == NULL)
0721             t->mode_mask |= T_RADIO;
0722         dprintk("Setting mode_mask to 0x%02x\n", t->mode_mask);
0723     }
0724 
0725     /* Should be just before return */
0726 register_client:
0727 #if defined(CONFIG_MEDIA_CONTROLLER)
0728     t->sd.entity.name = t->name;
0729     /*
0730      * Handle the special case where the tuner has actually
0731      * two stages: the PLL to tune into a frequency and the
0732      * IF-PLL demodulator (tda988x).
0733      */
0734     if (t->type == TUNER_TDA9887) {
0735         t->pad[IF_VID_DEC_PAD_IF_INPUT].flags = MEDIA_PAD_FL_SINK;
0736         t->pad[IF_VID_DEC_PAD_IF_INPUT].sig_type = PAD_SIGNAL_ANALOG;
0737         t->pad[IF_VID_DEC_PAD_OUT].flags = MEDIA_PAD_FL_SOURCE;
0738         t->pad[IF_VID_DEC_PAD_OUT].sig_type = PAD_SIGNAL_ANALOG;
0739         ret = media_entity_pads_init(&t->sd.entity,
0740                          IF_VID_DEC_PAD_NUM_PADS,
0741                          &t->pad[0]);
0742         t->sd.entity.function = MEDIA_ENT_F_IF_VID_DECODER;
0743     } else {
0744         t->pad[TUNER_PAD_RF_INPUT].flags = MEDIA_PAD_FL_SINK;
0745         t->pad[TUNER_PAD_RF_INPUT].sig_type = PAD_SIGNAL_ANALOG;
0746         t->pad[TUNER_PAD_OUTPUT].flags = MEDIA_PAD_FL_SOURCE;
0747         t->pad[TUNER_PAD_OUTPUT].sig_type = PAD_SIGNAL_ANALOG;
0748         t->pad[TUNER_PAD_AUD_OUT].flags = MEDIA_PAD_FL_SOURCE;
0749         t->pad[TUNER_PAD_AUD_OUT].sig_type = PAD_SIGNAL_AUDIO;
0750         ret = media_entity_pads_init(&t->sd.entity, TUNER_NUM_PADS,
0751                          &t->pad[0]);
0752         t->sd.entity.function = MEDIA_ENT_F_TUNER;
0753     }
0754 
0755     if (ret < 0) {
0756         pr_err("failed to initialize media entity!\n");
0757         kfree(t);
0758         return ret;
0759     }
0760 #endif
0761     /* Sets a default mode */
0762     if (t->mode_mask & T_ANALOG_TV)
0763         t->mode = V4L2_TUNER_ANALOG_TV;
0764     else
0765         t->mode = V4L2_TUNER_RADIO;
0766     set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
0767     list_add_tail(&t->list, &tuner_list);
0768 
0769     pr_info("Tuner %d found with type(s)%s%s.\n",
0770            t->type,
0771            t->mode_mask & T_RADIO ? " Radio" : "",
0772            t->mode_mask & T_ANALOG_TV ? " TV" : "");
0773     return 0;
0774 }
0775 
0776 /**
0777  * tuner_remove - detaches a tuner
0778  *
0779  * @client: i2c_client descriptor
0780  */
0781 
0782 static int tuner_remove(struct i2c_client *client)
0783 {
0784     struct tuner *t = to_tuner(i2c_get_clientdata(client));
0785 
0786     v4l2_device_unregister_subdev(&t->sd);
0787     tuner_detach(&t->fe);
0788     t->fe.analog_demod_priv = NULL;
0789 
0790     list_del(&t->list);
0791     kfree(t);
0792     return 0;
0793 }
0794 
0795 /*
0796  * Functions to switch between Radio and TV
0797  *
0798  * A few cards have a separate I2C tuner for radio. Those routines
0799  * take care of switching between TV/Radio mode, filtering only the
0800  * commands that apply to the Radio or TV tuner.
0801  */
0802 
0803 /**
0804  * check_mode - Verify if tuner supports the requested mode
0805  * @t: a pointer to the module's internal struct_tuner
0806  * @mode: mode of the tuner, as defined by &enum v4l2_tuner_type.
0807  *
0808  * This function checks if the tuner is capable of tuning analog TV,
0809  * digital TV or radio, depending on what the caller wants. If the
0810  * tuner can't support that mode, it returns -EINVAL. Otherwise, it
0811  * returns 0.
0812  * This function is needed for boards that have a separate tuner for
0813  * radio (like devices with tea5767).
0814  *
0815  * NOTE: mt20xx uses V4L2_TUNER_DIGITAL_TV and calls set_tv_freq to
0816  *       select a TV frequency. So, t_mode = T_ANALOG_TV could actually
0817  *   be used to represent a Digital TV too.
0818  */
0819 static inline int check_mode(struct tuner *t, enum v4l2_tuner_type mode)
0820 {
0821     int t_mode;
0822     if (mode == V4L2_TUNER_RADIO)
0823         t_mode = T_RADIO;
0824     else
0825         t_mode = T_ANALOG_TV;
0826 
0827     if ((t_mode & t->mode_mask) == 0)
0828         return -EINVAL;
0829 
0830     return 0;
0831 }
0832 
0833 /**
0834  * set_mode - Switch tuner to other mode.
0835  * @t:      a pointer to the module's internal struct_tuner
0836  * @mode:   enum v4l2_type (radio or TV)
0837  *
0838  * If tuner doesn't support the needed mode (radio or TV), prints a
0839  * debug message and returns -EINVAL, changing its state to standby.
0840  * Otherwise, changes the mode and returns 0.
0841  */
0842 static int set_mode(struct tuner *t, enum v4l2_tuner_type mode)
0843 {
0844     struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
0845 
0846     if (mode != t->mode) {
0847         if (check_mode(t, mode) == -EINVAL) {
0848             dprintk("Tuner doesn't support mode %d. Putting tuner to sleep\n",
0849                   mode);
0850             t->standby = true;
0851             if (analog_ops->standby)
0852                 analog_ops->standby(&t->fe);
0853             return -EINVAL;
0854         }
0855         t->mode = mode;
0856         dprintk("Changing to mode %d\n", mode);
0857     }
0858     return 0;
0859 }
0860 
0861 /**
0862  * set_freq - Set the tuner to the desired frequency.
0863  * @t:      a pointer to the module's internal struct_tuner
0864  * @freq:   frequency to set (0 means to use the current frequency)
0865  */
0866 static void set_freq(struct tuner *t, unsigned int freq)
0867 {
0868     struct i2c_client *client = v4l2_get_subdevdata(&t->sd);
0869 
0870     if (t->mode == V4L2_TUNER_RADIO) {
0871         if (!freq)
0872             freq = t->radio_freq;
0873         set_radio_freq(client, freq);
0874     } else {
0875         if (!freq)
0876             freq = t->tv_freq;
0877         set_tv_freq(client, freq);
0878     }
0879 }
0880 
0881 /*
0882  * Functions that are specific for TV mode
0883  */
0884 
0885 /**
0886  * set_tv_freq - Set tuner frequency,  freq in Units of 62.5 kHz = 1/16MHz
0887  *
0888  * @c:  i2c_client descriptor
0889  * @freq: frequency
0890  */
0891 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
0892 {
0893     struct tuner *t = to_tuner(i2c_get_clientdata(c));
0894     struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
0895 
0896     struct analog_parameters params = {
0897         .mode      = t->mode,
0898         .audmode   = t->audmode,
0899         .std       = t->std
0900     };
0901 
0902     if (t->type == UNSET) {
0903         pr_warn("tuner type not set\n");
0904         return;
0905     }
0906     if (NULL == analog_ops->set_params) {
0907         pr_warn("Tuner has no way to set tv freq\n");
0908         return;
0909     }
0910     if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
0911         dprintk("TV freq (%d.%02d) out of range (%d-%d)\n",
0912                freq / 16, freq % 16 * 100 / 16, tv_range[0],
0913                tv_range[1]);
0914         /* V4L2 spec: if the freq is not possible then the closest
0915            possible value should be selected */
0916         if (freq < tv_range[0] * 16)
0917             freq = tv_range[0] * 16;
0918         else
0919             freq = tv_range[1] * 16;
0920     }
0921     params.frequency = freq;
0922     dprintk("tv freq set to %d.%02d\n",
0923             freq / 16, freq % 16 * 100 / 16);
0924     t->tv_freq = freq;
0925     t->standby = false;
0926 
0927     analog_ops->set_params(&t->fe, &params);
0928 }
0929 
0930 /**
0931  * tuner_fixup_std - force a given video standard variant
0932  *
0933  * @t: tuner internal struct
0934  * @std:    TV standard
0935  *
0936  * A few devices or drivers have problem to detect some standard variations.
0937  * On other operational systems, the drivers generally have a per-country
0938  * code, and some logic to apply per-country hacks. V4L2 API doesn't provide
0939  * such hacks. Instead, it relies on a proper video standard selection from
0940  * the userspace application. However, as some apps are buggy, not allowing
0941  * to distinguish all video standard variations, a modprobe parameter can
0942  * be used to force a video standard match.
0943  */
0944 static v4l2_std_id tuner_fixup_std(struct tuner *t, v4l2_std_id std)
0945 {
0946     if (pal[0] != '-' && (std & V4L2_STD_PAL) == V4L2_STD_PAL) {
0947         switch (pal[0]) {
0948         case '6':
0949             return V4L2_STD_PAL_60;
0950         case 'b':
0951         case 'B':
0952         case 'g':
0953         case 'G':
0954             return V4L2_STD_PAL_BG;
0955         case 'i':
0956         case 'I':
0957             return V4L2_STD_PAL_I;
0958         case 'd':
0959         case 'D':
0960         case 'k':
0961         case 'K':
0962             return V4L2_STD_PAL_DK;
0963         case 'M':
0964         case 'm':
0965             return V4L2_STD_PAL_M;
0966         case 'N':
0967         case 'n':
0968             if (pal[1] == 'c' || pal[1] == 'C')
0969                 return V4L2_STD_PAL_Nc;
0970             return V4L2_STD_PAL_N;
0971         default:
0972             pr_warn("pal= argument not recognised\n");
0973             break;
0974         }
0975     }
0976     if (secam[0] != '-' && (std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
0977         switch (secam[0]) {
0978         case 'b':
0979         case 'B':
0980         case 'g':
0981         case 'G':
0982         case 'h':
0983         case 'H':
0984             return V4L2_STD_SECAM_B |
0985                    V4L2_STD_SECAM_G |
0986                    V4L2_STD_SECAM_H;
0987         case 'd':
0988         case 'D':
0989         case 'k':
0990         case 'K':
0991             return V4L2_STD_SECAM_DK;
0992         case 'l':
0993         case 'L':
0994             if ((secam[1] == 'C') || (secam[1] == 'c'))
0995                 return V4L2_STD_SECAM_LC;
0996             return V4L2_STD_SECAM_L;
0997         default:
0998             pr_warn("secam= argument not recognised\n");
0999             break;
1000         }
1001     }
1002 
1003     if (ntsc[0] != '-' && (std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
1004         switch (ntsc[0]) {
1005         case 'm':
1006         case 'M':
1007             return V4L2_STD_NTSC_M;
1008         case 'j':
1009         case 'J':
1010             return V4L2_STD_NTSC_M_JP;
1011         case 'k':
1012         case 'K':
1013             return V4L2_STD_NTSC_M_KR;
1014         default:
1015             pr_info("ntsc= argument not recognised\n");
1016             break;
1017         }
1018     }
1019     return std;
1020 }
1021 
1022 /*
1023  * Functions that are specific for Radio mode
1024  */
1025 
1026 /**
1027  * set_radio_freq - Set tuner frequency,  freq in Units of 62.5 Hz  = 1/16kHz
1028  *
1029  * @c:  i2c_client descriptor
1030  * @freq: frequency
1031  */
1032 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
1033 {
1034     struct tuner *t = to_tuner(i2c_get_clientdata(c));
1035     struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1036 
1037     struct analog_parameters params = {
1038         .mode      = t->mode,
1039         .audmode   = t->audmode,
1040         .std       = t->std
1041     };
1042 
1043     if (t->type == UNSET) {
1044         pr_warn("tuner type not set\n");
1045         return;
1046     }
1047     if (NULL == analog_ops->set_params) {
1048         pr_warn("tuner has no way to set radio frequency\n");
1049         return;
1050     }
1051     if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
1052         dprintk("radio freq (%d.%02d) out of range (%d-%d)\n",
1053                freq / 16000, freq % 16000 * 100 / 16000,
1054                radio_range[0], radio_range[1]);
1055         /* V4L2 spec: if the freq is not possible then the closest
1056            possible value should be selected */
1057         if (freq < radio_range[0] * 16000)
1058             freq = radio_range[0] * 16000;
1059         else
1060             freq = radio_range[1] * 16000;
1061     }
1062     params.frequency = freq;
1063     dprintk("radio freq set to %d.%02d\n",
1064             freq / 16000, freq % 16000 * 100 / 16000);
1065     t->radio_freq = freq;
1066     t->standby = false;
1067 
1068     analog_ops->set_params(&t->fe, &params);
1069     /*
1070      * The tuner driver might decide to change the audmode if it only
1071      * supports stereo, so update t->audmode.
1072      */
1073     t->audmode = params.audmode;
1074 }
1075 
1076 /*
1077  * Debug function for reporting tuner status to userspace
1078  */
1079 
1080 /**
1081  * tuner_status - Dumps the current tuner status at dmesg
1082  * @fe: pointer to struct dvb_frontend
1083  *
1084  * This callback is used only for driver debug purposes, answering to
1085  * VIDIOC_LOG_STATUS. No changes should happen on this call.
1086  */
1087 static void tuner_status(struct dvb_frontend *fe)
1088 {
1089     struct tuner *t = fe->analog_demod_priv;
1090     unsigned long freq, freq_fraction;
1091     struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
1092     struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
1093     const char *p;
1094 
1095     switch (t->mode) {
1096     case V4L2_TUNER_RADIO:
1097         p = "radio";
1098         break;
1099     case V4L2_TUNER_DIGITAL_TV: /* Used by mt20xx */
1100         p = "digital TV";
1101         break;
1102     case V4L2_TUNER_ANALOG_TV:
1103     default:
1104         p = "analog TV";
1105         break;
1106     }
1107     if (t->mode == V4L2_TUNER_RADIO) {
1108         freq = t->radio_freq / 16000;
1109         freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
1110     } else {
1111         freq = t->tv_freq / 16;
1112         freq_fraction = (t->tv_freq % 16) * 100 / 16;
1113     }
1114     pr_info("Tuner mode:      %s%s\n", p,
1115            t->standby ? " on standby mode" : "");
1116     pr_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
1117     pr_info("Standard:        0x%08lx\n", (unsigned long)t->std);
1118     if (t->mode != V4L2_TUNER_RADIO)
1119         return;
1120     if (fe_tuner_ops->get_status) {
1121         u32 tuner_status = 0;
1122 
1123         fe_tuner_ops->get_status(&t->fe, &tuner_status);
1124         if (tuner_status & TUNER_STATUS_LOCKED)
1125             pr_info("Tuner is locked.\n");
1126         if (tuner_status & TUNER_STATUS_STEREO)
1127             pr_info("Stereo:          yes\n");
1128     }
1129     if (analog_ops->has_signal) {
1130         u16 signal;
1131 
1132         if (!analog_ops->has_signal(fe, &signal))
1133             pr_info("Signal strength: %hu\n", signal);
1134     }
1135 }
1136 
1137 /*
1138  * Function to splicitly change mode to radio. Probably not needed anymore
1139  */
1140 
1141 static int tuner_s_radio(struct v4l2_subdev *sd)
1142 {
1143     struct tuner *t = to_tuner(sd);
1144 
1145     if (set_mode(t, V4L2_TUNER_RADIO) == 0)
1146         set_freq(t, 0);
1147     return 0;
1148 }
1149 
1150 /*
1151  * Tuner callbacks to handle userspace ioctl's
1152  */
1153 
1154 /**
1155  * tuner_standby - places the tuner in standby mode
1156  * @sd: pointer to struct v4l2_subdev
1157  */
1158 static int tuner_standby(struct v4l2_subdev *sd)
1159 {
1160     struct tuner *t = to_tuner(sd);
1161     struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1162 
1163     dprintk("Putting tuner to sleep\n");
1164     t->standby = true;
1165     if (analog_ops->standby)
1166         analog_ops->standby(&t->fe);
1167     return 0;
1168 }
1169 
1170 static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1171 {
1172     struct tuner *t = to_tuner(sd);
1173 
1174     if (set_mode(t, V4L2_TUNER_ANALOG_TV))
1175         return 0;
1176 
1177     t->std = tuner_fixup_std(t, std);
1178     if (t->std != std)
1179         dprintk("Fixup standard %llx to %llx\n", std, t->std);
1180     set_freq(t, 0);
1181     return 0;
1182 }
1183 
1184 static int tuner_s_frequency(struct v4l2_subdev *sd, const struct v4l2_frequency *f)
1185 {
1186     struct tuner *t = to_tuner(sd);
1187 
1188     if (set_mode(t, f->type) == 0)
1189         set_freq(t, f->frequency);
1190     return 0;
1191 }
1192 
1193 /**
1194  * tuner_g_frequency - Get the tuned frequency for the tuner
1195  * @sd: pointer to struct v4l2_subdev
1196  * @f: pointer to struct v4l2_frequency
1197  *
1198  * At return, the structure f will be filled with tuner frequency
1199  * if the tuner matches the f->type.
1200  * Note: f->type should be initialized before calling it.
1201  * This is done by either video_ioctl2 or by the bridge driver.
1202  */
1203 static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1204 {
1205     struct tuner *t = to_tuner(sd);
1206     struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1207 
1208     if (check_mode(t, f->type) == -EINVAL)
1209         return 0;
1210     if (f->type == t->mode && fe_tuner_ops->get_frequency && !t->standby) {
1211         u32 abs_freq;
1212 
1213         fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
1214         f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
1215             DIV_ROUND_CLOSEST(abs_freq * 2, 125) :
1216             DIV_ROUND_CLOSEST(abs_freq, 62500);
1217     } else {
1218         f->frequency = (V4L2_TUNER_RADIO == f->type) ?
1219             t->radio_freq : t->tv_freq;
1220     }
1221     return 0;
1222 }
1223 
1224 /**
1225  * tuner_g_tuner - Fill in tuner information
1226  * @sd: pointer to struct v4l2_subdev
1227  * @vt: pointer to struct v4l2_tuner
1228  *
1229  * At return, the structure vt will be filled with tuner information
1230  * if the tuner matches vt->type.
1231  * Note: vt->type should be initialized before calling it.
1232  * This is done by either video_ioctl2 or by the bridge driver.
1233  */
1234 static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1235 {
1236     struct tuner *t = to_tuner(sd);
1237     struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1238     struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1239 
1240     if (check_mode(t, vt->type) == -EINVAL)
1241         return 0;
1242     if (vt->type == t->mode && analog_ops->get_afc)
1243         analog_ops->get_afc(&t->fe, &vt->afc);
1244     if (vt->type == t->mode && analog_ops->has_signal) {
1245         u16 signal = (u16)vt->signal;
1246 
1247         if (!analog_ops->has_signal(&t->fe, &signal))
1248             vt->signal = signal;
1249     }
1250     if (vt->type != V4L2_TUNER_RADIO) {
1251         vt->capability |= V4L2_TUNER_CAP_NORM;
1252         vt->rangelow = tv_range[0] * 16;
1253         vt->rangehigh = tv_range[1] * 16;
1254         return 0;
1255     }
1256 
1257     /* radio mode */
1258     if (vt->type == t->mode) {
1259         vt->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1260         if (fe_tuner_ops->get_status) {
1261             u32 tuner_status = 0;
1262 
1263             fe_tuner_ops->get_status(&t->fe, &tuner_status);
1264             vt->rxsubchans =
1265                 (tuner_status & TUNER_STATUS_STEREO) ?
1266                 V4L2_TUNER_SUB_STEREO :
1267                 V4L2_TUNER_SUB_MONO;
1268         }
1269         vt->audmode = t->audmode;
1270     }
1271     vt->capability |= V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1272     vt->rangelow = radio_range[0] * 16000;
1273     vt->rangehigh = radio_range[1] * 16000;
1274 
1275     return 0;
1276 }
1277 
1278 /**
1279  * tuner_s_tuner - Set the tuner's audio mode
1280  * @sd: pointer to struct v4l2_subdev
1281  * @vt: pointer to struct v4l2_tuner
1282  *
1283  * Sets the audio mode if the tuner matches vt->type.
1284  * Note: vt->type should be initialized before calling it.
1285  * This is done by either video_ioctl2 or by the bridge driver.
1286  */
1287 static int tuner_s_tuner(struct v4l2_subdev *sd, const struct v4l2_tuner *vt)
1288 {
1289     struct tuner *t = to_tuner(sd);
1290 
1291     if (set_mode(t, vt->type))
1292         return 0;
1293 
1294     if (t->mode == V4L2_TUNER_RADIO) {
1295         t->audmode = vt->audmode;
1296         /*
1297          * For radio audmode can only be mono or stereo. Map any
1298          * other values to stereo. The actual tuner driver that is
1299          * called in set_radio_freq can decide to limit the audmode to
1300          * mono if only mono is supported.
1301          */
1302         if (t->audmode != V4L2_TUNER_MODE_MONO &&
1303             t->audmode != V4L2_TUNER_MODE_STEREO)
1304             t->audmode = V4L2_TUNER_MODE_STEREO;
1305     }
1306     set_freq(t, 0);
1307 
1308     return 0;
1309 }
1310 
1311 static int tuner_log_status(struct v4l2_subdev *sd)
1312 {
1313     struct tuner *t = to_tuner(sd);
1314     struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1315 
1316     if (analog_ops->tuner_status)
1317         analog_ops->tuner_status(&t->fe);
1318     return 0;
1319 }
1320 
1321 #ifdef CONFIG_PM_SLEEP
1322 static int tuner_suspend(struct device *dev)
1323 {
1324     struct i2c_client *c = to_i2c_client(dev);
1325     struct tuner *t = to_tuner(i2c_get_clientdata(c));
1326     struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1327 
1328     dprintk("suspend\n");
1329 
1330     if (t->fe.ops.tuner_ops.suspend)
1331         t->fe.ops.tuner_ops.suspend(&t->fe);
1332     else if (!t->standby && analog_ops->standby)
1333         analog_ops->standby(&t->fe);
1334 
1335     return 0;
1336 }
1337 
1338 static int tuner_resume(struct device *dev)
1339 {
1340     struct i2c_client *c = to_i2c_client(dev);
1341     struct tuner *t = to_tuner(i2c_get_clientdata(c));
1342 
1343     dprintk("resume\n");
1344 
1345     if (t->fe.ops.tuner_ops.resume)
1346         t->fe.ops.tuner_ops.resume(&t->fe);
1347     else if (!t->standby)
1348         if (set_mode(t, t->mode) == 0)
1349             set_freq(t, 0);
1350 
1351     return 0;
1352 }
1353 #endif
1354 
1355 static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1356 {
1357     struct v4l2_subdev *sd = i2c_get_clientdata(client);
1358 
1359     /* TUNER_SET_CONFIG is still called by tuner-simple.c, so we have
1360        to handle it here.
1361        There must be a better way of doing this... */
1362     switch (cmd) {
1363     case TUNER_SET_CONFIG:
1364         return tuner_s_config(sd, arg);
1365     }
1366     return -ENOIOCTLCMD;
1367 }
1368 
1369 /*
1370  * Callback structs
1371  */
1372 
1373 static const struct v4l2_subdev_core_ops tuner_core_ops = {
1374     .log_status = tuner_log_status,
1375 };
1376 
1377 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
1378     .standby = tuner_standby,
1379     .s_radio = tuner_s_radio,
1380     .g_tuner = tuner_g_tuner,
1381     .s_tuner = tuner_s_tuner,
1382     .s_frequency = tuner_s_frequency,
1383     .g_frequency = tuner_g_frequency,
1384     .s_type_addr = tuner_s_type_addr,
1385     .s_config = tuner_s_config,
1386 };
1387 
1388 static const struct v4l2_subdev_video_ops tuner_video_ops = {
1389     .s_std = tuner_s_std,
1390 };
1391 
1392 static const struct v4l2_subdev_ops tuner_ops = {
1393     .core = &tuner_core_ops,
1394     .tuner = &tuner_tuner_ops,
1395     .video = &tuner_video_ops,
1396 };
1397 
1398 /*
1399  * I2C structs and module init functions
1400  */
1401 
1402 static const struct dev_pm_ops tuner_pm_ops = {
1403     SET_SYSTEM_SLEEP_PM_OPS(tuner_suspend, tuner_resume)
1404 };
1405 
1406 static const struct i2c_device_id tuner_id[] = {
1407     { "tuner", }, /* autodetect */
1408     { }
1409 };
1410 MODULE_DEVICE_TABLE(i2c, tuner_id);
1411 
1412 static struct i2c_driver tuner_driver = {
1413     .driver = {
1414         .name   = "tuner",
1415         .pm = &tuner_pm_ops,
1416     },
1417     .probe      = tuner_probe,
1418     .remove     = tuner_remove,
1419     .command    = tuner_command,
1420     .id_table   = tuner_id,
1421 };
1422 
1423 module_i2c_driver(tuner_driver);
1424 
1425 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
1426 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
1427 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!