URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [media/] [radio/] [radio-sf16fmr2.c] - Blame information for rev 78

Go to most recent revision | Details | Compare with Previous | View Log


/* SF16FMR2 radio driver for Linux radio support
 * heavily based on fmi driver...
 * (c) 2000-2002 Ziglio Frediano, freddy77@angelfire.com
 *
 * Notes on the hardware
 *
 *  Frequency control is done digitally -- ie out(port,encodefreq(95.8));
 *  No volume control - only mute/unmute - you have to use line volume
 *
 *  For read stereo/mono you must wait 0.1 sec after set frequency and
 *  card unmuted so I set frequency on unmute
 *  Signal handling seem to work only on autoscanning (not implemented)
 *
 *  Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
 */
 
#include <linux/module.h>       /* Modules                      */
#include <linux/init.h>         /* Initdata                     */
#include <linux/ioport.h>       /* request_region               */
#include <linux/delay.h>        /* udelay                       */
#include <asm/io.h>             /* outb, outb_p                 */
#include <asm/uaccess.h>        /* copy to/from user            */
#include <linux/videodev2.h>    /* kernel radio structs         */
#include <media/v4l2-common.h>
#include <linux/mutex.h>
 
static struct mutex lock;
 
#include <linux/version.h>      /* for KERNEL_VERSION MACRO     */
#define RADIO_VERSION KERNEL_VERSION(0,0,2)
 
static struct v4l2_queryctrl radio_qctrl[] = {
        {
                .id            = V4L2_CID_AUDIO_MUTE,
                .name          = "Mute",
                .minimum       = 0,
                .maximum       = 1,
                .default_value = 1,
                .type          = V4L2_CTRL_TYPE_BOOLEAN,
        },{
                .id            = V4L2_CID_AUDIO_VOLUME,
                .name          = "Volume",
                .minimum       = 0,
                .maximum       = 65535,
                .step          = 1<<12,
                .default_value = 0xff,
                .type          = V4L2_CTRL_TYPE_INTEGER,
        }
};
 
#undef DEBUG
//#define DEBUG 1
 
#ifdef DEBUG
# define  debug_print(s) printk s
#else
# define  debug_print(s)
#endif
 
/* this should be static vars for module size */
struct fmr2_device
{
        int port;
        int curvol; /* 0-65535, if not volume 0 or 65535 */
        int mute;
        int stereo; /* card is producing stereo audio */
        unsigned long curfreq; /* freq in kHz */
        int card_type;
        __u32 flags;
};
 
static int io = 0x384;
static int radio_nr = -1;
 
/* hw precision is 12.5 kHz
 * It is only useful to give freq in intervall of 200 (=0.0125Mhz),
 * other bits will be truncated
 */
#define RSF16_ENCODE(x) ((x)/200+856)
#define RSF16_MINFREQ 87*16000
#define RSF16_MAXFREQ 108*16000
 
static inline void wait(int n,int port)
{
        for (;n;--n) inb(port);
}
 
static void outbits(int bits, unsigned int data, int nWait, int port)
{
        int bit;
        for(;--bits>=0;) {
                bit = (data>>bits) & 1;
                outb(bit,port);
                wait(nWait,port);
                outb(bit|2,port);
                wait(nWait,port);
                outb(bit,port);
                wait(nWait,port);
        }
}
 
static inline void fmr2_mute(int port)
{
        outb(0x00, port);
        wait(4,port);
}
 
static inline void fmr2_unmute(int port)
{
        outb(0x04, port);
        wait(4,port);
}
 
static inline int fmr2_stereo_mode(int port)
{
        int n = inb(port);
        outb(6,port);
        inb(port);
        n = ((n>>3)&1)^1;
        debug_print((KERN_DEBUG "stereo: %d\n", n));
        return n;
}
 
static int fmr2_product_info(struct fmr2_device *dev)
{
        int n = inb(dev->port);
        n &= 0xC1;
        if (n == 0)
        {
                /* this should support volume set */
                dev->card_type = 12;
                return 0;
        }
        /* not volume (mine is 11) */
        dev->card_type = (n==128)?11:0;
        return n;
}
 
