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

Subversion Repositories test_project

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

Details | Compare with Previous | View Log


/*
 * Guillemot Maxi Radio FM 2000 PCI radio card driver for Linux
 * (C) 2001 Dimitromanolakis Apostolos <apdim@grecian.net>
 *
 * Based in the radio Maestro PCI driver. Actually it uses the same chip
 * for radio but different pci controller.
 *
 * I didn't have any specs I reversed engineered the protocol from
 * the windows driver (radio.dll).
 *
 * The card uses the TEA5757 chip that includes a search function but it
 * is useless as I haven't found any way to read back the frequency. If
 * anybody does please mail me.
 *
 * For the pdf file see:
 * http://www.semiconductors.philips.com/pip/TEA5757H/V1
 *
 *
 * CHANGES:
 *   0.75b
 *     - better pci interface thanks to Francois Romieu <romieu@cogenit.fr>
 *
 *   0.75      Sun Feb  4 22:51:27 EET 2001
 *     - tiding up
 *     - removed support for multiple devices as it didn't work anyway
 *
 * BUGS:
 *   - card unmutes if you change frequency
 *
 * (c) 2006, 2007 by Mauro Carvalho Chehab <mchehab@infradead.org>:
 *      - Conversion to V4L2 API
 *      - Uses video_ioctl2 for parsing and to add debug support
 */
 
 
#include <linux/module.h>
#include <linux/init.h>
#include <linux/ioport.h>
#include <linux/delay.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <linux/mutex.h>
 
#include <linux/pci.h>
#include <linux/videodev2.h>
#include <media/v4l2-common.h>
 
#define DRIVER_VERSION  "0.77"
 
#include <linux/version.h>      /* for KERNEL_VERSION MACRO     */
#define RADIO_VERSION KERNEL_VERSION(0,7,7)
 
static struct video_device maxiradio_radio;
 
#define dprintk(num, fmt, arg...)                                          \
        do {                                                               \
                if (maxiradio_radio.debug >= num)                          \
                        printk(KERN_DEBUG "%s: " fmt,                      \
                                maxiradio_radio.name, ## arg); } while (0)
 
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,
        }
};
 
#ifndef PCI_VENDOR_ID_GUILLEMOT
#define PCI_VENDOR_ID_GUILLEMOT 0x5046
#endif
 
#ifndef PCI_DEVICE_ID_GUILLEMOT
#define PCI_DEVICE_ID_GUILLEMOT_MAXIRADIO 0x1001
#endif
 
 
/* TEA5757 pin mappings */
static const int clk = 1, data = 2, wren = 4, mo_st = 8, power = 16 ;
 
static int radio_nr = -1;
module_param(radio_nr, int, 0);
 
 
#define FREQ_LO          50*16000
#define FREQ_HI         150*16000
 
#define FREQ_IF         171200 /* 10.7*16000   */
#define FREQ_STEP       200    /* 12.5*16      */
 
/* (x==fmhz*16*1000) -> bits */
#define FREQ2BITS(x)    ((( (unsigned int)(x)+FREQ_IF+(FREQ_STEP<<1)) \
                        /(FREQ_STEP<<2))<<2)
 
#define BITS2FREQ(x)    ((x) * FREQ_STEP - FREQ_IF)
 
 
static const struct file_operations maxiradio_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 radio_device
{
        __u16   io,     /* base of radio io */
                muted,  /* VIDEO_AUDIO_MUTE */
                stereo, /* VIDEO_TUNER_STEREO_ON */
                tuned;  /* signal strength (0 or 0xffff) */
 
        unsigned long freq;
 
        struct mutex lock;
} radio_unit = {
        .muted =1,
        .freq = FREQ_LO,
};
 
static void outbit(unsigned long bit, __u16 io)
{
        if (bit != 0)
                {
                        outb(  power|wren|data     ,io); udelay(4);
                        outb(  power|wren|data|clk ,io); udelay(4);
                        outb(  power|wren|data     ,io); udelay(4);
                }
        else
                {
                        outb(  power|wren          ,io); udelay(4);
                        outb(  power|wren|clk      ,io); udelay(4);
                        outb(  power|wren          ,io); udelay(4);
                }
}
 
