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/videodev.h>
  19 #include <media/tuner.h>
  20 #include <media/tuner-types.h>
  21 #include <media/v4l2-common.h>
  22 #include "tuner-driver.h"
  23 #include "mt20xx.h"
  24 #include "tda8290.h"
  25 #include "tea5761.h"
  26 #include "tea5767.h"
  27 #include "tuner-simple.h"
  28
  29 #define UNSET (-1U)
  30
  31 /* standard i2c insmod options */
  32 static unsigned short normal_i2c[] = {
  33 #ifdef CONFIG_TUNER_TEA5761
  34         0x10,
  35 #endif
  36         0x42, 0x43, 0x4a, 0x4b,                 /* tda8290 */
  37         0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
  38         0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
  39         I2C_CLIENT_END
  40 };
  41
  42 I2C_CLIENT_INSMOD;
  43
  44 /* insmod options used at init time => read/only */
  45 static unsigned int addr = 0;
  46 static unsigned int no_autodetect = 0;
  47 static unsigned int show_i2c = 0;
  48
  49 /* insmod options used at runtime => read/write */
  50 int tuner_debug = 0;
  51
  52 static unsigned int tv_range[2] = { 44, 958 };
  53 static unsigned int radio_range[2] = { 65, 108 };
  54
  55 static char pal[] = "--";
  56 static char secam[] = "--";
  57 static char ntsc[] = "-";
  58
  59
  60 module_param(addr, int, 0444);
  61 module_param(no_autodetect, int, 0444);
  62 module_param(show_i2c, int, 0444);
  63 module_param_named(debug,tuner_debug, int, 0644);
  64 module_param_string(pal, pal, sizeof(pal), 0644);
  65 module_param_string(secam, secam, sizeof(secam), 0644);
  66 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
  67 module_param_array(tv_range, int, NULL, 0644);
  68 module_param_array(radio_range, int, NULL, 0644);
  69
  70 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
  71 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
  72 MODULE_LICENSE("GPL");
  73
  74 static struct i2c_driver driver;
  75 static struct i2c_client client_template;
  76
  77 /* ---------------------------------------------------------------------- */
  78
  79 static void fe_set_freq(struct tuner *t, unsigned int freq)
  80 {
  81         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
  82
  83         struct analog_parameters params = {
  84                 .frequency = freq,
  85                 .mode      = t->mode,
  86                 .audmode   = t->audmode,
  87                 .std       = t->std
  88         };
  89
  90         if (NULL == fe_tuner_ops->set_analog_params) {
  91                 tuner_warn("Tuner frontend module has no way to set freq\n");
  92                 return;
  93         }
  94         fe_tuner_ops->set_analog_params(&t->fe, &params);
  95 }
  96
  97 static void fe_release(struct tuner *t)
  98 {
  99         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 100
 101         if (fe_tuner_ops->release)
 102                 fe_tuner_ops->release(&t->fe);
 103 }
 104
 105 static void fe_standby(struct tuner *t)
 106 {
 107         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 108
 109         if (fe_tuner_ops->sleep)
 110                 fe_tuner_ops->sleep(&t->fe);
 111 }
 112
 113 static int fe_has_signal(struct tuner *t)
 114 {
 115         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 116         u16 strength = 0;
 117
 118         if (fe_tuner_ops->get_rf_strength)
 119                 fe_tuner_ops->get_rf_strength(&t->fe, &strength);
 120
 121         return strength;
 122 }
 123
 124 /* Set tuner frequency,  freq in Units of 62.5kHz = 1/16MHz */
 125 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
 126 {
 127         struct tuner *t = i2c_get_clientdata(c);
 128
 129         if (t->type == UNSET) {
 130                 tuner_warn ("tuner type not set\n");
 131                 return;
 132         }
 133         if (NULL == t->ops.set_tv_freq) {
 134                 tuner_warn ("Tuner has no way to set tv freq\n");
 135                 return;
 136         }
 137         if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
 138                 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
 139                            freq / 16, freq % 16 * 100 / 16, tv_range[0],
 140                            tv_range[1]);
 141                 /* V4L2 spec: if the freq is not possible then the closest
 142                    possible value should be selected */
 143                 if (freq < tv_range[0] * 16)
 144                         freq = tv_range[0] * 16;
 145                 else
 146                         freq = tv_range[1] * 16;
 147         }
 148         t->ops.set_tv_freq(t, freq);
 149 }
 150
 151 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
 152 {
 153         struct tuner *t = i2c_get_clientdata(c);
 154
 155         if (t->type == UNSET) {
 156                 tuner_warn ("tuner type not set\n");
 157                 return;
 158         }
 159         if (NULL == t->ops.set_radio_freq) {
 160                 tuner_warn ("tuner has no way to set radio frequency\n");
 161                 return;
 162         }
 163         if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
 164                 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
 165                            freq / 16000, freq % 16000 * 100 / 16000,
 166                            radio_range[0], radio_range[1]);
 167                 /* V4L2 spec: if the freq is not possible then the closest
 168                    possible value should be selected */
 169                 if (freq < radio_range[0] * 16000)
 170                         freq = radio_range[0] * 16000;
 171                 else
 172                         freq = radio_range[1] * 16000;
 173         }
 174
 175         t->ops.set_radio_freq(t, freq);
 176 }
 177
 178 static void set_freq(struct i2c_client *c, unsigned long freq)
 179 {
 180         struct tuner *t = i2c_get_clientdata(c);
 181
 182         switch (t->mode) {
 183         case V4L2_TUNER_RADIO:
 184                 tuner_dbg("radio freq set to %lu.%02lu\n",
 185                           freq / 16000, freq % 16000 * 100 / 16000);
 186                 set_radio_freq(c, freq);
 187                 t->radio_freq = freq;
 188                 break;
 189         case V4L2_TUNER_ANALOG_TV:
 190         case V4L2_TUNER_DIGITAL_TV:
 191                 tuner_dbg("tv freq set to %lu.%02lu\n",
 192                           freq / 16, freq % 16 * 100 / 16);
 193                 set_tv_freq(c, freq);
 194                 t->tv_freq = freq;
 195                 break;
 196         }
 197 }
 198
 199 static void tuner_i2c_address_check(struct tuner *t)
 200 {
 201         if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
 202             ((t->i2c.addr < 0x64) || (t->i2c.addr > 0x6f)))
 203                 return;
 204
 205         tuner_warn("====================== WARNING! ======================\n");
 206         tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
 207         tuner_warn("will soon be dropped. This message indicates that your\n");
 208         tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
 209                    t->i2c.name, t->i2c.addr);
 210         tuner_warn("To ensure continued support for your device, please\n");
 211         tuner_warn("send a copy of this message, along with full dmesg\n");
 212         tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
 213         tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
 214         tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
 215                    t->i2c.adapter->name, t->i2c.addr, t->type,
 216                    tuners[t->type].name);
 217         tuner_warn("====================== WARNING! ======================\n");
 218 }
 219
 220 static void attach_tda8290(struct tuner *t)
 221 {
 222         struct tda8290_config cfg = {
 223                 .lna_cfg        = &t->config,
 224                 .tuner_callback = t->tuner_callback
 225         };
 226         tda8290_attach(&t->fe, t->i2c.adapter, t->i2c.addr, &cfg);
 227 }
 228
 229 static void attach_simple_tuner(struct tuner *t)
 230 {
 231         struct simple_tuner_config cfg = {
 232                 .type = t->type,
 233                 .tun  = &tuners[t->type]
 234         };
 235         simple_tuner_attach(&t->fe, t->i2c.adapter, t->i2c.addr, &cfg);
 236 }
 237
 238 static void set_type(struct i2c_client *c, unsigned int type,
 239                      unsigned int new_mode_mask, unsigned int new_config,
 240                      int (*tuner_callback) (void *dev, int command,int arg))
 241 {
 242         struct tuner *t = i2c_get_clientdata(c);
 243         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 244         unsigned char buffer[4];
 245
 246         if (type == UNSET || type == TUNER_ABSENT) {
 247                 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
 248                 return;
 249         }
 250
 251         if (type >= tuner_count) {
 252                 tuner_warn ("tuner 0x%02x: Tuner count greater than %d\n",c->addr,tuner_count);
 253                 return;
 254         }
 255
 256         t->type = type;
 257         t->config = new_config;
 258         if (tuner_callback != NULL) {
 259                 tuner_dbg("defining GPIO callback\n");
 260                 t->tuner_callback = tuner_callback;
 261         }
 262
 263         /* This code detects calls by card attach_inform */
 264         if (NULL == t->i2c.dev.driver) {
 265                 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
 266
 267                 return;
 268         }
 269
 270         /* discard private data, in case set_type() was previously called */
 271         if (t->ops.release)
 272                 t->ops.release(t);
 273         else {
 274                 kfree(t->priv);
 275                 t->priv = NULL;
 276         }
 277
 278         switch (t->type) {
 279         case TUNER_MT2032:
 280                 microtune_attach(&t->fe, t->i2c.adapter, t->i2c.addr);
 281                 break;
 282         case TUNER_PHILIPS_TDA8290:
 283         {
 284                 attach_tda8290(t);
 285                 break;
 286         }
 287         case TUNER_TEA5767:
 288                 if (tea5767_attach(&t->fe, t->i2c.adapter, t->i2c.addr) == NULL) {
 289                         t->type = TUNER_ABSENT;
 290                         t->mode_mask = T_UNINITIALIZED;
 291                         return;
 292                 }
 293                 t->mode_mask = T_RADIO;
 294                 break;
 295 #ifdef CONFIG_TUNER_TEA5761
 296         case TUNER_TEA5761:
 297                 if (tea5761_attach(&t->fe, t->i2c.adapter, t->i2c.addr) == NULL) {
 298                         t->type = TUNER_ABSENT;
 299                         t->mode_mask = T_UNINITIALIZED;
 300                         return;
 301                 }
 302                 t->mode_mask = T_RADIO;
 303                 break;
 304 #endif
 305         case TUNER_PHILIPS_FMD1216ME_MK3:
 306                 buffer[0] = 0x0b;
 307                 buffer[1] = 0xdc;
 308                 buffer[2] = 0x9c;
 309                 buffer[3] = 0x60;
 310                 i2c_master_send(c, buffer, 4);
 311                 mdelay(1);
 312                 buffer[2] = 0x86;
 313                 buffer[3] = 0x54;
 314                 i2c_master_send(c, buffer, 4);
 315                 attach_simple_tuner(t);
 316                 break;
 317         case TUNER_PHILIPS_TD1316:
 318                 buffer[0] = 0x0b;
 319                 buffer[1] = 0xdc;
 320                 buffer[2] = 0x86;
 321                 buffer[3] = 0xa4;
 322                 i2c_master_send(c,buffer,4);
 323                 attach_simple_tuner(t);
 324                 break;
 325         case TUNER_TDA9887:
 326                 tda9887_tuner_init(t);
 327                 break;
 328         default:
 329                 attach_simple_tuner(t);
 330                 break;
 331         }
 332
 333         if (fe_tuner_ops->set_analog_params) {
 334                 strlcpy(t->i2c.name, fe_tuner_ops->info.name, sizeof(t->i2c.name));
 335
 336                 t->ops.set_tv_freq    = fe_set_freq;
 337                 t->ops.set_radio_freq = fe_set_freq;
 338                 t->ops.standby        = fe_standby;
 339                 t->ops.release        = fe_release;
 340                 t->ops.has_signal     = fe_has_signal;
 341         }
 342
 343         tuner_info("type set to %s\n", t->i2c.name);
 344
 345         if (t->mode_mask == T_UNINITIALIZED)
 346                 t->mode_mask = new_mode_mask;
 347
 348         set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
 349         tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
 350                   c->adapter->name, c->driver->driver.name, c->addr << 1, type,
 351                   t->mode_mask);
 352         tuner_i2c_address_check(t);
 353 }
 354
 355 /*
 356  * This function apply tuner config to tuner specified
 357  * by tun_setup structure. I addr is unset, then admin status
 358  * and tun addr status is more precise then current status,
 359  * it's applied. Otherwise status and type are applied only to
 360  * tuner with exactly the same addr.
 361 */
 362
 363 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
 364 {
 365         struct tuner *t = i2c_get_clientdata(c);
 366
 367         tuner_dbg("set addr for type %i\n", t->type);
 368
 369         if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
 370                 (t->mode_mask & tun_setup->mode_mask))) ||
 371                 (tun_setup->addr == c->addr)) {
 372                         set_type(c, tun_setup->type, tun_setup->mode_mask,
 373                                  tun_setup->config, tun_setup->tuner_callback);
 374         }
 375 }
 376
 377 static inline int check_mode(struct tuner *t, char *cmd)
 378 {
 379         if ((1 << t->mode & t->mode_mask) == 0) {
 380                 return EINVAL;
 381         }
 382
 383         switch (t->mode) {
 384         case V4L2_TUNER_RADIO:
 385                 tuner_dbg("Cmd %s accepted for radio\n", cmd);
 386                 break;
 387         case V4L2_TUNER_ANALOG_TV:
 388                 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
 389                 break;
 390         case V4L2_TUNER_DIGITAL_TV:
 391                 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
 392                 break;
 393         }
 394         return 0;
 395 }
 396
 397 /* get more precise norm info from insmod option */
 398 static int tuner_fixup_std(struct tuner *t)
 399 {
 400         if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
 401                 switch (pal[0]) {
 402                 case '6':
 403                         tuner_dbg ("insmod fixup: PAL => PAL-60\n");
 404                         t->std = V4L2_STD_PAL_60;
 405                         break;
 406                 case 'b':
 407                 case 'B':
 408                 case 'g':
 409                 case 'G':
 410                         tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
 411                         t->std = V4L2_STD_PAL_BG;
 412                         break;
 413                 case 'i':
 414                 case 'I':
 415                         tuner_dbg ("insmod fixup: PAL => PAL-I\n");
 416                         t->std = V4L2_STD_PAL_I;
 417                         break;
 418                 case 'd':
 419                 case 'D':
 420                 case 'k':
 421                 case 'K':
 422                         tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
 423                         t->std = V4L2_STD_PAL_DK;
 424                         break;
 425                 case 'M':
 426                 case 'm':
 427                         tuner_dbg ("insmod fixup: PAL => PAL-M\n");
 428                         t->std = V4L2_STD_PAL_M;
 429                         break;
 430                 case 'N':
 431                 case 'n':
 432                         if (pal[1] == 'c' || pal[1] == 'C') {
 433                                 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
 434                                 t->std = V4L2_STD_PAL_Nc;
 435                         } else {
 436                                 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
 437                                 t->std = V4L2_STD_PAL_N;
 438                         }
 439                         break;
 440                 case '-':
 441                         /* default parameter, do nothing */
 442                         break;
 443                 default:
 444                         tuner_warn ("pal= argument not recognised\n");
 445                         break;
 446                 }
 447         }
 448         if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
 449                 switch (secam[0]) {
 450                 case 'b':
 451                 case 'B':
 452                 case 'g':
 453                 case 'G':
 454                 case 'h':
 455                 case 'H':
 456                         tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
 457                         t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
 458                         break;
 459                 case 'd':
 460                 case 'D':
 461                 case 'k':
 462                 case 'K':
 463                         tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
 464                         t->std = V4L2_STD_SECAM_DK;
 465                         break;
 466                 case 'l':
 467                 case 'L':
 468                         if ((secam[1]=='C')||(secam[1]=='c')) {
 469                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
 470                                 t->std = V4L2_STD_SECAM_LC;
 471                         } else {
 472                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
 473                                 t->std = V4L2_STD_SECAM_L;
 474                         }
 475                         break;
 476                 case '-':
 477                         /* default parameter, do nothing */
 478                         break;
 479                 default:
 480                         tuner_warn ("secam= argument not recognised\n");
 481                         break;
 482                 }
 483         }
 484
 485         if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
 486                 switch (ntsc[0]) {
 487                 case 'm':
 488                 case 'M':
 489                         tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
 490                         t->std = V4L2_STD_NTSC_M;
 491                         break;
 492                 case 'j':
 493                 case 'J':
 494                         tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
 495                         t->std = V4L2_STD_NTSC_M_JP;
 496                         break;
 497                 case 'k':
 498                 case 'K':
 499                         tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
 500                         t->std = V4L2_STD_NTSC_M_KR;
 501                         break;
 502                 case '-':
 503                         /* default parameter, do nothing */
 504                         break;
 505                 default:
 506                         tuner_info("ntsc= argument not recognised\n");
 507                         break;
 508                 }
 509         }
 510         return 0;
 511 }
 512
 513 static void tuner_status(struct tuner *t)
 514 {
 515         unsigned long freq, freq_fraction;
 516         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 517         const char *p;
 518
 519         switch (t->mode) {
 520                 case V4L2_TUNER_RADIO:      p = "radio"; break;
 521                 case V4L2_TUNER_ANALOG_TV:  p = "analog TV"; break;
 522                 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
 523                 default: p = "undefined"; break;
 524         }
 525         if (t->mode == V4L2_TUNER_RADIO) {
 526                 freq = t->radio_freq / 16000;
 527                 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
 528         } else {
 529                 freq = t->tv_freq / 16;
 530                 freq_fraction = (t->tv_freq % 16) * 100 / 16;
 531         }
 532         tuner_info("Tuner mode:      %s\n", p);
 533         tuner_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
 534         tuner_info("Standard:        0x%08lx\n", (unsigned long)t->std);
 535         if (t->mode != V4L2_TUNER_RADIO)
 536                return;
 537         if (fe_tuner_ops->get_status) {
 538                 u32 tuner_status;
 539
 540                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
 541                 if (tuner_status & TUNER_STATUS_LOCKED)
 542                         tuner_info("Tuner is locked.\n");
 543                 if (tuner_status & TUNER_STATUS_STEREO)
 544                         tuner_info("Stereo:          yes\n");
 545         }
 546         if (t->ops.has_signal) {
 547                 tuner_info("Signal strength: %d\n", t->ops.has_signal(t));
 548         }
 549         if (t->ops.is_stereo) {
 550                 tuner_info("Stereo:          %s\n", t->ops.is_stereo(t) ? "yes" : "no");
 551         }
 552 }
 553
 554 /* ---------------------------------------------------------------------- */
 555
 556 /* static vars: used only in tuner_attach and tuner_probe */
 557 static unsigned default_mode_mask;
 558
 559 /* During client attach, set_type is called by adapter's attach_inform callback.
 560    set_type must then be completed by tuner_attach.
 561  */
 562 static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
 563 {
 564         struct tuner *t;
 565
 566         client_template.adapter = adap;
 567         client_template.addr = addr;
 568
 569         t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
 570         if (NULL == t)
 571                 return -ENOMEM;
 572         memcpy(&t->i2c, &client_template, sizeof(struct i2c_client));
 573         i2c_set_clientdata(&t->i2c, t);
 574         t->type = UNSET;
 575         t->audmode = V4L2_TUNER_MODE_STEREO;
 576         t->mode_mask = T_UNINITIALIZED;
 577         t->ops.tuner_status = tuner_status;
 578
 579         if (show_i2c) {
 580                 unsigned char buffer[16];
 581                 int i,rc;
 582
 583                 memset(buffer, 0, sizeof(buffer));
 584                 rc = i2c_master_recv(&t->i2c, buffer, sizeof(buffer));
 585                 tuner_info("I2C RECV = ");
 586                 for (i=0;i<rc;i++)
 587                         printk("%02x ",buffer[i]);
 588                 printk("\n");
 589         }
 590         /* HACK: This test were added to avoid tuner to probe tda9840 and tea6415c on the MXB card */
 591         if (adap->id == I2C_HW_SAA7146 && addr < 0x4a)
 592                 return -ENODEV;
 593
 594         /* autodetection code based on the i2c addr */
 595         if (!no_autodetect) {
 596                 switch (addr) {
 597 #ifdef CONFIG_TUNER_TEA5761
 598                 case 0x10:
 599                         if (tea5761_autodetection(t->i2c.adapter, t->i2c.addr) != EINVAL) {
 600                                 t->type = TUNER_TEA5761;
 601                                 t->mode_mask = T_RADIO;
 602                                 t->mode = T_STANDBY;
 603                                 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
 604                                 default_mode_mask &= ~T_RADIO;
 605
 606                                 goto register_client;
 607                         }
 608                         break;
 609 #endif
 610                 case 0x42:
 611                 case 0x43:
 612                 case 0x4a:
 613                 case 0x4b:
 614                         /* If chip is not tda8290, don't register.
 615                            since it can be tda9887*/
 616                         if (tda8290_probe(t->i2c.adapter, t->i2c.addr) == 0) {
 617                                 tuner_dbg("chip at addr %x is a tda8290\n", addr);
 618                         } else {
 619                                 /* Default is being tda9887 */
 620                                 t->type = TUNER_TDA9887;
 621                                 t->mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
 622                                 t->mode = T_STANDBY;
 623                                 goto register_client;
 624                         }
 625                         break;
 626                 case 0x60:
 627                         if (tea5767_autodetection(t->i2c.adapter, t->i2c.addr) != EINVAL) {
 628                                 t->type = TUNER_TEA5767;
 629                                 t->mode_mask = T_RADIO;
 630                                 t->mode = T_STANDBY;
 631                                 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
 632                                 default_mode_mask &= ~T_RADIO;
 633
 634                                 goto register_client;
 635                         }
 636                         break;
 637                 }
 638         }
 639
 640         /* Initializes only the first adapter found */
 641         if (default_mode_mask != T_UNINITIALIZED) {
 642                 tuner_dbg ("Setting mode_mask to 0x%02x\n", default_mode_mask);
 643                 t->mode_mask = default_mode_mask;
 644                 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
 645                 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
 646                 default_mode_mask = T_UNINITIALIZED;
 647         }
 648
 649         /* Should be just before return */
 650 register_client:
 651         tuner_info("chip found @ 0x%x (%s)\n", addr << 1, adap->name);
 652         i2c_attach_client (&t->i2c);
 653         set_type (&t->i2c,t->type, t->mode_mask, t->config, t->tuner_callback);
 654         return 0;
 655 }
 656
 657 static int tuner_probe(struct i2c_adapter *adap)
 658 {
 659         if (0 != addr) {
 660                 normal_i2c[0] = addr;
 661                 normal_i2c[1] = I2C_CLIENT_END;
 662         }
 663
 664         /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
 665          * FusionHDTV5 RT Gold has an ir receiver at 0x6b
 666          * and an RTC at 0x6f which can get corrupted if probed.
 667          */
 668         if ((adap->id == I2C_HW_B_CX2388x) ||
 669             (adap->id == I2C_HW_B_CX23885)) {
 670                 unsigned int i = 0;
 671
 672                 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
 673                         i += 2;
 674                 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
 675                         ignore[i+0] = adap->nr;
 676                         ignore[i+1] = 0x6b;
 677                         ignore[i+2] = adap->nr;
 678                         ignore[i+3] = 0x6f;
 679                         ignore[i+4] = I2C_CLIENT_END;
 680                 } else
 681                         printk(KERN_WARNING "tuner: "
 682                                "too many options specified "
 683                                "in i2c probe ignore list!\n");
 684         }
 685
 686         default_mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
 687
 688         if (adap->class & I2C_CLASS_TV_ANALOG)
 689                 return i2c_probe(adap, &addr_data, tuner_attach);
 690         return 0;
 691 }
 692
 693 static int tuner_detach(struct i2c_client *client)
 694 {
 695         struct tuner *t = i2c_get_clientdata(client);
 696         int err;
 697
 698         err = i2c_detach_client(&t->i2c);
 699         if (err) {
 700                 tuner_warn
 701                     ("Client deregistration failed, client not detached.\n");
 702                 return err;
 703         }
 704
 705         if (t->ops.release)
 706                 t->ops.release(t);
 707         else {
 708                 kfree(t->priv);
 709         }
 710         kfree(t);
 711         return 0;
 712 }
 713
 714 /*
 715  * Switch tuner to other mode. If tuner support both tv and radio,
 716  * set another frequency to some value (This is needed for some pal
 717  * tuners to avoid locking). Otherwise, just put second tuner in
 718  * standby mode.
 719  */
 720
 721 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
 722 {
 723         if (mode == t->mode)
 724                 return 0;
 725
 726         t->mode = mode;
 727
 728         if (check_mode(t, cmd) == EINVAL) {
 729                 t->mode = T_STANDBY;
 730                 if (t->ops.standby)
 731                         t->ops.standby(t);
 732                 return EINVAL;
 733         }
 734         return 0;
 735 }
 736
 737 #define switch_v4l2()   if (!t->using_v4l2) \
 738                             tuner_dbg("switching to v4l2\n"); \
 739                         t->using_v4l2 = 1;
 740
 741 static inline int check_v4l2(struct tuner *t)
 742 {
 743         /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
 744            TV, v4l1 for radio), until that is fixed this code is disabled.
 745            Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
 746            first. */
 747         return 0;
 748 }
 749
 750 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
 751 {
 752         struct tuner *t = i2c_get_clientdata(client);
 753         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 754
 755         if (tuner_debug>1)
 756                 v4l_i2c_print_ioctl(&(t->i2c),cmd);
 757
 758         switch (cmd) {
 759         /* --- configuration --- */
 760         case TUNER_SET_TYPE_ADDR:
 761                 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
 762                                 ((struct tuner_setup *)arg)->type,
 763                                 ((struct tuner_setup *)arg)->addr,
 764                                 ((struct tuner_setup *)arg)->mode_mask,
 765                                 ((struct tuner_setup *)arg)->config);
 766
 767                 set_addr(client, (struct tuner_setup *)arg);
 768                 break;
 769         case AUDC_SET_RADIO:
 770                 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
 771                                 == EINVAL)
 772                         return 0;
 773                 if (t->radio_freq)
 774                         set_freq(client, t->radio_freq);
 775                 break;
 776         case TUNER_SET_STANDBY:
 777                 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
 778                         return 0;
 779                 t->mode = T_STANDBY;
 780                 if (t->ops.standby)
 781                         t->ops.standby(t);
 782                 break;
 783 #ifdef CONFIG_VIDEO_V4L1
 784         case VIDIOCSAUDIO:
 785                 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
 786                         return 0;
 787                 if (check_v4l2(t) == EINVAL)
 788                         return 0;
 789
 790                 /* Should be implemented, since bttv calls it */
 791                 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
 792                 break;
 793         case VIDIOCSCHAN:
 794                 {
 795                         static const v4l2_std_id map[] = {
 796                                 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
 797                                 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
 798                                 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
 799                                 [4 /* bttv */ ] = V4L2_STD_PAL_M,
 800                                 [5 /* bttv */ ] = V4L2_STD_PAL_N,
 801                                 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
 802                         };
 803                         struct video_channel *vc = arg;
 804
 805                         if (check_v4l2(t) == EINVAL)
 806                                 return 0;
 807
 808                         if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
 809                                 return 0;
 810
 811                         if (vc->norm < ARRAY_SIZE(map))
 812                                 t->std = map[vc->norm];
 813                         tuner_fixup_std(t);
 814                         if (t->tv_freq)
 815                                 set_tv_freq(client, t->tv_freq);
 816                         return 0;
 817                 }
 818         case VIDIOCSFREQ:
 819                 {
 820                         unsigned long *v = arg;
 821
 822                         if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
 823                                 return 0;
 824                         if (check_v4l2(t) == EINVAL)
 825                                 return 0;
 826
 827                         set_freq(client, *v);
 828                         return 0;
 829                 }
 830         case VIDIOCGTUNER:
 831                 {
 832                         struct video_tuner *vt = arg;
 833
 834                         if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
 835                                 return 0;
 836                         if (check_v4l2(t) == EINVAL)
 837                                 return 0;
 838
 839                         if (V4L2_TUNER_RADIO == t->mode) {
 840                                 if (fe_tuner_ops->get_status) {
 841                                         u32 tuner_status;
 842
 843                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 844                                         if (tuner_status & TUNER_STATUS_STEREO)
 845                                                 vt->flags |= VIDEO_TUNER_STEREO_ON;
 846                                         else
 847                                                 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
 848                                 } else {
 849                                         if (t->ops.is_stereo) {
 850                                                 if (t->ops.is_stereo(t))
 851                                                         vt->flags |=
 852                                                                 VIDEO_TUNER_STEREO_ON;
 853                                                 else
 854                                                         vt->flags &=
 855                                                                 ~VIDEO_TUNER_STEREO_ON;
 856                                         }
 857                                 }
 858                                 if (t->ops.has_signal)
 859                                         vt->signal = t->ops.has_signal(t);
 860
 861                                 vt->flags |= VIDEO_TUNER_LOW;   /* Allow freqs at 62.5 Hz */
 862
 863                                 vt->rangelow = radio_range[0] * 16000;
 864                                 vt->rangehigh = radio_range[1] * 16000;
 865
 866                         } else {
 867                                 vt->rangelow = tv_range[0] * 16;
 868                                 vt->rangehigh = tv_range[1] * 16;
 869                         }
 870
 871                         return 0;
 872                 }
 873         case VIDIOCGAUDIO:
 874                 {
 875                         struct video_audio *va = arg;
 876
 877                         if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
 878                                 return 0;
 879                         if (check_v4l2(t) == EINVAL)
 880                                 return 0;
 881
 882                         if (V4L2_TUNER_RADIO == t->mode) {
 883                                 if (fe_tuner_ops->get_status) {
 884                                         u32 tuner_status;
 885
 886                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 887                                         va->mode = (tuner_status & TUNER_STATUS_STEREO)
 888                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 889                                 } else if (t->ops.is_stereo)
 890                                         va->mode = t->ops.is_stereo(t)
 891                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 892                         }
 893                         return 0;
 894                 }
 895 #endif
 896         case TDA9887_SET_CONFIG:
 897                 if (t->type == TUNER_TDA9887) {
 898                         int *i = arg;
 899
 900                         t->tda9887_config = *i;
 901                         set_freq(client, t->tv_freq);
 902                 }
 903                 break;
 904         /* --- v4l ioctls --- */
 905         /* take care: bttv does userspace copying, we'll get a
 906            kernel pointer here... */
 907         case VIDIOC_S_STD:
 908                 {
 909                         v4l2_std_id *id = arg;
 910
 911                         if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
 912                                         == EINVAL)
 913                                 return 0;
 914
 915                         switch_v4l2();
 916
 917                         t->std = *id;
 918                         tuner_fixup_std(t);
 919                         if (t->tv_freq)
 920                                 set_freq(client, t->tv_freq);
 921                         break;
 922                 }
 923         case VIDIOC_S_FREQUENCY:
 924                 {
 925                         struct v4l2_frequency *f = arg;
 926
 927                         if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
 928                                         == EINVAL)
 929                                 return 0;
 930                         switch_v4l2();
 931                         set_freq(client,f->frequency);
 932
 933                         break;
 934                 }
 935         case VIDIOC_G_FREQUENCY:
 936                 {
 937                         struct v4l2_frequency *f = arg;
 938
 939                         if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
 940                                 return 0;
 941                         switch_v4l2();
 942                         f->type = t->mode;
 943                         if (fe_tuner_ops->get_frequency) {
 944                                 u32 abs_freq;
 945
 946                                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
 947                                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 948                                         (abs_freq * 2 + 125/2) / 125 :
 949                                         (abs_freq + 62500/2) / 62500;
 950                                 break;
 951                         }
 952                         f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 953                                 t->radio_freq : t->tv_freq;
 954                         break;
 955                 }
 956         case VIDIOC_G_TUNER:
 957                 {
 958                         struct v4l2_tuner *tuner = arg;
 959
 960                         if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
 961                                 return 0;
 962                         switch_v4l2();
 963
 964                         tuner->type = t->mode;
 965                         if (t->ops.get_afc)
 966                                 tuner->afc=t->ops.get_afc(t);
 967                         if (t->mode == V4L2_TUNER_ANALOG_TV)
 968                                 tuner->capability |= V4L2_TUNER_CAP_NORM;
 969                         if (t->mode != V4L2_TUNER_RADIO) {
 970                                 tuner->rangelow = tv_range[0] * 16;
 971                                 tuner->rangehigh = tv_range[1] * 16;
 972                                 break;
 973                         }
 974
 975                         /* radio mode */
 976                         tuner->rxsubchans =
 977                                 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
 978                         if (fe_tuner_ops->get_status) {
 979                                 u32 tuner_status;
 980
 981                                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
 982                                 tuner->rxsubchans = (tuner_status & TUNER_STATUS_STEREO) ?
 983                                         V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
 984                         } else {
 985                                 if (t->ops.is_stereo) {
 986                                         tuner->rxsubchans = t->ops.is_stereo(t) ?
 987                                                 V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
 988                                 }
 989                         }
 990                         if (t->ops.has_signal)
 991                                 tuner->signal = t->ops.has_signal(t);
 992                         tuner->capability |=
 993                             V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
 994                         tuner->audmode = t->audmode;
 995                         tuner->rangelow = radio_range[0] * 16000;
 996                         tuner->rangehigh = radio_range[1] * 16000;
 997                         break;
 998                 }
 999         case VIDIOC_S_TUNER:
