[deliverable/linux.git] / drivers / media / video / dsbr100.c

/* A driver for the D-Link DSB-R100 USB radio.  The R100 plugs
 into both the USB and an analog audio input, so this thing
 only deals with initialisation and frequency setting, the
 audio data has to be handled by a sound driver.

 Major issue: I can't find out where the device reports the signal
 strength, and indeed the windows software appearantly just looks
 at the stereo indicator as well.  So, scanning will only find
 stereo stations.  Sad, but I can't help it.

 Also, the windows program sends oodles of messages over to the
 device, and I couldn't figure out their meaning.  My suspicion
 is that they don't have any:-)

 You might find some interesting stuff about this module at
 http://unimut.fsk.uni-heidelberg.de/unimut/demi/dsbr

 Copyright (c) 2000 Markus Demleitner <msdemlei@cl.uni-heidelberg.de>

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

 History:

 Version 0.40:
  Markus: Updates for 2.6.x kernels, code layout changes, name sanitizing

 Version 0.30:
	Markus: Updates for 2.5.x kernel and more ISO compliant source

 Version 0.25:
	PSL and Markus: Cleanup, radio now doesn't stop on device close

 Version 0.24:
	Markus: Hope I got these silly VIDEO_TUNER_LOW issues finally
	right.  Some minor cleanup, improved standalone compilation

 Version 0.23:
	Markus: Sign extension bug fixed by declaring transfer_buffer unsigned

 Version 0.22:
	Markus: Some (brown bag) cleanup in what VIDIOCSTUNER returns,
	thanks to Mike Cox for pointing the problem out.

 Version 0.21:
	Markus: Minor cleanup, warnings if something goes wrong, lame attempt
	to adhere to Documentation/CodingStyle

 Version 0.2:
	Brad Hards <bradh@dynamite.com.au>: Fixes to make it work as non-module
	Markus: Copyright clarification

 Version 0.01: Markus: initial release

*/


#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/videodev.h>
#include <media/v4l2-common.h>
#include <linux/usb.h>
#include <linux/smp_lock.h>

/*
 * Version Information
 */
#define DRIVER_VERSION "v0.40"
#define DRIVER_AUTHOR "Markus Demleitner <msdemlei@tucana.harvard.edu>"
#define DRIVER_DESC "D-Link DSB-R100 USB FM radio driver"

#define DSB100_VENDOR 0x04b4
#define DSB100_PRODUCT 0x1002

/* Commands the device appears to understand */
#define DSB100_TUNE 1
#define DSB100_ONOFF 2

#define TB_LEN 16

/* Frequency limits in MHz -- these are European values.  For Japanese
devices, that would be 76 and 91.  */
#define FREQ_MIN  87.5
#define FREQ_MAX 108.0
#define FREQ_MUL 16000


static int usb_dsbr100_probe(struct usb_interface *intf,
			     const struct usb_device_id *id);
static void usb_dsbr100_disconnect(struct usb_interface *intf);
static int usb_dsbr100_ioctl(struct inode *inode, struct file *file,
			     unsigned int cmd, unsigned long arg);
static int usb_dsbr100_open(struct inode *inode, struct file *file);
static int usb_dsbr100_close(struct inode *inode, struct file *file);

static int radio_nr = -1;
module_param(radio_nr, int, 0);

/* Data for one (physical) device */
typedef struct {
	struct usb_device *usbdev;
	struct video_device *videodev;
	unsigned char transfer_buffer[TB_LEN];
	int curfreq;
	int stereo;
	int users;
	int removed;
} dsbr100_device;


/* File system interface */
static struct file_operations usb_dsbr100_fops = {
	.owner =	THIS_MODULE,
	.open =		usb_dsbr100_open,
	.release =     	usb_dsbr100_close,
	.ioctl =        usb_dsbr100_ioctl,
	.compat_ioctl = v4l_compat_ioctl32,
	.llseek =       no_llseek,
};

/* V4L interface */
static struct video_device dsbr100_videodev_template=
{
	.owner =	THIS_MODULE,
	.name =		"D-Link DSB-R 100",
	.type =		VID_TYPE_TUNER,
	.hardware =	VID_HARDWARE_AZTECH,
	.fops =         &usb_dsbr100_fops,
	.release = video_device_release,
};

