[mirror_ubuntu-kernels.git] / drivers / media / radio / radio-cadet.c

/* 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;
static int curtuner;
static int tunestat;
static int sigstrength;
static wait_queue_head_t read_queue;
static struct timer_list readtimer;
static __u8 rdsin, rdsout, rdsstat;
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,
};

#ifdef CONFIG_PNP

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,
};

#else
static struct pnp_driver cadet_pnp_driver;
#endif

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);
Commit	Line	Data
1da177e4 LT	1	/* 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
4286c6f6	11	* Jason Lewis (jlewis@twilight.vtc.vsc.edu)
1da177e4 LT	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
c0c7fa09 HK	28	*
	29	* 2006-07-30 Hans J. Koch <koch@hjk-az.de>
	30	* Changed API to V4L2
1da177e4 LT	31	*/
1da177e4 LT	32
d591b9cc	33	#include <linux/version.h>
1da177e4 LT	34	#include <linux/module.h> /* Modules */
1da177e4 LT	35	#include <linux/init.h> /* Initdata */
fb911ee8	36	#include <linux/ioport.h> /* request_region */
1da177e4 LT	37	#include <linux/delay.h> /* udelay */
	38	#include <asm/io.h> /* outb, outb_p */
	39	#include <asm/uaccess.h> /* copy to/from user */
c0c7fa09	40	#include <linux/videodev2.h> /* V4L2 API defs */
5e87efa3	41	#include <media/v4l2-common.h>
1da177e4 LT	42	#include <linux/param.h>
	43	#include <linux/pnp.h>
	44
	45	#define RDS_BUFFER 256
c0c7fa09 HK	46	#define RDS_RX_FLAG 1
	47	#define MBS_RX_FLAG 2
	48
	49	#define CADET_VERSION KERNEL_VERSION(0,3,3)
1da177e4	50
c1c4fd3e DL	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
1da177e4 LT	70	static int io=-1; /* default to isapnp activation */
1da177e4 LT	71	static int radio_nr = -1;
ff699e6b DSL	72	static int users;
	73	static int curtuner;
	74	static int tunestat;
	75	static int sigstrength;
1da177e4 LT	76	static wait_queue_head_t read_queue;
1da177e4 LT	77	static struct timer_list readtimer;
ff699e6b	78	static __u8 rdsin, rdsout, rdsstat;
1da177e4 LT	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
4286c6f6	86	* The V4L API spec does not define any particular unit for the signal
1da177e4 LT	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
1da177e4	91
c0c7fa09 HK	92	static int
c0c7fa09 HK	93	cadet_getstereo(void)
1da177e4	94	{
c0c7fa09	95	int ret = V4L2_TUNER_SUB_MONO;
4286c6f6	96	if(curtuner != 0) /* Only FM has stereo capability! */
c0c7fa09	97	return V4L2_TUNER_SUB_MONO;
1da177e4 LT	98
1da177e4 LT	99	spin_lock(&cadet_io_lock);
4286c6f6	100	outb(7,io); /* Select tuner control */
1da177e4	101	if( (inb(io+1) & 0x40) == 0)
c0c7fa09	102	ret = V4L2_TUNER_SUB_STEREO;
4286c6f6 MCC	103	spin_unlock(&cadet_io_lock);
4286c6f6 MCC	104	return ret;
1da177e4 LT	105	}
1da177e4 LT	106
c0c7fa09 HK	107	static unsigned
c0c7fa09 HK	108	cadet_gettune(void)
1da177e4	109	{
4286c6f6	110	int curvol,i;
1da177e4 LT	111	unsigned fifo=0;
1da177e4 LT	112
4286c6f6 MCC	113	/*
	114	* Prepare for read
	115	*/
1da177e4 LT	116
1da177e4 LT	117	spin_lock(&cadet_io_lock);
4286c6f6 MCC	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 */
1da177e4 LT	122	tunestat=0xffff;
1da177e4 LT	123
4286c6f6 MCC	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);
1da177e4	131	tunestat&=inb(io+1);
4286c6f6 MCC	132	outb(0x00,io+1);
	133	}
	134	}
	135
	136	/*
	137	* Restore volume/mute setting
	138	*/
	139	outb(curvol,io+1);
1da177e4 LT	140	spin_unlock(&cadet_io_lock);
	141
	142	return fifo;
	143	}
	144
