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