git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/tuner-core.c

   1 /*
   2  *
   3  * i2c tv tuner chip device driver
   4  * core core, i.e. kernel interfaces, registering and so on
   5  */
   6
   7 #include <linux/module.h>
   8 #include <linux/kernel.h>
   9 #include <linux/string.h>
  10 #include <linux/timer.h>
  11 #include <linux/delay.h>
  12 #include <linux/errno.h>
  13 #include <linux/slab.h>
  14 #include <linux/poll.h>
  15 #include <linux/i2c.h>
  16 #include <linux/types.h>
  17 #include <linux/init.h>
  18 #include <linux/videodev.h>
  19 #include <media/tuner.h>
  20 #include <media/tuner-types.h>
  21 #include <media/v4l2-device.h>
  22 #include <media/v4l2-ioctl.h>
  23 #include <media/v4l2-i2c-drv-legacy.h>
  24 #include "mt20xx.h"
  25 #include "tda8290.h"
  26 #include "tea5761.h"
  27 #include "tea5767.h"
  28 #include "tuner-xc2028.h"
  29 #include "tuner-simple.h"
  30 #include "tda9887.h"
  31 #include "xc5000.h"
  32
  33 #define UNSET (-1U)
  34
  35 #define PREFIX t->i2c->driver->driver.name
  36
  37 /** This macro allows us to probe dynamically, avoiding static links */
  38 #ifdef CONFIG_MEDIA_ATTACH
  39 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
  40         int __r = -EINVAL; \
  41         typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
  42         if (__a) { \
  43                 __r = (int) __a(ARGS); \
  44                 symbol_put(FUNCTION); \
  45         } else { \
  46                 printk(KERN_ERR "TUNER: Unable to find " \
  47                                 "symbol "#FUNCTION"()\n"); \
  48         } \
  49         __r; \
  50 })
  51
  52 static void tuner_detach(struct dvb_frontend *fe)
  53 {
  54         if (fe->ops.tuner_ops.release) {
  55                 fe->ops.tuner_ops.release(fe);
  56                 symbol_put_addr(fe->ops.tuner_ops.release);
  57         }
  58         if (fe->ops.analog_ops.release) {
  59                 fe->ops.analog_ops.release(fe);
  60                 symbol_put_addr(fe->ops.analog_ops.release);
  61         }
  62 }
  63 #else
  64 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
  65         FUNCTION(ARGS); \
  66 })
  67
  68 static void tuner_detach(struct dvb_frontend *fe)
  69 {
  70         if (fe->ops.tuner_ops.release)
  71                 fe->ops.tuner_ops.release(fe);
  72         if (fe->ops.analog_ops.release)
  73                 fe->ops.analog_ops.release(fe);
  74 }
  75 #endif
  76
  77 struct tuner {
  78         /* device */
  79         struct dvb_frontend fe;
  80         struct i2c_client   *i2c;
  81         struct v4l2_subdev  sd;
  82         struct list_head    list;
  83         unsigned int        using_v4l2:1;
  84
  85         /* keep track of the current settings */
  86         v4l2_std_id         std;
  87         unsigned int        tv_freq;
  88         unsigned int        radio_freq;
  89         unsigned int        audmode;
  90
  91         unsigned int        mode;
  92         unsigned int        mode_mask; /* Combination of allowable modes */
  93
  94         unsigned int        type; /* chip type id */
  95         unsigned int        config;
  96         const char          *name;
  97 };
  98
  99 static inline struct tuner *to_tuner(struct v4l2_subdev *sd)
 100 {
 101         return container_of(sd, struct tuner, sd);
 102 }
 103
 104 /* standard i2c insmod options */
 105 static unsigned short normal_i2c[] = {
 106 #if defined(CONFIG_MEDIA_TUNER_TEA5761) || (defined(CONFIG_MEDIA_TUNER_TEA5761_MODULE) && defined(MODULE))
 107         0x10,
 108 #endif
 109         0x42, 0x43, 0x4a, 0x4b,                 /* tda8290 */
 110         0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
 111         0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
 112         I2C_CLIENT_END
 113 };
 114
 115 I2C_CLIENT_INSMOD;
 116
 117 /* insmod options used at init time => read/only */
 118 static unsigned int addr;
 119 static unsigned int no_autodetect;
 120 static unsigned int show_i2c;
 121
 122 /* insmod options used at runtime => read/write */
 123 static int tuner_debug;
 124
 125 #define tuner_warn(fmt, arg...) do {                    \
 126         printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
 127                i2c_adapter_id(t->i2c->adapter),         \
 128                t->i2c->addr, ##arg);                    \
 129          } while (0)
 130
 131 #define tuner_info(fmt, arg...) do {                    \
 132         printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX,    \
 133                i2c_adapter_id(t->i2c->adapter),         \
 134                t->i2c->addr, ##arg);                    \
 135          } while (0)
 136
 137 #define tuner_err(fmt, arg...) do {                     \
 138         printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX,     \
 139                i2c_adapter_id(t->i2c->adapter),         \
 140                t->i2c->addr, ##arg);                    \
 141          } while (0)
 142
 143 #define tuner_dbg(fmt, arg...) do {                             \
 144         if (tuner_debug)                                        \
 145                 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX,   \
 146                        i2c_adapter_id(t->i2c->adapter),         \
 147                        t->i2c->addr, ##arg);                    \
 148          } while (0)
 149
 150 /* ------------------------------------------------------------------------ */
 151
 152 static unsigned int tv_range[2] = { 44, 958 };
 153 static unsigned int radio_range[2] = { 65, 108 };
 154
 155 static char pal[] = "--";
 156 static char secam[] = "--";
 157 static char ntsc[] = "-";
 158
 159
 160 module_param(addr, int, 0444);
 161 module_param(no_autodetect, int, 0444);
 162 module_param(show_i2c, int, 0444);
 163 module_param_named(debug,tuner_debug, int, 0644);
 164 module_param_string(pal, pal, sizeof(pal), 0644);
 165 module_param_string(secam, secam, sizeof(secam), 0644);
 166 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
 167 module_param_array(tv_range, int, NULL, 0644);
 168 module_param_array(radio_range, int, NULL, 0644);
 169
 170 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
 171 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
 172 MODULE_LICENSE("GPL");
 173
 174 /* ---------------------------------------------------------------------- */
 175
 176 static void fe_set_params(struct dvb_frontend *fe,
 177                           struct analog_parameters *params)
 178 {
 179         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 180         struct tuner *t = fe->analog_demod_priv;
 181
 182         if (NULL == fe_tuner_ops->set_analog_params) {
 183                 tuner_warn("Tuner frontend module has no way to set freq\n");
 184                 return;
 185         }
 186         fe_tuner_ops->set_analog_params(fe, params);
 187 }
 188
 189 static void fe_standby(struct dvb_frontend *fe)
 190 {
 191         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 192
 193         if (fe_tuner_ops->sleep)
 194                 fe_tuner_ops->sleep(fe);
 195 }
 196
 197 static int fe_has_signal(struct dvb_frontend *fe)
 198 {
 199         u16 strength = 0;
 200
 201         if (fe->ops.tuner_ops.get_rf_strength)
 202                 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
 203
 204         return strength;
 205 }
 206
 207 static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
 208 {
 209         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 210         struct tuner *t = fe->analog_demod_priv;
 211
 212         if (fe_tuner_ops->set_config)
 213                 return fe_tuner_ops->set_config(fe, priv_cfg);
 214
 215         tuner_warn("Tuner frontend module has no way to set config\n");
 216
 217         return 0;
 218 }
 219
 220 static void tuner_status(struct dvb_frontend *fe);
 221
 222 static struct analog_demod_ops tuner_analog_ops = {
 223         .set_params     = fe_set_params,
 224         .standby        = fe_standby,
 225         .has_signal     = fe_has_signal,
 226         .set_config     = fe_set_config,
 227         .tuner_status   = tuner_status
 228 };
 229
 230 /* Set tuner frequency,  freq in Units of 62.5kHz = 1/16MHz */
 231 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
 232 {
 233         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 234         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 235
 236         struct analog_parameters params = {
 237                 .mode      = t->mode,
 238                 .audmode   = t->audmode,
 239                 .std       = t->std
 240         };
 241
 242         if (t->type == UNSET) {
 243                 tuner_warn ("tuner type not set\n");
 244                 return;
 245         }
 246         if (NULL == analog_ops->set_params) {
 247                 tuner_warn ("Tuner has no way to set tv freq\n");
 248                 return;
 249         }
 250         if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
 251                 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
 252                            freq / 16, freq % 16 * 100 / 16, tv_range[0],
 253                            tv_range[1]);
 254                 /* V4L2 spec: if the freq is not possible then the closest
 255                    possible value should be selected */
 256                 if (freq < tv_range[0] * 16)
 257                         freq = tv_range[0] * 16;
 258                 else
 259                         freq = tv_range[1] * 16;
 260         }
 261         params.frequency = freq;
 262
 263         analog_ops->set_params(&t->fe, &params);
 264 }
 265
 266 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
 267 {
 268         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 269         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 270
 271         struct analog_parameters params = {
 272                 .mode      = t->mode,
 273                 .audmode   = t->audmode,
 274                 .std       = t->std
 275         };
 276
 277         if (t->type == UNSET) {
 278                 tuner_warn ("tuner type not set\n");
 279                 return;
 280         }
 281         if (NULL == analog_ops->set_params) {
 282                 tuner_warn ("tuner has no way to set radio frequency\n");
 283                 return;
 284         }
 285         if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
 286                 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
 287                            freq / 16000, freq % 16000 * 100 / 16000,
 288                            radio_range[0], radio_range[1]);
 289                 /* V4L2 spec: if the freq is not possible then the closest
 290                    possible value should be selected */
 291                 if (freq < radio_range[0] * 16000)
 292                         freq = radio_range[0] * 16000;
 293                 else
 294                         freq = radio_range[1] * 16000;
 295         }
 296         params.frequency = freq;
 297
 298         analog_ops->set_params(&t->fe, &params);
 299 }
 300
 301 static void set_freq(struct i2c_client *c, unsigned long freq)
 302 {
 303         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 304
 305         switch (t->mode) {
 306         case V4L2_TUNER_RADIO:
 307                 tuner_dbg("radio freq set to %lu.%02lu\n",
 308                           freq / 16000, freq % 16000 * 100 / 16000);
 309                 set_radio_freq(c, freq);
 310                 t->radio_freq = freq;
 311                 break;
 312         case V4L2_TUNER_ANALOG_TV:
 313         case V4L2_TUNER_DIGITAL_TV:
 314                 tuner_dbg("tv freq set to %lu.%02lu\n",
 315                           freq / 16, freq % 16 * 100 / 16);
 316                 set_tv_freq(c, freq);
 317                 t->tv_freq = freq;
 318                 break;
 319         default:
 320                 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
 321         }
 322 }
 323
 324 static void tuner_i2c_address_check(struct tuner *t)
 325 {
 326         if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
 327             ((t->i2c->addr < 0x64) || (t->i2c->addr > 0x6f)))
 328                 return;
 329
 330         /* We already know that the XC5000 can only be located at
 331          * i2c address 0x61, 0x62, 0x63 or 0x64 */
 332         if ((t->type == TUNER_XC5000) &&
 333             ((t->i2c->addr <= 0x64)) && (t->i2c->addr >= 0x61))
 334                 return;
 335
 336         tuner_warn("====================== WARNING! ======================\n");
 337         tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
 338         tuner_warn("will soon be dropped. This message indicates that your\n");
 339         tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
 340                    t->name, t->i2c->addr);
 341         tuner_warn("To ensure continued support for your device, please\n");
 342         tuner_warn("send a copy of this message, along with full dmesg\n");
 343         tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
 344         tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
 345         tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
 346                    t->i2c->adapter->name, t->i2c->addr, t->type, t->name);
 347         tuner_warn("====================== WARNING! ======================\n");
 348 }
 349
 350 static struct xc5000_config xc5000_cfg;
 351
 352 static void set_type(struct i2c_client *c, unsigned int type,
 353                      unsigned int new_mode_mask, unsigned int new_config,
 354                      int (*tuner_callback) (void *dev, int component, int cmd, int arg))
 355 {
 356         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 357         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 358         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 359         unsigned char buffer[4];
 360
 361         if (type == UNSET || type == TUNER_ABSENT) {
 362                 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
 363                 return;
 364         }
 365
 366         t->type = type;
 367         /* prevent invalid config values */
 368         t->config = ((new_config >= 0) && (new_config < 256)) ? new_config : 0;
 369         if (tuner_callback != NULL) {
 370                 tuner_dbg("defining GPIO callback\n");
 371                 t->fe.callback = tuner_callback;
 372         }
 373
 374         if (t->mode == T_UNINITIALIZED) {
 375                 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
 376
 377                 return;
 378         }
 379
 380         /* discard private data, in case set_type() was previously called */
 381         tuner_detach(&t->fe);
 382         t->fe.analog_demod_priv = NULL;
 383
 384         switch (t->type) {
 385         case TUNER_MT2032:
 386                 if (!dvb_attach(microtune_attach,
 387                            &t->fe, t->i2c->adapter, t->i2c->addr))
 388                         goto attach_failed;
 389                 break;
 390         case TUNER_PHILIPS_TDA8290:
 391         {
 392                 struct tda829x_config cfg = {
 393                         .lna_cfg        = t->config,
 394                 };
 395                 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
 396                                 t->i2c->addr, &cfg))
 397                         goto attach_failed;
 398                 break;
 399         }
 400         case TUNER_TEA5767:
 401                 if (!dvb_attach(tea5767_attach, &t->fe,
 402                                 t->i2c->adapter, t->i2c->addr))
 403                         goto attach_failed;
 404                 t->mode_mask = T_RADIO;
 405                 break;
 406         case TUNER_TEA5761:
 407                 if (!dvb_attach(tea5761_attach, &t->fe,
 408                                 t->i2c->adapter, t->i2c->addr))
 409                         goto attach_failed;
 410                 t->mode_mask = T_RADIO;
 411                 break;
 412         case TUNER_PHILIPS_FMD1216ME_MK3:
 413                 buffer[0] = 0x0b;
 414                 buffer[1] = 0xdc;
 415                 buffer[2] = 0x9c;
 416                 buffer[3] = 0x60;
 417                 i2c_master_send(c, buffer, 4);
 418                 mdelay(1);
 419                 buffer[2] = 0x86;
 420                 buffer[3] = 0x54;
 421                 i2c_master_send(c, buffer, 4);
 422                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 423                                 t->i2c->adapter, t->i2c->addr, t->type))
 424                         goto attach_failed;
 425                 break;
 426         case TUNER_PHILIPS_TD1316:
 427                 buffer[0] = 0x0b;
 428                 buffer[1] = 0xdc;
 429                 buffer[2] = 0x86;
 430                 buffer[3] = 0xa4;
 431                 i2c_master_send(c, buffer, 4);
 432                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 433                                 t->i2c->adapter, t->i2c->addr, t->type))
 434                         goto attach_failed;
 435                 break;
 436         case TUNER_XC2028:
 437         {
 438                 struct xc2028_config cfg = {
 439                         .i2c_adap  = t->i2c->adapter,
 440                         .i2c_addr  = t->i2c->addr,
 441                 };
 442                 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
 443                         goto attach_failed;
 444                 break;
 445         }
 446         case TUNER_TDA9887:
 447                 if (!dvb_attach(tda9887_attach,
 448                            &t->fe, t->i2c->adapter, t->i2c->addr))
 449                         goto attach_failed;
 450                 break;
 451         case TUNER_XC5000:
 452         {
 453                 struct dvb_tuner_ops *xc_tuner_ops;
 454
 455                 xc5000_cfg.i2c_address    = t->i2c->addr;
 456                 /* if_khz will be set when the digital dvb_attach() occurs */
 457                 xc5000_cfg.if_khz         = 0;
 458                 if (!dvb_attach(xc5000_attach,
 459                                 &t->fe, t->i2c->adapter, &xc5000_cfg))
 460                         goto attach_failed;
 461
 462                 xc_tuner_ops = &t->fe.ops.tuner_ops;
 463                 if (xc_tuner_ops->init)
 464                         xc_tuner_ops->init(&t->fe);
 465                 break;
 466         }
 467         default:
 468                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 469                                 t->i2c->adapter, t->i2c->addr, t->type))
 470                         goto attach_failed;
 471
 472                 break;
 473         }
 474
 475         if ((NULL == analog_ops->set_params) &&
 476             (fe_tuner_ops->set_analog_params)) {
 477
 478                 t->name = fe_tuner_ops->info.name;
 479
 480                 t->fe.analog_demod_priv = t;
 481                 memcpy(analog_ops, &tuner_analog_ops,
 482                        sizeof(struct analog_demod_ops));
 483
 484         } else {
 485                 t->name = analog_ops->info.name;
 486         }
 487
 488         tuner_dbg("type set to %s\n", t->name);
 489
 490         if (t->mode_mask == T_UNINITIALIZED)
 491                 t->mode_mask = new_mode_mask;
 492
 493         /* xc2028/3028 and xc5000 requires a firmware to be set-up later
 494            trying to set a frequency here will just fail
 495            FIXME: better to move set_freq to the tuner code. This is needed
 496            on analog tuners for PLL to properly work
 497          */
 498         if (t->type != TUNER_XC2028 && t->type != TUNER_XC5000)
 499                 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ?
 500                             t->radio_freq : t->tv_freq);
 501
 502         tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
 503                   c->adapter->name, c->driver->driver.name, c->addr << 1, type,
 504                   t->mode_mask);
 505         tuner_i2c_address_check(t);
 506         return;
 507
 508 attach_failed:
 509         tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
 510         t->type = TUNER_ABSENT;
 511         t->mode_mask = T_UNINITIALIZED;
 512
 513         return;
 514 }
 515
 516 /*
 517  * This function apply tuner config to tuner specified
 518  * by tun_setup structure. I addr is unset, then admin status
 519  * and tun addr status is more precise then current status,
 520  * it's applied. Otherwise status and type are applied only to
 521  * tuner with exactly the same addr.
 522 */
 523
 524 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
 525 {
 526         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 527
 528         if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
 529                 (t->mode_mask & tun_setup->mode_mask))) ||
 530                 (tun_setup->addr == c->addr)) {
 531                         set_type(c, tun_setup->type, tun_setup->mode_mask,
 532                                  tun_setup->config, tun_setup->tuner_callback);
 533         } else
 534                 tuner_dbg("set addr discarded for type %i, mask %x. "
 535                           "Asked to change tuner at addr 0x%02x, with mask %x\n",
 536                           t->type, t->mode_mask,
 537                           tun_setup->addr, tun_setup->mode_mask);
 538 }
 539
 540 static inline int check_mode(struct tuner *t, char *cmd)
 541 {
 542         if ((1 << t->mode & t->mode_mask) == 0) {
 543                 return -EINVAL;
 544         }
 545
 546         switch (t->mode) {
 547         case V4L2_TUNER_RADIO:
 548                 tuner_dbg("Cmd %s accepted for radio\n", cmd);
 549                 break;
 550         case V4L2_TUNER_ANALOG_TV:
 551                 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
 552                 break;
 553         case V4L2_TUNER_DIGITAL_TV:
 554                 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
 555                 break;
 556         }
 557         return 0;
 558 }
 559
 560 /* get more precise norm info from insmod option */
 561 static int tuner_fixup_std(struct tuner *t)
 562 {
 563         if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
 564                 switch (pal[0]) {
 565                 case '6':
 566                         tuner_dbg ("insmod fixup: PAL => PAL-60\n");
 567                         t->std = V4L2_STD_PAL_60;
 568                         break;
 569                 case 'b':
 570                 case 'B':
 571                 case 'g':
 572                 case 'G':
 573                         tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
 574                         t->std = V4L2_STD_PAL_BG;
 575                         break;
 576                 case 'i':
 577                 case 'I':
 578                         tuner_dbg ("insmod fixup: PAL => PAL-I\n");
 579                         t->std = V4L2_STD_PAL_I;
 580                         break;
 581                 case 'd':
 582                 case 'D':
 583                 case 'k':
 584                 case 'K':
 585                         tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
 586                         t->std = V4L2_STD_PAL_DK;
 587                         break;
 588                 case 'M':
 589                 case 'm':
 590                         tuner_dbg ("insmod fixup: PAL => PAL-M\n");
 591                         t->std = V4L2_STD_PAL_M;
 592                         break;
 593                 case 'N':
 594                 case 'n':
 595                         if (pal[1] == 'c' || pal[1] == 'C') {
 596                                 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
 597                                 t->std = V4L2_STD_PAL_Nc;
 598                         } else {
 599                                 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
 600                                 t->std = V4L2_STD_PAL_N;
 601                         }
 602                         break;
 603                 case '-':
 604                         /* default parameter, do nothing */
 605                         break;
 606                 default:
 607                         tuner_warn ("pal= argument not recognised\n");
 608                         break;
 609                 }
 610         }
 611         if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
 612                 switch (secam[0]) {
 613                 case 'b':
 614                 case 'B':
 615                 case 'g':
 616                 case 'G':
 617                 case 'h':
 618                 case 'H':
 619                         tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
 620                         t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
 621                         break;
 622                 case 'd':
 623                 case 'D':
 624                 case 'k':
 625                 case 'K':
 626                         tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
 627                         t->std = V4L2_STD_SECAM_DK;
 628                         break;
 629                 case 'l':
 630                 case 'L':
 631                         if ((secam[1]=='C')||(secam[1]=='c')) {
 632                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
 633                                 t->std = V4L2_STD_SECAM_LC;
 634                         } else {
 635                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
 636                                 t->std = V4L2_STD_SECAM_L;
 637                         }
 638                         break;
 639                 case '-':
 640                         /* default parameter, do nothing */
 641                         break;
 642                 default:
 643                         tuner_warn ("secam= argument not recognised\n");
 644                         break;
 645                 }
 646         }
 647
 648         if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
 649                 switch (ntsc[0]) {
 650                 case 'm':
 651                 case 'M':
 652                         tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
 653                         t->std = V4L2_STD_NTSC_M;
 654                         break;
 655                 case 'j':
 656                 case 'J':
 657                         tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
 658                         t->std = V4L2_STD_NTSC_M_JP;
 659                         break;
 660                 case 'k':
 661                 case 'K':
 662                         tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
 663                         t->std = V4L2_STD_NTSC_M_KR;
 664                         break;
 665                 case '-':
 666                         /* default parameter, do nothing */
 667                         break;
 668                 default:
 669                         tuner_info("ntsc= argument not recognised\n");
 670                         break;
 671                 }
 672         }
 673         return 0;
 674 }
 675
 676 static void tuner_status(struct dvb_frontend *fe)
 677 {
 678         struct tuner *t = fe->analog_demod_priv;
 679         unsigned long freq, freq_fraction;
 680         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 681         struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
 682         const char *p;
 683
 684         switch (t->mode) {
 685                 case V4L2_TUNER_RADIO:      p = "radio"; break;
 686                 case V4L2_TUNER_ANALOG_TV:  p = "analog TV"; break;
 687                 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
 688                 default: p = "undefined"; break;
 689         }
 690         if (t->mode == V4L2_TUNER_RADIO) {
 691                 freq = t->radio_freq / 16000;
 692                 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
 693         } else {
 694                 freq = t->tv_freq / 16;
 695                 freq_fraction = (t->tv_freq % 16) * 100 / 16;
 696         }
 697         tuner_info("Tuner mode:      %s\n", p);
 698         tuner_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
 699         tuner_info("Standard:        0x%08lx\n", (unsigned long)t->std);
 700         if (t->mode != V4L2_TUNER_RADIO)
 701                return;
 702         if (fe_tuner_ops->get_status) {
 703                 u32 tuner_status;
 704
 705                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
 706                 if (tuner_status & TUNER_STATUS_LOCKED)
 707                         tuner_info("Tuner is locked.\n");
 708                 if (tuner_status & TUNER_STATUS_STEREO)
 709                         tuner_info("Stereo:          yes\n");
 710         }
 711         if (analog_ops->has_signal)
 712                 tuner_info("Signal strength: %d\n",
 713                            analog_ops->has_signal(fe));
 714         if (analog_ops->is_stereo)
 715                 tuner_info("Stereo:          %s\n",
 716                            analog_ops->is_stereo(fe) ? "yes" : "no");
 717 }
 718
 719 /* ---------------------------------------------------------------------- */
 720
 721 /*
 722  * Switch tuner to other mode. If tuner support both tv and radio,
 723  * set another frequency to some value (This is needed for some pal
 724  * tuners to avoid locking). Otherwise, just put second tuner in
 725  * standby mode.
 726  */
 727
 728 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
 729 {
 730         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 731
 732         if (mode == t->mode)
 733                 return 0;
 734
 735         t->mode = mode;
 736
 737         if (check_mode(t, cmd) == -EINVAL) {
 738                 tuner_dbg("Tuner doesn't support this mode. "
 739                           "Putting tuner to sleep\n");
 740                 t->mode = T_STANDBY;
 741                 if (analog_ops->standby)
 742                         analog_ops->standby(&t->fe);
 743                 return -EINVAL;
 744         }
 745         return 0;
 746 }
 747
 748 #define switch_v4l2()   if (!t->using_v4l2) \
 749                             tuner_dbg("switching to v4l2\n"); \
 750                         t->using_v4l2 = 1;
 751
 752 static inline int check_v4l2(struct tuner *t)
 753 {
 754         /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
 755            TV, v4l1 for radio), until that is fixed this code is disabled.
 756            Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
 757            first. */
 758         return 0;
 759 }
 760
 761 static int tuner_s_type_addr(struct v4l2_subdev *sd, struct tuner_setup *type)
 762 {
 763         struct tuner *t = to_tuner(sd);
 764         struct i2c_client *client = v4l2_get_subdevdata(sd);
 765
 766         tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
 767                         type->type,
 768                         type->addr,
 769                         type->mode_mask,
 770                         type->config);
 771
 772         set_addr(client, type);
 773         return 0;
 774 }
 775
 776 static int tuner_s_radio(struct v4l2_subdev *sd)
 777 {
 778         struct tuner *t = to_tuner(sd);
 779         struct i2c_client *client = v4l2_get_subdevdata(sd);
 780
 781         if (set_mode(client, t, V4L2_TUNER_RADIO, "s_radio") == -EINVAL)
 782                 return 0;
 783         if (t->radio_freq)
 784                 set_freq(client, t->radio_freq);
 785         return 0;
 786 }
 787
 788 static int tuner_s_standby(struct v4l2_subdev *sd, u32 standby)
 789 {
 790         struct tuner *t = to_tuner(sd);
 791         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 792
 793         tuner_dbg("Putting tuner to sleep\n");
 794
 795         if (check_mode(t, "s_standby") == -EINVAL)
 796                 return 0;
 797         t->mode = T_STANDBY;
 798         if (analog_ops->standby)
 799                 analog_ops->standby(&t->fe);
 800         return 0;
 801 }
 802
 803 static int tuner_s_config(struct v4l2_subdev *sd, const struct v4l2_priv_tun_config *cfg)
 804 {
 805         struct tuner *t = to_tuner(sd);
 806         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 807
 808         if (t->type != cfg->tuner)
 809                 return 0;
 810
 811         if (analog_ops->set_config) {
 812                 analog_ops->set_config(&t->fe, cfg->priv);
 813                 return 0;
 814         }
 815
 816         tuner_dbg("Tuner frontend module has no way to set config\n");
 817         return 0;
 818 }
 819
 820 /* --- v4l ioctls --- */
 821 /* take care: bttv does userspace copying, we'll get a
 822    kernel pointer here... */
 823 static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
 824 {
 825         struct tuner *t = to_tuner(sd);
 826         struct i2c_client *client = v4l2_get_subdevdata(sd);
 827
 828         if (set_mode(client, t, V4L2_TUNER_ANALOG_TV, "s_std") == -EINVAL)
 829                 return 0;
 830
 831         switch_v4l2();
 832
 833         t->std = std;
 834         tuner_fixup_std(t);
 835         if (t->tv_freq)
 836                 set_freq(client, t->tv_freq);
 837         return 0;
 838 }
 839
 840 static int tuner_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
 841 {
 842         struct tuner *t = to_tuner(sd);
 843         struct i2c_client *client = v4l2_get_subdevdata(sd);
 844
 845         if (set_mode(client, t, f->type, "s_frequency") == -EINVAL)
 846                 return 0;
 847         switch_v4l2();
 848         set_freq(client, f->frequency);
 849
 850         return 0;
 851 }
 852
 853 static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
 854 {
 855         struct tuner *t = to_tuner(sd);
 856         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 857
 858         if (check_mode(t, "g_frequency") == -EINVAL)
 859                 return 0;
 860         switch_v4l2();
 861         f->type = t->mode;
 862         if (fe_tuner_ops->get_frequency) {
 863                 u32 abs_freq;
 864
 865                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
 866                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 867                         (abs_freq * 2 + 125/2) / 125 :
 868                         (abs_freq + 62500/2) / 62500;
 869                 return 0;
 870         }
 871         f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 872                 t->radio_freq : t->tv_freq;
 873         return 0;
 874 }
 875
 876 static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
 877 {
 878         struct tuner *t = to_tuner(sd);
 879         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 880         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 881
 882         if (check_mode(t, "g_tuner") == -EINVAL)
 883                 return 0;
 884         switch_v4l2();
 885
 886         vt->type = t->mode;
 887         if (analog_ops->get_afc)
 888                 vt->afc = analog_ops->get_afc(&t->fe);
 889         if (t->mode == V4L2_TUNER_ANALOG_TV)
 890                 vt->capability |= V4L2_TUNER_CAP_NORM;
 891         if (t->mode != V4L2_TUNER_RADIO) {
 892                 vt->rangelow = tv_range[0] * 16;
 893                 vt->rangehigh = tv_range[1] * 16;
 894                 return 0;
 895         }
 896
 897         /* radio mode */
 898         vt->rxsubchans =
 899                 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
 900         if (fe_tuner_ops->get_status) {
 901                 u32 tuner_status;
 902
 903                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
 904                 vt->rxsubchans =
 905                         (tuner_status & TUNER_STATUS_STEREO) ?
 906                         V4L2_TUNER_SUB_STEREO :
 907                         V4L2_TUNER_SUB_MONO;
 908         } else {
 909                 if (analog_ops->is_stereo) {
 910                         vt->rxsubchans =
 911                                 analog_ops->is_stereo(&t->fe) ?
 912                                 V4L2_TUNER_SUB_STEREO :
 913                                 V4L2_TUNER_SUB_MONO;
 914                 }
 915         }
 916         if (analog_ops->has_signal)
 917                 vt->signal = analog_ops->has_signal(&t->fe);
 918         vt->capability |=
 919                 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
 920         vt->audmode = t->audmode;
 921         vt->rangelow = radio_range[0] * 16000;
 922         vt->rangehigh = radio_range[1] * 16000;
 923         return 0;
 924 }
 925
 926 static int tuner_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
 927 {
 928         struct tuner *t = to_tuner(sd);
 929         struct i2c_client *client = v4l2_get_subdevdata(sd);
 930
 931         if (check_mode(t, "s_tuner") == -EINVAL)
 932                 return 0;
 933
 934         switch_v4l2();
 935
 936         /* do nothing unless we're a radio tuner */
 937         if (t->mode != V4L2_TUNER_RADIO)
 938                 return 0;
 939         t->audmode = vt->audmode;
 940         set_radio_freq(client, t->radio_freq);
 941         return 0;
 942 }
 943
 944 static int tuner_log_status(struct v4l2_subdev *sd)
 945 {
 946         struct tuner *t = to_tuner(sd);
 947         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 948
 949         if (analog_ops->tuner_status)
 950                 analog_ops->tuner_status(&t->fe);
 951         return 0;
 952 }
 953
 954 static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
 955 {
 956         return v4l2_subdev_command(i2c_get_clientdata(client), cmd, arg);
 957 }
 958
 959 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
 960 {
 961         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 962
 963         tuner_dbg("suspend\n");
 964         /* FIXME: power down ??? */
 965         return 0;
 966 }
 967
 968 static int tuner_resume(struct i2c_client *c)
 969 {
 970         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 971
 972         tuner_dbg("resume\n");
 973         if (V4L2_TUNER_RADIO == t->mode) {
 974                 if (t->radio_freq)
 975                         set_freq(c, t->radio_freq);
 976         } else {
 977                 if (t->tv_freq)
 978                         set_freq(c, t->tv_freq);
 979         }
 980         return 0;
 981 }
 982
 983 /* ----------------------------------------------------------------------- */
 984
 985 static const struct v4l2_subdev_core_ops tuner_core_ops = {
 986         .log_status = tuner_log_status,
 987         .s_standby = tuner_s_standby,
 988 };
 989
 990 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
 991         .s_std = tuner_s_std,
 992         .s_radio = tuner_s_radio,
 993         .g_tuner = tuner_g_tuner,
 994         .s_tuner = tuner_s_tuner,
 995         .s_frequency = tuner_s_frequency,
 996         .g_frequency = tuner_g_frequency,
 997         .s_type_addr = tuner_s_type_addr,
 998         .s_config = tuner_s_config,
 999 };