c0c7fa09 HK	145	static unsigned
c0c7fa09 HK	146	cadet_getfreq(void)
1da177e4	147	{
4286c6f6 MCC	148	int i;
4286c6f6 MCC	149	unsigned freq=0,test,fifo=0;
1da177e4 LT	150
	151	/*
	152	* Read current tuning
	153	*/
	154	fifo=cadet_gettune();
	155
4286c6f6 MCC	156	/*
	157	* Convert to actual frequency
	158	*/
1da177e4	159	if(curtuner==0) { /* FM */
4286c6f6 MCC	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 */
1da177e4 LT	170	}
1da177e4 LT	171	if(curtuner==1) { /* AM */
4286c6f6	172	freq=((fifo&0x7fff)-2010)*16;
1da177e4 LT	173	}
1da177e4 LT	174
4286c6f6	175	return freq;
1da177e4 LT	176	}
1da177e4 LT	177
c0c7fa09 HK	178	static void
c0c7fa09 HK	179	cadet_settune(unsigned fifo)
1da177e4	180	{
4286c6f6 MCC	181	int i;
4286c6f6 MCC	182	unsigned test;
1da177e4 LT	183
1da177e4 LT	184	spin_lock(&cadet_io_lock);
4286c6f6	185
1da177e4 LT	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++) {
4286c6f6	196	test\|=0x01; /* Toggle SCK High */
1da177e4 LT	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
c0c7fa09 HK	207	static void
c0c7fa09 HK	208	cadet_setfreq(unsigned freq)
1da177e4	209	{
4286c6f6 MCC	210	unsigned fifo;
	211	int i,j,test;
	212	int curvol;
1da177e4	213
4286c6f6 MCC	214	/*
	215	* Formulate a fifo command
	216	*/
1da177e4 LT	217	fifo=0;
1da177e4 LT	218	if(curtuner==0) { /* FM */
4286c6f6 MCC	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	}
1da177e4 LT	230	}
1da177e4 LT	231	if(curtuner==1) { /* AM */
4286c6f6	232	fifo=(freq/16)+2010; /* Make it kHz */
1da177e4 LT	233	fifo\|=0x100000; /* Select AM Band */
	234	}
	235
4286c6f6 MCC	236	/*
	237	* Save current volume/mute setting
	238	*/
1da177e4 LT	239
	240	spin_lock(&cadet_io_lock);
	241	outb(7,io); /* Select tuner control */
4286c6f6 MCC	242	curvol=inb(io+1);
4286c6f6 MCC	243	spin_unlock(&cadet_io_lock);
1da177e4 LT	244
	245	/*
	246	* Tune the card
	247	*/
	248	for(j=3;j>-1;j--) {
4286c6f6 MCC	249	cadet_settune(fifo\|(j<<16));
	250
	251	spin_lock(&cadet_io_lock);
1da177e4 LT	252	outb(7,io); /* Select tuner control */
	253	outb(curvol,io+1);
	254	spin_unlock(&cadet_io_lock);
4286c6f6	255
1da177e4 LT	256	msleep(100);
	257
	258	cadet_gettune();
	259	if((tunestat & 0x40) == 0) { /* Tuned */
4286c6f6	260	sigstrength=sigtable[curtuner][j];
1da177e4 LT	261	return;
	262	}
	263	}
	264	sigstrength=0;
	265	}
	266
	267
c0c7fa09 HK	268	static int
c0c7fa09 HK	269	cadet_getvol(void)
1da177e4 LT	270	{
1da177e4 LT	271	int ret = 0;
4286c6f6	272
1da177e4	273	spin_lock(&cadet_io_lock);
4286c6f6 MCC	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;
1da177e4 LT	281	}
	282
	283
c0c7fa09 HK	284	static void
c0c7fa09 HK	285	cadet_setvol(int vol)
1da177e4 LT	286	{
1da177e4 LT	287	spin_lock(&cadet_io_lock);
4286c6f6 MCC	288	outb(7,io); /* Select tuner control */
	289	if(vol>0)
	290	outb(0x20,io+1);
	291	else
	292	outb(0x00,io+1);
1da177e4	293	spin_unlock(&cadet_io_lock);
4286c6f6	294	}
1da177e4	295
c0c7fa09 HK	296	static void
c0c7fa09 HK	297	cadet_handler(unsigned long data)
1da177e4 LT	298	{
	299	/*
	300	* Service the RDS fifo
	301	*/
	302
	303	if(spin_trylock(&cadet_io_lock))
	304	{
4286c6f6	305	outb(0x3,io); /* Select RDS Decoder Control */
1da177e4	306	if((inb(io+1)&0x20)!=0) {
4286c6f6	307	printk(KERN_CRIT "cadet: RDS fifo overflow\n");
1da177e4 LT	308	}
	309	outb(0x80,io); /* Select RDS fifo */
	310	while((inb(io)&0x80)!=0) {
4286c6f6	311	rdsbuf[rdsin]=inb(io+1);
1da177e4	312	if(rdsin==rdsout)
4286c6f6	313	printk(KERN_WARNING "cadet: RDS buffer overflow\n");
1da177e4 LT	314	else
	315	rdsin++;
	316	}
	317	spin_unlock(&cadet_io_lock);
	318	}
	319
	320	/*
	321	* Service pending read
	322	*/
	323	if( rdsin!=rdsout)
4286c6f6	324	wake_up_interruptible(&read_queue);
1da177e4	325
4286c6f6	326	/*
1da177e4 LT	327	* Clean up and exit
	328	*/
	329	init_timer(&readtimer);
	330	readtimer.function=cadet_handler;
	331	readtimer.data=(unsigned long)0;
a2d66a37	332	readtimer.expires=jiffies+msecs_to_jiffies(50);
1da177e4 LT	333	add_timer(&readtimer);
	334	}
	335
	336
	337
