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

Subversion Repositories test_project

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

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


/* radio-cadet.c - A video4linux driver for the ADS Cadet AM/FM Radio Card
 *
 * by Fred Gleason <fredg@wava.com>
 * Version 0.3.3
 *
 * (Loosely) based on code for the Aztech radio card by
 *
 * Russell Kroll    (rkroll@exploits.org)
 * Quay Ly
 * Donald Song
 * Jason Lewis      (jlewis@twilight.vtc.vsc.edu)
 * Scott McGrath    (smcgrath@twilight.vtc.vsc.edu)
 * William McGrath  (wmcgrath@twilight.vtc.vsc.edu)
 *
 * History:
 * 2000-04-29   Russell Kroll <rkroll@exploits.org>
 *              Added ISAPnP detection for Linux 2.3/2.4
 *
 * 2001-01-10   Russell Kroll <rkroll@exploits.org>
 *              Removed dead CONFIG_RADIO_CADET_PORT code
 *              PnP detection on load is now default (no args necessary)
 *
 * 2002-01-17   Adam Belay <ambx1@neo.rr.com>
 *              Updated to latest pnp code
 *
 * 2003-01-31   Alan Cox <alan@redhat.com>
 *              Cleaned up locking, delay code, general odds and ends
 *
 * 2006-07-30   Hans J. Koch <koch@hjk-az.de>
 *              Changed API to V4L2
 */
 
#include <linux/version.h>
#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>    /* V4L2 API defs                */
#include <media/v4l2-common.h>
#include <linux/param.h>
#include <linux/pnp.h>
 
#define RDS_BUFFER 256
#define RDS_RX_FLAG 1
#define MBS_RX_FLAG 2
 
#define CADET_VERSION KERNEL_VERSION(0,3,3)
 
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       = 0xff,
                .step          = 1,
                .default_value = 0xff,
                .type          = V4L2_CTRL_TYPE_INTEGER,
        }
};
 
static int io=-1;               /* default to isapnp activation */
static int radio_nr = -1;
static int users=0;
static int curtuner=0;
static int tunestat=0;
static int sigstrength=0;
static wait_queue_head_t read_queue;
static struct timer_list readtimer;
static __u8 rdsin=0,rdsout=0,rdsstat=0;
static unsigned char rdsbuf[RDS_BUFFER];
static spinlock_t cadet_io_lock;
 
static int cadet_probe(void);
 
/*
 * Signal Strength Threshold Values
 * The V4L API spec does not define any particular unit for the signal
 * strength value.  These values are in microvolts of RF at the tuner's input.
 */
static __u16 sigtable[2][4]={{5,10,30,150},{28,40,63,1000}};
 
 
static int
cadet_getstereo(void)
{
        int ret = V4L2_TUNER_SUB_MONO;
        if(curtuner != 0)        /* Only FM has stereo capability! */
                return V4L2_TUNER_SUB_MONO;
 
        spin_lock(&cadet_io_lock);
        outb(7,io);          /* Select tuner control */
        if( (inb(io+1) & 0x40) == 0)
                ret = V4L2_TUNER_SUB_STEREO;
        spin_unlock(&cadet_io_lock);
        return ret;
}
 
static unsigned
cadet_gettune(void)
{
        int curvol,i;
        unsigned fifo=0;
 
        /*
         * Prepare for read
         */
 
        spin_lock(&cadet_io_lock);
 
        outb(7,io);       /* Select tuner control */
        curvol=inb(io+1); /* Save current volume/mute setting */
        outb(0x00,io+1);  /* Ensure WRITE-ENABLE is LOW */
        tunestat=0xffff;
 
        /*
         * Read the shift register
         */
        for(i=0;i<25;i++) {
                fifo=(fifo<<1)|((inb(io+1)>>7)&0x01);
                if(i<24) {
                        outb(0x01,io+1);
                        tunestat&=inb(io+1);
                        outb(0x00,io+1);
                }
        }
 
        /*
         * Restore volume/mute setting
         */
        outb(curvol,io+1);
        spin_unlock(&cadet_io_lock);
 
        return fifo;
}
 
static unsigned
cadet_getfreq(void)
{
        int i;
        unsigned freq=0,test,fifo=0;
 
        /*
         * Read current tuning
         */
        fifo=cadet_gettune();
 
        /*
         * Convert to actual frequency
         */
        if(curtuner==0) {    /* FM */
                test=12500;
                for(i=0;i<14;i++) {
                        if((fifo&0x01)!=0) {
                                freq+=test;
                        }
                        test=test<<1;
                        fifo=fifo>>1;
                }
                freq-=10700000;           /* IF frequency is 10.7 MHz */
                freq=(freq*16)/1000000;   /* Make it 1/16 MHz */
        }
        if(curtuner==1) {    /* AM */
                freq=((fifo&0x7fff)-2010)*16;
        }
 
        return freq;
}
 
static void
cadet_settune(unsigned fifo)
{
        int i;
        unsigned test;
 
        spin_lock(&cadet_io_lock);
 
        outb(7,io);                /* Select tuner control */
        /*
         * Write the shift register
         */
        test=0;
        test=(fifo>>23)&0x02;      /* Align data for SDO */
        test|=0x1c;                /* SDM=1, SWE=1, SEN=1, SCK=0 */
        outb(7,io);                /* Select tuner control */
        outb(test,io+1);           /* Initialize for write */
        for(i=0;i<25;i++) {
                test|=0x01;              /* Toggle SCK High */
                outb(test,io+1);
                test&=0xfe;              /* Toggle SCK Low */
                outb(test,io+1);
                fifo=fifo<<1;            /* Prepare the next bit */
                test=0x1c|((fifo>>23)&0x02);
                outb(test,io+1);
        }
        spin_unlock(&cadet_io_lock);
}
 
