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