git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/tuner-core.c

   1 /*
   2  *
   3  * i2c tv tuner chip device driver
   4  * core core, i.e. kernel interfaces, registering and so on
   5  */
   6
   7 #include <linux/module.h>
   8 #include <linux/kernel.h>
   9 #include <linux/string.h>
  10 #include <linux/timer.h>
  11 #include <linux/delay.h>
  12 #include <linux/errno.h>
  13 #include <linux/slab.h>
  14 #include <linux/poll.h>
  15 #include <linux/i2c.h>
  16 #include <linux/types.h>
  17 #include <linux/init.h>
  18 #include <linux/videodev.h>
  19 #include <media/tuner.h>
  20 #include <media/tuner-types.h>
  21 #include <media/v4l2-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                 t->mode = T_STANDBY;
 737                 if (analog_ops->standby)
 738                         analog_ops->standby(&t->fe);
 739                 return -EINVAL;
 740         }
 741         return 0;
 742 }
 743
 744 #define switch_v4l2()   if (!t->using_v4l2) \
 745                             tuner_dbg("switching to v4l2\n"); \
 746                         t->using_v4l2 = 1;
 747
 748 static inline int check_v4l2(struct tuner *t)
 749 {
 750         /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
 751            TV, v4l1 for radio), until that is fixed this code is disabled.
 752            Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
 753            first. */
 754         return 0;
 755 }
 756
 757 static int tuner_s_type_addr(struct v4l2_subdev *sd, struct tuner_setup *type)
 758 {
 759         struct tuner *t = to_tuner(sd);
 760         struct i2c_client *client = v4l2_get_subdevdata(sd);
 761
 762         tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
 763                         type->type,
 764                         type->addr,
 765                         type->mode_mask,
 766                         type->config);
 767
 768         set_addr(client, type);
 769         return 0;
 770 }
 771
 772 static int tuner_s_radio(struct v4l2_subdev *sd)
 773 {
 774         struct tuner *t = to_tuner(sd);
 775         struct i2c_client *client = v4l2_get_subdevdata(sd);
 776
 777         if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
 778                         == -EINVAL)
 779                 return 0;
 780         if (t->radio_freq)
 781                 set_freq(client, t->radio_freq);
 782         return 0;
 783 }
 784
 785 static int tuner_s_standby(struct v4l2_subdev *sd, u32 standby)
 786 {
 787         struct tuner *t = to_tuner(sd);
 788         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 789
 790         if (check_mode(t, "TUNER_SET_STANDBY") == -EINVAL)
 791                 return 0;
 792         t->mode = T_STANDBY;
 793         if (analog_ops->standby)
 794                 analog_ops->standby(&t->fe);
 795         return 0;
 796 }
 797
 798 #ifdef CONFIG_VIDEO_ALLOW_V4L1
 799 static int tuner_ioctl(struct v4l2_subdev *sd, int cmd, void *arg)
 800 {
 801         struct tuner *t = to_tuner(sd);
 802         struct i2c_client *client = v4l2_get_subdevdata(sd);
 803         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 804         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 805
 806         switch (cmd) {
 807         case VIDIOCSAUDIO:
 808                 if (check_mode(t, "VIDIOCSAUDIO") == -EINVAL)
 809                         return 0;
 810                 if (check_v4l2(t) == -EINVAL)
 811                         return 0;
 812
 813                 /* Should be implemented, since bttv calls it */
 814                 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
 815                 break;
 816         case VIDIOCSCHAN:
 817                 {
 818                         static const v4l2_std_id map[] = {
 819                                 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
 820                                 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
 821                                 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
 822                                 [4 /* bttv */ ] = V4L2_STD_PAL_M,
 823                                 [5 /* bttv */ ] = V4L2_STD_PAL_N,
 824                                 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
 825                         };
 826                         struct video_channel *vc = arg;
 827
 828                         if (check_v4l2(t) == -EINVAL)
 829                                 return 0;
 830
 831                         if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==-EINVAL)
 832                                 return 0;
 833
 834                         if (vc->norm < ARRAY_SIZE(map))
 835                                 t->std = map[vc->norm];
 836                         tuner_fixup_std(t);
 837                         if (t->tv_freq)
 838                                 set_tv_freq(client, t->tv_freq);
 839                         return 0;
 840                 }
 841         case VIDIOCSFREQ:
 842                 {
 843                         unsigned long *v = arg;
 844
 845                         if (check_mode(t, "VIDIOCSFREQ") == -EINVAL)
 846                                 return 0;
 847                         if (check_v4l2(t) == -EINVAL)
 848                                 return 0;
 849
 850                         set_freq(client, *v);
 851                         return 0;
 852                 }
 853         case VIDIOCGTUNER:
 854                 {
 855                         struct video_tuner *vt = arg;
 856
 857                         if (check_mode(t, "VIDIOCGTUNER") == -EINVAL)
 858                                 return 0;
 859                         if (check_v4l2(t) == -EINVAL)
 860                                 return 0;
 861
 862                         if (V4L2_TUNER_RADIO == t->mode) {
 863                                 if (fe_tuner_ops->get_status) {
 864                                         u32 tuner_status;
 865
 866                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 867                                         if (tuner_status & TUNER_STATUS_STEREO)
 868                                                 vt->flags |= VIDEO_TUNER_STEREO_ON;
 869                                         else
 870                                                 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
 871                                 } else {
 872                                         if (analog_ops->is_stereo) {
 873                                                 if (analog_ops->is_stereo(&t->fe))
 874                                                         vt->flags |=
 875                                                                 VIDEO_TUNER_STEREO_ON;
 876                                                 else
 877                                                         vt->flags &=
 878                                                                 ~VIDEO_TUNER_STEREO_ON;
 879                                         }
 880                                 }
 881                                 if (analog_ops->has_signal)
 882                                         vt->signal =
 883                                                 analog_ops->has_signal(&t->fe);
 884
 885                                 vt->flags |= VIDEO_TUNER_LOW;   /* Allow freqs at 62.5 Hz */
 886
 887                                 vt->rangelow = radio_range[0] * 16000;
 888                                 vt->rangehigh = radio_range[1] * 16000;
 889
 890                         } else {
 891                                 vt->rangelow = tv_range[0] * 16;
 892                                 vt->rangehigh = tv_range[1] * 16;
 893                         }
 894
 895                         return 0;
 896                 }
 897         case VIDIOCGAUDIO:
 898                 {
 899                         struct video_audio *va = arg;
 900
 901                         if (check_mode(t, "VIDIOCGAUDIO") == -EINVAL)
 902                                 return 0;
 903                         if (check_v4l2(t) == -EINVAL)
 904                                 return 0;
 905
 906                         if (V4L2_TUNER_RADIO == t->mode) {
 907                                 if (fe_tuner_ops->get_status) {
 908                                         u32 tuner_status;
 909
 910                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 911                                         va->mode = (tuner_status & TUNER_STATUS_STEREO)
 912                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 913                                 } else if (analog_ops->is_stereo)
 914                                         va->mode = analog_ops->is_stereo(&t->fe)
 915                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 916                         }
 917                         return 0;
 918                 }
 919         }
 920         return -ENOIOCTLCMD;
 921 }
 922 #endif
 923
 924 static int tuner_s_config(struct v4l2_subdev *sd, const struct v4l2_priv_tun_config *cfg)
 925 {
 926         struct tuner *t = to_tuner(sd);
 927         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 928
 929         if (t->type != cfg->tuner)
 930                 return 0;
 931
 932         if (analog_ops->set_config) {
 933                 analog_ops->set_config(&t->fe, cfg->priv);
 934                 return 0;
 935         }
 936
 937         tuner_dbg("Tuner frontend module has no way to set config\n");
 938         return 0;
 939 }
 940
 941 /* --- v4l ioctls --- */
 942 /* take care: bttv does userspace copying, we'll get a
 943    kernel pointer here... */
 944 static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
 945 {
 946         struct tuner *t = to_tuner(sd);
 947         struct i2c_client *client = v4l2_get_subdevdata(sd);
 948
 949         if (set_mode(client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
 950                         == -EINVAL)
 951                 return 0;
 952
 953         switch_v4l2();
 954
 955         t->std = std;
 956         tuner_fixup_std(t);
 957         if (t->tv_freq)
 958                 set_freq(client, t->tv_freq);
 959         return 0;
 960 }
 961
 962 static int tuner_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
 963 {
 964         struct tuner *t = to_tuner(sd);
 965         struct i2c_client *client = v4l2_get_subdevdata(sd);
 966
 967         if (set_mode(client, t, f->type, "VIDIOC_S_FREQUENCY")
 968                         == -EINVAL)
 969                 return 0;
 970         switch_v4l2();
 971         set_freq(client, f->frequency);
 972
 973         return 0;
 974 }
 975
 976 static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
 977 {
 978         struct tuner *t = to_tuner(sd);
 979         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 980
 981         if (check_mode(t, "VIDIOC_G_FREQUENCY") == -EINVAL)
 982                 return 0;
 983         switch_v4l2();
 984         f->type = t->mode;
 985         if (fe_tuner_ops->get_frequency) {
 986                 u32 abs_freq;
 987
 988                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
 989                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 990                         (abs_freq * 2 + 125/2) / 125 :
 991                         (abs_freq + 62500/2) / 62500;
 992                 return 0;
 993         }
 994         f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 995                 t->radio_freq : t->tv_freq;
 996         return 0;
 997 }
 998
 999 static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1000 {
1001         struct tuner *t = to_tuner(sd);
1002         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1003         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1004
1005         if (check_mode(t, "VIDIOC_G_TUNER") == -EINVAL)
1006                 return 0;
1007         switch_v4l2();
1008
1009         vt->type = t->mode;
1010         if (analog_ops->get_afc)
1011                 vt->afc = analog_ops->get_afc(&t->fe);
1012         if (t->mode == V4L2_TUNER_ANALOG_TV)
1013                 vt->capability |= V4L2_TUNER_CAP_NORM;
1014         if (t->mode != V4L2_TUNER_RADIO) {
1015                 vt->rangelow = tv_range[0] * 16;
1016                 vt->rangehigh = tv_range[1] * 16;
1017                 return 0;
1018         }
1019
1020         /* radio mode */
1021         vt->rxsubchans =
1022                 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1023         if (fe_tuner_ops->get_status) {
1024                 u32 tuner_status;
1025
1026                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1027                 vt->rxsubchans =
1028                         (tuner_status & TUNER_STATUS_STEREO) ?
1029                         V4L2_TUNER_SUB_STEREO :
1030                         V4L2_TUNER_SUB_MONO;
1031         } else {
1032                 if (analog_ops->is_stereo) {
1033                         vt->rxsubchans =
1034                                 analog_ops->is_stereo(&t->fe) ?
1035                                 V4L2_TUNER_SUB_STEREO :
1036                                 V4L2_TUNER_SUB_MONO;
1037                 }
1038         }
1039         if (analog_ops->has_signal)
1040                 vt->signal = analog_ops->has_signal(&t->fe);
1041         vt->capability |=
1042                 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1043         vt->audmode = t->audmode;
1044         vt->rangelow = radio_range[0] * 16000;
1045         vt->rangehigh = radio_range[1] * 16000;
1046         return 0;
1047 }
1048
1049 static int tuner_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1050 {
1051         struct tuner *t = to_tuner(sd);
1052         struct i2c_client *client = v4l2_get_subdevdata(sd);
1053
1054         if (check_mode(t, "VIDIOC_S_TUNER") == -EINVAL)
1055                 return 0;
1056
1057         switch_v4l2();
1058
1059         /* do nothing unless we're a radio tuner */
1060         if (t->mode != V4L2_TUNER_RADIO)
1061                 return 0;
1062         t->audmode = vt->audmode;
1063         set_radio_freq(client, t->radio_freq);
1064         return 0;
1065 }
1066
1067 static int tuner_log_status(struct v4l2_subdev *sd)
1068 {
1069         struct tuner *t = to_tuner(sd);
1070         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1071
1072         if (analog_ops->tuner_status)
1073                 analog_ops->tuner_status(&t->fe);
1074         return 0;
1075 }
1076
1077 static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1078 {
1079         return v4l2_subdev_command(i2c_get_clientdata(client), cmd, arg);
1080 }
1081
1082 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1083 {
1084         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1085
1086         tuner_dbg("suspend\n");
1087         /* FIXME: power down ??? */
1088         return 0;
1089 }
1090
1091 static int tuner_resume(struct i2c_client *c)
1092 {
1093         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1094
1095         tuner_dbg("resume\n");
1096         if (V4L2_TUNER_RADIO == t->mode) {
1097                 if (t->radio_freq)
1098                         set_freq(c, t->radio_freq);
1099         } else {
1100                 if (t->tv_freq)
1101                         set_freq(c, t->tv_freq);
1102         }
1103         return 0;
1104 }
1105
1106 /* ----------------------------------------------------------------------- */
1107
1108 static const struct v4l2_subdev_core_ops tuner_core_ops = {
1109         .log_status = tuner_log_status,
1110         .s_standby = tuner_s_standby,
1111         .ioctl = tuner_ioctl,
1112 };
1113
1114 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
1115         .s_std = tuner_s_std,
1116         .s_radio = tuner_s_radio,
1117         .g_tuner = tuner_g_tuner,
1118         .s_tuner = tuner_s_tuner,
1119         .s_frequency = tuner_s_frequency,
1120         .g_frequency = tuner_g_frequency,
1121         .s_type_addr = tuner_s_type_addr,
1122         .s_config = tuner_s_config,
1123 };
1124
1125 static const struct v4l2_subdev_ops tuner_ops = {
1126         .core = &tuner_core_ops,
1127         .tuner = &tuner_tuner_ops,
1128 };
1129
1130 /* ---------------------------------------------------------------------- */
1131
1132 static LIST_HEAD(tuner_list);
1133
1134 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1135    Note that when this function is called from tuner_probe you can be
1136    certain no other devices will be added/deleted at the same time, I2C
1137    core protects against that. */
1138 static void tuner_lookup(struct i2c_adapter *adap,
1139                 struct tuner **radio, struct tuner **tv)
1140 {
1141         struct tuner *pos;
1142
1143         *radio = NULL;
1144         *tv = NULL;
1145
1146         list_for_each_entry(pos, &tuner_list, list) {
1147                 int mode_mask;
1148
1149                 if (pos->i2c->adapter != adap ||
1150                     pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1151                         continue;
1152
1153                 mode_mask = pos->mode_mask & ~T_STANDBY;
1154                 if (*radio == NULL && mode_mask == T_RADIO)
1155                         *radio = pos;
1156                 /* Note: currently TDA9887 is the only demod-only
1157                    device. If other devices appear then we need to
1158                    make this test more general. */
1159                 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1160                          (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1161                         *tv = pos;
1162         }
1163 }
1164
1165 /* During client attach, set_type is called by adapter's attach_inform callback.
1166    set_type must then be completed by tuner_probe.
1167  */
1168 static int tuner_probe(struct i2c_client *client,
1169                        const struct i2c_device_id *id)
1170 {
1171         struct tuner *t;
1172         struct tuner *radio;
1173         struct tuner *tv;
1174
1175         t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1176         if (NULL == t)
1177                 return -ENOMEM;
1178         v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
1179         t->i2c = client;
1180         t->name = "(tuner unset)";
1181         t->type = UNSET;
1182         t->audmode = V4L2_TUNER_MODE_STEREO;
1183         t->mode_mask = T_UNINITIALIZED;
1184
1185         if (show_i2c) {
1186                 unsigned char buffer[16];
1187                 int i, rc;
1188
1189                 memset(buffer, 0, sizeof(buffer));
1190                 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1191                 tuner_info("I2C RECV = ");
1192                 for (i = 0; i < rc; i++)
1193                         printk(KERN_CONT "%02x ", buffer[i]);
1194                 printk("\n");
1195         }
1196         /* HACK: This test was added to avoid tuner to probe tda9840 and
1197            tea6415c on the MXB card */
1198         if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1199                 kfree(t);
1200                 return -ENODEV;
1201         }
1202
1203         /* autodetection code based on the i2c addr */
1204         if (!no_autodetect) {
1205                 switch (client->addr) {
1206                 case 0x10:
1207                         if (tuner_symbol_probe(tea5761_autodetection,
1208                                                t->i2c->adapter,
1209                                                t->i2c->addr) >= 0) {
1210                                 t->type = TUNER_TEA5761;
1211                                 t->mode_mask = T_RADIO;
1212                                 t->mode = T_STANDBY;
1213                                 /* Sets freq to FM range */
1214                                 t->radio_freq = 87.5 * 16000;
1215                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1216                                 if (tv)
1217                                         tv->mode_mask &= ~T_RADIO;
1218
1219                                 goto register_client;
1220                         }
1221                         return -ENODEV;
1222                 case 0x42:
1223                 case 0x43:
1224                 case 0x4a:
1225                 case 0x4b:
1226                         /* If chip is not tda8290, don't register.
1227                            since it can be tda9887*/
1228                         if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
1229                                                t->i2c->addr) >= 0) {
1230                                 tuner_dbg("tda829x detected\n");
1231                         } else {
1232                                 /* Default is being tda9887 */
1233                                 t->type = TUNER_TDA9887;
1234                                 t->mode_mask = T_RADIO | T_ANALOG_TV |
1235                                                T_DIGITAL_TV;
1236                                 t->mode = T_STANDBY;
1237                                 goto register_client;
1238                         }
1239                         break;
1240                 case 0x60:
1241                         if (tuner_symbol_probe(tea5767_autodetection,
1242                                                t->i2c->adapter, t->i2c->addr)
1243                                         >= 0) {
1244                                 t->type = TUNER_TEA5767;
1245                                 t->mode_mask = T_RADIO;
1246                                 t->mode = T_STANDBY;
1247                                 /* Sets freq to FM range */
1248                                 t->radio_freq = 87.5 * 16000;
1249                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1250                                 if (tv)
1251                                         tv->mode_mask &= ~T_RADIO;
1252
1253                                 goto register_client;
1254                         }
1255                         break;
1256                 }
1257         }
1258
1259         /* Initializes only the first TV tuner on this adapter. Why only the
1260            first? Because there are some devices (notably the ones with TI
1261            tuners) that have more than one i2c address for the *same* device.
1262            Experience shows that, except for just one case, the first
1263            address is the right one. The exception is a Russian tuner
1264            (ACORP_Y878F). So, the desired behavior is just to enable the
1265            first found TV tuner. */
1266         tuner_lookup(t->i2c->adapter, &radio, &tv);
1267         if (tv == NULL) {
1268                 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1269                 if (radio == NULL)
1270                         t->mode_mask |= T_RADIO;
1271                 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1272                 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1273                 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1274         }
1275
1276         /* Should be just before return */
1277 register_client:
1278         tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1279                        client->adapter->name);
1280
1281         /* Sets a default mode */
1282         if (t->mode_mask & T_ANALOG_TV) {
1283                 t->mode = V4L2_TUNER_ANALOG_TV;
1284         } else  if (t->mode_mask & T_RADIO) {
1285                 t->mode = V4L2_TUNER_RADIO;
1286         } else {
1287                 t->mode = V4L2_TUNER_DIGITAL_TV;
1288         }
1289         set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
1290         list_add_tail(&t->list, &tuner_list);
1291         return 0;
1292 }
1293
1294 static int tuner_legacy_probe(struct i2c_adapter *adap)
1295 {
1296         if (0 != addr) {
1297                 normal_i2c[0] = addr;
1298                 normal_i2c[1] = I2C_CLIENT_END;
1299         }
1300
1301         if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1302                 return 0;
1303
1304         /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1305          * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1306          * and an RTC at 0x6f which can get corrupted if probed.
1307          */
1308         if ((adap->id == I2C_HW_B_CX2388x) ||
1309             (adap->id == I2C_HW_B_CX23885)) {
1310                 unsigned int i = 0;
1311
1312                 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1313                         i += 2;
1314                 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1315                         ignore[i+0] = adap->nr;
1316                         ignore[i+1] = 0x6b;
1317                         ignore[i+2] = adap->nr;
1318                         ignore[i+3] = 0x6f;
1319                         ignore[i+4] = I2C_CLIENT_END;
1320                 } else
1321                         printk(KERN_WARNING "tuner: "
1322                                "too many options specified "
1323                                "in i2c probe ignore list!\n");
1324         }
1325         return 1;
1326 }
1327
1328 static int tuner_remove(struct i2c_client *client)
1329 {
1330         struct tuner *t = to_tuner(i2c_get_clientdata(client));
1331
1332         v4l2_device_unregister_subdev(&t->sd);
1333         tuner_detach(&t->fe);
1334         t->fe.analog_demod_priv = NULL;
1335
1336         list_del(&t->list);
1337         kfree(t);
1338         return 0;
1339 }
1340
1341 /* ----------------------------------------------------------------------- */
1342
1343 /* This driver supports many devices and the idea is to let the driver
1344    detect which device is present. So rather than listing all supported
1345    devices here, we pretend to support a single, fake device type. */
1346 static const struct i2c_device_id tuner_id[] = {
1347         { "tuner", }, /* autodetect */
1348         { }
1349 };
1350 MODULE_DEVICE_TABLE(i2c, tuner_id);
1351
1352 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1353         .name = "tuner",
1354         .driverid = I2C_DRIVERID_TUNER,
1355         .command = tuner_command,
1356         .probe = tuner_probe,
1357         .remove = tuner_remove,
1358         .suspend = tuner_suspend,
1359         .resume = tuner_resume,
1360         .legacy_probe = tuner_legacy_probe,
1361         .id_table = tuner_id,
1362 };
1363
1364 /*
1365  * Overrides for Emacs so that we follow Linus's tabbing style.
1366  * ---------------------------------------------------------------------------
1367  * Local variables:
1368  * c-basic-offset: 8
1369  * End:
1370  */