static struct usb_device_id usb_dsbr100_device_table [] = {
	{ USB_DEVICE(DSB100_VENDOR, DSB100_PRODUCT) },
	{ }						/* Terminating entry */
};

MODULE_DEVICE_TABLE (usb, usb_dsbr100_device_table);

/* USB subsystem interface */
static struct usb_driver usb_dsbr100_driver = {
	.name =		"dsbr100",
	.probe =	usb_dsbr100_probe,
	.disconnect =	usb_dsbr100_disconnect,
	.id_table =	usb_dsbr100_device_table,
};

/* Low-level device interface begins here */

/* switch on radio */
static int dsbr100_start(dsbr100_device *radio)
{
	if (usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
			USB_REQ_GET_STATUS,
			USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
			0x00, 0xC7, radio->transfer_buffer, 8, 300)<0 ||
	usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
			DSB100_ONOFF,
			USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
			0x01, 0x00, radio->transfer_buffer, 8, 300)<0)
		return -1;
	return (radio->transfer_buffer)[0];
}


/* switch off radio */
static int dsbr100_stop(dsbr100_device *radio)
{
	if (usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
			USB_REQ_GET_STATUS,
			USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
			0x16, 0x1C, radio->transfer_buffer, 8, 300)<0 ||
	usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
			DSB100_ONOFF,
			USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
			0x00, 0x00, radio->transfer_buffer, 8, 300)<0)
		return -1;
	return (radio->transfer_buffer)[0];
}

/* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */
static int dsbr100_setfreq(dsbr100_device *radio, int freq)
{
	freq = (freq/16*80)/1000+856;
	if (usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
			DSB100_TUNE,
			USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
			(freq>>8)&0x00ff, freq&0xff,
			radio->transfer_buffer, 8, 300)<0 ||
	   usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
			USB_REQ_GET_STATUS,
			USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
			0x96, 0xB7, radio->transfer_buffer, 8, 300)<0 ||
	usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
			USB_REQ_GET_STATUS,
			USB_TYPE_VENDOR | USB_RECIP_DEVICE |  USB_DIR_IN,
			0x00, 0x24, radio->transfer_buffer, 8, 300)<0) {
		radio->stereo = -1;
		return -1;
	}
	radio->stereo = ! ((radio->transfer_buffer)[0]&0x01);
	return (radio->transfer_buffer)[0];
}

/* return the device status.  This is, in effect, just whether it
sees a stereo signal or not.  Pity. */
static void dsbr100_getstat(dsbr100_device *radio)
{
	if (usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
		USB_REQ_GET_STATUS,
		USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
		0x00 , 0x24, radio->transfer_buffer, 8, 300)<0)
		radio->stereo = -1;
	else
		radio->stereo = ! (radio->transfer_buffer[0]&0x01);
}


/* USB subsystem interface begins here */

/* check if the device is present and register with v4l and
usb if it is */
static int usb_dsbr100_probe(struct usb_interface *intf,
			 const struct usb_device_id *id)
{
	dsbr100_device *radio;

	if (!(radio = kmalloc(sizeof(dsbr100_device), GFP_KERNEL)))
		return -ENOMEM;
	if (!(radio->videodev = video_device_alloc())) {
		kfree(radio);
		return -ENOMEM;
	}
	memcpy(radio->videodev, &dsbr100_videodev_template,
		sizeof(dsbr100_videodev_template));
	radio->removed = 0;
	radio->users = 0;
	radio->usbdev = interface_to_usbdev(intf);
	radio->curfreq = FREQ_MIN*FREQ_MUL;
	video_set_drvdata(radio->videodev, radio);
	if (video_register_device(radio->videodev, VFL_TYPE_RADIO,
		radio_nr)) {
		warn("Could not register video device");
		video_device_release(radio->videodev);
		kfree(radio);
		return -EIO;
	}
	usb_set_intfdata(intf, radio);
	return 0;
}

/* handle unplugging of the device, release data structures
if nothing keeps us from doing it.  If something is still
keeping us busy, the release callback of v4l will take care
of releasing it.  stv680.c does not relase its private
data, so I don't do this here either.  Checking out the
code I'd expect I better did that, but if there's a memory
leak here it's tiny (~50 bytes per disconnect) */
static void usb_dsbr100_disconnect(struct usb_interface *intf)
{
	dsbr100_device *radio = usb_get_intfdata(intf);

	usb_set_intfdata (intf, NULL);
	if (radio) {
		video_unregister_device(radio->videodev);
		radio->videodev = NULL;
		if (radio->users) {
			kfree(radio);
		} else {
			radio->removed = 1;
		}
	}
}