static inline int fmr2_getsigstr(struct fmr2_device *dev)
{
        /* !!! work only if scanning freq */
        int port = dev->port, res = 0xffff;
        outb(5,port);
        wait(4,port);
        if (!(inb(port)&1)) res = 0;
        debug_print((KERN_DEBUG "signal: %d\n", res));
        return res;
}
 
/* set frequency and unmute card */
static int fmr2_setfreq(struct fmr2_device *dev)
{
        int port = dev->port;
        unsigned long freq = dev->curfreq;
 
        fmr2_mute(port);
 
        /* 0x42 for mono output
         * 0x102 forward scanning
         * 0x182 scansione avanti
         */
        outbits(9,0x2,3,port);
        outbits(16,RSF16_ENCODE(freq),2,port);
 
        fmr2_unmute(port);
 
        /* wait 0.11 sec */
        msleep(110);
 
        /* NOTE if mute this stop radio
           you must set freq on unmute */
        dev->stereo = fmr2_stereo_mode(port);
        return 0;
}
 
/* !!! not tested, in my card this does't work !!! */
static int fmr2_setvolume(struct fmr2_device *dev)
{
        int i,a,n, port = dev->port;
 
        if (dev->card_type != 11) return 1;
 
        switch( (dev->curvol+(1<<11)) >> 12 )
        {
        case 0: case 1: n = 0x21; break;
        case 2: n = 0x84; break;
        case 3: n = 0x90; break;
        case 4: n = 0x104; break;
        case 5: n = 0x110; break;
        case 6: n = 0x204; break;
        case 7: n = 0x210; break;
        case 8: n = 0x402; break;
        case 9: n = 0x404; break;
        default:
        case 10: n = 0x408; break;
        case 11: n = 0x410; break;
        case 12: n = 0x801; break;
        case 13: n = 0x802; break;
        case 14: n = 0x804; break;
        case 15: n = 0x808; break;
        case 16: n = 0x810; break;
        }
        for(i=12;--i>=0;)
        {
                a = ((n >> i) & 1) << 6; /* if (a=0) a= 0; else a= 0x40; */
                outb(a|4, port);
                wait(4,port);
                outb(a|0x24, port);
                wait(4,port);
                outb(a|4, port);
                wait(4,port);
        }
        for(i=6;--i>=0;)
        {
                a = ((0x18 >> i) & 1) << 6;
                outb(a|4, port);
                wait(4,port);
                outb(a|0x24, port);
                wait(4,port);
                outb(a|4, port);
                wait(4,port);
        }
        wait(4,port);
        outb(0x14, port);
 
        return 0;
}
 
static int vidioc_querycap(struct file *file, void  *priv,
                                        struct v4l2_capability *v)
{
        strlcpy(v->driver, "radio-sf16fmr2", sizeof(v->driver));
        strlcpy(v->card, "SF16-FMR2 radio", sizeof(v->card));
        sprintf(v->bus_info, "ISA");
        v->version = RADIO_VERSION;
        v->capabilities = V4L2_CAP_TUNER;
        return 0;
}
 
static int vidioc_g_tuner(struct file *file, void *priv,
                                        struct v4l2_tuner *v)
{
        int mult;
        struct video_device *dev = video_devdata(file);
        struct fmr2_device *fmr2 = dev->priv;
 
        if (v->index > 0)
                return -EINVAL;
 
        strcpy(v->name, "FM");
        v->type = V4L2_TUNER_RADIO;
 
        mult = (fmr2->flags & V4L2_TUNER_CAP_LOW) ? 1 : 1000;
        v->rangelow = RSF16_MINFREQ/mult;
        v->rangehigh = RSF16_MAXFREQ/mult;
        v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_MODE_STEREO;
        v->capability = fmr2->flags&V4L2_TUNER_CAP_LOW;
        v->audmode = fmr2->stereo ? V4L2_TUNER_MODE_STEREO:
                                V4L2_TUNER_MODE_MONO;
        mutex_lock(&lock);
        v->signal = fmr2_getsigstr(fmr2);
        mutex_unlock(&lock);
        return 0;
}
 
