[media] radio-mr800: cleanup and have it comply to the V4L2 API (85578b0f) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/media/radio/radio-mr800.c

+112 −228

Original line number	Diff line number	Diff line
		@@ -62,6 +62,8 @@
		#include <linux/videodev2.h>
		#include <media/v4l2-device.h>
		#include <media/v4l2-ioctl.h>
		#include <media/v4l2-ctrls.h>
		#include <media/v4l2-event.h>
		#include <linux/usb.h>
		#include <linux/mutex.h>

		@@ -117,29 +119,20 @@ static int radio_nr = -1;
		module_param(radio_nr, int, 0);
		MODULE_PARM_DESC(radio_nr, "Radio Nr");

		static int usb_amradio_probe(struct usb_interface *intf,
		const struct usb_device_id *id);
		static void usb_amradio_disconnect(struct usb_interface *intf);
		static int usb_amradio_open(struct file *file);
		static int usb_amradio_close(struct file *file);
		static int usb_amradio_suspend(struct usb_interface *intf,
		pm_message_t message);
		static int usb_amradio_resume(struct usb_interface *intf);

		/* Data for one (physical) device */
		struct amradio_device {
		/* reference to USB and video device */
		struct usb_device *usbdev;
		struct usb_interface *intf;
		struct video_device videodev;
		struct video_device vdev;
		struct v4l2_device v4l2_dev;
		struct v4l2_ctrl_handler hdl;

		unsigned char *buffer;
		struct mutex lock; /* buffer locking */
		int curfreq;
		int stereo;
		int muted;
		int initialized;
		};

		static inline struct amradio_device to_amradio_dev(struct v4l2_device v4l2_dev)
		@@ -147,27 +140,6 @@ static inline struct amradio_device to_amradio_dev(struct v4l2_device v4l2_dev
		return container_of(v4l2_dev, struct amradio_device, v4l2_dev);
		}

		/* USB Device ID List */
		static struct usb_device_id usb_amradio_device_table[] = {
		{USB_DEVICE_AND_INTERFACE_INFO(USB_AMRADIO_VENDOR, USB_AMRADIO_PRODUCT,
		USB_CLASS_HID, 0, 0) },
		{ } /* Terminating entry */
		};

		MODULE_DEVICE_TABLE(usb, usb_amradio_device_table);

		/* USB subsystem interface */
		static struct usb_driver usb_amradio_driver = {
		.name = MR800_DRIVER_NAME,
		.probe = usb_amradio_probe,
		.disconnect = usb_amradio_disconnect,
		.suspend = usb_amradio_suspend,
		.resume = usb_amradio_resume,
		.reset_resume = usb_amradio_resume,
		.id_table = usb_amradio_device_table,
		.supports_autosuspend = 1,
		};

		/* switch on/off the radio. Send 8 bytes to device */
		static int amradio_set_mute(struct amradio_device *radio, char argument)
		{
		@@ -187,21 +159,19 @@ static int amradio_set_mute(struct amradio_device *radio, char argument)
		(void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);

		if (retval < 0 \|\| size != BUFFER_LENGTH) {
		amradio_dev_warn(&radio->videodev.dev, "set mute failed\n");
		return retval;
		amradio_dev_warn(&radio->vdev.dev, "set mute failed\n");
		return retval < 0 ? retval : -EIO;
		}

		radio->muted = argument;

		return retval;
		return 0;
		}

		/* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */
		static int amradio_setfreq(struct amradio_device *radio, int freq)
		{
		unsigned short freq_send = 0x10 + (freq >> 3) / 25;
		int retval;
		int size;
		unsigned short freq_send = 0x10 + (freq >> 3) / 25;

		radio->buffer[0] = 0x00;
		radio->buffer[1] = 0x55;
		@@ -216,7 +186,7 @@ static int amradio_setfreq(struct amradio_device *radio, int freq)
		(void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);

		if (retval < 0 \|\| size != BUFFER_LENGTH)
		goto out_err;
		goto out;

		/* frequency is calculated from freq_send and placed in first 2 bytes */
		radio->buffer[0] = (freq_send >> 8) & 0xff;
		@@ -230,16 +200,14 @@ static int amradio_setfreq(struct amradio_device *radio, int freq)
		retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
		(void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);

		if (retval < 0 \|\| size != BUFFER_LENGTH)
		goto out_err;

		if (retval >= 0 && size == BUFFER_LENGTH) {
		radio->curfreq = freq;
		goto out;
		return 0;
		}

		out_err:
		amradio_dev_warn(&radio->videodev.dev, "set frequency failed\n");
		out:
		return retval;
		amradio_dev_warn(&radio->vdev.dev, "set frequency failed\n");
		return retval < 0 ? retval : -EIO;
		}

		static int amradio_set_stereo(struct amradio_device *radio, char argument)
		@@ -260,16 +228,12 @@ static int amradio_set_stereo(struct amradio_device *radio, char argument)
		(void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);

		if (retval < 0 \|\| size != BUFFER_LENGTH) {
		amradio_dev_warn(&radio->videodev.dev, "set stereo failed\n");
		return retval;
		amradio_dev_warn(&radio->vdev.dev, "set stereo failed\n");
		return retval < 0 ? retval : -EIO;
		}

		if (argument == WANT_STEREO)
		radio->stereo = 1;
		else
		radio->stereo = 0;

		return retval;
		radio->stereo = (argument == WANT_STEREO);
		return 0;
		}

		/* Handle unplugging the device.
		@@ -282,25 +246,24 @@ static void usb_amradio_disconnect(struct usb_interface *intf)
		struct amradio_device *radio = to_amradio_dev(usb_get_intfdata(intf));

		mutex_lock(&radio->lock);
		/* increase the device node's refcount */
		get_device(&radio->videodev.dev);
		usb_set_intfdata(intf, NULL);
		video_unregister_device(&radio->vdev);
		v4l2_device_disconnect(&radio->v4l2_dev);
		video_unregister_device(&radio->videodev);
		mutex_unlock(&radio->lock);
		/* decrease the device node's refcount, allowing it to be released */
		put_device(&radio->videodev.dev);
		v4l2_device_put(&radio->v4l2_dev);
		}

		/* vidioc_querycap - query device capabilities */
		static int vidioc_querycap(struct file file, void priv,
		struct v4l2_capability *v)
		{
		struct amradio_device *radio = file->private_data;
		struct amradio_device *radio = video_drvdata(file);

		strlcpy(v->driver, "radio-mr800", sizeof(v->driver));
		strlcpy(v->card, "AverMedia MR 800 USB FM Radio", sizeof(v->card));
		usb_make_path(radio->usbdev, v->bus_info, sizeof(v->bus_info));
		v->capabilities = V4L2_CAP_TUNER;
		v->device_caps = V4L2_CAP_RADIO \| V4L2_CAP_TUNER;
		v->capabilities = v->device_caps \| V4L2_CAP_DEVICE_CAPS;
		return 0;
		}

		@@ -308,44 +271,31 @@ static int vidioc_querycap(struct file file, void priv,
		static int vidioc_g_tuner(struct file file, void priv,
		struct v4l2_tuner *v)
		{
		struct amradio_device *radio = file->private_data;
		int retval;
		struct amradio_device *radio = video_drvdata(file);

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

		/* TODO: Add function which look is signal stereo or not
		* amradio_getstat(radio);
		*/

		/* we call amradio_set_stereo to set radio->stereo
		* Honestly, amradio_getstat should cover this in future and
		* amradio_set_stereo shouldn't be here
		*/
		retval = amradio_set_stereo(radio, WANT_STEREO);

		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; /* Can't get the signal strength, sad.. */
		v->afc = 0; /* Don't know what is this */

		return retval;
		v->capability = V4L2_TUNER_CAP_LOW \| V4L2_TUNER_CAP_STEREO;
		/* We do not know how to get hold of the stereo indicator, so
		all we can do is give back both mono and stereo, which
		effectively means that we don't know. */
		v->rxsubchans = V4L2_TUNER_SUB_STEREO \| V4L2_TUNER_SUB_MONO;
		v->signal = 0xffff;
		v->audmode = radio->stereo ?
		V4L2_TUNER_MODE_STEREO : V4L2_TUNER_MODE_MONO;
		return 0;
		}

		/* vidioc_s_tuner - set tuner attributes */
		static int vidioc_s_tuner(struct file file, void priv,
		struct v4l2_tuner *v)
		{
		struct amradio_device *radio = file->private_data;
		int retval = -EINVAL;
		struct amradio_device *radio = video_drvdata(file);

		if (v->index > 0)
		return -EINVAL;
		@@ -353,34 +303,31 @@ static int vidioc_s_tuner(struct file file, void priv,
		/* mono/stereo selector */
		switch (v->audmode) {
		case V4L2_TUNER_MODE_MONO:
		retval = amradio_set_stereo(radio, WANT_MONO);
		break;
		case V4L2_TUNER_MODE_STEREO:
		retval = amradio_set_stereo(radio, WANT_STEREO);
		break;
		return amradio_set_stereo(radio, WANT_MONO);
		default:
		return amradio_set_stereo(radio, WANT_STEREO);
		}

		return retval;
		}

		/* vidioc_s_frequency - set tuner radio frequency */
		static int vidioc_s_frequency(struct file file, void priv,
		struct v4l2_frequency *f)
		{
		struct amradio_device *radio = file->private_data;
		struct amradio_device *radio = video_drvdata(file);

		if (f->tuner != 0 \|\| f->type != V4L2_TUNER_RADIO)
		if (f->tuner != 0)
		return -EINVAL;
		return amradio_setfreq(radio, f->frequency);
		return amradio_setfreq(radio, clamp_t(unsigned, f->frequency,
		FREQ_MIN * FREQ_MUL, FREQ_MAX * FREQ_MUL));
		}

		/* vidioc_g_frequency - get tuner radio frequency */
		static int vidioc_g_frequency(struct file file, void priv,
		struct v4l2_frequency *f)
		{
		struct amradio_device *radio = file->private_data;
		struct amradio_device *radio = video_drvdata(file);

		if (f->tuner != 0)
		if (f->tuner != 0 \|\| f->type != V4L2_TUNER_RADIO)
		return -EINVAL;
		f->type = V4L2_TUNER_RADIO;
		f->frequency = radio->curfreq;
		@@ -388,89 +335,20 @@ static int vidioc_g_frequency(struct file file, void priv,
		return 0;
		}

		/* vidioc_queryctrl - enumerate control items */
		static int vidioc_queryctrl(struct file file, void priv,
		struct v4l2_queryctrl *qc)
		static int usb_amradio_s_ctrl(struct v4l2_ctrl *ctrl)
		{
		switch (qc->id) {
		case V4L2_CID_AUDIO_MUTE:
		return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
		}

		return -EINVAL;
		}

		/* vidioc_g_ctrl - get the value of a control */
		static int vidioc_g_ctrl(struct file file, void priv,
		struct v4l2_control *ctrl)
		{
		struct amradio_device *radio = file->private_data;
		struct amradio_device *radio =
		container_of(ctrl->handler, struct amradio_device, hdl);

		switch (ctrl->id) {
		case V4L2_CID_AUDIO_MUTE:
		ctrl->value = radio->muted;
		return 0;
		return amradio_set_mute(radio,
		ctrl->val ? AMRADIO_STOP : AMRADIO_START);
		}

		return -EINVAL;
		}

		/* vidioc_s_ctrl - set the value of a control */
		static int vidioc_s_ctrl(struct file file, void priv,
		struct v4l2_control *ctrl)
		{
		struct amradio_device *radio = file->private_data;
		int retval = -EINVAL;

		switch (ctrl->id) {
		case V4L2_CID_AUDIO_MUTE:
		if (ctrl->value)
		retval = amradio_set_mute(radio, AMRADIO_STOP);
		else
		retval = amradio_set_mute(radio, AMRADIO_START);

		break;
		}

		return retval;
		}

		/* vidioc_g_audio - get audio attributes */
		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;
		}

		/* vidioc_s_audio - set audio attributes */
		static int vidioc_s_audio(struct file file, void priv,
		struct v4l2_audio *a)
		{
		if (a->index != 0)
		return -EINVAL;
		return 0;
		}

		/* vidioc_g_input - get input */
		static int vidioc_g_input(struct file filp, void priv, unsigned int *i)
		{
		*i = 0;
		return 0;
		}

		/* vidioc_s_input - set input */
		static int vidioc_s_input(struct file filp, void priv, unsigned int i)
		{
		if (i != 0)
		return -EINVAL;
		return 0;
		}

		static int usb_amradio_init(struct amradio_device *radio)
		{
		int retval;
		@@ -483,51 +361,21 @@ static int usb_amradio_init(struct amradio_device *radio)
		if (retval)
		goto out_err;

		radio->initialized = 1;
		goto out;

		out_err:
		amradio_dev_err(&radio->videodev.dev, "initialization failed\n");
		amradio_dev_err(&radio->vdev.dev, "initialization failed\n");
		out:
		return retval;
		}

		/* open device - amradio_start() and amradio_setfreq() */
		static int usb_amradio_open(struct file *file)
		{
		struct amradio_device *radio = video_drvdata(file);
		int retval;

		file->private_data = radio;
		retval = usb_autopm_get_interface(radio->intf);
		if (retval)
		return retval;

		if (unlikely(!radio->initialized)) {
		retval = usb_amradio_init(radio);
		if (retval)
		usb_autopm_put_interface(radio->intf);
		}
		return retval;
		}

		/close device /
		static int usb_amradio_close(struct file *file)
		{
		struct amradio_device *radio = file->private_data;

		if (video_is_registered(&radio->videodev))
		usb_autopm_put_interface(radio->intf);
		return 0;
		}

		/* Suspend device - stop device. Need to be checked and fixed */
		static int usb_amradio_suspend(struct usb_interface *intf, pm_message_t message)
		{
		struct amradio_device *radio = to_amradio_dev(usb_get_intfdata(intf));

		mutex_lock(&radio->lock);
		if (!radio->muted && radio->initialized) {
		if (!radio->muted) {
		amradio_set_mute(radio, AMRADIO_STOP);
		radio->muted = 0;
		}
		@@ -543,9 +391,6 @@ static int usb_amradio_resume(struct usb_interface *intf)
		struct amradio_device *radio = to_amradio_dev(usb_get_intfdata(intf));

		mutex_lock(&radio->lock);
		if (unlikely(!radio->initialized))
		goto unlock;

		if (radio->stereo)
		amradio_set_stereo(radio, WANT_STEREO);
		else
		@@ -556,18 +401,22 @@ static int usb_amradio_resume(struct usb_interface *intf)
		if (!radio->muted)
		amradio_set_mute(radio, AMRADIO_START);

		unlock:
		mutex_unlock(&radio->lock);

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

		static const struct v4l2_ctrl_ops usb_amradio_ctrl_ops = {
		.s_ctrl = usb_amradio_s_ctrl,
		};

		/* File system interface */
		static const struct v4l2_file_operations usb_amradio_fops = {
		.owner = THIS_MODULE,
		.open = usb_amradio_open,
		.release = usb_amradio_close,
		.open = v4l2_fh_open,
		.release = v4l2_fh_release,
		.poll = v4l2_ctrl_poll,
		.unlocked_ioctl = video_ioctl2,
		};

		@@ -577,20 +426,18 @@ static const struct v4l2_ioctl_ops usb_amradio_ioctl_ops = {
		.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,
		.vidioc_log_status = v4l2_ctrl_log_status,
		.vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
		.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
		};

		static void usb_amradio_video_device_release(struct video_device *videodev)
		static void usb_amradio_release(struct v4l2_device *v4l2_dev)
		{
		struct amradio_device *radio = video_get_drvdata(videodev);
		struct amradio_device *radio = to_amradio_dev(v4l2_dev);

		/* free rest memory */
		v4l2_ctrl_handler_free(&radio->hdl);
		v4l2_device_unregister(&radio->v4l2_dev);
		kfree(radio->buffer);
		kfree(radio);
		}
		@@ -624,23 +471,38 @@ static int usb_amradio_probe(struct usb_interface *intf,
		goto err_v4l2;
		}

		v4l2_ctrl_handler_init(&radio->hdl, 1);
		v4l2_ctrl_new_std(&radio->hdl, &usb_amradio_ctrl_ops,
		V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
		if (radio->hdl.error) {
		retval = radio->hdl.error;
		dev_err(&intf->dev, "couldn't register control\n");
		goto err_ctrl;
		}
		mutex_init(&radio->lock);

		strlcpy(radio->videodev.name, radio->v4l2_dev.name,
		sizeof(radio->videodev.name));
		radio->videodev.v4l2_dev = &radio->v4l2_dev;
		radio->videodev.fops = &usb_amradio_fops;
		radio->videodev.ioctl_ops = &usb_amradio_ioctl_ops;
		radio->videodev.release = usb_amradio_video_device_release;
		radio->videodev.lock = &radio->lock;
		radio->v4l2_dev.ctrl_handler = &radio->hdl;
		radio->v4l2_dev.release = usb_amradio_release;
		strlcpy(radio->vdev.name, radio->v4l2_dev.name,
		sizeof(radio->vdev.name));
		radio->vdev.v4l2_dev = &radio->v4l2_dev;
		radio->vdev.fops = &usb_amradio_fops;
		radio->vdev.ioctl_ops = &usb_amradio_ioctl_ops;
		radio->vdev.release = video_device_release_empty;
		radio->vdev.lock = &radio->lock;
		set_bit(V4L2_FL_USE_FH_PRIO, &radio->vdev.flags);

		radio->usbdev = interface_to_usbdev(intf);
		radio->intf = intf;
		usb_set_intfdata(intf, &radio->v4l2_dev);
		radio->curfreq = 95.16 * FREQ_MUL;

		video_set_drvdata(&radio->videodev, radio);
		video_set_drvdata(&radio->vdev, radio);
		retval = usb_amradio_init(radio);
		if (retval)
		goto err_vdev;

		retval = video_register_device(&radio->videodev, VFL_TYPE_RADIO,
		retval = video_register_device(&radio->vdev, VFL_TYPE_RADIO,
		radio_nr);
		if (retval < 0) {
		dev_err(&intf->dev, "could not register video device\n");
		@@ -650,6 +512,8 @@ static int usb_amradio_probe(struct usb_interface *intf,
		return 0;

		err_vdev:
		v4l2_ctrl_handler_free(&radio->hdl);
		err_ctrl:
		v4l2_device_unregister(&radio->v4l2_dev);
		err_v4l2:
		kfree(radio->buffer);
		@@ -659,4 +523,24 @@ static int usb_amradio_probe(struct usb_interface *intf,
		return retval;
		}

		/* USB Device ID List */
		static struct usb_device_id usb_amradio_device_table[] = {
		{ USB_DEVICE_AND_INTERFACE_INFO(USB_AMRADIO_VENDOR, USB_AMRADIO_PRODUCT,
		USB_CLASS_HID, 0, 0) },
		{ } /* Terminating entry */
		};

		MODULE_DEVICE_TABLE(usb, usb_amradio_device_table);

		/* USB subsystem interface */
		static struct usb_driver usb_amradio_driver = {
		.name = MR800_DRIVER_NAME,
		.probe = usb_amradio_probe,
		.disconnect = usb_amradio_disconnect,
		.suspend = usb_amradio_suspend,
		.resume = usb_amradio_resume,
		.reset_resume = usb_amradio_resume,
		.id_table = usb_amradio_device_table,
		};

		module_usb_driver(usb_amradio_driver);