/* Video for Linux interface */

static int usb_dsbr100_do_ioctl(struct inode *inode, struct file *file,
				unsigned int cmd, void *arg)
{
	dsbr100_device *radio=video_get_drvdata(video_devdata(file));

	if (!radio)
		return -EIO;

	switch(cmd) {
		case VIDIOCGCAP: {
			struct video_capability *v = arg;

			memset(v, 0, sizeof(*v));
			v->type = VID_TYPE_TUNER;
			v->channels = 1;
			v->audios = 1;
			strcpy(v->name, "D-Link R-100 USB FM Radio");
			return 0;
		}
		case VIDIOCGTUNER: {
			struct video_tuner *v = arg;

			dsbr100_getstat(radio);
			if(v->tuner)	/* Only 1 tuner */
				return -EINVAL;
			v->rangelow = FREQ_MIN*FREQ_MUL;
			v->rangehigh = FREQ_MAX*FREQ_MUL;
			v->flags = VIDEO_TUNER_LOW;
			v->mode = VIDEO_MODE_AUTO;
			v->signal = radio->stereo*0x7000;
				/* Don't know how to get signal strength */
			v->flags |= VIDEO_TUNER_STEREO_ON*radio->stereo;
			strcpy(v->name, "DSB R-100");
			return 0;
		}
		case VIDIOCSTUNER: {
			struct video_tuner *v = arg;

			if(v->tuner!=0)
				return -EINVAL;
			/* Only 1 tuner so no setting needed ! */
			return 0;
		}
		case VIDIOCGFREQ: {
			int *freq = arg;

			if (radio->curfreq==-1)
				return -EINVAL;
			*freq = radio->curfreq;
			return 0;
		}
		case VIDIOCSFREQ: {
			int *freq = arg;

			radio->curfreq = *freq;
			if (dsbr100_setfreq(radio, radio->curfreq)==-1)
				warn("Set frequency failed");
			return 0;
		}
		case VIDIOCGAUDIO: {
			struct video_audio *v = arg;

			memset(v, 0, sizeof(*v));
			v->flags |= VIDEO_AUDIO_MUTABLE;
			v->mode = VIDEO_SOUND_STEREO;
			v->volume = 1;
			v->step = 1;
			strcpy(v->name, "Radio");
			return 0;
		}
		case VIDIOCSAUDIO: {
			struct video_audio *v = arg;

			if (v->audio)
				return -EINVAL;
			if (v->flags&VIDEO_AUDIO_MUTE) {
				if (dsbr100_stop(radio)==-1)
					warn("Radio did not respond properly");
			}
			else
				if (dsbr100_start(radio)==-1)
					warn("Radio did not respond properly");
			return 0;
		}
		default:
			return -ENOIOCTLCMD;
	}
}

static int usb_dsbr100_ioctl(struct inode *inode, struct file *file,
			     unsigned int cmd, unsigned long arg)
{
	return video_usercopy(inode, file, cmd, arg, usb_dsbr100_do_ioctl);
}

static int usb_dsbr100_open(struct inode *inode, struct file *file)
{
	dsbr100_device *radio=video_get_drvdata(video_devdata(file));

	radio->users = 1;
	if (dsbr100_start(radio)<0) {
		warn("Radio did not start up properly");
		radio->users = 0;
		return -EIO;
	}
	dsbr100_setfreq(radio, radio->curfreq);
	return 0;
}

static int usb_dsbr100_close(struct inode *inode, struct file *file)
{
	dsbr100_device *radio=video_get_drvdata(video_devdata(file));

	if (!radio)
		return -ENODEV;
	radio->users = 0;
	if (radio->removed) {
		kfree(radio);
	}
	return 0;
}

static int __init dsbr100_init(void)
{
	int retval = usb_register(&usb_dsbr100_driver);
	info(DRIVER_VERSION ":" DRIVER_DESC);
	return retval;
}

static void __exit dsbr100_exit(void)
{
	usb_deregister(&usb_dsbr100_driver);
}

