[linux-2.6-block.git] / drivers / media / radio / radio-gemtek.c

/* 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,2)

static struct v4l2_queryctrl radio_qctrl[] = {
	{
		.id            = V4L2_CID_AUDIO_MUTE,
		.name          = "Mute",
		.minimum       = 0,
		.maximum       = 1,
		.default_value = 1,
		.type          = V4L2_CTRL_TYPE_BOOLEAN,
	},{
		.id            = V4L2_CID_AUDIO_VOLUME,
		.name          = "Volume",
		.minimum       = 0,
		.maximum       = 65535,
		.step          = 65535,
		.default_value = 0xff,
		.type          = V4L2_CTRL_TYPE_INTEGER,
	}
};

#ifndef CONFIG_RADIO_GEMTEK_PORT
#define CONFIG_RADIO_GEMTEK_PORT -1
#endif

static int io = CONFIG_RADIO_GEMTEK_PORT;
static int radio_nr = -1;
static spinlock_t lock;

struct gemtek_device
{
	int port;
	unsigned long curfreq;
	int muted;
};


/* local things */

/* the correct way to mute the gemtek may be to write the last written
 * frequency || 0x10, but just writing 0x10 once seems to do it as well
 */
static void gemtek_mute(struct gemtek_device *dev)
{
	if(dev->muted)
		return;
	spin_lock(&lock);
	outb(0x10, io);
	spin_unlock(&lock);
	dev->muted = 1;
}

static void gemtek_unmute(struct gemtek_device *dev)
{
	if(dev->muted == 0)
		return;
	spin_lock(&lock);
	outb(0x20, io);
	spin_unlock(&lock);
	dev->muted = 0;
}

static void zero(void)
{
	outb_p(0x04, io);
	udelay(5);
	outb_p(0x05, io);
	udelay(5);
}

static void one(void)
{
	outb_p(0x06, io);
	udelay(5);
	outb_p(0x07, io);
	udelay(5);
}

static int gemtek_setfreq(struct gemtek_device *dev, unsigned long freq)
{
	int i;

/*        freq = 78.25*((float)freq/16000.0 + 10.52); */

	freq /= 16;
	freq += 10520;
	freq *= 7825;
	freq /= 100000;

	spin_lock(&lock);

	/* 2 start bits */
	outb_p(0x03, io);
	udelay(5);
	outb_p(0x07, io);
	udelay(5);

	/* 28 frequency bits (lsb first) */
	for (i = 0; i < 14; i++)
		if (freq & (1 << i))
			one();
		else
			zero();
	/* 36 unknown bits */
	for (i = 0; i < 11; i++)
		zero();
	one();
	for (i = 0; i < 4; i++)
		zero();
	one();
	zero();

	/* 2 end bits */
	outb_p(0x03, io);
	udelay(5);
	outb_p(0x07, io);
	udelay(5);

	spin_unlock(&lock);

	return 0;
}

static int gemtek_getsigstr(struct gemtek_device *dev)
{
	spin_lock(&lock);
	inb(io);
	udelay(5);
	spin_unlock(&lock);
	if (inb(io) & 8)		/* bit set = no signal present */
		return 0;
	return 1;		/* signal present */
}

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)
{
	struct video_device *dev = video_devdata(file);
	struct gemtek_device *rt = dev->priv;

	if (v->index > 0)
		return -EINVAL;

	strcpy(v->name, "FM");
	v->type = V4L2_TUNER_RADIO;
	v->rangelow = (87*16000);
	v->rangehigh = (108*16000);
	v->rxsubchans = V4L2_TUNER_SUB_MONO;
	v->capability = V4L2_TUNER_CAP_LOW;
	v->audmode = V4L2_TUNER_MODE_MONO;
	v->signal = 0xffff*gemtek_getsigstr(rt);
	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;

	rt->curfreq = f->frequency;
	/* needs to be called twice in order for getsigstr to work */
	gemtek_setfreq(rt, rt->curfreq);
	gemtek_setfreq(rt, rt->curfreq);
	return 0;
}

static int vidioc_g_frequency(struct file *file, void *priv,
					struct v4l2_frequency *f)
{
	struct video_device *dev = video_devdata(file);
	struct gemtek_device *rt = dev->priv;

	f->type = V4L2_TUNER_RADIO;
	f->frequency = rt->curfreq;
	return 0;
}