static void
cadet_setfreq(unsigned freq)
{
        unsigned fifo;
        int i,j,test;
        int curvol;
 
        /*
         * Formulate a fifo command
         */
        fifo=0;
        if(curtuner==0) {    /* FM */
                test=102400;
                freq=(freq*1000)/16;       /* Make it kHz */
                freq+=10700;               /* IF is 10700 kHz */
                for(i=0;i<14;i++) {
                        fifo=fifo<<1;
                        if(freq>=test) {
                                fifo|=0x01;
                                freq-=test;
                        }
                        test=test>>1;
                }
        }
        if(curtuner==1) {    /* AM */
                fifo=(freq/16)+2010;            /* Make it kHz */
                fifo|=0x100000;            /* Select AM Band */
        }
 
        /*
         * Save current volume/mute setting
         */
 
        spin_lock(&cadet_io_lock);
        outb(7,io);                /* Select tuner control */
        curvol=inb(io+1);
        spin_unlock(&cadet_io_lock);
 
        /*
         * Tune the card
         */
        for(j=3;j>-1;j--) {
                cadet_settune(fifo|(j<<16));
 
                spin_lock(&cadet_io_lock);
                outb(7,io);         /* Select tuner control */
                outb(curvol,io+1);
                spin_unlock(&cadet_io_lock);
 
                msleep(100);
 
                cadet_gettune();
                if((tunestat & 0x40) == 0) {   /* Tuned */
                        sigstrength=sigtable[curtuner][j];
                        return;
                }
        }
        sigstrength=0;
}
 
 
static int
cadet_getvol(void)
{
        int ret = 0;
 
        spin_lock(&cadet_io_lock);
 
        outb(7,io);                /* Select tuner control */
        if((inb(io + 1) & 0x20) != 0)
                ret = 0xffff;
 
        spin_unlock(&cadet_io_lock);
        return ret;
}
 
 
static void
cadet_setvol(int vol)
{
        spin_lock(&cadet_io_lock);
        outb(7,io);                /* Select tuner control */
        if(vol>0)
                outb(0x20,io+1);
        else
                outb(0x00,io+1);
        spin_unlock(&cadet_io_lock);
}
 
static void
cadet_handler(unsigned long data)
{
        /*
         * Service the RDS fifo
         */
 
        if(spin_trylock(&cadet_io_lock))
        {
                outb(0x3,io);       /* Select RDS Decoder Control */
                if((inb(io+1)&0x20)!=0) {
                        printk(KERN_CRIT "cadet: RDS fifo overflow\n");
                }
                outb(0x80,io);      /* Select RDS fifo */
                while((inb(io)&0x80)!=0) {
                        rdsbuf[rdsin]=inb(io+1);
                        if(rdsin==rdsout)
                                printk(KERN_WARNING "cadet: RDS buffer overflow\n");
                        else
                                rdsin++;
                }
                spin_unlock(&cadet_io_lock);
        }
 
        /*
         * Service pending read
         */
        if( rdsin!=rdsout)
                wake_up_interruptible(&read_queue);
 
        /*
         * Clean up and exit
         */
        init_timer(&readtimer);
        readtimer.function=cadet_handler;
        readtimer.data=(unsigned long)0;
        readtimer.expires=jiffies+msecs_to_jiffies(50);
        add_timer(&readtimer);
}
 
 
 
static ssize_t
cadet_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
{
        int i=0;
        unsigned char readbuf[RDS_BUFFER];
 
        if(rdsstat==0) {
                spin_lock(&cadet_io_lock);
                rdsstat=1;
                outb(0x80,io);        /* Select RDS fifo */
                spin_unlock(&cadet_io_lock);
                init_timer(&readtimer);
                readtimer.function=cadet_handler;
                readtimer.data=(unsigned long)0;
                readtimer.expires=jiffies+msecs_to_jiffies(50);
                add_timer(&readtimer);
        }
        if(rdsin==rdsout) {
                if (file->f_flags & O_NONBLOCK)
                        return -EWOULDBLOCK;
                interruptible_sleep_on(&read_queue);
        }
        while( i<count && rdsin!=rdsout)
                readbuf[i++]=rdsbuf[rdsout++];
 
        if (copy_to_user(data,readbuf,i))
                return -EFAULT;
        return i;
}
 
 
static int vidioc_querycap(struct file *file, void *priv,
                                struct v4l2_capability *v)
{
        v->capabilities =
                V4L2_CAP_TUNER |
                V4L2_CAP_READWRITE;
        v->version = CADET_VERSION;
        strcpy(v->driver, "ADS Cadet");
        strcpy(v->card, "ADS Cadet");
        return 0;
}
 
static int vidioc_g_tuner(struct file *file, void *priv,
                                struct v4l2_tuner *v)
{
        v->type = V4L2_TUNER_RADIO;
        switch (v->index) {
        case 0:
                strcpy(v->name, "FM");
                v->capability = V4L2_TUNER_CAP_STEREO;
                v->rangelow = 1400;     /* 87.5 MHz */
                v->rangehigh = 1728;    /* 108.0 MHz */
                v->rxsubchans=cadet_getstereo();
                switch (v->rxsubchans){
                case V4L2_TUNER_SUB_MONO:
                        v->audmode = V4L2_TUNER_MODE_MONO;
                        break;
                case V4L2_TUNER_SUB_STEREO:
                        v->audmode = V4L2_TUNER_MODE_STEREO;
                        break;
                default: ;
                }
                break;
        case 1:
                strcpy(v->name, "AM");
                v->capability = V4L2_TUNER_CAP_LOW;
                v->rangelow = 8320;      /* 520 kHz */
                v->rangehigh = 26400;    /* 1650 kHz */
                v->rxsubchans = V4L2_TUNER_SUB_MONO;
                v->audmode = V4L2_TUNER_MODE_MONO;
                break;
        default:
                return -EINVAL;
        }
        v->signal = sigstrength; /* We might need to modify scaling of this */
        return 0;
}
 
