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