[media] radio-mr800: cleanup and have it comply to the V4L2 API

Implement the control framework and update to the latest V4L2 framework.
The v4l2-compliance tool now runs without errors.
Fixed bad g/s_tuner handling with respect to mono/stereo.
Support control events.

Signed-off-by: Hans Verkuil <hans.verkuil@cisco.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

1 files changed, 112 insertions, 228 deletions

diff --git a/drivers/media/radio/radio-mr800.c b/drivers/media/radio/radio-mr800.c
index a860a72a58ec..0a96edae6786 100644
--- a/drivers/media/radio/radio-mr800.c
+++ b/drivers/media/radio/radio-mr800.c
@@ -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;
-
-        radio->curfreq = freq;
-        goto out;
+        if (retval >= 0 && size == BUFFER_LENGTH) {
+                radio->curfreq = freq;
+                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 @@ err:
         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);