err.no 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-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 void attach_tda829x(struct tuner *t)
 321 {
 322         struct tda829x_config cfg = {
 323                 .lna_cfg        = t->config,
 324                 .tuner_callback = t->tuner_callback,
 325         };
 326         tda829x_attach(&t->fe, t->i2c->adapter, t->i2c->addr, &cfg);
 327 }
 328
 329 static struct xc5000_config xc5000_cfg;
 330
 331 static void set_type(struct i2c_client *c, unsigned int type,
 332                      unsigned int new_mode_mask, unsigned int new_config,
 333                      int (*tuner_callback) (void *dev, int command,int arg))
 334 {
 335         struct tuner *t = i2c_get_clientdata(c);
 336         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 337         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 338         unsigned char buffer[4];
 339
 340         if (type == UNSET || type == TUNER_ABSENT) {
 341                 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
 342                 return;
 343         }
 344
 345         t->type = type;
 346         t->config = new_config;
 347         if (tuner_callback != NULL) {
 348                 tuner_dbg("defining GPIO callback\n");
 349                 t->tuner_callback = tuner_callback;
 350         }
 351
 352         if (t->mode == T_UNINITIALIZED) {
 353                 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
 354
 355                 return;
 356         }
 357
 358         /* discard private data, in case set_type() was previously called */
 359         if (analog_ops->release)
 360                 analog_ops->release(&t->fe);
 361
 362         switch (t->type) {
 363         case TUNER_MT2032:
 364                 microtune_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
 365                 break;
 366         case TUNER_PHILIPS_TDA8290:
 367         {
 368                 attach_tda829x(t);
 369                 break;
 370         }
 371         case TUNER_TEA5767:
 372                 if (!tea5767_attach(&t->fe, t->i2c->adapter, t->i2c->addr))
 373                         goto attach_failed;
 374                 t->mode_mask = T_RADIO;
 375                 break;
 376         case TUNER_TEA5761:
 377                 if (!tea5761_attach(&t->fe, t->i2c->adapter, t->i2c->addr))
 378                         goto attach_failed;
 379                 t->mode_mask = T_RADIO;
 380                 break;
 381         case TUNER_PHILIPS_FMD1216ME_MK3:
 382                 buffer[0] = 0x0b;
 383                 buffer[1] = 0xdc;
 384                 buffer[2] = 0x9c;
 385                 buffer[3] = 0x60;
 386                 i2c_master_send(c, buffer, 4);
 387                 mdelay(1);
 388                 buffer[2] = 0x86;
 389                 buffer[3] = 0x54;
 390                 i2c_master_send(c, buffer, 4);
 391                 if (!simple_tuner_attach(&t->fe, t->i2c->adapter, t->i2c->addr,
 392                                         t->type))
 393                         goto attach_failed;
 394                 break;
 395         case TUNER_PHILIPS_TD1316:
 396                 buffer[0] = 0x0b;
 397                 buffer[1] = 0xdc;
 398                 buffer[2] = 0x86;
 399                 buffer[3] = 0xa4;
 400                 i2c_master_send(c,buffer,4);
 401                 if (!simple_tuner_attach(&t->fe, t->i2c->adapter,
 402                                         t->i2c->addr, t->type))
 403                         goto attach_failed;
 404                 break;
 405         case TUNER_XC2028:
 406         {
 407                 struct xc2028_config cfg = {
 408                         .i2c_adap  = t->i2c->adapter,
 409                         .i2c_addr  = t->i2c->addr,
 410                         .callback  = t->tuner_callback,
 411                 };
 412                 if (!xc2028_attach(&t->fe, &cfg))
 413                         goto attach_failed;
 414                 break;
 415         }
 416         case TUNER_TDA9887:
 417                 tda9887_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
 418                 break;
 419         case TUNER_XC5000:
 420         {
 421                 struct dvb_tuner_ops *xc_tuner_ops;
 422
 423                 xc5000_cfg.i2c_address    = t->i2c->addr;
 424                 xc5000_cfg.if_khz         = 5380;
 425                 xc5000_cfg.priv           = c->adapter->algo_data;
 426                 xc5000_cfg.tuner_callback = t->tuner_callback;
 427                 if (!xc5000_attach(&t->fe, t->i2c->adapter, &xc5000_cfg))
 428                         goto attach_failed;
 429
 430                 xc_tuner_ops = &t->fe.ops.tuner_ops;
 431                 if (xc_tuner_ops->init)
 432                         xc_tuner_ops->init(&t->fe);
 433                 break;
 434         }
 435         default:
 436                 if (!simple_tuner_attach(&t->fe, t->i2c->adapter,
 437                                         t->i2c->addr, t->type))
 438                         goto attach_failed;
 439
 440                 break;
 441         }
 442
 443         if ((NULL == analog_ops->set_params) &&
 444             (fe_tuner_ops->set_analog_params)) {
 445                 strlcpy(t->i2c->name, fe_tuner_ops->info.name,
 446                         sizeof(t->i2c->name));
 447
 448                 t->fe.analog_demod_priv = t;
 449                 memcpy(analog_ops, &tuner_core_ops,
 450                        sizeof(struct analog_demod_ops));
 451         } else {
 452                 strlcpy(t->i2c->name, analog_ops->info.name,
 453                         sizeof(t->i2c->name));
 454         }
 455
 456         tuner_dbg("type set to %s\n", t->i2c->name);
 457
 458         if (t->mode_mask == T_UNINITIALIZED)
 459                 t->mode_mask = new_mode_mask;
 460
 461         /* xc2028/3028 and xc5000 requires a firmware to be set-up later
 462            trying to set a frequency here will just fail
 463            FIXME: better to move set_freq to the tuner code. This is needed
 464            on analog tuners for PLL to properly work
 465          */
 466         if (t->type != TUNER_XC2028 && t->type != TUNER_XC5000)
 467                 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ?
 468                             t->radio_freq : t->tv_freq);
 469
 470         tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
 471                   c->adapter->name, c->driver->driver.name, c->addr << 1, type,
 472                   t->mode_mask);
 473         tuner_i2c_address_check(t);
 474         return;
 475
 476 attach_failed:
 477         tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
 478         t->type = TUNER_ABSENT;
 479         t->mode_mask = T_UNINITIALIZED;
 480
 481         return;
 482 }
 483
 484 /*
 485  * This function apply tuner config to tuner specified
 486  * by tun_setup structure. I addr is unset, then admin status
 487  * and tun addr status is more precise then current status,
 488  * it's applied. Otherwise status and type are applied only to
 489  * tuner with exactly the same addr.
 490 */
 491
 492 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
 493 {
 494         struct tuner *t = i2c_get_clientdata(c);
 495
 496         if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
 497                 (t->mode_mask & tun_setup->mode_mask))) ||
 498                 (tun_setup->addr == c->addr)) {
 499                         set_type(c, tun_setup->type, tun_setup->mode_mask,
 500                                  tun_setup->config, tun_setup->tuner_callback);
 501         } else
 502                 tuner_dbg("set addr discarded for type %i, mask %x. "
 503                           "Asked to change tuner at addr 0x%02x, with mask %x\n",
 504                           t->type, t->mode_mask,
 505                           tun_setup->addr, tun_setup->mode_mask);
 506 }
 507
 508 static inline int check_mode(struct tuner *t, char *cmd)
 509 {
 510         if ((1 << t->mode & t->mode_mask) == 0) {
 511                 return EINVAL;
 512         }
 513
 514         switch (t->mode) {
 515         case V4L2_TUNER_RADIO:
 516                 tuner_dbg("Cmd %s accepted for radio\n", cmd);
 517                 break;
 518         case V4L2_TUNER_ANALOG_TV:
 519                 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
 520                 break;
 521         case V4L2_TUNER_DIGITAL_TV:
 522                 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
 523                 break;
 524         }
 525         return 0;
 526 }
 527
 528 /* get more precise norm info from insmod option */
 529 static int tuner_fixup_std(struct tuner *t)
 530 {
 531         if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
 532                 switch (pal[0]) {
 533                 case '6':
 534                         tuner_dbg ("insmod fixup: PAL => PAL-60\n");
 535                         t->std = V4L2_STD_PAL_60;
 536                         break;
 537                 case 'b':
 538                 case 'B':
 539                 case 'g':
 540                 case 'G':
 541                         tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
 542                         t->std = V4L2_STD_PAL_BG;
 543                         break;
 544                 case 'i':
 545                 case 'I':
 546                         tuner_dbg ("insmod fixup: PAL => PAL-I\n");
 547                         t->std = V4L2_STD_PAL_I;
 548                         break;
 549                 case 'd':
 550                 case 'D':
 551                 case 'k':
 552                 case 'K':
 553                         tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
 554                         t->std = V4L2_STD_PAL_DK;
 555                         break;
 556                 case 'M':
 557                 case 'm':
 558                         tuner_dbg ("insmod fixup: PAL => PAL-M\n");
 559                         t->std = V4L2_STD_PAL_M;
 560                         break;
 561                 case 'N':
 562                 case 'n':
 563                         if (pal[1] == 'c' || pal[1] == 'C') {
 564                                 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
 565                                 t->std = V4L2_STD_PAL_Nc;
 566                         } else {
 567                                 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
 568                                 t->std = V4L2_STD_PAL_N;
 569                         }
 570                         break;
 571                 case '-':
 572                         /* default parameter, do nothing */
 573                         break;
 574                 default:
 575                         tuner_warn ("pal= argument not recognised\n");
 576                         break;
 577                 }
 578         }
 579         if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
 580                 switch (secam[0]) {
 581                 case 'b':
 582                 case 'B':
 583                 case 'g':
 584                 case 'G':
 585                 case 'h':
 586                 case 'H':
 587                         tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
 588                         t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
 589                         break;
 590                 case 'd':
 591                 case 'D':
 592                 case 'k':
 593                 case 'K':
 594                         tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
 595                         t->std = V4L2_STD_SECAM_DK;
 596                         break;
 597                 case 'l':
 598                 case 'L':
 599                         if ((secam[1]=='C')||(secam[1]=='c')) {
 600                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
 601                                 t->std = V4L2_STD_SECAM_LC;
 602                         } else {
 603                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
 604                                 t->std = V4L2_STD_SECAM_L;
 605                         }
 606                         break;
 607                 case '-':
 608                         /* default parameter, do nothing */
 609                         break;
 610                 default:
 611                         tuner_warn ("secam= argument not recognised\n");
 612                         break;
 613                 }
 614         }
 615
 616         if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
 617                 switch (ntsc[0]) {
 618                 case 'm':
 619                 case 'M':
 620                         tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
 621                         t->std = V4L2_STD_NTSC_M;
 622                         break;
 623                 case 'j':
 624                 case 'J':
 625                         tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
 626                         t->std = V4L2_STD_NTSC_M_JP;
 627                         break;
 628                 case 'k':
 629                 case 'K':
 630                         tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
 631                         t->std = V4L2_STD_NTSC_M_KR;
 632                         break;
 633                 case '-':
 634                         /* default parameter, do nothing */
 635                         break;
 636                 default:
 637                         tuner_info("ntsc= argument not recognised\n");
 638                         break;
 639                 }
 640         }
 641         return 0;
 642 }
 643
 644 static void tuner_status(struct dvb_frontend *fe)
 645 {
 646         struct tuner *t = fe->analog_demod_priv;
 647         unsigned long freq, freq_fraction;
 648         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 649         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 650         const char *p;
 651
 652         switch (t->mode) {
 653                 case V4L2_TUNER_RADIO:      p = "radio"; break;
 654                 case V4L2_TUNER_ANALOG_TV:  p = "analog TV"; break;
 655                 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
 656                 default: p = "undefined"; break;
 657         }
 658         if (t->mode == V4L2_TUNER_RADIO) {
 659                 freq = t->radio_freq / 16000;
 660                 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
 661         } else {
 662                 freq = t->tv_freq / 16;
 663                 freq_fraction = (t->tv_freq % 16) * 100 / 16;
 664         }
 665         tuner_info("Tuner mode:      %s\n", p);
 666         tuner_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
 667         tuner_info("Standard:        0x%08lx\n", (unsigned long)t->std);
 668         if (t->mode != V4L2_TUNER_RADIO)
 669                return;
 670         if (fe_tuner_ops->get_status) {
 671                 u32 tuner_status;
 672
 673                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
 674                 if (tuner_status & TUNER_STATUS_LOCKED)
 675                         tuner_info("Tuner is locked.\n");
 676                 if (tuner_status & TUNER_STATUS_STEREO)
 677                         tuner_info("Stereo:          yes\n");
 678         }
 679         if (analog_ops->has_signal)
 680                 tuner_info("Signal strength: %d\n",
 681                            analog_ops->has_signal(fe));
 682         if (analog_ops->is_stereo)
 683                 tuner_info("Stereo:          %s\n",
 684                            analog_ops->is_stereo(fe) ? "yes" : "no");
 685 }
 686
 687 /* ---------------------------------------------------------------------- */
 688
 689 /*
 690  * Switch tuner to other mode. If tuner support both tv and radio,
 691  * set another frequency to some value (This is needed for some pal
 692  * tuners to avoid locking). Otherwise, just put second tuner in
 693  * standby mode.
 694  */
 695
 696 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
 697 {
 698         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 699
 700         if (mode == t->mode)
 701                 return 0;
 702
 703         t->mode = mode;
 704
 705         if (check_mode(t, cmd) == EINVAL) {
 706                 t->mode = T_STANDBY;
 707                 if (analog_ops->standby)
 708                         analog_ops->standby(&t->fe);
 709                 return EINVAL;
 710         }
 711         return 0;
 712 }
 713
 714 #define switch_v4l2()   if (!t->using_v4l2) \
 715                             tuner_dbg("switching to v4l2\n"); \
 716                         t->using_v4l2 = 1;
 717
 718 static inline int check_v4l2(struct tuner *t)
 719 {
 720         /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
 721            TV, v4l1 for radio), until that is fixed this code is disabled.
 722            Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
 723            first. */
 724         return 0;
 725 }
 726
 727 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
 728 {
 729         struct tuner *t = i2c_get_clientdata(client);
 730         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 731         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 732
 733         if (tuner_debug > 1) {
 734                 v4l_i2c_print_ioctl(client,cmd);
 735                 printk("\n");
 736         }
 737
 738         switch (cmd) {
 739         /* --- configuration --- */
 740         case TUNER_SET_TYPE_ADDR:
 741                 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
 742                                 ((struct tuner_setup *)arg)->type,
 743                                 ((struct tuner_setup *)arg)->addr,
 744                                 ((struct tuner_setup *)arg)->mode_mask,
 745                                 ((struct tuner_setup *)arg)->config);
 746
 747                 set_addr(client, (struct tuner_setup *)arg);
 748                 break;
 749         case AUDC_SET_RADIO:
 750                 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
 751                                 == EINVAL)
 752                         return 0;
 753                 if (t->radio_freq)
 754                         set_freq(client, t->radio_freq);
 755                 break;
 756         case TUNER_SET_STANDBY:
 757                 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
 758                         return 0;
 759                 t->mode = T_STANDBY;
 760                 if (analog_ops->standby)
 761                         analog_ops->standby(&t->fe);
 762                 break;
 763 #ifdef CONFIG_VIDEO_ALLOW_V4L1
 764         case VIDIOCSAUDIO:
 765                 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
 766                         return 0;
 767                 if (check_v4l2(t) == EINVAL)
 768                         return 0;
 769
 770                 /* Should be implemented, since bttv calls it */
 771                 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
 772                 break;
 773         case VIDIOCSCHAN:
 774                 {
 775                         static const v4l2_std_id map[] = {
 776                                 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
 777                                 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
 778                                 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
 779                                 [4 /* bttv */ ] = V4L2_STD_PAL_M,
 780                                 [5 /* bttv */ ] = V4L2_STD_PAL_N,
 781                                 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
 782                         };
 783                         struct video_channel *vc = arg;
 784
 785                         if (check_v4l2(t) == EINVAL)
 786                                 return 0;
 787
 788                         if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
 789                                 return 0;
 790
 791                         if (vc->norm < ARRAY_SIZE(map))
 792                                 t->std = map[vc->norm];
 793                         tuner_fixup_std(t);
 794                         if (t->tv_freq)
 795                                 set_tv_freq(client, t->tv_freq);
 796                         return 0;
 797                 }
 798         case VIDIOCSFREQ:
 799                 {
 800                         unsigned long *v = arg;
 801
 802                         if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
 803                                 return 0;
 804                         if (check_v4l2(t) == EINVAL)
 805                                 return 0;
 806
 807                         set_freq(client, *v);
 808                         return 0;
 809                 }
 810         case VIDIOCGTUNER:
 811                 {
 812                         struct video_tuner *vt = arg;
 813
 814                         if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
 815                                 return 0;
 816                         if (check_v4l2(t) == EINVAL)
 817                                 return 0;
 818
 819                         if (V4L2_TUNER_RADIO == t->mode) {
 820                                 if (fe_tuner_ops->get_status) {
 821                                         u32 tuner_status;
 822
 823                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 824                                         if (tuner_status & TUNER_STATUS_STEREO)
 825                                                 vt->flags |= VIDEO_TUNER_STEREO_ON;
 826                                         else
 827                                                 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
 828                                 } else {
 829                                         if (analog_ops->is_stereo) {
 830                                                 if (analog_ops->is_stereo(&t->fe))
 831                                                         vt->flags |=
 832                                                                 VIDEO_TUNER_STEREO_ON;
 833                                                 else
 834                                                         vt->flags &=
 835                                                                 ~VIDEO_TUNER_STEREO_ON;
 836                                         }
 837                                 }
 838                                 if (analog_ops->has_signal)
 839                                         vt->signal =
 840                                                 analog_ops->has_signal(&t->fe);
 841
 842                                 vt->flags |= VIDEO_TUNER_LOW;   /* Allow freqs at 62.5 Hz */
 843
 844                                 vt->rangelow = radio_range[0] * 16000;
 845                                 vt->rangehigh = radio_range[1] * 16000;
 846
 847                         } else {
 848                                 vt->rangelow = tv_range[0] * 16;
 849                                 vt->rangehigh = tv_range[1] * 16;
 850                         }
 851
 852                         return 0;
 853                 }
 854         case VIDIOCGAUDIO:
 855                 {
 856                         struct video_audio *va = arg;
 857
 858                         if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
 859                                 return 0;
 860                         if (check_v4l2(t) == EINVAL)
 861                                 return 0;
 862
 863                         if (V4L2_TUNER_RADIO == t->mode) {
 864                                 if (fe_tuner_ops->get_status) {
 865                                         u32 tuner_status;
 866
 867                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 868                                         va->mode = (tuner_status & TUNER_STATUS_STEREO)
 869                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 870                                 } else if (analog_ops->is_stereo)
 871                                         va->mode = analog_ops->is_stereo(&t->fe)
 872                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 873                         }
 874                         return 0;
 875                 }
 876 #endif
 877         case TUNER_SET_CONFIG:
 878         {
 879                 struct v4l2_priv_tun_config *cfg = arg;
 880
 881                 if (t->type != cfg->tuner)
 882                         break;
 883
 884                 if (analog_ops->set_config) {
 885                         analog_ops->set_config(&t->fe, cfg->priv);
 886                         break;
 887                 }
 888
 889                 tuner_dbg("Tuner frontend module has no way to set config\n");
 890                 break;
 891         }
 892         /* --- v4l ioctls --- */
 893         /* take care: bttv does userspace copying, we'll get a
 894            kernel pointer here... */
 895         case VIDIOC_S_STD:
 896                 {
 897                         v4l2_std_id *id = arg;
 898
 899                         if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
 900                                         == EINVAL)
 901                                 return 0;
 902
 903                         switch_v4l2();
 904
 905                         t->std = *id;
 906                         tuner_fixup_std(t);
 907                         if (t->tv_freq)
 908                                 set_freq(client, t->tv_freq);
 909                         break;
 910                 }
 911         case VIDIOC_S_FREQUENCY:
 912                 {
 913                         struct v4l2_frequency *f = arg;
 914
 915                         if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
 916                                         == EINVAL)
 917                                 return 0;
 918                         switch_v4l2();
 919                         set_freq(client,f->frequency);
 920
 921                         break;
 922                 }
 923         case VIDIOC_G_FREQUENCY:
 924                 {
 925                         struct v4l2_frequency *f = arg;
 926
 927                         if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
 928                                 return 0;
 929                         switch_v4l2();
 930                         f->type = t->mode;
 931                         if (fe_tuner_ops->get_frequency) {
 932                                 u32 abs_freq;
 933
 934                                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
 935                                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 936                                         (abs_freq * 2 + 125/2) / 125 :
 937                                         (abs_freq + 62500/2) / 62500;
 938                                 break;
 939                         }
 940                         f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 941                                 t->radio_freq : t->tv_freq;
 942                         break;
 943                 }
 944         case VIDIOC_G_TUNER:
 945                 {
 946                         struct v4l2_tuner *tuner = arg;
 947
 948                         if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
 949                                 return 0;
 950                         switch_v4l2();
 951
 952                         tuner->type = t->mode;
 953                         if (analog_ops->get_afc)
 954                                 tuner->afc = analog_ops->get_afc(&t->fe);
 955                         if (t->mode == V4L2_TUNER_ANALOG_TV)
 956                                 tuner->capability |= V4L2_TUNER_CAP_NORM;
 957                         if (t->mode != V4L2_TUNER_RADIO) {
 958                                 tuner->rangelow = tv_range[0] * 16;
 959                                 tuner->rangehigh = tv_range[1] * 16;
 960                                 break;
 961                         }
 962
 963                         /* radio mode */
 964                         tuner->rxsubchans =
 965                                 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
 966                         if (fe_tuner_ops->get_status) {
 967                                 u32 tuner_status;
 968
 969                                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
 970                                 tuner->rxsubchans =
 971                                         (tuner_status & TUNER_STATUS_STEREO) ?
 972                                         V4L2_TUNER_SUB_STEREO :
 973                                         V4L2_TUNER_SUB_MONO;
 974                         } else {
 975                                 if (analog_ops->is_stereo) {
 976                                         tuner->rxsubchans =
 977                                                 analog_ops->is_stereo(&t->fe) ?
 978                                                 V4L2_TUNER_SUB_STEREO :
 979                                                 V4L2_TUNER_SUB_MONO;
 980                                 }
 981                         }
 982                         if (analog_ops->has_signal)
 983                                 tuner->signal = analog_ops->has_signal(&t->fe);
 984                         tuner->capability |=
 985                             V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
 986                         tuner->audmode = t->audmode;
 987                         tuner->rangelow = radio_range[0] * 16000;
 988                         tuner->rangehigh = radio_range[1] * 16000;
 989                         break;
 990                 }
 991         case VIDIOC_S_TUNER:
 992                 {
 993                         struct v4l2_tuner *tuner = arg;
 994
 995                         if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
 996                                 return 0;
 997
 998                         switch_v4l2();
 999
1000                         /* do nothing unless we're a radio tuner */
1001                         if (t->mode != V4L2_TUNER_RADIO)
1002                                 break;
1003                         t->audmode = tuner->audmode;
1004                         set_radio_freq(client, t->radio_freq);
1005                         break;
1006                 }
1007         case VIDIOC_LOG_STATUS:
1008                 if (analog_ops->tuner_status)
1009                         analog_ops->tuner_status(&t->fe);
1010                 break;
1011         }
1012
1013         return 0;
1014 }
1015
1016 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1017 {
1018         struct tuner *t = i2c_get_clientdata(c);
1019
1020         tuner_dbg("suspend\n");
1021         /* FIXME: power down ??? */
1022         return 0;
1023 }
1024
1025 static int tuner_resume(struct i2c_client *c)
1026 {
1027         struct tuner *t = i2c_get_clientdata(c);
1028
1029         tuner_dbg("resume\n");
1030         if (V4L2_TUNER_RADIO == t->mode) {
1031                 if (t->radio_freq)
1032                         set_freq(c, t->radio_freq);
1033         } else {
1034                 if (t->tv_freq)
1035                         set_freq(c, t->tv_freq);
1036         }
1037         return 0;
1038 }
1039
1040 /* ---------------------------------------------------------------------- */
1041
1042 static LIST_HEAD(tuner_list);
1043
1044 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1045    Note that when this function is called from tuner_probe you can be
1046    certain no other devices will be added/deleted at the same time, I2C
1047    core protects against that. */
1048 static void tuner_lookup(struct i2c_adapter *adap,
1049                 struct tuner **radio, struct tuner **tv)
1050 {
1051         struct tuner *pos;
1052
1053         *radio = NULL;
1054         *tv = NULL;
1055
1056         list_for_each_entry(pos, &tuner_list, list) {
1057                 int mode_mask;
1058
1059                 if (pos->i2c->adapter != adap ||
1060                     pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1061                         continue;
1062
1063                 mode_mask = pos->mode_mask & ~T_STANDBY;
1064                 if (*radio == NULL && mode_mask == T_RADIO)
1065                         *radio = pos;
1066                 /* Note: currently TDA9887 is the only demod-only
1067                    device. If other devices appear then we need to
1068                    make this test more general. */
1069                 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1070                          (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1071                         *tv = pos;
1072         }
1073 }
1074
1075 /* During client attach, set_type is called by adapter's attach_inform callback.
1076    set_type must then be completed by tuner_probe.
1077  */
1078 static int tuner_probe(struct i2c_client *client)
1079 {
1080         struct tuner *t;
1081         struct tuner *radio;
1082         struct tuner *tv;
1083
1084         t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1085         if (NULL == t)
1086                 return -ENOMEM;
1087         t->i2c = client;
1088         strlcpy(client->name, "(tuner unset)", sizeof(client->name));
1089         i2c_set_clientdata(client, t);
1090         t->type = UNSET;
1091         t->audmode = V4L2_TUNER_MODE_STEREO;
1092         t->mode_mask = T_UNINITIALIZED;
1093
1094         if (show_i2c) {
1095                 unsigned char buffer[16];
1096                 int i, rc;
1097
1098                 memset(buffer, 0, sizeof(buffer));
1099                 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1100                 tuner_info("I2C RECV = ");
1101                 for (i = 0; i < rc; i++)
1102                         printk(KERN_CONT "%02x ", buffer[i]);
1103                 printk("\n");
1104         }
1105         /* HACK: This test was added to avoid tuner to probe tda9840 and
1106            tea6415c on the MXB card */
1107         if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1108                 kfree(t);
1109                 return -ENODEV;
1110         }
1111
1112         /* autodetection code based on the i2c addr */
1113         if (!no_autodetect) {
1114                 switch (client->addr) {
1115                 case 0x10:
1116                         if (tea5761_autodetection(t->i2c->adapter,
1117                                                   t->i2c->addr) >= 0) {
1118                                 t->type = TUNER_TEA5761;
1119                                 t->mode_mask = T_RADIO;
1120                                 t->mode = T_STANDBY;
1121                                 /* Sets freq to FM range */
1122                                 t->radio_freq = 87.5 * 16000;
1123                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1124                                 if (tv)
1125                                         tv->mode_mask &= ~T_RADIO;
1126
1127                                 goto register_client;
1128                         }
1129                         return -ENODEV;
1130                 case 0x42:
1131                 case 0x43:
1132                 case 0x4a:
1133                 case 0x4b:
1134                         /* If chip is not tda8290, don't register.
1135                            since it can be tda9887*/
1136                         if (tda829x_probe(t->i2c->adapter,
1137                                           t->i2c->addr) == 0) {
1138                                 tuner_dbg("tda829x detected\n");
1139                         } else {
1140                                 /* Default is being tda9887 */
1141                                 t->type = TUNER_TDA9887;
1142                                 t->mode_mask = T_RADIO | T_ANALOG_TV |
1143                                                T_DIGITAL_TV;
1144                                 t->mode = T_STANDBY;
1145                                 goto register_client;
1146                         }
1147                         break;
1148                 case 0x60:
1149                         if (tea5767_autodetection(t->i2c->adapter, t->i2c->addr)
1150                                         != EINVAL) {
1151                                 t->type = TUNER_TEA5767;
1152                                 t->mode_mask = T_RADIO;
1153                                 t->mode = T_STANDBY;
1154                                 /* Sets freq to FM range */
1155                                 t->radio_freq = 87.5 * 16000;
1156                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1157                                 if (tv)
1158                                         tv->mode_mask &= ~T_RADIO;
1159
1160                                 goto register_client;
1161                         }
1162                         break;
1163                 }
1164         }
1165
1166         /* Initializes only the first TV tuner on this adapter. Why only the
1167            first? Because there are some devices (notably the ones with TI
1168            tuners) that have more than one i2c address for the *same* device.
1169            Experience shows that, except for just one case, the first
1170            address is the right one. The exception is a Russian tuner
1171            (ACORP_Y878F). So, the desired behavior is just to enable the
1172            first found TV tuner. */
1173         tuner_lookup(t->i2c->adapter, &radio, &tv);
1174         if (tv == NULL) {
1175                 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1176                 if (radio == NULL)
1177                         t->mode_mask |= T_RADIO;
1178                 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1179                 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1180                 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1181         }
1182
1183         /* Should be just before return */
1184 register_client:
1185         tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1186                        client->adapter->name);
1187
1188         /* Sets a default mode */
1189         if (t->mode_mask & T_ANALOG_TV) {
1190                 t->mode = V4L2_TUNER_ANALOG_TV;
1191         } else  if (t->mode_mask & T_RADIO) {
1192                 t->mode = V4L2_TUNER_RADIO;
1193         } else {
1194                 t->mode = V4L2_TUNER_DIGITAL_TV;
1195         }
1196         set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
1197         list_add_tail(&t->list, &tuner_list);
1198         return 0;
1199 }
1200
1201 static int tuner_legacy_probe(struct i2c_adapter *adap)
1202 {
1203         if (0 != addr) {
1204                 normal_i2c[0] = addr;
1205                 normal_i2c[1] = I2C_CLIENT_END;
1206         }
1207
1208         if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1209                 return 0;
1210
1211         /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1212          * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1213          * and an RTC at 0x6f which can get corrupted if probed.
1214          */
1215         if ((adap->id == I2C_HW_B_CX2388x) ||
1216             (adap->id == I2C_HW_B_CX23885)) {
1217                 unsigned int i = 0;
1218
1219                 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1220                         i += 2;
1221                 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1222                         ignore[i+0] = adap->nr;
1223                         ignore[i+1] = 0x6b;
1224                         ignore[i+2] = adap->nr;
1225                         ignore[i+3] = 0x6f;
1226                         ignore[i+4] = I2C_CLIENT_END;
1227                 } else
1228                         printk(KERN_WARNING "tuner: "
1229                                "too many options specified "
1230                                "in i2c probe ignore list!\n");
1231         }
1232         return 1;
1233 }
1234
1235 static int tuner_remove(struct i2c_client *client)
1236 {
1237         struct tuner *t = i2c_get_clientdata(client);
1238         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1239
1240         if (analog_ops->release)
1241                 analog_ops->release(&t->fe);
1242
1243         list_del(&t->list);
1244         kfree(t);
1245         return 0;
1246 }
1247
1248 /* ----------------------------------------------------------------------- */
1249
1250 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1251         .name = "tuner",
1252         .driverid = I2C_DRIVERID_TUNER,
1253         .command = tuner_command,
1254         .probe = tuner_probe,
1255         .remove = tuner_remove,
1256         .suspend = tuner_suspend,
1257         .resume = tuner_resume,
1258         .legacy_probe = tuner_legacy_probe,
1259 };
1260
1261
1262 /*
1263  * Overrides for Emacs so that we follow Linus's tabbing style.
1264  * ---------------------------------------------------------------------------
1265  * Local variables:
1266  * c-basic-offset: 8
1267  * End:
1268  */