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