media: media/usb: set device_caps in struct video_device

Instead of filling in the struct v4l2_capability device_caps
field, fill in the struct video_device device_caps field.

That way the V4L2 core knows what the capabilities of the
video device are.

But this only really works if all drivers use this, so convert
all usb drivers in this patch.

Signed-off-by: Hans Verkuil <hverkuil-cisco@xs4all.nl>
Signed-off-by: Mauro Carvalho Chehab <mchehab+samsung@kernel.org>

diff --git a/drivers/media/usb/airspy/airspy.c b/drivers/media/usb/airspy/airspy.c
index 41fa0f93143d45c81eb3c70a4e028a4efc191cc4..6a3e8be956979670969f60fcf4ea522682ff82a5 100644 (file)
--- a/drivers/media/usb/airspy/airspy.c
+++ b/drivers/media/usb/airspy/airspy.c
@@ -622,10 +622,6 @@ static int airspy_querycap(struct file *file, void *fh,
        strscpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
        strscpy(cap->card, s->vdev.name, sizeof(cap->card));
        usb_make_path(s->udev, cap->bus_info, sizeof(cap->bus_info));
-       cap->device_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_STREAMING |
-                       V4L2_CAP_READWRITE | V4L2_CAP_TUNER;
-       cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
-
        return 0;
 }
 
