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

Subversion Repositories test_project

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

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


/* zoltrix radio plus driver for Linux radio support
 * (c) 1998 C. van Schaik <carl@leg.uct.ac.za>
 *
 * BUGS
 *  Due to the inconsistency in reading from the signal flags
 *  it is difficult to get an accurate tuned signal.
 *
 *  It seems that the card is not linear to 0 volume. It cuts off
 *  at a low volume, and it is not possible (at least I have not found)
 *  to get fine volume control over the low volume range.
 *
 *  Some code derived from code by Romolo Manfredini
 *                                 romolo@bicnet.it
 *
 * 1999-05-06 - (C. van Schaik)
 *            - Make signal strength and stereo scans
 *              kinder to cpu while in delay
 * 1999-01-05 - (C. van Schaik)
 *            - Changed tuning to 1/160Mhz accuracy
 *            - Added stereo support
 *              (card defaults to stereo)
 *              (can explicitly force mono on the card)
 *              (can detect if station is in stereo)
 *            - Added unmute function
 *            - Reworked ioctl functions
 * 2002-07-15 - Fix Stereo typo
 *
 * 2006-07-24 - 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, msleep                 */
#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/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          = 4096,
                .default_value = 0xff,
                .type          = V4L2_CTRL_TYPE_INTEGER,
        }
};
 
#ifndef CONFIG_RADIO_ZOLTRIX_PORT
#define CONFIG_RADIO_ZOLTRIX_PORT -1
#endif
 
static int io = CONFIG_RADIO_ZOLTRIX_PORT;
static int radio_nr = -1;
 
struct zol_device {
        int port;
        int curvol;
        unsigned long curfreq;
        int muted;
        unsigned int stereo;
        struct mutex lock;
};
 
static int zol_setvol(struct zol_device *dev, int vol)
{
        dev->curvol = vol;
        if (dev->muted)
                return 0;
 
        mutex_lock(&dev->lock);
        if (vol == 0) {
                outb(0, io);
                outb(0, io);
                inb(io + 3);    /* Zoltrix needs to be read to confirm */
                mutex_unlock(&dev->lock);
                return 0;
        }
 
        outb(dev->curvol-1, io);
        msleep(10);
        inb(io + 2);
        mutex_unlock(&dev->lock);
        return 0;
}
 
static void zol_mute(struct zol_device *dev)
{
        dev->muted = 1;
        mutex_lock(&dev->lock);
        outb(0, io);
        outb(0, io);
        inb(io + 3);            /* Zoltrix needs to be read to confirm */
        mutex_unlock(&dev->lock);
}
 
static void zol_unmute(struct zol_device *dev)
{
        dev->muted = 0;
        zol_setvol(dev, dev->curvol);
}
 
static int zol_setfreq(struct zol_device *dev, unsigned long freq)
{
        /* tunes the radio to the desired frequency */
        unsigned long long bitmask, f, m;
        unsigned int stereo = dev->stereo;
        int i;
 
        if (freq == 0)
                return 1;
        m = (freq / 160 - 8800) * 2;
        f = (unsigned long long) m + 0x4d1c;
 
        bitmask = 0xc480402c10080000ull;
        i = 45;
 
        mutex_lock(&dev->lock);
 
        outb(0, io);
        outb(0, io);
        inb(io + 3);            /* Zoltrix needs to be read to confirm */
 
        outb(0x40, io);
        outb(0xc0, io);
 
        bitmask = (bitmask ^ ((f & 0xff) << 47) ^ ((f & 0xff00) << 30) ^ ( stereo << 31));
        while (i--) {
                if ((bitmask & 0x8000000000000000ull) != 0) {
                        outb(0x80, io);
                        udelay(50);
                        outb(0x00, io);
                        udelay(50);
                        outb(0x80, io);
                        udelay(50);
                } else {
                        outb(0xc0, io);
                        udelay(50);
                        outb(0x40, io);
                        udelay(50);
                        outb(0xc0, io);
                        udelay(50);
                }
                bitmask *= 2;
        }
        /* termination sequence */
        outb(0x80, io);
        outb(0xc0, io);
        outb(0x40, io);
        udelay(1000);
        inb(io+2);
 
        udelay(1000);
 
        if (dev->muted)
        {
                outb(0, io);
                outb(0, io);
                inb(io + 3);
                udelay(1000);
        }
 
        mutex_unlock(&dev->lock);
 
        if(!dev->muted)
        {
                zol_setvol(dev, dev->curvol);
        }
        return 0;
}
 
