err.no Git - linux-2.6/blob - drivers/media/video/tuner-core.c

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