1000
1001 static const struct v4l2_subdev_ops tuner_ops = {
1002         .core = &tuner_core_ops,
1003         .tuner = &tuner_tuner_ops,
1004 };
1005
1006 /* ---------------------------------------------------------------------- */
1007
1008 static LIST_HEAD(tuner_list);
1009
1010 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1011    Note that when this function is called from tuner_probe you can be
1012    certain no other devices will be added/deleted at the same time, I2C
1013    core protects against that. */
1014 static void tuner_lookup(struct i2c_adapter *adap,
1015                 struct tuner **radio, struct tuner **tv)
1016 {
1017         struct tuner *pos;
1018
1019         *radio = NULL;
1020         *tv = NULL;
1021
1022         list_for_each_entry(pos, &tuner_list, list) {
1023                 int mode_mask;
1024
1025                 if (pos->i2c->adapter != adap ||
1026                     pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1027                         continue;
1028
1029                 mode_mask = pos->mode_mask & ~T_STANDBY;
1030                 if (*radio == NULL && mode_mask == T_RADIO)
1031                         *radio = pos;
1032                 /* Note: currently TDA9887 is the only demod-only
1033                    device. If other devices appear then we need to
1034                    make this test more general. */
1035                 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1036                          (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1037                         *tv = pos;
1038         }
1039 }
1040
1041 /* During client attach, set_type is called by adapter's attach_inform callback.
1042    set_type must then be completed by tuner_probe.
1043  */
1044 static int tuner_probe(struct i2c_client *client,
1045                        const struct i2c_device_id *id)
1046 {
1047         struct tuner *t;
1048         struct tuner *radio;
1049         struct tuner *tv;
1050
1051         t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1052         if (NULL == t)
1053                 return -ENOMEM;
1054         v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
1055         t->i2c = client;
1056         t->name = "(tuner unset)";
1057         t->type = UNSET;
1058         t->audmode = V4L2_TUNER_MODE_STEREO;
1059         t->mode_mask = T_UNINITIALIZED;
1060
1061         if (show_i2c) {
1062                 unsigned char buffer[16];
1063                 int i, rc;
1064
1065                 memset(buffer, 0, sizeof(buffer));
1066                 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1067                 tuner_info("I2C RECV = ");
1068                 for (i = 0; i < rc; i++)
1069                         printk(KERN_CONT "%02x ", buffer[i]);
1070                 printk("\n");
1071         }
1072         /* HACK: This test was added to avoid tuner to probe tda9840 and
1073            tea6415c on the MXB card */
1074         if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1075                 kfree(t);
1076                 return -ENODEV;
1077         }
1078
1079         /* autodetection code based on the i2c addr */
1080         if (!no_autodetect) {
1081                 switch (client->addr) {
1082                 case 0x10:
1083                         if (tuner_symbol_probe(tea5761_autodetection,
1084                                                t->i2c->adapter,
1085                                                t->i2c->addr) >= 0) {
1086                                 t->type = TUNER_TEA5761;
1087                                 t->mode_mask = T_RADIO;
1088                                 t->mode = T_STANDBY;
1089                                 /* Sets freq to FM range */
1090                                 t->radio_freq = 87.5 * 16000;
1091                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1092                                 if (tv)
1093                                         tv->mode_mask &= ~T_RADIO;
1094
1095                                 goto register_client;
1096                         }
1097                         return -ENODEV;
1098                 case 0x42:
1099                 case 0x43:
1100                 case 0x4a:
1101                 case 0x4b:
1102                         /* If chip is not tda8290, don't register.
1103                            since it can be tda9887*/
1104                         if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
1105                                                t->i2c->addr) >= 0) {
1106                                 tuner_dbg("tda829x detected\n");
1107                         } else {
1108                                 /* Default is being tda9887 */
1109                                 t->type = TUNER_TDA9887;
1110                                 t->mode_mask = T_RADIO | T_ANALOG_TV |
1111                                                T_DIGITAL_TV;
1112                                 t->mode = T_STANDBY;
1113                                 goto register_client;
1114                         }
1115                         break;
1116                 case 0x60:
1117                         if (tuner_symbol_probe(tea5767_autodetection,
1118                                                t->i2c->adapter, t->i2c->addr)
1119                                         >= 0) {
1120                                 t->type = TUNER_TEA5767;
1121                                 t->mode_mask = T_RADIO;
1122                                 t->mode = T_STANDBY;
1123                                 /* Sets freq to FM range */
1124                                 t->radio_freq = 87.5 * 16000;
1125                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1126                                 if (tv)
1127                                         tv->mode_mask &= ~T_RADIO;
1128
1129                                 goto register_client;
1130                         }
1131                         break;
1132                 }
1133         }
1134
1135         /* Initializes only the first TV tuner on this adapter. Why only the
1136            first? Because there are some devices (notably the ones with TI
1137            tuners) that have more than one i2c address for the *same* device.
1138            Experience shows that, except for just one case, the first
1139            address is the right one. The exception is a Russian tuner
1140            (ACORP_Y878F). So, the desired behavior is just to enable the
1141            first found TV tuner. */
1142         tuner_lookup(t->i2c->adapter, &radio, &tv);
1143         if (tv == NULL) {
1144                 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1145                 if (radio == NULL)
1146                         t->mode_mask |= T_RADIO;
1147                 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1148                 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1149                 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1150         }
1151
1152         /* Should be just before return */
1153 register_client:
1154         tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1155                        client->adapter->name);
1156
1157         /* Sets a default mode */
1158         if (t->mode_mask & T_ANALOG_TV) {
1159                 t->mode = V4L2_TUNER_ANALOG_TV;
1160         } else  if (t->mode_mask & T_RADIO) {
1161                 t->mode = V4L2_TUNER_RADIO;
1162         } else {
1163                 t->mode = V4L2_TUNER_DIGITAL_TV;
1164         }
1165         set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
1166         list_add_tail(&t->list, &tuner_list);
1167         return 0;
1168 }
1169
1170 static int tuner_legacy_probe(struct i2c_adapter *adap)
1171 {
1172         if (0 != addr) {
1173                 normal_i2c[0] = addr;
1174                 normal_i2c[1] = I2C_CLIENT_END;
1175         }
1176
1177         if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1178                 return 0;
1179
1180         /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1181          * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1182          * and an RTC at 0x6f which can get corrupted if probed.
1183          */
1184         if ((adap->id == I2C_HW_B_CX2388x) ||
1185             (adap->id == I2C_HW_B_CX23885)) {
1186                 unsigned int i = 0;
1187
1188                 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1189                         i += 2;
1190                 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1191                         ignore[i+0] = adap->nr;
1192                         ignore[i+1] = 0x6b;
1193                         ignore[i+2] = adap->nr;
1194                         ignore[i+3] = 0x6f;
1195                         ignore[i+4] = I2C_CLIENT_END;
1196                 } else
1197                         printk(KERN_WARNING "tuner: "
1198                                "too many options specified "
1199                                "in i2c probe ignore list!\n");
1200         }
1201         return 1;
1202 }
1203
1204 static int tuner_remove(struct i2c_client *client)
1205 {
1206         struct tuner *t = to_tuner(i2c_get_clientdata(client));
1207
1208         v4l2_device_unregister_subdev(&t->sd);
1209         tuner_detach(&t->fe);
1210         t->fe.analog_demod_priv = NULL;
1211
1212         list_del(&t->list);
1213         kfree(t);
1214         return 0;
1215 }
1216
1217 /* ----------------------------------------------------------------------- */
1218
1219 /* This driver supports many devices and the idea is to let the driver
1220    detect which device is present. So rather than listing all supported
1221    devices here, we pretend to support a single, fake device type. */
1222 static const struct i2c_device_id tuner_id[] = {
1223         { "tuner", }, /* autodetect */
1224         { }
1225 };
1226 MODULE_DEVICE_TABLE(i2c, tuner_id);
1227
1228 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1229         .name = "tuner",
1230         .driverid = I2C_DRIVERID_TUNER,
1231         .command = tuner_command,
1232         .probe = tuner_probe,
1233         .remove = tuner_remove,
1234         .suspend = tuner_suspend,
1235         .resume = tuner_resume,
1236         .legacy_probe = tuner_legacy_probe,
1237         .id_table = tuner_id,
1238 };
1239
1240 /*
1241  * Overrides for Emacs so that we follow Linus's tabbing style.
1242  * ---------------------------------------------------------------------------
1243  * Local variables:
1244  * c-basic-offset: 8
1245  * End:
1246  */