module_init (dsbr100_init);
module_exit (dsbr100_exit);

MODULE_AUTHOR( DRIVER_AUTHOR );
MODULE_DESCRIPTION( DRIVER_DESC );
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/* A driver for the D-Link DSB-R100 USB radio. The R100 plugs
	2	into both the USB and an analog audio input, so this thing
	3	only deals with initialisation and frequency setting, the
	4	audio data has to be handled by a sound driver.
	5
	6	Major issue: I can't find out where the device reports the signal
	7	strength, and indeed the windows software appearantly just looks
	8	at the stereo indicator as well. So, scanning will only find
	9	stereo stations. Sad, but I can't help it.
	10
	11	Also, the windows program sends oodles of messages over to the
	12	device, and I couldn't figure out their meaning. My suspicion
	13	is that they don't have any:-)
	14
	15	You might find some interesting stuff about this module at
	16	http://unimut.fsk.uni-heidelberg.de/unimut/demi/dsbr
	17
	18	Copyright (c) 2000 Markus Demleitner <msdemlei@cl.uni-heidelberg.de>
	19
	20	This program is free software; you can redistribute it and/or modify
	21	it under the terms of the GNU General Public License as published by
	22	the Free Software Foundation; either version 2 of the License, or
	23	(at your option) any later version.
	24
	25	This program is distributed in the hope that it will be useful,
	26	but WITHOUT ANY WARRANTY; without even the implied warranty of
	27	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	28	GNU General Public License for more details.
	29
	30	You should have received a copy of the GNU General Public License
	31	along with this program; if not, write to the Free Software
	32	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	33
	34	History:
	35
	36	Version 0.40:
	37	Markus: Updates for 2.6.x kernels, code layout changes, name sanitizing
	38
	39	Version 0.30:
d56410e0	40	Markus: Updates for 2.5.x kernel and more ISO compliant source
1da177e4 LT	41
1da177e4 LT	42	Version 0.25:
d56410e0	43	PSL and Markus: Cleanup, radio now doesn't stop on device close
1da177e4 LT	44
1da177e4 LT	45	Version 0.24:
d56410e0	46	Markus: Hope I got these silly VIDEO_TUNER_LOW issues finally
1da177e4 LT	47	right. Some minor cleanup, improved standalone compilation
	48
	49	Version 0.23:
d56410e0	50	Markus: Sign extension bug fixed by declaring transfer_buffer unsigned
1da177e4 LT	51
1da177e4 LT	52	Version 0.22:
d56410e0	53	Markus: Some (brown bag) cleanup in what VIDIOCSTUNER returns,
1da177e4 LT	54	thanks to Mike Cox for pointing the problem out.
	55
	56	Version 0.21:
d56410e0	57	Markus: Minor cleanup, warnings if something goes wrong, lame attempt
1da177e4 LT	58	to adhere to Documentation/CodingStyle
1da177e4 LT	59
d56410e0 MCC	60	Version 0.2:
d56410e0 MCC	61	Brad Hards <bradh@dynamite.com.au>: Fixes to make it work as non-module
1da177e4 LT	62	Markus: Copyright clarification
	63
	64	Version 0.01: Markus: initial release
	65
	66	*/
	67
	68
	69	#include <linux/kernel.h>
	70	#include <linux/module.h>
	71	#include <linux/init.h>
	72	#include <linux/slab.h>
	73	#include <linux/input.h>
	74	#include <linux/videodev.h>
