drivers/media/video/tuner-core.c

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