static int vidioc_s_tuner(struct file *file, void *priv,
                                        struct v4l2_tuner *v)
{
        if (v->index > 0)
                return -EINVAL;
        return 0;
}
 
static int vidioc_s_frequency(struct file *file, void *priv,
                                        struct v4l2_frequency *f)
{
        struct video_device *dev = video_devdata(file);
        struct fmr2_device *fmr2 = dev->priv;
 
        if (!(fmr2->flags & V4L2_TUNER_CAP_LOW))
                f->frequency *= 1000;
        if (f->frequency < RSF16_MINFREQ ||
                        f->frequency > RSF16_MAXFREQ )
                return -EINVAL;
        /*rounding in steps of 200 to match th freq
        that will be used */
        fmr2->curfreq = (f->frequency/200)*200;
 
        /* set card freq (if not muted) */
        if (fmr2->curvol && !fmr2->mute) {
                mutex_lock(&lock);
                fmr2_setfreq(fmr2);
                mutex_unlock(&lock);
        }
        return 0;
}
 
static int vidioc_g_frequency(struct file *file, void *priv,
                                        struct v4l2_frequency *f)
{
        struct video_device *dev = video_devdata(file);
        struct fmr2_device *fmr2 = dev->priv;
 
        f->type = V4L2_TUNER_RADIO;
        f->frequency = fmr2->curfreq;
        if (!(fmr2->flags & V4L2_TUNER_CAP_LOW))
                f->frequency /= 1000;
        return 0;
}
 
static int vidioc_queryctrl(struct file *file, void *priv,
                                        struct v4l2_queryctrl *qc)
{
        int i;
        struct video_device *dev = video_devdata(file);
        struct fmr2_device *fmr2 = dev->priv;
 
        for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
                if ((fmr2->card_type != 11)
                                && V4L2_CID_AUDIO_VOLUME)
                        radio_qctrl[i].step = 65535;
                if (qc->id && qc->id == radio_qctrl[i].id) {
                        memcpy(qc, &(radio_qctrl[i]),
                                                sizeof(*qc));
                        return 0;
                }
        }
        return -EINVAL;
}
 
static int vidioc_g_ctrl(struct file *file, void *priv,
                                        struct v4l2_control *ctrl)
{
        struct video_device *dev = video_devdata(file);
        struct fmr2_device *fmr2 = dev->priv;
 
        switch (ctrl->id) {
        case V4L2_CID_AUDIO_MUTE:
                ctrl->value = fmr2->mute;
                return 0;
        case V4L2_CID_AUDIO_VOLUME:
                ctrl->value = fmr2->curvol;
                return 0;
        }
        return -EINVAL;
}
 
static int vidioc_s_ctrl(struct file *file, void *priv,
                                        struct v4l2_control *ctrl)
{
        struct video_device *dev = video_devdata(file);
        struct fmr2_device *fmr2 = dev->priv;
 
        switch (ctrl->id) {
        case V4L2_CID_AUDIO_MUTE:
                fmr2->mute = ctrl->value;
                if (fmr2->card_type != 11) {
                        if (!fmr2->mute)
                                fmr2->curvol = 65535;
                        else
                                fmr2->curvol = 0;
                }
                break;
        case V4L2_CID_AUDIO_VOLUME:
                fmr2->curvol = ctrl->value;
                if (fmr2->card_type != 11) {
                        if (fmr2->curvol) {
                                fmr2->curvol = 65535;
                                fmr2->mute = 0;
                        } else {
                                fmr2->curvol = 0;
                                fmr2->mute = 1;
                        }
                }
                break;
        default:
                return -EINVAL;
        }
 
#ifdef DEBUG
        if (fmr2->curvol && !fmr2->mute)
                printk(KERN_DEBUG "unmute\n");
        else
                printk(KERN_DEBUG "mute\n");
#endif
 
        mutex_lock(&lock);
        if (fmr2->curvol && !fmr2->mute) {
                fmr2_setvolume(fmr2);
                fmr2_setfreq(fmr2);
        } else
                fmr2_mute(fmr2->port);
        mutex_unlock(&lock);
        return 0;
}
 
