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 #include "tda18271.h"
  33
  34 #define UNSET (-1U)
  35
  36 #define PREFIX t->i2c->driver->driver.name
  37
  38 /** This macro allows us to probe dynamically, avoiding static links */
  39 #ifdef CONFIG_MEDIA_ATTACH
  40 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
  41         int __r = -EINVAL; \
  42         typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
  43         if (__a) { \
  44                 __r = (int) __a(ARGS); \
  45                 symbol_put(FUNCTION); \
  46         } else { \
  47                 printk(KERN_ERR "TUNER: Unable to find " \
  48                                 "symbol "#FUNCTION"()\n"); \
  49         } \
  50         __r; \
  51 })
  52
  53 static void tuner_detach(struct dvb_frontend *fe)
  54 {
  55         if (fe->ops.tuner_ops.release) {
  56                 fe->ops.tuner_ops.release(fe);
  57                 symbol_put_addr(fe->ops.tuner_ops.release);
  58         }
  59         if (fe->ops.analog_ops.release) {
  60                 fe->ops.analog_ops.release(fe);
  61                 symbol_put_addr(fe->ops.analog_ops.release);
  62         }
  63 }
  64 #else
  65 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
  66         FUNCTION(ARGS); \
  67 })
  68
  69 static void tuner_detach(struct dvb_frontend *fe)
  70 {
  71         if (fe->ops.tuner_ops.release)
  72                 fe->ops.tuner_ops.release(fe);
  73         if (fe->ops.analog_ops.release)
  74                 fe->ops.analog_ops.release(fe);
  75 }
  76 #endif
  77
  78 struct tuner {
  79         /* device */
  80         struct dvb_frontend fe;
  81         struct i2c_client   *i2c;
  82         struct v4l2_subdev  sd;
  83         struct list_head    list;
  84         unsigned int        using_v4l2:1;
  85
  86         /* keep track of the current settings */
  87         v4l2_std_id         std;
  88         unsigned int        tv_freq;
  89         unsigned int        radio_freq;
  90         unsigned int        audmode;
  91
  92         unsigned int        mode;
  93         unsigned int        mode_mask; /* Combination of allowable modes */
  94
  95         unsigned int        type; /* chip type id */
  96         unsigned int        config;
  97         const char          *name;
  98 };
  99
 100 static inline struct tuner *to_tuner(struct v4l2_subdev *sd)
 101 {
 102         return container_of(sd, struct tuner, sd);
 103 }
 104
 105
 106 /* insmod options used at init time => read/only */
 107 static unsigned int addr;
 108 static unsigned int no_autodetect;
 109 static unsigned int show_i2c;
 110
 111 /* insmod options used at runtime => read/write */
 112 static int tuner_debug;
 113
 114 #define tuner_warn(fmt, arg...) do {                    \
 115         printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
 116                i2c_adapter_id(t->i2c->adapter),         \
 117                t->i2c->addr, ##arg);                    \
 118          } while (0)
 119
 120 #define tuner_info(fmt, arg...) do {                    \
 121         printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX,    \
 122                i2c_adapter_id(t->i2c->adapter),         \
 123                t->i2c->addr, ##arg);                    \
 124          } while (0)
 125
 126 #define tuner_err(fmt, arg...) do {                     \
 127         printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX,     \
 128                i2c_adapter_id(t->i2c->adapter),         \
 129                t->i2c->addr, ##arg);                    \
 130          } while (0)
 131
 132 #define tuner_dbg(fmt, arg...) do {                             \
 133         if (tuner_debug)                                        \
 134                 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX,   \
 135                        i2c_adapter_id(t->i2c->adapter),         \
 136                        t->i2c->addr, ##arg);                    \
 137          } while (0)
 138
 139 /* ------------------------------------------------------------------------ */
 140
 141 static unsigned int tv_range[2] = { 44, 958 };
 142 static unsigned int radio_range[2] = { 65, 108 };
 143
 144 static char pal[] = "--";
 145 static char secam[] = "--";
 146 static char ntsc[] = "-";
 147
 148
 149 module_param(addr, int, 0444);
 150 module_param(no_autodetect, int, 0444);
 151 module_param(show_i2c, int, 0444);
 152 module_param_named(debug,tuner_debug, int, 0644);
 153 module_param_string(pal, pal, sizeof(pal), 0644);
 154 module_param_string(secam, secam, sizeof(secam), 0644);
 155 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
 156 module_param_array(tv_range, int, NULL, 0644);
 157 module_param_array(radio_range, int, NULL, 0644);
 158
 159 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
 160 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
 161 MODULE_LICENSE("GPL");
 162
 163 /* ---------------------------------------------------------------------- */
 164
 165 static void fe_set_params(struct dvb_frontend *fe,
 166                           struct analog_parameters *params)
 167 {
 168         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 169         struct tuner *t = fe->analog_demod_priv;
 170
 171         if (NULL == fe_tuner_ops->set_analog_params) {
 172                 tuner_warn("Tuner frontend module has no way to set freq\n");
 173                 return;
 174         }
 175         fe_tuner_ops->set_analog_params(fe, params);
 176 }
 177
 178 static void fe_standby(struct dvb_frontend *fe)
 179 {
 180         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 181
 182         if (fe_tuner_ops->sleep)
 183                 fe_tuner_ops->sleep(fe);
 184 }
 185
 186 static int fe_has_signal(struct dvb_frontend *fe)
 187 {
 188         u16 strength = 0;
 189
 190         if (fe->ops.tuner_ops.get_rf_strength)
 191                 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
 192
 193         return strength;
 194 }
 195
 196 static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
 197 {
 198         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 199         struct tuner *t = fe->analog_demod_priv;
 200
 201         if (fe_tuner_ops->set_config)
 202                 return fe_tuner_ops->set_config(fe, priv_cfg);
 203
 204         tuner_warn("Tuner frontend module has no way to set config\n");
 205
 206         return 0;
 207 }
 208
 209 static void tuner_status(struct dvb_frontend *fe);
 210
 211 static struct analog_demod_ops tuner_analog_ops = {
 212         .set_params     = fe_set_params,
 213         .standby        = fe_standby,
 214         .has_signal     = fe_has_signal,
 215         .set_config     = fe_set_config,
 216         .tuner_status   = tuner_status
 217 };
 218
 219 /* Set tuner frequency,  freq in Units of 62.5kHz = 1/16MHz */
 220 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
 221 {
 222         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 223         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 224
 225         struct analog_parameters params = {
 226                 .mode      = t->mode,
 227                 .audmode   = t->audmode,
 228                 .std       = t->std
 229         };
 230
 231         if (t->type == UNSET) {
 232                 tuner_warn ("tuner type not set\n");
 233                 return;
 234         }
 235         if (NULL == analog_ops->set_params) {
 236                 tuner_warn ("Tuner has no way to set tv freq\n");
 237                 return;
 238         }
 239         if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
 240                 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
 241                            freq / 16, freq % 16 * 100 / 16, tv_range[0],
 242                            tv_range[1]);
 243                 /* V4L2 spec: if the freq is not possible then the closest
 244                    possible value should be selected */
 245                 if (freq < tv_range[0] * 16)
 246                         freq = tv_range[0] * 16;
 247                 else
 248                         freq = tv_range[1] * 16;
 249         }
 250         params.frequency = freq;
 251
 252         analog_ops->set_params(&t->fe, &params);
 253 }
 254
 255 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
 256 {
 257         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 258         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 259
 260         struct analog_parameters params = {
 261                 .mode      = t->mode,
 262                 .audmode   = t->audmode,
 263                 .std       = t->std
 264         };
 265
 266         if (t->type == UNSET) {
 267                 tuner_warn ("tuner type not set\n");
 268                 return;
 269         }
 270         if (NULL == analog_ops->set_params) {
 271                 tuner_warn ("tuner has no way to set radio frequency\n");
 272                 return;
 273         }
 274         if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
 275                 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
 276                            freq / 16000, freq % 16000 * 100 / 16000,
 277                            radio_range[0], radio_range[1]);
 278                 /* V4L2 spec: if the freq is not possible then the closest
 279                    possible value should be selected */
 280                 if (freq < radio_range[0] * 16000)
 281                         freq = radio_range[0] * 16000;
 282                 else
 283                         freq = radio_range[1] * 16000;
 284         }
 285         params.frequency = freq;
 286
 287         analog_ops->set_params(&t->fe, &params);
 288 }
 289
 290 static void set_freq(struct i2c_client *c, unsigned long freq)
 291 {
 292         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 293
 294         switch (t->mode) {
 295         case V4L2_TUNER_RADIO:
 296                 tuner_dbg("radio freq set to %lu.%02lu\n",
 297                           freq / 16000, freq % 16000 * 100 / 16000);
 298                 set_radio_freq(c, freq);
 299                 t->radio_freq = freq;
 300                 break;
 301         case V4L2_TUNER_ANALOG_TV:
 302         case V4L2_TUNER_DIGITAL_TV:
 303                 tuner_dbg("tv freq set to %lu.%02lu\n",
 304                           freq / 16, freq % 16 * 100 / 16);
 305                 set_tv_freq(c, freq);
 306                 t->tv_freq = freq;
 307                 break;
 308         default:
 309                 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
 310         }
 311 }
 312
 313 static struct xc5000_config xc5000_cfg;
 314
 315 static void set_type(struct i2c_client *c, unsigned int type,
 316                      unsigned int new_mode_mask, unsigned int new_config,
 317                      int (*tuner_callback) (void *dev, int component, int cmd, int arg))
 318 {
 319         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 320         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 321         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 322         unsigned char buffer[4];
 323         int tune_now = 1;
 324
 325         if (type == UNSET || type == TUNER_ABSENT) {
 326                 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
 327                 return;
 328         }
 329
 330         t->type = type;
 331         /* prevent invalid config values */
 332         t->config = new_config < 256 ? new_config : 0;
 333         if (tuner_callback != NULL) {
 334                 tuner_dbg("defining GPIO callback\n");
 335                 t->fe.callback = tuner_callback;
 336         }
 337
 338         if (t->mode == T_UNINITIALIZED) {
 339                 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
 340
 341                 return;
 342         }
 343
 344         /* discard private data, in case set_type() was previously called */
 345         tuner_detach(&t->fe);
 346         t->fe.analog_demod_priv = NULL;
 347
 348         switch (t->type) {
 349         case TUNER_MT2032:
 350                 if (!dvb_attach(microtune_attach,
 351                            &t->fe, t->i2c->adapter, t->i2c->addr))
 352                         goto attach_failed;
 353                 break;
 354         case TUNER_PHILIPS_TDA8290:
 355         {
 356                 struct tda829x_config cfg = {
 357                         .lna_cfg        = t->config,
 358                 };
 359                 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
 360                                 t->i2c->addr, &cfg))
 361                         goto attach_failed;
 362                 break;
 363         }
 364         case TUNER_TEA5767:
 365                 if (!dvb_attach(tea5767_attach, &t->fe,
 366                                 t->i2c->adapter, t->i2c->addr))
 367                         goto attach_failed;
 368                 t->mode_mask = T_RADIO;
 369                 break;
 370         case TUNER_TEA5761:
 371                 if (!dvb_attach(tea5761_attach, &t->fe,
 372                                 t->i2c->adapter, t->i2c->addr))
 373                         goto attach_failed;
 374                 t->mode_mask = T_RADIO;
 375                 break;
 376         case TUNER_PHILIPS_FMD1216ME_MK3:
 377                 buffer[0] = 0x0b;
 378                 buffer[1] = 0xdc;
 379                 buffer[2] = 0x9c;
 380                 buffer[3] = 0x60;
 381                 i2c_master_send(c, buffer, 4);
 382                 mdelay(1);
 383                 buffer[2] = 0x86;
 384                 buffer[3] = 0x54;
 385                 i2c_master_send(c, buffer, 4);
 386                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 387                                 t->i2c->adapter, t->i2c->addr, t->type))
 388                         goto attach_failed;
 389                 break;
 390         case TUNER_PHILIPS_TD1316:
 391                 buffer[0] = 0x0b;
 392                 buffer[1] = 0xdc;
 393                 buffer[2] = 0x86;
 394                 buffer[3] = 0xa4;
 395                 i2c_master_send(c, buffer, 4);
 396                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 397                                 t->i2c->adapter, t->i2c->addr, t->type))
 398                         goto attach_failed;
 399                 break;
 400         case TUNER_XC2028:
 401         {
 402                 struct xc2028_config cfg = {
 403                         .i2c_adap  = t->i2c->adapter,
 404                         .i2c_addr  = t->i2c->addr,
 405                 };
 406                 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
 407                         goto attach_failed;
 408                 tune_now = 0;
 409                 break;
 410         }
 411         case TUNER_TDA9887:
 412                 if (!dvb_attach(tda9887_attach,
 413                            &t->fe, t->i2c->adapter, t->i2c->addr))
 414                         goto attach_failed;
 415                 break;
 416         case TUNER_XC5000:
 417         {
 418                 xc5000_cfg.i2c_address    = t->i2c->addr;
 419                 /* if_khz will be set when the digital dvb_attach() occurs */
 420                 xc5000_cfg.if_khz         = 0;
 421                 if (!dvb_attach(xc5000_attach,
 422                                 &t->fe, t->i2c->adapter, &xc5000_cfg))
 423                         goto attach_failed;
 424                 tune_now = 0;
 425                 break;
 426         }
 427         case TUNER_NXP_TDA18271:
 428         {
 429                 struct tda18271_config cfg = {
 430                         .config = t->config,
 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         /* HACK: This test was added to avoid tuner to probe tda9840 and
1057            tea6415c on the MXB card */
1058         if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1059                 kfree(t);
1060                 return -ENODEV;
1061         }
1062
1063         /* autodetection code based on the i2c addr */
1064         if (!no_autodetect) {
1065                 switch (client->addr) {
1066                 case 0x10:
1067                         if (tuner_symbol_probe(tea5761_autodetection,
1068                                                t->i2c->adapter,
1069                                                t->i2c->addr) >= 0) {
1070                                 t->type = TUNER_TEA5761;
1071                                 t->mode_mask = T_RADIO;
1072                                 t->mode = T_STANDBY;
1073                                 /* Sets freq to FM range */
1074                                 t->radio_freq = 87.5 * 16000;
1075                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1076                                 if (tv)
1077                                         tv->mode_mask &= ~T_RADIO;
1078
1079                                 goto register_client;
1080                         }
1081                         return -ENODEV;
1082                 case 0x42:
1083                 case 0x43:
1084                 case 0x4a:
1085                 case 0x4b:
1086                         /* If chip is not tda8290, don't register.
1087                            since it can be tda9887*/
1088                         if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
1089                                                t->i2c->addr) >= 0) {
1090                                 tuner_dbg("tda829x detected\n");
1091                         } else {
1092                                 /* Default is being tda9887 */
1093                                 t->type = TUNER_TDA9887;
1094                                 t->mode_mask = T_RADIO | T_ANALOG_TV |
1095                                                T_DIGITAL_TV;
1096                                 t->mode = T_STANDBY;
1097                                 goto register_client;
1098                         }
1099                         break;
1100                 case 0x60:
1101                         if (tuner_symbol_probe(tea5767_autodetection,
1102                                                t->i2c->adapter, t->i2c->addr)
1103                                         >= 0) {
1104                                 t->type = TUNER_TEA5767;
1105                                 t->mode_mask = T_RADIO;
1106                                 t->mode = T_STANDBY;
1107                                 /* Sets freq to FM range */
1108                                 t->radio_freq = 87.5 * 16000;
1109                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1110                                 if (tv)
1111                                         tv->mode_mask &= ~T_RADIO;
1112
1113                                 goto register_client;
1114                         }
1115                         break;
1116                 }
1117         }
1118
1119         /* Initializes only the first TV tuner on this adapter. Why only the
1120            first? Because there are some devices (notably the ones with TI
1121            tuners) that have more than one i2c address for the *same* device.
1122            Experience shows that, except for just one case, the first
1123            address is the right one. The exception is a Russian tuner
1124            (ACORP_Y878F). So, the desired behavior is just to enable the
1125            first found TV tuner. */
1126         tuner_lookup(t->i2c->adapter, &radio, &tv);
1127         if (tv == NULL) {
1128                 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1129                 if (radio == NULL)
1130                         t->mode_mask |= T_RADIO;
1131                 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1132                 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1133                 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1134         }
1135
1136         /* Should be just before return */
1137 register_client:
1138         tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1139                        client->adapter->name);
1140
1141         /* Sets a default mode */
1142         if (t->mode_mask & T_ANALOG_TV) {
1143                 t->mode = V4L2_TUNER_ANALOG_TV;
1144         } else  if (t->mode_mask & T_RADIO) {
1145                 t->mode = V4L2_TUNER_RADIO;
1146         } else {
1147                 t->mode = V4L2_TUNER_DIGITAL_TV;
1148         }
1149         set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
1150         list_add_tail(&t->list, &tuner_list);
1151         return 0;
1152 }
1153
1154 static int tuner_remove(struct i2c_client *client)
1155 {
1156         struct tuner *t = to_tuner(i2c_get_clientdata(client));
1157
1158         v4l2_device_unregister_subdev(&t->sd);
1159         tuner_detach(&t->fe);
1160         t->fe.analog_demod_priv = NULL;
1161
1162         list_del(&t->list);
1163         kfree(t);
1164         return 0;
1165 }
1166
1167 /* ----------------------------------------------------------------------- */
1168
1169 /* This driver supports many devices and the idea is to let the driver
1170    detect which device is present. So rather than listing all supported
1171    devices here, we pretend to support a single, fake device type. */
1172 static const struct i2c_device_id tuner_id[] = {
1173         { "tuner", }, /* autodetect */
1174         { }
1175 };
1176 MODULE_DEVICE_TABLE(i2c, tuner_id);
1177
1178 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1179         .name = "tuner",
1180         .probe = tuner_probe,
1181         .remove = tuner_remove,
1182         .command = tuner_command,
1183         .suspend = tuner_suspend,
1184         .resume = tuner_resume,
1185         .id_table = tuner_id,
1186 };
1187
1188 /*
1189  * Overrides for Emacs so that we follow Linus's tabbing style.
1190  * ---------------------------------------------------------------------------
1191  * Local variables:
1192  * c-basic-offset: 8
1193  * End:
1194  */