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