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

Subversion Repositories test_project

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

Details | Compare with Previous | View Log


/* GemTek radio card driver for Linux (C) 1998 Jonas Munsin <jmunsin@iki.fi>
 *
 * GemTek hasn't released any specs on the card, so the protocol had to
 * be reverse engineered with dosemu.
 *
 * Besides the protocol changes, this is mostly a copy of:
 *
 *    RadioTrack II driver for Linux radio support (C) 1998 Ben Pfaff
 *
 *    Based on RadioTrack I/RadioReveal (C) 1997 M. Kirkwood
 *    Converted to new API by Alan Cox <Alan.Cox@linux.org>
 *    Various bugfixes and enhancements by Russell Kroll <rkroll@exploits.org>
 *
 * TODO: Allow for more than one of these foolish entities :-)
 *
 * 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/spinlock.h>
 
#include <linux/version.h>      /* for KERNEL_VERSION MACRO     */
#define RADIO_VERSION KERNEL_VERSION(0,0,3)
#define RADIO_BANNER "GemTek Radio card driver: v0.0.3"
 
/*
 * Module info.
 */
 
MODULE_AUTHOR("Jonas Munsin, Pekka Sepp�nen <pexu@kapsi.fi>");
MODULE_DESCRIPTION("A driver for the GemTek Radio card.");
MODULE_LICENSE("GPL");
 
/*
 * Module params.
 */
 
#ifndef CONFIG_RADIO_GEMTEK_PORT
#define CONFIG_RADIO_GEMTEK_PORT -1
#endif
#ifndef CONFIG_RADIO_GEMTEK_PROBE
#define CONFIG_RADIO_GEMTEK_PROBE 1
#endif
 
static int io           = CONFIG_RADIO_GEMTEK_PORT;
static int probe        = CONFIG_RADIO_GEMTEK_PROBE;
static int hardmute;
static int shutdown     = 1;
static int keepmuted    = 1;
static int initmute     = 1;
static int radio_nr     = -1;
 
module_param(io, int, 0444);
MODULE_PARM_DESC(io, "Force I/O port for the GemTek Radio card if automatic"
         "probing is disabled or fails. The most common I/O ports are: 0x20c "
         "0x30c, 0x24c or 0x34c (0x20c, 0x248 and 0x28c have been reported to "
         " work for the combined sound/radiocard).");
 
module_param(probe, bool, 0444);
MODULE_PARM_DESC(probe, "Enable automatic device probing. Note: only the most "
        "common I/O ports used by the card are probed.");
 
module_param(hardmute, bool, 0644);
MODULE_PARM_DESC(hardmute, "Enable `hard muting' by shutting down PLL, may "
         "reduce static noise.");
 
module_param(shutdown, bool, 0644);
MODULE_PARM_DESC(shutdown, "Enable shutting down PLL and muting line when "
         "module is unloaded.");
 
module_param(keepmuted, bool, 0644);
MODULE_PARM_DESC(keepmuted, "Keep card muted even when frequency is changed.");
 
module_param(initmute, bool, 0444);
MODULE_PARM_DESC(initmute, "Mute card when module is loaded.");
 
module_param(radio_nr, int, 0444);
 
/*
 * Functions for controlling the card.
 */
#define GEMTEK_LOWFREQ  (87*16000)
#define GEMTEK_HIGHFREQ (108*16000)
 
/*
 * Frequency calculation constants.  Intermediate frequency 10.52 MHz (nominal
 * value 10.7 MHz), reference divisor 6.39 kHz (nominal 6.25 kHz).
 */
#define FSCALE          8
#define IF_OFFSET       ((unsigned int)(10.52 * 16000 * (1<<FSCALE)))
#define REF_FREQ        ((unsigned int)(6.39 * 16 * (1<<FSCALE)))
 
#define GEMTEK_CK               0x01    /* Clock signal                 */
#define GEMTEK_DA               0x02    /* Serial data                  */
#define GEMTEK_CE               0x04    /* Chip enable                  */
#define GEMTEK_NS               0x08    /* No signal                    */
#define GEMTEK_MT               0x10    /* Line mute                    */
#define GEMTEK_STDF_3_125_KHZ   0x01    /* Standard frequency 3.125 kHz */
#define GEMTEK_PLL_OFF          0x07    /* PLL off                      */
 
#define BU2614_BUS_SIZE 32      /* BU2614 / BU2614FS bus size           */
 
#define SHORT_DELAY 5           /* usec */
#define LONG_DELAY 75           /* usec */
 
struct gemtek_device {
        unsigned long lastfreq;
        int muted;
        u32 bu2614data;
};
 
#define BU2614_FREQ_BITS        16 /* D0..D15, Frequency data           */
#define BU2614_PORT_BITS        3 /* P0..P2, Output port control data   */
#define BU2614_VOID_BITS        4 /* unused                             */
#define BU2614_FMES_BITS        1 /* CT, Frequency measurement beginning data */
#define BU2614_STDF_BITS        3 /* R0..R2, Standard frequency data    */
#define BU2614_SWIN_BITS        1 /* S, Switch between FMIN / AMIN      */
#define BU2614_SWAL_BITS        1 /* PS, Swallow counter division (AMIN only)*/
#define BU2614_VOID2_BITS       1 /* unused                             */
#define BU2614_FMUN_BITS        1 /* GT, Frequency measurement time & unlock */
#define BU2614_TEST_BITS        1 /* TS, Test data is input             */
 