static void turn_power(__u16 io, int p)
{
        if (p != 0) {
                dprintk(1, "Radio powered on\n");
                outb(power, io);
        } else {
                dprintk(1, "Radio powered off\n");
                outb(0,io);
        }
}
 
static void set_freq(__u16 io, __u32 freq)
{
        unsigned long int si;
        int bl;
        int data = FREQ2BITS(freq);
 
        /* TEA5757 shift register bits (see pdf) */
 
        outbit(0,io); // 24  search
        outbit(1,io); // 23  search up/down
 
        outbit(0,io); // 22  stereo/mono
 
        outbit(0,io); // 21  band
        outbit(0,io); // 20  band (only 00=FM works I think)
 
        outbit(0,io); // 19  port ?
        outbit(0,io); // 18  port ?
 
        outbit(0,io); // 17  search level
        outbit(0,io); // 16  search level
 
        si = 0x8000;
        for (bl = 1; bl <= 16 ; bl++) {
                outbit(data & si,io);
                si >>=1;
        }
 
        dprintk(1, "Radio freq set to %d.%02d MHz\n",
                                freq / 16000,
                                freq % 16000 * 100 / 16000);
 
        turn_power(io, 1);
}
 
static int get_stereo(__u16 io)
{
        outb(power,io);
        udelay(4);
 
        return !(inb(io) & mo_st);
}
 