@@ -1066,6 +1062,8 @@ static int airspy_probe(struct usb_interface *intf,
        s->v4l2_dev.ctrl_handler = &s->hdl;
        s->vdev.v4l2_dev = &s->v4l2_dev;
        s->vdev.lock = &s->v4l2_lock;
+       s->vdev.device_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_STREAMING |
+                             V4L2_CAP_READWRITE | V4L2_CAP_TUNER;
 
        ret = video_register_device(&s->vdev, VFL_TYPE_SDR, -1);
        if (ret) {

diff --git a/drivers/media/usb/au0828/au0828-video.c b/drivers/media/usb/au0828/au0828-video.c
index 4bde3db83aa22e6044ca3e8b242a506caa10c5fe..981ee08fb05f0af2d74268451f8b70922d2ba0b6 100644 (file)
--- a/drivers/media/usb/au0828/au0828-video.c
+++ b/drivers/media/usb/au0828/au0828-video.c
@@ -1191,7 +1191,6 @@ static int au0828_set_format(struct au0828_dev *dev, unsigned int cmd,
 static int vidioc_querycap(struct file *file, void  *priv,
                           struct v4l2_capability *cap)
 {
-       struct video_device *vdev = video_devdata(file);
        struct au0828_dev *dev = video_drvdata(file);
 
        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
@@ -1202,16 +1201,10 @@ static int vidioc_querycap(struct file *file, void  *priv,
        usb_make_path(dev->usbdev, cap->bus_info, sizeof(cap->bus_info));
 
        /* set the device capabilities */
-       cap->device_caps = V4L2_CAP_AUDIO |
-               V4L2_CAP_READWRITE |
-               V4L2_CAP_STREAMING |
-               V4L2_CAP_TUNER;
-       if (vdev->vfl_type == VFL_TYPE_GRABBER)
-               cap->device_caps |= V4L2_CAP_VIDEO_CAPTURE;
-       else
-               cap->device_caps |= V4L2_CAP_VBI_CAPTURE;
-       cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
-               V4L2_CAP_VBI_CAPTURE | V4L2_CAP_VIDEO_CAPTURE;
+       cap->capabilities =
+               V4L2_CAP_AUDIO | V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
+               V4L2_CAP_TUNER | V4L2_CAP_VBI_CAPTURE | V4L2_CAP_VIDEO_CAPTURE |
+               V4L2_CAP_DEVICE_CAPS;
        return 0;
 }
 
@@ -2000,6 +1993,9 @@ int au0828_analog_register(struct au0828_dev *dev,
        dev->vdev.lock = &dev->lock;
        dev->vdev.queue = &dev->vb_vidq;
        dev->vdev.queue->lock = &dev->vb_queue_lock;
+       dev->vdev.device_caps =
+               V4L2_CAP_AUDIO | V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
+               V4L2_CAP_TUNER | V4L2_CAP_VIDEO_CAPTURE;
        strscpy(dev->vdev.name, "au0828a video", sizeof(dev->vdev.name));
 
        /* Setup the VBI device */
@@ -2008,6 +2004,9 @@ int au0828_analog_register(struct au0828_dev *dev,
        dev->vbi_dev.lock = &dev->lock;
        dev->vbi_dev.queue = &dev->vb_vbiq;
        dev->vbi_dev.queue->lock = &dev->vb_vbi_queue_lock;
+       dev->vbi_dev.device_caps =
+               V4L2_CAP_AUDIO | V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
+               V4L2_CAP_TUNER | V4L2_CAP_VBI_CAPTURE;
        strscpy(dev->vbi_dev.name, "au0828a vbi", sizeof(dev->vbi_dev.name));
 
        /* Init entities at the Media Controller */

diff --git a/drivers/media/usb/cpia2/cpia2_v4l.c b/drivers/media/usb/cpia2/cpia2_v4l.c
index 45caf78119c4f234248e4709f32d70f7628b49cc..d3533e9f32a3bedca90c4e45291c67bf55336ef8 100644 (file)
--- a/drivers/media/usb/cpia2/cpia2_v4l.c
+++ b/drivers/media/usb/cpia2/cpia2_v4l.c
@@ -259,13 +259,6 @@ static int cpia2_querycap(struct file *file, void *fh, struct v4l2_capability *v
 
        if (usb_make_path(cam->dev, vc->bus_info, sizeof(vc->bus_info)) <0)
                memset(vc->bus_info,0, sizeof(vc->bus_info));
-
-       vc->device_caps = V4L2_CAP_VIDEO_CAPTURE |
-                          V4L2_CAP_READWRITE |
-                          V4L2_CAP_STREAMING;
-       vc->capabilities = vc->device_caps |
-                          V4L2_CAP_DEVICE_CAPS;
-
        return 0;
 }
 
@@ -1161,6 +1154,8 @@ int cpia2_register_camera(struct camera_data *cam)
        cam->vdev.lock = &cam->v4l2_lock;
        cam->vdev.ctrl_handler = hdl;
        cam->vdev.v4l2_dev = &cam->v4l2_dev;
+       cam->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
+                               V4L2_CAP_STREAMING;
 
        reset_camera_struct_v4l(cam);
 

diff --git a/drivers/media/usb/cx231xx/cx231xx-video.c b/drivers/media/usb/cx231xx/cx231xx-video.c
index f8820478d46b8c90434e6ccf525bedac8ede5bd7..b651ac7713ea88b2d5f8d0dd969499af50b3ba54 100644 (file)
--- a/drivers/media/usb/cx231xx/cx231xx-video.c
+++ b/drivers/media/usb/cx231xx/cx231xx-video.c
@@ -1555,30 +1555,19 @@ static int vidioc_streamoff(struct file *file, void *priv,
 int cx231xx_querycap(struct file *file, void *priv,
                           struct v4l2_capability *cap)
 {
-       struct video_device *vdev = video_devdata(file);
        struct cx231xx_fh *fh = priv;
        struct cx231xx *dev = fh->dev;
 
        strscpy(cap->driver, "cx231xx", sizeof(cap->driver));
        strscpy(cap->card, cx231xx_boards[dev->model].name, sizeof(cap->card));
        usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
-
-       if (vdev->vfl_type == VFL_TYPE_RADIO)
-               cap->device_caps = V4L2_CAP_RADIO;
-       else {
-               cap->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
-               if (vdev->vfl_type == VFL_TYPE_VBI)
-                       cap->device_caps |= V4L2_CAP_VBI_CAPTURE;
-               else
-                       cap->device_caps |= V4L2_CAP_VIDEO_CAPTURE;
-       }
-       if (dev->tuner_type != TUNER_ABSENT)
-               cap->device_caps |= V4L2_CAP_TUNER;
-       cap->capabilities = cap->device_caps | V4L2_CAP_READWRITE |
+       cap->capabilities = V4L2_CAP_READWRITE |
                V4L2_CAP_VBI_CAPTURE | V4L2_CAP_VIDEO_CAPTURE |
                V4L2_CAP_STREAMING | V4L2_CAP_DEVICE_CAPS;
        if (video_is_registered(&dev->radio_dev))
                cap->capabilities |= V4L2_CAP_RADIO;
+       if (dev->tuner_type != TUNER_ABSENT)
+               cap->capabilities |= V4L2_CAP_TUNER;
 
        return 0;
 }
@@ -2234,6 +2223,11 @@ int cx231xx_register_analog_devices(struct cx231xx *dev)
                dev_err(dev->dev, "failed to initialize video media entity!\n");
 #endif
        dev->vdev.ctrl_handler = &dev->ctrl_handler;
+       dev->vdev.device_caps = V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
+                               V4L2_CAP_VIDEO_CAPTURE;
+       if (dev->tuner_type != TUNER_ABSENT)
+               dev->vdev.device_caps |= V4L2_CAP_TUNER;
+
        /* register v4l2 video video_device */
        ret = video_register_device(&dev->vdev, VFL_TYPE_GRABBER,
                                    video_nr[dev->devno]);
@@ -2262,6 +2256,11 @@ int cx231xx_register_analog_devices(struct cx231xx *dev)
                dev_err(dev->dev, "failed to initialize vbi media entity!\n");
 #endif
        dev->vbi_dev.ctrl_handler = &dev->ctrl_handler;
+       dev->vbi_dev.device_caps = V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
+                                  V4L2_CAP_VBI_CAPTURE;
+       if (dev->tuner_type != TUNER_ABSENT)
+               dev->vbi_dev.device_caps |= V4L2_CAP_TUNER;
+
        /* register v4l2 vbi video_device */
        ret = video_register_device(&dev->vbi_dev, VFL_TYPE_VBI,
                                    vbi_nr[dev->devno]);
@@ -2277,6 +2276,7 @@ int cx231xx_register_analog_devices(struct cx231xx *dev)
                cx231xx_vdev_init(dev, &dev->radio_dev,
                                &cx231xx_radio_template, "radio");
                dev->radio_dev.ctrl_handler = &dev->radio_ctrl_handler;
+               dev->radio_dev.device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER;
                ret = video_register_device(&dev->radio_dev, VFL_TYPE_RADIO,
                                            radio_nr[dev->devno]);
                if (ret < 0) {

diff --git a/drivers/media/usb/em28xx/em28xx-video.c b/drivers/media/usb/em28xx/em28xx-video.c
index f43717ea831db9cb20c2511f588d942cd66d7b2d..0512e19593945d04c2cc949a35ba6ca742e6ff87 100644 (file)
--- a/drivers/media/usb/em28xx/em28xx-video.c
+++ b/drivers/media/usb/em28xx/em28xx-video.c
@@ -1984,7 +1984,6 @@ static int vidioc_s_register(struct file *file, void *priv,
 static int vidioc_querycap(struct file *file, void  *priv,
                           struct v4l2_capability *cap)
 {
-       struct video_device   *vdev = video_devdata(file);
        struct em28xx         *dev  = video_drvdata(file);
        struct em28xx_v4l2    *v4l2 = dev->v4l2;
        struct usb_device *udev = interface_to_usbdev(dev->intf);
@@ -1993,23 +1992,12 @@ static int vidioc_querycap(struct file *file, void  *priv,
        strscpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
        usb_make_path(udev, cap->bus_info, sizeof(cap->bus_info));
 
-       if (vdev->vfl_type == VFL_TYPE_GRABBER)
-               cap->device_caps = V4L2_CAP_READWRITE |
-                       V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
-       else if (vdev->vfl_type == VFL_TYPE_RADIO)
-               cap->device_caps = V4L2_CAP_RADIO;
-       else
-               cap->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE;
-
+       cap->capabilities = V4L2_CAP_DEVICE_CAPS | V4L2_CAP_READWRITE |
+                           V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
        if (dev->int_audio_type != EM28XX_INT_AUDIO_NONE)
-               cap->device_caps |= V4L2_CAP_AUDIO;
-
+               cap->capabilities |= V4L2_CAP_AUDIO;
        if (dev->tuner_type != TUNER_ABSENT)
-               cap->device_caps |= V4L2_CAP_TUNER;
-
-       cap->capabilities = cap->device_caps |
-                           V4L2_CAP_DEVICE_CAPS | V4L2_CAP_READWRITE |
-                           V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
+               cap->capabilities |= V4L2_CAP_TUNER;
        if (video_is_registered(&v4l2->vbi_dev))
                cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
        if (video_is_registered(&v4l2->radio_dev))
@@ -2782,6 +2770,13 @@ static int em28xx_v4l2_init(struct em28xx *dev)
        mutex_init(&v4l2->vb_vbi_queue_lock);
        v4l2->vdev.queue = &v4l2->vb_vidq;
        v4l2->vdev.queue->lock = &v4l2->vb_queue_lock;
+       v4l2->vdev.device_caps = V4L2_CAP_READWRITE | V4L2_CAP_VIDEO_CAPTURE |
+                                V4L2_CAP_STREAMING;
+       if (dev->int_audio_type != EM28XX_INT_AUDIO_NONE)
+               v4l2->vdev.device_caps |= V4L2_CAP_AUDIO;
+       if (dev->tuner_type != TUNER_ABSENT)
+               v4l2->vdev.device_caps |= V4L2_CAP_TUNER;
+
 
        /* disable inapplicable ioctls */
        if (dev->is_webcam) {
@@ -2818,6 +2813,10 @@ static int em28xx_v4l2_init(struct em28xx *dev)
 
                v4l2->vbi_dev.queue = &v4l2->vb_vbiq;
                v4l2->vbi_dev.queue->lock = &v4l2->vb_vbi_queue_lock;
+               v4l2->vbi_dev.device_caps = V4L2_CAP_STREAMING |
+                       V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE;
+               if (dev->tuner_type != TUNER_ABSENT)
+                       v4l2->vbi_dev.device_caps |= V4L2_CAP_TUNER;
 
                /* disable inapplicable ioctls */
                v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_PARM);
@@ -2845,6 +2844,7 @@ static int em28xx_v4l2_init(struct em28xx *dev)
        if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) {
                em28xx_vdev_init(dev, &v4l2->radio_dev, &em28xx_radio_template,
                                 "radio");
+               v4l2->radio_dev.device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER;
                ret = video_register_device(&v4l2->radio_dev, VFL_TYPE_RADIO,
                                            radio_nr[dev->devno]);
                if (ret < 0) {

diff --git a/drivers/media/usb/go7007/go7007-v4l2.c b/drivers/media/usb/go7007/go7007-v4l2.c
index bebdfcecf60020df31603f3ec85159e35bce2e60..ffbbd393bc7e2ab3ab67cd8d7a41f1ae7554339e 100644 (file)
--- a/drivers/media/usb/go7007/go7007-v4l2.c
+++ b/drivers/media/usb/go7007/go7007-v4l2.c
@@ -287,15 +287,6 @@ static int vidioc_querycap(struct file *file, void  *priv,
        strscpy(cap->driver, "go7007", sizeof(cap->driver));
        strscpy(cap->card, go->name, sizeof(cap->card));
        strscpy(cap->bus_info, go->bus_info, sizeof(cap->bus_info));
-
-       cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
-                               V4L2_CAP_STREAMING;
-
-       if (go->board_info->num_aud_inputs)
-               cap->device_caps |= V4L2_CAP_AUDIO;
-       if (go->board_info->flags & GO7007_BOARD_HAS_TUNER)
-               cap->device_caps |= V4L2_CAP_TUNER;
-       cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
        return 0;
 }
 
@@ -1122,6 +1113,12 @@ int go7007_v4l2_init(struct go7007 *go)
        *vdev = go7007_template;
        vdev->lock = &go->serialize_lock;
        vdev->queue = &go->vidq;
+       vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
+                           V4L2_CAP_STREAMING;
+       if (go->board_info->num_aud_inputs)
+               vdev->device_caps |= V4L2_CAP_AUDIO;
+       if (go->board_info->flags & GO7007_BOARD_HAS_TUNER)
+               vdev->device_caps |= V4L2_CAP_TUNER;
        video_set_drvdata(vdev, go);
        vdev->v4l2_dev = &go->v4l2_dev;
        if (!v4l2_device_has_op(&go->v4l2_dev, 0, video, querystd))

diff --git a/drivers/media/usb/gspca/gspca.c b/drivers/media/usb/gspca/gspca.c
index 4d7517411cc2d6c769b8a6773528555fee14428c..d389020b50f97c72b5a6adbb7e5be30991bfba8e 100644 (file)
--- a/drivers/media/usb/gspca/gspca.c
+++ b/drivers/media/usb/gspca/gspca.c
@@ -1218,10 +1218,6 @@ static int vidioc_querycap(struct file *file, void  *priv,
        }
        usb_make_path(gspca_dev->dev, (char *) cap->bus_info,
                        sizeof(cap->bus_info));
-       cap->device_caps = V4L2_CAP_VIDEO_CAPTURE
-                         | V4L2_CAP_STREAMING
-                         | V4L2_CAP_READWRITE;
-       cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
        return 0;
 }
 
@@ -1517,6 +1513,8 @@ int gspca_dev_probe2(struct usb_interface *intf,
        gspca_dev->empty_packet = -1;   /* don't check the empty packets */
        gspca_dev->vdev = gspca_template;
        gspca_dev->vdev.v4l2_dev = &gspca_dev->v4l2_dev;
+       gspca_dev->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE |
+                                     V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
        video_set_drvdata(&gspca_dev->vdev, gspca_dev);
        gspca_dev->module = module;
 

diff --git a/drivers/media/usb/hackrf/hackrf.c b/drivers/media/usb/hackrf/hackrf.c
index d437852066224c4ca7936aa0610333f98f1b0720..d625263f4984f4f2e57a9e213ec9fc0844dc5839 100644 (file)
--- a/drivers/media/usb/hackrf/hackrf.c
+++ b/drivers/media/usb/hackrf/hackrf.c
@@ -905,19 +905,13 @@ static int hackrf_querycap(struct file *file, void *fh,
 {
        struct hackrf_dev *dev = video_drvdata(file);
        struct usb_interface *intf = dev->intf;
-       struct video_device *vdev = video_devdata(file);
 
        dev_dbg(&intf->dev, "\n");
 
-       cap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
-       if (vdev->vfl_dir == VFL_DIR_RX)
-               cap->device_caps |= V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER;
-       else
-               cap->device_caps |= V4L2_CAP_SDR_OUTPUT | V4L2_CAP_MODULATOR;
-
        cap->capabilities = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER |
                            V4L2_CAP_SDR_OUTPUT | V4L2_CAP_MODULATOR |
-                           V4L2_CAP_DEVICE_CAPS | cap->device_caps;
+                           V4L2_CAP_STREAMING | V4L2_CAP_READWRITE |
+                           V4L2_CAP_DEVICE_CAPS;
        strscpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
        strscpy(cap->card, dev->rx_vdev.name, sizeof(cap->card));
        usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
@@ -1496,6 +1490,8 @@ static int hackrf_probe(struct usb_interface *intf,
        dev->rx_vdev.ctrl_handler = &dev->rx_ctrl_handler;
        dev->rx_vdev.lock = &dev->v4l2_lock;
        dev->rx_vdev.vfl_dir = VFL_DIR_RX;
+       dev->rx_vdev.device_caps = V4L2_CAP_STREAMING | V4L2_CAP_READWRITE |
+                                  V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER;
        video_set_drvdata(&dev->rx_vdev, dev);
        ret = video_register_device(&dev->rx_vdev, VFL_TYPE_SDR, -1);
        if (ret) {
@@ -1514,6 +1510,8 @@ static int hackrf_probe(struct usb_interface *intf,
        dev->tx_vdev.ctrl_handler = &dev->tx_ctrl_handler;
        dev->tx_vdev.lock = &dev->v4l2_lock;
        dev->tx_vdev.vfl_dir = VFL_DIR_TX;
+       dev->tx_vdev.device_caps = V4L2_CAP_STREAMING | V4L2_CAP_READWRITE |
+                                  V4L2_CAP_SDR_OUTPUT | V4L2_CAP_MODULATOR;
        video_set_drvdata(&dev->tx_vdev, dev);
        ret = video_register_device(&dev->tx_vdev, VFL_TYPE_SDR, -1);
        if (ret) {

diff --git a/drivers/media/usb/hdpvr/hdpvr-video.c b/drivers/media/usb/hdpvr/hdpvr-video.c
index 3804aa3fb50fed559df13e19e903fada715b87a6..a675506e8939bfc2f2303f100b581a146c427ad8 100644 (file)
--- a/drivers/media/usb/hdpvr/hdpvr-video.c
+++ b/drivers/media/usb/hdpvr/hdpvr-video.c
@@ -581,9 +581,6 @@ static int vidioc_querycap(struct file *file, void  *priv,
        strscpy(cap->driver, "hdpvr", sizeof(cap->driver));
        strscpy(cap->card, "Hauppauge HD PVR", sizeof(cap->card));
        usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
-       cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_AUDIO |
-                           V4L2_CAP_READWRITE;
-       cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
        return 0;
 }
 
@@ -1154,6 +1151,8 @@ static const struct video_device hdpvr_video_template = {
        .release                = hdpvr_device_release,
        .ioctl_ops              = &hdpvr_ioctl_ops,
        .tvnorms                = V4L2_STD_ALL,
+       .device_caps            = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_AUDIO |
+                                 V4L2_CAP_READWRITE,
 };
 
 static const struct v4l2_ctrl_ops hdpvr_ctrl_ops = {

diff --git a/drivers/media/usb/msi2500/msi2500.c b/drivers/media/usb/msi2500/msi2500.c
index 10b5b95bee34d22dd0c516e9aba219257c6f2daf..384d9bbd6495c853bd8c85631d6e05e670da7d8c 100644 (file)
--- a/drivers/media/usb/msi2500/msi2500.c
+++ b/drivers/media/usb/msi2500/msi2500.c
@@ -607,9 +607,6 @@ static int msi2500_querycap(struct file *file, void *fh,
        strscpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
        strscpy(cap->card, dev->vdev.name, sizeof(cap->card));
        usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
-       cap->device_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_STREAMING |
-                       V4L2_CAP_READWRITE | V4L2_CAP_TUNER;
-       cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
        return 0;
 }
 
@@ -1283,6 +1280,8 @@ static int msi2500_probe(struct usb_interface *intf,
        dev->v4l2_dev.ctrl_handler = &dev->hdl;
        dev->vdev.v4l2_dev = &dev->v4l2_dev;
        dev->vdev.lock = &dev->v4l2_lock;
+       dev->vdev.device_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_STREAMING |
+                               V4L2_CAP_READWRITE | V4L2_CAP_TUNER;
 
        ret = video_register_device(&dev->vdev, VFL_TYPE_SDR, -1);
        if (ret) {

diff --git a/drivers/media/usb/pvrusb2/pvrusb2-v4l2.c b/drivers/media/usb/pvrusb2/pvrusb2-v4l2.c
index cb6668580d772644446c1150a60a93e8158bf04e..30701ecc84c5b4bcdde7e8c91bc0f88234a0b14f 100644 (file)
--- a/drivers/media/usb/pvrusb2/pvrusb2-v4l2.c
+++ b/drivers/media/usb/pvrusb2/pvrusb2-v4l2.c
@@ -128,17 +128,6 @@ static int pvr2_querycap(struct file *file, void *priv, struct v4l2_capability *
        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
                            V4L2_CAP_AUDIO | V4L2_CAP_RADIO |
                            V4L2_CAP_READWRITE | V4L2_CAP_DEVICE_CAPS;
-       switch (fh->pdi->devbase.vfl_type) {
-       case VFL_TYPE_GRABBER:
-               cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_AUDIO;
-               break;
-       case VFL_TYPE_RADIO:
-               cap->device_caps = V4L2_CAP_RADIO;
-               break;
-       default:
-               return -EINVAL;
-       }
-       cap->device_caps |= V4L2_CAP_TUNER | V4L2_CAP_READWRITE;
        return 0;
 }
 
@@ -1205,6 +1194,8 @@ static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
        int unit_number;
        struct pvr2_hdw *hdw;
        int *nr_ptr = NULL;
+       u32 caps = V4L2_CAP_TUNER | V4L2_CAP_READWRITE;
+
        dip->v4lp = vp;
 
        hdw = vp->channel.mc_head->hdw;
@@ -1215,6 +1206,7 @@ static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
                dip->config = pvr2_config_mpeg;
                dip->minor_type = pvr2_v4l_type_video;
                nr_ptr = video_nr;
+               caps |= V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_AUDIO;
                if (!dip->stream) {
                        pr_err(KBUILD_MODNAME
                                ": Failed to set up pvrusb2 v4l video dev due to missing stream instance\n");
@@ -1225,12 +1217,14 @@ static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
                dip->config = pvr2_config_vbi;
                dip->minor_type = pvr2_v4l_type_vbi;
                nr_ptr = vbi_nr;
+               caps |= V4L2_CAP_VBI_CAPTURE;
                break;
        case VFL_TYPE_RADIO:
                dip->stream = &vp->channel.mc_head->video_stream;
                dip->config = pvr2_config_mpeg;
                dip->minor_type = pvr2_v4l_type_radio;
                nr_ptr = radio_nr;
+               caps |= V4L2_CAP_RADIO;
                break;
        default:
                /* Bail out (this should be impossible) */
@@ -1241,6 +1235,7 @@ static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
        dip->devbase = vdev_template;
        dip->devbase.release = pvr2_video_device_release;
        dip->devbase.ioctl_ops = &pvr2_ioctl_ops;
+       dip->devbase.device_caps = caps;
        {
                int val;
                pvr2_ctrl_get_value(

diff --git a/drivers/media/usb/pwc/pwc-if.c b/drivers/media/usb/pwc/pwc-if.c
index 4e94197094ad1b39a2fa7f55c60d33d8b88957a9..a1bd1cb5924b41c808dc2976a511a7411fd36255 100644 (file)
--- a/drivers/media/usb/pwc/pwc-if.c
+++ b/drivers/media/usb/pwc/pwc-if.c
@@ -1125,6 +1125,8 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
        pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
        pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
        pdev->vdev.lock = &pdev->v4l2_lock;
+       pdev->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
+                                V4L2_CAP_READWRITE;
 
        rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, -1);
        if (rc < 0) {

diff --git a/drivers/media/usb/pwc/pwc-v4l.c b/drivers/media/usb/pwc/pwc-v4l.c
index bef6e4ef8a7e14812f064d566e37e9af497fc14c..85efb433c00472a13be22524b878b5c7dd3a2cb2 100644 (file)
--- a/drivers/media/usb/pwc/pwc-v4l.c
+++ b/drivers/media/usb/pwc/pwc-v4l.c
@@ -495,9 +495,6 @@ static int pwc_querycap(struct file *file, void *fh, struct v4l2_capability *cap
        strscpy(cap->driver, PWC_NAME, sizeof(cap->driver));
        strscpy(cap->card, pdev->vdev.name, sizeof(cap->card));
        usb_make_path(pdev->udev, cap->bus_info, sizeof(cap->bus_info));
-       cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
-                                       V4L2_CAP_READWRITE;
-       cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
        return 0;
 }
 

diff --git a/drivers/media/usb/s2255/s2255drv.c b/drivers/media/usb/s2255/s2255drv.c
index 5b3e54b76e9a522b2b69f3d55612b04c120426d9..15c1cf18266ab213ba5410956abaf432865b881d 100644 (file)
--- a/drivers/media/usb/s2255/s2255drv.c
+++ b/drivers/media/usb/s2255/s2255drv.c
@@ -733,9 +733,6 @@ static int vidioc_querycap(struct file *file, void *priv,
        strscpy(cap->driver, "s2255", sizeof(cap->driver));
        strscpy(cap->card, "s2255", sizeof(cap->card));
        usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
-       cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
-               V4L2_CAP_READWRITE;
-       cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
        return 0;
 }
 
@@ -1666,6 +1663,8 @@ static int s2255_probe_v4l(struct s2255_dev *dev)
                vc->vdev.ctrl_handler = &vc->hdl;
                vc->vdev.lock = &dev->lock;
                vc->vdev.v4l2_dev = &dev->v4l2_dev;
+               vc->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE |
+                                      V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
                video_set_drvdata(&vc->vdev, vc);
                if (video_nr == -1)
                        ret = video_register_device(&vc->vdev,

diff --git a/drivers/media/usb/stk1160/stk1160-v4l.c b/drivers/media/usb/stk1160/stk1160-v4l.c
index 701ed3d4afe64a493dc225198dff2164bd365a3f..166e867b20017f88dcac7e9a460d5655e39ee855 100644 (file)
--- a/drivers/media/usb/stk1160/stk1160-v4l.c
+++ b/drivers/media/usb/stk1160/stk1160-v4l.c
@@ -347,11 +347,6 @@ static int vidioc_querycap(struct file *file,
        strscpy(cap->driver, "stk1160", sizeof(cap->driver));
        strscpy(cap->card, "stk1160", sizeof(cap->card));
        usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
-       cap->device_caps =
-               V4L2_CAP_VIDEO_CAPTURE |
-               V4L2_CAP_STREAMING |
-               V4L2_CAP_READWRITE;
-       cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
        return 0;
 }
 
@@ -831,6 +826,8 @@ int stk1160_video_register(struct stk1160 *dev)
 
        /* This will be used to set video_device parent */
        dev->vdev.v4l2_dev = &dev->v4l2_dev;
+       dev->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
+                               V4L2_CAP_READWRITE;
 
        /* NTSC is default */
        dev->norm = V4L2_STD_NTSC_M;

diff --git a/drivers/media/usb/stkwebcam/stk-webcam.c b/drivers/media/usb/stkwebcam/stk-webcam.c
index cb7d6454bbe16fd2f72080f44d30791ebb78331a..be8041e3e6b86a2cff46e9bf8711ee43130c6448 100644 (file)
--- a/drivers/media/usb/stkwebcam/stk-webcam.c
+++ b/drivers/media/usb/stkwebcam/stk-webcam.c
@@ -798,10 +798,6 @@ static int stk_vidioc_querycap(struct file *filp,
        strscpy(cap->driver, "stk", sizeof(cap->driver));
        strscpy(cap->card, "stk", sizeof(cap->card));
        usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
-
-       cap->device_caps = V4L2_CAP_VIDEO_CAPTURE
-               | V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
-       cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
        return 0;
 }
 
@@ -1261,6 +1257,8 @@ static int stk_register_video_device(struct stk_camera *dev)
        dev->vdev = stk_v4l_data;
        dev->vdev.lock = &dev->lock;
        dev->vdev.v4l2_dev = &dev->v4l2_dev;
+       dev->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
+                               V4L2_CAP_STREAMING;
        video_set_drvdata(&dev->vdev, dev);
        err = video_register_device(&dev->vdev, VFL_TYPE_GRABBER, -1);
        if (err)

diff --git a/drivers/media/usb/tm6000/tm6000-video.c b/drivers/media/usb/tm6000/tm6000-video.c
index 072210f5f92f3b35fd3684a598939879f3ec77a4..85fcddfb02023efbf1f0298cd66615fb7fcb763a 100644 (file)
--- a/drivers/media/usb/tm6000/tm6000-video.c
+++ b/drivers/media/usb/tm6000/tm6000-video.c
@@ -854,22 +854,17 @@ static int vidioc_querycap(struct file *file, void  *priv,
                                        struct v4l2_capability *cap)
 {
        struct tm6000_core *dev = ((struct tm6000_fh *)priv)->dev;
-       struct video_device *vdev = video_devdata(file);
 
        strscpy(cap->driver, "tm6000", sizeof(cap->driver));
        strscpy(cap->card, "Trident TVMaster TM5600/6000/6010",
                sizeof(cap->card));
        usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
+       cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
+                           V4L2_CAP_DEVICE_CAPS;
        if (dev->tuner_type != TUNER_ABSENT)
-               cap->device_caps |= V4L2_CAP_TUNER;
-       if (vdev->vfl_type == VFL_TYPE_GRABBER)
-               cap->device_caps |= V4L2_CAP_VIDEO_CAPTURE |
-                               V4L2_CAP_STREAMING |
-                               V4L2_CAP_READWRITE;
-       else
-               cap->device_caps |= V4L2_CAP_RADIO;
-       cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
-               V4L2_CAP_RADIO | V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE;
+               cap->capabilities |= V4L2_CAP_TUNER;
+       if (dev->caps.has_radio)
+               cap->capabilities |= V4L2_CAP_RADIO;
 
        return 0;
 }
@@ -1639,6 +1634,10 @@ int tm6000_v4l2_register(struct tm6000_core *dev)
        vdev_init(dev, &dev->vfd, &tm6000_template, "video");
 
        dev->vfd.ctrl_handler = &dev->ctrl_handler;
+       dev->vfd.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
+                              V4L2_CAP_READWRITE;
+       if (dev->tuner_type != TUNER_ABSENT)
+               dev->vfd.device_caps |= V4L2_CAP_TUNER;
 
        /* init video dma queues */
        INIT_LIST_HEAD(&dev->vidq.active);
@@ -1659,6 +1658,7 @@ int tm6000_v4l2_register(struct tm6000_core *dev)
                vdev_init(dev, &dev->radio_dev, &tm6000_radio_template,
                                                           "radio");
                dev->radio_dev.ctrl_handler = &dev->radio_ctrl_handler;
+               dev->radio_dev.device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER;
                ret = video_register_device(&dev->radio_dev, VFL_TYPE_RADIO,
                                            radio_nr);
                if (ret < 0) {

diff --git a/drivers/media/usb/usbtv/usbtv-video.c b/drivers/media/usb/usbtv/usbtv-video.c
index 4a1eab711bdc632da2a3ea80ad5c2a5384cadd93..51f784479e91a07bbdf3aba4fb945f1194e26c6f 100644 (file)
--- a/drivers/media/usb/usbtv/usbtv-video.c
+++ b/drivers/media/usb/usbtv/usbtv-video.c
@@ -603,9 +603,6 @@ static int usbtv_querycap(struct file *file, void *priv,
        strscpy(cap->driver, "usbtv", sizeof(cap->driver));
        strscpy(cap->card, "usbtv", sizeof(cap->card));
        usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
-       cap->device_caps = V4L2_CAP_VIDEO_CAPTURE;
-       cap->device_caps |= V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
-       cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
        return 0;
 }
 
@@ -942,6 +939,8 @@ int usbtv_video_init(struct usbtv *usbtv)
        usbtv->vdev.tvnorms = USBTV_TV_STD;
        usbtv->vdev.queue = &usbtv->vb2q;
        usbtv->vdev.lock = &usbtv->v4l2_lock;
+       usbtv->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
+                                 V4L2_CAP_STREAMING;
        video_set_drvdata(&usbtv->vdev, usbtv);
        ret = video_register_device(&usbtv->vdev, VFL_TYPE_GRABBER, -1);
        if (ret < 0) {

diff --git a/drivers/media/usb/usbvision/usbvision-video.c b/drivers/media/usb/usbvision/usbvision-video.c
index e611052ebf590ee788830139f1aa30f5942e17f6..bd216c9ff3d1ac4c34cca20efab921e0c648d3a4 100644 (file)
--- a/drivers/media/usb/usbvision/usbvision-video.c
+++ b/drivers/media/usb/usbvision/usbvision-video.c
@@ -465,24 +465,18 @@ static int vidioc_querycap(struct file *file, void  *priv,
                                        struct v4l2_capability *vc)
 {
        struct usb_usbvision *usbvision = video_drvdata(file);
-       struct video_device *vdev = video_devdata(file);
 
        strscpy(vc->driver, "USBVision", sizeof(vc->driver));
        strscpy(vc->card,
                usbvision_device_data[usbvision->dev_model].model_string,
                sizeof(vc->card));
        usb_make_path(usbvision->dev, vc->bus_info, sizeof(vc->bus_info));
-       vc->device_caps = usbvision->have_tuner ? V4L2_CAP_TUNER : 0;
-       if (vdev->vfl_type == VFL_TYPE_GRABBER)
-               vc->device_caps |= V4L2_CAP_VIDEO_CAPTURE |
-                       V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
-       else
-               vc->device_caps |= V4L2_CAP_RADIO;
-
-       vc->capabilities = vc->device_caps | V4L2_CAP_VIDEO_CAPTURE |
-               V4L2_CAP_READWRITE | V4L2_CAP_STREAMING | V4L2_CAP_DEVICE_CAPS;
+       vc->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
+                          V4L2_CAP_STREAMING | V4L2_CAP_DEVICE_CAPS;
        if (usbvision_device_data[usbvision->dev_model].radio)
                vc->capabilities |= V4L2_CAP_RADIO;
+       if (usbvision->have_tuner)
+               vc->capabilities |= V4L2_CAP_TUNER;
        return 0;
 }
 
@@ -1280,6 +1274,11 @@ static int usbvision_register_video(struct usb_usbvision *usbvision)
                v4l2_disable_ioctl(&usbvision->vdev, VIDIOC_G_FREQUENCY);
                v4l2_disable_ioctl(&usbvision->vdev, VIDIOC_S_TUNER);
        }
+       usbvision->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE |
+                                     V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
+       if (usbvision->have_tuner)
+               usbvision->vdev.device_caps |= V4L2_CAP_TUNER;
+
        if (video_register_device(&usbvision->vdev, VFL_TYPE_GRABBER, video_nr) < 0)
                goto err_exit;
        printk(KERN_INFO "USBVision[%d]: registered USBVision Video device %s [v4l2]\n",
@@ -1290,6 +1289,7 @@ static int usbvision_register_video(struct usb_usbvision *usbvision)
                /* usbvision has radio */
                usbvision_vdev_init(usbvision, &usbvision->rdev,
                              &usbvision_radio_template, "USBVision Radio");
+               usbvision->rdev.device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER;
                if (video_register_device(&usbvision->rdev, VFL_TYPE_RADIO, radio_nr) < 0)
                        goto err_exit;
                printk(KERN_INFO "USBVision[%d]: registered USBVision Radio device %s [v4l2]\n",

diff --git a/drivers/media/usb/zr364xx/zr364xx.c b/drivers/media/usb/zr364xx/zr364xx.c
index cd2bc9ed0cd9a64d8ca9c051bd490724fcef7a32..87c5663e28bba3d35178a93f8a80d9df670e6949 100644 (file)
--- a/drivers/media/usb/zr364xx/zr364xx.c
+++ b/drivers/media/usb/zr364xx/zr364xx.c
@@ -707,11 +707,6 @@ static int zr364xx_vidioc_querycap(struct file *file, void *priv,
                strscpy(cap->card, cam->udev->product, sizeof(cap->card));
        strscpy(cap->bus_info, dev_name(&cam->udev->dev),
                sizeof(cap->bus_info));
-       cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
-                           V4L2_CAP_READWRITE |
-                           V4L2_CAP_STREAMING;
-       cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
-
        return 0;
 }
 
@@ -1338,6 +1333,8 @@ static const struct video_device zr364xx_template = {
        .fops = &zr364xx_fops,
        .ioctl_ops = &zr364xx_ioctl_ops,
        .release = video_device_release_empty,
+       .device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
+                      V4L2_CAP_STREAMING,
 };