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