[mirror_ubuntu-bionic-kernel.git] / drivers / media / radio / dsbr100.c

/* A driver for the D-Link DSB-R100 USB radio and Gemtek USB Radio 21.
 The device 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.46:
	Removed usb_dsbr100_open/close calls and radio->users counter. Also,
	radio->muted changed to radio->status and suspend/resume calls updated.

 Version 0.45:
	Converted to v4l2_device.

 Version 0.44:
	Add suspend/resume functions, fix unplug of device,
	a lot of cleanups and fixes by Alexey Klimov <klimov.linux@gmail.com>

 Version 0.43:
	Oliver Neukum: avoided DMA coherency issue

 Version 0.42:
	Converted dsbr100 to use video_ioctl2
	by Douglas Landgraf <dougsland@gmail.com>

 Version 0.41-ac1:
	Alan Cox: Some cleanups and fixes

 Version 0.41:
	Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>

 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/videodev2.h>
#include <media/v4l2-device.h>
#include <media/v4l2-ioctl.h>
#include <linux/usb.h>

/*
 * Version Information
 */
#define DRIVER_VERSION "0.4.7"

#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

/* defines for radio->status */
#define STARTED	0
#define STOPPED	1

#define v4l2_dev_to_radio(d) container_of(d, struct dsbr100_device, v4l2_dev)

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_suspend(struct usb_interface *intf,
						pm_message_t message);
static int usb_dsbr100_resume(struct usb_interface *intf);

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

/* Data for one (physical) device */
struct dsbr100_device {
	struct usb_device *usbdev;
	struct video_device videodev;
	struct v4l2_device v4l2_dev;

	u8 *transfer_buffer;
	struct mutex v4l2_lock;
	int curfreq;
	int stereo;
	int status;
};

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,
	.suspend		= usb_dsbr100_suspend,
	.resume			= usb_dsbr100_resume,
	.reset_resume		= usb_dsbr100_resume,
	.supports_autosuspend	= 0,
};

/* Low-level device interface begins here */

/* switch on radio */
static int dsbr100_start(struct dsbr100_device *radio)
{
	int retval;
	int request;

	retval = 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);

	if (retval < 0) {
		request = USB_REQ_GET_STATUS;
		goto usb_control_msg_failed;
	}

	retval = 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);

	if (retval < 0) {
		request = DSB100_ONOFF;
		goto usb_control_msg_failed;
	}

	radio->status = STARTED;
	return (radio->transfer_buffer)[0];

usb_control_msg_failed:
	dev_err(&radio->usbdev->dev,
		"%s - usb_control_msg returned %i, request %i\n",
			__func__, retval, request);
	return retval;

}

/* switch off radio */
static int dsbr100_stop(struct dsbr100_device *radio)
{
	int retval;
	int request;

	retval = 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);

	if (retval < 0) {
		request = USB_REQ_GET_STATUS;
		goto usb_control_msg_failed;
	}

	retval = 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);

	if (retval < 0) {
		request = DSB100_ONOFF;
		goto usb_control_msg_failed;
	}

	radio->status = STOPPED;
	return (radio->transfer_buffer)[0];

usb_control_msg_failed:
	dev_err(&radio->usbdev->dev,
		"%s - usb_control_msg returned %i, request %i\n",
			__func__, retval, request);
	return retval;

}

/* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */
static int dsbr100_setfreq(struct dsbr100_device *radio)
{
	int retval;
	int request;
	int freq = (radio->curfreq / 16 * 80) / 1000 + 856;

	retval = 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);

	if (retval < 0) {
		request = DSB100_TUNE;
		goto usb_control_msg_failed;
	}

	retval = 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);

	if (retval < 0) {
		request = USB_REQ_GET_STATUS;
		goto usb_control_msg_failed;
	}

	retval = 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);

	if (retval < 0) {
		request = USB_REQ_GET_STATUS;
		goto usb_control_msg_failed;
	}

	radio->stereo = !((radio->transfer_buffer)[0] & 0x01);
	return (radio->transfer_buffer)[0];

usb_control_msg_failed:
	radio->stereo = -1;
	dev_err(&radio->usbdev->dev,
		"%s - usb_control_msg returned %i, request %i\n",
			__func__, retval, request);
	return retval;
}

/* return the device status.  This is, in effect, just whether it
sees a stereo signal or not.  Pity. */
static void dsbr100_getstat(struct dsbr100_device *radio)
{
	int retval;

	retval = 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);

	if (retval < 0) {
		radio->stereo = -1;
		dev_err(&radio->usbdev->dev,
			"%s - usb_control_msg returned %i, request %i\n",
				__func__, retval, USB_REQ_GET_STATUS);
	} else {
		radio->stereo = !(radio->transfer_buffer[0] & 0x01);
	}
}

static int vidioc_querycap(struct file *file, void *priv,
					struct v4l2_capability *v)
{
	struct dsbr100_device *radio = video_drvdata(file);