static int vidioc_s_tuner(struct file *file, void *priv,
                                struct v4l2_tuner *v)
{
        if((v->index != 0)&&(v->index != 1))
                return -EINVAL;
        curtuner = v->index;
        return 0;
}
 
static int vidioc_g_frequency(struct file *file, void *priv,
                                struct v4l2_frequency *f)
{
        f->tuner = curtuner;
        f->type = V4L2_TUNER_RADIO;
        f->frequency = cadet_getfreq();
        return 0;
}
 
 
static int vidioc_s_frequency(struct file *file, void *priv,
                                struct v4l2_frequency *f)
{
        if (f->type != V4L2_TUNER_RADIO)
                return -EINVAL;
        if((curtuner==0)&&((f->frequency<1400)||(f->frequency>1728)))
                return -EINVAL;
        if((curtuner==1)&&((f->frequency<8320)||(f->frequency>26400)))
                return -EINVAL;
        cadet_setfreq(f->frequency);
        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)
{
        switch (ctrl->id){
        case V4L2_CID_AUDIO_MUTE: /* TODO: Handle this correctly */
                ctrl->value = (cadet_getvol() == 0);
                break;
        case V4L2_CID_AUDIO_VOLUME:
                ctrl->value = cadet_getvol();
                break;
        default:
                return -EINVAL;
        }
        return 0;
}
 
