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