	strlcpy(v->driver, "dsbr100", sizeof(v->driver));
	strlcpy(v->card, "D-Link R-100 USB FM Radio", sizeof(v->card));
	usb_make_path(radio->usbdev, v->bus_info, sizeof(v->bus_info));
	v->capabilities = V4L2_CAP_TUNER;
	return 0;
}

static int vidioc_g_tuner(struct file *file, void *priv,
				struct v4l2_tuner *v)
{
	struct dsbr100_device *radio = video_drvdata(file);

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

	dsbr100_getstat(radio);
	strcpy(v->name, "FM");
	v->type = V4L2_TUNER_RADIO;
	v->rangelow = FREQ_MIN * FREQ_MUL;
	v->rangehigh = FREQ_MAX * FREQ_MUL;
	v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
	v->capability = V4L2_TUNER_CAP_LOW;
	if(radio->stereo)
		v->audmode = V4L2_TUNER_MODE_STEREO;
	else
		v->audmode = V4L2_TUNER_MODE_MONO;
	v->signal = 0xffff;     /* We can't get the signal strength */
	return 0;
}

static int vidioc_s_tuner(struct file *file, void *priv,
				struct v4l2_tuner *v)
{
	return v->index ? -EINVAL : 0;
}

static int vidioc_s_frequency(struct file *file, void *priv,
				struct v4l2_frequency *f)
{
	struct dsbr100_device *radio = video_drvdata(file);
	int retval;

	radio->curfreq = f->frequency;

	retval = dsbr100_setfreq(radio);
	if (retval < 0)
		dev_warn(&radio->usbdev->dev, "Set frequency failed\n");
	return 0;
}

static int vidioc_g_frequency(struct file *file, void *priv,
				struct v4l2_frequency *f)
{
	struct dsbr100_device *radio = video_drvdata(file);

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

static int vidioc_queryctrl(struct file *file, void *priv,
				struct v4l2_queryctrl *qc)
{
	switch (qc->id) {
	case V4L2_CID_AUDIO_MUTE:
		return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
	}

	return -EINVAL;
}

static int vidioc_g_ctrl(struct file *file, void *priv,
				struct v4l2_control *ctrl)
{
	struct dsbr100_device *radio = video_drvdata(file);

	switch (ctrl->id) {
	case V4L2_CID_AUDIO_MUTE:
		ctrl->value = radio->status;
		return 0;
	}
	return -EINVAL;
}

static int vidioc_s_ctrl(struct file *file, void *priv,
				struct v4l2_control *ctrl)
{
	struct dsbr100_device *radio = video_drvdata(file);
	int retval;

