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