5e87efa3	75	#include <media/v4l2-common.h>
1da177e4 LT	76	#include <linux/usb.h>
	77	#include <linux/smp_lock.h>
	78
	79	/*
	80	* Version Information
	81	*/
	82	#define DRIVER_VERSION "v0.40"
	83	#define DRIVER_AUTHOR "Markus Demleitner <msdemlei@tucana.harvard.edu>"
	84	#define DRIVER_DESC "D-Link DSB-R100 USB FM radio driver"
	85
	86	#define DSB100_VENDOR 0x04b4
	87	#define DSB100_PRODUCT 0x1002
	88
	89	/* Commands the device appears to understand */
	90	#define DSB100_TUNE 1
	91	#define DSB100_ONOFF 2
	92
	93	#define TB_LEN 16
	94
	95	/* Frequency limits in MHz -- these are European values. For Japanese
	96	devices, that would be 76 and 91. */
	97	#define FREQ_MIN 87.5
	98	#define FREQ_MAX 108.0
	99	#define FREQ_MUL 16000
	100
	101
	102	static int usb_dsbr100_probe(struct usb_interface *intf,
	103	const struct usb_device_id *id);
	104	static void usb_dsbr100_disconnect(struct usb_interface *intf);
	105	static int usb_dsbr100_ioctl(struct inode inode, struct file file,
	106	unsigned int cmd, unsigned long arg);
	107	static int usb_dsbr100_open(struct inode inode, struct file file);
	108	static int usb_dsbr100_close(struct inode inode, struct file file);
	109
	110	static int radio_nr = -1;
	111	module_param(radio_nr, int, 0);
	112
	113	/* Data for one (physical) device */
	114	typedef struct {
	115	struct usb_device *usbdev;
	116	struct video_device *videodev;
	117	unsigned char transfer_buffer[TB_LEN];
	118	int curfreq;
	119	int stereo;
	120	int users;
	121	int removed;
	122	} dsbr100_device;
	123
	124
	125	/* File system interface */
	126	static struct file_operations usb_dsbr100_fops = {
	127	.owner = THIS_MODULE,
	128	.open = usb_dsbr100_open,
	129	.release = usb_dsbr100_close,
	130	.ioctl = usb_dsbr100_ioctl,
0d0fbf81	131	.compat_ioctl = v4l_compat_ioctl32,
1da177e4 LT	132	.llseek = no_llseek,
	133	};
	134
	135	/* V4L interface */
	136	static struct video_device dsbr100_videodev_template=
	137	{
	138	.owner = THIS_MODULE,
	139	.name = "D-Link DSB-R 100",
	140	.type = VID_TYPE_TUNER,
	141	.hardware = VID_HARDWARE_AZTECH,
	142	.fops = &usb_dsbr100_fops,
	143	.release = video_device_release,
	144	};
	145
	146	static struct usb_device_id usb_dsbr100_device_table [] = {
	147	{ USB_DEVICE(DSB100_VENDOR, DSB100_PRODUCT) },
	148	{ } /* Terminating entry */
	149	};
	150
	151	MODULE_DEVICE_TABLE (usb, usb_dsbr100_device_table);
	152
	153	/* USB subsystem interface */
	154	static struct usb_driver usb_dsbr100_driver = {
1da177e4 LT	155	.name = "dsbr100",
	156	.probe = usb_dsbr100_probe,
	157	.disconnect = usb_dsbr100_disconnect,
	158	.id_table = usb_dsbr100_device_table,
	159	};
	160
	161	/* Low-level device interface begins here */
	162
	163	/* switch on radio */
	164	static int dsbr100_start(dsbr100_device *radio)
	165	{
	166	if (usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
d56410e0	167	USB_REQ_GET_STATUS,
1da177e4 LT	168	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
	169	0x00, 0xC7, radio->transfer_buffer, 8, 300)<0 \|\|
	170	usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
d56410e0	171	DSB100_ONOFF,
1da177e4 LT	172	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
	173	0x01, 0x00, radio->transfer_buffer, 8, 300)<0)
	174	return -1;
	175	return (radio->transfer_buffer)[0];
	176	}
	177
	178
	179	/* switch off radio */
	180	static int dsbr100_stop(dsbr100_device *radio)
	181	{
	182	if (usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
d56410e0	183	USB_REQ_GET_STATUS,
1da177e4 LT	184	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
	185	0x16, 0x1C, radio->transfer_buffer, 8, 300)<0 \|\|
	186	usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
d56410e0	187	DSB100_ONOFF,
1da177e4 LT	188	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
	189	0x00, 0x00, radio->transfer_buffer, 8, 300)<0)
	190	return -1;
	191	return (radio->transfer_buffer)[0];
	192	}
	193
	194	/* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */
	195	static int dsbr100_setfreq(dsbr100_device *radio, int freq)
	196	{
	197	freq = (freq/16*80)/1000+856;
	198	if (usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
d56410e0	199	DSB100_TUNE,
1da177e4	200	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
d56410e0	201	(freq>>8)&0x00ff, freq&0xff,
1da177e4 LT	202	radio->transfer_buffer, 8, 300)<0 \|\|
1da177e4 LT	203	usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
d56410e0	204	USB_REQ_GET_STATUS,
1da177e4 LT	205	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
	206	0x96, 0xB7, radio->transfer_buffer, 8, 300)<0 \|\|
	207	usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
