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         t->config = new_config;
 368         if (tuner_callback != NULL) {
 369                 tuner_dbg("defining GPIO callback\n");
 370                 t->fe.callback = tuner_callback;
 371         }
 372
 373         if (t->mode == T_UNINITIALIZED) {
 374                 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
 375
 376                 return;
 377         }
 378
 379         /* discard private data, in case set_type() was previously called */
 380         tuner_detach(&t->fe);
 381         t->fe.analog_demod_priv = NULL;
 382
 383         switch (t->type) {
 384         case TUNER_MT2032:
 385                 if (!dvb_attach(microtune_attach,
 386                            &t->fe, t->i2c->adapter, t->i2c->addr))
 387                         goto attach_failed;
 388                 break;
 389         case TUNER_PHILIPS_TDA8290:
 390         {
 391                 struct tda829x_config cfg = {
 392                         .lna_cfg        = t->config,
 393                 };
 394                 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
 395                                 t->i2c->addr, &cfg))
 396                         goto attach_failed;
 397                 break;
 398         }
 399         case TUNER_TEA5767:
 400                 if (!dvb_attach(tea5767_attach, &t->fe,
 401                                 t->i2c->adapter, t->i2c->addr))
 402                         goto attach_failed;
 403                 t->mode_mask = T_RADIO;
 404                 break;
 405         case TUNER_TEA5761:
 406                 if (!dvb_attach(tea5761_attach, &t->fe,
 407                                 t->i2c->adapter, t->i2c->addr))
 408                         goto attach_failed;
 409                 t->mode_mask = T_RADIO;
 410                 break;
 411         case TUNER_PHILIPS_FMD1216ME_MK3:
 412                 buffer[0] = 0x0b;
 413                 buffer[1] = 0xdc;
 414                 buffer[2] = 0x9c;
 415                 buffer[3] = 0x60;
 416                 i2c_master_send(c, buffer, 4);
 417                 mdelay(1);
 418                 buffer[2] = 0x86;
 419                 buffer[3] = 0x54;
 420                 i2c_master_send(c, buffer, 4);
 421                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 422                                 t->i2c->adapter, t->i2c->addr, t->type))
 423                         goto attach_failed;
 424                 break;
 425         case TUNER_PHILIPS_TD1316:
 426                 buffer[0] = 0x0b;
 427                 buffer[1] = 0xdc;
 428                 buffer[2] = 0x86;
 429                 buffer[3] = 0xa4;
 430                 i2c_master_send(c, buffer, 4);
 431                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 432                                 t->i2c->adapter, t->i2c->addr, t->type))
 433                         goto attach_failed;
 434                 break;
 435         case TUNER_XC2028:
 436         {
 437                 struct xc2028_config cfg = {
 438                         .i2c_adap  = t->i2c->adapter,
 439                         .i2c_addr  = t->i2c->addr,
 440                 };
 441                 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
 442                         goto attach_failed;
 443                 break;
 444         }
 445         case TUNER_TDA9887:
 446                 if (!dvb_attach(tda9887_attach,
 447                            &t->fe, t->i2c->adapter, t->i2c->addr))
 448                         goto attach_failed;
 449                 break;
 450         case TUNER_XC5000:
 451         {
 452                 struct dvb_tuner_ops *xc_tuner_ops;
 453
 454                 xc5000_cfg.i2c_address    = t->i2c->addr;
 455                 /* if_khz will be set when the digital dvb_attach() occurs */
 456                 xc5000_cfg.if_khz         = 0;
 457                 if (!dvb_attach(xc5000_attach,
 458                                 &t->fe, t->i2c->adapter, &xc5000_cfg))
 459                         goto attach_failed;
 460
 461                 xc_tuner_ops = &t->fe.ops.tuner_ops;
 462                 if (xc_tuner_ops->init)
 463                         xc_tuner_ops->init(&t->fe);
 464                 break;
 465         }
 466         default:
 467                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 468                                 t->i2c->adapter, t->i2c->addr, t->type))
 469                         goto attach_failed;
 470
 471                 break;
 472         }
 473
 474         if ((NULL == analog_ops->set_params) &&
 475             (fe_tuner_ops->set_analog_params)) {
 476
 477                 t->name = fe_tuner_ops->info.name;
 478
 479                 t->fe.analog_demod_priv = t;
 480                 memcpy(analog_ops, &tuner_analog_ops,
 481                        sizeof(struct analog_demod_ops));
 482
 483         } else {
 484                 t->name = analog_ops->info.name;
 485         }
 486
 487         tuner_dbg("type set to %s\n", t->name);
 488
 489         if (t->mode_mask == T_UNINITIALIZED)
 490                 t->mode_mask = new_mode_mask;
 491
 492         /* xc2028/3028 and xc5000 requires a firmware to be set-up later
 493            trying to set a frequency here will just fail
 494            FIXME: better to move set_freq to the tuner code. This is needed
 495            on analog tuners for PLL to properly work
 496          */
 497         if (t->type != TUNER_XC2028 && t->type != TUNER_XC5000)
 498                 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ?
 499                             t->radio_freq : t->tv_freq);
 500
 501         tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
 502                   c->adapter->name, c->driver->driver.name, c->addr << 1, type,
 503                   t->mode_mask);
 504         tuner_i2c_address_check(t);
 505         return;
 506
 507 attach_failed:
 508         tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
 509         t->type = TUNER_ABSENT;
 510         t->mode_mask = T_UNINITIALIZED;
 511
 512         return;
 513 }
 514
 515 /*
 516  * This function apply tuner config to tuner specified
 517  * by tun_setup structure. I addr is unset, then admin status
 518  * and tun addr status is more precise then current status,
 519  * it's applied. Otherwise status and type are applied only to
 520  * tuner with exactly the same addr.
 521 */
 522
 523 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
 524 {
 525         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 526
 527         if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
 528                 (t->mode_mask & tun_setup->mode_mask))) ||
 529                 (tun_setup->addr == c->addr)) {
 530                         set_type(c, tun_setup->type, tun_setup->mode_mask,
 531                                  tun_setup->config, tun_setup->tuner_callback);
 532         } else
 533                 tuner_dbg("set addr discarded for type %i, mask %x. "
 534                           "Asked to change tuner at addr 0x%02x, with mask %x\n",
 535                           t->type, t->mode_mask,
 536                           tun_setup->addr, tun_setup->mode_mask);
 537 }
 538
 539 static inline int check_mode(struct tuner *t, char *cmd)
 540 {
 541         if ((1 << t->mode & t->mode_mask) == 0) {
 542                 return -EINVAL;
 543         }
 544
 545         switch (t->mode) {
 546         case V4L2_TUNER_RADIO:
 547                 tuner_dbg("Cmd %s accepted for radio\n", cmd);
 548                 break;
 549         case V4L2_TUNER_ANALOG_TV:
 550                 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
 551                 break;
 552         case V4L2_TUNER_DIGITAL_TV:
 553                 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
 554                 break;
 555         }
 556         return 0;
 557 }
 558
 559 /* get more precise norm info from insmod option */
 560 static int tuner_fixup_std(struct tuner *t)
 561 {
 562         if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
 563                 switch (pal[0]) {
 564                 case '6':
 565                         tuner_dbg ("insmod fixup: PAL => PAL-60\n");
 566                         t->std = V4L2_STD_PAL_60;
 567                         break;
 568                 case 'b':
 569                 case 'B':
 570                 case 'g':
 571                 case 'G':
 572                         tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
 573                         t->std = V4L2_STD_PAL_BG;
 574                         break;
 575                 case 'i':
 576                 case 'I':
 577                         tuner_dbg ("insmod fixup: PAL => PAL-I\n");
 578                         t->std = V4L2_STD_PAL_I;
 579                         break;
 580                 case 'd':
 581                 case 'D':
 582                 case 'k':
 583                 case 'K':
 584                         tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
 585                         t->std = V4L2_STD_PAL_DK;
 586                         break;
 587                 case 'M':
 588                 case 'm':
 589                         tuner_dbg ("insmod fixup: PAL => PAL-M\n");
 590                         t->std = V4L2_STD_PAL_M;
 591                         break;
 592                 case 'N':
 593                 case 'n':
 594                         if (pal[1] == 'c' || pal[1] == 'C') {
 595                                 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
 596                                 t->std = V4L2_STD_PAL_Nc;
 597                         } else {
 598                                 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
 599                                 t->std = V4L2_STD_PAL_N;
 600                         }
 601                         break;
 602                 case '-':
 603                         /* default parameter, do nothing */
 604                         break;
 605                 default:
 606                         tuner_warn ("pal= argument not recognised\n");
 607                         break;
 608                 }
 609         }
 610         if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
 611                 switch (secam[0]) {
 612                 case 'b':
 613                 case 'B':
 614                 case 'g':
 615                 case 'G':
 616                 case 'h':
 617                 case 'H':
 618                         tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
 619                         t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
 620                         break;
 621                 case 'd':
 622                 case 'D':
 623                 case 'k':
 624                 case 'K':
 625                         tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
 626                         t->std = V4L2_STD_SECAM_DK;
 627                         break;
 628                 case 'l':
 629                 case 'L':
 630                         if ((secam[1]=='C')||(secam[1]=='c')) {
 631                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
 632                                 t->std = V4L2_STD_SECAM_LC;
 633                         } else {
 634                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
 635                                 t->std = V4L2_STD_SECAM_L;
 636                         }
 637                         break;
 638                 case '-':
 639                         /* default parameter, do nothing */
 640                         break;
 641                 default:
 642                         tuner_warn ("secam= argument not recognised\n");
 643                         break;
 644                 }
 645         }
 646
 647         if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
 648                 switch (ntsc[0]) {
 649                 case 'm':
 650                 case 'M':
 651                         tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
 652                         t->std = V4L2_STD_NTSC_M;
 653                         break;
 654                 case 'j':
 655                 case 'J':
 656                         tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
 657                         t->std = V4L2_STD_NTSC_M_JP;
 658                         break;
 659                 case 'k':
 660                 case 'K':
 661                         tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
 662                         t->std = V4L2_STD_NTSC_M_KR;
 663                         break;
 664                 case '-':
 665                         /* default parameter, do nothing */
 666                         break;
 667                 default:
 668                         tuner_info("ntsc= argument not recognised\n");
 669                         break;
 670                 }
 671         }
 672         return 0;
 673 }
 674
 675 static void tuner_status(struct dvb_frontend *fe)
 676 {
 677         struct tuner *t = fe->analog_demod_priv;
 678         unsigned long freq, freq_fraction;
 679         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 680         struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
 681         const char *p;
 682
 683         switch (t->mode) {
 684                 case V4L2_TUNER_RADIO:      p = "radio"; break;
 685                 case V4L2_TUNER_ANALOG_TV:  p = "analog TV"; break;
 686                 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
 687                 default: p = "undefined"; break;
 688         }
 689         if (t->mode == V4L2_TUNER_RADIO) {
 690                 freq = t->radio_freq / 16000;
 691                 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
 692         } else {
 693                 freq = t->tv_freq / 16;
 694                 freq_fraction = (t->tv_freq % 16) * 100 / 16;
 695         }
 696         tuner_info("Tuner mode:      %s\n", p);
 697         tuner_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
 698         tuner_info("Standard:        0x%08lx\n", (unsigned long)t->std);
 699         if (t->mode != V4L2_TUNER_RADIO)
 700                return;
 701         if (fe_tuner_ops->get_status) {
 702                 u32 tuner_status;
 703
 704                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
 705                 if (tuner_status & TUNER_STATUS_LOCKED)
 706                         tuner_info("Tuner is locked.\n");
 707                 if (tuner_status & TUNER_STATUS_STEREO)
 708                         tuner_info("Stereo:          yes\n");
 709         }
 710         if (analog_ops->has_signal)
 711                 tuner_info("Signal strength: %d\n",
 712                            analog_ops->has_signal(fe));
 713         if (analog_ops->is_stereo)
 714                 tuner_info("Stereo:          %s\n",
 715                            analog_ops->is_stereo(fe) ? "yes" : "no");
 716 }
 717
 718 /* ---------------------------------------------------------------------- */
 719
 720 /*
 721  * Switch tuner to other mode. If tuner support both tv and radio,
 722  * set another frequency to some value (This is needed for some pal
 723  * tuners to avoid locking). Otherwise, just put second tuner in
 724  * standby mode.
 725  */
 726
 727 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
 728 {
 729         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 730
 731         if (mode == t->mode)
 732                 return 0;
 733
 734         t->mode = mode;
 735
 736         if (check_mode(t, cmd) == -EINVAL) {
 737                 tuner_dbg("Tuner doesn't support this mode. "
 738                           "Putting tuner to sleep\n");
 739                 t->mode = T_STANDBY;
 740                 if (analog_ops->standby)
 741                         analog_ops->standby(&t->fe);
 742                 return -EINVAL;
 743         }
 744         return 0;
 745 }
 746
 747 #define switch_v4l2()   if (!t->using_v4l2) \
 748                             tuner_dbg("switching to v4l2\n"); \
 749                         t->using_v4l2 = 1;
 750
 751 static inline int check_v4l2(struct tuner *t)
 752 {
 753         /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
 754            TV, v4l1 for radio), until that is fixed this code is disabled.
 755            Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
 756            first. */
 757         return 0;
 758 }
 759
 760 static int tuner_s_type_addr(struct v4l2_subdev *sd, struct tuner_setup *type)
 761 {
 762         struct tuner *t = to_tuner(sd);
 763         struct i2c_client *client = v4l2_get_subdevdata(sd);
 764
 765         tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
 766                         type->type,
 767                         type->addr,
 768                         type->mode_mask,
 769                         type->config);
 770
 771         set_addr(client, type);
 772         return 0;
 773 }
 774
 775 static int tuner_s_radio(struct v4l2_subdev *sd)
 776 {
 777         struct tuner *t = to_tuner(sd);
 778         struct i2c_client *client = v4l2_get_subdevdata(sd);
 779
 780         if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
 781                         == -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, "TUNER_SET_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, "VIDIOC_S_STD")
 955                         == -EINVAL)
 956                 return 0;
 957
 958         switch_v4l2();
 959
 960         t->std = std;
 961         tuner_fixup_std(t);
 962         if (t->tv_freq)
 963                 set_freq(client, t->tv_freq);
 964         return 0;
 965 }
 966
 967 static int tuner_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
 968 {
 969         struct tuner *t = to_tuner(sd);
 970         struct i2c_client *client = v4l2_get_subdevdata(sd);
 971
 972         if (set_mode(client, t, f->type, "VIDIOC_S_FREQUENCY")
 973                         == -EINVAL)
 974                 return 0;
 975         switch_v4l2();
 976         set_freq(client, f->frequency);
 977
 978         return 0;
 979 }
 980
 981 static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
 982 {
 983         struct tuner *t = to_tuner(sd);
 984         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 985
 986         if (check_mode(t, "VIDIOC_G_FREQUENCY") == -EINVAL)
 987                 return 0;
 988         switch_v4l2();
 989         f->type = t->mode;
 990         if (fe_tuner_ops->get_frequency) {
 991                 u32 abs_freq;
 992
 993                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
 994                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 995                         (abs_freq * 2 + 125/2) / 125 :
 996                         (abs_freq + 62500/2) / 62500;
 997                 return 0;
 998         }
 999         f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
1000                 t->radio_freq : t->tv_freq;
1001         return 0;
1002 }
1003
1004 static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1005 {
1006         struct tuner *t = to_tuner(sd);
1007         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1008         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1009
1010         if (check_mode(t, "VIDIOC_G_TUNER") == -EINVAL)
1011                 return 0;
1012         switch_v4l2();
1013
1014         vt->type = t->mode;
1015         if (analog_ops->get_afc)
1016                 vt->afc = analog_ops->get_afc(&t->fe);
1017         if (t->mode == V4L2_TUNER_ANALOG_TV)
1018                 vt->capability |= V4L2_TUNER_CAP_NORM;
1019         if (t->mode != V4L2_TUNER_RADIO) {
1020                 vt->rangelow = tv_range[0] * 16;
1021                 vt->rangehigh = tv_range[1] * 16;
1022                 return 0;
1023         }
1024
1025         /* radio mode */
1026         vt->rxsubchans =
1027                 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1028         if (fe_tuner_ops->get_status) {
1029                 u32 tuner_status;
1030
1031                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1032                 vt->rxsubchans =
1033                         (tuner_status & TUNER_STATUS_STEREO) ?
1034                         V4L2_TUNER_SUB_STEREO :
1035                         V4L2_TUNER_SUB_MONO;
1036         } else {
1037                 if (analog_ops->is_stereo) {
1038                         vt->rxsubchans =
1039                                 analog_ops->is_stereo(&t->fe) ?
1040                                 V4L2_TUNER_SUB_STEREO :
1041                                 V4L2_TUNER_SUB_MONO;
1042                 }
1043         }
1044         if (analog_ops->has_signal)
1045                 vt->signal = analog_ops->has_signal(&t->fe);
1046         vt->capability |=
1047                 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1048         vt->audmode = t->audmode;
1049         vt->rangelow = radio_range[0] * 16000;
1050         vt->rangehigh = radio_range[1] * 16000;
1051         return 0;
1052 }
1053
1054 static int tuner_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1055 {
1056         struct tuner *t = to_tuner(sd);
1057         struct i2c_client *client = v4l2_get_subdevdata(sd);
1058
1059         if (check_mode(t, "VIDIOC_S_TUNER") == -EINVAL)
1060                 return 0;
1061
1062         switch_v4l2();
1063
1064         /* do nothing unless we're a radio tuner */
1065         if (t->mode != V4L2_TUNER_RADIO)
1066                 return 0;
1067         t->audmode = vt->audmode;
1068         set_radio_freq(client, t->radio_freq);
1069         return 0;
1070 }
1071
1072 static int tuner_log_status(struct v4l2_subdev *sd)
1073 {
1074         struct tuner *t = to_tuner(sd);
1075         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1076
1077         if (analog_ops->tuner_status)
1078                 analog_ops->tuner_status(&t->fe);
1079         return 0;
1080 }
1081
1082 static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1083 {
1084         return v4l2_subdev_command(i2c_get_clientdata(client), cmd, arg);
1085 }
1086
1087 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1088 {
1089         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1090
1091         tuner_dbg("suspend\n");
1092         /* FIXME: power down ??? */
1093         return 0;
1094 }
1095
1096 static int tuner_resume(struct i2c_client *c)
1097 {
1098         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1099
1100         tuner_dbg("resume\n");
1101         if (V4L2_TUNER_RADIO == t->mode) {
1102                 if (t->radio_freq)
1103                         set_freq(c, t->radio_freq);
1104         } else {
1105                 if (t->tv_freq)
1106                         set_freq(c, t->tv_freq);
1107         }
1108         return 0;
1109 }
1110
1111 /* ----------------------------------------------------------------------- */
1112
1113 static const struct v4l2_subdev_core_ops tuner_core_ops = {
1114         .log_status = tuner_log_status,
1115         .s_standby = tuner_s_standby,
1116 #ifdef CONFIG_VIDEO_ALLOW_V4L1
1117         .ioctl = tuner_ioctl,
1118 #endif
1119 };
1120
1121 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
1122         .s_std = tuner_s_std,
1123         .s_radio = tuner_s_radio,
1124         .g_tuner = tuner_g_tuner,
1125         .s_tuner = tuner_s_tuner,
1126         .s_frequency = tuner_s_frequency,
1127         .g_frequency = tuner_g_frequency,
1128         .s_type_addr = tuner_s_type_addr,
1129         .s_config = tuner_s_config,
1130 };
1131
1132 static const struct v4l2_subdev_ops tuner_ops = {
1133         .core = &tuner_core_ops,
1134         .tuner = &tuner_tuner_ops,
1135 };
1136
1137 /* ---------------------------------------------------------------------- */
1138
1139 static LIST_HEAD(tuner_list);
1140
1141 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1142    Note that when this function is called from tuner_probe you can be
1143    certain no other devices will be added/deleted at the same time, I2C
1144    core protects against that. */
1145 static void tuner_lookup(struct i2c_adapter *adap,
1146                 struct tuner **radio, struct tuner **tv)
1147 {
1148         struct tuner *pos;
1149
1150         *radio = NULL;
1151         *tv = NULL;
1152
1153         list_for_each_entry(pos, &tuner_list, list) {
1154                 int mode_mask;
1155
1156                 if (pos->i2c->adapter != adap ||
1157                     pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1158                         continue;
1159
1160                 mode_mask = pos->mode_mask & ~T_STANDBY;
1161                 if (*radio == NULL && mode_mask == T_RADIO)
1162                         *radio = pos;
1163                 /* Note: currently TDA9887 is the only demod-only
1164                    device. If other devices appear then we need to
1165                    make this test more general. */
1166                 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1167                          (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1168                         *tv = pos;
1169         }
1170 }
1171
1172 /* During client attach, set_type is called by adapter's attach_inform callback.
1173    set_type must then be completed by tuner_probe.
1174  */
1175 static int tuner_probe(struct i2c_client *client,
1176                        const struct i2c_device_id *id)
1177 {
1178         struct tuner *t;
1179         struct tuner *radio;
1180         struct tuner *tv;
1181
1182         t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1183         if (NULL == t)
1184                 return -ENOMEM;
1185         v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
1186         t->i2c = client;
1187         t->name = "(tuner unset)";
1188         t->type = UNSET;
1189         t->audmode = V4L2_TUNER_MODE_STEREO;
1190         t->mode_mask = T_UNINITIALIZED;
1191
1192         if (show_i2c) {
1193                 unsigned char buffer[16];
1194                 int i, rc;
1195
1196                 memset(buffer, 0, sizeof(buffer));
1197                 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1198                 tuner_info("I2C RECV = ");
1199                 for (i = 0; i < rc; i++)
1200                         printk(KERN_CONT "%02x ", buffer[i]);
1201                 printk("\n");
1202         }
1203         /* HACK: This test was added to avoid tuner to probe tda9840 and
1204            tea6415c on the MXB card */
1205         if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1206                 kfree(t);
1207                 return -ENODEV;
1208         }
1209
1210         /* autodetection code based on the i2c addr */
1211         if (!no_autodetect) {
1212                 switch (client->addr) {
1213                 case 0x10:
1214                         if (tuner_symbol_probe(tea5761_autodetection,
1215                                                t->i2c->adapter,
1216                                                t->i2c->addr) >= 0) {
1217                                 t->type = TUNER_TEA5761;
1218                                 t->mode_mask = T_RADIO;
1219                                 t->mode = T_STANDBY;
1220                                 /* Sets freq to FM range */
1221                                 t->radio_freq = 87.5 * 16000;
1222                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1223                                 if (tv)
1224                                         tv->mode_mask &= ~T_RADIO;
1225
1226                                 goto register_client;
1227                         }
1228                         return -ENODEV;
1229                 case 0x42:
1230                 case 0x43:
1231                 case 0x4a:
1232                 case 0x4b:
1233                         /* If chip is not tda8290, don't register.
1234                            since it can be tda9887*/
1235                         if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
1236                                                t->i2c->addr) >= 0) {
1237                                 tuner_dbg("tda829x detected\n");
1238                         } else {
1239                                 /* Default is being tda9887 */
1240                                 t->type = TUNER_TDA9887;
1241                                 t->mode_mask = T_RADIO | T_ANALOG_TV |
1242                                                T_DIGITAL_TV;
1243                                 t->mode = T_STANDBY;
1244                                 goto register_client;
1245                         }
1246                         break;
1247                 case 0x60:
1248                         if (tuner_symbol_probe(tea5767_autodetection,
1249                                                t->i2c->adapter, t->i2c->addr)
1250                                         >= 0) {
1251                                 t->type = TUNER_TEA5767;
1252                                 t->mode_mask = T_RADIO;
1253                                 t->mode = T_STANDBY;
1254                                 /* Sets freq to FM range */
1255                                 t->radio_freq = 87.5 * 16000;
1256                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1257                                 if (tv)
1258                                         tv->mode_mask &= ~T_RADIO;
1259
1260                                 goto register_client;
1261                         }
1262                         break;
1263                 }
1264         }
1265
1266         /* Initializes only the first TV tuner on this adapter. Why only the
1267            first? Because there are some devices (notably the ones with TI
1268            tuners) that have more than one i2c address for the *same* device.
1269            Experience shows that, except for just one case, the first
1270            address is the right one. The exception is a Russian tuner
1271            (ACORP_Y878F). So, the desired behavior is just to enable the
1272            first found TV tuner. */
1273         tuner_lookup(t->i2c->adapter, &radio, &tv);
1274         if (tv == NULL) {
1275                 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1276                 if (radio == NULL)
1277                         t->mode_mask |= T_RADIO;
1278                 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1279                 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1280                 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1281         }
1282
1283         /* Should be just before return */
1284 register_client:
1285         tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1286                        client->adapter->name);
1287
1288         /* Sets a default mode */
1289         if (t->mode_mask & T_ANALOG_TV) {
1290                 t->mode = V4L2_TUNER_ANALOG_TV;
1291         } else  if (t->mode_mask & T_RADIO) {
1292                 t->mode = V4L2_TUNER_RADIO;
1293         } else {
1294                 t->mode = V4L2_TUNER_DIGITAL_TV;
1295         }
1296         set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
1297         list_add_tail(&t->list, &tuner_list);
1298         return 0;
1299 }
1300
1301 static int tuner_legacy_probe(struct i2c_adapter *adap)
1302 {
1303         if (0 != addr) {
1304                 normal_i2c[0] = addr;
1305                 normal_i2c[1] = I2C_CLIENT_END;
1306         }
1307
1308         if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1309                 return 0;
1310
1311         /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1312          * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1313          * and an RTC at 0x6f which can get corrupted if probed.
1314          */
1315         if ((adap->id == I2C_HW_B_CX2388x) ||
1316             (adap->id == I2C_HW_B_CX23885)) {
1317                 unsigned int i = 0;
1318
1319                 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1320                         i += 2;
1321                 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1322                         ignore[i+0] = adap->nr;
1323                         ignore[i+1] = 0x6b;
1324                         ignore[i+2] = adap->nr;
1325                         ignore[i+3] = 0x6f;
1326                         ignore[i+4] = I2C_CLIENT_END;
1327                 } else
1328                         printk(KERN_WARNING "tuner: "
1329                                "too many options specified "
1330                                "in i2c probe ignore list!\n");
1331         }
1332         return 1;
1333 }
1334
1335 static int tuner_remove(struct i2c_client *client)
1336 {
1337         struct tuner *t = to_tuner(i2c_get_clientdata(client));
1338
1339         v4l2_device_unregister_subdev(&t->sd);
1340         tuner_detach(&t->fe);
1341         t->fe.analog_demod_priv = NULL;
1342
1343         list_del(&t->list);
1344         kfree(t);
1345         return 0;
1346 }
1347
1348 /* ----------------------------------------------------------------------- */
1349
1350 /* This driver supports many devices and the idea is to let the driver
1351    detect which device is present. So rather than listing all supported
1352    devices here, we pretend to support a single, fake device type. */
1353 static const struct i2c_device_id tuner_id[] = {
1354         { "tuner", }, /* autodetect */
1355         { }
1356 };
1357 MODULE_DEVICE_TABLE(i2c, tuner_id);
1358
1359 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1360         .name = "tuner",
1361         .driverid = I2C_DRIVERID_TUNER,
1362         .command = tuner_command,
1363         .probe = tuner_probe,
1364         .remove = tuner_remove,
1365         .suspend = tuner_suspend,
1366         .resume = tuner_resume,
1367         .legacy_probe = tuner_legacy_probe,
1368         .id_table = tuner_id,
1369 };
1370
1371 /*
1372  * Overrides for Emacs so that we follow Linus's tabbing style.
1373  * ---------------------------------------------------------------------------
1374  * Local variables:
1375  * c-basic-offset: 8
1376  * End:
1377  */