#define BU2614_FREQ_SHIFT       0
#define BU2614_PORT_SHIFT       (BU2614_FREQ_BITS + BU2614_FREQ_SHIFT)
#define BU2614_VOID_SHIFT       (BU2614_PORT_BITS + BU2614_PORT_SHIFT)
#define BU2614_FMES_SHIFT       (BU2614_VOID_BITS + BU2614_VOID_SHIFT)
#define BU2614_STDF_SHIFT       (BU2614_FMES_BITS + BU2614_FMES_SHIFT)
#define BU2614_SWIN_SHIFT       (BU2614_STDF_BITS + BU2614_STDF_SHIFT)
#define BU2614_SWAL_SHIFT       (BU2614_SWIN_BITS + BU2614_SWIN_SHIFT)
#define BU2614_VOID2_SHIFT      (BU2614_SWAL_BITS + BU2614_SWAL_SHIFT)
#define BU2614_FMUN_SHIFT       (BU2614_VOID2_BITS + BU2614_VOID2_SHIFT)
#define BU2614_TEST_SHIFT       (BU2614_FMUN_BITS + BU2614_FMUN_SHIFT)
 
#define MKMASK(field)   (((1<<BU2614_##field##_BITS) - 1) << \
                        BU2614_##field##_SHIFT)
#define BU2614_PORT_MASK        MKMASK(PORT)
#define BU2614_FREQ_MASK        MKMASK(FREQ)
#define BU2614_VOID_MASK        MKMASK(VOID)
#define BU2614_FMES_MASK        MKMASK(FMES)
#define BU2614_STDF_MASK        MKMASK(STDF)
#define BU2614_SWIN_MASK        MKMASK(SWIN)
#define BU2614_SWAL_MASK        MKMASK(SWAL)
#define BU2614_VOID2_MASK       MKMASK(VOID2)
#define BU2614_FMUN_MASK        MKMASK(FMUN)
#define BU2614_TEST_MASK        MKMASK(TEST)
 
static struct gemtek_device gemtek_unit;
 
static spinlock_t lock;
 
/*
 * Set data which will be sent to BU2614FS.
 */
#define gemtek_bu2614_set(dev, field, data) ((dev)->bu2614data = \
        ((dev)->bu2614data & ~field##_MASK) | ((data) << field##_SHIFT))
 
/*
 * Transmit settings to BU2614FS over GemTek IC.
 */
static void gemtek_bu2614_transmit(struct gemtek_device *dev)
{
        int i, bit, q, mute;
 
        spin_lock(&lock);
 
        mute = dev->muted ? GEMTEK_MT : 0x00;
 
        outb_p(mute | GEMTEK_DA | GEMTEK_CK, io);
        udelay(SHORT_DELAY);
        outb_p(mute | GEMTEK_CE | GEMTEK_DA | GEMTEK_CK, io);
        udelay(LONG_DELAY);
 
        for (i = 0, q = dev->bu2614data; i < 32; i++, q >>= 1) {
            bit = (q & 1) ? GEMTEK_DA : 0;
            outb_p(mute | GEMTEK_CE | bit, io);
            udelay(SHORT_DELAY);
            outb_p(mute | GEMTEK_CE | bit | GEMTEK_CK, io);
            udelay(SHORT_DELAY);
        }
 
        outb_p(mute | GEMTEK_DA | GEMTEK_CK, io);
        udelay(SHORT_DELAY);
        outb_p(mute | GEMTEK_CE | GEMTEK_DA | GEMTEK_CK, io);
        udelay(LONG_DELAY);
 
        spin_unlock(&lock);
}
 
/*
 * Calculate divisor from FM-frequency for BU2614FS (3.125 KHz STDF expected).
 */
static unsigned long gemtek_convfreq(unsigned long freq)
{
        return ((freq<<FSCALE) + IF_OFFSET + REF_FREQ/2) / REF_FREQ;
}
 
/*
 * Set FM-frequency.
 */
static void gemtek_setfreq(struct gemtek_device *dev, unsigned long freq)
{
 
        if (keepmuted && hardmute && dev->muted)
                return;
 
        if (freq < GEMTEK_LOWFREQ)
                freq = GEMTEK_LOWFREQ;
        else if (freq > GEMTEK_HIGHFREQ)
                freq = GEMTEK_HIGHFREQ;
 
        dev->lastfreq = freq;
        dev->muted = 0;
 
        gemtek_bu2614_set(dev, BU2614_PORT, 0);
        gemtek_bu2614_set(dev, BU2614_FMES, 0);
        gemtek_bu2614_set(dev, BU2614_SWIN, 0);  /* FM-mode      */
        gemtek_bu2614_set(dev, BU2614_SWAL, 0);
        gemtek_bu2614_set(dev, BU2614_FMUN, 1); /* GT bit set   */
        gemtek_bu2614_set(dev, BU2614_TEST, 0);
 
        gemtek_bu2614_set(dev, BU2614_STDF, GEMTEK_STDF_3_125_KHZ);
        gemtek_bu2614_set(dev, BU2614_FREQ, gemtek_convfreq(freq));
 
        gemtek_bu2614_transmit(dev);
}
 
/*
 * Set mute flag.
 */
static void gemtek_mute(struct gemtek_device *dev)
{
        int i;
        dev->muted = 1;
 
        if (hardmute) {
                /* Turn off PLL, disable data output */
                gemtek_bu2614_set(dev, BU2614_PORT, 0);
                gemtek_bu2614_set(dev, BU2614_FMES, 0);  /* CT bit off   */
                gemtek_bu2614_set(dev, BU2614_SWIN, 0);  /* FM-mode      */
                gemtek_bu2614_set(dev, BU2614_SWAL, 0);
                gemtek_bu2614_set(dev, BU2614_FMUN, 0);  /* GT bit off   */
                gemtek_bu2614_set(dev, BU2614_TEST, 0);
                gemtek_bu2614_set(dev, BU2614_STDF, GEMTEK_PLL_OFF);
                gemtek_bu2614_set(dev, BU2614_FREQ, 0);
                gemtek_bu2614_transmit(dev);
        } else {
                spin_lock(&lock);
 
                /* Read bus contents (CE, CK and DA). */
                i = inb_p(io);
                /* Write it back with mute flag set. */
                outb_p((i >> 5) | GEMTEK_MT, io);
                udelay(SHORT_DELAY);
 
                spin_unlock(&lock);
        }
}
 
/*
 * Unset mute flag.
 */
static void gemtek_unmute(struct gemtek_device *dev)
{
        int i;
        dev->muted = 0;
 
        if (hardmute) {
                /* Turn PLL back on. */
                gemtek_setfreq(dev, dev->lastfreq);
        } else {
                spin_lock(&lock);
 
                i = inb_p(io);
                outb_p(i >> 5, io);
                udelay(SHORT_DELAY);
 
                spin_unlock(&lock);
        }
}
 
/*
 * Get signal strength (= stereo status).
 */
static inline int gemtek_getsigstr(void)
{
        return inb_p(io) & GEMTEK_NS ? 0 : 1;
}
 
/*
 * Check if requested card acts like GemTek Radio card.
 */
static int gemtek_verify(int port)
{
        static int verified = -1;
        int i, q;
 
        if (verified == port)
                return 1;
 
        spin_lock(&lock);
 
        q = inb_p(port);        /* Read bus contents before probing. */
        /* Try to turn on CE, CK and DA respectively and check if card responds
           properly. */
        for (i = 0; i < 3; ++i) {
                outb_p(1 << i, port);
                udelay(SHORT_DELAY);
 
                if ((inb_p(port) & (~GEMTEK_NS)) != (0x17 | (1 << (i + 5)))) {
                        spin_unlock(&lock);
                        return 0;
                }
        }
        outb_p(q >> 5, port);   /* Write bus contents back. */
        udelay(SHORT_DELAY);
 
        spin_unlock(&lock);
        verified = port;
 
        return 1;
}
 
/*
 * Automatic probing for card.
 */
static int gemtek_probe(void)
{
        int ioports[] = { 0x20c, 0x30c, 0x24c, 0x34c, 0x248, 0x28c };
        int i;
 
        if (!probe) {
                printk(KERN_INFO "Automatic device probing disabled.\n");
                return -1;
        }
 
        printk(KERN_INFO "Automatic device probing enabled.\n");
 
        for (i = 0; i < ARRAY_SIZE(ioports); ++i) {
                printk(KERN_INFO "Trying I/O port 0x%x...\n", ioports[i]);
 
                if (!request_region(ioports[i], 1, "gemtek-probe")) {
                        printk(KERN_WARNING "I/O port 0x%x busy!\n",
                               ioports[i]);
                        continue;
                }
 
                if (gemtek_verify(ioports[i])) {
                        printk(KERN_INFO "Card found from I/O port "
                               "0x%x!\n", ioports[i]);
 
                        release_region(ioports[i], 1);
 
                        io = ioports[i];
                        return io;
                }
 
                release_region(ioports[i], 1);
        }
 
        printk(KERN_ERR "Automatic probing failed!\n");
 
        return -1;
}
 
/*
 * Video 4 Linux stuff.
 */
 
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 = 65535,
                .default_value = 0xff,
                .type = V4L2_CTRL_TYPE_INTEGER,
        }
};
 