d56410e0	208	USB_REQ_GET_STATUS,
1da177e4 LT	209	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
	210	0x00, 0x24, radio->transfer_buffer, 8, 300)<0) {
	211	radio->stereo = -1;
	212	return -1;
	213	}
	214	radio->stereo = ! ((radio->transfer_buffer)[0]&0x01);
	215	return (radio->transfer_buffer)[0];
	216	}
	217
	218	/* return the device status. This is, in effect, just whether it
	219	sees a stereo signal or not. Pity. */
	220	static void dsbr100_getstat(dsbr100_device *radio)
	221	{
	222	if (usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
d56410e0	223	USB_REQ_GET_STATUS,
1da177e4 LT	224	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
	225	0x00 , 0x24, radio->transfer_buffer, 8, 300)<0)
	226	radio->stereo = -1;
	227	else
	228	radio->stereo = ! (radio->transfer_buffer[0]&0x01);
	229	}
	230
	231
	232	/* USB subsystem interface begins here */
	233
	234	/* check if the device is present and register with v4l and
	235	usb if it is */
d56410e0	236	static int usb_dsbr100_probe(struct usb_interface *intf,
1da177e4 LT	237	const struct usb_device_id *id)
	238	{
	239	dsbr100_device *radio;
	240
	241	if (!(radio = kmalloc(sizeof(dsbr100_device), GFP_KERNEL)))
	242	return -ENOMEM;
	243	if (!(radio->videodev = video_device_alloc())) {
	244	kfree(radio);
	245	return -ENOMEM;
	246	}
d56410e0	247	memcpy(radio->videodev, &dsbr100_videodev_template,
1da177e4 LT	248	sizeof(dsbr100_videodev_template));
	249	radio->removed = 0;
	250	radio->users = 0;
	251	radio->usbdev = interface_to_usbdev(intf);
	252	radio->curfreq = FREQ_MIN*FREQ_MUL;
	253	video_set_drvdata(radio->videodev, radio);
	254	if (video_register_device(radio->videodev, VFL_TYPE_RADIO,
	255	radio_nr)) {
	256	warn("Could not register video device");
	257	video_device_release(radio->videodev);
	258	kfree(radio);
	259	return -EIO;
	260	}
	261	usb_set_intfdata(intf, radio);
	262	return 0;
	263	}
	264
	265	/* handle unplugging of the device, release data structures
	266	if nothing keeps us from doing it. If something is still
	267	keeping us busy, the release callback of v4l will take care
	268	of releasing it. stv680.c does not relase its private
	269	data, so I don't do this here either. Checking out the
	270	code I'd expect I better did that, but if there's a memory
	271	leak here it's tiny (~50 bytes per disconnect) */
	272	static void usb_dsbr100_disconnect(struct usb_interface *intf)
	273	{
	274	dsbr100_device *radio = usb_get_intfdata(intf);
	275
	276	usb_set_intfdata (intf, NULL);
	277	if (radio) {
	278	video_unregister_device(radio->videodev);
	279	radio->videodev = NULL;
	280	if (radio->users) {
	281	kfree(radio);
	282	} else {
	283	radio->removed = 1;
	284	}
	285	}
	286	}
	287
	288
	289	/* Video for Linux interface */
	290
	291	static int usb_dsbr100_do_ioctl(struct inode inode, struct file file,
	292	unsigned int cmd, void *arg)
	293	{
	294	dsbr100_device *radio=video_get_drvdata(video_devdata(file));
	295
	296	if (!radio)
	297	return -EIO;
	298
	299	switch(cmd) {
	300	case VIDIOCGCAP: {
	301	struct video_capability *v = arg;
	302
	303	memset(v, 0, sizeof(*v));
	304	v->type = VID_TYPE_TUNER;
	305	v->channels = 1;
	306	v->audios = 1;
	307	strcpy(v->name, "D-Link R-100 USB FM Radio");
	308	return 0;
	309	}
	310	case VIDIOCGTUNER: {
	311	struct video_tuner *v = arg;
312
313	dsbr100_getstat(radio);
d56410e0	314	if(v->tuner) /* Only 1 tuner */
1da177e4 LT	315	return -EINVAL;
	316	v->rangelow = FREQ_MIN*FREQ_MUL;
	317	v->rangehigh = FREQ_MAX*FREQ_MUL;
	318	v->flags = VIDEO_TUNER_LOW;
	319	v->mode = VIDEO_MODE_AUTO;
	320	v->signal = radio->stereo*0x7000;
	321	/* Don't know how to get signal strength */
	322	v->flags \|= VIDEO_TUNER_STEREO_ON*radio->stereo;
	323	strcpy(v->name, "DSB R-100");
	324	return 0;
	325	}
	326	case VIDIOCSTUNER: {
	327	struct video_tuner *v = arg;
	328
	329	if(v->tuner!=0)
	330	return -EINVAL;
	331	/* Only 1 tuner so no setting needed ! */
	332	return 0;
	333	}
	334	case VIDIOCGFREQ: {
	335	int *freq = arg;
	336
	337	if (radio->curfreq==-1)
	338	return -EINVAL;
	339	*freq = radio->curfreq;
	340	return 0;
	341	}
	342	case VIDIOCSFREQ: {
	343	int *freq = arg;
	344
	345	radio->curfreq = *freq;
	346	if (dsbr100_setfreq(radio, radio->curfreq)==-1)
	347	warn("Set frequency failed");
	348	return 0;
	349	}
	350	case VIDIOCGAUDIO: {
	351	struct video_audio *v = arg;
	352
	353	memset(v, 0, sizeof(*v));
	354	v->flags \|= VIDEO_AUDIO_MUTABLE;
	355	v->mode = VIDEO_SOUND_STEREO;
	356	v->volume = 1;
	357	v->step = 1;
	358	strcpy(v->name, "Radio");
d56410e0	359	return 0;
1da177e4 LT	360	}
	361	case VIDIOCSAUDIO: {
	362	struct video_audio *v = arg;
	363
d56410e0	364	if (v->audio)
1da177e4 LT	365	return -EINVAL;
	366	if (v->flags&VIDEO_AUDIO_MUTE) {
	367	if (dsbr100_stop(radio)==-1)
	368	warn("Radio did not respond properly");
	369	}
	370	else
	371	if (dsbr100_start(radio)==-1)
	372	warn("Radio did not respond properly");
	373	return 0;
	374	}
	375	default:
	376	return -ENOIOCTLCMD;
	377	}
	378	}
	379
	380	static int usb_dsbr100_ioctl(struct inode inode, struct file file,
	381	unsigned int cmd, unsigned long arg)
	382	{
	383	return video_usercopy(inode, file, cmd, arg, usb_dsbr100_do_ioctl);
	384	}
	385
	386	static int usb_dsbr100_open(struct inode inode, struct file file)
	387	{
	388	dsbr100_device *radio=video_get_drvdata(video_devdata(file));
	389
	390	radio->users = 1;
	391	if (dsbr100_start(radio)<0) {
	392	warn("Radio did not start up properly");
	393	radio->users = 0;
	394	return -EIO;
	395	}
	396	dsbr100_setfreq(radio, radio->curfreq);
	397	return 0;
	398	}
	399
	400	static int usb_dsbr100_close(struct inode inode, struct file file)
	401	{
	402	dsbr100_device *radio=video_get_drvdata(video_devdata(file));
	403
	404	if (!radio)
	405	return -ENODEV;
	406	radio->users = 0;
	407	if (radio->removed) {
	408	kfree(radio);
	409	}
	410	return 0;
	411	}
	412
	413	static int __init dsbr100_init(void)
	414	{
	415	int retval = usb_register(&usb_dsbr100_driver);
	416	info(DRIVER_VERSION ":" DRIVER_DESC);
	417	return retval;
	418	}
	419
	420	static void __exit dsbr100_exit(void)
	421	{
	422	usb_deregister(&usb_dsbr100_driver);
	423	}
	424
	425	module_init (dsbr100_init);
	426	module_exit (dsbr100_exit);
	427
	428	MODULE_AUTHOR( DRIVER_AUTHOR );
429	MODULE_DESCRIPTION( DRIVER_DESC );
430	MODULE_LICENSE("GPL");