git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/tuner-core.c

   1 /*
   2  * $Id: tuner-core.c,v 1.63 2005/07/28 18:19:55 mchehab Exp $
   3  *
   4  * i2c tv tuner chip device driver
   5  * core core, i.e. kernel interfaces, registering and so on
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/moduleparam.h>
  10 #include <linux/kernel.h>
  11 #include <linux/sched.h>
  12 #include <linux/string.h>
  13 #include <linux/timer.h>
  14 #include <linux/delay.h>
  15 #include <linux/errno.h>
  16 #include <linux/slab.h>
  17 #include <linux/poll.h>
  18 #include <linux/i2c.h>
  19 #include <linux/types.h>
  20 #include <linux/videodev.h>
  21 #include <linux/init.h>
  22
  23 #include <media/tuner.h>
  24 #include <media/audiochip.h>
  25
  26 #include "msp3400.h"
  27
  28 #define UNSET (-1U)
  29
  30 /* standard i2c insmod options */
  31 static unsigned short normal_i2c[] = {
  32         0x4b,                   /* tda8290 */
  33         0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
  34         0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
  35         I2C_CLIENT_END
  36 };
  37
  38 I2C_CLIENT_INSMOD;
  39
  40 /* insmod options used at init time => read/only */
  41 static unsigned int addr = 0;
  42 module_param(addr, int, 0444);
  43
  44 static unsigned int no_autodetect = 0;
  45 module_param(no_autodetect, int, 0444);
  46
  47 static unsigned int show_i2c = 0;
  48 module_param(show_i2c, int, 0444);
  49
  50 /* insmod options used at runtime => read/write */
  51 unsigned int tuner_debug = 0;
  52 module_param(tuner_debug, int, 0644);
  53
  54 static unsigned int tv_range[2] = { 44, 958 };
  55 static unsigned int radio_range[2] = { 65, 108 };
  56
  57 module_param_array(tv_range, int, NULL, 0644);
  58 module_param_array(radio_range, int, NULL, 0644);
  59
  60 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
  61 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
  62 MODULE_LICENSE("GPL");
  63
  64 static struct i2c_driver driver;
  65 static struct i2c_client client_template;
  66
  67 /* ---------------------------------------------------------------------- */
  68
  69 /* Set tuner frequency,  freq in Units of 62.5kHz = 1/16MHz */
  70 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
  71 {
  72         struct tuner *t = i2c_get_clientdata(c);
  73
  74         if (t->type == UNSET) {
  75                 tuner_warn ("tuner type not set\n");
  76                 return;
  77         }
  78         if (NULL == t->tv_freq) {
  79                 tuner_warn ("Tuner has no way to set tv freq\n");
  80                 return;
  81         }
  82         if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
  83                 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
  84                            freq / 16, freq % 16 * 100 / 16, tv_range[0],
  85                            tv_range[1]);
  86         }
  87         t->tv_freq(c, freq);
  88 }
  89
  90 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
  91 {
  92         struct tuner *t = i2c_get_clientdata(c);
  93
  94         if (t->type == UNSET) {
  95                 tuner_warn ("tuner type not set\n");
  96                 return;
  97         }
  98         if (NULL == t->radio_freq) {
  99                 tuner_warn ("tuner has no way to set radio frequency\n");
 100                 return;
 101         }
 102         if (freq <= radio_range[0] * 16000 || freq >= radio_range[1] * 16000) {
 103                 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
 104                            freq / 16000, freq % 16000 * 100 / 16000,
 105                            radio_range[0], radio_range[1]);
 106         }
 107
 108         t->radio_freq(c, freq);
 109         return;
 110 }
 111
 112 static void set_freq(struct i2c_client *c, unsigned long freq)
 113 {
 114         struct tuner *t = i2c_get_clientdata(c);
 115
 116         switch (t->mode) {
 117         case V4L2_TUNER_RADIO:
 118                 tuner_dbg("radio freq set to %lu.%02lu\n",
 119                           freq / 16000, freq % 16000 * 100 / 16000);
 120                 set_radio_freq(c, freq);
 121                 break;
 122         case V4L2_TUNER_ANALOG_TV:
 123         case V4L2_TUNER_DIGITAL_TV:
 124                 tuner_dbg("tv freq set to %lu.%02lu\n",
 125                           freq / 16, freq % 16 * 100 / 16);
 126                 set_tv_freq(c, freq);
 127                 break;
 128         }
 129         t->freq = freq;
 130 }
 131
 132 static void set_type(struct i2c_client *c, unsigned int type,
 133                      unsigned int new_mode_mask)
 134 {
 135         struct tuner *t = i2c_get_clientdata(c);
 136         unsigned char buffer[4];
 137
 138         if (type == UNSET || type == TUNER_ABSENT) {
 139                 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
 140                 return;
 141         }
 142
 143         if (type >= tuner_count) {
 144                 tuner_warn ("tuner 0x%02x: Tuner count greater than %d\n",c->addr,tuner_count);
 145                 return;
 146         }
 147
 148         /* This code detects calls by card attach_inform */
 149         if (NULL == t->i2c.dev.driver) {
 150                 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
 151
 152                 t->type=type;
 153                 return;
 154         }
 155
 156         t->type = type;
 157
 158         switch (t->type) {
 159         case TUNER_MT2032:
 160                 microtune_init(c);
 161                 break;
 162         case TUNER_PHILIPS_TDA8290:
 163                 tda8290_init(c);
 164                 break;
 165         case TUNER_TEA5767:
 166                 if (tea5767_tuner_init(c) == EINVAL) {
 167                         t->type = TUNER_ABSENT;
 168                         t->mode_mask = T_UNINITIALIZED;
 169                         return;
 170                 }
 171                 t->mode_mask = T_RADIO;
 172                 break;
 173         case TUNER_PHILIPS_FMD1216ME_MK3:
 174                 buffer[0] = 0x0b;
 175                 buffer[1] = 0xdc;
 176                 buffer[2] = 0x9c;
 177                 buffer[3] = 0x60;
 178                 i2c_master_send(c, buffer, 4);
 179                 mdelay(1);
 180                 buffer[2] = 0x86;
 181                 buffer[3] = 0x54;
 182                 i2c_master_send(c, buffer, 4);
 183                 default_tuner_init(c);
 184                 break;
 185         default:
 186                 default_tuner_init(c);
 187                 break;
 188         }
 189
 190         if (t->mode_mask == T_UNINITIALIZED)
 191                 t->mode_mask = new_mode_mask;
 192
 193         set_freq(c, t->freq);
 194         tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
 195                   c->adapter->name, c->driver->name, c->addr << 1, type,
 196                   t->mode_mask);
 197 }
 198
 199 /*
 200  * This function apply tuner config to tuner specified
 201  * by tun_setup structure. I addr is unset, then admin status
 202  * and tun addr status is more precise then current status,
 203  * it's applied. Otherwise status and type are applied only to
 204  * tuner with exactly the same addr.
 205 */
 206
 207 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
 208 {
 209         struct tuner *t = i2c_get_clientdata(c);
 210
 211         if (tun_setup->addr == ADDR_UNSET) {
 212                 if (t->mode_mask & tun_setup->mode_mask)
 213                         set_type(c, tun_setup->type, tun_setup->mode_mask);
 214         } else if (tun_setup->addr == c->addr) {
 215                 set_type(c, tun_setup->type, tun_setup->mode_mask);
 216         }
 217 }
 218
 219 static inline int check_mode(struct tuner *t, char *cmd)
 220 {
 221         if (1 << t->mode & t->mode_mask) {
 222                 switch (t->mode) {
 223                 case V4L2_TUNER_RADIO:
 224                         tuner_dbg("Cmd %s accepted for radio\n", cmd);
 225                         break;
 226                 case V4L2_TUNER_ANALOG_TV:
 227                         tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
 228                         break;
 229                 case V4L2_TUNER_DIGITAL_TV:
 230                         tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
 231                         break;
 232                 }
 233                 return 0;
 234         }
 235         return EINVAL;
 236 }
 237
 238 static char pal[] = "-";
 239 module_param_string(pal, pal, sizeof(pal), 0644);
 240 static char secam[] = "-";
 241 module_param_string(secam, secam, sizeof(secam), 0644);
 242
 243 /* get more precise norm info from insmod option */
 244 static int tuner_fixup_std(struct tuner *t)
 245 {
 246         if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
 247                 switch (pal[0]) {
 248                 case 'b':
 249                 case 'B':
 250                 case 'g':
 251                 case 'G':
 252                         tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
 253                         t->std = V4L2_STD_PAL_BG;
 254                         break;
 255                 case 'i':
 256                 case 'I':
 257                         tuner_dbg ("insmod fixup: PAL => PAL-I\n");
 258                         t->std = V4L2_STD_PAL_I;
 259                         break;
 260                 case 'd':
 261                 case 'D':
 262                 case 'k':
 263                 case 'K':
 264                         tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
 265                         t->std = V4L2_STD_PAL_DK;
 266                         break;
 267                 case 'M':
 268                 case 'm':
 269                         tuner_dbg ("insmod fixup: PAL => PAL-M\n");
 270                         t->std = V4L2_STD_PAL_M;
 271                         break;
 272                 case 'N':
 273                 case 'n':
 274                         tuner_dbg ("insmod fixup: PAL => PAL-N\n");
 275                         t->std = V4L2_STD_PAL_N;
 276                         break;
 277                 }
 278         }
 279         if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
 280                 switch (secam[0]) {
 281                 case 'd':
 282                 case 'D':
 283                 case 'k':
 284                 case 'K':
 285                         tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
 286                         t->std = V4L2_STD_SECAM_DK;
 287                         break;
 288                 case 'l':
 289                 case 'L':
 290                         tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
 291                         t->std = V4L2_STD_SECAM_L;
 292                         break;
 293                 }
 294         }
 295
 296         return 0;
 297 }
 298
 299 /* ---------------------------------------------------------------------- */
 300
 301 /* static var Used only in tuner_attach and tuner_probe */
 302 static unsigned default_mode_mask;
 303
 304 /* During client attach, set_type is called by adapter's attach_inform callback.
 305    set_type must then be completed by tuner_attach.
 306  */
 307 static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
 308 {
 309         struct tuner *t;
 310
 311         client_template.adapter = adap;
 312         client_template.addr = addr;
 313
 314         t = kmalloc(sizeof(struct tuner), GFP_KERNEL);
 315         if (NULL == t)
 316                 return -ENOMEM;
 317         memset(t, 0, sizeof(struct tuner));
 318         memcpy(&t->i2c, &client_template, sizeof(struct i2c_client));
 319         i2c_set_clientdata(&t->i2c, t);
 320         t->type = UNSET;
 321         t->radio_if2 = 10700 * 1000;    /* 10.7MHz - FM radio */
 322         t->audmode = V4L2_TUNER_MODE_STEREO;
 323         t->mode_mask = T_UNINITIALIZED;
 324
 325
 326         tuner_info("chip found @ 0x%x (%s)\n", addr << 1, adap->name);
 327
 328         if (show_i2c) {
 329                 unsigned char buffer[16];
 330                 int i,rc;
 331
 332                 memset(buffer, 0, sizeof(buffer));
 333                 rc = i2c_master_recv(&t->i2c, buffer, sizeof(buffer));
 334                 printk("tuner-%04x I2C RECV = ",addr);
 335                 for (i=0;i<rc;i++)
 336                         printk("%02x ",buffer[i]);
 337                 printk("\n");
 338         }
 339         /* TEA5767 autodetection code - only for addr = 0xc0 */
 340         if (!no_autodetect) {
 341                 if (addr == 0x60) {
 342                         if (tea5767_autodetection(&t->i2c) != EINVAL) {
 343                                 t->type = TUNER_TEA5767;
 344                                 t->mode_mask = T_RADIO;
 345                                 t->mode = T_STANDBY;
 346                                 t->freq = 87.5 * 16; /* Sets freq to FM range */
 347                                 default_mode_mask &= ~T_RADIO;
 348
 349                                 i2c_attach_client (&t->i2c);
 350                                 set_type(&t->i2c,t->type, t->mode_mask);
 351                                 return 0;
 352                         }
 353                 }
 354         }
 355
 356         /* Initializes only the first adapter found */
 357         if (default_mode_mask != T_UNINITIALIZED) {
 358                 tuner_dbg ("Setting mode_mask to 0x%02x\n", default_mode_mask);
 359                 t->mode_mask = default_mode_mask;
 360                 t->freq = 400 * 16; /* Sets freq to VHF High */
 361                 default_mode_mask = T_UNINITIALIZED;
 362         }
 363
 364         /* Should be just before return */
 365         i2c_attach_client (&t->i2c);
 366         set_type (&t->i2c,t->type, t->mode_mask);
 367         return 0;
 368 }
 369
 370 static int tuner_probe(struct i2c_adapter *adap)
 371 {
 372         if (0 != addr) {
 373                 normal_i2c[0] = addr;
 374                 normal_i2c[1] = I2C_CLIENT_END;
 375         }
 376
 377         default_mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
 378
 379         if (adap->class & I2C_CLASS_TV_ANALOG)
 380                 return i2c_probe(adap, &addr_data, tuner_attach);
 381         return 0;
 382 }
 383
 384 static int tuner_detach(struct i2c_client *client)
 385 {
 386         struct tuner *t = i2c_get_clientdata(client);
 387         int err;
 388
 389         err = i2c_detach_client(&t->i2c);
 390         if (err) {
 391                 tuner_warn
 392                     ("Client deregistration failed, client not detached.\n");
 393                 return err;
 394         }
 395
 396         kfree(t);
 397         return 0;
 398 }
 399
 400 /*
 401  * Switch tuner to other mode. If tuner support both tv and radio,
 402  * set another frequency to some value (This is needed for some pal
 403  * tuners to avoid locking). Otherwise, just put second tuner in
 404  * standby mode.
 405  */
 406
 407 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
 408 {
 409         if (mode != t->mode) {
 410
 411                 t->mode = mode;
 412                 if (check_mode(t, cmd) == EINVAL) {
 413                         t->mode = T_STANDBY;
 414                         if (V4L2_TUNER_RADIO == mode) {
 415                                 set_tv_freq(client, 400 * 16);
 416                         } else {
 417                                 set_radio_freq(client, 87.5 * 16000);
 418                         }
 419                         return EINVAL;
 420                 }
 421         }
 422         return 0;
 423 }
 424
 425 #define switch_v4l2()   if (!t->using_v4l2) \
 426                             tuner_dbg("switching to v4l2\n"); \
 427                         t->using_v4l2 = 1;
 428
 429 static inline int check_v4l2(struct tuner *t)
 430 {
 431         if (t->using_v4l2) {
 432                 tuner_dbg ("ignore v4l1 call\n");
 433                 return EINVAL;
 434         }
 435         return 0;
 436 }
 437
 438 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
 439 {
 440         struct tuner *t = i2c_get_clientdata(client);
 441         unsigned int *iarg = (int *)arg;
 442
 443         switch (cmd) {
 444         /* --- configuration --- */
 445         case TUNER_SET_TYPE_ADDR:
 446                 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x\n",
 447                                 ((struct tuner_setup *)arg)->type,
 448                                 ((struct tuner_setup *)arg)->addr,
 449                                 ((struct tuner_setup *)arg)->mode_mask);
 450
 451                 set_addr(client, (struct tuner_setup *)arg);
 452                 break;
 453         case AUDC_SET_RADIO:
 454                 set_mode(client,t,V4L2_TUNER_RADIO, "AUDC_SET_RADIO");
 455                 break;
 456         case AUDC_CONFIG_PINNACLE:
 457                 if (check_mode(t, "AUDC_CONFIG_PINNACLE") == EINVAL)
 458                         return 0;
 459                 switch (*iarg) {
 460                 case 2:
 461                         tuner_dbg("pinnacle pal\n");
 462                         t->radio_if2 = 33300 * 1000;
 463                         break;
 464                 case 3:
 465                         tuner_dbg("pinnacle ntsc\n");
 466                         t->radio_if2 = 41300 * 1000;
 467                         break;
 468                 }
 469                 break;
 470         case VIDIOCSAUDIO:
 471                 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
 472                         return 0;
 473                 if (check_v4l2(t) == EINVAL)
 474                         return 0;
 475
 476                 /* Should be implemented, since bttv calls it */
 477                 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
 478
 479                 break;
 480         case MSP_SET_MATRIX:
 481         case TDA9887_SET_CONFIG:
 482                 break;
 483         /* --- v4l ioctls --- */
 484         /* take care: bttv does userspace copying, we'll get a
 485            kernel pointer here... */
 486         case VIDIOCSCHAN:
 487                 {
 488                         static const v4l2_std_id map[] = {
 489                                 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
 490                                 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
 491                                 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
 492                                 [4 /* bttv */ ] = V4L2_STD_PAL_M,
 493                                 [5 /* bttv */ ] = V4L2_STD_PAL_N,
 494                                 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
 495                         };
 496                         struct video_channel *vc = arg;
 497
 498                         if (check_v4l2(t) == EINVAL)
 499                                 return 0;
 500
 501                         if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
 502                                 return 0;
 503
 504                         if (vc->norm < ARRAY_SIZE(map))
 505                                 t->std = map[vc->norm];
 506                         tuner_fixup_std(t);
 507                         if (t->freq)
 508                                 set_tv_freq(client, t->freq);
 509                         return 0;
 510                 }
 511         case VIDIOCSFREQ:
 512                 {
 513                         unsigned long *v = arg;
 514
 515                         if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
 516                                 return 0;
 517                         if (check_v4l2(t) == EINVAL)
 518                                 return 0;
 519
 520                         set_freq(client, *v);
 521                         return 0;
 522                 }
 523         case VIDIOCGTUNER:
 524                 {
 525                         struct video_tuner *vt = arg;
 526
 527                         if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
 528                                 return 0;
 529                         if (check_v4l2(t) == EINVAL)
 530                                 return 0;
 531
 532                         if (V4L2_TUNER_RADIO == t->mode) {
 533                                 if (t->has_signal)
 534                                         vt->signal = t->has_signal(client);
 535                                 if (t->is_stereo) {
 536                                         if (t->is_stereo(client))
 537                                                 vt->flags |=
 538                                                     VIDEO_TUNER_STEREO_ON;
 539                                         else
 540                                                 vt->flags &=
 541                                                     ~VIDEO_TUNER_STEREO_ON;
 542                                 }
 543                                 vt->flags |= VIDEO_TUNER_LOW;   /* Allow freqs at 62.5 Hz */
 544
 545                                 vt->rangelow = radio_range[0] * 16000;
 546                                 vt->rangehigh = radio_range[1] * 16000;
 547
 548                         } else {
 549                                 vt->rangelow = tv_range[0] * 16;
 550                                 vt->rangehigh = tv_range[1] * 16;
 551                         }
 552
 553                         return 0;
 554                 }
 555         case VIDIOCGAUDIO:
 556                 {
 557                         struct video_audio *va = arg;
 558
 559                         if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
 560                                 return 0;
 561                         if (check_v4l2(t) == EINVAL)
 562                                 return 0;
 563
 564                         if (V4L2_TUNER_RADIO == t->mode && t->is_stereo)
 565                                 va->mode = t->is_stereo(client)
 566                                     ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 567                         return 0;
 568                 }
 569
 570         case VIDIOC_S_STD:
 571                 {
 572                         v4l2_std_id *id = arg;
 573
 574                         if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
 575                                         == EINVAL)
 576                                 return 0;
 577
 578                         switch_v4l2();
 579
 580                         t->std = *id;
 581                         tuner_fixup_std(t);
 582                         if (t->freq)
 583                                 set_freq(client, t->freq);
 584                         break;
 585                 }
 586         case VIDIOC_S_FREQUENCY:
 587                 {
 588                         struct v4l2_frequency *f = arg;
 589
 590                         t->freq = f->frequency;
 591                         switch_v4l2();
 592                         if (V4L2_TUNER_RADIO == f->type &&
 593                             V4L2_TUNER_RADIO != t->mode) {
 594                                 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
 595                                             == EINVAL)
 596                                         return 0;
 597                         }
 598                         set_freq(client,t->freq);
 599
 600                         break;
 601                 }
 602         case VIDIOC_G_FREQUENCY:
 603                 {
 604                         struct v4l2_frequency *f = arg;
 605
 606                         if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
 607                                 return 0;
 608                         switch_v4l2();
 609                         f->type = t->mode;
 610                         f->frequency = t->freq;
 611                         break;
 612                 }
 613         case VIDIOC_G_TUNER:
 614                 {
 615                         struct v4l2_tuner *tuner = arg;
 616
 617                         if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
 618                                 return 0;
 619                         switch_v4l2();
 620
 621                         if (V4L2_TUNER_RADIO == t->mode) {
 622
 623                                 if (t->has_signal)
 624                                         tuner->signal = t->has_signal(client);
 625
 626                                 if (t->is_stereo) {
 627                                         if (t->is_stereo(client)) {
 628                                                 tuner->rxsubchans =
 629                                                     V4L2_TUNER_SUB_STEREO |
 630                                                     V4L2_TUNER_SUB_MONO;
 631                                         } else {
 632                                                 tuner->rxsubchans =
 633                                                     V4L2_TUNER_SUB_MONO;
 634                                         }
 635                                 }
 636
 637                                 tuner->capability |=
 638                                     V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
 639
 640                                 tuner->audmode = t->audmode;
 641
 642                                 tuner->rangelow = radio_range[0] * 16000;
 643                                 tuner->rangehigh = radio_range[1] * 16000;
 644                         } else {
 645                                 tuner->rangelow = tv_range[0] * 16;
 646                                 tuner->rangehigh = tv_range[1] * 16;
 647                         }
 648                         break;
 649                 }
 650         case VIDIOC_S_TUNER:
 651                 {
 652                         struct v4l2_tuner *tuner = arg;
 653
 654                         if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
 655                                 return 0;
 656
 657                         switch_v4l2();
 658
 659                         if (V4L2_TUNER_RADIO == t->mode) {
 660                                 t->audmode = tuner->audmode;
 661                                 set_radio_freq(client, t->freq);
 662                         }
 663                         break;
 664                 }
 665         default:
 666                 tuner_dbg("Unimplemented IOCTL 0x%08x(dir=%d,tp=0x%02x,nr=%d,sz=%d)\n",
 667                                          cmd, _IOC_DIR(cmd), _IOC_TYPE(cmd),
 668                                         _IOC_NR(cmd), _IOC_SIZE(cmd));
 669                 break;
 670         }
 671
 672         return 0;
 673 }
 674
 675 static int tuner_suspend(struct device *dev, u32 state, u32 level)
 676 {
 677         struct i2c_client *c = container_of (dev, struct i2c_client, dev);
 678         struct tuner *t = i2c_get_clientdata (c);
 679
 680         tuner_dbg ("suspend\n");
 681         /* FIXME: power down ??? */
 682         return 0;
 683 }
 684
 685 static int tuner_resume(struct device *dev, u32 level)
 686 {
 687         struct i2c_client *c = container_of (dev, struct i2c_client, dev);
 688         struct tuner *t = i2c_get_clientdata (c);
 689
 690         tuner_dbg ("resume\n");
 691         if (t->freq)
 692                 set_freq(c, t->freq);
 693         return 0;
 694 }
 695
 696 /* ----------------------------------------------------------------------- */
 697
 698 static struct i2c_driver driver = {
 699         .owner = THIS_MODULE,
 700         .name = "tuner",
 701         .id = I2C_DRIVERID_TUNER,
 702         .flags = I2C_DF_NOTIFY,
 703         .attach_adapter = tuner_probe,
 704         .detach_client = tuner_detach,
 705         .command = tuner_command,
 706         .driver = {
 707                    .suspend = tuner_suspend,
 708                    .resume = tuner_resume,
 709                    },
 710 };
 711 static struct i2c_client client_template = {
 712         I2C_DEVNAME("(tuner unset)"),
 713         .flags = I2C_CLIENT_ALLOW_USE,
 714         .driver = &driver,
 715 };
 716
 717 static int __init tuner_init_module(void)
 718 {
 719         return i2c_add_driver(&driver);
 720 }
 721
 722 static void __exit tuner_cleanup_module(void)
 723 {
 724         i2c_del_driver(&driver);
 725 }
 726
 727 module_init(tuner_init_module);
 728 module_exit(tuner_cleanup_module);
 729
 730 /*
 731  * Overrides for Emacs so that we follow Linus's tabbing style.
 732  * ---------------------------------------------------------------------------
 733  * Local variables:
 734  * c-basic-offset: 8
 735  * End:
 736  */