?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
allow coexistance of N build and AC build.
[tomato.git] / release / src-rt-6.x / linux / linux-2.6 / drivers / media / radio / radio-cadet.c
blob8cf2e9df5c8aa0ae5365d2293b1e53c9c417669e
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+(HZ/20);
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+(HZ/20);
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 static struct pnp_device_id cadet_pnp_devices[] = {
591 /* ADS Cadet AM/FM Radio Card */
592 {.id = "MSM0c24", .driver_data = 0},
593 {.id = ""}
594 };
595
596 MODULE_DEVICE_TABLE(pnp, cadet_pnp_devices);
597
598 static int cadet_pnp_probe(struct pnp_dev * dev, const struct pnp_device_id *dev_id)
599 {
600 if (!dev)
601 return -ENODEV;
602 /* only support one device */
603 if (io > 0)
604 return -EBUSY;
605
606 if (!pnp_port_valid(dev, 0)) {
607 return -ENODEV;
608 }
609
610 io = pnp_port_start(dev, 0);
611
612 printk ("radio-cadet: PnP reports device at %#x\n", io);
613
614 return io;
615 }
616
617 static struct pnp_driver cadet_pnp_driver = {
618 .name = "radio-cadet",
619 .id_table = cadet_pnp_devices,
620 .probe = cadet_pnp_probe,
621 .remove = NULL,
622 };
623
624 static int cadet_probe(void)
625 {
626 static int iovals[8]={0x330,0x332,0x334,0x336,0x338,0x33a,0x33c,0x33e};
627 int i;
628
629 for(i=0;i<8;i++) {
630 io=iovals[i];
631 if (request_region(io, 2, "cadet-probe")) {
632 cadet_setfreq(1410);
633 if(cadet_getfreq()==1410) {
634 release_region(io, 2);
635 return io;
636 }
637 release_region(io, 2);
638 }
639 }
640 return -1;
641 }
642
643 /*
644 * io should only be set if the user has used something like
645 * isapnp (the userspace program) to initialize this card for us
646 */
647
648 static int __init cadet_init(void)
649 {
650 spin_lock_init(&cadet_io_lock);
651
652 /*
653 * If a probe was requested then probe ISAPnP first (safest)
654 */
655 if (io < 0)
656 pnp_register_driver(&cadet_pnp_driver);
657 /*
658 * If that fails then probe unsafely if probe is requested
659 */
660 if(io < 0)
661 io = cadet_probe ();
662
663 /*
664 * Else we bail out
665 */
666
667 if(io < 0) {
668 #ifdef MODULE
669 printk(KERN_ERR "You must set an I/O address with io=0x???\n");
670 #endif
671 goto fail;
672 }
673 if (!request_region(io,2,"cadet"))
674 goto fail;
675 if(video_register_device(&cadet_radio,VFL_TYPE_RADIO,radio_nr)==-1) {
676 release_region(io,2);
677 goto fail;
678 }
679 printk(KERN_INFO "ADS Cadet Radio Card at 0x%x\n",io);
680 return 0;
681 fail:
682 pnp_unregister_driver(&cadet_pnp_driver);
683 return -1;
684 }
685
686
687
688 MODULE_AUTHOR("Fred Gleason, Russell Kroll, Quay Lu, Donald Song, Jason Lewis, Scott McGrath, William McGrath");
689 MODULE_DESCRIPTION("A driver for the ADS Cadet AM/FM/RDS radio card.");
690 MODULE_LICENSE("GPL");
691
692 module_param(io, int, 0);
693 MODULE_PARM_DESC(io, "I/O address of Cadet card (0x330,0x332,0x334,0x336,0x338,0x33a,0x33c,0x33e)");
694 module_param(radio_nr, int, 0);
695
696 static void __exit cadet_cleanup_module(void)
697 {
698 video_unregister_device(&cadet_radio);
699 release_region(io,2);
700 pnp_unregister_driver(&cadet_pnp_driver);
701 }
702
703 module_init(cadet_init);
704 module_exit(cadet_cleanup_module);
705
Tomato firmware and modifications.