	switch (ctrl->id) {
	case V4L2_CID_AUDIO_MUTE:
		if (ctrl->value) {
			retval = dsbr100_stop(radio);
			if (retval < 0) {
				dev_warn(&radio->usbdev->dev,
					 "Radio did not respond properly\n");
				return -EBUSY;
			}
		} else {
			retval = dsbr100_start(radio);
			if (retval < 0) {
				dev_warn(&radio->usbdev->dev,
					 "Radio did not respond properly\n");
				return -EBUSY;
			}
		}
		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)
{
	return i ? -EINVAL : 0;
}

static int vidioc_s_audio(struct file *file, void *priv,
					struct v4l2_audio *a)
{
	return a->index ? -EINVAL : 0;
}

/* USB subsystem interface begins here */

/*
 * Handle unplugging of the device.
 * We call video_unregister_device in any case.
 * The last function called in this procedure is
 * usb_dsbr100_video_device_release
 */
static void usb_dsbr100_disconnect(struct usb_interface *intf)
{
	struct dsbr100_device *radio = usb_get_intfdata(intf);

	v4l2_device_get(&radio->v4l2_dev);
	mutex_lock(&radio->v4l2_lock);
	usb_set_intfdata(intf, NULL);
	video_unregister_device(&radio->videodev);
	v4l2_device_disconnect(&radio->v4l2_dev);
	mutex_unlock(&radio->v4l2_lock);
	v4l2_device_put(&radio->v4l2_dev);
}


/* Suspend device - stop device. */
static int usb_dsbr100_suspend(struct usb_interface *intf, pm_message_t message)
{
	struct dsbr100_device *radio = usb_get_intfdata(intf);
	int retval;

	mutex_lock(&radio->v4l2_lock);
	if (radio->status == STARTED) {
		retval = dsbr100_stop(radio);
		if (retval < 0)
			dev_warn(&intf->dev, "dsbr100_stop failed\n");

		/* After dsbr100_stop() status set to STOPPED.
		 * If we want driver to start radio on resume
		 * we set status equal to STARTED.
		 * On resume we will check status and run radio if needed.
		 */
		radio->status = STARTED;
	}
	mutex_unlock(&radio->v4l2_lock);

	dev_info(&intf->dev, "going into suspend..\n");

	return 0;
}

/* Resume device - start device. */
static int usb_dsbr100_resume(struct usb_interface *intf)
{
	struct dsbr100_device *radio = usb_get_intfdata(intf);
	int retval;

	mutex_lock(&radio->v4l2_lock);
	if (radio->status == STARTED) {
		retval = dsbr100_start(radio);
		if (retval < 0)
			dev_warn(&intf->dev, "dsbr100_start failed\n");
	}
	mutex_unlock(&radio->v4l2_lock);

	dev_info(&intf->dev, "coming out of suspend..\n");

	return 0;
}

/* free data structures */
static void usb_dsbr100_release(struct v4l2_device *v4l2_dev)
{
	struct dsbr100_device *radio = v4l2_dev_to_radio(v4l2_dev);

	v4l2_device_unregister(&radio->v4l2_dev);
	kfree(radio->transfer_buffer);
	kfree(radio);
}

/* File system interface */
static const struct v4l2_file_operations usb_dsbr100_fops = {
	.owner		= THIS_MODULE,
	.unlocked_ioctl	= video_ioctl2,
};

static const struct v4l2_ioctl_ops usb_dsbr100_ioctl_ops = {
	.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,
};

/* 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)
{
	struct dsbr100_device *radio;
	struct v4l2_device *v4l2_dev;
	int retval;

	radio = kzalloc(sizeof(struct dsbr100_device), GFP_KERNEL);

	if (!radio)
		return -ENOMEM;

	radio->transfer_buffer = kmalloc(TB_LEN, GFP_KERNEL);

	if (!(radio->transfer_buffer)) {
		kfree(radio);
		return -ENOMEM;
	}

	v4l2_dev = &radio->v4l2_dev;
	v4l2_dev->release = usb_dsbr100_release;

	retval = v4l2_device_register(&intf->dev, v4l2_dev);
	if (retval < 0) {
		v4l2_err(v4l2_dev, "couldn't register v4l2_device\n");
		kfree(radio->transfer_buffer);
		kfree(radio);
		return retval;
	}

	mutex_init(&radio->v4l2_lock);
	strlcpy(radio->videodev.name, v4l2_dev->name, sizeof(radio->videodev.name));
	radio->videodev.v4l2_dev = v4l2_dev;
	radio->videodev.fops = &usb_dsbr100_fops;
	radio->videodev.ioctl_ops = &usb_dsbr100_ioctl_ops;
	radio->videodev.release = video_device_release_empty;
	radio->videodev.lock = &radio->v4l2_lock;

	radio->usbdev = interface_to_usbdev(intf);
	radio->curfreq = FREQ_MIN * FREQ_MUL;
	radio->status = STOPPED;

	video_set_drvdata(&radio->videodev, radio);

	retval = video_register_device(&radio->videodev, VFL_TYPE_RADIO, radio_nr);
	if (retval < 0) {
		v4l2_err(v4l2_dev, "couldn't register video device\n");
		v4l2_device_unregister(v4l2_dev);
		kfree(radio->transfer_buffer);
		kfree(radio);
		return -EIO;
	}
	usb_set_intfdata(intf, radio);
	return 0;
}

module_usb_driver(usb_dsbr100_driver);

MODULE_AUTHOR( DRIVER_AUTHOR );
MODULE_DESCRIPTION( DRIVER_DESC );
MODULE_LICENSE("GPL");
MODULE_VERSION(DRIVER_VERSION);
Commit	Line	Data
fc55bcb0 AK	1	/* A driver for the D-Link DSB-R100 USB radio and Gemtek USB Radio 21.
fc55bcb0 AK	2	The device plugs into both the USB and an analog audio input, so this thing
1da177e4 LT	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
f1ca0adf AK	36	Version 0.46:
	37	Removed usb_dsbr100_open/close calls and radio->users counter. Also,
	38	radio->muted changed to radio->status and suspend/resume calls updated.
	39
406827cc AK	40	Version 0.45:
	41	Converted to v4l2_device.
	42
6076dbf4 AK	43	Version 0.44:
	44	Add suspend/resume functions, fix unplug of device,
	45	a lot of cleanups and fixes by Alexey Klimov <klimov.linux@gmail.com>
	46
863c86dd ON	47	Version 0.43:
	48	Oliver Neukum: avoided DMA coherency issue
	49
7002a4f3 DL	50	Version 0.42:
	51	Converted dsbr100 to use video_ioctl2
	52	by Douglas Landgraf <dougsland@gmail.com>
	53
5aff308c AC	54	Version 0.41-ac1:
	55	Alan Cox: Some cleanups and fixes
	56
	57	Version 0.41:
	58	Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
	59
1da177e4	60	Version 0.40:
5aff308c	61	Markus: Updates for 2.6.x kernels, code layout changes, name sanitizing
1da177e4 LT	62
1da177e4 LT	63	Version 0.30:
d56410e0	64	Markus: Updates for 2.5.x kernel and more ISO compliant source
1da177e4 LT	65
1da177e4 LT	66	Version 0.25:
d56410e0	67	PSL and Markus: Cleanup, radio now doesn't stop on device close
1da177e4 LT	68
1da177e4 LT	69	Version 0.24:
d56410e0	70	Markus: Hope I got these silly VIDEO_TUNER_LOW issues finally
1da177e4 LT	71	right. Some minor cleanup, improved standalone compilation
	72
	73	Version 0.23:
d56410e0	74	Markus: Sign extension bug fixed by declaring transfer_buffer unsigned
1da177e4 LT	75
1da177e4 LT	76	Version 0.22:
d56410e0	77	Markus: Some (brown bag) cleanup in what VIDIOCSTUNER returns,
1da177e4 LT	78	thanks to Mike Cox for pointing the problem out.
	79
	80	Version 0.21:
d56410e0	81	Markus: Minor cleanup, warnings if something goes wrong, lame attempt
1da177e4 LT	82	to adhere to Documentation/CodingStyle
1da177e4 LT	83
d56410e0 MCC	84	Version 0.2:
d56410e0 MCC	85	Brad Hards <bradh@dynamite.com.au>: Fixes to make it work as non-module
1da177e4 LT	86	Markus: Copyright clarification
	87
	88	Version 0.01: Markus: initial release
	89
	90	*/
	91
1da177e4 LT	92	#include <linux/kernel.h>
	93	#include <linux/module.h>
	94	#include <linux/init.h>
	95	#include <linux/slab.h>
	96	#include <linux/input.h>
5aff308c	97	#include <linux/videodev2.h>
406827cc	98	#include <media/v4l2-device.h>
35ea11ff	99	#include <media/v4l2-ioctl.h>
1da177e4	100	#include <linux/usb.h>
1da177e4 LT	101
	102	/*
	103	* Version Information
	104	*/
29834c1a	105	#define DRIVER_VERSION "0.4.7"
5aff308c	106
1da177e4 LT	107	#define DRIVER_AUTHOR "Markus Demleitner <msdemlei@tucana.harvard.edu>"
	108	#define DRIVER_DESC "D-Link DSB-R100 USB FM radio driver"
	109
	110	#define DSB100_VENDOR 0x04b4
	111	#define DSB100_PRODUCT 0x1002
	112
	113	/* Commands the device appears to understand */
	114	#define DSB100_TUNE 1
	115	#define DSB100_ONOFF 2
	116
	117	#define TB_LEN 16
	118
	119	/* Frequency limits in MHz -- these are European values. For Japanese
	120	devices, that would be 76 and 91. */
	121	#define FREQ_MIN 87.5
	122	#define FREQ_MAX 108.0
	123	#define FREQ_MUL 16000
	124
f1ca0adf AK	125	/* defines for radio->status */
	126	#define STARTED 0
	127	#define STOPPED 1
	128
13099294	129	#define v4l2_dev_to_radio(d) container_of(d, struct dsbr100_device, v4l2_dev)
1da177e4 LT	130
	131	static int usb_dsbr100_probe(struct usb_interface *intf,
	132	const struct usb_device_id *id);
	133	static void usb_dsbr100_disconnect(struct usb_interface *intf);
04e0ffbb AK	134	static int usb_dsbr100_suspend(struct usb_interface *intf,
	135	pm_message_t message);
	136	static int usb_dsbr100_resume(struct usb_interface *intf);
1da177e4 LT	137
	138	static int radio_nr = -1;
	139	module_param(radio_nr, int, 0);
	140
	141	/* Data for one (physical) device */
5aff308c	142	struct dsbr100_device {
1da177e4	143	struct usb_device *usbdev;
3a0efc32	144	struct video_device videodev;
406827cc AK	145	struct v4l2_device v4l2_dev;
406827cc AK	146
863c86dd	147	u8 *transfer_buffer;
e64d07c9	148	struct mutex v4l2_lock;
1da177e4 LT	149	int curfreq;
1da177e4 LT	150	int stereo;
f1ca0adf	151	int status;
5aff308c	152	};
1da177e4	153
1da177e4 LT	154	static struct usb_device_id usb_dsbr100_device_table [] = {
	155	{ USB_DEVICE(DSB100_VENDOR, DSB100_PRODUCT) },
	156	{ } /* Terminating entry */
	157	};
	158
	159	MODULE_DEVICE_TABLE (usb, usb_dsbr100_device_table);
	160
	161	/* USB subsystem interface */
	162	static struct usb_driver usb_dsbr100_driver = {
04e0ffbb AK	163	.name = "dsbr100",
	164	.probe = usb_dsbr100_probe,
	165	.disconnect = usb_dsbr100_disconnect,
	166	.id_table = usb_dsbr100_device_table,
	167	.suspend = usb_dsbr100_suspend,
	168	.resume = usb_dsbr100_resume,
	169	.reset_resume = usb_dsbr100_resume,
	170	.supports_autosuspend = 0,
1da177e4 LT	171	};
	172
	173	/* Low-level device interface begins here */
	174
	175	/* switch on radio */
5aff308c	176	static int dsbr100_start(struct dsbr100_device *radio)
1da177e4	177	{
417b7953 AK	178	int retval;
	179	int request;
	180
417b7953 AK	181	retval = usb_control_msg(radio->usbdev,
	182	usb_rcvctrlpipe(radio->usbdev, 0),
	183	USB_REQ_GET_STATUS,
	184	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
	185	0x00, 0xC7, radio->transfer_buffer, 8, 300);
	186
	187	if (retval < 0) {
	188	request = USB_REQ_GET_STATUS;
	189	goto usb_control_msg_failed;
3a0efc32 AK	190	}
3a0efc32 AK	191
417b7953 AK	192	retval = usb_control_msg(radio->usbdev,
	193	usb_rcvctrlpipe(radio->usbdev, 0),
	194	DSB100_ONOFF,
	195	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
	196	0x01, 0x00, radio->transfer_buffer, 8, 300);
	197
	198	if (retval < 0) {
	199	request = DSB100_ONOFF;
	200	goto usb_control_msg_failed;
	201	}
	202
f1ca0adf	203	radio->status = STARTED;
1da177e4	204	return (radio->transfer_buffer)[0];
417b7953 AK	205
417b7953 AK	206	usb_control_msg_failed:
417b7953 AK	207	dev_err(&radio->usbdev->dev,
	208	"%s - usb_control_msg returned %i, request %i\n",
	209	__func__, retval, request);
d25cb646	210	return retval;
417b7953	211
1da177e4 LT	212	}
1da177e4 LT	213
1da177e4	214	/* switch off radio */
5aff308c	215	static int dsbr100_stop(struct dsbr100_device *radio)
1da177e4	216	{
417b7953 AK	217	int retval;
	218	int request;
	219
417b7953 AK	220	retval = usb_control_msg(radio->usbdev,
	221	usb_rcvctrlpipe(radio->usbdev, 0),
	222	USB_REQ_GET_STATUS,
	223	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
	224	0x16, 0x1C, radio->transfer_buffer, 8, 300);
	225
	226	if (retval < 0) {
	227	request = USB_REQ_GET_STATUS;
	228	goto usb_control_msg_failed;
	229	}
	230
	231	retval = usb_control_msg(radio->usbdev,
	232	usb_rcvctrlpipe(radio->usbdev, 0),
	233	DSB100_ONOFF,
	234	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
	235	0x00, 0x00, radio->transfer_buffer, 8, 300);
	236
	237	if (retval < 0) {
	238	request = DSB100_ONOFF;
	239	goto usb_control_msg_failed;
3a0efc32 AK	240	}
3a0efc32 AK	241
f1ca0adf	242	radio->status = STOPPED;
1da177e4	243	return (radio->transfer_buffer)[0];
417b7953 AK	244
417b7953 AK	245	usb_control_msg_failed:
417b7953 AK	246	dev_err(&radio->usbdev->dev,
	247	"%s - usb_control_msg returned %i, request %i\n",
	248	__func__, retval, request);
d25cb646	249	return retval;
417b7953	250
1da177e4 LT	251	}
	252
	253	/* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */
917fab4f	254	static int dsbr100_setfreq(struct dsbr100_device *radio)
1da177e4	255	{
417b7953 AK	256	int retval;
417b7953 AK	257	int request;
917fab4f	258	int freq = (radio->curfreq / 16 * 80) / 1000 + 856;
417b7953	259
417b7953 AK	260	retval = usb_control_msg(radio->usbdev,
	261	usb_rcvctrlpipe(radio->usbdev, 0),
	262	DSB100_TUNE,
	263	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
	264	(freq >> 8) & 0x00ff, freq & 0xff,
	265	radio->transfer_buffer, 8, 300);
	266
	267	if (retval < 0) {
	268	request = DSB100_TUNE;
	269	goto usb_control_msg_failed;
	270	}
	271
	272	retval = usb_control_msg(radio->usbdev,
	273	usb_rcvctrlpipe(radio->usbdev, 0),
	274	USB_REQ_GET_STATUS,
	275	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
	276	0x96, 0xB7, radio->transfer_buffer, 8, 300);
	277
	278	if (retval < 0) {
	279	request = USB_REQ_GET_STATUS;
	280	goto usb_control_msg_failed;
	281	}
	282
	283	retval = usb_control_msg(radio->usbdev,
	284	usb_rcvctrlpipe(radio->usbdev, 0),
	285	USB_REQ_GET_STATUS,
	286	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
	287	0x00, 0x24, radio->transfer_buffer, 8, 300);
	288
	289	if (retval < 0) {
	290	request = USB_REQ_GET_STATUS;
	291	goto usb_control_msg_failed;
1da177e4	292	}
3a0efc32	293
223377e7	294	radio->stereo = !((radio->transfer_buffer)[0] & 0x01);
1da177e4	295	return (radio->transfer_buffer)[0];
417b7953 AK	296
	297	usb_control_msg_failed:
	298	radio->stereo = -1;
417b7953 AK	299	dev_err(&radio->usbdev->dev,
	300	"%s - usb_control_msg returned %i, request %i\n",
	301	__func__, retval, request);
d25cb646	302	return retval;
1da177e4 LT	303	}
	304
	305	/* return the device status. This is, in effect, just whether it
	306	sees a stereo signal or not. Pity. */
5aff308c	307	static void dsbr100_getstat(struct dsbr100_device *radio)
1da177e4	308	{
417b7953 AK	309	int retval;
417b7953 AK	310
417b7953 AK	311	retval = usb_control_msg(radio->usbdev,
417b7953 AK	312	usb_rcvctrlpipe(radio->usbdev, 0),
d56410e0	313	USB_REQ_GET_STATUS,
1da177e4	314	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
417b7953 AK	315	0x00 , 0x24, radio->transfer_buffer, 8, 300);
	316
	317	if (retval < 0) {
1da177e4	318	radio->stereo = -1;
417b7953 AK	319	dev_err(&radio->usbdev->dev,
	320	"%s - usb_control_msg returned %i, request %i\n",
	321	__func__, retval, USB_REQ_GET_STATUS);
	322	} else {
223377e7	323	radio->stereo = !(radio->transfer_buffer[0] & 0x01);
417b7953	324	}
1da177e4 LT	325	}
1da177e4 LT	326
7002a4f3 DL	327	static int vidioc_querycap(struct file file, void priv,
	328	struct v4l2_capability *v)
	329	{
c7181cfa AK	330	struct dsbr100_device *radio = video_drvdata(file);
c7181cfa AK	331
7002a4f3 DL	332	strlcpy(v->driver, "dsbr100", sizeof(v->driver));
7002a4f3 DL	333	strlcpy(v->card, "D-Link R-100 USB FM Radio", sizeof(v->card));
c7181cfa	334	usb_make_path(radio->usbdev, v->bus_info, sizeof(v->bus_info));
7002a4f3 DL	335	v->capabilities = V4L2_CAP_TUNER;
	336	return 0;
	337	}
1da177e4	338
7002a4f3 DL	339	static int vidioc_g_tuner(struct file file, void priv,
7002a4f3 DL	340	struct v4l2_tuner *v)
1da177e4	341	{
c170ecf4	342	struct dsbr100_device *radio = video_drvdata(file);
7002a4f3 DL	343
	344	if (v->index > 0)
	345	return -EINVAL;
	346
	347	dsbr100_getstat(radio);
	348	strcpy(v->name, "FM");
	349	v->type = V4L2_TUNER_RADIO;
223377e7 AK	350	v->rangelow = FREQ_MIN * FREQ_MUL;
	351	v->rangehigh = FREQ_MAX * FREQ_MUL;
	352	v->rxsubchans = V4L2_TUNER_SUB_MONO \| V4L2_TUNER_SUB_STEREO;
7002a4f3 DL	353	v->capability = V4L2_TUNER_CAP_LOW;
	354	if(radio->stereo)
	355	v->audmode = V4L2_TUNER_MODE_STEREO;
	356	else
	357	v->audmode = V4L2_TUNER_MODE_MONO;
	358	v->signal = 0xffff; /* We can't get the signal strength */
	359	return 0;
	360	}
1da177e4	361
7002a4f3 DL	362	static int vidioc_s_tuner(struct file file, void priv,
	363	struct v4l2_tuner *v)
	364	{
13099294	365	return v->index ? -EINVAL : 0;
7002a4f3	366	}
5aff308c	367
7002a4f3 DL	368	static int vidioc_s_frequency(struct file file, void priv,
	369	struct v4l2_frequency *f)
	370	{
c170ecf4	371	struct dsbr100_device *radio = video_drvdata(file);
417b7953	372	int retval;
1da177e4	373
7002a4f3	374	radio->curfreq = f->frequency;
fdf9c997	375
917fab4f	376	retval = dsbr100_setfreq(radio);
d25cb646	377	if (retval < 0)
aa82661b	378	dev_warn(&radio->usbdev->dev, "Set frequency failed\n");
7002a4f3 DL	379	return 0;
7002a4f3 DL	380	}
5aff308c	381
7002a4f3 DL	382	static int vidioc_g_frequency(struct file file, void priv,
	383	struct v4l2_frequency *f)
	384	{
c170ecf4	385	struct dsbr100_device *radio = video_drvdata(file);
5aff308c	386
7002a4f3 DL	387	f->type = V4L2_TUNER_RADIO;
	388	f->frequency = radio->curfreq;
	389	return 0;
	390	}
5aff308c	391
7002a4f3 DL	392	static int vidioc_queryctrl(struct file file, void priv,
	393	struct v4l2_queryctrl *qc)
	394	{
406827cc AK	395	switch (qc->id) {
	396	case V4L2_CID_AUDIO_MUTE:
	397	return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
7002a4f3	398	}
406827cc	399
7002a4f3 DL	400	return -EINVAL;
7002a4f3 DL	401	}
5aff308c	402
7002a4f3 DL	403	static int vidioc_g_ctrl(struct file file, void priv,
	404	struct v4l2_control *ctrl)
	405	{
c170ecf4	406	struct dsbr100_device *radio = video_drvdata(file);
1da177e4	407
7002a4f3 DL	408	switch (ctrl->id) {
7002a4f3 DL	409	case V4L2_CID_AUDIO_MUTE:
f1ca0adf	410	ctrl->value = radio->status;
7002a4f3 DL	411	return 0;
	412	}
	413	return -EINVAL;
	414	}
5aff308c	415
7002a4f3 DL	416	static int vidioc_s_ctrl(struct file file, void priv,
	417	struct v4l2_control *ctrl)
	418	{
c170ecf4	419	struct dsbr100_device *radio = video_drvdata(file);
417b7953	420	int retval;
5aff308c	421
7002a4f3 DL	422	switch (ctrl->id) {
	423	case V4L2_CID_AUDIO_MUTE:
	424	if (ctrl->value) {
417b7953	425	retval = dsbr100_stop(radio);
d25cb646	426	if (retval < 0) {
aa82661b GKH	427	dev_warn(&radio->usbdev->dev,
aa82661b GKH	428	"Radio did not respond properly\n");
90b698dd AK	429	return -EBUSY;
90b698dd AK	430	}
7002a4f3	431	} else {
417b7953	432	retval = dsbr100_start(radio);
d25cb646	433	if (retval < 0) {
aa82661b GKH	434	dev_warn(&radio->usbdev->dev,
aa82661b GKH	435	"Radio did not respond properly\n");
90b698dd AK	436	return -EBUSY;
90b698dd AK	437	}
1da177e4	438	}
7002a4f3	439	return 0;
1da177e4	440	}
7002a4f3	441	return -EINVAL;
1da177e4 LT	442	}
1da177e4 LT	443
7002a4f3 DL	444	static int vidioc_g_audio(struct file file, void priv,
7002a4f3 DL	445	struct v4l2_audio *a)
1da177e4	446	{
7002a4f3 DL	447	if (a->index > 1)
	448	return -EINVAL;
	449
	450	strcpy(a->name, "Radio");
	451	a->capability = V4L2_AUDCAP_STEREO;
	452	return 0;
	453	}
	454
	455	static int vidioc_g_input(struct file filp, void priv, unsigned int *i)
	456	{
	457	*i = 0;
	458	return 0;
	459	}
	460
	461	static int vidioc_s_input(struct file filp, void priv, unsigned int i)
	462	{
13099294	463	return i ? -EINVAL : 0;
7002a4f3 DL	464	}
	465
	466	static int vidioc_s_audio(struct file file, void priv,
	467	struct v4l2_audio *a)
	468	{
13099294	469	return a->index ? -EINVAL : 0;
1da177e4 LT	470	}
1da177e4 LT	471
e64d07c9 HV	472	/* USB subsystem interface begins here */
	473
	474	/*
	475	* Handle unplugging of the device.
	476	* We call video_unregister_device in any case.
	477	* The last function called in this procedure is
	478	* usb_dsbr100_video_device_release
	479	*/
	480	static void usb_dsbr100_disconnect(struct usb_interface *intf)
	481	{
	482	struct dsbr100_device *radio = usb_get_intfdata(intf);
	483
13099294	484	v4l2_device_get(&radio->v4l2_dev);
e64d07c9	485	mutex_lock(&radio->v4l2_lock);
13099294	486	usb_set_intfdata(intf, NULL);
e64d07c9 HV	487	video_unregister_device(&radio->videodev);
e64d07c9 HV	488	v4l2_device_disconnect(&radio->v4l2_dev);
13099294 HV	489	mutex_unlock(&radio->v4l2_lock);
13099294 HV	490	v4l2_device_put(&radio->v4l2_dev);
e64d07c9 HV	491	}
	492
	493
04e0ffbb AK	494	/* Suspend device - stop device. */
	495	static int usb_dsbr100_suspend(struct usb_interface *intf, pm_message_t message)
	496	{
	497	struct dsbr100_device *radio = usb_get_intfdata(intf);
	498	int retval;
	499
e64d07c9	500	mutex_lock(&radio->v4l2_lock);
f1ca0adf AK	501	if (radio->status == STARTED) {
	502	retval = dsbr100_stop(radio);
	503	if (retval < 0)
	504	dev_warn(&intf->dev, "dsbr100_stop failed\n");
	505
	506	/* After dsbr100_stop() status set to STOPPED.
	507	* If we want driver to start radio on resume
	508	* we set status equal to STARTED.
	509	* On resume we will check status and run radio if needed.
	510	*/
f1ca0adf	511	radio->status = STARTED;
f1ca0adf	512	}
e64d07c9	513	mutex_unlock(&radio->v4l2_lock);
04e0ffbb AK	514
	515	dev_info(&intf->dev, "going into suspend..\n");
	516
	517	return 0;
	518	}
	519
	520	/* Resume device - start device. */
	521	static int usb_dsbr100_resume(struct usb_interface *intf)
	522	{
	523	struct dsbr100_device *radio = usb_get_intfdata(intf);
	524	int retval;
	525
e64d07c9	526	mutex_lock(&radio->v4l2_lock);
f1ca0adf AK	527	if (radio->status == STARTED) {
	528	retval = dsbr100_start(radio);
	529	if (retval < 0)
	530	dev_warn(&intf->dev, "dsbr100_start failed\n");
	531	}
e64d07c9	532	mutex_unlock(&radio->v4l2_lock);
04e0ffbb AK	533
	534	dev_info(&intf->dev, "coming out of suspend..\n");
	535
	536	return 0;
	537	}
	538
fc55bcb0	539	/* free data structures */
13099294	540	static void usb_dsbr100_release(struct v4l2_device *v4l2_dev)
3a0efc32	541	{
13099294	542	struct dsbr100_device *radio = v4l2_dev_to_radio(v4l2_dev);
3a0efc32	543
406827cc	544	v4l2_device_unregister(&radio->v4l2_dev);
3a0efc32 AK	545	kfree(radio->transfer_buffer);
	546	kfree(radio);
	547	}
	548
7002a4f3	549	/* File system interface */
bec43661	550	static const struct v4l2_file_operations usb_dsbr100_fops = {
7002a4f3	551	.owner = THIS_MODULE,
e64d07c9	552	.unlocked_ioctl = video_ioctl2,
7002a4f3 DL	553	};
7002a4f3 DL	554
a399810c	555	static const struct v4l2_ioctl_ops usb_dsbr100_ioctl_ops = {
7002a4f3 DL	556	.vidioc_querycap = vidioc_querycap,
	557	.vidioc_g_tuner = vidioc_g_tuner,
	558	.vidioc_s_tuner = vidioc_s_tuner,
	559	.vidioc_g_frequency = vidioc_g_frequency,
	560	.vidioc_s_frequency = vidioc_s_frequency,
	561	.vidioc_queryctrl = vidioc_queryctrl,
	562	.vidioc_g_ctrl = vidioc_g_ctrl,
	563	.vidioc_s_ctrl = vidioc_s_ctrl,
	564	.vidioc_g_audio = vidioc_g_audio,
	565	.vidioc_s_audio = vidioc_s_audio,
	566	.vidioc_g_input = vidioc_g_input,
	567	.vidioc_s_input = vidioc_s_input,
	568	};
	569
fc55bcb0	570	/* check if the device is present and register with v4l and usb if it is */
7002a4f3 DL	571	static int usb_dsbr100_probe(struct usb_interface *intf,
	572	const struct usb_device_id *id)
	573	{
	574	struct dsbr100_device *radio;
406827cc	575	struct v4l2_device *v4l2_dev;
417b7953	576	int retval;
7002a4f3	577
406827cc	578	radio = kzalloc(sizeof(struct dsbr100_device), GFP_KERNEL);
223377e7 AK	579
223377e7 AK	580	if (!radio)
7002a4f3	581	return -ENOMEM;
223377e7 AK	582
	583	radio->transfer_buffer = kmalloc(TB_LEN, GFP_KERNEL);
	584
	585	if (!(radio->transfer_buffer)) {
863c86dd ON	586	kfree(radio);
	587	return -ENOMEM;
	588	}
223377e7	589
406827cc	590	v4l2_dev = &radio->v4l2_dev;
13099294	591	v4l2_dev->release = usb_dsbr100_release;
406827cc AK	592
	593	retval = v4l2_device_register(&intf->dev, v4l2_dev);
	594	if (retval < 0) {
	595	v4l2_err(v4l2_dev, "couldn't register v4l2_device\n");
	596	kfree(radio->transfer_buffer);
	597	kfree(radio);
	598	return retval;
	599	}
	600
e64d07c9	601	mutex_init(&radio->v4l2_lock);
406827cc AK	602	strlcpy(radio->videodev.name, v4l2_dev->name, sizeof(radio->videodev.name));
	603	radio->videodev.v4l2_dev = v4l2_dev;
	604	radio->videodev.fops = &usb_dsbr100_fops;
	605	radio->videodev.ioctl_ops = &usb_dsbr100_ioctl_ops;
13099294	606	radio->videodev.release = video_device_release_empty;
e64d07c9	607	radio->videodev.lock = &radio->v4l2_lock;
3a0efc32	608
7002a4f3	609	radio->usbdev = interface_to_usbdev(intf);
223377e7	610	radio->curfreq = FREQ_MIN * FREQ_MUL;
f1ca0adf	611	radio->status = STOPPED;
406827cc	612
3a0efc32	613	video_set_drvdata(&radio->videodev, radio);
406827cc	614
417b7953 AK	615	retval = video_register_device(&radio->videodev, VFL_TYPE_RADIO, radio_nr);
417b7953 AK	616	if (retval < 0) {
406827cc AK	617	v4l2_err(v4l2_dev, "couldn't register video device\n");
406827cc AK	618	v4l2_device_unregister(v4l2_dev);
863c86dd	619	kfree(radio->transfer_buffer);
7002a4f3 DL	620	kfree(radio);
	621	return -EIO;
	622	}
	623	usb_set_intfdata(intf, radio);
	624	return 0;
	625	}
	626
ecb3b2b3	627	module_usb_driver(usb_dsbr100_driver);
1da177e4 LT	628
	629	MODULE_AUTHOR( DRIVER_AUTHOR );
	630	MODULE_DESCRIPTION( DRIVER_DESC );
	631	MODULE_LICENSE("GPL");
29834c1a	632	MODULE_VERSION(DRIVER_VERSION);