static int vidioc_queryctrl(struct file *file, void *priv,
					struct v4l2_queryctrl *qc)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
		if (qc->id && qc->id == radio_qctrl[i].id) {
			memcpy(qc, &(radio_qctrl[i]),
						sizeof(*qc));
			return 0;
		}
	}
	return -EINVAL;
}

static int vidioc_g_ctrl(struct file *file, void *priv,
					struct v4l2_control *ctrl)
{
	struct video_device *dev = video_devdata(file);
	struct 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 gemtek_device gemtek_unit;

static const 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 struct video_device gemtek_radio=
{
	.owner		= THIS_MODULE,
	.name		= "GemTek radio",
	.type		= VID_TYPE_TUNER,
	.hardware	= 0,
	.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,
};

static int __init gemtek_init(void)
{
	if(io==-1)
	{
		printk(KERN_ERR "You must set an I/O address with io=0x20c, io=0x30c, io=0x24c or io=0x34c (io=0x020c or io=0x248 for the combined sound/radiocard)\n");
		return -EINVAL;
	}

	if (!request_region(io, 4, "gemtek"))
	{
		printk(KERN_ERR "gemtek: port 0x%x already in use\n", io);
		return -EBUSY;
	}

	gemtek_radio.priv=&gemtek_unit;

	if(video_register_device(&gemtek_radio, VFL_TYPE_RADIO, radio_nr)==-1)
	{
		release_region(io, 4);
		return -EINVAL;
	}
	printk(KERN_INFO "GemTek Radio Card driver.\n");

	spin_lock_init(&lock);

	/* this is _maybe_ unnecessary */
	outb(0x01, io);

	/* mute card - prevents noisy bootups */
	gemtek_unit.muted = 0;
	gemtek_mute(&gemtek_unit);

	return 0;
}

MODULE_AUTHOR("Jonas Munsin");
MODULE_DESCRIPTION("A driver for the GemTek Radio Card");
MODULE_LICENSE("GPL");

module_param(io, int, 0);
MODULE_PARM_DESC(io, "I/O address of the GemTek card (0x20c, 0x30c, 0x24c or 0x34c (0x20c or 0x248 have been reported to work for the combined sound/radiocard)).");
module_param(radio_nr, int, 0);

static void __exit gemtek_cleanup(void)
{
	video_unregister_device(&gemtek_radio);
	release_region(io,4);
}

module_init(gemtek_init);
module_exit(gemtek_cleanup);

/*
  Local variables:
  compile-command: "gcc -c -DMODVERSIONS -D__KERNEL__ -DMODULE -O6 -Wall -Wstrict-prototypes -I /home/blp/tmp/linux-2.1.111-rtrack/include radio-rtrack2.c"
  End:
*/
Commit	Line	Data
1da177e4 LT	1	/* 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
4286c6f6	9	*
1da177e4 LT	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	*
d1c4ecde	16	* Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
1da177e4 LT	17	*/
	18
	19	#include <linux/module.h> /* Modules */
	20	#include <linux/init.h> /* Initdata */
fb911ee8	21	#include <linux/ioport.h> /* request_region */
1da177e4 LT	22	#include <linux/delay.h> /* udelay */
	23	#include <asm/io.h> /* outb, outb_p */
	24	#include <asm/uaccess.h> /* copy to/from user */
d1c4ecde	25	#include <linux/videodev2.h> /* kernel radio structs */
5e87efa3	26	#include <media/v4l2-common.h>
1da177e4 LT	27	#include <linux/spinlock.h>
1da177e4 LT	28
d1c4ecde MCC	29	#include <linux/version.h> /* for KERNEL_VERSION MACRO */
	30	#define RADIO_VERSION KERNEL_VERSION(0,0,2)
	31
	32	static struct v4l2_queryctrl radio_qctrl[] = {
	33	{
	34	.id = V4L2_CID_AUDIO_MUTE,
	35	.name = "Mute",
	36	.minimum = 0,
	37	.maximum = 1,
	38	.default_value = 1,
	39	.type = V4L2_CTRL_TYPE_BOOLEAN,
	40	},{
	41	.id = V4L2_CID_AUDIO_VOLUME,
	42	.name = "Volume",
	43	.minimum = 0,
	44	.maximum = 65535,
	45	.step = 65535,
	46	.default_value = 0xff,
	47	.type = V4L2_CTRL_TYPE_INTEGER,
	48	}
	49	};
	50
1da177e4 LT	51	#ifndef CONFIG_RADIO_GEMTEK_PORT
	52	#define CONFIG_RADIO_GEMTEK_PORT -1
	53	#endif
	54
4286c6f6	55	static int io = CONFIG_RADIO_GEMTEK_PORT;
1da177e4 LT	56	static int radio_nr = -1;
	57	static spinlock_t lock;
	58
	59	struct gemtek_device
	60	{
	61	int port;
	62	unsigned long curfreq;
	63	int muted;
	64	};
	65
	66
	67	/* local things */
	68
	69	/* the correct way to mute the gemtek may be to write the last written
	70	* frequency \|\| 0x10, but just writing 0x10 once seems to do it as well
	71	*/
	72	static void gemtek_mute(struct gemtek_device *dev)
	73	{
4286c6f6	74	if(dev->muted)
1da177e4 LT	75	return;
	76	spin_lock(&lock);
	77	outb(0x10, io);
	78	spin_unlock(&lock);
	79	dev->muted = 1;
	80	}
	81
	82	static void gemtek_unmute(struct gemtek_device *dev)
	83	{
	84	if(dev->muted == 0)
	85	return;
	86	spin_lock(&lock);
	87	outb(0x20, io);
	88	spin_unlock(&lock);
	89	dev->muted = 0;
	90	}
	91
	92	static void zero(void)
	93	{
	94	outb_p(0x04, io);
	95	udelay(5);
	96	outb_p(0x05, io);
	97	udelay(5);
	98	}
	99
	100	static void one(void)
	101	{
	102	outb_p(0x06, io);
	103	udelay(5);
	104	outb_p(0x07, io);
	105	udelay(5);
	106	}
	107
	108	static int gemtek_setfreq(struct gemtek_device *dev, unsigned long freq)
	109	{
	110	int i;
	111
	112	/* freq = 78.25((float)freq/16000.0 + 10.52); /
	113
	114	freq /= 16;
	115	freq += 10520;
	116	freq *= 7825;
	117	freq /= 100000;
	118
	119	spin_lock(&lock);
4286c6f6	120
1da177e4 LT	121	/* 2 start bits */
	122	outb_p(0x03, io);
	123	udelay(5);
	124	outb_p(0x07, io);
	125	udelay(5);
	126
4286c6f6	127	/* 28 frequency bits (lsb first) */
1da177e4 LT	128	for (i = 0; i < 14; i++)
	129	if (freq & (1 << i))
	130	one();
	131	else
	132	zero();
4286c6f6	133	/* 36 unknown bits */
1da177e4 LT	134	for (i = 0; i < 11; i++)
	135	zero();
	136	one();
	137	for (i = 0; i < 4; i++)
	138	zero();
	139	one();
	140	zero();
	141
	142	/* 2 end bits */
	143	outb_p(0x03, io);
	144	udelay(5);
	145	outb_p(0x07, io);
	146	udelay(5);
	147
	148	spin_unlock(&lock);
4286c6f6	149
1da177e4 LT	150	return 0;
	151	}
	152
	153	static int gemtek_getsigstr(struct gemtek_device *dev)
	154	{
	155	spin_lock(&lock);
	156	inb(io);
	157	udelay(5);
	158	spin_unlock(&lock);
	159	if (inb(io) & 8) /* bit set = no signal present */
	160	return 0;
	161	return 1; /* signal present */
	162	}
	163
e9bb9c64 DL	164	static int vidioc_querycap(struct file file, void priv,
	165	struct v4l2_capability *v)
	166	{
	167	strlcpy(v->driver, "radio-gemtek", sizeof(v->driver));
	168	strlcpy(v->card, "GemTek", sizeof(v->card));
	169	sprintf(v->bus_info, "ISA");
	170	v->version = RADIO_VERSION;
	171	v->capabilities = V4L2_CAP_TUNER;
	172	return 0;
	173	}
	174
	175	static int vidioc_g_tuner(struct file file, void priv,
	176	struct v4l2_tuner *v)
1da177e4 LT	177	{
1da177e4 LT	178	struct video_device *dev = video_devdata(file);
e9bb9c64	179	struct gemtek_device *rt = dev->priv;
1da177e4	180
e9bb9c64 DL	181	if (v->index > 0)
e9bb9c64 DL	182	return -EINVAL;
d1c4ecde	183
e9bb9c64 DL	184	strcpy(v->name, "FM");
	185	v->type = V4L2_TUNER_RADIO;
	186	v->rangelow = (87*16000);
	187	v->rangehigh = (108*16000);
	188	v->rxsubchans = V4L2_TUNER_SUB_MONO;
	189	v->capability = V4L2_TUNER_CAP_LOW;
	190	v->audmode = V4L2_TUNER_MODE_MONO;
	191	v->signal = 0xffff*gemtek_getsigstr(rt);
	192	return 0;
	193	}
	194
	195	static int vidioc_s_tuner(struct file file, void priv,
	196	struct v4l2_tuner *v)
	197	{
	198	if (v->index > 0)
	199	return -EINVAL;
	200	return 0;
	201	}
d1c4ecde	202
e9bb9c64 DL	203	static int vidioc_s_frequency(struct file file, void priv,
	204	struct v4l2_frequency *f)
	205	{
	206	struct video_device *dev = video_devdata(file);
	207	struct gemtek_device *rt = dev->priv;
d1c4ecde	208
e9bb9c64 DL	209	rt->curfreq = f->frequency;
	210	/* needs to be called twice in order for getsigstr to work */
	211	gemtek_setfreq(rt, rt->curfreq);
	212	gemtek_setfreq(rt, rt->curfreq);
	213	return 0;
	214	}
d1c4ecde	215
e9bb9c64 DL	216	static int vidioc_g_frequency(struct file file, void priv,
	217	struct v4l2_frequency *f)
	218	{
	219	struct video_device *dev = video_devdata(file);
	220	struct gemtek_device *rt = dev->priv;
d1c4ecde	221
e9bb9c64 DL	222	f->type = V4L2_TUNER_RADIO;
	223	f->frequency = rt->curfreq;
	224	return 0;
	225	}
d1c4ecde	226
e9bb9c64 DL	227	static int vidioc_queryctrl(struct file file, void priv,
	228	struct v4l2_queryctrl *qc)
	229	{
	230	int i;
d1c4ecde	231
e9bb9c64 DL	232	for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
	233	if (qc->id && qc->id == radio_qctrl[i].id) {
	234	memcpy(qc, &(radio_qctrl[i]),
	235	sizeof(*qc));
1da177e4 LT	236	return 0;
1da177e4 LT	237	}
e9bb9c64 DL	238	}
	239	return -EINVAL;
	240	}
