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