static int get_tune(__u16 io)
{
        outb(power+clk,io);
        udelay(4);
 
        return !(inb(io) & mo_st);
}
 
 
static int vidioc_querycap (struct file *file, void  *priv,
                            struct v4l2_capability *v)
{
        strlcpy(v->driver, "radio-maxiradio", sizeof (v->driver));
        strlcpy(v->card, "Maxi Radio FM2000 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 radio_device *card=dev->priv;
 
        if (v->index > 0)
                return -EINVAL;
 
        memset(v,0,sizeof(*v));
        strcpy(v->name, "FM");
        v->type = V4L2_TUNER_RADIO;
 
        v->rangelow=FREQ_LO;
        v->rangehigh=FREQ_HI;
        v->rxsubchans =V4L2_TUNER_SUB_MONO|V4L2_TUNER_SUB_STEREO;
        v->capability=V4L2_TUNER_CAP_LOW;
        if(get_stereo(card->io))
                v->audmode = V4L2_TUNER_MODE_STEREO;
        else
                v->audmode = V4L2_TUNER_MODE_MONO;
        v->signal=0xffff*get_tune(card->io);
 
        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_g_audio (struct file *file, void *priv,
                           struct v4l2_audio *a)
{
        if (a->index > 1)
                return -EINVAL;
 
        strcpy(a->name, "FM");
        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 int vidioc_s_frequency (struct file *file, void *priv,
                               struct v4l2_frequency *f)
{
        struct video_device *dev = video_devdata(file);
        struct radio_device *card=dev->priv;
 
        if (f->frequency < FREQ_LO || f->frequency > FREQ_HI) {
                dprintk(1, "radio freq (%d.%02d MHz) out of range (%d-%d)\n",
                                        f->frequency / 16000,
                                        f->frequency % 16000 * 100 / 16000,
                                        FREQ_LO / 16000, FREQ_HI / 16000);
 
                return -EINVAL;
        }
 
        card->freq = f->frequency;
        set_freq(card->io, card->freq);
        msleep(125);
 
        return 0;
}
 
static int vidioc_g_frequency (struct file *file, void *priv,
                               struct v4l2_frequency *f)
{
        struct video_device *dev = video_devdata(file);
        struct radio_device *card=dev->priv;
 
        f->type = V4L2_TUNER_RADIO;
        f->frequency = card->freq;
 
        dprintk(4, "radio freq is %d.%02d MHz",
                                f->frequency / 16000,
                                f->frequency % 16000 * 100 / 16000);
 
        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 radio_device *card=dev->priv;
 
        switch (ctrl->id) {
                case V4L2_CID_AUDIO_MUTE:
                        ctrl->value=card->muted;
                        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 radio_device *card=dev->priv;
 
        switch (ctrl->id) {
                case V4L2_CID_AUDIO_MUTE:
                        card->muted = ctrl->value;
                        if(card->muted)
                                turn_power(card->io, 0);
                        else
                                set_freq(card->io, card->freq);
                        return 0;
        }
 
        return -EINVAL;
}
 
static struct video_device maxiradio_radio =
{
        .owner              = THIS_MODULE,
        .name               = "Maxi Radio FM2000 radio",
        .type               = VID_TYPE_TUNER,
        .fops               = &maxiradio_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 __devinit maxiradio_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
{
        if(!request_region(pci_resource_start(pdev, 0),
                           pci_resource_len(pdev, 0), "Maxi Radio FM 2000")) {
                printk(KERN_ERR "radio-maxiradio: can't reserve I/O ports\n");
                goto err_out;
        }
 
        if (pci_enable_device(pdev))
                goto err_out_free_region;
 
        radio_unit.io = pci_resource_start(pdev, 0);
        mutex_init(&radio_unit.lock);
        maxiradio_radio.priv = &radio_unit;
 
        if (video_register_device(&maxiradio_radio, VFL_TYPE_RADIO, radio_nr)==-1) {
                printk("radio-maxiradio: can't register device!");
                goto err_out_free_region;
        }
 
        printk(KERN_INFO "radio-maxiradio: version "
               DRIVER_VERSION
               " time "
               __TIME__ "  "
               __DATE__
               "\n");
 
        printk(KERN_INFO "radio-maxiradio: found Guillemot MAXI Radio device (io = 0x%x)\n",
               radio_unit.io);
        return 0;
 
err_out_free_region:
        release_region(pci_resource_start(pdev, 0), pci_resource_len(pdev, 0));
err_out:
        return -ENODEV;
}
 
static void __devexit maxiradio_remove_one(struct pci_dev *pdev)
{
        video_unregister_device(&maxiradio_radio);
        release_region(pci_resource_start(pdev, 0), pci_resource_len(pdev, 0));
}
 
static struct pci_device_id maxiradio_pci_tbl[] = {
        { PCI_VENDOR_ID_GUILLEMOT, PCI_DEVICE_ID_GUILLEMOT_MAXIRADIO,
                PCI_ANY_ID, PCI_ANY_ID, },
        { 0,}
};
 
MODULE_DEVICE_TABLE(pci, maxiradio_pci_tbl);
 
static struct pci_driver maxiradio_driver = {
        .name           = "radio-maxiradio",
        .id_table       = maxiradio_pci_tbl,
        .probe          = maxiradio_init_one,
        .remove         = __devexit_p(maxiradio_remove_one),
};
 
static int __init maxiradio_radio_init(void)
{
        return pci_register_driver(&maxiradio_driver);
}
 
static void __exit maxiradio_radio_exit(void)
{
        pci_unregister_driver(&maxiradio_driver);
}
 
module_init(maxiradio_radio_init);
module_exit(maxiradio_radio_exit);
 
MODULE_AUTHOR("Dimitromanolakis Apostolos, apdim@grecian.net");
MODULE_DESCRIPTION("Radio driver for the Guillemot Maxi Radio FM2000 radio.");
MODULE_LICENSE("GPL");
 
module_param_named(debug,maxiradio_radio.debug, int, 0644);
MODULE_PARM_DESC(debug,"activates debug info");

Browse

Tools

Subversion Repositories test_project

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

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* Guillemot Maxi Radio FM 2000 PCI radio card driver for Linux`
3			`* (C) 2001 Dimitromanolakis Apostolos <apdim@grecian.net>`
4			`*`
5			`* Based in the radio Maestro PCI driver. Actually it uses the same chip`
6			`* for radio but different pci controller.`
7			`*`
8			`* I didn't have any specs I reversed engineered the protocol from`
9			`* the windows driver (radio.dll).`
10			`*`
11			`* The card uses the TEA5757 chip that includes a search function but it`
12			`* is useless as I haven't found any way to read back the frequency. If`
13			`* anybody does please mail me.`
14			`*`
15			`* For the pdf file see:`
16			`* http://www.semiconductors.philips.com/pip/TEA5757H/V1`
17			`*`
18			`*`
19			`* CHANGES:`
20			`* 0.75b`
21			`* - better pci interface thanks to Francois Romieu <romieu@cogenit.fr>`
22			`*`
23			`* 0.75 Sun Feb 4 22:51:27 EET 2001`
24			`* - tiding up`
25			`* - removed support for multiple devices as it didn't work anyway`
26			`*`
27			`* BUGS:`
28			`* - card unmutes if you change frequency`
29			`*`
30			`* (c) 2006, 2007 by Mauro Carvalho Chehab <mchehab@infradead.org>:`
31			`* - Conversion to V4L2 API`
32			`* - Uses video_ioctl2 for parsing and to add debug support`
33			`*/`
34
35
36			`#include <linux/module.h>`
37			`#include <linux/init.h>`
38			`#include <linux/ioport.h>`
39			`#include <linux/delay.h>`
40			`#include <asm/io.h>`
41			`#include <asm/uaccess.h>`
42			`#include <linux/mutex.h>`
43
44			`#include <linux/pci.h>`
45			`#include <linux/videodev2.h>`
46			`#include <media/v4l2-common.h>`
47
48			`#define DRIVER_VERSION "0.77"`
49
50			`#include <linux/version.h> /* for KERNEL_VERSION MACRO */`
51			`#define RADIO_VERSION KERNEL_VERSION(0,7,7)`
52
53			`static struct video_device maxiradio_radio;`
54
55			`#define dprintk(num, fmt, arg...) \`
56			`do { \`
57			`if (maxiradio_radio.debug >= num) \`
58			`printk(KERN_DEBUG "%s: " fmt, \`
59			`maxiradio_radio.name, ## arg); } while (0)`
60
61			`static struct v4l2_queryctrl radio_qctrl[] = {`
62			`{`
63			`.id = V4L2_CID_AUDIO_MUTE,`
64			`.name = "Mute",`
65			`.minimum = 0,`
66			`.maximum = 1,`
67			`.default_value = 1,`
68			`.type = V4L2_CTRL_TYPE_BOOLEAN,`
69			`}`
70			`};`
71
72			`#ifndef PCI_VENDOR_ID_GUILLEMOT`
73			`#define PCI_VENDOR_ID_GUILLEMOT 0x5046`
74			`#endif`
75
76			`#ifndef PCI_DEVICE_ID_GUILLEMOT`
77			`#define PCI_DEVICE_ID_GUILLEMOT_MAXIRADIO 0x1001`
78			`#endif`
79
80
81			`/* TEA5757 pin mappings */`
82			`static const int clk = 1, data = 2, wren = 4, mo_st = 8, power = 16 ;`
83
84			`static int radio_nr = -1;`
85			`module_param(radio_nr, int, 0);`
86
87
88			`#define FREQ_LO 50*16000`
89			`#define FREQ_HI 150*16000`
90
91			`#define FREQ_IF 171200 /* 10.716000 /`
92			`#define FREQ_STEP 200 /* 12.516 /`
93
94			`/* (x==fmhz161000) -> bits */`
95			`#define FREQ2BITS(x) ((( (unsigned int)(x)+FREQ_IF+(FREQ_STEP<<1)) \`
96			`/(FREQ_STEP<<2))<<2)`
97
98			`#define BITS2FREQ(x) ((x) * FREQ_STEP - FREQ_IF)`
99
100
101			`static const struct file_operations maxiradio_fops = {`
102			`.owner = THIS_MODULE,`
103			`.open = video_exclusive_open,`
104			`.release = video_exclusive_release,`
105			`.ioctl = video_ioctl2,`
106			`.compat_ioctl = v4l_compat_ioctl32,`
107			`.llseek = no_llseek,`
108			`};`
109
110			`static struct radio_device`
111			`{`
112			`__u16 io, /* base of radio io */`
113			`muted, /* VIDEO_AUDIO_MUTE */`
114			`stereo, /* VIDEO_TUNER_STEREO_ON */`
115			`tuned; /* signal strength (0 or 0xffff) */`
116
117			`unsigned long freq;`
118
119			`struct mutex lock;`
120			`} radio_unit = {`
121			`.muted =1,`
122			`.freq = FREQ_LO,`
123			`};`
124
125			`static void outbit(unsigned long bit, __u16 io)`
126			`{`
127			`if (bit != 0)`
128			`{`
129			`outb( power\|wren\|data ,io); udelay(4);`
130			`outb( power\|wren\|data\|clk ,io); udelay(4);`
131			`outb( power\|wren\|data ,io); udelay(4);`
132			`}`
133			`else`
134			`{`
135			`outb( power\|wren ,io); udelay(4);`
136			`outb( power\|wren\|clk ,io); udelay(4);`
137			`outb( power\|wren ,io); udelay(4);`
138			`}`
139			`}`
140
141			`static void turn_power(__u16 io, int p)`
142			`{`
143			`if (p != 0) {`
144			`dprintk(1, "Radio powered on\n");`
145			`outb(power, io);`
146			`} else {`
147			`dprintk(1, "Radio powered off\n");`
148			`outb(0,io);`
149			`}`
150			`}`
151
152			`static void set_freq(__u16 io, __u32 freq)`
153			`{`
154			`unsigned long int si;`
155			`int bl;`
156			`int data = FREQ2BITS(freq);`
157
158			`/* TEA5757 shift register bits (see pdf) */`
159
160			`outbit(0,io); // 24 search`
161			`outbit(1,io); // 23 search up/down`
162
163			`outbit(0,io); // 22 stereo/mono`
164
165			`outbit(0,io); // 21 band`
166			`outbit(0,io); // 20 band (only 00=FM works I think)`
167
168			`outbit(0,io); // 19 port ?`
169			`outbit(0,io); // 18 port ?`
170
171			`outbit(0,io); // 17 search level`
172			`outbit(0,io); // 16 search level`
173
174			`si = 0x8000;`
175			`for (bl = 1; bl <= 16 ; bl++) {`
176			`outbit(data & si,io);`
177			`si >>=1;`
178			`}`
179
180			`dprintk(1, "Radio freq set to %d.%02d MHz\n",`
181			`freq / 16000,`
182			`freq % 16000 * 100 / 16000);`
183
184			`turn_power(io, 1);`
185			`}`
186
187			`static int get_stereo(__u16 io)`
188			`{`
189			`outb(power,io);`
190			`udelay(4);`
191
192			`return !(inb(io) & mo_st);`
193			`}`
194
195			`static int get_tune(__u16 io)`
196			`{`
197			`outb(power+clk,io);`
198			`udelay(4);`
199
200			`return !(inb(io) & mo_st);`
201			`}`
202
203
204			`static int vidioc_querycap (struct file file, void priv,`
205			`struct v4l2_capability *v)`
206			`{`
207			`strlcpy(v->driver, "radio-maxiradio", sizeof (v->driver));`
208			`strlcpy(v->card, "Maxi Radio FM2000 radio", sizeof (v->card));`
209			`sprintf(v->bus_info,"ISA");`
210			`v->version = RADIO_VERSION;`
211			`v->capabilities = V4L2_CAP_TUNER;`
212
213			`return 0;`
214			`}`
215
216			`static int vidioc_g_tuner (struct file file, void priv,`
217			`struct v4l2_tuner *v)`
218			`{`
219			`struct video_device *dev = video_devdata(file);`
220			`struct radio_device *card=dev->priv;`
221
222			`if (v->index > 0)`
223			`return -EINVAL;`
224
225			`memset(v,0,sizeof(*v));`
226			`strcpy(v->name, "FM");`
227			`v->type = V4L2_TUNER_RADIO;`
228
229			`v->rangelow=FREQ_LO;`
230			`v->rangehigh=FREQ_HI;`
231			`v->rxsubchans =V4L2_TUNER_SUB_MONO\|V4L2_TUNER_SUB_STEREO;`
232			`v->capability=V4L2_TUNER_CAP_LOW;`
233			`if(get_stereo(card->io))`
234			`v->audmode = V4L2_TUNER_MODE_STEREO;`
235			`else`
236			`v->audmode = V4L2_TUNER_MODE_MONO;`
237			`v->signal=0xffff*get_tune(card->io);`
238
239			`return 0;`
240			`}`
241
242			`static int vidioc_s_tuner (struct file file, void priv,`
243			`struct v4l2_tuner *v)`
244			`{`
245			`if (v->index > 0)`
246			`return -EINVAL;`
247
248			`return 0;`
249			`}`
250
251			`static int vidioc_g_audio (struct file file, void priv,`
252			`struct v4l2_audio *a)`
253			`{`
254			`if (a->index > 1)`
255			`return -EINVAL;`
256
257			`strcpy(a->name, "FM");`
258			`a->capability = V4L2_AUDCAP_STEREO;`
259			`return 0;`
260			`}`
261
262			`static int vidioc_g_input(struct file filp, void priv, unsigned int *i)`
263			`{`
264			`*i = 0;`
265
266			`return 0;`
267			`}`
268
269			`static int vidioc_s_input(struct file filp, void priv, unsigned int i)`
270			`{`
271			`if (i != 0)`
272			`return -EINVAL;`
273
274			`return 0;`
275			`}`
276
277
278			`static int vidioc_s_audio (struct file file, void priv,`
279			`struct v4l2_audio *a)`
280			`{`
281			`if (a->index != 0)`
282			`return -EINVAL;`
283
284			`return 0;`
285			`}`
286
287			`static int vidioc_s_frequency (struct file file, void priv,`
288			`struct v4l2_frequency *f)`
289			`{`
290			`struct video_device *dev = video_devdata(file);`
291			`struct radio_device *card=dev->priv;`
292
293			`if (f->frequency < FREQ_LO \|\| f->frequency > FREQ_HI) {`
294			`dprintk(1, "radio freq (%d.%02d MHz) out of range (%d-%d)\n",`
295			`f->frequency / 16000,`
296			`f->frequency % 16000 * 100 / 16000,`
297			`FREQ_LO / 16000, FREQ_HI / 16000);`
298
299			`return -EINVAL;`
300			`}`
301
302			`card->freq = f->frequency;`
303			`set_freq(card->io, card->freq);`
304			`msleep(125);`
305
306			`return 0;`
307			`}`
308
309			`static int vidioc_g_frequency (struct file file, void priv,`
310			`struct v4l2_frequency *f)`
311			`{`
312			`struct video_device *dev = video_devdata(file);`
313			`struct radio_device *card=dev->priv;`
314
315			`f->type = V4L2_TUNER_RADIO;`
316			`f->frequency = card->freq;`
317
318			`dprintk(4, "radio freq is %d.%02d MHz",`
319			`f->frequency / 16000,`
320			`f->frequency % 16000 * 100 / 16000);`
321
322			`return 0;`
323			`}`
324
325			`static int vidioc_queryctrl (struct file file, void priv,`
326			`struct v4l2_queryctrl *qc)`
327			`{`
328			`int i;`
329
330			`for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {`
331			`if (qc->id && qc->id == radio_qctrl[i].id) {`
332			`memcpy(qc, &(radio_qctrl[i]), sizeof(*qc));`
333			`return (0);`
334			`}`
335			`}`
336
337			`return -EINVAL;`
338			`}`
339
340			`static int vidioc_g_ctrl (struct file file, void priv,`
341			`struct v4l2_control *ctrl)`
342			`{`
343			`struct video_device *dev = video_devdata(file);`
344			`struct radio_device *card=dev->priv;`
345
346			`switch (ctrl->id) {`
347			`case V4L2_CID_AUDIO_MUTE:`
348			`ctrl->value=card->muted;`
349			`return (0);`
350			`}`
351
352			`return -EINVAL;`
353			`}`
354
355			`static int vidioc_s_ctrl (struct file file, void priv,`
356			`struct v4l2_control *ctrl)`
357			`{`
358			`struct video_device *dev = video_devdata(file);`
359			`struct radio_device *card=dev->priv;`
360
361			`switch (ctrl->id) {`
362			`case V4L2_CID_AUDIO_MUTE:`
363			`card->muted = ctrl->value;`
364			`if(card->muted)`
365			`turn_power(card->io, 0);`
366			`else`
367			`set_freq(card->io, card->freq);`
368			`return 0;`
369			`}`
370
371			`return -EINVAL;`
372			`}`
373
374			`static struct video_device maxiradio_radio =`
375			`{`
376			`.owner = THIS_MODULE,`
377			`.name = "Maxi Radio FM2000 radio",`
378			`.type = VID_TYPE_TUNER,`
379			`.fops = &maxiradio_fops,`
380
381			`.vidioc_querycap = vidioc_querycap,`
382			`.vidioc_g_tuner = vidioc_g_tuner,`
383			`.vidioc_s_tuner = vidioc_s_tuner,`
384			`.vidioc_g_audio = vidioc_g_audio,`
385			`.vidioc_s_audio = vidioc_s_audio,`
386			`.vidioc_g_input = vidioc_g_input,`
387			`.vidioc_s_input = vidioc_s_input,`
388			`.vidioc_g_frequency = vidioc_g_frequency,`
389			`.vidioc_s_frequency = vidioc_s_frequency,`
390			`.vidioc_queryctrl = vidioc_queryctrl,`
391			`.vidioc_g_ctrl = vidioc_g_ctrl,`
392			`.vidioc_s_ctrl = vidioc_s_ctrl,`
393			`};`
394
395			`static int __devinit maxiradio_init_one(struct pci_dev pdev, const struct pci_device_id ent)`
396			`{`
397			`if(!request_region(pci_resource_start(pdev, 0),`
398			`pci_resource_len(pdev, 0), "Maxi Radio FM 2000")) {`
399			`printk(KERN_ERR "radio-maxiradio: can't reserve I/O ports\n");`
400			`goto err_out;`
401			`}`
402
403			`if (pci_enable_device(pdev))`
404			`goto err_out_free_region;`
405
406			`radio_unit.io = pci_resource_start(pdev, 0);`
407			`mutex_init(&radio_unit.lock);`
408			`maxiradio_radio.priv = &radio_unit;`
409
410			`if (video_register_device(&maxiradio_radio, VFL_TYPE_RADIO, radio_nr)==-1) {`
411			`printk("radio-maxiradio: can't register device!");`
412			`goto err_out_free_region;`
413			`}`
414
415			`printk(KERN_INFO "radio-maxiradio: version "`
416			`DRIVER_VERSION`
417			`" time "`
418			`__TIME__ " "`
419			`__DATE__`
420			`"\n");`
421
422			`printk(KERN_INFO "radio-maxiradio: found Guillemot MAXI Radio device (io = 0x%x)\n",`
423			`radio_unit.io);`
424			`return 0;`
425
426			`err_out_free_region:`
427			`release_region(pci_resource_start(pdev, 0), pci_resource_len(pdev, 0));`
428			`err_out:`
429			`return -ENODEV;`
430			`}`
431
432			`static void __devexit maxiradio_remove_one(struct pci_dev *pdev)`
433			`{`
434			`video_unregister_device(&maxiradio_radio);`
435			`release_region(pci_resource_start(pdev, 0), pci_resource_len(pdev, 0));`
436			`}`
437
438			`static struct pci_device_id maxiradio_pci_tbl[] = {`
439			`{ PCI_VENDOR_ID_GUILLEMOT, PCI_DEVICE_ID_GUILLEMOT_MAXIRADIO,`
440			`PCI_ANY_ID, PCI_ANY_ID, },`
441			`{ 0,}`
442			`};`
443
444			`MODULE_DEVICE_TABLE(pci, maxiradio_pci_tbl);`
445
446			`static struct pci_driver maxiradio_driver = {`
447			`.name = "radio-maxiradio",`
448			`.id_table = maxiradio_pci_tbl,`
449			`.probe = maxiradio_init_one,`
450			`.remove = __devexit_p(maxiradio_remove_one),`
451			`};`
452
453			`static int __init maxiradio_radio_init(void)`
454			`{`
455			`return pci_register_driver(&maxiradio_driver);`
456			`}`
457
458			`static void __exit maxiradio_radio_exit(void)`
459			`{`
460			`pci_unregister_driver(&maxiradio_driver);`
461			`}`
462
463			`module_init(maxiradio_radio_init);`
464			`module_exit(maxiradio_radio_exit);`
465
466			`MODULE_AUTHOR("Dimitromanolakis Apostolos, apdim@grecian.net");`
467			`MODULE_DESCRIPTION("Radio driver for the Guillemot Maxi Radio FM2000 radio.");`
468			`MODULE_LICENSE("GPL");`
469
470			`module_param_named(debug,maxiradio_radio.debug, int, 0644);`
471			`MODULE_PARM_DESC(debug,"activates debug info");`