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