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