1000                 {
1001                         struct v4l2_tuner *tuner = arg;
1002
1003                         if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
1004                                 return 0;
1005
1006                         switch_v4l2();
1007
1008                         /* do nothing unless we're a radio tuner */
1009                         if (t->mode != V4L2_TUNER_RADIO)
1010                                 break;
1011                         t->audmode = tuner->audmode;
1012                         set_radio_freq(client, t->radio_freq);
1013                         break;
1014                 }
1015         case VIDIOC_LOG_STATUS:
1016                 if (t->ops.tuner_status)
1017                         t->ops.tuner_status(t);
1018                 break;
1019         }
1020
1021         return 0;
1022 }
1023
1024 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1025 {
1026         struct tuner *t = i2c_get_clientdata (c);
1027
1028         tuner_dbg ("suspend\n");
1029         /* FIXME: power down ??? */
1030         return 0;
1031 }
1032
1033 static int tuner_resume(struct i2c_client *c)
1034 {
1035         struct tuner *t = i2c_get_clientdata (c);
1036
1037         tuner_dbg ("resume\n");
1038         if (V4L2_TUNER_RADIO == t->mode) {
1039                 if (t->radio_freq)
1040                         set_freq(c, t->radio_freq);
1041         } else {
1042                 if (t->tv_freq)
1043                         set_freq(c, t->tv_freq);
1044         }
1045         return 0;
1046 }
1047
1048 /* ----------------------------------------------------------------------- */
1049
1050 static struct i2c_driver driver = {
1051         .id = I2C_DRIVERID_TUNER,
1052         .attach_adapter = tuner_probe,
1053         .detach_client = tuner_detach,
1054         .command = tuner_command,
1055         .suspend = tuner_suspend,
1056         .resume  = tuner_resume,
1057         .driver = {
1058                 .name    = "tuner",
1059         },
1060 };
1061 static struct i2c_client client_template = {
1062         .name = "(tuner unset)",
1063         .driver = &driver,
1064 };
1065
1066 static int __init tuner_init_module(void)
1067 {
1068         return i2c_add_driver(&driver);
1069 }
1070
1071 static void __exit tuner_cleanup_module(void)
1072 {
1073         i2c_del_driver(&driver);
1074 }
1075
1076 module_init(tuner_init_module);
1077 module_exit(tuner_cleanup_module);
1078
1079 /*
1080  * Overrides for Emacs so that we follow Linus's tabbing style.
1081  * ---------------------------------------------------------------------------
1082  * Local variables:
1083  * c-basic-offset: 8
1084  * End:
1085  */