drivers/media/video/tuner-core.c

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