git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/tuner-core.c

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