static struct file_operations gemtek_fops = {
        .owner          = THIS_MODULE,
        .open           = video_exclusive_open,
        .release        = video_exclusive_release,
        .ioctl          = video_ioctl2,
        .compat_ioctl   = v4l_compat_ioctl32,
        .llseek         = no_llseek
};
 
static int vidioc_querycap(struct file *file, void *priv,
                           struct v4l2_capability *v)
{
        strlcpy(v->driver, "radio-gemtek", sizeof(v->driver));
        strlcpy(v->card, "GemTek", 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)
{
        if (v->index > 0)
                return -EINVAL;
 
        strcpy(v->name, "FM");
        v->type = V4L2_TUNER_RADIO;
        v->rangelow = GEMTEK_LOWFREQ;
        v->rangehigh = GEMTEK_HIGHFREQ;
        v->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
        v->signal = 0xffff * gemtek_getsigstr();
        if (v->signal) {
                v->audmode = V4L2_TUNER_MODE_STEREO;
                v->rxsubchans = V4L2_TUNER_SUB_STEREO;
        } else {
                v->audmode = V4L2_TUNER_MODE_MONO;
                v->rxsubchans = V4L2_TUNER_SUB_MONO;
        }
 
        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 gemtek_device *rt = dev->priv;
 
        gemtek_setfreq(rt, f->frequency);
 
        return 0;
}
 
static int vidioc_g_frequency(struct file *file, void *priv,
                              struct v4l2_frequency *f)
{
        struct video_device *dev = video_devdata(file);
        struct gemtek_device *rt = dev->priv;
 
        f->type = V4L2_TUNER_RADIO;
        f->frequency = rt->lastfreq;
        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 gemtek_device *rt = dev->priv;
 
