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