1da177e4	241
e9bb9c64 DL	242	static int vidioc_g_ctrl(struct file file, void priv,
	243	struct v4l2_control *ctrl)
	244	{
	245	struct video_device *dev = video_devdata(file);
	246	struct gemtek_device *rt = dev->priv;
1da177e4	247
e9bb9c64 DL	248	switch (ctrl->id) {
	249	case V4L2_CID_AUDIO_MUTE:
	250	ctrl->value = rt->muted;
	251	return 0;
	252	case V4L2_CID_AUDIO_VOLUME:
	253	if (rt->muted)
	254	ctrl->value = 0;
	255	else
	256	ctrl->value = 65535;
	257	return 0;
	258	}
	259	return -EINVAL;
	260	}
	261
	262	static int vidioc_s_ctrl(struct file file, void priv,
	263	struct v4l2_control *ctrl)
	264	{
	265	struct video_device *dev = video_devdata(file);
	266	struct gemtek_device *rt = dev->priv;
	267
	268	switch (ctrl->id) {
	269	case V4L2_CID_AUDIO_MUTE:
	270	if (ctrl->value)
	271	gemtek_mute(rt);
	272	else
	273	gemtek_unmute(rt);
	274	return 0;
	275	case V4L2_CID_AUDIO_VOLUME:
	276	if (ctrl->value)
	277	gemtek_unmute(rt);
	278	else
	279	gemtek_mute(rt);
	280	return 0;
1da177e4	281	}
e9bb9c64	282	return -EINVAL;
1da177e4 LT	283	}
1da177e4 LT	284
e9bb9c64 DL	285	static int vidioc_g_audio (struct file file, void priv,
e9bb9c64 DL	286	struct v4l2_audio *a)
1da177e4	287	{
e9bb9c64 DL	288	if (a->index > 1)
	289	return -EINVAL;
	290
	291	strcpy(a->name, "Radio");
	292	a->capability = V4L2_AUDCAP_STEREO;
	293	return 0;
	294	}
	295
	296	static int vidioc_g_input(struct file filp, void priv, unsigned int *i)
	297	{
	298	*i = 0;
	299	return 0;
	300	}
	301
	302	static int vidioc_s_input(struct file filp, void priv, unsigned int i)
	303	{
	304	if (i != 0)
	305	return -EINVAL;
	306	return 0;
	307	}
	308
	309	static int vidioc_s_audio(struct file file, void priv,
	310	struct v4l2_audio *a)
	311	{
	312	if (a->index != 0)
	313	return -EINVAL;
	314	return 0;
1da177e4 LT	315	}
	316
	317	static struct gemtek_device gemtek_unit;
	318
