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 /*
 589  * Switch tuner to other mode. If tuner support both tv and radio,
 590  * set another frequency to some value (This is needed for some pal
 591  * tuners to avoid locking). Otherwise, just put second tuner in
 592  * standby mode.
 593  */
 594
 595 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
 596 {
 597         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
 598
 599         if (mode == t->mode)
 600                 return 0;
 601
 602         t->mode = mode;
 603
 604         if (check_mode(t, cmd) == EINVAL) {
 605                 t->mode = T_STANDBY;
 606                 if (ops && ops->standby)
 607                         ops->standby(&t->fe);
 608                 return EINVAL;
 609         }
 610         return 0;
 611 }
 612
 613 #define switch_v4l2()   if (!t->using_v4l2) \
 614                             tuner_dbg("switching to v4l2\n"); \
 615                         t->using_v4l2 = 1;
 616
 617 static inline int check_v4l2(struct tuner *t)
 618 {
 619         /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
 620            TV, v4l1 for radio), until that is fixed this code is disabled.
 621            Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
 622            first. */
 623         return 0;
 624 }
 625
 626 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
 627 {
 628         struct tuner *t = i2c_get_clientdata(client);
 629         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 630         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
 631
 632         if (tuner_debug>1)
 633                 v4l_i2c_print_ioctl(client,cmd);
 634
 635         switch (cmd) {
 636         /* --- configuration --- */
 637         case TUNER_SET_TYPE_ADDR:
 638                 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
 639                                 ((struct tuner_setup *)arg)->type,
 640                                 ((struct tuner_setup *)arg)->addr,
 641                                 ((struct tuner_setup *)arg)->mode_mask,
 642                                 ((struct tuner_setup *)arg)->config);
 643
 644                 set_addr(client, (struct tuner_setup *)arg);
 645                 break;
 646         case AUDC_SET_RADIO:
 647                 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
 648                                 == EINVAL)
 649                         return 0;
 650                 if (t->radio_freq)
 651                         set_freq(client, t->radio_freq);
 652                 break;
 653         case TUNER_SET_STANDBY:
 654                 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
 655                         return 0;
 656                 t->mode = T_STANDBY;
 657                 if (ops && ops->standby)
 658                         ops->standby(&t->fe);
 659                 break;
 660 #ifdef CONFIG_VIDEO_V4L1
 661         case VIDIOCSAUDIO:
 662                 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
 663                         return 0;
 664                 if (check_v4l2(t) == EINVAL)
 665                         return 0;
 666
 667                 /* Should be implemented, since bttv calls it */
 668                 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
 669                 break;
 670         case VIDIOCSCHAN:
 671                 {
 672                         static const v4l2_std_id map[] = {
 673                                 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
 674                                 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
 675                                 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
 676                                 [4 /* bttv */ ] = V4L2_STD_PAL_M,
 677                                 [5 /* bttv */ ] = V4L2_STD_PAL_N,
 678                                 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
 679                         };
 680                         struct video_channel *vc = arg;
 681
 682                         if (check_v4l2(t) == EINVAL)
 683                                 return 0;
 684
 685                         if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
 686                                 return 0;
 687
 688                         if (vc->norm < ARRAY_SIZE(map))
 689                                 t->std = map[vc->norm];
 690                         tuner_fixup_std(t);
 691                         if (t->tv_freq)
 692                                 set_tv_freq(client, t->tv_freq);
 693                         return 0;
 694                 }
 695         case VIDIOCSFREQ:
 696                 {
 697                         unsigned long *v = arg;
 698
 699                         if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
 700                                 return 0;
 701                         if (check_v4l2(t) == EINVAL)
 702                                 return 0;
 703
 704                         set_freq(client, *v);
 705                         return 0;
 706                 }
 707         case VIDIOCGTUNER:
 708                 {
 709                         struct video_tuner *vt = arg;
 710
 711                         if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
 712                                 return 0;
 713                         if (check_v4l2(t) == EINVAL)
 714                                 return 0;
 715
 716                         if (V4L2_TUNER_RADIO == t->mode) {
 717                                 if (fe_tuner_ops->get_status) {
 718                                         u32 tuner_status;
 719
 720                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 721                                         if (tuner_status & TUNER_STATUS_STEREO)
 722                                                 vt->flags |= VIDEO_TUNER_STEREO_ON;
 723                                         else
 724                                                 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
 725                                 } else {
 726                                         if (ops && ops->is_stereo) {
 727                                                 if (ops->is_stereo(&t->fe))
 728                                                         vt->flags |=
 729                                                                 VIDEO_TUNER_STEREO_ON;
 730                                                 else
 731                                                         vt->flags &=
 732                                                                 ~VIDEO_TUNER_STEREO_ON;
 733                                         }
 734                                 }
 735                                 if (ops && ops->has_signal)
 736                                         vt->signal = ops->has_signal(&t->fe);
 737
 738                                 vt->flags |= VIDEO_TUNER_LOW;   /* Allow freqs at 62.5 Hz */
 739
 740                                 vt->rangelow = radio_range[0] * 16000;
 741                                 vt->rangehigh = radio_range[1] * 16000;
 742
 743                         } else {
 744                                 vt->rangelow = tv_range[0] * 16;
 745                                 vt->rangehigh = tv_range[1] * 16;
 746                         }
 747
 748                         return 0;
 749                 }
 750         case VIDIOCGAUDIO:
 751                 {
 752                         struct video_audio *va = arg;
 753
 754                         if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
 755                                 return 0;
 756                         if (check_v4l2(t) == EINVAL)
 757                                 return 0;
 758
 759                         if (V4L2_TUNER_RADIO == t->mode) {
 760                                 if (fe_tuner_ops->get_status) {
 761                                         u32 tuner_status;
 762
 763                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 764                                         va->mode = (tuner_status & TUNER_STATUS_STEREO)
 765                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 766                                 } else if (ops && ops->is_stereo)
 767                                         va->mode = ops->is_stereo(&t->fe)
 768                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 769                         }
 770                         return 0;
 771                 }
 772 #endif
 773         case TUNER_SET_CONFIG:
 774         {
 775                 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 776                 struct v4l2_priv_tun_config *cfg = arg;
 777
 778                 if (t->type != cfg->tuner)
 779                         break;
 780
 781                 if (t->type == TUNER_TDA9887) {
 782                         t->tda9887_config = *(unsigned int *)cfg->priv;
 783                         set_freq(client, t->tv_freq);
 784                         break;
 785                 }
 786
 787                 if (NULL == fe_tuner_ops->set_config) {
 788                         tuner_warn("Tuner frontend module has no way to "
 789                                    "set config\n");
 790                         break;
 791                 }
 792                 fe_tuner_ops->set_config(&t->fe, cfg->priv);
 793
 794                 break;
 795         }
 796         /* --- v4l ioctls --- */
 797         /* take care: bttv does userspace copying, we'll get a
 798            kernel pointer here... */
 799         case VIDIOC_S_STD:
 800                 {
 801                         v4l2_std_id *id = arg;
 802
 803                         if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
 804                                         == EINVAL)
 805                                 return 0;
 806
 807                         switch_v4l2();
 808
 809                         t->std = *id;
 810                         tuner_fixup_std(t);
 811                         if (t->tv_freq)
 812                                 set_freq(client, t->tv_freq);
 813                         break;
 814                 }
 815         case VIDIOC_S_FREQUENCY:
 816                 {
 817                         struct v4l2_frequency *f = arg;
 818
 819                         if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
 820                                         == EINVAL)
 821                                 return 0;
 822                         switch_v4l2();
 823                         set_freq(client,f->frequency);
 824
 825                         break;
 826                 }
 827         case VIDIOC_G_FREQUENCY:
 828                 {
 829                         struct v4l2_frequency *f = arg;
 830
 831                         if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
 832                                 return 0;
 833                         switch_v4l2();
 834                         f->type = t->mode;
 835                         if (fe_tuner_ops->get_frequency) {
 836                                 u32 abs_freq;
 837
 838                                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
 839                                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 840                                         (abs_freq * 2 + 125/2) / 125 :
 841                                         (abs_freq + 62500/2) / 62500;
 842                                 break;
 843                         }
 844                         f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 845                                 t->radio_freq : t->tv_freq;
 846                         break;
 847                 }
 848         case VIDIOC_G_TUNER:
 849                 {
 850                         struct v4l2_tuner *tuner = arg;
 851
 852                         if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
 853                                 return 0;
 854                         switch_v4l2();
 855
 856                         tuner->type = t->mode;
 857                         if (ops && ops->get_afc)
 858                                 tuner->afc = ops->get_afc(&t->fe);
 859                         if (t->mode == V4L2_TUNER_ANALOG_TV)
 860                                 tuner->capability |= V4L2_TUNER_CAP_NORM;
 861                         if (t->mode != V4L2_TUNER_RADIO) {
 862                                 tuner->rangelow = tv_range[0] * 16;
 863                                 tuner->rangehigh = tv_range[1] * 16;
 864                                 break;
 865                         }
 866
 867                         /* radio mode */
 868                         tuner->rxsubchans =
 869                                 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
 870                         if (fe_tuner_ops->get_status) {
 871                                 u32 tuner_status;
 872
 873                                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
 874                                 tuner->rxsubchans =
 875                                         (tuner_status & TUNER_STATUS_STEREO) ?
 876                                         V4L2_TUNER_SUB_STEREO :
 877                                         V4L2_TUNER_SUB_MONO;
 878                         } else {
 879                                 if (ops && ops->is_stereo) {
 880                                         tuner->rxsubchans =
 881                                                 ops->is_stereo(&t->fe) ?
 882                                                 V4L2_TUNER_SUB_STEREO :
 883                                                 V4L2_TUNER_SUB_MONO;
 884                                 }
 885                         }
 886                         if (ops && ops->has_signal)
 887                                 tuner->signal = ops->has_signal(&t->fe);
 888                         tuner->capability |=
 889                             V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
 890                         tuner->audmode = t->audmode;
 891                         tuner->rangelow = radio_range[0] * 16000;
 892                         tuner->rangehigh = radio_range[1] * 16000;
 893                         break;
 894                 }
 895         case VIDIOC_S_TUNER:
 896                 {
 897                         struct v4l2_tuner *tuner = arg;
 898
 899                         if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
 900                                 return 0;
 901
 902                         switch_v4l2();
 903
 904                         /* do nothing unless we're a radio tuner */
 905                         if (t->mode != V4L2_TUNER_RADIO)
 906                                 break;
 907                         t->audmode = tuner->audmode;
 908                         set_radio_freq(client, t->radio_freq);
 909                         break;
 910                 }
 911         case VIDIOC_LOG_STATUS:
 912                 if (ops && ops->tuner_status)
 913                         ops->tuner_status(&t->fe);
 914                 break;
 915         }
 916
 917         return 0;
 918 }
 919
 920 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
 921 {
 922         struct tuner *t = i2c_get_clientdata (c);
 923
 924         tuner_dbg ("suspend\n");
 925         /* FIXME: power down ??? */
 926         return 0;
 927 }
 928
 929 static int tuner_resume(struct i2c_client *c)
 930 {
 931         struct tuner *t = i2c_get_clientdata (c);
 932
 933         tuner_dbg ("resume\n");
 934         if (V4L2_TUNER_RADIO == t->mode) {
 935                 if (t->radio_freq)
 936                         set_freq(c, t->radio_freq);
 937         } else {
 938                 if (t->tv_freq)
 939                         set_freq(c, t->tv_freq);
 940         }
 941         return 0;
 942 }
 943
 944 /* ---------------------------------------------------------------------- */
 945
 946 LIST_HEAD(tuner_list);
 947
 948 /* Search for existing radio and/or TV tuners on the given I2C adapter.
 949    Note that when this function is called from tuner_attach you can be
 950    certain no other devices will be added/deleted at the same time, I2C
 951    core protects against that. */
 952 static void tuner_lookup(struct i2c_adapter *adap,
 953                 struct tuner **radio, struct tuner **tv)
 954 {
 955         struct tuner *pos;
 956
 957         *radio = NULL;
 958         *tv = NULL;
 959
 960         list_for_each_entry(pos, &tuner_list, list) {
 961                 int mode_mask;
 962
 963                 if (pos->i2c->adapter != adap ||
 964                     pos->i2c->driver->id != I2C_DRIVERID_TUNER)
 965                         continue;
 966
 967                 mode_mask = pos->mode_mask & ~T_STANDBY;
 968                 if (*radio == NULL && mode_mask == T_RADIO)
 969                         *radio = pos;
 970                 /* Note: currently TDA9887 is the only demod-only
 971                    device. If other devices appear then we need to
 972                    make this test more general. */
 973                 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
 974                          (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
 975                         *tv = pos;
 976         }
 977 }
 978
 979 /* During client attach, set_type is called by adapter's attach_inform callback.
 980    set_type must then be completed by tuner_attach.
 981  */
 982 static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
 983 {
 984         struct i2c_client *client;
 985         struct tuner *t;
 986         struct tuner *radio;
 987         struct tuner *tv;
 988
 989         client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
 990         if (NULL == client)
 991                 return -ENOMEM;
 992
 993         t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
 994         if (NULL == t) {
 995                 kfree(client);
 996                 return -ENOMEM;
 997         }
 998         t->i2c = client;
 999         client_template.adapter = adap;
1000         client_template.addr = addr;
1001         memcpy(client, &client_template, sizeof(struct i2c_client));
1002         i2c_set_clientdata(client, t);
1003         t->type = UNSET;
1004         t->audmode = V4L2_TUNER_MODE_STEREO;
1005         t->mode_mask = T_UNINITIALIZED;
1006
1007         if (show_i2c) {
1008                 unsigned char buffer[16];
1009                 int i, rc;
1010
1011                 memset(buffer, 0, sizeof(buffer));
1012                 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1013                 tuner_info("I2C RECV = ");
1014                 for (i = 0; i < rc; i++)
1015                         printk(KERN_CONT "%02x ", buffer[i]);
1016                 printk("\n");
1017         }
1018         /* HACK: This test were added to avoid tuner to probe tda9840 and
1019            tea6415c on the MXB card */
1020         if (adap->id == I2C_HW_SAA7146 && addr < 0x4a)
1021                 return -ENODEV;
1022
1023         /* autodetection code based on the i2c addr */
1024         if (!no_autodetect) {
1025                 switch (addr) {
1026                 case 0x10:
1027                         if (tea5761_autodetection(t->i2c->adapter, t->i2c->addr)
1028                                         != EINVAL) {
1029                                 t->type = TUNER_TEA5761;
1030                                 t->mode_mask = T_RADIO;
1031                                 t->mode = T_STANDBY;
1032                                 /* Sets freq to FM range */
1033                                 t->radio_freq = 87.5 * 16000;
1034                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1035                                 if (tv)
1036                                         tv->mode_mask &= ~T_RADIO;
1037
1038                                 goto register_client;
1039                         }
1040                         break;
1041                 case 0x42:
1042                 case 0x43:
1043                 case 0x4a:
1044                 case 0x4b:
1045                         /* If chip is not tda8290, don't register.
1046                            since it can be tda9887*/
1047                         if (tda829x_probe(t) == 0) {
1048                                 tuner_dbg("tda829x detected\n");
1049                         } else {
1050                                 /* Default is being tda9887 */
1051                                 t->type = TUNER_TDA9887;
1052                                 t->mode_mask = T_RADIO | T_ANALOG_TV |
1053                                                T_DIGITAL_TV;
1054                                 t->mode = T_STANDBY;
1055                                 goto register_client;
1056                         }
1057                         break;
1058                 case 0x60:
1059                         if (tea5767_autodetection(t->i2c->adapter, t->i2c->addr)
1060                                         != EINVAL) {
1061                                 t->type = TUNER_TEA5767;
1062                                 t->mode_mask = T_RADIO;
1063                                 t->mode = T_STANDBY;
1064                                 /* Sets freq to FM range */
1065                                 t->radio_freq = 87.5 * 16000;
1066                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1067                                 if (tv)
1068                                         tv->mode_mask &= ~T_RADIO;
1069
1070                                 goto register_client;
1071                         }
1072                         break;
1073                 }
1074         }
1075
1076         /* Initializes only the first TV tuner on this adapter. Why only the
1077            first? Because there are some devices (notably the ones with TI
1078            tuners) that have more than one i2c address for the *same* device.
1079            Experience shows that, except for just one case, the first
1080            address is the right one. The exception is a Russian tuner
1081            (ACORP_Y878F). So, the desired behavior is just to enable the
1082            first found TV tuner. */
1083         tuner_lookup(t->i2c->adapter, &radio, &tv);
1084         if (tv == NULL) {
1085                 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1086                 if (radio == NULL)
1087                         t->mode_mask |= T_RADIO;
1088                 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1089                 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1090                 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1091         }
1092
1093         /* Should be just before return */
1094 register_client:
1095         tuner_info("chip found @ 0x%x (%s)\n", addr << 1, adap->name);
1096
1097         /* Sets a default mode */
1098         if (t->mode_mask & T_ANALOG_TV) {
1099                 t->mode = T_ANALOG_TV;
1100         } else  if (t->mode_mask & T_RADIO) {
1101                 t->mode = T_RADIO;
1102         } else {
1103                 t->mode = T_DIGITAL_TV;
1104         }
1105
1106         i2c_attach_client(client);
1107         set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
1108         return 0;
1109 }
1110
1111 static int tuner_probe(struct i2c_adapter *adap)
1112 {
1113         if (0 != addr) {
1114                 normal_i2c[0] = addr;
1115                 normal_i2c[1] = I2C_CLIENT_END;
1116         }
1117
1118         /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1119          * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1120          * and an RTC at 0x6f which can get corrupted if probed.
1121          */
1122         if ((adap->id == I2C_HW_B_CX2388x) ||
1123             (adap->id == I2C_HW_B_CX23885)) {
1124                 unsigned int i = 0;
1125
1126                 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1127                         i += 2;
1128                 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1129                         ignore[i+0] = adap->nr;
1130                         ignore[i+1] = 0x6b;
1131                         ignore[i+2] = adap->nr;
1132                         ignore[i+3] = 0x6f;
1133                         ignore[i+4] = I2C_CLIENT_END;
1134                 } else
1135                         printk(KERN_WARNING "tuner: "
1136                                "too many options specified "
1137                                "in i2c probe ignore list!\n");
1138         }
1139
1140         if (adap->class & I2C_CLASS_TV_ANALOG)
1141                 return i2c_probe(adap, &addr_data, tuner_attach);
1142         return 0;
1143 }
1144
1145 static int tuner_detach(struct i2c_client *client)
1146 {
1147         struct tuner *t = i2c_get_clientdata(client);
1148         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
1149         int err;
1150
1151         err = i2c_detach_client(t->i2c);
1152         if (err) {
1153                 tuner_warn
1154                     ("Client deregistration failed, client not detached.\n");
1155                 return err;
1156         }
1157
1158         if (ops && ops->release)
1159                 ops->release(&t->fe);
1160
1161         list_del(&t->list);
1162         kfree(t);
1163         kfree(client);
1164         return 0;
1165 }
1166
1167 /* ----------------------------------------------------------------------- */
1168
1169 static struct i2c_driver driver = {
1170         .id = I2C_DRIVERID_TUNER,
1171         .attach_adapter = tuner_probe,
1172         .detach_client = tuner_detach,
1173         .command = tuner_command,
1174         .suspend = tuner_suspend,
1175         .resume  = tuner_resume,
1176         .driver = {
1177                 .name    = "tuner",
1178         },
1179 };
1180 static struct i2c_client client_template = {
1181         .name = "(tuner unset)",
1182         .driver = &driver,
1183 };
1184
1185 static int __init tuner_init_module(void)
1186 {
1187         return i2c_add_driver(&driver);
1188 }
1189
1190 static void __exit tuner_cleanup_module(void)
1191 {
1192         i2c_del_driver(&driver);
1193 }
1194
1195 module_init(tuner_init_module);
1196 module_exit(tuner_cleanup_module);
1197
1198 /*
1199  * Overrides for Emacs so that we follow Linus's tabbing style.
1200  * ---------------------------------------------------------------------------
1201  * Local variables:
1202  * c-basic-offset: 8
1203  * End:
1204  */