drivers/media/video/tuner-core.c

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