drivers/media/radio/radio-cadet.c

   1 /* radio-cadet.c - A video4linux driver for the ADS Cadet AM/FM Radio Card
   2  *
   3  * by Fred Gleason <fredg@wava.com>
   4  * Version 0.3.3
   5  *
   6  * (Loosely) based on code for the Aztech radio card by
   7  *
   8  * Russell Kroll    (rkroll@exploits.org)
   9  * Quay Ly
  10  * Donald Song
  11  * Jason Lewis      (jlewis@twilight.vtc.vsc.edu)
  12  * Scott McGrath    (smcgrath@twilight.vtc.vsc.edu)
  13  * William McGrath  (wmcgrath@twilight.vtc.vsc.edu)
  14  *
  15  * History:
  16  * 2000-04-29   Russell Kroll <rkroll@exploits.org>
  17  *              Added ISAPnP detection for Linux 2.3/2.4
  18  *
  19  * 2001-01-10   Russell Kroll <rkroll@exploits.org>
  20  *              Removed dead CONFIG_RADIO_CADET_PORT code
  21  *              PnP detection on load is now default (no args necessary)
  22  *
  23  * 2002-01-17   Adam Belay <ambx1@neo.rr.com>
  24  *              Updated to latest pnp code
  25  *
  26  * 2003-01-31   Alan Cox <alan@redhat.com>
  27  *              Cleaned up locking, delay code, general odds and ends
  28  *
  29  * 2006-07-30   Hans J. Koch <koch@hjk-az.de>
  30  *              Changed API to V4L2
  31  */
  32
  33 #include <linux/version.h>
  34 #include <linux/module.h>       /* Modules                      */
  35 #include <linux/init.h>         /* Initdata                     */
  36 #include <linux/ioport.h>       /* request_region               */
  37 #include <linux/delay.h>        /* udelay                       */
  38 #include <asm/io.h>             /* outb, outb_p                 */
  39 #include <asm/uaccess.h>        /* copy to/from user            */
  40 #include <linux/videodev2.h>    /* V4L2 API defs                */
  41 #include <media/v4l2-common.h>
  42 #include <media/v4l2-ioctl.h>
  43 #include <linux/param.h>
  44 #include <linux/pnp.h>
  45
  46 #define RDS_BUFFER 256
  47 #define RDS_RX_FLAG 1
  48 #define MBS_RX_FLAG 2
  49
  50 #define CADET_VERSION KERNEL_VERSION(0,3,3)
  51
  52 static struct v4l2_queryctrl radio_qctrl[] = {
  53         {
  54                 .id            = V4L2_CID_AUDIO_MUTE,
  55                 .name          = "Mute",
  56                 .minimum       = 0,
  57                 .maximum       = 1,
  58                 .default_value = 1,
  59                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
  60         },{
  61                 .id            = V4L2_CID_AUDIO_VOLUME,
  62                 .name          = "Volume",
  63                 .minimum       = 0,
  64                 .maximum       = 0xff,
  65                 .step          = 1,
  66                 .default_value = 0xff,
  67                 .type          = V4L2_CTRL_TYPE_INTEGER,
  68         }
  69 };
  70
  71 static int io=-1;               /* default to isapnp activation */
  72 static int radio_nr = -1;
  73 static int users;
  74 static int curtuner;
  75 static int tunestat;
  76 static int sigstrength;
  77 static wait_queue_head_t read_queue;
  78 static struct timer_list readtimer;
  79 static __u8 rdsin, rdsout, rdsstat;
  80 static unsigned char rdsbuf[RDS_BUFFER];
  81 static spinlock_t cadet_io_lock;
  82
  83 static int cadet_probe(void);
  84
  85 /*
  86  * Signal Strength Threshold Values
  87  * The V4L API spec does not define any particular unit for the signal
  88  * strength value.  These values are in microvolts of RF at the tuner's input.
  89  */
  90 static __u16 sigtable[2][4]={{5,10,30,150},{28,40,63,1000}};
  91
  92
  93 static int
  94 cadet_getstereo(void)
  95 {
  96         int ret = V4L2_TUNER_SUB_MONO;
  97         if(curtuner != 0)       /* Only FM has stereo capability! */
  98                 return V4L2_TUNER_SUB_MONO;
  99
 100         spin_lock(&cadet_io_lock);
 101         outb(7,io);          /* Select tuner control */
 102         if( (inb(io+1) & 0x40) == 0)
 103                 ret = V4L2_TUNER_SUB_STEREO;
 104         spin_unlock(&cadet_io_lock);
 105         return ret;
 106 }
 107
 108 static unsigned
 109 cadet_gettune(void)
 110 {
 111         int curvol,i;
 112         unsigned fifo=0;
 113
 114         /*
 115          * Prepare for read
 116          */
 117
 118         spin_lock(&cadet_io_lock);
 119
 120         outb(7,io);       /* Select tuner control */
 121         curvol=inb(io+1); /* Save current volume/mute setting */
 122         outb(0x00,io+1);  /* Ensure WRITE-ENABLE is LOW */
 123         tunestat=0xffff;
 124
 125         /*
 126          * Read the shift register
 127          */
 128         for(i=0;i<25;i++) {
 129                 fifo=(fifo<<1)|((inb(io+1)>>7)&0x01);
 130                 if(i<24) {
 131                         outb(0x01,io+1);
 132                         tunestat&=inb(io+1);
 133                         outb(0x00,io+1);
 134                 }
 135         }
 136
 137         /*
 138          * Restore volume/mute setting
 139          */
 140         outb(curvol,io+1);
 141         spin_unlock(&cadet_io_lock);
 142
 143         return fifo;
 144 }
 145
 146 static unsigned
 147 cadet_getfreq(void)
 148 {
 149         int i;
 150         unsigned freq=0,test,fifo=0;
 151
 152         /*
 153          * Read current tuning
 154          */
 155         fifo=cadet_gettune();
 156
 157         /*
 158          * Convert to actual frequency
 159          */
 160         if(curtuner==0) {    /* FM */
 161                 test=12500;
 162                 for(i=0;i<14;i++) {
 163                         if((fifo&0x01)!=0) {
 164                                 freq+=test;
 165                         }
 166                         test=test<<1;
 167                         fifo=fifo>>1;
 168                 }
 169                 freq-=10700000;           /* IF frequency is 10.7 MHz */
 170                 freq=(freq*16)/1000000;   /* Make it 1/16 MHz */
 171         }
 172         if(curtuner==1) {    /* AM */
 173                 freq=((fifo&0x7fff)-2010)*16;
 174         }
 175
 176         return freq;
 177 }
 178
 179 static void
 180 cadet_settune(unsigned fifo)
 181 {
 182         int i;
 183         unsigned test;
 184
 185         spin_lock(&cadet_io_lock);
 186
 187         outb(7,io);                /* Select tuner control */
 188         /*
 189          * Write the shift register
 190          */
 191         test=0;
 192         test=(fifo>>23)&0x02;      /* Align data for SDO */
 193         test|=0x1c;                /* SDM=1, SWE=1, SEN=1, SCK=0 */
 194         outb(7,io);                /* Select tuner control */
 195         outb(test,io+1);           /* Initialize for write */
 196         for(i=0;i<25;i++) {
 197                 test|=0x01;              /* Toggle SCK High */
 198                 outb(test,io+1);
 199                 test&=0xfe;              /* Toggle SCK Low */
 200                 outb(test,io+1);
 201                 fifo=fifo<<1;            /* Prepare the next bit */
 202                 test=0x1c|((fifo>>23)&0x02);
 203                 outb(test,io+1);
 204         }
 205         spin_unlock(&cadet_io_lock);
 206 }
 207
 208 static void
 209 cadet_setfreq(unsigned freq)
 210 {
 211         unsigned fifo;
 212         int i,j,test;
 213         int curvol;
 214
 215         /*
 216          * Formulate a fifo command
 217          */
 218         fifo=0;
 219         if(curtuner==0) {    /* FM */
 220                 test=102400;
 221                 freq=(freq*1000)/16;       /* Make it kHz */
 222                 freq+=10700;               /* IF is 10700 kHz */
 223                 for(i=0;i<14;i++) {
 224                         fifo=fifo<<1;
 225                         if(freq>=test) {
 226                                 fifo|=0x01;
 227                                 freq-=test;
 228                         }
 229                         test=test>>1;
 230                 }
 231         }
 232         if(curtuner==1) {    /* AM */
 233                 fifo=(freq/16)+2010;            /* Make it kHz */
 234                 fifo|=0x100000;            /* Select AM Band */
 235         }
 236
 237         /*
 238          * Save current volume/mute setting
 239          */
 240
 241         spin_lock(&cadet_io_lock);
 242         outb(7,io);                /* Select tuner control */
 243         curvol=inb(io+1);
 244         spin_unlock(&cadet_io_lock);
 245
 246         /*
 247          * Tune the card
 248          */
 249         for(j=3;j>-1;j--) {
 250                 cadet_settune(fifo|(j<<16));
 251
 252                 spin_lock(&cadet_io_lock);
 253                 outb(7,io);         /* Select tuner control */
 254                 outb(curvol,io+1);
 255                 spin_unlock(&cadet_io_lock);
 256
 257                 msleep(100);
 258
 259                 cadet_gettune();
 260                 if((tunestat & 0x40) == 0) {   /* Tuned */
 261                         sigstrength=sigtable[curtuner][j];
 262                         return;
 263                 }
 264         }
 265         sigstrength=0;
 266 }
 267
 268
 269 static int
 270 cadet_getvol(void)
 271 {
 272         int ret = 0;
 273
 274         spin_lock(&cadet_io_lock);
 275
 276         outb(7,io);                /* Select tuner control */
 277         if((inb(io + 1) & 0x20) != 0)
 278                 ret = 0xffff;
 279
 280         spin_unlock(&cadet_io_lock);
 281         return ret;
 282 }
 283
 284
 285 static void
 286 cadet_setvol(int vol)
 287 {
 288         spin_lock(&cadet_io_lock);
 289         outb(7,io);                /* Select tuner control */
 290         if(vol>0)
 291                 outb(0x20,io+1);
 292         else
 293                 outb(0x00,io+1);
 294         spin_unlock(&cadet_io_lock);
 295 }
 296
 297 static void
 298 cadet_handler(unsigned long data)
 299 {
 300         /*
 301          * Service the RDS fifo
 302          */
 303
 304         if(spin_trylock(&cadet_io_lock))
 305         {
 306                 outb(0x3,io);       /* Select RDS Decoder Control */
 307                 if((inb(io+1)&0x20)!=0) {
 308                         printk(KERN_CRIT "cadet: RDS fifo overflow\n");
 309                 }
 310                 outb(0x80,io);      /* Select RDS fifo */
 311                 while((inb(io)&0x80)!=0) {
 312                         rdsbuf[rdsin]=inb(io+1);
 313                         if(rdsin==rdsout)
 314                                 printk(KERN_WARNING "cadet: RDS buffer overflow\n");
 315                         else
 316                                 rdsin++;
 317                 }
 318                 spin_unlock(&cadet_io_lock);
 319         }
 320
 321         /*
 322          * Service pending read
 323          */
 324         if( rdsin!=rdsout)
 325                 wake_up_interruptible(&read_queue);
 326
 327         /*
 328          * Clean up and exit
 329          */
 330         init_timer(&readtimer);
 331         readtimer.function=cadet_handler;
 332         readtimer.data=(unsigned long)0;
 333         readtimer.expires=jiffies+msecs_to_jiffies(50);
 334         add_timer(&readtimer);
 335 }
 336
 337
 338
 339 static ssize_t
 340 cadet_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
 341 {
 342         int i=0;
 343         unsigned char readbuf[RDS_BUFFER];
 344
 345         if(rdsstat==0) {
 346                 spin_lock(&cadet_io_lock);
 347                 rdsstat=1;
 348                 outb(0x80,io);        /* Select RDS fifo */
 349                 spin_unlock(&cadet_io_lock);
 350                 init_timer(&readtimer);
 351                 readtimer.function=cadet_handler;
 352                 readtimer.data=(unsigned long)0;
 353                 readtimer.expires=jiffies+msecs_to_jiffies(50);
 354                 add_timer(&readtimer);
 355         }
 356         if(rdsin==rdsout) {
 357                 if (file->f_flags & O_NONBLOCK)
 358                         return -EWOULDBLOCK;
 359                 interruptible_sleep_on(&read_queue);
 360         }
 361         while( i<count && rdsin!=rdsout)
 362                 readbuf[i++]=rdsbuf[rdsout++];
 363
 364         if (copy_to_user(data,readbuf,i))
 365                 return -EFAULT;
 366         return i;
 367 }
 368
 369
 370 static int vidioc_querycap(struct file *file, void *priv,
 371                                 struct v4l2_capability *v)
 372 {
 373         v->capabilities =
 374                 V4L2_CAP_TUNER |
 375                 V4L2_CAP_READWRITE;
 376         v->version = CADET_VERSION;
 377         strcpy(v->driver, "ADS Cadet");
 378         strcpy(v->card, "ADS Cadet");
 379         return 0;
 380 }
 381
 382 static int vidioc_g_tuner(struct file *file, void *priv,
 383                                 struct v4l2_tuner *v)
 384 {
 385         v->type = V4L2_TUNER_RADIO;
 386         switch (v->index) {
 387         case 0:
 388                 strcpy(v->name, "FM");
 389                 v->capability = V4L2_TUNER_CAP_STEREO;
 390                 v->rangelow = 1400;     /* 87.5 MHz */
 391                 v->rangehigh = 1728;    /* 108.0 MHz */
 392                 v->rxsubchans=cadet_getstereo();
 393                 switch (v->rxsubchans){
 394                 case V4L2_TUNER_SUB_MONO:
 395                         v->audmode = V4L2_TUNER_MODE_MONO;
 396                         break;
 397                 case V4L2_TUNER_SUB_STEREO:
 398                         v->audmode = V4L2_TUNER_MODE_STEREO;
 399                         break;
 400                 default: ;
 401                 }
 402                 break;
 403         case 1:
 404                 strcpy(v->name, "AM");
 405                 v->capability = V4L2_TUNER_CAP_LOW;
 406                 v->rangelow = 8320;      /* 520 kHz */
 407                 v->rangehigh = 26400;    /* 1650 kHz */
 408                 v->rxsubchans = V4L2_TUNER_SUB_MONO;
 409                 v->audmode = V4L2_TUNER_MODE_MONO;
 410                 break;
 411         default:
 412                 return -EINVAL;
 413         }
 414         v->signal = sigstrength; /* We might need to modify scaling of this */
 415         return 0;
 416 }
 417
 418 static int vidioc_s_tuner(struct file *file, void *priv,
 419                                 struct v4l2_tuner *v)
 420 {
 421         if((v->index != 0)&&(v->index != 1))
 422                 return -EINVAL;
 423         curtuner = v->index;
 424         return 0;
 425 }
 426
 427 static int vidioc_g_frequency(struct file *file, void *priv,
 428                                 struct v4l2_frequency *f)
 429 {
 430         f->tuner = curtuner;
 431         f->type = V4L2_TUNER_RADIO;
 432         f->frequency = cadet_getfreq();
 433         return 0;
 434 }
 435
 436
 437 static int vidioc_s_frequency(struct file *file, void *priv,
 438                                 struct v4l2_frequency *f)
 439 {
 440         if (f->type != V4L2_TUNER_RADIO)
 441                 return -EINVAL;
 442         if((curtuner==0)&&((f->frequency<1400)||(f->frequency>1728)))
 443                 return -EINVAL;
 444         if((curtuner==1)&&((f->frequency<8320)||(f->frequency>26400)))
 445                 return -EINVAL;
 446         cadet_setfreq(f->frequency);
 447         return 0;
 448 }
 449
 450 static int vidioc_queryctrl(struct file *file, void *priv,
 451                                 struct v4l2_queryctrl *qc)
 452 {
 453         int i;
 454
 455         for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
 456                 if (qc->id && qc->id == radio_qctrl[i].id) {
 457                         memcpy(qc, &(radio_qctrl[i]),
 458                                                 sizeof(*qc));
 459                         return 0;
 460                 }
 461         }
 462         return -EINVAL;
 463 }
 464
 465 static int vidioc_g_ctrl(struct file *file, void *priv,
 466                                 struct v4l2_control *ctrl)
 467 {
 468         switch (ctrl->id){
 469         case V4L2_CID_AUDIO_MUTE: /* TODO: Handle this correctly */
 470                 ctrl->value = (cadet_getvol() == 0);
 471                 break;
 472         case V4L2_CID_AUDIO_VOLUME:
 473                 ctrl->value = cadet_getvol();
 474                 break;
 475         default:
 476                 return -EINVAL;
 477         }
 478         return 0;
 479 }
 480
 481 static int vidioc_s_ctrl(struct file *file, void *priv,
 482                                 struct v4l2_control *ctrl)
 483 {
 484         switch (ctrl->id){
 485         case V4L2_CID_AUDIO_MUTE: /* TODO: Handle this correctly */
 486                 if (ctrl->value)
 487                         cadet_setvol(0);
 488                 else
 489                         cadet_setvol(0xffff);
 490                 break;
 491         case V4L2_CID_AUDIO_VOLUME:
 492                 cadet_setvol(ctrl->value);
 493                 break;
 494         default:
 495                 return -EINVAL;
 496         }
 497         return 0;
 498 }
 499
 500 static int vidioc_g_audio(struct file *file, void *priv,
 501                                 struct v4l2_audio *a)
 502 {
 503         if (a->index > 1)
 504                 return -EINVAL;
 505         strcpy(a->name, "Radio");
 506         a->capability = V4L2_AUDCAP_STEREO;
 507         return 0;
 508 }
 509
 510 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
 511 {
 512         *i = 0;
 513         return 0;
 514 }
 515
 516 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
 517 {
 518         if (i != 0)
 519                 return -EINVAL;
 520         return 0;
 521 }
 522
 523 static int vidioc_s_audio(struct file *file, void *priv,
 524                                 struct v4l2_audio *a)
 525 {
 526         if (a->index != 0)
 527                 return -EINVAL;
 528         return 0;
 529 }
 530
 531 static int
 532 cadet_open(struct inode *inode, struct file *file)
 533 {
 534         users++;
 535         if (1 == users) init_waitqueue_head(&read_queue);
 536         return 0;
 537 }
 538
 539 static int
 540 cadet_release(struct inode *inode, struct file *file)
 541 {
 542         users--;
 543         if (0 == users){
 544                 del_timer_sync(&readtimer);
 545                 rdsstat=0;
 546         }
 547         return 0;
 548 }
 549
 550 static unsigned int
 551 cadet_poll(struct file *file, struct poll_table_struct *wait)
 552 {
 553         poll_wait(file,&read_queue,wait);
 554         if(rdsin != rdsout)
 555                 return POLLIN | POLLRDNORM;
 556         return 0;
 557 }
 558
 559
 560 static const struct file_operations cadet_fops = {
 561         .owner          = THIS_MODULE,
 562         .open           = cadet_open,
 563         .release        = cadet_release,
 564         .read           = cadet_read,
 565         .ioctl          = video_ioctl2,
 566         .poll           = cadet_poll,
 567 #ifdef CONFIG_COMPAT
 568         .compat_ioctl   = v4l_compat_ioctl32,
 569 #endif
 570         .llseek         = no_llseek,
 571 };
 572
 573 static const struct v4l2_ioctl_ops cadet_ioctl_ops = {
 574         .vidioc_querycap    = vidioc_querycap,
 575         .vidioc_g_tuner     = vidioc_g_tuner,
 576         .vidioc_s_tuner     = vidioc_s_tuner,
 577         .vidioc_g_frequency = vidioc_g_frequency,
 578         .vidioc_s_frequency = vidioc_s_frequency,
 579         .vidioc_queryctrl   = vidioc_queryctrl,
 580         .vidioc_g_ctrl      = vidioc_g_ctrl,
 581         .vidioc_s_ctrl      = vidioc_s_ctrl,
 582         .vidioc_g_audio     = vidioc_g_audio,
 583         .vidioc_s_audio     = vidioc_s_audio,
 584         .vidioc_g_input     = vidioc_g_input,
 585         .vidioc_s_input     = vidioc_s_input,
 586 };
 587
 588 static struct video_device cadet_radio = {
 589         .name           = "Cadet radio",
 590         .fops           = &cadet_fops,
 591         .ioctl_ops      = &cadet_ioctl_ops,
 592 };
 593
 594 #ifdef CONFIG_PNP
 595
 596 static struct pnp_device_id cadet_pnp_devices[] = {
 597         /* ADS Cadet AM/FM Radio Card */
 598         {.id = "MSM0c24", .driver_data = 0},
 599         {.id = ""}
 600 };
 601
 602 MODULE_DEVICE_TABLE(pnp, cadet_pnp_devices);
 603
 604 static int cadet_pnp_probe(struct pnp_dev * dev, const struct pnp_device_id *dev_id)
 605 {
 606         if (!dev)
 607                 return -ENODEV;
 608         /* only support one device */
 609         if (io > 0)
 610                 return -EBUSY;
 611
 612         if (!pnp_port_valid(dev, 0)) {
 613                 return -ENODEV;
 614         }
 615
 616         io = pnp_port_start(dev, 0);
 617
 618         printk ("radio-cadet: PnP reports device at %#x\n", io);
 619
 620         return io;
 621 }
 622
 623 static struct pnp_driver cadet_pnp_driver = {
 624         .name           = "radio-cadet",
 625         .id_table       = cadet_pnp_devices,
 626         .probe          = cadet_pnp_probe,
 627         .remove         = NULL,
 628 };
 629
 630 #else
 631 static struct pnp_driver cadet_pnp_driver;
 632 #endif
 633
 634 static int cadet_probe(void)
 635 {
 636         static int iovals[8]={0x330,0x332,0x334,0x336,0x338,0x33a,0x33c,0x33e};
 637         int i;
 638
 639         for(i=0;i<8;i++) {
 640                 io=iovals[i];
 641                 if (request_region(io, 2, "cadet-probe")) {
 642                         cadet_setfreq(1410);
 643                         if(cadet_getfreq()==1410) {
 644                                 release_region(io, 2);
 645                                 return io;
 646                         }
 647                         release_region(io, 2);
 648                 }
 649         }
 650         return -1;
 651 }
 652
 653 /*
 654  * io should only be set if the user has used something like
 655  * isapnp (the userspace program) to initialize this card for us
 656  */
 657
 658 static int __init cadet_init(void)
 659 {
 660         spin_lock_init(&cadet_io_lock);
 661
 662         /*
 663          *      If a probe was requested then probe ISAPnP first (safest)
 664          */
 665         if (io < 0)
 666                 pnp_register_driver(&cadet_pnp_driver);
 667         /*
 668          *      If that fails then probe unsafely if probe is requested
 669          */
 670         if(io < 0)
 671                 io = cadet_probe ();
 672
 673         /*
 674          *      Else we bail out
 675          */
 676
 677         if(io < 0) {
 678 #ifdef MODULE
 679                 printk(KERN_ERR "You must set an I/O address with io=0x???\n");
 680 #endif
 681                 goto fail;
 682         }
 683         if (!request_region(io,2,"cadet"))
 684                 goto fail;
 685         if (video_register_device(&cadet_radio, VFL_TYPE_RADIO, radio_nr) < 0) {
 686                 release_region(io,2);
 687                 goto fail;
 688         }
 689         printk(KERN_INFO "ADS Cadet Radio Card at 0x%x\n",io);
 690         return 0;
 691 fail:
 692         pnp_unregister_driver(&cadet_pnp_driver);
 693         return -1;
 694 }
 695
 696
 697
 698 MODULE_AUTHOR("Fred Gleason, Russell Kroll, Quay Lu, Donald Song, Jason Lewis, Scott McGrath, William McGrath");
 699 MODULE_DESCRIPTION("A driver for the ADS Cadet AM/FM/RDS radio card.");
 700 MODULE_LICENSE("GPL");
 701
 702 module_param(io, int, 0);
 703 MODULE_PARM_DESC(io, "I/O address of Cadet card (0x330,0x332,0x334,0x336,0x338,0x33a,0x33c,0x33e)");
 704 module_param(radio_nr, int, 0);
 705
 706 static void __exit cadet_cleanup_module(void)
 707 {
 708         video_unregister_device(&cadet_radio);
 709         release_region(io,2);
 710         pnp_unregister_driver(&cadet_pnp_driver);
 711 }
 712
 713 module_init(cadet_init);
 714 module_exit(cadet_cleanup_module);
 715