git.oblomov.eu 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         }
 414
 415         tuner_dbg("type set to %s\n", t->i2c->name);
 416
 417         if (t->mode_mask == T_UNINITIALIZED)
 418                 t->mode_mask = new_mode_mask;
 419
 420         set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
 421         tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
 422                   c->adapter->name, c->driver->driver.name, c->addr << 1, type,
 423                   t->mode_mask);
 424         tuner_i2c_address_check(t);
 425 }
 426
 427 /*
 428  * This function apply tuner config to tuner specified
 429  * by tun_setup structure. I addr is unset, then admin status
 430  * and tun addr status is more precise then current status,
 431  * it's applied. Otherwise status and type are applied only to
 432  * tuner with exactly the same addr.
 433 */
 434
 435 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
 436 {
 437         struct tuner *t = i2c_get_clientdata(c);
 438
 439         tuner_dbg("set addr for type %i\n", t->type);
 440
 441         if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
 442                 (t->mode_mask & tun_setup->mode_mask))) ||
 443                 (tun_setup->addr == c->addr)) {
 444                         set_type(c, tun_setup->type, tun_setup->mode_mask,
 445                                  tun_setup->config, tun_setup->tuner_callback);
 446         }
 447 }
 448
 449 static inline int check_mode(struct tuner *t, char *cmd)
 450 {
 451         if ((1 << t->mode & t->mode_mask) == 0) {
 452                 return EINVAL;
 453         }
 454
 455         switch (t->mode) {
 456         case V4L2_TUNER_RADIO:
 457                 tuner_dbg("Cmd %s accepted for radio\n", cmd);
 458                 break;
 459         case V4L2_TUNER_ANALOG_TV:
 460                 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
 461                 break;
 462         case V4L2_TUNER_DIGITAL_TV:
 463                 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
 464                 break;
 465         }
 466         return 0;
 467 }
 468
 469 /* get more precise norm info from insmod option */
 470 static int tuner_fixup_std(struct tuner *t)
 471 {
 472         if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
 473                 switch (pal[0]) {
 474                 case '6':
 475                         tuner_dbg ("insmod fixup: PAL => PAL-60\n");
 476                         t->std = V4L2_STD_PAL_60;
 477                         break;
 478                 case 'b':
 479                 case 'B':
 480                 case 'g':
 481                 case 'G':
 482                         tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
 483                         t->std = V4L2_STD_PAL_BG;
 484                         break;
 485                 case 'i':
 486                 case 'I':
 487                         tuner_dbg ("insmod fixup: PAL => PAL-I\n");
 488                         t->std = V4L2_STD_PAL_I;
 489                         break;
 490                 case 'd':
 491                 case 'D':
 492                 case 'k':
 493                 case 'K':
 494                         tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
 495                         t->std = V4L2_STD_PAL_DK;
 496                         break;
 497                 case 'M':
 498                 case 'm':
 499                         tuner_dbg ("insmod fixup: PAL => PAL-M\n");
 500                         t->std = V4L2_STD_PAL_M;
 501                         break;
 502                 case 'N':
 503                 case 'n':
 504                         if (pal[1] == 'c' || pal[1] == 'C') {
 505                                 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
 506                                 t->std = V4L2_STD_PAL_Nc;
 507                         } else {
 508                                 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
 509                                 t->std = V4L2_STD_PAL_N;
 510                         }
 511                         break;
 512                 case '-':
 513                         /* default parameter, do nothing */
 514                         break;
 515                 default:
 516                         tuner_warn ("pal= argument not recognised\n");
 517                         break;
 518                 }
 519         }
 520         if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
 521                 switch (secam[0]) {
 522                 case 'b':
 523                 case 'B':
 524                 case 'g':
 525                 case 'G':
 526                 case 'h':
 527                 case 'H':
 528                         tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
 529                         t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
 530                         break;
 531                 case 'd':
 532                 case 'D':
 533                 case 'k':
 534                 case 'K':
 535                         tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
 536                         t->std = V4L2_STD_SECAM_DK;
 537                         break;
 538                 case 'l':
 539                 case 'L':
 540                         if ((secam[1]=='C')||(secam[1]=='c')) {
 541                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
 542                                 t->std = V4L2_STD_SECAM_LC;
 543                         } else {
 544                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
 545                                 t->std = V4L2_STD_SECAM_L;
 546                         }
 547                         break;
 548                 case '-':
 549                         /* default parameter, do nothing */
 550                         break;
 551                 default:
 552                         tuner_warn ("secam= argument not recognised\n");
 553                         break;
 554                 }
 555         }
 556
 557         if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
 558                 switch (ntsc[0]) {
 559                 case 'm':
 560                 case 'M':
 561                         tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
 562                         t->std = V4L2_STD_NTSC_M;
 563                         break;
 564                 case 'j':
 565                 case 'J':
 566                         tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
 567                         t->std = V4L2_STD_NTSC_M_JP;
 568                         break;
 569                 case 'k':
 570                 case 'K':
 571                         tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
 572                         t->std = V4L2_STD_NTSC_M_KR;
 573                         break;
 574                 case '-':
 575                         /* default parameter, do nothing */
 576                         break;
 577                 default:
 578                         tuner_info("ntsc= argument not recognised\n");
 579                         break;
 580                 }
 581         }
 582         return 0;
 583 }
 584
 585 static void tuner_status(struct dvb_frontend *fe)
 586 {
 587         struct tuner *t = fe->analog_demod_priv;
 588         unsigned long freq, freq_fraction;
 589         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 590         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
 591         const char *p;
 592
 593         switch (t->mode) {
 594                 case V4L2_TUNER_RADIO:      p = "radio"; break;
 595                 case V4L2_TUNER_ANALOG_TV:  p = "analog TV"; break;
 596                 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
 597                 default: p = "undefined"; break;
 598         }
 599         if (t->mode == V4L2_TUNER_RADIO) {
 600                 freq = t->radio_freq / 16000;
 601                 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
 602         } else {
 603                 freq = t->tv_freq / 16;
 604                 freq_fraction = (t->tv_freq % 16) * 100 / 16;
 605         }
 606         tuner_info("Tuner mode:      %s\n", p);
 607         tuner_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
 608         tuner_info("Standard:        0x%08lx\n", (unsigned long)t->std);
 609         if (t->mode != V4L2_TUNER_RADIO)
 610                return;
 611         if (fe_tuner_ops->get_status) {
 612                 u32 tuner_status;
 613
 614                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
 615                 if (tuner_status & TUNER_STATUS_LOCKED)
 616                         tuner_info("Tuner is locked.\n");
 617                 if (tuner_status & TUNER_STATUS_STEREO)
 618                         tuner_info("Stereo:          yes\n");
 619         }
 620         if (ops) {
 621                 if (ops->has_signal)
 622                         tuner_info("Signal strength: %d\n",
 623                                    ops->has_signal(fe));
 624                 if (ops->is_stereo)
 625                         tuner_info("Stereo:          %s\n",
 626                                    ops->is_stereo(fe) ? "yes" : "no");
 627         }
 628 }
 629
 630 /* ---------------------------------------------------------------------- */
 631
 632 /*
 633  * Switch tuner to other mode. If tuner support both tv and radio,
 634  * set another frequency to some value (This is needed for some pal
 635  * tuners to avoid locking). Otherwise, just put second tuner in
 636  * standby mode.
 637  */
 638
 639 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
 640 {
 641         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
 642
 643         if (mode == t->mode)
 644                 return 0;
 645
 646         t->mode = mode;
 647
 648         if (check_mode(t, cmd) == EINVAL) {
 649                 t->mode = T_STANDBY;
 650                 if (ops && ops->standby)
 651                         ops->standby(&t->fe);
 652                 return EINVAL;
 653         }
 654         return 0;
 655 }
 656
 657 #define switch_v4l2()   if (!t->using_v4l2) \
 658                             tuner_dbg("switching to v4l2\n"); \
 659                         t->using_v4l2 = 1;
 660
 661 static inline int check_v4l2(struct tuner *t)
 662 {
 663         /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
 664            TV, v4l1 for radio), until that is fixed this code is disabled.
 665            Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
 666            first. */
 667         return 0;
 668 }
 669
 670 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
 671 {
 672         struct tuner *t = i2c_get_clientdata(client);
 673         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 674         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
 675
 676         if (tuner_debug>1)
 677                 v4l_i2c_print_ioctl(client,cmd);
 678
 679         switch (cmd) {
 680         /* --- configuration --- */
 681         case TUNER_SET_TYPE_ADDR:
 682                 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
 683                                 ((struct tuner_setup *)arg)->type,
 684                                 ((struct tuner_setup *)arg)->addr,
 685                                 ((struct tuner_setup *)arg)->mode_mask,
 686                                 ((struct tuner_setup *)arg)->config);
 687
 688                 set_addr(client, (struct tuner_setup *)arg);
 689                 break;
 690         case AUDC_SET_RADIO:
 691                 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
 692                                 == EINVAL)
 693                         return 0;
 694                 if (t->radio_freq)
 695                         set_freq(client, t->radio_freq);
 696                 break;
 697         case TUNER_SET_STANDBY:
 698                 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
 699                         return 0;
 700                 t->mode = T_STANDBY;
 701                 if (ops && ops->standby)
 702                         ops->standby(&t->fe);
 703                 break;
 704 #ifdef CONFIG_VIDEO_V4L1
 705         case VIDIOCSAUDIO:
 706                 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
 707                         return 0;
 708                 if (check_v4l2(t) == EINVAL)
 709                         return 0;
 710
 711                 /* Should be implemented, since bttv calls it */
 712                 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
 713                 break;
 714         case VIDIOCSCHAN:
 715                 {
 716                         static const v4l2_std_id map[] = {
 717                                 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
 718                                 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
 719                                 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
 720                                 [4 /* bttv */ ] = V4L2_STD_PAL_M,
 721                                 [5 /* bttv */ ] = V4L2_STD_PAL_N,
 722                                 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
 723                         };
 724                         struct video_channel *vc = arg;
 725
 726                         if (check_v4l2(t) == EINVAL)
 727                                 return 0;
 728
 729                         if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
 730                                 return 0;
 731
 732                         if (vc->norm < ARRAY_SIZE(map))
 733                                 t->std = map[vc->norm];
 734                         tuner_fixup_std(t);
 735                         if (t->tv_freq)
 736                                 set_tv_freq(client, t->tv_freq);
 737                         return 0;
 738                 }
 739         case VIDIOCSFREQ:
 740                 {
 741                         unsigned long *v = arg;
 742
 743                         if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
 744                                 return 0;
 745                         if (check_v4l2(t) == EINVAL)
 746                                 return 0;
 747
 748                         set_freq(client, *v);
 749                         return 0;
 750                 }
 751         case VIDIOCGTUNER:
 752                 {
 753                         struct video_tuner *vt = arg;
 754
 755                         if (check_mode(t, "VIDIOCGTUNER") == 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                                         if (tuner_status & TUNER_STATUS_STEREO)
 766                                                 vt->flags |= VIDEO_TUNER_STEREO_ON;
 767                                         else
 768                                                 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
 769                                 } else {
 770                                         if (ops && ops->is_stereo) {
 771                                                 if (ops->is_stereo(&t->fe))
 772                                                         vt->flags |=
 773                                                                 VIDEO_TUNER_STEREO_ON;
 774                                                 else
 775                                                         vt->flags &=
 776                                                                 ~VIDEO_TUNER_STEREO_ON;
 777                                         }
 778                                 }
 779                                 if (ops && ops->has_signal)
 780                                         vt->signal = ops->has_signal(&t->fe);
 781
 782                                 vt->flags |= VIDEO_TUNER_LOW;   /* Allow freqs at 62.5 Hz */
 783
 784                                 vt->rangelow = radio_range[0] * 16000;
 785                                 vt->rangehigh = radio_range[1] * 16000;
 786
 787                         } else {
 788                                 vt->rangelow = tv_range[0] * 16;
 789                                 vt->rangehigh = tv_range[1] * 16;
 790                         }
 791
 792                         return 0;
 793                 }
 794         case VIDIOCGAUDIO:
 795                 {
 796                         struct video_audio *va = arg;
 797
 798                         if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
 799                                 return 0;
 800                         if (check_v4l2(t) == EINVAL)
 801                                 return 0;
 802
 803                         if (V4L2_TUNER_RADIO == t->mode) {
 804                                 if (fe_tuner_ops->get_status) {
 805                                         u32 tuner_status;
 806
 807                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 808                                         va->mode = (tuner_status & TUNER_STATUS_STEREO)
 809                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 810                                 } else if (ops && ops->is_stereo)
 811                                         va->mode = ops->is_stereo(&t->fe)
 812                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 813                         }
 814                         return 0;
 815                 }
 816 #endif
 817         case TUNER_SET_CONFIG:
 818         {
 819                 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 820                 struct v4l2_priv_tun_config *cfg = arg;
 821
 822                 if (t->type != cfg->tuner)
 823                         break;
 824
 825                 if (t->type == TUNER_TDA9887) {
 826                         t->tda9887_config = *(unsigned int *)cfg->priv;
 827                         set_freq(client, t->tv_freq);
 828                         break;
 829                 }
 830
 831                 if (NULL == fe_tuner_ops->set_config) {
 832                         tuner_warn("Tuner frontend module has no way to "
 833                                    "set config\n");
 834                         break;
 835                 }
 836                 fe_tuner_ops->set_config(&t->fe, cfg->priv);
 837
 838                 break;
 839         }
 840         /* --- v4l ioctls --- */
 841         /* take care: bttv does userspace copying, we'll get a
 842            kernel pointer here... */
 843         case VIDIOC_S_STD:
 844                 {
 845                         v4l2_std_id *id = arg;
 846
 847                         if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
 848                                         == EINVAL)
 849                                 return 0;
 850
 851                         switch_v4l2();
 852
 853                         t->std = *id;
 854                         tuner_fixup_std(t);
 855                         if (t->tv_freq)
 856                                 set_freq(client, t->tv_freq);
 857                         break;
 858                 }
 859         case VIDIOC_S_FREQUENCY:
 860                 {
 861                         struct v4l2_frequency *f = arg;
 862
 863                         if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
 864                                         == EINVAL)
 865                                 return 0;
 866                         switch_v4l2();
 867                         set_freq(client,f->frequency);
 868
 869                         break;
 870                 }
 871         case VIDIOC_G_FREQUENCY:
 872                 {
 873                         struct v4l2_frequency *f = arg;
 874
 875                         if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
 876                                 return 0;
 877                         switch_v4l2();
 878                         f->type = t->mode;
 879                         if (fe_tuner_ops->get_frequency) {
 880                                 u32 abs_freq;
 881
 882                                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
 883                                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 884                                         (abs_freq * 2 + 125/2) / 125 :
 885                                         (abs_freq + 62500/2) / 62500;
 886                                 break;
 887                         }
 888                         f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 889                                 t->radio_freq : t->tv_freq;
 890                         break;
 891                 }
 892         case VIDIOC_G_TUNER:
 893                 {
 894                         struct v4l2_tuner *tuner = arg;
 895
 896                         if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
 897                                 return 0;
 898                         switch_v4l2();
 899
 900                         tuner->type = t->mode;
 901                         if (ops && ops->get_afc)
 902                                 tuner->afc = ops->get_afc(&t->fe);
 903                         if (t->mode == V4L2_TUNER_ANALOG_TV)
 904                                 tuner->capability |= V4L2_TUNER_CAP_NORM;
 905                         if (t->mode != V4L2_TUNER_RADIO) {
 906                                 tuner->rangelow = tv_range[0] * 16;
 907                                 tuner->rangehigh = tv_range[1] * 16;
 908                                 break;
 909                         }
 910
 911                         /* radio mode */
 912                         tuner->rxsubchans =
 913                                 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
 914                         if (fe_tuner_ops->get_status) {
 915                                 u32 tuner_status;
 916
 917                                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
 918                                 tuner->rxsubchans =
 919                                         (tuner_status & TUNER_STATUS_STEREO) ?
 920                                         V4L2_TUNER_SUB_STEREO :
 921                                         V4L2_TUNER_SUB_MONO;
 922                         } else {
 923                                 if (ops && ops->is_stereo) {
 924                                         tuner->rxsubchans =
 925                                                 ops->is_stereo(&t->fe) ?
 926                                                 V4L2_TUNER_SUB_STEREO :
 927                                                 V4L2_TUNER_SUB_MONO;
 928                                 }
 929                         }
 930                         if (ops && ops->has_signal)
 931                                 tuner->signal = ops->has_signal(&t->fe);
 932                         tuner->capability |=
 933                             V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
 934                         tuner->audmode = t->audmode;
 935                         tuner->rangelow = radio_range[0] * 16000;
 936                         tuner->rangehigh = radio_range[1] * 16000;
 937                         break;
 938                 }
 939         case VIDIOC_S_TUNER:
 940                 {
 941                         struct v4l2_tuner *tuner = arg;
 942
 943                         if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
 944                                 return 0;
 945
 946                         switch_v4l2();
 947
 948                         /* do nothing unless we're a radio tuner */
 949                         if (t->mode != V4L2_TUNER_RADIO)
 950                                 break;
 951                         t->audmode = tuner->audmode;
 952                         set_radio_freq(client, t->radio_freq);
 953                         break;
 954                 }
 955         case VIDIOC_LOG_STATUS:
 956                 if (ops && ops->tuner_status)
 957                         ops->tuner_status(&t->fe);
 958                 break;
 959         }
 960
 961         return 0;
 962 }
 963
 964 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
 965 {
 966         struct tuner *t = i2c_get_clientdata(c);
 967
 968         tuner_dbg("suspend\n");
 969         /* FIXME: power down ??? */
 970         return 0;
 971 }
 972
 973 static int tuner_resume(struct i2c_client *c)
 974 {
 975         struct tuner *t = i2c_get_clientdata(c);
 976
 977         tuner_dbg("resume\n");
 978         if (V4L2_TUNER_RADIO == t->mode) {
 979                 if (t->radio_freq)
 980                         set_freq(c, t->radio_freq);
 981         } else {
 982                 if (t->tv_freq)
 983                         set_freq(c, t->tv_freq);
 984         }
 985         return 0;
 986 }
 987
 988 /* ---------------------------------------------------------------------- */
 989
 990 LIST_HEAD(tuner_list);
 991
 992 /* Search for existing radio and/or TV tuners on the given I2C adapter.
 993    Note that when this function is called from tuner_probe you can be
 994    certain no other devices will be added/deleted at the same time, I2C
 995    core protects against that. */
 996 static void tuner_lookup(struct i2c_adapter *adap,
 997                 struct tuner **radio, struct tuner **tv)
 998 {
 999         struct tuner *pos;
1000
1001         *radio = NULL;
1002         *tv = NULL;
1003
1004         list_for_each_entry(pos, &tuner_list, list) {
1005                 int mode_mask;
1006
1007                 if (pos->i2c->adapter != adap ||
1008                     pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1009                         continue;
1010
1011                 mode_mask = pos->mode_mask & ~T_STANDBY;
1012                 if (*radio == NULL && mode_mask == T_RADIO)
1013                         *radio = pos;
1014                 /* Note: currently TDA9887 is the only demod-only
1015                    device. If other devices appear then we need to
1016                    make this test more general. */
1017                 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1018                          (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1019                         *tv = pos;
1020         }
1021 }
1022
1023 /* During client attach, set_type is called by adapter's attach_inform callback.
1024    set_type must then be completed by tuner_probe.
1025  */
1026 static int tuner_probe(struct i2c_client *client)
1027 {
1028         struct tuner *t;
1029         struct tuner *radio;
1030         struct tuner *tv;
1031
1032         t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1033         if (NULL == t)
1034                 return -ENOMEM;
1035         t->i2c = client;
1036         strlcpy(client->name, "(tuner unset)", sizeof(client->name));
1037         i2c_set_clientdata(client, t);
1038         t->type = UNSET;
1039         t->audmode = V4L2_TUNER_MODE_STEREO;
1040         t->mode_mask = T_UNINITIALIZED;
1041
1042         if (show_i2c) {
1043                 unsigned char buffer[16];
1044                 int i, rc;
1045
1046                 memset(buffer, 0, sizeof(buffer));
1047                 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1048                 tuner_info("I2C RECV = ");
1049                 for (i = 0; i < rc; i++)
1050                         printk(KERN_CONT "%02x ", buffer[i]);
1051                 printk("\n");
1052         }
1053         /* HACK: This test was added to avoid tuner to probe tda9840 and
1054            tea6415c on the MXB card */
1055         if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1056                 kfree(t);
1057                 return -ENODEV;
1058         }
1059
1060         /* autodetection code based on the i2c addr */
1061         if (!no_autodetect) {
1062                 switch (client->addr) {
1063                 case 0x10:
1064                         if (tea5761_autodetection(t->i2c->adapter, t->i2c->addr)
1065                                         != EINVAL) {
1066                                 t->type = TUNER_TEA5761;
1067                                 t->mode_mask = T_RADIO;
1068                                 t->mode = T_STANDBY;
1069                                 /* Sets freq to FM range */
1070                                 t->radio_freq = 87.5 * 16000;
1071                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1072                                 if (tv)
1073                                         tv->mode_mask &= ~T_RADIO;
1074
1075                                 goto register_client;
1076                         }
1077                         break;
1078                 case 0x42:
1079                 case 0x43:
1080                 case 0x4a:
1081                 case 0x4b:
1082                         /* If chip is not tda8290, don't register.
1083                            since it can be tda9887*/
1084                         if (tda829x_probe(t->i2c->adapter,
1085                                           t->i2c->addr) == 0) {
1086                                 tuner_dbg("tda829x detected\n");
1087                         } else {
1088                                 /* Default is being tda9887 */
1089                                 t->type = TUNER_TDA9887;
1090                                 t->mode_mask = T_RADIO | T_ANALOG_TV |
1091                                                T_DIGITAL_TV;
1092                                 t->mode = T_STANDBY;
1093                                 goto register_client;
1094                         }
1095                         break;
1096                 case 0x60:
1097                         if (tea5767_autodetection(t->i2c->adapter, t->i2c->addr)
1098                                         != EINVAL) {
1099                                 t->type = TUNER_TEA5767;
1100                                 t->mode_mask = T_RADIO;
1101                                 t->mode = T_STANDBY;
1102                                 /* Sets freq to FM range */
1103                                 t->radio_freq = 87.5 * 16000;
1104                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1105                                 if (tv)
1106                                         tv->mode_mask &= ~T_RADIO;
1107
1108                                 goto register_client;
1109                         }
1110                         break;
1111                 }
1112         }
1113
1114         /* Initializes only the first TV tuner on this adapter. Why only the
1115            first? Because there are some devices (notably the ones with TI
1116            tuners) that have more than one i2c address for the *same* device.
1117            Experience shows that, except for just one case, the first
1118            address is the right one. The exception is a Russian tuner
1119            (ACORP_Y878F). So, the desired behavior is just to enable the
1120            first found TV tuner. */
1121         tuner_lookup(t->i2c->adapter, &radio, &tv);
1122         if (tv == NULL) {
1123                 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1124                 if (radio == NULL)
1125                         t->mode_mask |= T_RADIO;
1126                 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1127                 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1128                 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1129         }
1130
1131         /* Should be just before return */
1132 register_client:
1133         tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1134                        client->adapter->name);
1135
1136         /* Sets a default mode */
1137         if (t->mode_mask & T_ANALOG_TV) {
1138                 t->mode = T_ANALOG_TV;
1139         } else  if (t->mode_mask & T_RADIO) {
1140                 t->mode = T_RADIO;
1141         } else {
1142                 t->mode = T_DIGITAL_TV;
1143         }
1144         set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
1145         list_add_tail(&t->list, &tuner_list);
1146         return 0;
1147 }
1148
1149 static int tuner_legacy_probe(struct i2c_adapter *adap)
1150 {
1151         if (0 != addr) {
1152                 normal_i2c[0] = addr;
1153                 normal_i2c[1] = I2C_CLIENT_END;
1154         }
1155
1156         if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1157                 return 0;
1158
1159         /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1160          * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1161          * and an RTC at 0x6f which can get corrupted if probed.
1162          */
1163         if ((adap->id == I2C_HW_B_CX2388x) ||
1164             (adap->id == I2C_HW_B_CX23885)) {
1165                 unsigned int i = 0;
1166
1167                 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1168                         i += 2;
1169                 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1170                         ignore[i+0] = adap->nr;
1171                         ignore[i+1] = 0x6b;
1172                         ignore[i+2] = adap->nr;
1173                         ignore[i+3] = 0x6f;
1174                         ignore[i+4] = I2C_CLIENT_END;
1175                 } else
1176                         printk(KERN_WARNING "tuner: "
1177                                "too many options specified "
1178                                "in i2c probe ignore list!\n");
1179         }
1180         return 1;
1181 }
1182
1183 static int tuner_remove(struct i2c_client *client)
1184 {
1185         struct tuner *t = i2c_get_clientdata(client);
1186         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
1187
1188         if (ops && ops->release)
1189                 ops->release(&t->fe);
1190
1191         list_del(&t->list);
1192         kfree(t);
1193         return 0;
1194 }
1195
1196 /* ----------------------------------------------------------------------- */
1197
1198 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1199         .name = "tuner",
1200         .driverid = I2C_DRIVERID_TUNER,
1201         .command = tuner_command,
1202         .probe = tuner_probe,
1203         .remove = tuner_remove,
1204         .suspend = tuner_suspend,
1205         .resume = tuner_resume,
1206         .legacy_probe = tuner_legacy_probe,
1207 };
1208
1209
1210 /*
1211  * Overrides for Emacs so that we follow Linus's tabbing style.
1212  * ---------------------------------------------------------------------------
1213  * Local variables:
1214  * c-basic-offset: 8
1215  * End:
1216  */