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