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