        switch (ctrl->id) {
        case V4L2_CID_AUDIO_MUTE:
                ctrl->value = rt->muted;
                return 0;
        case V4L2_CID_AUDIO_VOLUME:
                if (rt->muted)
                        ctrl->value = 0;
                else
                        ctrl->value = 65535;
                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 gemtek_device *rt = dev->priv;
 
        switch (ctrl->id) {
        case V4L2_CID_AUDIO_MUTE:
                if (ctrl->value)
                        gemtek_mute(rt);
                else
                        gemtek_unmute(rt);
                return 0;
        case V4L2_CID_AUDIO_VOLUME:
                if (ctrl->value)
                        gemtek_unmute(rt);
                else
                        gemtek_mute(rt);
                return 0;
        }
        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 video_device gemtek_radio = {
        .owner                  = THIS_MODULE,
        .name                   = "GemTek Radio card",
        .type                   = VID_TYPE_TUNER,
        .fops                   = &gemtek_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
};
 
/*
 * Initialization / cleanup related stuff.
 */
 
/*
 * Initilize card.
 */
static int __init gemtek_init(void)
{
        printk(KERN_INFO RADIO_BANNER "\n");
 
        spin_lock_init(&lock);
 
        gemtek_probe();
        if (io) {
                if (!request_region(io, 1, "gemtek")) {
                        printk(KERN_ERR "I/O port 0x%x already in use.\n", io);
                        return -EBUSY;
                }
 
                if (!gemtek_verify(io))
                        printk(KERN_WARNING "Card at I/O port 0x%x does not "
                               "respond properly, check your "
                               "configuration.\n", io);
                else
                        printk(KERN_INFO "Using I/O port 0x%x.\n", io);
        } else if (probe) {
                printk(KERN_ERR "Automatic probing failed and no "
                       "fixed I/O port defined.\n");
                return -ENODEV;
        } else {
                printk(KERN_ERR "Automatic probing disabled but no fixed "
                       "I/O port defined.");
                return -EINVAL;
        }
 
        gemtek_radio.priv = &gemtek_unit;
 
        if (video_register_device(&gemtek_radio, VFL_TYPE_RADIO,
                radio_nr) == -1) {
                release_region(io, 1);
                return -EBUSY;
        }
 
        /* Set defaults */
        gemtek_unit.lastfreq = GEMTEK_LOWFREQ;
        gemtek_unit.bu2614data = 0;
 
        if (initmute)
                gemtek_mute(&gemtek_unit);
 
        return 0;
}
 
/*
 * Module cleanup
 */
static void __exit gemtek_exit(void)
{
        if (shutdown) {
                hardmute = 1;   /* Turn off PLL */
                gemtek_mute(&gemtek_unit);
        } else {
                printk(KERN_INFO "Module unloaded but card not muted!\n");
        }
 
        video_unregister_device(&gemtek_radio);
        release_region(io, 1);
}
 
module_init(gemtek_init);
module_exit(gemtek_exit);

Browse

Tools

Subversion Repositories test_project

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

Line No.	Rev	Author	Line
1	62	marcus.erl	`/* GemTek radio card driver for Linux (C) 1998 Jonas Munsin <jmunsin@iki.fi>`
2			`*`
3			`* GemTek hasn't released any specs on the card, so the protocol had to`
4			`* be reverse engineered with dosemu.`
5			`*`
6			`* Besides the protocol changes, this is mostly a copy of:`
7			`*`
8			`* RadioTrack II driver for Linux radio support (C) 1998 Ben Pfaff`
9			`*`
10			`* Based on RadioTrack I/RadioReveal (C) 1997 M. Kirkwood`
11			`* Converted to new API by Alan Cox <Alan.Cox@linux.org>`
12			`* Various bugfixes and enhancements by Russell Kroll <rkroll@exploits.org>`
13			`*`
14			`* TODO: Allow for more than one of these foolish entities :-)`
15			`*`
16			`* Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>`
17			`*/`
18
19			`#include <linux/module.h> /* Modules */`
20			`#include <linux/init.h> /* Initdata */`
21			`#include <linux/ioport.h> /* request_region */`
22			`#include <linux/delay.h> /* udelay */`
23			`#include <asm/io.h> /* outb, outb_p */`
24			`#include <asm/uaccess.h> /* copy to/from user */`
25			`#include <linux/videodev2.h> /* kernel radio structs */`
26			`#include <media/v4l2-common.h>`
27			`#include <linux/spinlock.h>`
28
29			`#include <linux/version.h> /* for KERNEL_VERSION MACRO */`
30			`#define RADIO_VERSION KERNEL_VERSION(0,0,3)`
31			`#define RADIO_BANNER "GemTek Radio card driver: v0.0.3"`
32
33			`/*`
34			`* Module info.`
35			`*/`
36
37			`MODULE_AUTHOR("Jonas Munsin, Pekka Sepp�nen <pexu@kapsi.fi>");`
38			`MODULE_DESCRIPTION("A driver for the GemTek Radio card.");`
39			`MODULE_LICENSE("GPL");`
40
41			`/*`
42			`* Module params.`
43			`*/`
44
45			`#ifndef CONFIG_RADIO_GEMTEK_PORT`
46			`#define CONFIG_RADIO_GEMTEK_PORT -1`
47			`#endif`
48			`#ifndef CONFIG_RADIO_GEMTEK_PROBE`
49			`#define CONFIG_RADIO_GEMTEK_PROBE 1`
50			`#endif`
51
52			`static int io = CONFIG_RADIO_GEMTEK_PORT;`
53			`static int probe = CONFIG_RADIO_GEMTEK_PROBE;`
54			`static int hardmute;`
55			`static int shutdown = 1;`
56			`static int keepmuted = 1;`
57			`static int initmute = 1;`
58			`static int radio_nr = -1;`
59
60			`module_param(io, int, 0444);`
61			`MODULE_PARM_DESC(io, "Force I/O port for the GemTek Radio card if automatic"`
62			`"probing is disabled or fails. The most common I/O ports are: 0x20c "`
63			`"0x30c, 0x24c or 0x34c (0x20c, 0x248 and 0x28c have been reported to "`
64			`" work for the combined sound/radiocard).");`
65
66			`module_param(probe, bool, 0444);`
67			`MODULE_PARM_DESC(probe, "Enable automatic device probing. Note: only the most "`
68			`"common I/O ports used by the card are probed.");`
69
70			`module_param(hardmute, bool, 0644);`
71			MODULE_PARM_DESC(hardmute, "Enable `hard muting' by shutting down PLL, may "
72			`"reduce static noise.");`
73
74			`module_param(shutdown, bool, 0644);`
75			`MODULE_PARM_DESC(shutdown, "Enable shutting down PLL and muting line when "`
76			`"module is unloaded.");`
77
78			`module_param(keepmuted, bool, 0644);`
79			`MODULE_PARM_DESC(keepmuted, "Keep card muted even when frequency is changed.");`
80
81			`module_param(initmute, bool, 0444);`
82			`MODULE_PARM_DESC(initmute, "Mute card when module is loaded.");`
83
84			`module_param(radio_nr, int, 0444);`
85
86			`/*`
87			`* Functions for controlling the card.`
88			`*/`
89			`#define GEMTEK_LOWFREQ (87*16000)`
90			`#define GEMTEK_HIGHFREQ (108*16000)`
91
92			`/*`
93			`* Frequency calculation constants. Intermediate frequency 10.52 MHz (nominal`
94			`* value 10.7 MHz), reference divisor 6.39 kHz (nominal 6.25 kHz).`
95			`*/`
96			`#define FSCALE 8`
97			`#define IF_OFFSET ((unsigned int)(10.52 * 16000 * (1<<FSCALE)))`
98			`#define REF_FREQ ((unsigned int)(6.39 * 16 * (1<<FSCALE)))`
99
100			`#define GEMTEK_CK 0x01 /* Clock signal */`
101			`#define GEMTEK_DA 0x02 /* Serial data */`
102			`#define GEMTEK_CE 0x04 /* Chip enable */`
103			`#define GEMTEK_NS 0x08 /* No signal */`
104			`#define GEMTEK_MT 0x10 /* Line mute */`
105			`#define GEMTEK_STDF_3_125_KHZ 0x01 /* Standard frequency 3.125 kHz */`
106			`#define GEMTEK_PLL_OFF 0x07 /* PLL off */`
107
108			`#define BU2614_BUS_SIZE 32 /* BU2614 / BU2614FS bus size */`
109
110			`#define SHORT_DELAY 5 /* usec */`
111			`#define LONG_DELAY 75 /* usec */`
112
113			`struct gemtek_device {`
114			`unsigned long lastfreq;`
115			`int muted;`
116			`u32 bu2614data;`
117			`};`
118
119			`#define BU2614_FREQ_BITS 16 /* D0..D15, Frequency data */`
120			`#define BU2614_PORT_BITS 3 /* P0..P2, Output port control data */`
121			`#define BU2614_VOID_BITS 4 /* unused */`
122			`#define BU2614_FMES_BITS 1 /* CT, Frequency measurement beginning data */`
123			`#define BU2614_STDF_BITS 3 /* R0..R2, Standard frequency data */`
124			`#define BU2614_SWIN_BITS 1 /* S, Switch between FMIN / AMIN */`
125			`#define BU2614_SWAL_BITS 1 /* PS, Swallow counter division (AMIN only)*/`
126			`#define BU2614_VOID2_BITS 1 /* unused */`
127			`#define BU2614_FMUN_BITS 1 /* GT, Frequency measurement time & unlock */`
128			`#define BU2614_TEST_BITS 1 /* TS, Test data is input */`
129
130			`#define BU2614_FREQ_SHIFT 0`
131			`#define BU2614_PORT_SHIFT (BU2614_FREQ_BITS + BU2614_FREQ_SHIFT)`
132			`#define BU2614_VOID_SHIFT (BU2614_PORT_BITS + BU2614_PORT_SHIFT)`
133			`#define BU2614_FMES_SHIFT (BU2614_VOID_BITS + BU2614_VOID_SHIFT)`
134			`#define BU2614_STDF_SHIFT (BU2614_FMES_BITS + BU2614_FMES_SHIFT)`
135			`#define BU2614_SWIN_SHIFT (BU2614_STDF_BITS + BU2614_STDF_SHIFT)`
136			`#define BU2614_SWAL_SHIFT (BU2614_SWIN_BITS + BU2614_SWIN_SHIFT)`
137			`#define BU2614_VOID2_SHIFT (BU2614_SWAL_BITS + BU2614_SWAL_SHIFT)`
138			`#define BU2614_FMUN_SHIFT (BU2614_VOID2_BITS + BU2614_VOID2_SHIFT)`
139			`#define BU2614_TEST_SHIFT (BU2614_FMUN_BITS + BU2614_FMUN_SHIFT)`
140
141			`#define MKMASK(field) (((1<<BU2614_##field##_BITS) - 1) << \`
142			`BU2614_##field##_SHIFT)`
143			`#define BU2614_PORT_MASK MKMASK(PORT)`
144			`#define BU2614_FREQ_MASK MKMASK(FREQ)`
145			`#define BU2614_VOID_MASK MKMASK(VOID)`
146			`#define BU2614_FMES_MASK MKMASK(FMES)`
147			`#define BU2614_STDF_MASK MKMASK(STDF)`
148			`#define BU2614_SWIN_MASK MKMASK(SWIN)`
149			`#define BU2614_SWAL_MASK MKMASK(SWAL)`
150			`#define BU2614_VOID2_MASK MKMASK(VOID2)`
151			`#define BU2614_FMUN_MASK MKMASK(FMUN)`
152			`#define BU2614_TEST_MASK MKMASK(TEST)`
153
154			`static struct gemtek_device gemtek_unit;`
155
156			`static spinlock_t lock;`
157
158			`/*`
159			`* Set data which will be sent to BU2614FS.`
160			`*/`
161			`#define gemtek_bu2614_set(dev, field, data) ((dev)->bu2614data = \`
162			`((dev)->bu2614data & ~field##_MASK) \| ((data) << field##_SHIFT))`
163
164			`/*`
165			`* Transmit settings to BU2614FS over GemTek IC.`
166			`*/`
167			`static void gemtek_bu2614_transmit(struct gemtek_device *dev)`
168			`{`
169			`int i, bit, q, mute;`
170
171			`spin_lock(&lock);`
172
173			`mute = dev->muted ? GEMTEK_MT : 0x00;`
174
175			`outb_p(mute \| GEMTEK_DA \| GEMTEK_CK, io);`
176			`udelay(SHORT_DELAY);`
177			`outb_p(mute \| GEMTEK_CE \| GEMTEK_DA \| GEMTEK_CK, io);`
178			`udelay(LONG_DELAY);`
179
180			`for (i = 0, q = dev->bu2614data; i < 32; i++, q >>= 1) {`
181			`bit = (q & 1) ? GEMTEK_DA : 0;`
182			`outb_p(mute \| GEMTEK_CE \| bit, io);`
183			`udelay(SHORT_DELAY);`
184			`outb_p(mute \| GEMTEK_CE \| bit \| GEMTEK_CK, io);`
185			`udelay(SHORT_DELAY);`
186			`}`
187
188			`outb_p(mute \| GEMTEK_DA \| GEMTEK_CK, io);`
189			`udelay(SHORT_DELAY);`
190			`outb_p(mute \| GEMTEK_CE \| GEMTEK_DA \| GEMTEK_CK, io);`
191			`udelay(LONG_DELAY);`
192
193			`spin_unlock(&lock);`
194			`}`
195
196			`/*`
197			`* Calculate divisor from FM-frequency for BU2614FS (3.125 KHz STDF expected).`
198			`*/`
199			`static unsigned long gemtek_convfreq(unsigned long freq)`
200			`{`
201			`return ((freq<<FSCALE) + IF_OFFSET + REF_FREQ/2) / REF_FREQ;`
202			`}`
203
204			`/*`
205			`* Set FM-frequency.`
206			`*/`
207			`static void gemtek_setfreq(struct gemtek_device *dev, unsigned long freq)`
208			`{`
209
210			`if (keepmuted && hardmute && dev->muted)`
211			`return;`
212
213			`if (freq < GEMTEK_LOWFREQ)`
214			`freq = GEMTEK_LOWFREQ;`
215			`else if (freq > GEMTEK_HIGHFREQ)`
216			`freq = GEMTEK_HIGHFREQ;`
217
218			`dev->lastfreq = freq;`
219			`dev->muted = 0;`
220
221			`gemtek_bu2614_set(dev, BU2614_PORT, 0);`
222			`gemtek_bu2614_set(dev, BU2614_FMES, 0);`
223			`gemtek_bu2614_set(dev, BU2614_SWIN, 0); /* FM-mode */`
224			`gemtek_bu2614_set(dev, BU2614_SWAL, 0);`
225			`gemtek_bu2614_set(dev, BU2614_FMUN, 1); /* GT bit set */`
226			`gemtek_bu2614_set(dev, BU2614_TEST, 0);`
227
228			`gemtek_bu2614_set(dev, BU2614_STDF, GEMTEK_STDF_3_125_KHZ);`
229			`gemtek_bu2614_set(dev, BU2614_FREQ, gemtek_convfreq(freq));`
230
231			`gemtek_bu2614_transmit(dev);`
232			`}`
233
234			`/*`
235			`* Set mute flag.`
236			`*/`
237			`static void gemtek_mute(struct gemtek_device *dev)`
238			`{`
239			`int i;`
240			`dev->muted = 1;`
241
242			`if (hardmute) {`
243			`/* Turn off PLL, disable data output */`
244			`gemtek_bu2614_set(dev, BU2614_PORT, 0);`
245			`gemtek_bu2614_set(dev, BU2614_FMES, 0); /* CT bit off */`
246			`gemtek_bu2614_set(dev, BU2614_SWIN, 0); /* FM-mode */`
247			`gemtek_bu2614_set(dev, BU2614_SWAL, 0);`
248			`gemtek_bu2614_set(dev, BU2614_FMUN, 0); /* GT bit off */`
249			`gemtek_bu2614_set(dev, BU2614_TEST, 0);`
250			`gemtek_bu2614_set(dev, BU2614_STDF, GEMTEK_PLL_OFF);`
251			`gemtek_bu2614_set(dev, BU2614_FREQ, 0);`
252			`gemtek_bu2614_transmit(dev);`
253			`} else {`
254			`spin_lock(&lock);`
255
256			`/* Read bus contents (CE, CK and DA). */`
257			`i = inb_p(io);`
258			`/* Write it back with mute flag set. */`
259			`outb_p((i >> 5) \| GEMTEK_MT, io);`
260			`udelay(SHORT_DELAY);`
261
262			`spin_unlock(&lock);`
263			`}`
264			`}`
265
266			`/*`
267			`* Unset mute flag.`
268			`*/`
269			`static void gemtek_unmute(struct gemtek_device *dev)`
270			`{`
271			`int i;`
272			`dev->muted = 0;`
273
274			`if (hardmute) {`
275			`/* Turn PLL back on. */`
276			`gemtek_setfreq(dev, dev->lastfreq);`
277			`} else {`
278			`spin_lock(&lock);`
279
280			`i = inb_p(io);`
281			`outb_p(i >> 5, io);`
282			`udelay(SHORT_DELAY);`
283
284			`spin_unlock(&lock);`
285			`}`
286			`}`
287
288			`/*`
289			`* Get signal strength (= stereo status).`
290			`*/`
291			`static inline int gemtek_getsigstr(void)`
292			`{`
293			`return inb_p(io) & GEMTEK_NS ? 0 : 1;`
294			`}`
295
296			`/*`
297			`* Check if requested card acts like GemTek Radio card.`
298			`*/`
299			`static int gemtek_verify(int port)`
300			`{`
301			`static int verified = -1;`
302			`int i, q;`
303
304			`if (verified == port)`
305			`return 1;`
306
307			`spin_lock(&lock);`
308
309			`q = inb_p(port); /* Read bus contents before probing. */`
310			`/* Try to turn on CE, CK and DA respectively and check if card responds`
311			`properly. */`
312			`for (i = 0; i < 3; ++i) {`
313			`outb_p(1 << i, port);`
314			`udelay(SHORT_DELAY);`
315
316			`if ((inb_p(port) & (~GEMTEK_NS)) != (0x17 \| (1 << (i + 5)))) {`
317			`spin_unlock(&lock);`
318			`return 0;`
319			`}`
320			`}`
321			`outb_p(q >> 5, port); /* Write bus contents back. */`
322			`udelay(SHORT_DELAY);`
323
324			`spin_unlock(&lock);`
325			`verified = port;`
326
327			`return 1;`
328			`}`
329
330			`/*`
331			`* Automatic probing for card.`
332			`*/`
333			`static int gemtek_probe(void)`
334			`{`
335			`int ioports[] = { 0x20c, 0x30c, 0x24c, 0x34c, 0x248, 0x28c };`
336			`int i;`
337
338			`if (!probe) {`
339			`printk(KERN_INFO "Automatic device probing disabled.\n");`
340			`return -1;`
341			`}`
342
343			`printk(KERN_INFO "Automatic device probing enabled.\n");`
344
345			`for (i = 0; i < ARRAY_SIZE(ioports); ++i) {`
346			`printk(KERN_INFO "Trying I/O port 0x%x...\n", ioports[i]);`
347
348			`if (!request_region(ioports[i], 1, "gemtek-probe")) {`
349			`printk(KERN_WARNING "I/O port 0x%x busy!\n",`
350			`ioports[i]);`
351			`continue;`
352			`}`
353
354			`if (gemtek_verify(ioports[i])) {`
355			`printk(KERN_INFO "Card found from I/O port "`
356			`"0x%x!\n", ioports[i]);`
357
358			`release_region(ioports[i], 1);`
359
360			`io = ioports[i];`
361			`return io;`
362			`}`
363
364			`release_region(ioports[i], 1);`
365			`}`
366
367			`printk(KERN_ERR "Automatic probing failed!\n");`
368
369			`return -1;`
370			`}`
371
372			`/*`
373			`* Video 4 Linux stuff.`
374			`*/`
375
376			`static struct v4l2_queryctrl radio_qctrl[] = {`
377			`{`
378			`.id = V4L2_CID_AUDIO_MUTE,`
379			`.name = "Mute",`
380			`.minimum = 0,`
381			`.maximum = 1,`
382			`.default_value = 1,`
383			`.type = V4L2_CTRL_TYPE_BOOLEAN,`
384			`}, {`
385			`.id = V4L2_CID_AUDIO_VOLUME,`
386			`.name = "Volume",`
387			`.minimum = 0,`
388			`.maximum = 65535,`
389			`.step = 65535,`
390			`.default_value = 0xff,`
391			`.type = V4L2_CTRL_TYPE_INTEGER,`
392			`}`
393			`};`
394
395			`static struct file_operations gemtek_fops = {`
396			`.owner = THIS_MODULE,`
397			`.open = video_exclusive_open,`
398			`.release = video_exclusive_release,`
399			`.ioctl = video_ioctl2,`
400			`.compat_ioctl = v4l_compat_ioctl32,`
401			`.llseek = no_llseek`
402			`};`
403
404			`static int vidioc_querycap(struct file file, void priv,`
405			`struct v4l2_capability *v)`
406			`{`
407			`strlcpy(v->driver, "radio-gemtek", sizeof(v->driver));`
408			`strlcpy(v->card, "GemTek", sizeof(v->card));`
409			`sprintf(v->bus_info, "ISA");`
410			`v->version = RADIO_VERSION;`
411			`v->capabilities = V4L2_CAP_TUNER;`
412			`return 0;`
413			`}`
414
415			`static int vidioc_g_tuner(struct file file, void priv, struct v4l2_tuner *v)`
416			`{`
417			`if (v->index > 0)`
418			`return -EINVAL;`
419
420			`strcpy(v->name, "FM");`
421			`v->type = V4L2_TUNER_RADIO;`
422			`v->rangelow = GEMTEK_LOWFREQ;`
423			`v->rangehigh = GEMTEK_HIGHFREQ;`
424			`v->capability = V4L2_TUNER_CAP_LOW \| V4L2_TUNER_CAP_STEREO;`
425			`v->signal = 0xffff * gemtek_getsigstr();`
426			`if (v->signal) {`
427			`v->audmode = V4L2_TUNER_MODE_STEREO;`
428			`v->rxsubchans = V4L2_TUNER_SUB_STEREO;`
429			`} else {`
430			`v->audmode = V4L2_TUNER_MODE_MONO;`
431			`v->rxsubchans = V4L2_TUNER_SUB_MONO;`
432			`}`
433
434			`return 0;`
435			`}`
436
437			`static int vidioc_s_tuner(struct file file, void priv, struct v4l2_tuner *v)`
438			`{`
439			`if (v->index > 0)`
440			`return -EINVAL;`
441			`return 0;`
442			`}`
443
444			`static int vidioc_s_frequency(struct file file, void priv,`
445			`struct v4l2_frequency *f)`
446			`{`
447			`struct video_device *dev = video_devdata(file);`
448			`struct gemtek_device *rt = dev->priv;`
449
450			`gemtek_setfreq(rt, f->frequency);`
451
452			`return 0;`
453			`}`
454
455			`static int vidioc_g_frequency(struct file file, void priv,`
456			`struct v4l2_frequency *f)`
457			`{`
458			`struct video_device *dev = video_devdata(file);`
459			`struct gemtek_device *rt = dev->priv;`
460
461			`f->type = V4L2_TUNER_RADIO;`
462			`f->frequency = rt->lastfreq;`
463			`return 0;`
464			`}`
465
466			`static int vidioc_queryctrl(struct file file, void priv,`
467			`struct v4l2_queryctrl *qc)`
468			`{`
469			`int i;`
470
471			`for (i = 0; i < ARRAY_SIZE(radio_qctrl); ++i) {`
472			`if (qc->id && qc->id == radio_qctrl[i].id) {`
473			`memcpy(qc, &(radio_qctrl[i]), sizeof(*qc));`
474			`return 0;`
475			`}`
476			`}`
477			`return -EINVAL;`
478			`}`
479
480			`static int vidioc_g_ctrl(struct file file, void priv,`
481			`struct v4l2_control *ctrl)`
482			`{`
483			`struct video_device *dev = video_devdata(file);`
484			`struct gemtek_device *rt = dev->priv;`
485
486			`switch (ctrl->id) {`
487			`case V4L2_CID_AUDIO_MUTE:`
488			`ctrl->value = rt->muted;`
489			`return 0;`
490			`case V4L2_CID_AUDIO_VOLUME:`
491			`if (rt->muted)`
492			`ctrl->value = 0;`
493			`else`
494			`ctrl->value = 65535;`
495			`return 0;`
496			`}`
497			`return -EINVAL;`
498			`}`
499
500			`static int vidioc_s_ctrl(struct file file, void priv,`
501			`struct v4l2_control *ctrl)`
502			`{`
503			`struct video_device *dev = video_devdata(file);`
504			`struct gemtek_device *rt = dev->priv;`
505
506			`switch (ctrl->id) {`
507			`case V4L2_CID_AUDIO_MUTE:`
508			`if (ctrl->value)`
509			`gemtek_mute(rt);`
510			`else`
511			`gemtek_unmute(rt);`
512			`return 0;`
513			`case V4L2_CID_AUDIO_VOLUME:`
514			`if (ctrl->value)`
515			`gemtek_unmute(rt);`
516			`else`
517			`gemtek_mute(rt);`
518			`return 0;`
519			`}`
520			`return -EINVAL;`
521			`}`
522
523			`static int vidioc_g_audio(struct file file, void priv, struct v4l2_audio *a)`
524			`{`
525			`if (a->index > 1)`
526			`return -EINVAL;`
527
528			`strcpy(a->name, "Radio");`
529			`a->capability = V4L2_AUDCAP_STEREO;`
530			`return 0;`
531			`}`
532
533			`static int vidioc_g_input(struct file filp, void priv, unsigned int *i)`
534			`{`
535			`*i = 0;`
536			`return 0;`
537			`}`
538
539			`static int vidioc_s_input(struct file filp, void priv, unsigned int i)`
540			`{`
541			`if (i != 0)`
542			`return -EINVAL;`
543			`return 0;`
544			`}`
545
546			`static int vidioc_s_audio(struct file file, void priv, struct v4l2_audio *a)`
547			`{`
548			`if (a->index != 0)`
549			`return -EINVAL;`
550			`return 0;`
551			`}`
552
553			`static struct video_device gemtek_radio = {`
554			`.owner = THIS_MODULE,`
555			`.name = "GemTek Radio card",`
556			`.type = VID_TYPE_TUNER,`
557			`.fops = &gemtek_fops,`
558			`.vidioc_querycap = vidioc_querycap,`
559			`.vidioc_g_tuner = vidioc_g_tuner,`
560			`.vidioc_s_tuner = vidioc_s_tuner,`
561			`.vidioc_g_audio = vidioc_g_audio,`
562			`.vidioc_s_audio = vidioc_s_audio,`
563			`.vidioc_g_input = vidioc_g_input,`
564			`.vidioc_s_input = vidioc_s_input,`
565			`.vidioc_g_frequency = vidioc_g_frequency,`
566			`.vidioc_s_frequency = vidioc_s_frequency,`
567			`.vidioc_queryctrl = vidioc_queryctrl,`
568			`.vidioc_g_ctrl = vidioc_g_ctrl,`
569			`.vidioc_s_ctrl = vidioc_s_ctrl`
570			`};`
571
572			`/*`
573			`* Initialization / cleanup related stuff.`
574			`*/`
575
576			`/*`
577			`* Initilize card.`
578			`*/`
579			`static int __init gemtek_init(void)`
580			`{`
581			`printk(KERN_INFO RADIO_BANNER "\n");`
582
583			`spin_lock_init(&lock);`
584
585			`gemtek_probe();`
586			`if (io) {`
587			`if (!request_region(io, 1, "gemtek")) {`
588			`printk(KERN_ERR "I/O port 0x%x already in use.\n", io);`
589			`return -EBUSY;`
590			`}`
591
592			`if (!gemtek_verify(io))`
593			`printk(KERN_WARNING "Card at I/O port 0x%x does not "`
594			`"respond properly, check your "`
595			`"configuration.\n", io);`
596			`else`
597			`printk(KERN_INFO "Using I/O port 0x%x.\n", io);`
598			`} else if (probe) {`
599			`printk(KERN_ERR "Automatic probing failed and no "`
600			`"fixed I/O port defined.\n");`
601			`return -ENODEV;`
602			`} else {`
603			`printk(KERN_ERR "Automatic probing disabled but no fixed "`
604			`"I/O port defined.");`
605			`return -EINVAL;`
606			`}`
607
608			`gemtek_radio.priv = &gemtek_unit;`
609
610			`if (video_register_device(&gemtek_radio, VFL_TYPE_RADIO,`
611			`radio_nr) == -1) {`
612			`release_region(io, 1);`
613			`return -EBUSY;`
614			`}`
615
616			`/* Set defaults */`
617			`gemtek_unit.lastfreq = GEMTEK_LOWFREQ;`
618			`gemtek_unit.bu2614data = 0;`
619
620			`if (initmute)`
621			`gemtek_mute(&gemtek_unit);`
622
623			`return 0;`
624			`}`
625
626			`/*`
627			`* Module cleanup`
628			`*/`
629			`static void __exit gemtek_exit(void)`
630			`{`
631			`if (shutdown) {`
632			`hardmute = 1; /* Turn off PLL */`
633			`gemtek_mute(&gemtek_unit);`
634			`} else {`
635			`printk(KERN_INFO "Module unloaded but card not muted!\n");`
636			`}`
637
638			`video_unregister_device(&gemtek_radio);`
639			`release_region(io, 1);`
640			`}`
641
642			`module_init(gemtek_init);`
643			`module_exit(gemtek_exit);`