SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/tuner-core.c

   1 /*
   2  *
   3  * i2c tv tuner chip device driver
   4  * core core, i.e. kernel interfaces, registering and so on
   5  */
   6
   7 #include <linux/module.h>
   8 #include <linux/kernel.h>
   9 #include <linux/string.h>
  10 #include <linux/timer.h>
  11 #include <linux/delay.h>
  12 #include <linux/errno.h>
  13 #include <linux/slab.h>
  14 #include <linux/poll.h>
  15 #include <linux/i2c.h>
  16 #include <linux/types.h>
  17 #include <linux/init.h>
  18 #include <linux/videodev.h>
  19 #include <media/tuner.h>
  20 #include <media/tuner-types.h>
  21 #include <media/v4l2-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                 xc5000_cfg.if_khz         = 5380;
 456                 if (!dvb_attach(xc5000_attach,
 457                                 &t->fe, t->i2c->adapter, &xc5000_cfg))
 458                         goto attach_failed;
 459
 460                 xc_tuner_ops = &t->fe.ops.tuner_ops;
 461                 if (xc_tuner_ops->init)
 462                         xc_tuner_ops->init(&t->fe);
 463                 break;
 464         }
 465         default:
 466                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 467                                 t->i2c->adapter, t->i2c->addr, t->type))
 468                         goto attach_failed;
 469
 470                 break;
 471         }
 472
 473         if ((NULL == analog_ops->set_params) &&
 474             (fe_tuner_ops->set_analog_params)) {
 475
 476                 t->name = fe_tuner_ops->info.name;
 477
 478                 t->fe.analog_demod_priv = t;
 479                 memcpy(analog_ops, &tuner_analog_ops,
 480                        sizeof(struct analog_demod_ops));
 481
 482         } else {
 483                 t->name = analog_ops->info.name;
 484         }
 485
 486         tuner_dbg("type set to %s\n", t->name);
 487
 488         if (t->mode_mask == T_UNINITIALIZED)
 489                 t->mode_mask = new_mode_mask;
 490
 491         /* xc2028/3028 and xc5000 requires a firmware to be set-up later
 492            trying to set a frequency here will just fail
 493            FIXME: better to move set_freq to the tuner code. This is needed
 494            on analog tuners for PLL to properly work
 495          */
 496         if (t->type != TUNER_XC2028 && t->type != TUNER_XC5000)
 497                 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ?
 498                             t->radio_freq : t->tv_freq);
 499
 500         tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
 501                   c->adapter->name, c->driver->driver.name, c->addr << 1, type,
 502                   t->mode_mask);
 503         tuner_i2c_address_check(t);
 504         return;
 505
 506 attach_failed:
 507         tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
 508         t->type = TUNER_ABSENT;
 509         t->mode_mask = T_UNINITIALIZED;
 510
 511         return;
 512 }
 513
 514 /*
 515  * This function apply tuner config to tuner specified
 516  * by tun_setup structure. I addr is unset, then admin status
 517  * and tun addr status is more precise then current status,
 518  * it's applied. Otherwise status and type are applied only to
 519  * tuner with exactly the same addr.
 520 */
 521
 522 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
 523 {
 524         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 525
 526         if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
 527                 (t->mode_mask & tun_setup->mode_mask))) ||
 528                 (tun_setup->addr == c->addr)) {
 529                         set_type(c, tun_setup->type, tun_setup->mode_mask,
 530                                  tun_setup->config, tun_setup->tuner_callback);
 531         } else
 532                 tuner_dbg("set addr discarded for type %i, mask %x. "
 533                           "Asked to change tuner at addr 0x%02x, with mask %x\n",
 534                           t->type, t->mode_mask,
 535                           tun_setup->addr, tun_setup->mode_mask);
 536 }
 537
 538 static inline int check_mode(struct tuner *t, char *cmd)
 539 {
 540         if ((1 << t->mode & t->mode_mask) == 0) {
 541                 return -EINVAL;
 542         }
 543
 544         switch (t->mode) {
 545         case V4L2_TUNER_RADIO:
 546                 tuner_dbg("Cmd %s accepted for radio\n", cmd);
 547                 break;
 548         case V4L2_TUNER_ANALOG_TV:
 549                 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
 550                 break;
 551         case V4L2_TUNER_DIGITAL_TV:
 552                 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
 553                 break;
 554         }
 555         return 0;
 556 }
 557
 558 /* get more precise norm info from insmod option */
 559 static int tuner_fixup_std(struct tuner *t)
 560 {
 561         if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
 562                 switch (pal[0]) {
 563                 case '6':
 564                         tuner_dbg ("insmod fixup: PAL => PAL-60\n");
 565                         t->std = V4L2_STD_PAL_60;
 566                         break;
 567                 case 'b':
 568                 case 'B':
 569                 case 'g':
 570                 case 'G':
 571                         tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
 572                         t->std = V4L2_STD_PAL_BG;
 573                         break;
 574                 case 'i':
 575                 case 'I':
 576                         tuner_dbg ("insmod fixup: PAL => PAL-I\n");
 577                         t->std = V4L2_STD_PAL_I;
 578                         break;
 579                 case 'd':
 580                 case 'D':
 581                 case 'k':
 582                 case 'K':
 583                         tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
 584                         t->std = V4L2_STD_PAL_DK;
 585                         break;
 586                 case 'M':
 587                 case 'm':
 588                         tuner_dbg ("insmod fixup: PAL => PAL-M\n");
 589                         t->std = V4L2_STD_PAL_M;
 590                         break;
 591                 case 'N':
 592                 case 'n':
 593                         if (pal[1] == 'c' || pal[1] == 'C') {
 594                                 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
 595                                 t->std = V4L2_STD_PAL_Nc;
 596                         } else {
 597                                 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
 598                                 t->std = V4L2_STD_PAL_N;
 599                         }
 600                         break;
 601                 case '-':
 602                         /* default parameter, do nothing */
 603                         break;
 604                 default:
 605                         tuner_warn ("pal= argument not recognised\n");
 606                         break;
 607                 }
 608         }
 609         if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
 610                 switch (secam[0]) {
 611                 case 'b':
 612                 case 'B':
 613                 case 'g':
 614                 case 'G':
 615                 case 'h':
 616                 case 'H':
 617                         tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
 618                         t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
 619                         break;
 620                 case 'd':
 621                 case 'D':
 622                 case 'k':
 623                 case 'K':
 624                         tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
 625                         t->std = V4L2_STD_SECAM_DK;
 626                         break;
 627                 case 'l':
 628                 case 'L':
 629                         if ((secam[1]=='C')||(secam[1]=='c')) {
 630                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
 631                                 t->std = V4L2_STD_SECAM_LC;
 632                         } else {
 633                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
 634                                 t->std = V4L2_STD_SECAM_L;
 635                         }
 636                         break;
 637                 case '-':
 638                         /* default parameter, do nothing */
 639                         break;
 640                 default:
 641                         tuner_warn ("secam= argument not recognised\n");
 642                         break;
 643                 }
 644         }
 645
 646         if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
 647                 switch (ntsc[0]) {
 648                 case 'm':
 649                 case 'M':
 650                         tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
 651                         t->std = V4L2_STD_NTSC_M;
 652                         break;
 653                 case 'j':
 654                 case 'J':
 655                         tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
 656                         t->std = V4L2_STD_NTSC_M_JP;
 657                         break;
 658                 case 'k':
 659                 case 'K':
 660                         tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
 661                         t->std = V4L2_STD_NTSC_M_KR;
 662                         break;
 663                 case '-':
 664                         /* default parameter, do nothing */
 665                         break;
 666                 default:
 667                         tuner_info("ntsc= argument not recognised\n");
 668                         break;
 669                 }
 670         }
 671         return 0;
 672 }
 673
 674 static void tuner_status(struct dvb_frontend *fe)
 675 {
 676         struct tuner *t = fe->analog_demod_priv;
 677         unsigned long freq, freq_fraction;
 678         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 679         struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
 680         const char *p;
 681
 682         switch (t->mode) {
 683                 case V4L2_TUNER_RADIO:      p = "radio"; break;
 684                 case V4L2_TUNER_ANALOG_TV:  p = "analog TV"; break;
 685                 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
 686                 default: p = "undefined"; break;
 687         }
 688         if (t->mode == V4L2_TUNER_RADIO) {
 689                 freq = t->radio_freq / 16000;
 690                 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
 691         } else {
 692                 freq = t->tv_freq / 16;
 693                 freq_fraction = (t->tv_freq % 16) * 100 / 16;
 694         }
 695         tuner_info("Tuner mode:      %s\n", p);
 696         tuner_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
 697         tuner_info("Standard:        0x%08lx\n", (unsigned long)t->std);
 698         if (t->mode != V4L2_TUNER_RADIO)
 699                return;
 700         if (fe_tuner_ops->get_status) {
 701                 u32 tuner_status;
 702
 703                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
 704                 if (tuner_status & TUNER_STATUS_LOCKED)
 705                         tuner_info("Tuner is locked.\n");
 706                 if (tuner_status & TUNER_STATUS_STEREO)
 707                         tuner_info("Stereo:          yes\n");
 708         }
 709         if (analog_ops->has_signal)
 710                 tuner_info("Signal strength: %d\n",
 711                            analog_ops->has_signal(fe));
 712         if (analog_ops->is_stereo)
 713                 tuner_info("Stereo:          %s\n",
 714                            analog_ops->is_stereo(fe) ? "yes" : "no");
 715 }
 716
 717 /* ---------------------------------------------------------------------- */
 718
 719 /*
 720  * Switch tuner to other mode. If tuner support both tv and radio,
 721  * set another frequency to some value (This is needed for some pal
 722  * tuners to avoid locking). Otherwise, just put second tuner in
 723  * standby mode.
 724  */
 725
 726 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
 727 {
 728         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 729
 730         if (mode == t->mode)
 731                 return 0;
 732
 733         t->mode = mode;
 734
 735         if (check_mode(t, cmd) == -EINVAL) {
 736                 tuner_dbg("Tuner doesn't support this mode. "
 737                           "Putting tuner to sleep\n");
 738                 t->mode = T_STANDBY;
 739                 if (analog_ops->standby)
 740                         analog_ops->standby(&t->fe);
 741                 return -EINVAL;
 742         }
 743         return 0;
 744 }
 745
 746 #define switch_v4l2()   if (!t->using_v4l2) \
 747                             tuner_dbg("switching to v4l2\n"); \
 748                         t->using_v4l2 = 1;
 749
 750 static inline int check_v4l2(struct tuner *t)
 751 {
 752         /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
 753            TV, v4l1 for radio), until that is fixed this code is disabled.
 754            Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
 755            first. */
 756         return 0;
 757 }
 758
 759 static int tuner_s_type_addr(struct v4l2_subdev *sd, struct tuner_setup *type)
 760 {
 761         struct tuner *t = to_tuner(sd);
 762         struct i2c_client *client = v4l2_get_subdevdata(sd);
 763
 764         tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
 765                         type->type,
 766                         type->addr,
 767                         type->mode_mask,
 768                         type->config);
 769
 770         set_addr(client, type);
 771         return 0;
 772 }
 773
 774 static int tuner_s_radio(struct v4l2_subdev *sd)
 775 {
 776         struct tuner *t = to_tuner(sd);
 777         struct i2c_client *client = v4l2_get_subdevdata(sd);
 778
 779         if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
 780                         == -EINVAL)
 781                 return 0;
 782         if (t->radio_freq)
 783                 set_freq(client, t->radio_freq);
 784         return 0;
 785 }
 786
 787 static int tuner_s_standby(struct v4l2_subdev *sd, u32 standby)
 788 {
 789         struct tuner *t = to_tuner(sd);
 790         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 791
 792         tuner_dbg("Putting tuner to sleep\n");
 793
 794         if (check_mode(t, "TUNER_SET_STANDBY") == -EINVAL)
 795                 return 0;
 796         t->mode = T_STANDBY;
 797         if (analog_ops->standby)
 798                 analog_ops->standby(&t->fe);
 799         return 0;
 800 }
 801
 802 #ifdef CONFIG_VIDEO_ALLOW_V4L1
 803 static int tuner_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
 804 {
 805         struct tuner *t = to_tuner(sd);
 806         struct i2c_client *client = v4l2_get_subdevdata(sd);
 807         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 808         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 809
 810         switch (cmd) {
 811         case VIDIOCSAUDIO:
 812                 if (check_mode(t, "VIDIOCSAUDIO") == -EINVAL)
 813                         return 0;
 814                 if (check_v4l2(t) == -EINVAL)
 815                         return 0;
 816
 817                 /* Should be implemented, since bttv calls it */
 818                 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
 819                 break;
 820         case VIDIOCSCHAN:
 821                 {
 822                         static const v4l2_std_id map[] = {
 823                                 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
 824                                 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
 825                                 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
 826                                 [4 /* bttv */ ] = V4L2_STD_PAL_M,
 827                                 [5 /* bttv */ ] = V4L2_STD_PAL_N,
 828                                 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
 829                         };
 830                         struct video_channel *vc = arg;
 831
 832                         if (check_v4l2(t) == -EINVAL)
 833                                 return 0;
 834
 835                         if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==-EINVAL)
 836                                 return 0;
 837
 838                         if (vc->norm < ARRAY_SIZE(map))
 839                                 t->std = map[vc->norm];
 840                         tuner_fixup_std(t);
 841                         if (t->tv_freq)
 842                                 set_tv_freq(client, t->tv_freq);
 843                         return 0;
 844                 }
 845         case VIDIOCSFREQ:
 846                 {
 847                         unsigned long *v = arg;
 848
 849                         if (check_mode(t, "VIDIOCSFREQ") == -EINVAL)
 850                                 return 0;
 851                         if (check_v4l2(t) == -EINVAL)
 852                                 return 0;
 853
 854                         set_freq(client, *v);
 855                         return 0;
 856                 }
 857         case VIDIOCGTUNER:
 858                 {
 859                         struct video_tuner *vt = arg;
 860
 861                         if (check_mode(t, "VIDIOCGTUNER") == -EINVAL)
 862                                 return 0;
 863                         if (check_v4l2(t) == -EINVAL)
 864                                 return 0;
 865
 866                         if (V4L2_TUNER_RADIO == t->mode) {
 867                                 if (fe_tuner_ops->get_status) {
 868                                         u32 tuner_status;
 869
 870                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 871                                         if (tuner_status & TUNER_STATUS_STEREO)
 872                                                 vt->flags |= VIDEO_TUNER_STEREO_ON;
 873                                         else
 874                                                 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
 875                                 } else {
 876                                         if (analog_ops->is_stereo) {
 877                                                 if (analog_ops->is_stereo(&t->fe))
 878                                                         vt->flags |=
 879                                                                 VIDEO_TUNER_STEREO_ON;
 880                                                 else
 881                                                         vt->flags &=
 882                                                                 ~VIDEO_TUNER_STEREO_ON;
 883                                         }
 884                                 }
 885                                 if (analog_ops->has_signal)
 886                                         vt->signal =
 887                                                 analog_ops->has_signal(&t->fe);
 888
 889                                 vt->flags |= VIDEO_TUNER_LOW;   /* Allow freqs at 62.5 Hz */
 890
 891                                 vt->rangelow = radio_range[0] * 16000;
 892                                 vt->rangehigh = radio_range[1] * 16000;
 893
 894                         } else {
 895                                 vt->rangelow = tv_range[0] * 16;
 896                                 vt->rangehigh = tv_range[1] * 16;
 897                         }
 898
 899                         return 0;
 900                 }
 901         case VIDIOCGAUDIO:
 902                 {
 903                         struct video_audio *va = arg;
 904
 905                         if (check_mode(t, "VIDIOCGAUDIO") == -EINVAL)
 906                                 return 0;
 907                         if (check_v4l2(t) == -EINVAL)
 908                                 return 0;
 909
 910                         if (V4L2_TUNER_RADIO == t->mode) {
 911                                 if (fe_tuner_ops->get_status) {
 912                                         u32 tuner_status;
 913
 914                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 915                                         va->mode = (tuner_status & TUNER_STATUS_STEREO)
 916                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 917                                 } else if (analog_ops->is_stereo)
 918                                         va->mode = analog_ops->is_stereo(&t->fe)
 919                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 920                         }
 921                         return 0;
 922                 }
 923         }
 924         return -ENOIOCTLCMD;
 925 }
 926 #endif
 927
 928 static int tuner_s_config(struct v4l2_subdev *sd, const struct v4l2_priv_tun_config *cfg)
 929 {
 930         struct tuner *t = to_tuner(sd);
 931         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 932
 933         if (t->type != cfg->tuner)
 934                 return 0;
 935
 936         if (analog_ops->set_config) {
 937                 analog_ops->set_config(&t->fe, cfg->priv);
 938                 return 0;
 939         }
 940
 941         tuner_dbg("Tuner frontend module has no way to set config\n");
 942         return 0;
 943 }
 944
 945 /* --- v4l ioctls --- */
 946 /* take care: bttv does userspace copying, we'll get a
 947    kernel pointer here... */
 948 static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
 949 {
 950         struct tuner *t = to_tuner(sd);
 951         struct i2c_client *client = v4l2_get_subdevdata(sd);
 952
 953         if (set_mode(client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
 954                         == -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, "VIDIOC_S_FREQUENCY")
 972                         == -EINVAL)
 973                 return 0;
 974         switch_v4l2();
 975         set_freq(client, f->frequency);
 976
 977         return 0;
 978 }
 979
 980 static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
 981 {
 982         struct tuner *t = to_tuner(sd);
 983         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 984
 985         if (check_mode(t, "VIDIOC_G_FREQUENCY") == -EINVAL)
 986                 return 0;
 987         switch_v4l2();
 988         f->type = t->mode;
 989         if (fe_tuner_ops->get_frequency) {
 990                 u32 abs_freq;
 991
 992                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
 993                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 994                         (abs_freq * 2 + 125/2) / 125 :
 995                         (abs_freq + 62500/2) / 62500;
 996                 return 0;
 997         }
 998         f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 999                 t->radio_freq : t->tv_freq;
1000         return 0;
1001 }
1002
1003 static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1004 {
1005         struct tuner *t = to_tuner(sd);
1006         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1007         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1008
1009         if (check_mode(t, "VIDIOC_G_TUNER") == -EINVAL)
1010                 return 0;
1011         switch_v4l2();
1012
1013         vt->type = t->mode;
1014         if (analog_ops->get_afc)
1015                 vt->afc = analog_ops->get_afc(&t->fe);
1016         if (t->mode == V4L2_TUNER_ANALOG_TV)
1017                 vt->capability |= V4L2_TUNER_CAP_NORM;
1018         if (t->mode != V4L2_TUNER_RADIO) {
1019                 vt->rangelow = tv_range[0] * 16;
1020                 vt->rangehigh = tv_range[1] * 16;
1021                 return 0;
1022         }
1023
1024         /* radio mode */
1025         vt->rxsubchans =
1026                 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1027         if (fe_tuner_ops->get_status) {
1028                 u32 tuner_status;
1029
1030                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1031                 vt->rxsubchans =
1032                         (tuner_status & TUNER_STATUS_STEREO) ?
1033                         V4L2_TUNER_SUB_STEREO :
1034                         V4L2_TUNER_SUB_MONO;
1035         } else {
1036                 if (analog_ops->is_stereo) {
1037                         vt->rxsubchans =
1038                                 analog_ops->is_stereo(&t->fe) ?
1039                                 V4L2_TUNER_SUB_STEREO :
1040                                 V4L2_TUNER_SUB_MONO;
1041                 }
1042         }
1043         if (analog_ops->has_signal)
1044                 vt->signal = analog_ops->has_signal(&t->fe);
1045         vt->capability |=
1046                 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1047         vt->audmode = t->audmode;
1048         vt->rangelow = radio_range[0] * 16000;
1049         vt->rangehigh = radio_range[1] * 16000;
1050         return 0;
1051 }
1052
1053 static int tuner_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1054 {
1055         struct tuner *t = to_tuner(sd);
1056         struct i2c_client *client = v4l2_get_subdevdata(sd);
1057
1058         if (check_mode(t, "VIDIOC_S_TUNER") == -EINVAL)
1059                 return 0;
1060
1061         switch_v4l2();
1062
1063         /* do nothing unless we're a radio tuner */
1064         if (t->mode != V4L2_TUNER_RADIO)
1065                 return 0;
1066         t->audmode = vt->audmode;
1067         set_radio_freq(client, t->radio_freq);
1068         return 0;
1069 }
1070
1071 static int tuner_log_status(struct v4l2_subdev *sd)
1072 {
1073         struct tuner *t = to_tuner(sd);
1074         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1075
1076         if (analog_ops->tuner_status)
1077                 analog_ops->tuner_status(&t->fe);
1078         return 0;
1079 }
1080
1081 static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1082 {
1083         return v4l2_subdev_command(i2c_get_clientdata(client), cmd, arg);
1084 }
1085
1086 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1087 {
1088         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1089
1090         tuner_dbg("suspend\n");
1091         /* FIXME: power down ??? */
1092         return 0;
1093 }
1094
1095 static int tuner_resume(struct i2c_client *c)
1096 {
1097         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1098
1099         tuner_dbg("resume\n");
1100         if (V4L2_TUNER_RADIO == t->mode) {
1101                 if (t->radio_freq)
1102                         set_freq(c, t->radio_freq);
1103         } else {
1104                 if (t->tv_freq)
1105                         set_freq(c, t->tv_freq);
1106         }
1107         return 0;
1108 }
1109
1110 /* ----------------------------------------------------------------------- */
1111
1112 static const struct v4l2_subdev_core_ops tuner_core_ops = {
1113         .log_status = tuner_log_status,
1114         .s_standby = tuner_s_standby,
1115 #ifdef CONFIG_VIDEO_ALLOW_V4L1
1116         .ioctl = tuner_ioctl,
1117 #endif
1118 };
1119
1120 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
1121         .s_std = tuner_s_std,
1122         .s_radio = tuner_s_radio,
1123         .g_tuner = tuner_g_tuner,
1124         .s_tuner = tuner_s_tuner,
1125         .s_frequency = tuner_s_frequency,
1126         .g_frequency = tuner_g_frequency,
1127         .s_type_addr = tuner_s_type_addr,
1128         .s_config = tuner_s_config,
1129 };
1130
1131 static const struct v4l2_subdev_ops tuner_ops = {
1132         .core = &tuner_core_ops,
1133         .tuner = &tuner_tuner_ops,
1134 };
1135
1136 /* ---------------------------------------------------------------------- */
1137
1138 static LIST_HEAD(tuner_list);
1139
1140 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1141    Note that when this function is called from tuner_probe you can be
1142    certain no other devices will be added/deleted at the same time, I2C
1143    core protects against that. */
1144 static void tuner_lookup(struct i2c_adapter *adap,
1145                 struct tuner **radio, struct tuner **tv)
1146 {
1147         struct tuner *pos;
1148
1149         *radio = NULL;
1150         *tv = NULL;
1151
1152         list_for_each_entry(pos, &tuner_list, list) {
1153                 int mode_mask;
1154
1155                 if (pos->i2c->adapter != adap ||
1156                     pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1157                         continue;
1158
1159                 mode_mask = pos->mode_mask & ~T_STANDBY;
1160                 if (*radio == NULL && mode_mask == T_RADIO)
1161                         *radio = pos;
1162                 /* Note: currently TDA9887 is the only demod-only
1163                    device. If other devices appear then we need to
1164                    make this test more general. */
1165                 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1166                          (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1167                         *tv = pos;
1168         }
1169 }
1170
1171 /* During client attach, set_type is called by adapter's attach_inform callback.
1172    set_type must then be completed by tuner_probe.
1173  */
1174 static int tuner_probe(struct i2c_client *client,
1175                        const struct i2c_device_id *id)
1176 {
1177         struct tuner *t;
1178         struct tuner *radio;
1179         struct tuner *tv;
1180
1181         t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1182         if (NULL == t)
1183                 return -ENOMEM;
1184         v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
1185         t->i2c = client;
1186         t->name = "(tuner unset)";
1187         t->type = UNSET;
1188         t->audmode = V4L2_TUNER_MODE_STEREO;
1189         t->mode_mask = T_UNINITIALIZED;
1190
1191         if (show_i2c) {
1192                 unsigned char buffer[16];
1193                 int i, rc;
1194
1195                 memset(buffer, 0, sizeof(buffer));
1196                 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1197                 tuner_info("I2C RECV = ");
1198                 for (i = 0; i < rc; i++)
1199                         printk(KERN_CONT "%02x ", buffer[i]);
1200                 printk("\n");
1201         }
1202         /* HACK: This test was added to avoid tuner to probe tda9840 and
1203            tea6415c on the MXB card */
1204         if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1205                 kfree(t);
1206                 return -ENODEV;
1207         }
1208
1209         /* autodetection code based on the i2c addr */
1210         if (!no_autodetect) {
1211                 switch (client->addr) {
1212                 case 0x10:
1213                         if (tuner_symbol_probe(tea5761_autodetection,
1214                                                t->i2c->adapter,
1215                                                t->i2c->addr) >= 0) {
1216                                 t->type = TUNER_TEA5761;
1217                                 t->mode_mask = T_RADIO;
1218                                 t->mode = T_STANDBY;
1219                                 /* Sets freq to FM range */
1220                                 t->radio_freq = 87.5 * 16000;
1221                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1222                                 if (tv)
1223                                         tv->mode_mask &= ~T_RADIO;
1224
1225                                 goto register_client;
1226                         }
1227                         return -ENODEV;
1228                 case 0x42:
1229                 case 0x43:
1230                 case 0x4a:
1231                 case 0x4b:
1232                         /* If chip is not tda8290, don't register.
1233                            since it can be tda9887*/
1234                         if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
1235                                                t->i2c->addr) >= 0) {
1236                                 tuner_dbg("tda829x detected\n");
1237                         } else {
1238                                 /* Default is being tda9887 */
1239                                 t->type = TUNER_TDA9887;
1240                                 t->mode_mask = T_RADIO | T_ANALOG_TV |
1241                                                T_DIGITAL_TV;
1242                                 t->mode = T_STANDBY;
1243                                 goto register_client;
1244                         }
1245                         break;
1246                 case 0x60:
1247                         if (tuner_symbol_probe(tea5767_autodetection,
1248                                                t->i2c->adapter, t->i2c->addr)
1249                                         >= 0) {
1250                                 t->type = TUNER_TEA5767;
1251                                 t->mode_mask = T_RADIO;
1252                                 t->mode = T_STANDBY;
1253                                 /* Sets freq to FM range */
1254                                 t->radio_freq = 87.5 * 16000;
1255                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1256                                 if (tv)
1257                                         tv->mode_mask &= ~T_RADIO;
1258
1259                                 goto register_client;
1260                         }
1261                         break;
1262                 }
1263         }
1264
1265         /* Initializes only the first TV tuner on this adapter. Why only the
1266            first? Because there are some devices (notably the ones with TI
1267            tuners) that have more than one i2c address for the *same* device.
1268            Experience shows that, except for just one case, the first
1269            address is the right one. The exception is a Russian tuner
1270            (ACORP_Y878F). So, the desired behavior is just to enable the
1271            first found TV tuner. */
1272         tuner_lookup(t->i2c->adapter, &radio, &tv);
1273         if (tv == NULL) {
1274                 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1275                 if (radio == NULL)
1276                         t->mode_mask |= T_RADIO;
1277                 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1278                 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1279                 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1280         }
1281
1282         /* Should be just before return */
1283 register_client:
1284         tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1285                        client->adapter->name);
1286
1287         /* Sets a default mode */
1288         if (t->mode_mask & T_ANALOG_TV) {
1289                 t->mode = V4L2_TUNER_ANALOG_TV;
1290         } else  if (t->mode_mask & T_RADIO) {
1291                 t->mode = V4L2_TUNER_RADIO;
1292         } else {
1293                 t->mode = V4L2_TUNER_DIGITAL_TV;
1294         }
1295         set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
1296         list_add_tail(&t->list, &tuner_list);
1297         return 0;
1298 }
1299
1300 static int tuner_legacy_probe(struct i2c_adapter *adap)
1301 {
1302         if (0 != addr) {
1303                 normal_i2c[0] = addr;
1304                 normal_i2c[1] = I2C_CLIENT_END;
1305         }
1306
1307         if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1308                 return 0;
1309
1310         /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1311          * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1312          * and an RTC at 0x6f which can get corrupted if probed.
1313          */
1314         if ((adap->id == I2C_HW_B_CX2388x) ||
1315             (adap->id == I2C_HW_B_CX23885)) {
1316                 unsigned int i = 0;
1317
1318                 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1319                         i += 2;
1320                 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1321                         ignore[i+0] = adap->nr;
1322                         ignore[i+1] = 0x6b;
1323                         ignore[i+2] = adap->nr;
1324                         ignore[i+3] = 0x6f;
1325                         ignore[i+4] = I2C_CLIENT_END;
1326                 } else
1327                         printk(KERN_WARNING "tuner: "
1328                                "too many options specified "
1329                                "in i2c probe ignore list!\n");
1330         }
1331         return 1;
1332 }
1333
1334 static int tuner_remove(struct i2c_client *client)
1335 {
1336         struct tuner *t = to_tuner(i2c_get_clientdata(client));
1337
1338         v4l2_device_unregister_subdev(&t->sd);
1339         tuner_detach(&t->fe);
1340         t->fe.analog_demod_priv = NULL;
1341
1342         list_del(&t->list);
1343         kfree(t);
1344         return 0;
1345 }
1346
1347 /* ----------------------------------------------------------------------- */
1348
1349 /* This driver supports many devices and the idea is to let the driver
1350    detect which device is present. So rather than listing all supported
1351    devices here, we pretend to support a single, fake device type. */
1352 static const struct i2c_device_id tuner_id[] = {
1353         { "tuner", }, /* autodetect */
1354         { }
1355 };
1356 MODULE_DEVICE_TABLE(i2c, tuner_id);
1357
1358 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1359         .name = "tuner",
1360         .driverid = I2C_DRIVERID_TUNER,
1361         .command = tuner_command,
1362         .probe = tuner_probe,
1363         .remove = tuner_remove,
1364         .suspend = tuner_suspend,
1365         .resume = tuner_resume,
1366         .legacy_probe = tuner_legacy_probe,
1367         .id_table = tuner_id,
1368 };
1369
1370 /*
1371  * Overrides for Emacs so that we follow Linus's tabbing style.
1372  * ---------------------------------------------------------------------------
1373  * Local variables:
1374  * c-basic-offset: 8
1375  * End:
1376  */