fa027c2a	319	static const struct file_operations gemtek_fops = {
1da177e4 LT	320	.owner = THIS_MODULE,
	321	.open = video_exclusive_open,
	322	.release = video_exclusive_release,
e9bb9c64	323	.ioctl = video_ioctl2,
0d0fbf81	324	.compat_ioctl = v4l_compat_ioctl32,
1da177e4 LT	325	.llseek = no_llseek,
	326	};
	327
	328	static struct video_device gemtek_radio=
	329	{
	330	.owner = THIS_MODULE,
	331	.name = "GemTek radio",
	332	.type = VID_TYPE_TUNER,
d1c4ecde	333	.hardware = 0,
1da177e4	334	.fops = &gemtek_fops,
e9bb9c64 DL	335	.vidioc_querycap = vidioc_querycap,
	336	.vidioc_g_tuner = vidioc_g_tuner,
	337	.vidioc_s_tuner = vidioc_s_tuner,
	338	.vidioc_g_audio = vidioc_g_audio,
	339	.vidioc_s_audio = vidioc_s_audio,
	340	.vidioc_g_input = vidioc_g_input,
	341	.vidioc_s_input = vidioc_s_input,
	342	.vidioc_g_frequency = vidioc_g_frequency,
	343	.vidioc_s_frequency = vidioc_s_frequency,
	344	.vidioc_queryctrl = vidioc_queryctrl,
	345	.vidioc_g_ctrl = vidioc_g_ctrl,
	346	.vidioc_s_ctrl = vidioc_s_ctrl,
1da177e4 LT	347	};
	348
	349	static int __init gemtek_init(void)
	350	{
	351	if(io==-1)
	352	{
	353	printk(KERN_ERR "You must set an I/O address with io=0x20c, io=0x30c, io=0x24c or io=0x34c (io=0x020c or io=0x248 for the combined sound/radiocard)\n");
	354	return -EINVAL;
	355	}
	356
4286c6f6	357	if (!request_region(io, 4, "gemtek"))
1da177e4 LT	358	{
	359	printk(KERN_ERR "gemtek: port 0x%x already in use\n", io);
	360	return -EBUSY;
	361	}
	362
	363	gemtek_radio.priv=&gemtek_unit;
4286c6f6	364
1da177e4 LT	365	if(video_register_device(&gemtek_radio, VFL_TYPE_RADIO, radio_nr)==-1)
	366	{
	367	release_region(io, 4);
	368	return -EINVAL;
	369	}
	370	printk(KERN_INFO "GemTek Radio Card driver.\n");
	371
	372	spin_lock_init(&lock);
	373
	374	/* this is _maybe_ unnecessary */
	375	outb(0x01, io);
	376
4286c6f6	377	/* mute card - prevents noisy bootups */
1da177e4 LT	378	gemtek_unit.muted = 0;
	379	gemtek_mute(&gemtek_unit);
	380
	381	return 0;
	382	}
	383
	384	MODULE_AUTHOR("Jonas Munsin");
	385	MODULE_DESCRIPTION("A driver for the GemTek Radio Card");
	386	MODULE_LICENSE("GPL");
	387
	388	module_param(io, int, 0);
	389	MODULE_PARM_DESC(io, "I/O address of the GemTek card (0x20c, 0x30c, 0x24c or 0x34c (0x20c or 0x248 have been reported to work for the combined sound/radiocard)).");
	390	module_param(radio_nr, int, 0);
	391
	392	static void __exit gemtek_cleanup(void)
	393	{
	394	video_unregister_device(&gemtek_radio);
	395	release_region(io,4);
	396	}
	397
	398	module_init(gemtek_init);
	399	module_exit(gemtek_cleanup);
	400
	401	/*
	402	Local variables:
	403	compile-command: "gcc -c -DMODVERSIONS -D__KERNEL__ -DMODULE -O6 -Wall -Wstrict-prototypes -I /home/blp/tmp/linux-2.1.111-rtrack/include radio-rtrack2.c"
	404	End:
	405	*/