static int vidioc_s_ctrl(struct file *file, void *priv,
                                struct v4l2_control *ctrl)
{
        switch (ctrl->id){
        case V4L2_CID_AUDIO_MUTE: /* TODO: Handle this correctly */
                if (ctrl->value)
                        cadet_setvol(0);
                else
                        cadet_setvol(0xffff);
                break;
        case V4L2_CID_AUDIO_VOLUME:
                cadet_setvol(ctrl->value);
                break;
        default:
                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, "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 int
cadet_open(struct inode *inode, struct file *file)
{
        users++;
        if (1 == users) init_waitqueue_head(&read_queue);
        return 0;
}
 
static int
cadet_release(struct inode *inode, struct file *file)
{
        users--;
        if (0 == users){
                del_timer_sync(&readtimer);
                rdsstat=0;
        }
        return 0;
}
 
static unsigned int
cadet_poll(struct file *file, struct poll_table_struct *wait)
{
        poll_wait(file,&read_queue,wait);
        if(rdsin != rdsout)
                return POLLIN | POLLRDNORM;
        return 0;
}
 
 
static const struct file_operations cadet_fops = {
        .owner          = THIS_MODULE,
        .open           = cadet_open,
        .release        = cadet_release,
        .read           = cadet_read,
        .ioctl          = video_ioctl2,
        .poll           = cadet_poll,
        .compat_ioctl   = v4l_compat_ioctl32,
        .llseek         = no_llseek,
};
 
static struct video_device cadet_radio=
{
        .owner          = THIS_MODULE,
        .name           = "Cadet radio",
        .type           = VID_TYPE_TUNER,
        .fops           = &cadet_fops,
        .vidioc_querycap    = vidioc_querycap,
        .vidioc_g_tuner     = vidioc_g_tuner,
        .vidioc_s_tuner     = vidioc_s_tuner,
        .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,
        .vidioc_g_audio     = vidioc_g_audio,
        .vidioc_s_audio     = vidioc_s_audio,
        .vidioc_g_input     = vidioc_g_input,
        .vidioc_s_input     = vidioc_s_input,
};
 
static struct pnp_device_id cadet_pnp_devices[] = {
        /* ADS Cadet AM/FM Radio Card */
        {.id = "MSM0c24", .driver_data = 0},
        {.id = ""}
};
 
MODULE_DEVICE_TABLE(pnp, cadet_pnp_devices);
 
static int cadet_pnp_probe(struct pnp_dev * dev, const struct pnp_device_id *dev_id)
{
        if (!dev)
                return -ENODEV;
        /* only support one device */
        if (io > 0)
                return -EBUSY;
 
        if (!pnp_port_valid(dev, 0)) {
                return -ENODEV;
        }
 
        io = pnp_port_start(dev, 0);
 
        printk ("radio-cadet: PnP reports device at %#x\n", io);
 
        return io;
}
 
static struct pnp_driver cadet_pnp_driver = {
        .name           = "radio-cadet",
        .id_table       = cadet_pnp_devices,
        .probe          = cadet_pnp_probe,
        .remove         = NULL,
};
 
static int cadet_probe(void)
{
        static int iovals[8]={0x330,0x332,0x334,0x336,0x338,0x33a,0x33c,0x33e};
        int i;
 
        for(i=0;i<8;i++) {
                io=iovals[i];
                if (request_region(io, 2, "cadet-probe")) {
                        cadet_setfreq(1410);
                        if(cadet_getfreq()==1410) {
                                release_region(io, 2);
                                return io;
                        }
                        release_region(io, 2);
                }
        }
        return -1;
}
 
/*
 * io should only be set if the user has used something like
 * isapnp (the userspace program) to initialize this card for us
 */
 
static int __init cadet_init(void)
{
        spin_lock_init(&cadet_io_lock);
 
        /*
         *      If a probe was requested then probe ISAPnP first (safest)
         */
        if (io < 0)
                pnp_register_driver(&cadet_pnp_driver);
        /*
         *      If that fails then probe unsafely if probe is requested
         */
        if(io < 0)
                io = cadet_probe ();
 
        /*
         *      Else we bail out
         */
 
        if(io < 0) {
#ifdef MODULE
                printk(KERN_ERR "You must set an I/O address with io=0x???\n");
#endif
                goto fail;
        }
        if (!request_region(io,2,"cadet"))
                goto fail;
        if(video_register_device(&cadet_radio,VFL_TYPE_RADIO,radio_nr)==-1) {
                release_region(io,2);
                goto fail;
        }
        printk(KERN_INFO "ADS Cadet Radio Card at 0x%x\n",io);
        return 0;
fail:
        pnp_unregister_driver(&cadet_pnp_driver);
        return -1;
}
 
 
 
MODULE_AUTHOR("Fred Gleason, Russell Kroll, Quay Lu, Donald Song, Jason Lewis, Scott McGrath, William McGrath");
MODULE_DESCRIPTION("A driver for the ADS Cadet AM/FM/RDS radio card.");
MODULE_LICENSE("GPL");
 
module_param(io, int, 0);
MODULE_PARM_DESC(io, "I/O address of Cadet card (0x330,0x332,0x334,0x336,0x338,0x33a,0x33c,0x33e)");
module_param(radio_nr, int, 0);
 
static void __exit cadet_cleanup_module(void)
{
        video_unregister_device(&cadet_radio);
        release_region(io,2);
        pnp_unregister_driver(&cadet_pnp_driver);
}
 
module_init(cadet_init);
module_exit(cadet_cleanup_module);
 

Browse

Tools

Subversion Repositories test_project

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

Line No.	Rev	Author	Line
1	62	marcus.erl	`/* radio-cadet.c - A video4linux driver for the ADS Cadet AM/FM Radio Card`
2			`*`
3			`* by Fred Gleason <fredg@wava.com>`
4			`* Version 0.3.3`
5			`*`
6			`* (Loosely) based on code for the Aztech radio card by`
7			`*`
8			`* Russell Kroll (rkroll@exploits.org)`
9			`* Quay Ly`
10			`* Donald Song`
11			`* Jason Lewis (jlewis@twilight.vtc.vsc.edu)`
12			`* Scott McGrath (smcgrath@twilight.vtc.vsc.edu)`
13			`* William McGrath (wmcgrath@twilight.vtc.vsc.edu)`
14			`*`
15			`* History:`
16			`* 2000-04-29 Russell Kroll <rkroll@exploits.org>`
17			`* Added ISAPnP detection for Linux 2.3/2.4`
18			`*`
19			`* 2001-01-10 Russell Kroll <rkroll@exploits.org>`
20			`* Removed dead CONFIG_RADIO_CADET_PORT code`
21			`* PnP detection on load is now default (no args necessary)`
22			`*`
23			`* 2002-01-17 Adam Belay <ambx1@neo.rr.com>`
24			`* Updated to latest pnp code`
25			`*`
26			`* 2003-01-31 Alan Cox <alan@redhat.com>`
27			`* Cleaned up locking, delay code, general odds and ends`
28			`*`
29			`* 2006-07-30 Hans J. Koch <koch@hjk-az.de>`
30			`* Changed API to V4L2`
31			`*/`
32
33			`#include <linux/version.h>`
34			`#include <linux/module.h> /* Modules */`
35			`#include <linux/init.h> /* Initdata */`
36			`#include <linux/ioport.h> /* request_region */`
37			`#include <linux/delay.h> /* udelay */`
38			`#include <asm/io.h> /* outb, outb_p */`
39			`#include <asm/uaccess.h> /* copy to/from user */`
40			`#include <linux/videodev2.h> /* V4L2 API defs */`
41			`#include <media/v4l2-common.h>`
42			`#include <linux/param.h>`
43			`#include <linux/pnp.h>`
44
45			`#define RDS_BUFFER 256`
46			`#define RDS_RX_FLAG 1`
47			`#define MBS_RX_FLAG 2`
48
49			`#define CADET_VERSION KERNEL_VERSION(0,3,3)`
50
51			`static struct v4l2_queryctrl radio_qctrl[] = {`
52			`{`
53			`.id = V4L2_CID_AUDIO_MUTE,`
54			`.name = "Mute",`
55			`.minimum = 0,`
56			`.maximum = 1,`
57			`.default_value = 1,`
58			`.type = V4L2_CTRL_TYPE_BOOLEAN,`
59			`},{`
60			`.id = V4L2_CID_AUDIO_VOLUME,`
61			`.name = "Volume",`
62			`.minimum = 0,`
63			`.maximum = 0xff,`
64			`.step = 1,`
65			`.default_value = 0xff,`
66			`.type = V4L2_CTRL_TYPE_INTEGER,`
67			`}`
68			`};`
69
70			`static int io=-1; /* default to isapnp activation */`
71			`static int radio_nr = -1;`
72			`static int users=0;`
73			`static int curtuner=0;`
74			`static int tunestat=0;`
75			`static int sigstrength=0;`
76			`static wait_queue_head_t read_queue;`
77			`static struct timer_list readtimer;`
78			`static __u8 rdsin=0,rdsout=0,rdsstat=0;`
79			`static unsigned char rdsbuf[RDS_BUFFER];`
80			`static spinlock_t cadet_io_lock;`
81
82			`static int cadet_probe(void);`
83
84			`/*`
85			`* Signal Strength Threshold Values`
86			`* The V4L API spec does not define any particular unit for the signal`
87			`* strength value. These values are in microvolts of RF at the tuner's input.`
88			`*/`
89			`static __u16 sigtable[2][4]={{5,10,30,150},{28,40,63,1000}};`
90
91
92			`static int`
93			`cadet_getstereo(void)`
94			`{`
95			`int ret = V4L2_TUNER_SUB_MONO;`
96			`if(curtuner != 0) /* Only FM has stereo capability! */`
97			`return V4L2_TUNER_SUB_MONO;`
98
99			`spin_lock(&cadet_io_lock);`
100			`outb(7,io); /* Select tuner control */`
101			`if( (inb(io+1) & 0x40) == 0)`
102			`ret = V4L2_TUNER_SUB_STEREO;`
103			`spin_unlock(&cadet_io_lock);`
104			`return ret;`
105			`}`
106
107			`static unsigned`
108			`cadet_gettune(void)`
109			`{`
110			`int curvol,i;`
111			`unsigned fifo=0;`
112
113			`/*`
114			`* Prepare for read`
115			`*/`
116
117			`spin_lock(&cadet_io_lock);`
118
119			`outb(7,io); /* Select tuner control */`
120			`curvol=inb(io+1); /* Save current volume/mute setting */`
121			`outb(0x00,io+1); /* Ensure WRITE-ENABLE is LOW */`
122			`tunestat=0xffff;`
123
124			`/*`
125			`* Read the shift register`
126			`*/`
127			`for(i=0;i<25;i++) {`
128			`fifo=(fifo<<1)\|((inb(io+1)>>7)&0x01);`
129			`if(i<24) {`
130			`outb(0x01,io+1);`
131			`tunestat&=inb(io+1);`
132			`outb(0x00,io+1);`
133			`}`
134			`}`
135
136			`/*`
137			`* Restore volume/mute setting`
138			`*/`
139			`outb(curvol,io+1);`
140			`spin_unlock(&cadet_io_lock);`
141
142			`return fifo;`
143			`}`
144
145			`static unsigned`
146			`cadet_getfreq(void)`
147			`{`
148			`int i;`
149			`unsigned freq=0,test,fifo=0;`
150
151			`/*`
152			`* Read current tuning`
153			`*/`
154			`fifo=cadet_gettune();`
155
156			`/*`
157			`* Convert to actual frequency`
158			`*/`
159			`if(curtuner==0) { /* FM */`
160			`test=12500;`
161			`for(i=0;i<14;i++) {`
162			`if((fifo&0x01)!=0) {`
163			`freq+=test;`
164			`}`
165			`test=test<<1;`
166			`fifo=fifo>>1;`
167			`}`
168			`freq-=10700000; /* IF frequency is 10.7 MHz */`
169			`freq=(freq16)/1000000; / Make it 1/16 MHz */`
170			`}`
171			`if(curtuner==1) { /* AM */`
172			`freq=((fifo&0x7fff)-2010)*16;`
173			`}`
174
175			`return freq;`
176			`}`
177
178			`static void`
179			`cadet_settune(unsigned fifo)`
180			`{`
181			`int i;`
182			`unsigned test;`
183
184			`spin_lock(&cadet_io_lock);`
185
186			`outb(7,io); /* Select tuner control */`
187			`/*`
188			`* Write the shift register`
189			`*/`
190			`test=0;`
191			`test=(fifo>>23)&0x02; /* Align data for SDO */`
192			`test\|=0x1c; /* SDM=1, SWE=1, SEN=1, SCK=0 */`
193			`outb(7,io); /* Select tuner control */`
194			`outb(test,io+1); /* Initialize for write */`
195			`for(i=0;i<25;i++) {`
196			`test\|=0x01; /* Toggle SCK High */`
197			`outb(test,io+1);`
198			`test&=0xfe; /* Toggle SCK Low */`
199			`outb(test,io+1);`
200			`fifo=fifo<<1; /* Prepare the next bit */`
201			`test=0x1c\|((fifo>>23)&0x02);`
202			`outb(test,io+1);`
203			`}`
204			`spin_unlock(&cadet_io_lock);`
205			`}`
206
207			`static void`
208			`cadet_setfreq(unsigned freq)`
209			`{`
210			`unsigned fifo;`
211			`int i,j,test;`
212			`int curvol;`
213
214			`/*`
215			`* Formulate a fifo command`
216			`*/`
217			`fifo=0;`
218			`if(curtuner==0) { /* FM */`
219			`test=102400;`
220			`freq=(freq1000)/16; / Make it kHz */`
221			`freq+=10700; /* IF is 10700 kHz */`
222			`for(i=0;i<14;i++) {`
223			`fifo=fifo<<1;`
224			`if(freq>=test) {`
225			`fifo\|=0x01;`
226			`freq-=test;`
227			`}`
228			`test=test>>1;`
229			`}`
230			`}`
231			`if(curtuner==1) { /* AM */`
232			`fifo=(freq/16)+2010; /* Make it kHz */`
233			`fifo\|=0x100000; /* Select AM Band */`
234			`}`
235
236			`/*`
237			`* Save current volume/mute setting`
238			`*/`
239
240			`spin_lock(&cadet_io_lock);`
241			`outb(7,io); /* Select tuner control */`
242			`curvol=inb(io+1);`
243			`spin_unlock(&cadet_io_lock);`
244
245			`/*`
246			`* Tune the card`
247			`*/`
248			`for(j=3;j>-1;j--) {`
249			`cadet_settune(fifo\|(j<<16));`
250
251			`spin_lock(&cadet_io_lock);`
252			`outb(7,io); /* Select tuner control */`
253			`outb(curvol,io+1);`
254			`spin_unlock(&cadet_io_lock);`
255
256			`msleep(100);`
257
258			`cadet_gettune();`
259			`if((tunestat & 0x40) == 0) { /* Tuned */`
260			`sigstrength=sigtable[curtuner][j];`
261			`return;`
262			`}`
263			`}`
264			`sigstrength=0;`
265			`}`
266
267
268			`static int`
269			`cadet_getvol(void)`
270			`{`
271			`int ret = 0;`
272
273			`spin_lock(&cadet_io_lock);`
274
275			`outb(7,io); /* Select tuner control */`
276			`if((inb(io + 1) & 0x20) != 0)`
277			`ret = 0xffff;`
278
279			`spin_unlock(&cadet_io_lock);`
280			`return ret;`
281			`}`
282
283
284			`static void`
285			`cadet_setvol(int vol)`
286			`{`
287			`spin_lock(&cadet_io_lock);`
288			`outb(7,io); /* Select tuner control */`
289			`if(vol>0)`
290			`outb(0x20,io+1);`
291			`else`
292			`outb(0x00,io+1);`
293			`spin_unlock(&cadet_io_lock);`
294			`}`
295
296			`static void`
297			`cadet_handler(unsigned long data)`
298			`{`
299			`/*`
300			`* Service the RDS fifo`
301			`*/`
302
303			`if(spin_trylock(&cadet_io_lock))`
304			`{`
305			`outb(0x3,io); /* Select RDS Decoder Control */`
306			`if((inb(io+1)&0x20)!=0) {`
307			`printk(KERN_CRIT "cadet: RDS fifo overflow\n");`
308			`}`
309			`outb(0x80,io); /* Select RDS fifo */`
310			`while((inb(io)&0x80)!=0) {`
311			`rdsbuf[rdsin]=inb(io+1);`
312			`if(rdsin==rdsout)`
313			`printk(KERN_WARNING "cadet: RDS buffer overflow\n");`
314			`else`
315			`rdsin++;`
316			`}`
317			`spin_unlock(&cadet_io_lock);`
318			`}`
319
320			`/*`
321			`* Service pending read`
322			`*/`
323			`if( rdsin!=rdsout)`
324			`wake_up_interruptible(&read_queue);`
325
326			`/*`
327			`* Clean up and exit`
328			`*/`
329			`init_timer(&readtimer);`
330			`readtimer.function=cadet_handler;`
331			`readtimer.data=(unsigned long)0;`
332			`readtimer.expires=jiffies+msecs_to_jiffies(50);`
333			`add_timer(&readtimer);`
334			`}`
335
336
337
338			`static ssize_t`
339			`cadet_read(struct file file, char __user data, size_t count, loff_t *ppos)`
340			`{`
341			`int i=0;`
342			`unsigned char readbuf[RDS_BUFFER];`
343
344			`if(rdsstat==0) {`
345			`spin_lock(&cadet_io_lock);`
346			`rdsstat=1;`
347			`outb(0x80,io); /* Select RDS fifo */`
348			`spin_unlock(&cadet_io_lock);`
349			`init_timer(&readtimer);`
350			`readtimer.function=cadet_handler;`
351			`readtimer.data=(unsigned long)0;`
352			`readtimer.expires=jiffies+msecs_to_jiffies(50);`
353			`add_timer(&readtimer);`
354			`}`
355			`if(rdsin==rdsout) {`
356			`if (file->f_flags & O_NONBLOCK)`
357			`return -EWOULDBLOCK;`
358			`interruptible_sleep_on(&read_queue);`
359			`}`
360			`while( i<count && rdsin!=rdsout)`
361			`readbuf[i++]=rdsbuf[rdsout++];`
362
363			`if (copy_to_user(data,readbuf,i))`
364			`return -EFAULT;`
365			`return i;`
366			`}`
367
368
369			`static int vidioc_querycap(struct file file, void priv,`
370			`struct v4l2_capability *v)`
371			`{`
372			`v->capabilities =`
373			`V4L2_CAP_TUNER \|`
374			`V4L2_CAP_READWRITE;`
375			`v->version = CADET_VERSION;`
376			`strcpy(v->driver, "ADS Cadet");`
377			`strcpy(v->card, "ADS Cadet");`
378			`return 0;`
379			`}`
380
381			`static int vidioc_g_tuner(struct file file, void priv,`
382			`struct v4l2_tuner *v)`
383			`{`
384			`v->type = V4L2_TUNER_RADIO;`
385			`switch (v->index) {`
386			`case 0:`
387			`strcpy(v->name, "FM");`
388			`v->capability = V4L2_TUNER_CAP_STEREO;`
389			`v->rangelow = 1400; /* 87.5 MHz */`
390			`v->rangehigh = 1728; /* 108.0 MHz */`
391			`v->rxsubchans=cadet_getstereo();`
392			`switch (v->rxsubchans){`
393			`case V4L2_TUNER_SUB_MONO:`
394			`v->audmode = V4L2_TUNER_MODE_MONO;`
395			`break;`
396			`case V4L2_TUNER_SUB_STEREO:`
397			`v->audmode = V4L2_TUNER_MODE_STEREO;`
398			`break;`
399			`default: ;`
400			`}`
401			`break;`
402			`case 1:`
403			`strcpy(v->name, "AM");`
404			`v->capability = V4L2_TUNER_CAP_LOW;`
405			`v->rangelow = 8320; /* 520 kHz */`
406			`v->rangehigh = 26400; /* 1650 kHz */`
407			`v->rxsubchans = V4L2_TUNER_SUB_MONO;`
408			`v->audmode = V4L2_TUNER_MODE_MONO;`
409			`break;`
410			`default:`
411			`return -EINVAL;`
412			`}`
413			`v->signal = sigstrength; /* We might need to modify scaling of this */`
414			`return 0;`
415			`}`
416
417			`static int vidioc_s_tuner(struct file file, void priv,`
418			`struct v4l2_tuner *v)`
419			`{`
420			`if((v->index != 0)&&(v->index != 1))`
421			`return -EINVAL;`
422			`curtuner = v->index;`
423			`return 0;`
424			`}`
425
426			`static int vidioc_g_frequency(struct file file, void priv,`
427			`struct v4l2_frequency *f)`
428			`{`
429			`f->tuner = curtuner;`
430			`f->type = V4L2_TUNER_RADIO;`
431			`f->frequency = cadet_getfreq();`
432			`return 0;`
433			`}`
434
435
436			`static int vidioc_s_frequency(struct file file, void priv,`
437			`struct v4l2_frequency *f)`
438			`{`
439			`if (f->type != V4L2_TUNER_RADIO)`
440			`return -EINVAL;`
441			`if((curtuner==0)&&((f->frequency<1400)\|\|(f->frequency>1728)))`
442			`return -EINVAL;`
443			`if((curtuner==1)&&((f->frequency<8320)\|\|(f->frequency>26400)))`
444			`return -EINVAL;`
445			`cadet_setfreq(f->frequency);`
446			`return 0;`
447			`}`
448
449			`static int vidioc_queryctrl(struct file file, void priv,`
450			`struct v4l2_queryctrl *qc)`
451			`{`
452			`int i;`
453
454			`for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {`
455			`if (qc->id && qc->id == radio_qctrl[i].id) {`
456			`memcpy(qc, &(radio_qctrl[i]),`
457			`sizeof(*qc));`
458			`return 0;`
459			`}`
460			`}`
461			`return -EINVAL;`
462			`}`
463
464			`static int vidioc_g_ctrl(struct file file, void priv,`
465			`struct v4l2_control *ctrl)`
466			`{`
467			`switch (ctrl->id){`
468			`case V4L2_CID_AUDIO_MUTE: /* TODO: Handle this correctly */`
469			`ctrl->value = (cadet_getvol() == 0);`
470			`break;`
471			`case V4L2_CID_AUDIO_VOLUME:`
472			`ctrl->value = cadet_getvol();`
473			`break;`
474			`default:`
475			`return -EINVAL;`
476			`}`
477			`return 0;`
478			`}`
479
480			`static int vidioc_s_ctrl(struct file file, void priv,`
481			`struct v4l2_control *ctrl)`
482			`{`
483			`switch (ctrl->id){`
484			`case V4L2_CID_AUDIO_MUTE: /* TODO: Handle this correctly */`
485			`if (ctrl->value)`
486			`cadet_setvol(0);`
487			`else`
488			`cadet_setvol(0xffff);`
489			`break;`
490			`case V4L2_CID_AUDIO_VOLUME:`
491			`cadet_setvol(ctrl->value);`
492			`break;`
493			`default:`
494			`return -EINVAL;`
495			`}`
496			`return 0;`
497			`}`
498
499			`static int vidioc_g_audio(struct file file, void priv,`
500			`struct v4l2_audio *a)`
501			`{`
502			`if (a->index > 1)`
503			`return -EINVAL;`
504			`strcpy(a->name, "Radio");`
505			`a->capability = V4L2_AUDCAP_STEREO;`
506			`return 0;`
507			`}`
508
509			`static int vidioc_g_input(struct file filp, void priv, unsigned int *i)`
510			`{`
511			`*i = 0;`
512			`return 0;`
513			`}`
514
515			`static int vidioc_s_input(struct file filp, void priv, unsigned int i)`
516			`{`
517			`if (i != 0)`
518			`return -EINVAL;`
519			`return 0;`
520			`}`
521
522			`static int vidioc_s_audio(struct file file, void priv,`
523			`struct v4l2_audio *a)`
524			`{`
525			`if (a->index != 0)`
526			`return -EINVAL;`
527			`return 0;`
528			`}`
529
530			`static int`
531			`cadet_open(struct inode inode, struct file file)`
532			`{`
533			`users++;`
534			`if (1 == users) init_waitqueue_head(&read_queue);`
535			`return 0;`
536			`}`
537
538			`static int`
539			`cadet_release(struct inode inode, struct file file)`
540			`{`
541			`users--;`
542			`if (0 == users){`
543			`del_timer_sync(&readtimer);`
544			`rdsstat=0;`
545			`}`
546			`return 0;`
547			`}`
548
549			`static unsigned int`
550			`cadet_poll(struct file file, struct poll_table_struct wait)`
551			`{`
552			`poll_wait(file,&read_queue,wait);`
553			`if(rdsin != rdsout)`
554			`return POLLIN \| POLLRDNORM;`
555			`return 0;`
556			`}`
557
558
559			`static const struct file_operations cadet_fops = {`
560			`.owner = THIS_MODULE,`
561			`.open = cadet_open,`
562			`.release = cadet_release,`
563			`.read = cadet_read,`
564			`.ioctl = video_ioctl2,`
565			`.poll = cadet_poll,`
566			`.compat_ioctl = v4l_compat_ioctl32,`
567			`.llseek = no_llseek,`
568			`};`
569
570			`static struct video_device cadet_radio=`
571			`{`
572			`.owner = THIS_MODULE,`
573			`.name = "Cadet radio",`
574			`.type = VID_TYPE_TUNER,`
575			`.fops = &cadet_fops,`
576			`.vidioc_querycap = vidioc_querycap,`
577			`.vidioc_g_tuner = vidioc_g_tuner,`
578			`.vidioc_s_tuner = vidioc_s_tuner,`
579			`.vidioc_g_frequency = vidioc_g_frequency,`
580			`.vidioc_s_frequency = vidioc_s_frequency,`
581			`.vidioc_queryctrl = vidioc_queryctrl,`
582			`.vidioc_g_ctrl = vidioc_g_ctrl,`
583			`.vidioc_s_ctrl = vidioc_s_ctrl,`
584			`.vidioc_g_audio = vidioc_g_audio,`
585			`.vidioc_s_audio = vidioc_s_audio,`
586			`.vidioc_g_input = vidioc_g_input,`
587			`.vidioc_s_input = vidioc_s_input,`
588			`};`
589
590			`static struct pnp_device_id cadet_pnp_devices[] = {`
591			`/* ADS Cadet AM/FM Radio Card */`
592			`{.id = "MSM0c24", .driver_data = 0},`
593			`{.id = ""}`
594			`};`
595
596			`MODULE_DEVICE_TABLE(pnp, cadet_pnp_devices);`
597
598			`static int cadet_pnp_probe(struct pnp_dev * dev, const struct pnp_device_id *dev_id)`
599			`{`
600			`if (!dev)`
601			`return -ENODEV;`
602			`/* only support one device */`
603			`if (io > 0)`
604			`return -EBUSY;`
605
606			`if (!pnp_port_valid(dev, 0)) {`
607			`return -ENODEV;`
608			`}`
609
610			`io = pnp_port_start(dev, 0);`
611
612			`printk ("radio-cadet: PnP reports device at %#x\n", io);`
613
614			`return io;`
615			`}`
616
617			`static struct pnp_driver cadet_pnp_driver = {`
618			`.name = "radio-cadet",`
619			`.id_table = cadet_pnp_devices,`
620			`.probe = cadet_pnp_probe,`
621			`.remove = NULL,`
622			`};`
623
624			`static int cadet_probe(void)`
625			`{`
626			`static int iovals[8]={0x330,0x332,0x334,0x336,0x338,0x33a,0x33c,0x33e};`
627			`int i;`
628
629			`for(i=0;i<8;i++) {`
630			`io=iovals[i];`
631			`if (request_region(io, 2, "cadet-probe")) {`
632			`cadet_setfreq(1410);`
633			`if(cadet_getfreq()==1410) {`
634			`release_region(io, 2);`
635			`return io;`
636			`}`
637			`release_region(io, 2);`
638			`}`
639			`}`
640			`return -1;`
641			`}`
642
643			`/*`
644			`* io should only be set if the user has used something like`
645			`* isapnp (the userspace program) to initialize this card for us`
646			`*/`
647
648			`static int __init cadet_init(void)`
649			`{`
650			`spin_lock_init(&cadet_io_lock);`
651
652			`/*`
653			`* If a probe was requested then probe ISAPnP first (safest)`
654			`*/`
655			`if (io < 0)`
656			`pnp_register_driver(&cadet_pnp_driver);`
657			`/*`
658			`* If that fails then probe unsafely if probe is requested`
659			`*/`
660			`if(io < 0)`
661			`io = cadet_probe ();`
662
663			`/*`
664			`* Else we bail out`
665			`*/`
666
667			`if(io < 0) {`
668			`#ifdef MODULE`
669			`printk(KERN_ERR "You must set an I/O address with io=0x???\n");`
670			`#endif`
671			`goto fail;`
672			`}`
673			`if (!request_region(io,2,"cadet"))`
674			`goto fail;`
675			`if(video_register_device(&cadet_radio,VFL_TYPE_RADIO,radio_nr)==-1) {`
676			`release_region(io,2);`
677			`goto fail;`
678			`}`
679			`printk(KERN_INFO "ADS Cadet Radio Card at 0x%x\n",io);`
680			`return 0;`
681			`fail:`
682			`pnp_unregister_driver(&cadet_pnp_driver);`
683			`return -1;`
684			`}`
685
686
687
688			`MODULE_AUTHOR("Fred Gleason, Russell Kroll, Quay Lu, Donald Song, Jason Lewis, Scott McGrath, William McGrath");`
689			`MODULE_DESCRIPTION("A driver for the ADS Cadet AM/FM/RDS radio card.");`
690			`MODULE_LICENSE("GPL");`
691
692			`module_param(io, int, 0);`
693			`MODULE_PARM_DESC(io, "I/O address of Cadet card (0x330,0x332,0x334,0x336,0x338,0x33a,0x33c,0x33e)");`
694			`module_param(radio_nr, int, 0);`
695
696			`static void __exit cadet_cleanup_module(void)`
697			`{`
698			`video_unregister_device(&cadet_radio);`
699			`release_region(io,2);`
700			`pnp_unregister_driver(&cadet_pnp_driver);`
701			`}`
702
703			`module_init(cadet_init);`
704			`module_exit(cadet_cleanup_module);`
705