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