Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/x86/linux...
[linux-2.6] / drivers / media / radio / radio-sf16fmr2.c
1 /* SF16FMR2 radio driver for Linux radio support
2  * heavily based on fmi driver...
3  * (c) 2000-2002 Ziglio Frediano, freddy77@angelfire.com
4  *
5  * Notes on the hardware
6  *
7  *  Frequency control is done digitally -- ie out(port,encodefreq(95.8));
8  *  No volume control - only mute/unmute - you have to use line volume
9  *
10  *  For read stereo/mono you must wait 0.1 sec after set frequency and
11  *  card unmuted so I set frequency on unmute
12  *  Signal handling seem to work only on autoscanning (not implemented)
13  *
14  *  Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
15  */
16
17 #include <linux/module.h>       /* Modules                      */
18 #include <linux/init.h>         /* Initdata                     */
19 #include <linux/ioport.h>       /* request_region               */
20 #include <linux/delay.h>        /* udelay                       */
21 #include <asm/io.h>             /* outb, outb_p                 */
22 #include <asm/uaccess.h>        /* copy to/from user            */
23 #include <linux/videodev2.h>    /* kernel radio structs         */
24 #include <media/v4l2-common.h>
25 #include <linux/mutex.h>
26
27 static struct mutex lock;
28
29 #include <linux/version.h>      /* for KERNEL_VERSION MACRO     */
30 #define RADIO_VERSION KERNEL_VERSION(0,0,2)
31
32 #define AUD_VOL_INDEX 1
33
34 static struct v4l2_queryctrl radio_qctrl[] = {
35         {
36                 .id            = V4L2_CID_AUDIO_MUTE,
37                 .name          = "Mute",
38                 .minimum       = 0,
39                 .maximum       = 1,
40                 .default_value = 1,
41                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
42         },
43         [AUD_VOL_INDEX] = {
44                 .id            = V4L2_CID_AUDIO_VOLUME,
45                 .name          = "Volume",
46                 .minimum       = 0,
47                 .maximum       = 15,
48                 .step          = 1,
49                 .default_value = 0,
50                 .type          = V4L2_CTRL_TYPE_INTEGER,
51         }
52 };
53
54 #undef DEBUG
55 //#define DEBUG 1
56
57 #ifdef DEBUG
58 # define  debug_print(s) printk s
59 #else
60 # define  debug_print(s)
61 #endif
62
63 /* this should be static vars for module size */
64 struct fmr2_device
65 {
66         int port;
67         int curvol; /* 0-15 */
68         int mute;
69         int stereo; /* card is producing stereo audio */
70         unsigned long curfreq; /* freq in kHz */
71         int card_type;
72         __u32 flags;
73 };
74
75 static int io = 0x384;
76 static int radio_nr = -1;
77
78 /* hw precision is 12.5 kHz
79  * It is only useful to give freq in intervall of 200 (=0.0125Mhz),
80  * other bits will be truncated
81  */
82 #define RSF16_ENCODE(x) ((x)/200+856)
83 #define RSF16_MINFREQ 87*16000
84 #define RSF16_MAXFREQ 108*16000
85
86 static inline void wait(int n,int port)
87 {
88         for (;n;--n) inb(port);
89 }
90
91 static void outbits(int bits, unsigned int data, int nWait, int port)
92 {
93         int bit;
94         for(;--bits>=0;) {
95                 bit = (data>>bits) & 1;
96                 outb(bit,port);
97                 wait(nWait,port);
98                 outb(bit|2,port);
99                 wait(nWait,port);
100                 outb(bit,port);
101                 wait(nWait,port);
102         }
103 }
104
105 static inline void fmr2_mute(int port)
106 {
107         outb(0x00, port);
108         wait(4,port);
109 }
110
111 static inline void fmr2_unmute(int port)
112 {
113         outb(0x04, port);
114         wait(4,port);
115 }
116
117 static inline int fmr2_stereo_mode(int port)
118 {
119         int n = inb(port);
120         outb(6,port);
121         inb(port);
122         n = ((n>>3)&1)^1;
123         debug_print((KERN_DEBUG "stereo: %d\n", n));
124         return n;
125 }
126
127 static int fmr2_product_info(struct fmr2_device *dev)
128 {
129         int n = inb(dev->port);
130         n &= 0xC1;
131         if (n == 0)
132         {
133                 /* this should support volume set */
134                 dev->card_type = 12;
135                 return 0;
136         }
137         /* not volume (mine is 11) */
138         dev->card_type = (n==128)?11:0;
139         return n;
140 }
141
142 static inline int fmr2_getsigstr(struct fmr2_device *dev)
143 {
144         /* !!! work only if scanning freq */
145         int port = dev->port, res = 0xffff;
146         outb(5,port);
147         wait(4,port);
148         if (!(inb(port)&1)) res = 0;
149         debug_print((KERN_DEBUG "signal: %d\n", res));
150         return res;
151 }
152
153 /* set frequency and unmute card */
154 static int fmr2_setfreq(struct fmr2_device *dev)
155 {
156         int port = dev->port;
157         unsigned long freq = dev->curfreq;
158
159         fmr2_mute(port);
160
161         /* 0x42 for mono output
162          * 0x102 forward scanning
163          * 0x182 scansione avanti
164          */
165         outbits(9,0x2,3,port);
166         outbits(16,RSF16_ENCODE(freq),2,port);
167
168         fmr2_unmute(port);
169
170         /* wait 0.11 sec */
171         msleep(110);
172
173         /* NOTE if mute this stop radio
174            you must set freq on unmute */
175         dev->stereo = fmr2_stereo_mode(port);
176         return 0;
177 }
178
179 /* !!! not tested, in my card this does't work !!! */
180 static int fmr2_setvolume(struct fmr2_device *dev)
181 {
182         int vol[16] = { 0x021, 0x084, 0x090, 0x104,
183                         0x110, 0x204, 0x210, 0x402,
184                         0x404, 0x408, 0x410, 0x801,
185                         0x802, 0x804, 0x808, 0x810 };
186         int i, a, port = dev->port;
187         int n = vol[dev->curvol & 0x0f];
188
189         if (dev->card_type != 11)
190                 return 1;
191
192         for (i = 12; --i >= 0; ) {
193                 a = ((n >> i) & 1) << 6; /* if (a=0) a= 0; else a= 0x40; */
194                 outb(a | 4, port);
195                 wait(4, port);
196                 outb(a | 0x24, port);
197                 wait(4, port);
198                 outb(a | 4, port);
199                 wait(4, port);
200         }
201         for (i = 6; --i >= 0; ) {
202                 a = ((0x18 >> i) & 1) << 6;
203                 outb(a | 4, port);
204                 wait(4,port);
205                 outb(a | 0x24, port);
206                 wait(4,port);
207                 outb(a|4, port);
208                 wait(4,port);
209         }
210         wait(4, port);
211         outb(0x14, port);
212
213         return 0;
214 }
215
216 static int vidioc_querycap(struct file *file, void  *priv,
217                                         struct v4l2_capability *v)
218 {
219         strlcpy(v->driver, "radio-sf16fmr2", sizeof(v->driver));
220         strlcpy(v->card, "SF16-FMR2 radio", sizeof(v->card));
221         sprintf(v->bus_info, "ISA");
222         v->version = RADIO_VERSION;
223         v->capabilities = V4L2_CAP_TUNER;
224         return 0;
225 }
226
227 static int vidioc_g_tuner(struct file *file, void *priv,
228                                         struct v4l2_tuner *v)
229 {
230         int mult;
231         struct video_device *dev = video_devdata(file);
232         struct fmr2_device *fmr2 = dev->priv;
233
234         if (v->index > 0)
235                 return -EINVAL;
236
237         strcpy(v->name, "FM");
238         v->type = V4L2_TUNER_RADIO;
239
240         mult = (fmr2->flags & V4L2_TUNER_CAP_LOW) ? 1 : 1000;
241         v->rangelow = RSF16_MINFREQ/mult;
242         v->rangehigh = RSF16_MAXFREQ/mult;
243         v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_MODE_STEREO;
244         v->capability = fmr2->flags&V4L2_TUNER_CAP_LOW;
245         v->audmode = fmr2->stereo ? V4L2_TUNER_MODE_STEREO:
246                                 V4L2_TUNER_MODE_MONO;
247         mutex_lock(&lock);
248         v->signal = fmr2_getsigstr(fmr2);
249         mutex_unlock(&lock);
250         return 0;
251 }
252
253 static int vidioc_s_tuner(struct file *file, void *priv,
254                                         struct v4l2_tuner *v)
255 {
256         if (v->index > 0)
257                 return -EINVAL;
258         return 0;
259 }
260
261 static int vidioc_s_frequency(struct file *file, void *priv,
262                                         struct v4l2_frequency *f)
263 {
264         struct video_device *dev = video_devdata(file);
265         struct fmr2_device *fmr2 = dev->priv;
266
267         if (!(fmr2->flags & V4L2_TUNER_CAP_LOW))
268                 f->frequency *= 1000;
269         if (f->frequency < RSF16_MINFREQ ||
270                         f->frequency > RSF16_MAXFREQ )
271                 return -EINVAL;
272         /*rounding in steps of 200 to match th freq
273         that will be used */
274         fmr2->curfreq = (f->frequency/200)*200;
275
276         /* set card freq (if not muted) */
277         if (fmr2->curvol && !fmr2->mute) {
278                 mutex_lock(&lock);
279                 fmr2_setfreq(fmr2);
280                 mutex_unlock(&lock);
281         }
282         return 0;
283 }
284
285 static int vidioc_g_frequency(struct file *file, void *priv,
286                                         struct v4l2_frequency *f)
287 {
288         struct video_device *dev = video_devdata(file);
289         struct fmr2_device *fmr2 = dev->priv;
290
291         f->type = V4L2_TUNER_RADIO;
292         f->frequency = fmr2->curfreq;
293         if (!(fmr2->flags & V4L2_TUNER_CAP_LOW))
294                 f->frequency /= 1000;
295         return 0;
296 }
297
298 static int vidioc_queryctrl(struct file *file, void *priv,
299                                         struct v4l2_queryctrl *qc)
300 {
301         int i;
302
303         for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
304                 if (qc->id && qc->id == radio_qctrl[i].id) {
305                         memcpy(qc, &radio_qctrl[i], sizeof(*qc));
306                         return 0;
307                 }
308         }
309         return -EINVAL;
310 }
311
312 static int vidioc_g_ctrl(struct file *file, void *priv,
313                                         struct v4l2_control *ctrl)
314 {
315         struct video_device *dev = video_devdata(file);
316         struct fmr2_device *fmr2 = dev->priv;
317
318         switch (ctrl->id) {
319         case V4L2_CID_AUDIO_MUTE:
320                 ctrl->value = fmr2->mute;
321                 return 0;
322         case V4L2_CID_AUDIO_VOLUME:
323                 ctrl->value = fmr2->curvol;
324                 return 0;
325         }
326         return -EINVAL;
327 }
328
329 static int vidioc_s_ctrl(struct file *file, void *priv,
330                                         struct v4l2_control *ctrl)
331 {
332         struct video_device *dev = video_devdata(file);
333         struct fmr2_device *fmr2 = dev->priv;
334
335         switch (ctrl->id) {
336         case V4L2_CID_AUDIO_MUTE:
337                 fmr2->mute = ctrl->value;
338                 break;
339         case V4L2_CID_AUDIO_VOLUME:
340                 if (ctrl->value > radio_qctrl[AUD_VOL_INDEX].maximum)
341                         fmr2->curvol = radio_qctrl[AUD_VOL_INDEX].maximum;
342                 else
343                         fmr2->curvol = ctrl->value;
344
345                 break;
346         default:
347                 return -EINVAL;
348         }
349
350 #ifdef DEBUG
351         if (fmr2->curvol && !fmr2->mute)
352                 printk(KERN_DEBUG "unmute\n");
353         else
354                 printk(KERN_DEBUG "mute\n");
355 #endif
356
357         mutex_lock(&lock);
358         if (fmr2->curvol && !fmr2->mute) {
359                 fmr2_setvolume(fmr2);
360                 /* Set frequency and unmute card */
361                 fmr2_setfreq(fmr2);
362         } else
363                 fmr2_mute(fmr2->port);
364         mutex_unlock(&lock);
365         return 0;
366 }
367
368 static int vidioc_g_audio(struct file *file, void *priv,
369                                         struct v4l2_audio *a)
370 {
371         if (a->index > 1)
372                 return -EINVAL;
373
374         strcpy(a->name, "Radio");
375         a->capability = V4L2_AUDCAP_STEREO;
376         return 0;
377 }
378
379 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
380 {
381         *i = 0;
382         return 0;
383 }
384
385 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
386 {
387         if (i != 0)
388                 return -EINVAL;
389         return 0;
390 }
391
392 static int vidioc_s_audio(struct file *file, void *priv,
393                                         struct v4l2_audio *a)
394 {
395         if (a->index != 0)
396                 return -EINVAL;
397         return 0;
398 }
399
400 static struct fmr2_device fmr2_unit;
401
402 static const struct file_operations fmr2_fops = {
403         .owner          = THIS_MODULE,
404         .open           = video_exclusive_open,
405         .release        = video_exclusive_release,
406         .ioctl          = video_ioctl2,
407 #ifdef CONFIG_COMPAT
408         .compat_ioctl   = v4l_compat_ioctl32,
409 #endif
410         .llseek         = no_llseek,
411 };
412
413 static struct video_device fmr2_radio=
414 {
415         .owner          = THIS_MODULE,
416         .name           = "SF16FMR2 radio",
417         . type          = VID_TYPE_TUNER,
418         .fops           = &fmr2_fops,
419         .vidioc_querycap    = vidioc_querycap,
420         .vidioc_g_tuner     = vidioc_g_tuner,
421         .vidioc_s_tuner     = vidioc_s_tuner,
422         .vidioc_g_audio     = vidioc_g_audio,
423         .vidioc_s_audio     = vidioc_s_audio,
424         .vidioc_g_input     = vidioc_g_input,
425         .vidioc_s_input     = vidioc_s_input,
426         .vidioc_g_frequency = vidioc_g_frequency,
427         .vidioc_s_frequency = vidioc_s_frequency,
428         .vidioc_queryctrl   = vidioc_queryctrl,
429         .vidioc_g_ctrl      = vidioc_g_ctrl,
430         .vidioc_s_ctrl      = vidioc_s_ctrl,
431 };
432
433 static int __init fmr2_init(void)
434 {
435         fmr2_unit.port = io;
436         fmr2_unit.curvol = 0;
437         fmr2_unit.mute = 0;
438         fmr2_unit.curfreq = 0;
439         fmr2_unit.stereo = 1;
440         fmr2_unit.flags = V4L2_TUNER_CAP_LOW;
441         fmr2_unit.card_type = 0;
442         fmr2_radio.priv = &fmr2_unit;
443
444         mutex_init(&lock);
445
446         if (!request_region(io, 2, "sf16fmr2")) {
447                 printk(KERN_ERR "radio-sf16fmr2: request_region failed!\n");
448                 return -EBUSY;
449         }
450
451         if (video_register_device(&fmr2_radio, VFL_TYPE_RADIO, radio_nr) < 0) {
452                 release_region(io, 2);
453                 return -EINVAL;
454         }
455
456         printk(KERN_INFO "SF16FMR2 radio card driver at 0x%x.\n", io);
457         /* mute card - prevents noisy bootups */
458         mutex_lock(&lock);
459         fmr2_mute(io);
460         fmr2_product_info(&fmr2_unit);
461         mutex_unlock(&lock);
462         debug_print((KERN_DEBUG "card_type %d\n", fmr2_unit.card_type));
463
464         /* Only card_type == 11 implements volume */
465         if (fmr2_unit.card_type != 11)
466                 radio_qctrl[AUD_VOL_INDEX].maximum = 1;
467
468         return 0;
469 }
470
471 MODULE_AUTHOR("Ziglio Frediano, freddy77@angelfire.com");
472 MODULE_DESCRIPTION("A driver for the SF16FMR2 radio.");
473 MODULE_LICENSE("GPL");
474
475 module_param(io, int, 0);
476 MODULE_PARM_DESC(io, "I/O address of the SF16FMR2 card (should be 0x384, if do not work try 0x284)");
477 module_param(radio_nr, int, 0);
478
479 static void __exit fmr2_cleanup_module(void)
480 {
481         video_unregister_device(&fmr2_radio);
482         release_region(io,2);
483 }
484
485 module_init(fmr2_init);
486 module_exit(fmr2_cleanup_module);
487
488 #ifndef MODULE
489
490 static int __init fmr2_setup_io(char *str)
491 {
492         get_option(&str, &io);
493         return 1;
494 }
495
496 __setup("sf16fmr2=", fmr2_setup_io);
497
498 #endif