c0c7fa09 HK	338	static ssize_t
c0c7fa09 HK	339	cadet_read(struct file file, char __user data, size_t count, loff_t *ppos)
1da177e4	340	{
4286c6f6	341	int i=0;
1da177e4 LT	342	unsigned char readbuf[RDS_BUFFER];
1da177e4 LT	343
4286c6f6	344	if(rdsstat==0) {
1da177e4	345	spin_lock(&cadet_io_lock);
4286c6f6	346	rdsstat=1;
1da177e4 LT	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;
a2d66a37	352	readtimer.expires=jiffies+msecs_to_jiffies(50);
1da177e4 LT	353	add_timer(&readtimer);
	354	}
	355	if(rdsin==rdsout) {
4286c6f6 MCC	356	if (file->f_flags & O_NONBLOCK)
	357	return -EWOULDBLOCK;
	358	interruptible_sleep_on(&read_queue);
	359	}
1da177e4	360	while( i<count && rdsin!=rdsout)
4286c6f6	361	readbuf[i++]=rdsbuf[rdsout++];
1da177e4 LT	362
1da177e4 LT	363	if (copy_to_user(data,readbuf,i))
4286c6f6	364	return -EFAULT;
1da177e4 LT	365	return i;
	366	}
	367
	368
c1c4fd3e DL	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	}
1da177e4	380
c1c4fd3e DL	381	static int vidioc_g_tuner(struct file file, void priv,
c1c4fd3e DL	382	struct v4l2_tuner *v)
1da177e4	383	{
c1c4fd3e DL	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: ;
1da177e4	400	}
c1c4fd3e DL	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	}
c0c7fa09	416
c1c4fd3e DL	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	}
c0c7fa09	425
c1c4fd3e DL	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));
1da177e4 LT	458	return 0;
1da177e4 LT	459	}
c1c4fd3e DL	460	}
	461	return -EINVAL;
	462	}
c0c7fa09	463
c1c4fd3e DL	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;
1da177e4	476	}
c1c4fd3e	477	return 0;
1da177e4 LT	478	}
1da177e4 LT	479
c1c4fd3e DL	480	static int vidioc_s_ctrl(struct file file, void priv,
c1c4fd3e DL	481	struct v4l2_control *ctrl)
1da177e4	482	{
c1c4fd3e DL	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;
1da177e4 LT	528	}
1da177e4 LT	529
c0c7fa09 HK	530	static int
c0c7fa09 HK	531	cadet_open(struct inode inode, struct file file)
1da177e4	532	{
1da177e4	533	users++;
c0c7fa09	534	if (1 == users) init_waitqueue_head(&read_queue);
1da177e4 LT	535	return 0;
	536	}
	537
c0c7fa09 HK	538	static int
c0c7fa09 HK	539	cadet_release(struct inode inode, struct file file)
1da177e4	540	{
1da177e4	541	users--;
c0c7fa09 HK	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;
1da177e4 LT	555	return 0;
	556	}
	557
	558
