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