static int vidioc_g_audio(struct file *file, void *priv,
                                        struct v4l2_audio *a)
{
        if (a->index > 1)
                return -EINVAL;
 
        strcpy(a->name, "Radio");
        a->capability = V4L2_AUDCAP_STEREO;
        return 0;
}
 
static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
{
        *i = 0;
        return 0;
}
 
static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
{
        if (i != 0)
                return -EINVAL;
        return 0;
}
 
static int vidioc_s_audio(struct file *file, void *priv,
                                        struct v4l2_audio *a)
{
        if (a->index != 0)
                return -EINVAL;
        return 0;
}
 
static struct fmr2_device fmr2_unit;
 
static const struct file_operations fmr2_fops = {
        .owner          = THIS_MODULE,
        .open           = video_exclusive_open,
        .release        = video_exclusive_release,
        .ioctl          = video_ioctl2,
        .compat_ioctl   = v4l_compat_ioctl32,
        .llseek         = no_llseek,
};
 
static struct video_device fmr2_radio=
{
        .owner          = THIS_MODULE,
        .name           = "SF16FMR2 radio",
        . type          = VID_TYPE_TUNER,
        .fops           = &fmr2_fops,
        .vidioc_querycap    = vidioc_querycap,
        .vidioc_g_tuner     = vidioc_g_tuner,
        .vidioc_s_tuner     = vidioc_s_tuner,
        .vidioc_g_audio     = vidioc_g_audio,
        .vidioc_s_audio     = vidioc_s_audio,
        .vidioc_g_input     = vidioc_g_input,
        .vidioc_s_input     = vidioc_s_input,
        .vidioc_g_frequency = vidioc_g_frequency,
        .vidioc_s_frequency = vidioc_s_frequency,
        .vidioc_queryctrl   = vidioc_queryctrl,
        .vidioc_g_ctrl      = vidioc_g_ctrl,
        .vidioc_s_ctrl      = vidioc_s_ctrl,
};
 
static int __init fmr2_init(void)
{
        fmr2_unit.port = io;
        fmr2_unit.curvol = 0;
        fmr2_unit.mute = 0;
        fmr2_unit.curfreq = 0;
        fmr2_unit.stereo = 1;
        fmr2_unit.flags = V4L2_TUNER_CAP_LOW;
        fmr2_unit.card_type = 0;
        fmr2_radio.priv = &fmr2_unit;
 
        mutex_init(&lock);
 
        if (request_region(io, 2, "sf16fmr2"))
        {
                printk(KERN_ERR "fmr2: port 0x%x already in use\n", io);
                return -EBUSY;
        }
 
        if(video_register_device(&fmr2_radio, VFL_TYPE_RADIO, radio_nr)==-1)
        {
                release_region(io, 2);
                return -EINVAL;
        }
 
        printk(KERN_INFO "SF16FMR2 radio card driver at 0x%x.\n", io);
        /* mute card - prevents noisy bootups */
        mutex_lock(&lock);
        fmr2_mute(io);
        fmr2_product_info(&fmr2_unit);
        mutex_unlock(&lock);
        debug_print((KERN_DEBUG "card_type %d\n", fmr2_unit.card_type));
        return 0;
}
 
MODULE_AUTHOR("Ziglio Frediano, freddy77@angelfire.com");
MODULE_DESCRIPTION("A driver for the SF16FMR2 radio.");
MODULE_LICENSE("GPL");
 
module_param(io, int, 0);
MODULE_PARM_DESC(io, "I/O address of the SF16FMR2 card (should be 0x384, if do not work try 0x284)");
module_param(radio_nr, int, 0);
 
static void __exit fmr2_cleanup_module(void)
{
        video_unregister_device(&fmr2_radio);
        release_region(io,2);
}
 
module_init(fmr2_init);
module_exit(fmr2_cleanup_module);
 
#ifndef MODULE
 
static int __init fmr2_setup_io(char *str)
{
        get_option(&str, &io);
        return 1;
}
 
__setup("sf16fmr2=", fmr2_setup_io);
 
#endif

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [media/] [radio/] [radio-sf16fmr2.c] - Blame information for rev 78

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