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) == NULL) {
 373                         t->type = TUNER_ABSENT;
 374                         t->mode_mask = T_UNINITIALIZED;
 375                         return;
 376                 }
 377                 t->mode_mask = T_RADIO;
 378                 break;
 379         case TUNER_TEA5761:
 380                 if (tea5761_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
 381                         t->type = TUNER_ABSENT;
 382                         t->mode_mask = T_UNINITIALIZED;
 383                         return;
 384                 }
 385                 t->mode_mask = T_RADIO;
 386                 break;
 387         case TUNER_PHILIPS_FMD1216ME_MK3:
 388                 buffer[0] = 0x0b;
 389                 buffer[1] = 0xdc;
 390                 buffer[2] = 0x9c;
 391                 buffer[3] = 0x60;
 392                 i2c_master_send(c, buffer, 4);
 393                 mdelay(1);
 394                 buffer[2] = 0x86;
 395                 buffer[3] = 0x54;
 396                 i2c_master_send(c, buffer, 4);
 397                 if (simple_tuner_attach(&t->fe, t->i2c->adapter, t->i2c->addr,
 398                                         t->type) == NULL) {
 399                         t->type = TUNER_ABSENT;
 400                         t->mode_mask = T_UNINITIALIZED;
 401                         return;
 402                 }
 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                 if (simple_tuner_attach(&t->fe, t->i2c->adapter,
 411                                         t->i2c->addr, t->type) == NULL) {
 412                         t->type = TUNER_ABSENT;
 413                         t->mode_mask = T_UNINITIALIZED;
 414                         return;
 415                 }
 416                 break;
 417         case TUNER_XC2028:
 418         {
 419                 struct xc2028_config cfg = {
 420                         .i2c_adap  = t->i2c->adapter,
 421                         .i2c_addr  = t->i2c->addr,
 422                         .callback  = t->tuner_callback,
 423                 };
 424                 if (!xc2028_attach(&t->fe, &cfg)) {
 425                         t->type = TUNER_ABSENT;
 426                         t->mode_mask = T_UNINITIALIZED;
 427                         return;
 428                 }
 429                 break;
 430         }
 431         case TUNER_TDA9887:
 432                 tda9887_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
 433                 break;
 434         case TUNER_XC5000:
 435                 xc5000_cfg.i2c_address    = t->i2c->addr;
 436                 xc5000_cfg.if_khz         = 5380;
 437                 xc5000_cfg.priv           = c->adapter->algo_data;
 438                 xc5000_cfg.tuner_callback = t->tuner_callback;
 439                 if (!xc5000_attach(&t->fe, t->i2c->adapter, &xc5000_cfg)) {
 440                         t->type = TUNER_ABSENT;
 441                         t->mode_mask = T_UNINITIALIZED;
 442                         return;
 443                 }
 444                 {
 445                 struct dvb_tuner_ops *xc_tuner_ops;
 446                 xc_tuner_ops = &t->fe.ops.tuner_ops;
 447                 if(xc_tuner_ops->init != NULL)
 448                         xc_tuner_ops->init(&t->fe);
 449                 }
 450                 break;
 451         default:
 452                 if (simple_tuner_attach(&t->fe, t->i2c->adapter,
 453                                         t->i2c->addr, t->type) == NULL) {
 454                         t->type = TUNER_ABSENT;
 455                         t->mode_mask = T_UNINITIALIZED;
 456                         return;
 457                 }
 458                 break;
 459         }
 460
 461         if ((NULL == analog_ops->set_params) &&
 462             (fe_tuner_ops->set_analog_params)) {
 463                 strlcpy(t->i2c->name, fe_tuner_ops->info.name,
 464                         sizeof(t->i2c->name));
 465
 466                 t->fe.analog_demod_priv = t;
 467                 memcpy(analog_ops, &tuner_core_ops,
 468                        sizeof(struct analog_demod_ops));
 469         } else {
 470                 strlcpy(t->i2c->name, analog_ops->info.name,
 471                         sizeof(t->i2c->name));
 472         }
 473
 474         tuner_dbg("type set to %s\n", t->i2c->name);
 475
 476         if (t->mode_mask == T_UNINITIALIZED)
 477                 t->mode_mask = new_mode_mask;
 478
 479         set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
 480         tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
 481                   c->adapter->name, c->driver->driver.name, c->addr << 1, type,
 482                   t->mode_mask);
 483         tuner_i2c_address_check(t);
 484 }
 485
 486 /*
 487  * This function apply tuner config to tuner specified
 488  * by tun_setup structure. I addr is unset, then admin status
 489  * and tun addr status is more precise then current status,
 490  * it's applied. Otherwise status and type are applied only to
 491  * tuner with exactly the same addr.
 492 */
 493
 494 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
 495 {
 496         struct tuner *t = i2c_get_clientdata(c);
 497
 498         tuner_dbg("set addr for type %i\n", t->type);
 499
 500         if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
 501                 (t->mode_mask & tun_setup->mode_mask))) ||
 502                 (tun_setup->addr == c->addr)) {
 503                         set_type(c, tun_setup->type, tun_setup->mode_mask,
 504                                  tun_setup->config, tun_setup->tuner_callback);
 505         }
 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
 736         switch (cmd) {
 737         /* --- configuration --- */
 738         case TUNER_SET_TYPE_ADDR:
 739                 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
 740                                 ((struct tuner_setup *)arg)->type,
 741                                 ((struct tuner_setup *)arg)->addr,
 742                                 ((struct tuner_setup *)arg)->mode_mask,
 743                                 ((struct tuner_setup *)arg)->config);
 744
 745                 set_addr(client, (struct tuner_setup *)arg);
 746                 break;
 747         case AUDC_SET_RADIO:
 748                 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
 749                                 == EINVAL)
 750                         return 0;
 751                 if (t->radio_freq)
 752                         set_freq(client, t->radio_freq);
 753                 break;
 754         case TUNER_SET_STANDBY:
 755                 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
 756                         return 0;
 757                 t->mode = T_STANDBY;
 758                 if (analog_ops->standby)
 759                         analog_ops->standby(&t->fe);
 760                 break;
 761 #ifdef CONFIG_VIDEO_ALLOW_V4L1
 762         case VIDIOCSAUDIO:
 763                 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
 764                         return 0;
 765                 if (check_v4l2(t) == EINVAL)
 766                         return 0;
 767
 768                 /* Should be implemented, since bttv calls it */
 769                 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
 770                 break;
 771         case VIDIOCSCHAN:
 772                 {
 773                         static const v4l2_std_id map[] = {
 774                                 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
 775                                 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
 776                                 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
 777                                 [4 /* bttv */ ] = V4L2_STD_PAL_M,
 778                                 [5 /* bttv */ ] = V4L2_STD_PAL_N,
 779                                 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
 780                         };
 781                         struct video_channel *vc = arg;
 782
 783                         if (check_v4l2(t) == EINVAL)
 784                                 return 0;
 785
 786                         if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
 787                                 return 0;
 788
 789                         if (vc->norm < ARRAY_SIZE(map))
 790                                 t->std = map[vc->norm];
 791                         tuner_fixup_std(t);
 792                         if (t->tv_freq)
 793                                 set_tv_freq(client, t->tv_freq);
 794                         return 0;
 795                 }
 796         case VIDIOCSFREQ:
 797                 {
 798                         unsigned long *v = arg;
 799
 800                         if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
 801                                 return 0;
 802                         if (check_v4l2(t) == EINVAL)
 803                                 return 0;
 804
 805                         set_freq(client, *v);
 806                         return 0;
 807                 }
 808         case VIDIOCGTUNER:
 809                 {
 810                         struct video_tuner *vt = arg;
 811
 812                         if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
 813                                 return 0;
 814                         if (check_v4l2(t) == EINVAL)
 815                                 return 0;
 816
 817                         if (V4L2_TUNER_RADIO == t->mode) {
 818                                 if (fe_tuner_ops->get_status) {
 819                                         u32 tuner_status;
 820
 821                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 822                                         if (tuner_status & TUNER_STATUS_STEREO)
 823                                                 vt->flags |= VIDEO_TUNER_STEREO_ON;
 824                                         else
 825                                                 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
 826                                 } else {
 827                                         if (analog_ops->is_stereo) {
 828                                                 if (analog_ops->is_stereo(&t->fe))
 829                                                         vt->flags |=
 830                                                                 VIDEO_TUNER_STEREO_ON;
 831                                                 else
 832                                                         vt->flags &=
 833                                                                 ~VIDEO_TUNER_STEREO_ON;
 834                                         }
 835                                 }
 836                                 if (analog_ops->has_signal)
 837                                         vt->signal =
 838                                                 analog_ops->has_signal(&t->fe);
 839
 840                                 vt->flags |= VIDEO_TUNER_LOW;   /* Allow freqs at 62.5 Hz */
 841
 842                                 vt->rangelow = radio_range[0] * 16000;
 843                                 vt->rangehigh = radio_range[1] * 16000;
 844
 845                         } else {
 846                                 vt->rangelow = tv_range[0] * 16;
 847                                 vt->rangehigh = tv_range[1] * 16;
 848                         }
 849
 850                         return 0;
 851                 }
 852         case VIDIOCGAUDIO:
 853                 {
 854                         struct video_audio *va = arg;
 855
 856                         if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
 857                                 return 0;
 858                         if (check_v4l2(t) == EINVAL)
 859                                 return 0;
 860
 861                         if (V4L2_TUNER_RADIO == t->mode) {
 862                                 if (fe_tuner_ops->get_status) {
 863                                         u32 tuner_status;
 864
 865                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 866                                         va->mode = (tuner_status & TUNER_STATUS_STEREO)
 867                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 868                                 } else if (analog_ops->is_stereo)
 869                                         va->mode = analog_ops->is_stereo(&t->fe)
 870                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 871                         }
 872                         return 0;
 873                 }
 874 #endif
 875         case TUNER_SET_CONFIG:
 876         {
 877                 struct v4l2_priv_tun_config *cfg = arg;
 878
 879                 if (t->type != cfg->tuner)
 880                         break;
 881
 882                 if (analog_ops->set_config) {
 883                         analog_ops->set_config(&t->fe, cfg->priv);
 884                         break;
 885                 }
 886
 887                 tuner_dbg("Tuner frontend module has no way to set config\n");
 888                 break;
 889         }
 890         /* --- v4l ioctls --- */
 891         /* take care: bttv does userspace copying, we'll get a
 892            kernel pointer here... */
 893         case VIDIOC_S_STD:
 894                 {
 895                         v4l2_std_id *id = arg;
 896
 897                         if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
 898                                         == EINVAL)
 899                                 return 0;
 900
 901                         switch_v4l2();
 902
 903                         t->std = *id;
 904                         tuner_fixup_std(t);
 905                         if (t->tv_freq)
 906                                 set_freq(client, t->tv_freq);
 907                         break;
 908                 }
 909         case VIDIOC_S_FREQUENCY:
 910                 {
 911                         struct v4l2_frequency *f = arg;
 912
 913                         if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
 914                                         == EINVAL)
 915                                 return 0;
 916                         switch_v4l2();
 917                         set_freq(client,f->frequency);
 918
 919                         break;
 920                 }
 921         case VIDIOC_G_FREQUENCY:
 922                 {
 923                         struct v4l2_frequency *f = arg;
 924
 925                         if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
 926                                 return 0;
 927                         switch_v4l2();
 928                         f->type = t->mode;
 929                         if (fe_tuner_ops->get_frequency) {
 930                                 u32 abs_freq;
 931
 932                                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
 933                                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 934                                         (abs_freq * 2 + 125/2) / 125 :
 935                                         (abs_freq + 62500/2) / 62500;
 936                                 break;
 937                         }
 938                         f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 939                                 t->radio_freq : t->tv_freq;
 940                         break;
 941                 }
 942         case VIDIOC_G_TUNER:
 943                 {
 944                         struct v4l2_tuner *tuner = arg;
 945
 946                         if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
 947                                 return 0;
 948                         switch_v4l2();
 949
 950                         tuner->type = t->mode;
 951                         if (analog_ops->get_afc)
 952                                 tuner->afc = analog_ops->get_afc(&t->fe);
 953                         if (t->mode == V4L2_TUNER_ANALOG_TV)
 954                                 tuner->capability |= V4L2_TUNER_CAP_NORM;
 955                         if (t->mode != V4L2_TUNER_RADIO) {
 956                                 tuner->rangelow = tv_range[0] * 16;
 957                                 tuner->rangehigh = tv_range[1] * 16;
 958                                 break;
 959                         }
 960
 961                         /* radio mode */
 962                         tuner->rxsubchans =
 963                                 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
 964                         if (fe_tuner_ops->get_status) {
 965                                 u32 tuner_status;
 966
 967                                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
 968                                 tuner->rxsubchans =
 969                                         (tuner_status & TUNER_STATUS_STEREO) ?
 970                                         V4L2_TUNER_SUB_STEREO :
 971                                         V4L2_TUNER_SUB_MONO;
 972                         } else {
 973                                 if (analog_ops->is_stereo) {
 974                                         tuner->rxsubchans =
 975                                                 analog_ops->is_stereo(&t->fe) ?
 976                                                 V4L2_TUNER_SUB_STEREO :
 977                                                 V4L2_TUNER_SUB_MONO;
 978                                 }
 979                         }
 980                         if (analog_ops->has_signal)
 981                                 tuner->signal = analog_ops->has_signal(&t->fe);
 982                         tuner->capability |=
 983                             V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
 984                         tuner->audmode = t->audmode;
 985                         tuner->rangelow = radio_range[0] * 16000;
 986                         tuner->rangehigh = radio_range[1] * 16000;
 987                         break;
 988                 }
 989         case VIDIOC_S_TUNER:
 990                 {
 991                         struct v4l2_tuner *tuner = arg;
 992
 993                         if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
 994                                 return 0;
 995
 996                         switch_v4l2();
 997
 998                         /* do nothing unless we're a radio tuner */
 999                         if (t->mode != V4L2_TUNER_RADIO)
1000                                 break;
1001                         t->audmode = tuner->audmode;
1002                         set_radio_freq(client, t->radio_freq);
1003                         break;
1004                 }
1005         case VIDIOC_LOG_STATUS:
1006                 if (analog_ops->tuner_status)
1007                         analog_ops->tuner_status(&t->fe);
1008                 break;
1009         }
1010
1011         return 0;
1012 }
1013
1014 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1015 {
1016         struct tuner *t = i2c_get_clientdata(c);
1017
1018         tuner_dbg("suspend\n");
1019         /* FIXME: power down ??? */
1020         return 0;
1021 }
1022
1023 static int tuner_resume(struct i2c_client *c)
1024 {
1025         struct tuner *t = i2c_get_clientdata(c);
1026
1027         tuner_dbg("resume\n");
1028         if (V4L2_TUNER_RADIO == t->mode) {
1029                 if (t->radio_freq)
1030                         set_freq(c, t->radio_freq);
1031         } else {
1032                 if (t->tv_freq)
1033                         set_freq(c, t->tv_freq);
1034         }
1035         return 0;
1036 }
1037
1038 /* ---------------------------------------------------------------------- */
1039
1040 static LIST_HEAD(tuner_list);
1041
1042 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1043    Note that when this function is called from tuner_probe you can be
1044    certain no other devices will be added/deleted at the same time, I2C
1045    core protects against that. */
1046 static void tuner_lookup(struct i2c_adapter *adap,
1047                 struct tuner **radio, struct tuner **tv)
1048 {
1049         struct tuner *pos;
1050
1051         *radio = NULL;
1052         *tv = NULL;
1053
1054         list_for_each_entry(pos, &tuner_list, list) {
1055                 int mode_mask;
1056
1057                 if (pos->i2c->adapter != adap ||
1058                     pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1059                         continue;
1060
1061                 mode_mask = pos->mode_mask & ~T_STANDBY;
1062                 if (*radio == NULL && mode_mask == T_RADIO)
1063                         *radio = pos;
1064                 /* Note: currently TDA9887 is the only demod-only
1065                    device. If other devices appear then we need to
1066                    make this test more general. */
1067                 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1068                          (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1069                         *tv = pos;
1070         }
1071 }
1072
1073 /* During client attach, set_type is called by adapter's attach_inform callback.
1074    set_type must then be completed by tuner_probe.
1075  */
1076 static int tuner_probe(struct i2c_client *client)
1077 {
1078         struct tuner *t;
1079         struct tuner *radio;
1080         struct tuner *tv;
1081
1082         t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1083         if (NULL == t)
1084                 return -ENOMEM;
1085         t->i2c = client;
1086         strlcpy(client->name, "(tuner unset)", sizeof(client->name));
1087         i2c_set_clientdata(client, t);
1088         t->type = UNSET;
1089         t->audmode = V4L2_TUNER_MODE_STEREO;
1090         t->mode_mask = T_UNINITIALIZED;
1091
1092         if (show_i2c) {
1093                 unsigned char buffer[16];
1094                 int i, rc;
1095
1096                 memset(buffer, 0, sizeof(buffer));
1097                 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1098                 tuner_info("I2C RECV = ");
1099                 for (i = 0; i < rc; i++)
1100                         printk(KERN_CONT "%02x ", buffer[i]);
1101                 printk("\n");
1102         }
1103         /* HACK: This test was added to avoid tuner to probe tda9840 and
1104            tea6415c on the MXB card */
1105         if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1106                 kfree(t);
1107                 return -ENODEV;
1108         }
1109
1110         /* autodetection code based on the i2c addr */
1111         if (!no_autodetect) {
1112                 switch (client->addr) {
1113                 case 0x10:
1114                         if (tea5761_autodetection(t->i2c->adapter,
1115                                                   t->i2c->addr) >= 0) {
1116                                 t->type = TUNER_TEA5761;
1117                                 t->mode_mask = T_RADIO;
1118                                 t->mode = T_STANDBY;
1119                                 /* Sets freq to FM range */
1120                                 t->radio_freq = 87.5 * 16000;
1121                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1122                                 if (tv)
1123                                         tv->mode_mask &= ~T_RADIO;
1124
1125                                 goto register_client;
1126                         }
1127                         return -ENODEV;
1128                 case 0x42:
1129                 case 0x43:
1130                 case 0x4a:
1131                 case 0x4b:
1132                         /* If chip is not tda8290, don't register.
1133                            since it can be tda9887*/
1134                         if (tda829x_probe(t->i2c->adapter,
1135                                           t->i2c->addr) == 0) {
1136                                 tuner_dbg("tda829x detected\n");
1137                         } else {
1138                                 /* Default is being tda9887 */
1139                                 t->type = TUNER_TDA9887;
1140                                 t->mode_mask = T_RADIO | T_ANALOG_TV |
1141                                                T_DIGITAL_TV;
1142                                 t->mode = T_STANDBY;
1143                                 goto register_client;
1144                         }
1145                         break;
1146                 case 0x60:
1147                         if (tea5767_autodetection(t->i2c->adapter, t->i2c->addr)
1148                                         != EINVAL) {
1149                                 t->type = TUNER_TEA5767;
1150                                 t->mode_mask = T_RADIO;
1151                                 t->mode = T_STANDBY;
1152                                 /* Sets freq to FM range */
1153                                 t->radio_freq = 87.5 * 16000;
1154                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1155                                 if (tv)
1156                                         tv->mode_mask &= ~T_RADIO;
1157
1158                                 goto register_client;
1159                         }
1160                         break;
1161                 }
1162         }
1163
1164         /* Initializes only the first TV tuner on this adapter. Why only the
1165            first? Because there are some devices (notably the ones with TI
1166            tuners) that have more than one i2c address for the *same* device.
1167            Experience shows that, except for just one case, the first
1168            address is the right one. The exception is a Russian tuner
1169            (ACORP_Y878F). So, the desired behavior is just to enable the
1170            first found TV tuner. */
1171         tuner_lookup(t->i2c->adapter, &radio, &tv);
1172         if (tv == NULL) {
1173                 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1174                 if (radio == NULL)
1175                         t->mode_mask |= T_RADIO;
1176                 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1177                 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1178                 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1179         }
1180
1181         /* Should be just before return */
1182 register_client:
1183         tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1184                        client->adapter->name);
1185
1186         /* Sets a default mode */
1187         if (t->mode_mask & T_ANALOG_TV) {
1188                 t->mode = V4L2_TUNER_ANALOG_TV;
1189         } else  if (t->mode_mask & T_RADIO) {
1190                 t->mode = V4L2_TUNER_RADIO;
1191         } else {
1192                 t->mode = V4L2_TUNER_DIGITAL_TV;
1193         }
1194         set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
1195         list_add_tail(&t->list, &tuner_list);
1196         return 0;
1197 }
1198
1199 static int tuner_legacy_probe(struct i2c_adapter *adap)
1200 {
1201         if (0 != addr) {
1202                 normal_i2c[0] = addr;
1203                 normal_i2c[1] = I2C_CLIENT_END;
1204         }
1205
1206         if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1207                 return 0;
1208
1209         /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1210          * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1211          * and an RTC at 0x6f which can get corrupted if probed.
1212          */
1213         if ((adap->id == I2C_HW_B_CX2388x) ||
1214             (adap->id == I2C_HW_B_CX23885)) {
1215                 unsigned int i = 0;
1216
1217                 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1218                         i += 2;
1219                 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1220                         ignore[i+0] = adap->nr;
1221                         ignore[i+1] = 0x6b;
1222                         ignore[i+2] = adap->nr;
1223                         ignore[i+3] = 0x6f;
1224                         ignore[i+4] = I2C_CLIENT_END;
1225                 } else
1226                         printk(KERN_WARNING "tuner: "
1227                                "too many options specified "
1228                                "in i2c probe ignore list!\n");
1229         }
1230         return 1;
1231 }
1232
1233 static int tuner_remove(struct i2c_client *client)
1234 {
1235         struct tuner *t = i2c_get_clientdata(client);
1236         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1237
1238         if (analog_ops->release)
1239                 analog_ops->release(&t->fe);
1240
1241         list_del(&t->list);
1242         kfree(t);
1243         return 0;
1244 }
1245
1246 /* ----------------------------------------------------------------------- */
1247
1248 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1249         .name = "tuner",
1250         .driverid = I2C_DRIVERID_TUNER,
1251         .command = tuner_command,
1252         .probe = tuner_probe,
1253         .remove = tuner_remove,
1254         .suspend = tuner_suspend,
1255         .resume = tuner_resume,
1256         .legacy_probe = tuner_legacy_probe,
1257 };
1258
1259
1260 /*
1261  * Overrides for Emacs so that we follow Linus's tabbing style.
1262  * ---------------------------------------------------------------------------
1263  * Local variables:
1264  * c-basic-offset: 8
1265  * End:
1266  */