fa027c2a	559	static const struct file_operations cadet_fops = {
1da177e4 LT	560	.owner = THIS_MODULE,
	561	.open = cadet_open,
	562	.release = cadet_release,
	563	.read = cadet_read,
c1c4fd3e	564	.ioctl = video_ioctl2,
c0c7fa09	565	.poll = cadet_poll,
0d0fbf81	566	.compat_ioctl = v4l_compat_ioctl32,
1da177e4 LT	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,
1da177e4	575	.fops = &cadet_fops,
c1c4fd3e DL	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,
1da177e4 LT	588	};
1da177e4 LT	589
044dfc99 BH	590	#ifdef CONFIG_PNP
044dfc99 BH	591
1da177e4 LT	592	static struct pnp_device_id cadet_pnp_devices[] = {
	593	/* ADS Cadet AM/FM Radio Card */
	594	{.id = "MSM0c24", .driver_data = 0},
	595	{.id = ""}
	596	};
	597
	598	MODULE_DEVICE_TABLE(pnp, cadet_pnp_devices);
	599
	600	static int cadet_pnp_probe(struct pnp_dev * dev, const struct pnp_device_id *dev_id)
	601	{
	602	if (!dev)
	603	return -ENODEV;
	604	/* only support one device */
	605	if (io > 0)
	606	return -EBUSY;
	607
	608	if (!pnp_port_valid(dev, 0)) {
	609	return -ENODEV;
	610	}
	611
	612	io = pnp_port_start(dev, 0);
	613
	614	printk ("radio-cadet: PnP reports device at %#x\n", io);
	615
	616	return io;
	617	}
	618
	619	static struct pnp_driver cadet_pnp_driver = {
	620	.name = "radio-cadet",
	621	.id_table = cadet_pnp_devices,
	622	.probe = cadet_pnp_probe,
	623	.remove = NULL,
	624	};
	625
044dfc99 BH	626	#else
	627	static struct pnp_driver cadet_pnp_driver;
	628	#endif
	629
1da177e4 LT	630	static int cadet_probe(void)
1da177e4 LT	631	{
4286c6f6	632	static int iovals[8]={0x330,0x332,0x334,0x336,0x338,0x33a,0x33c,0x33e};
1da177e4 LT	633	int i;
	634
	635	for(i=0;i<8;i++) {
4286c6f6	636	io=iovals[i];
f1ac046d	637	if (request_region(io, 2, "cadet-probe")) {
4286c6f6	638	cadet_setfreq(1410);
1da177e4 LT	639	if(cadet_getfreq()==1410) {
1da177e4 LT	640	release_region(io, 2);
4286c6f6	641	return io;
1da177e4 LT	642	}
	643	release_region(io, 2);
	644	}
	645	}
	646	return -1;
	647	}
	648
4286c6f6	649	/*
1da177e4 LT	650	* io should only be set if the user has used something like
	651	* isapnp (the userspace program) to initialize this card for us
	652	*/
	653
	654	static int __init cadet_init(void)
	655	{
	656	spin_lock_init(&cadet_io_lock);
4286c6f6	657
1da177e4 LT	658	/*
	659	* If a probe was requested then probe ISAPnP first (safest)
	660	*/
	661	if (io < 0)
	662	pnp_register_driver(&cadet_pnp_driver);
	663	/*
	664	* If that fails then probe unsafely if probe is requested
	665	*/
	666	if(io < 0)
	667	io = cadet_probe ();
	668
	669	/*
	670	* Else we bail out
	671	*/
4286c6f6 MCC	672
	673	if(io < 0) {
	674	#ifdef MODULE
1da177e4 LT	675	printk(KERN_ERR "You must set an I/O address with io=0x???\n");
1da177e4 LT	676	#endif
4286c6f6	677	goto fail;
1da177e4 LT	678	}
	679	if (!request_region(io,2,"cadet"))
	680	goto fail;
	681	if(video_register_device(&cadet_radio,VFL_TYPE_RADIO,radio_nr)==-1) {
	682	release_region(io,2);
	683	goto fail;
	684	}
	685	printk(KERN_INFO "ADS Cadet Radio Card at 0x%x\n",io);
	686	return 0;
	687	fail:
	688	pnp_unregister_driver(&cadet_pnp_driver);
	689	return -1;
	690	}
	691
	692
	693
	694	MODULE_AUTHOR("Fred Gleason, Russell Kroll, Quay Lu, Donald Song, Jason Lewis, Scott McGrath, William McGrath");
	695	MODULE_DESCRIPTION("A driver for the ADS Cadet AM/FM/RDS radio card.");
	696	MODULE_LICENSE("GPL");
	697
	698	module_param(io, int, 0);
	699	MODULE_PARM_DESC(io, "I/O address of Cadet card (0x330,0x332,0x334,0x336,0x338,0x33a,0x33c,0x33e)");
	700	module_param(radio_nr, int, 0);
	701
	702	static void __exit cadet_cleanup_module(void)
	703	{
	704	video_unregister_device(&cadet_radio);
	705	release_region(io,2);
	706	pnp_unregister_driver(&cadet_pnp_driver);
	707	}
	708
	709	module_init(cadet_init);
	710	module_exit(cadet_cleanup_module);
	711