/* Get signal strength */
 
static int zol_getsigstr(struct zol_device *dev)
{
        int a, b;
 
        mutex_lock(&dev->lock);
        outb(0x00, io);         /* This stuff I found to do nothing */
        outb(dev->curvol, io);
        msleep(20);
 
        a = inb(io);
        msleep(10);
        b = inb(io);
 
        mutex_unlock(&dev->lock);
 
        if (a != b)
                return (0);
 
        if ((a == 0xcf) || (a == 0xdf)  /* I found this out by playing */
                || (a == 0xef))       /* with a binary scanner on the card io */
                return (1);
        return (0);
}
 
static int zol_is_stereo (struct zol_device *dev)
{
        int x1, x2;
 
        mutex_lock(&dev->lock);
 
        outb(0x00, io);
        outb(dev->curvol, io);
        msleep(20);
 
        x1 = inb(io);
        msleep(10);
        x2 = inb(io);
 
        mutex_unlock(&dev->lock);
 
        if ((x1 == x2) && (x1 == 0xcf))
                return 1;
        return 0;
}
 
static int vidioc_querycap(struct file *file, void  *priv,
                                        struct v4l2_capability *v)
{
        strlcpy(v->driver, "radio-zoltrix", sizeof(v->driver));
        strlcpy(v->card, "Zoltrix 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)
{
        struct video_device *dev = video_devdata(file);
        struct zol_device *zol = dev->priv;
 
        if (v->index > 0)
                return -EINVAL;
 
        strcpy(v->name, "FM");
        v->type = V4L2_TUNER_RADIO;
        v->rangelow = (88*16000);
        v->rangehigh = (108*16000);
        v->rxsubchans = V4L2_TUNER_SUB_MONO|V4L2_TUNER_SUB_STEREO;
        v->capability = V4L2_TUNER_CAP_LOW;
        if (zol_is_stereo(zol))
                v->audmode = V4L2_TUNER_MODE_STEREO;
        else
                v->audmode = V4L2_TUNER_MODE_MONO;
        v->signal = 0xFFFF*zol_getsigstr(zol);
        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 zol_device *zol = dev->priv;
 
        zol->curfreq = f->frequency;
        zol_setfreq(zol, zol->curfreq);
        return 0;
}
 
static int vidioc_g_frequency(struct file *file, void *priv,
                                        struct v4l2_frequency *f)
{
        struct video_device *dev = video_devdata(file);
        struct zol_device *zol = dev->priv;
 
        f->type = V4L2_TUNER_RADIO;
        f->frequency = zol->curfreq;
        return 0;
}
 
static int vidioc_queryctrl(struct file *file, void *priv,
                                        struct v4l2_queryctrl *qc)
{
        int i;
 
        for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
                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 zol_device *zol = dev->priv;
 
        switch (ctrl->id) {
        case V4L2_CID_AUDIO_MUTE:
                ctrl->value = zol->muted;
                return 0;
        case V4L2_CID_AUDIO_VOLUME:
                ctrl->value = zol->curvol * 4096;
                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 zol_device *zol = dev->priv;
 
        switch (ctrl->id) {
        case V4L2_CID_AUDIO_MUTE:
                if (ctrl->value)
                        zol_mute(zol);
                else {
                        zol_unmute(zol);
                        zol_setvol(zol,zol->curvol);
                }
                return 0;
        case V4L2_CID_AUDIO_VOLUME:
                zol_setvol(zol,ctrl->value/4096);
                return 0;
        }
        zol->stereo = 1;
        zol_setfreq(zol, zol->curfreq);
#if 0
/* FIXME: Implement stereo/mono switch on V4L2 */
                        if (v->mode & VIDEO_SOUND_STEREO) {
                                zol->stereo = 1;
                                zol_setfreq(zol, zol->curfreq);
                        }
                        if (v->mode & VIDEO_SOUND_MONO) {
                                zol->stereo = 0;
                                zol_setfreq(zol, zol->curfreq);
                        }
#endif
        return -EINVAL;
}
 
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 zol_device zoltrix_unit;
 
static const struct file_operations zoltrix_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 zoltrix_radio =
{
        .owner          = THIS_MODULE,
        .name           = "Zoltrix Radio Plus",
        .type           = VID_TYPE_TUNER,
        .fops           = &zoltrix_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 zoltrix_init(void)
{
        if (io == -1) {
                printk(KERN_ERR "You must set an I/O address with io=0x???\n");
                return -EINVAL;
        }
        if ((io != 0x20c) && (io != 0x30c)) {
                printk(KERN_ERR "zoltrix: invalid port, try 0x20c or 0x30c\n");
                return -ENXIO;
        }
 
        zoltrix_radio.priv = &zoltrix_unit;
        if (!request_region(io, 2, "zoltrix")) {
                printk(KERN_ERR "zoltrix: port 0x%x already in use\n", io);
                return -EBUSY;
        }
 
        if (video_register_device(&zoltrix_radio, VFL_TYPE_RADIO, radio_nr) == -1)
        {
                release_region(io, 2);
                return -EINVAL;
        }
        printk(KERN_INFO "Zoltrix Radio Plus card driver.\n");
 
        mutex_init(&zoltrix_unit.lock);
 
        /* mute card - prevents noisy bootups */
 
        /* this ensures that the volume is all the way down  */
 
        outb(0, io);
        outb(0, io);
        msleep(20);
        inb(io + 3);
 
        zoltrix_unit.curvol = 0;
        zoltrix_unit.stereo = 1;
 
        return 0;
}
 
MODULE_AUTHOR("C.van Schaik");
MODULE_DESCRIPTION("A driver for the Zoltrix Radio Plus.");
MODULE_LICENSE("GPL");
 
module_param(io, int, 0);
MODULE_PARM_DESC(io, "I/O address of the Zoltrix Radio Plus (0x20c or 0x30c)");
module_param(radio_nr, int, 0);
 
static void __exit zoltrix_cleanup_module(void)
{
        video_unregister_device(&zoltrix_radio);
        release_region(io, 2);
}
 
module_init(zoltrix_init);
module_exit(zoltrix_cleanup_module);
 

Browse

Tools

Subversion Repositories test_project

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

Line No.	Rev	Author	Line
1	62	marcus.erl	`/* zoltrix radio plus driver for Linux radio support`
2			`* (c) 1998 C. van Schaik <carl@leg.uct.ac.za>`
3			`*`
4			`* BUGS`
5			`* Due to the inconsistency in reading from the signal flags`
6			`* it is difficult to get an accurate tuned signal.`
7			`*`
8			`* It seems that the card is not linear to 0 volume. It cuts off`
9			`* at a low volume, and it is not possible (at least I have not found)`
10			`* to get fine volume control over the low volume range.`
11			`*`
12			`* Some code derived from code by Romolo Manfredini`
13			`* romolo@bicnet.it`
14			`*`
15			`* 1999-05-06 - (C. van Schaik)`
16			`* - Make signal strength and stereo scans`
17			`* kinder to cpu while in delay`
18			`* 1999-01-05 - (C. van Schaik)`
19			`* - Changed tuning to 1/160Mhz accuracy`
20			`* - Added stereo support`
21			`* (card defaults to stereo)`
22			`* (can explicitly force mono on the card)`
23			`* (can detect if station is in stereo)`
24			`* - Added unmute function`
25			`* - Reworked ioctl functions`
26			`* 2002-07-15 - Fix Stereo typo`
27			`*`
28			`* 2006-07-24 - Converted to V4L2 API`
29			`* by Mauro Carvalho Chehab <mchehab@infradead.org>`
30			`*/`
31
32			`#include <linux/module.h> /* Modules */`
33			`#include <linux/init.h> /* Initdata */`
34			`#include <linux/ioport.h> /* request_region */`
35			`#include <linux/delay.h> /* udelay, msleep */`
36			`#include <asm/io.h> /* outb, outb_p */`
37			`#include <asm/uaccess.h> /* copy to/from user */`
38			`#include <linux/videodev2.h> /* kernel radio structs */`
39			`#include <media/v4l2-common.h>`
40
41			`#include <linux/version.h> /* for KERNEL_VERSION MACRO */`
42			`#define RADIO_VERSION KERNEL_VERSION(0,0,2)`
43
44			`static struct v4l2_queryctrl radio_qctrl[] = {`
45			`{`
46			`.id = V4L2_CID_AUDIO_MUTE,`
47			`.name = "Mute",`
48			`.minimum = 0,`
49			`.maximum = 1,`
50			`.default_value = 1,`
51			`.type = V4L2_CTRL_TYPE_BOOLEAN,`
52			`},{`
53			`.id = V4L2_CID_AUDIO_VOLUME,`
54			`.name = "Volume",`
55			`.minimum = 0,`
56			`.maximum = 65535,`
57			`.step = 4096,`
58			`.default_value = 0xff,`
59			`.type = V4L2_CTRL_TYPE_INTEGER,`
60			`}`
61			`};`
62
63			`#ifndef CONFIG_RADIO_ZOLTRIX_PORT`
64			`#define CONFIG_RADIO_ZOLTRIX_PORT -1`
65			`#endif`
66
67			`static int io = CONFIG_RADIO_ZOLTRIX_PORT;`
68			`static int radio_nr = -1;`
69
70			`struct zol_device {`
71			`int port;`
72			`int curvol;`
73			`unsigned long curfreq;`
74			`int muted;`
75			`unsigned int stereo;`
76			`struct mutex lock;`
77			`};`
78
79			`static int zol_setvol(struct zol_device *dev, int vol)`
80			`{`
81			`dev->curvol = vol;`
82			`if (dev->muted)`
83			`return 0;`
84
85			`mutex_lock(&dev->lock);`
86			`if (vol == 0) {`
87			`outb(0, io);`
88			`outb(0, io);`
89			`inb(io + 3); /* Zoltrix needs to be read to confirm */`
90			`mutex_unlock(&dev->lock);`
91			`return 0;`
92			`}`
93
94			`outb(dev->curvol-1, io);`
95			`msleep(10);`
96			`inb(io + 2);`
97			`mutex_unlock(&dev->lock);`
98			`return 0;`
99			`}`
100
101			`static void zol_mute(struct zol_device *dev)`
102			`{`
103			`dev->muted = 1;`
104			`mutex_lock(&dev->lock);`
105			`outb(0, io);`
106			`outb(0, io);`
107			`inb(io + 3); /* Zoltrix needs to be read to confirm */`
108			`mutex_unlock(&dev->lock);`
109			`}`
110
111			`static void zol_unmute(struct zol_device *dev)`
112			`{`
113			`dev->muted = 0;`
114			`zol_setvol(dev, dev->curvol);`
115			`}`
116
117			`static int zol_setfreq(struct zol_device *dev, unsigned long freq)`
118			`{`
119			`/* tunes the radio to the desired frequency */`
120			`unsigned long long bitmask, f, m;`
121			`unsigned int stereo = dev->stereo;`
122			`int i;`
123
124			`if (freq == 0)`
125			`return 1;`
126			`m = (freq / 160 - 8800) * 2;`
127			`f = (unsigned long long) m + 0x4d1c;`
128
129			`bitmask = 0xc480402c10080000ull;`
130			`i = 45;`
131
132			`mutex_lock(&dev->lock);`
133
134			`outb(0, io);`
135			`outb(0, io);`
136			`inb(io + 3); /* Zoltrix needs to be read to confirm */`
137
138			`outb(0x40, io);`
139			`outb(0xc0, io);`
140
141			`bitmask = (bitmask ^ ((f & 0xff) << 47) ^ ((f & 0xff00) << 30) ^ ( stereo << 31));`
142			`while (i--) {`
143			`if ((bitmask & 0x8000000000000000ull) != 0) {`
144			`outb(0x80, io);`
145			`udelay(50);`
146			`outb(0x00, io);`
147			`udelay(50);`
148			`outb(0x80, io);`
149			`udelay(50);`
150			`} else {`
151			`outb(0xc0, io);`
152			`udelay(50);`
153			`outb(0x40, io);`
154			`udelay(50);`
155			`outb(0xc0, io);`
156			`udelay(50);`
157			`}`
158			`bitmask *= 2;`
159			`}`
160			`/* termination sequence */`
161			`outb(0x80, io);`
162			`outb(0xc0, io);`
163			`outb(0x40, io);`
164			`udelay(1000);`
165			`inb(io+2);`
166
167			`udelay(1000);`
168
169			`if (dev->muted)`
170			`{`
171			`outb(0, io);`
172			`outb(0, io);`
173			`inb(io + 3);`
174			`udelay(1000);`
175			`}`
176
177			`mutex_unlock(&dev->lock);`
178
179			`if(!dev->muted)`
180			`{`
181			`zol_setvol(dev, dev->curvol);`
182			`}`
183			`return 0;`
184			`}`
185
186			`/* Get signal strength */`
187
188			`static int zol_getsigstr(struct zol_device *dev)`
189			`{`
190			`int a, b;`
191
192			`mutex_lock(&dev->lock);`
193			`outb(0x00, io); /* This stuff I found to do nothing */`
194			`outb(dev->curvol, io);`
195			`msleep(20);`
196
197			`a = inb(io);`
198			`msleep(10);`
199			`b = inb(io);`
200
201			`mutex_unlock(&dev->lock);`
202
203			`if (a != b)`
204			`return (0);`
205
206			`if ((a == 0xcf) \|\| (a == 0xdf) /* I found this out by playing */`
207			`\|\| (a == 0xef)) /* with a binary scanner on the card io */`
208			`return (1);`
209			`return (0);`
210			`}`
211
212			`static int zol_is_stereo (struct zol_device *dev)`
213			`{`
214			`int x1, x2;`
215
216			`mutex_lock(&dev->lock);`
217
218			`outb(0x00, io);`
219			`outb(dev->curvol, io);`
220			`msleep(20);`
221
222			`x1 = inb(io);`
223			`msleep(10);`
224			`x2 = inb(io);`
225
226			`mutex_unlock(&dev->lock);`
227
228			`if ((x1 == x2) && (x1 == 0xcf))`
229			`return 1;`
230			`return 0;`
231			`}`
232
233			`static int vidioc_querycap(struct file file, void priv,`
234			`struct v4l2_capability *v)`
235			`{`
236			`strlcpy(v->driver, "radio-zoltrix", sizeof(v->driver));`
237			`strlcpy(v->card, "Zoltrix Radio", sizeof(v->card));`
238			`sprintf(v->bus_info, "ISA");`
239			`v->version = RADIO_VERSION;`
240			`v->capabilities = V4L2_CAP_TUNER;`
241			`return 0;`
242			`}`
243
244			`static int vidioc_g_tuner(struct file file, void priv,`
245			`struct v4l2_tuner *v)`
246			`{`
247			`struct video_device *dev = video_devdata(file);`
248			`struct zol_device *zol = dev->priv;`
249
250			`if (v->index > 0)`
251			`return -EINVAL;`
252
253			`strcpy(v->name, "FM");`
254			`v->type = V4L2_TUNER_RADIO;`
255			`v->rangelow = (88*16000);`
256			`v->rangehigh = (108*16000);`
257			`v->rxsubchans = V4L2_TUNER_SUB_MONO\|V4L2_TUNER_SUB_STEREO;`
258			`v->capability = V4L2_TUNER_CAP_LOW;`
259			`if (zol_is_stereo(zol))`
260			`v->audmode = V4L2_TUNER_MODE_STEREO;`
261			`else`
262			`v->audmode = V4L2_TUNER_MODE_MONO;`
263			`v->signal = 0xFFFF*zol_getsigstr(zol);`
264			`return 0;`
265			`}`
266
267			`static int vidioc_s_tuner(struct file file, void priv,`
268			`struct v4l2_tuner *v)`
269			`{`
270			`if (v->index > 0)`
271			`return -EINVAL;`
272			`return 0;`
273			`}`
274
275			`static int vidioc_s_frequency(struct file file, void priv,`
276			`struct v4l2_frequency *f)`
277			`{`
278			`struct video_device *dev = video_devdata(file);`
279			`struct zol_device *zol = dev->priv;`
280
281			`zol->curfreq = f->frequency;`
282			`zol_setfreq(zol, zol->curfreq);`
283			`return 0;`
284			`}`
285
286			`static int vidioc_g_frequency(struct file file, void priv,`
287			`struct v4l2_frequency *f)`
288			`{`
289			`struct video_device *dev = video_devdata(file);`
290			`struct zol_device *zol = dev->priv;`
291
292			`f->type = V4L2_TUNER_RADIO;`
293			`f->frequency = zol->curfreq;`
294			`return 0;`
295			`}`
296
297			`static int vidioc_queryctrl(struct file file, void priv,`
298			`struct v4l2_queryctrl *qc)`
299			`{`
300			`int i;`
301
302			`for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {`
303			`if (qc->id && qc->id == radio_qctrl[i].id) {`
304			`memcpy(qc, &(radio_qctrl[i]),`
305			`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 zol_device *zol = dev->priv;`
317
318			`switch (ctrl->id) {`
319			`case V4L2_CID_AUDIO_MUTE:`
320			`ctrl->value = zol->muted;`
321			`return 0;`
322			`case V4L2_CID_AUDIO_VOLUME:`
323			`ctrl->value = zol->curvol * 4096;`
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 zol_device *zol = dev->priv;`
334
335			`switch (ctrl->id) {`
336			`case V4L2_CID_AUDIO_MUTE:`
337			`if (ctrl->value)`
338			`zol_mute(zol);`
339			`else {`
340			`zol_unmute(zol);`
341			`zol_setvol(zol,zol->curvol);`
342			`}`
343			`return 0;`
344			`case V4L2_CID_AUDIO_VOLUME:`
345			`zol_setvol(zol,ctrl->value/4096);`
346			`return 0;`
347			`}`
348			`zol->stereo = 1;`
349			`zol_setfreq(zol, zol->curfreq);`
350			`#if 0`
351			`/* FIXME: Implement stereo/mono switch on V4L2 */`
352			`if (v->mode & VIDEO_SOUND_STEREO) {`
353			`zol->stereo = 1;`
354			`zol_setfreq(zol, zol->curfreq);`
355			`}`
356			`if (v->mode & VIDEO_SOUND_MONO) {`
357			`zol->stereo = 0;`
358			`zol_setfreq(zol, zol->curfreq);`
359			`}`
360			`#endif`
361			`return -EINVAL;`
362			`}`
363
364			`static int vidioc_g_audio(struct file file, void priv,`
365			`struct v4l2_audio *a)`
366			`{`
367			`if (a->index > 1)`
368			`return -EINVAL;`
369
370			`strcpy(a->name, "Radio");`
371			`a->capability = V4L2_AUDCAP_STEREO;`
372			`return 0;`
373			`}`
374
375			`static int vidioc_g_input(struct file filp, void priv, unsigned int *i)`
376			`{`
377			`*i = 0;`
378			`return 0;`
379			`}`
380
381			`static int vidioc_s_input(struct file filp, void priv, unsigned int i)`
382			`{`
383			`if (i != 0)`
384			`return -EINVAL;`
385			`return 0;`
386			`}`
387
388			`static int vidioc_s_audio(struct file file, void priv,`
389			`struct v4l2_audio *a)`
390			`{`
391			`if (a->index != 0)`
392			`return -EINVAL;`
393			`return 0;`
394			`}`
395
396			`static struct zol_device zoltrix_unit;`
397
398			`static const struct file_operations zoltrix_fops =`
399			`{`
400			`.owner = THIS_MODULE,`
401			`.open = video_exclusive_open,`
402			`.release = video_exclusive_release,`
403			`.ioctl = video_ioctl2,`
404			`.compat_ioctl = v4l_compat_ioctl32,`
405			`.llseek = no_llseek,`
406			`};`
407
408			`static struct video_device zoltrix_radio =`
409			`{`
410			`.owner = THIS_MODULE,`
411			`.name = "Zoltrix Radio Plus",`
412			`.type = VID_TYPE_TUNER,`
413			`.fops = &zoltrix_fops,`
414			`.vidioc_querycap = vidioc_querycap,`
415			`.vidioc_g_tuner = vidioc_g_tuner,`
416			`.vidioc_s_tuner = vidioc_s_tuner,`
417			`.vidioc_g_audio = vidioc_g_audio,`
418			`.vidioc_s_audio = vidioc_s_audio,`
419			`.vidioc_g_input = vidioc_g_input,`
420			`.vidioc_s_input = vidioc_s_input,`
421			`.vidioc_g_frequency = vidioc_g_frequency,`
422			`.vidioc_s_frequency = vidioc_s_frequency,`
423			`.vidioc_queryctrl = vidioc_queryctrl,`
424			`.vidioc_g_ctrl = vidioc_g_ctrl,`
425			`.vidioc_s_ctrl = vidioc_s_ctrl,`
426			`};`
427
428			`static int __init zoltrix_init(void)`
429			`{`
430			`if (io == -1) {`
431			`printk(KERN_ERR "You must set an I/O address with io=0x???\n");`
432			`return -EINVAL;`
433			`}`
434			`if ((io != 0x20c) && (io != 0x30c)) {`
435			`printk(KERN_ERR "zoltrix: invalid port, try 0x20c or 0x30c\n");`
436			`return -ENXIO;`
437			`}`
438
439			`zoltrix_radio.priv = &zoltrix_unit;`
440			`if (!request_region(io, 2, "zoltrix")) {`
441			`printk(KERN_ERR "zoltrix: port 0x%x already in use\n", io);`
442			`return -EBUSY;`
443			`}`
444
445			`if (video_register_device(&zoltrix_radio, VFL_TYPE_RADIO, radio_nr) == -1)`
446			`{`
447			`release_region(io, 2);`
448			`return -EINVAL;`
449			`}`
450			`printk(KERN_INFO "Zoltrix Radio Plus card driver.\n");`
451
452			`mutex_init(&zoltrix_unit.lock);`
453
454			`/* mute card - prevents noisy bootups */`
455
456			`/* this ensures that the volume is all the way down */`
457
458			`outb(0, io);`
459			`outb(0, io);`
460			`msleep(20);`
461			`inb(io + 3);`
462
463			`zoltrix_unit.curvol = 0;`
464			`zoltrix_unit.stereo = 1;`
465
466			`return 0;`
467			`}`
468
469			`MODULE_AUTHOR("C.van Schaik");`
470			`MODULE_DESCRIPTION("A driver for the Zoltrix Radio Plus.");`
471			`MODULE_LICENSE("GPL");`
472
473			`module_param(io, int, 0);`
474			`MODULE_PARM_DESC(io, "I/O address of the Zoltrix Radio Plus (0x20c or 0x30c)");`
475			`module_param(radio_nr, int, 0);`
476
477			`static void __exit zoltrix_cleanup_module(void)`
478			`{`
479			`video_unregister_device(&zoltrix_radio);`
480			`release_region(io, 2);`
481			`}`
482
483			`module_init(zoltrix_init);`
484			`module_exit(zoltrix_cleanup_module);`
485