redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

[media] em28xx: move video_device structs from struct em28xx to struct v4l2 

There are 3 struct video_device at the em28xx common struct,
for video, VBI and radio. They all are used only by the V4L2 driver.
So, move them to the v4l2-specific struct.

Signed-off-by: Frank Schäfer <fschaefer.oss@googlemail.com>
Signed-off-by: Hans Verkuil <hans.verkuil@cisco.com>
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
hifive-unleashed-5.1
Frank Schaefer 2014-03-24 16:33:12 -03:00 committed by Mauro Carvalho Chehab
parent 2c52a2fce0
commit ef74a0b9ff
2 changed files with 56 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

120
drivers/media/usb/em28xx/em28xx-video.c
View File

@ -1443,7 +1443,7 @@ static int vidioc_enum_input(struct file *file, void *priv,
(EM28XX_VMUX_CABLE == INPUT(n)->type))
i->type = V4L2_INPUT_TYPE_TUNER;
i->std = dev->vdev->tvnorms;
i->std = dev->v4l2->vdev->tvnorms;
/* webcams do not have the STD API */
if (dev->board.is_webcam)
i->capabilities = 0;
@ -1687,9 +1687,10 @@ 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_fh *fh = priv;
struct em28xx *dev = fh->dev;
struct video_device *vdev = video_devdata(file);
struct em28xx_fh *fh = priv;
struct em28xx *dev = fh->dev;
struct em28xx_v4l2 *v4l2 = dev->v4l2;
strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
@ -1711,9 +1712,9 @@ static int vidioc_querycap(struct file *file, void *priv,
cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
V4L2_CAP_READWRITE | V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
if (dev->vbi_dev)
if (v4l2->vbi_dev)
cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
if (dev->radio_dev)
if (v4l2->radio_dev)
cap->capabilities |= V4L2_CAP_RADIO;
return 0;
}
@ -1951,20 +1952,20 @@ static int em28xx_v4l2_fini(struct em28xx *dev)
em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
if (dev->radio_dev) {
if (v4l2->radio_dev) {
em28xx_info("V4L2 device %s deregistered\n",
video_device_node_name(dev->radio_dev));
video_unregister_device(dev->radio_dev);
video_device_node_name(v4l2->radio_dev));
video_unregister_device(v4l2->radio_dev);
}
if (dev->vbi_dev) {
if (v4l2->vbi_dev) {
em28xx_info("V4L2 device %s deregistered\n",
video_device_node_name(dev->vbi_dev));
video_unregister_device(dev->vbi_dev);
video_device_node_name(v4l2->vbi_dev));
video_unregister_device(v4l2->vbi_dev);
}
if (dev->vdev) {
if (v4l2->vdev) {
em28xx_info("V4L2 device %s deregistered\n",
video_device_node_name(dev->vdev));
video_unregister_device(dev->vdev);
video_device_node_name(v4l2->vdev));
video_unregister_device(v4l2->vdev);
}
v4l2_ctrl_handler_free(&v4l2->ctrl_handler);
@ -2057,23 +2058,6 @@ exit:
return 0;
}
/*
* em28xx_videodevice_release()
* called when the last user of the video device exits and frees the memeory
*/
static void em28xx_videodevice_release(struct video_device *vdev)
{
struct em28xx *dev = video_get_drvdata(vdev);
video_device_release(vdev);
if (vdev == dev->vdev)
dev->vdev = NULL;
else if (vdev == dev->vbi_dev)
dev->vbi_dev = NULL;
else if (vdev == dev->radio_dev)
dev->radio_dev = NULL;
}
static const struct v4l2_file_operations em28xx_v4l_fops = {
.owner = THIS_MODULE,
.open = em28xx_v4l2_open,
@ -2130,7 +2114,7 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
static const struct video_device em28xx_video_template = {
.fops = &em28xx_v4l_fops,
.ioctl_ops = &video_ioctl_ops,
.release = em28xx_videodevice_release,
.release = video_device_release,
.tvnorms = V4L2_STD_ALL,
};
@ -2159,7 +2143,7 @@ static const struct v4l2_ioctl_ops radio_ioctl_ops = {
static struct video_device em28xx_radio_template = {
.fops = &radio_fops,
.ioctl_ops = &radio_ioctl_ops,
.release = em28xx_videodevice_release,
.release = video_device_release,
};
/* I2C possible address to saa7115, tvp5150, msp3400, tvaudio */
@ -2489,36 +2473,36 @@ static int em28xx_v4l2_init(struct em28xx *dev)
goto unregister_dev;
/* allocate and fill video video_device struct */
dev->vdev = em28xx_vdev_init(dev, &em28xx_video_template, "video");
if (!dev->vdev) {
v4l2->vdev = em28xx_vdev_init(dev, &em28xx_video_template, "video");
if (!v4l2->vdev) {
em28xx_errdev("cannot allocate video_device.\n");
ret = -ENODEV;
goto unregister_dev;
}
dev->vdev->queue = &dev->vb_vidq;
dev->vdev->queue->lock = &dev->vb_queue_lock;
v4l2->vdev->queue = &dev->vb_vidq;
v4l2->vdev->queue->lock = &dev->vb_queue_lock;
/* disable inapplicable ioctls */
if (dev->board.is_webcam) {
v4l2_disable_ioctl(dev->vdev, VIDIOC_QUERYSTD);
v4l2_disable_ioctl(dev->vdev, VIDIOC_G_STD);
v4l2_disable_ioctl(dev->vdev, VIDIOC_S_STD);
v4l2_disable_ioctl(v4l2->vdev, VIDIOC_QUERYSTD);
v4l2_disable_ioctl(v4l2->vdev, VIDIOC_G_STD);
v4l2_disable_ioctl(v4l2->vdev, VIDIOC_S_STD);
} else {
v4l2_disable_ioctl(dev->vdev, VIDIOC_S_PARM);
v4l2_disable_ioctl(v4l2->vdev, VIDIOC_S_PARM);
}
if (dev->tuner_type == TUNER_ABSENT) {
v4l2_disable_ioctl(dev->vdev, VIDIOC_G_TUNER);
v4l2_disable_ioctl(dev->vdev, VIDIOC_S_TUNER);
v4l2_disable_ioctl(dev->vdev, VIDIOC_G_FREQUENCY);
v4l2_disable_ioctl(dev->vdev, VIDIOC_S_FREQUENCY);
v4l2_disable_ioctl(v4l2->vdev, VIDIOC_G_TUNER);
v4l2_disable_ioctl(v4l2->vdev, VIDIOC_S_TUNER);
v4l2_disable_ioctl(v4l2->vdev, VIDIOC_G_FREQUENCY);
v4l2_disable_ioctl(v4l2->vdev, VIDIOC_S_FREQUENCY);
}
if (!dev->audio_mode.has_audio) {
v4l2_disable_ioctl(dev->vdev, VIDIOC_G_AUDIO);
v4l2_disable_ioctl(dev->vdev, VIDIOC_S_AUDIO);
v4l2_disable_ioctl(v4l2->vdev, VIDIOC_G_AUDIO);
v4l2_disable_ioctl(v4l2->vdev, VIDIOC_S_AUDIO);
}
/* register v4l2 video video_device */
ret = video_register_device(dev->vdev, VFL_TYPE_GRABBER,
ret = video_register_device(v4l2->vdev, VFL_TYPE_GRABBER,
video_nr[dev->devno]);
if (ret) {
em28xx_errdev("unable to register video device (error=%i).\n",
@ -2528,27 +2512,27 @@ static int em28xx_v4l2_init(struct em28xx *dev)
/* Allocate and fill vbi video_device struct */
if (em28xx_vbi_supported(dev) == 1) {
dev->vbi_dev = em28xx_vdev_init(dev, &em28xx_video_template,
v4l2->vbi_dev = em28xx_vdev_init(dev, &em28xx_video_template,
"vbi");
dev->vbi_dev->queue = &dev->vb_vbiq;
dev->vbi_dev->queue->lock = &dev->vb_vbi_queue_lock;
v4l2->vbi_dev->queue = &dev->vb_vbiq;
v4l2->vbi_dev->queue->lock = &dev->vb_vbi_queue_lock;
/* disable inapplicable ioctls */
v4l2_disable_ioctl(dev->vdev, VIDIOC_S_PARM);
v4l2_disable_ioctl(v4l2->vdev, VIDIOC_S_PARM);
if (dev->tuner_type == TUNER_ABSENT) {
v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_G_TUNER);
v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_S_TUNER);
v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_G_FREQUENCY);
v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_S_FREQUENCY);
v4l2_disable_ioctl(v4l2->vbi_dev, VIDIOC_G_TUNER);
v4l2_disable_ioctl(v4l2->vbi_dev, VIDIOC_S_TUNER);
v4l2_disable_ioctl(v4l2->vbi_dev, VIDIOC_G_FREQUENCY);
v4l2_disable_ioctl(v4l2->vbi_dev, VIDIOC_S_FREQUENCY);
}
if (!dev->audio_mode.has_audio) {
v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_G_AUDIO);
v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_S_AUDIO);
v4l2_disable_ioctl(v4l2->vbi_dev, VIDIOC_G_AUDIO);
v4l2_disable_ioctl(v4l2->vbi_dev, VIDIOC_S_AUDIO);
}
/* register v4l2 vbi video_device */
ret = video_register_device(dev->vbi_dev, VFL_TYPE_VBI,
ret = video_register_device(v4l2->vbi_dev, VFL_TYPE_VBI,
vbi_nr[dev->devno]);
if (ret < 0) {
em28xx_errdev("unable to register vbi device\n");
@ -2557,29 +2541,29 @@ static int em28xx_v4l2_init(struct em28xx *dev)
}
if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) {
dev->radio_dev = em28xx_vdev_init(dev, &em28xx_radio_template,
"radio");
if (!dev->radio_dev) {
v4l2->radio_dev = em28xx_vdev_init(dev, &em28xx_radio_template,
"radio");
if (!v4l2->radio_dev) {
em28xx_errdev("cannot allocate video_device.\n");
ret = -ENODEV;
goto unregister_dev;
}
ret = video_register_device(dev->radio_dev, VFL_TYPE_RADIO,
ret = video_register_device(v4l2->radio_dev, VFL_TYPE_RADIO,
radio_nr[dev->devno]);
if (ret < 0) {
em28xx_errdev("can't register radio device\n");
goto unregister_dev;
}
em28xx_info("Registered radio device as %s\n",
video_device_node_name(dev->radio_dev));
video_device_node_name(v4l2->radio_dev));
}
em28xx_info("V4L2 video device registered as %s\n",
video_device_node_name(dev->vdev));
video_device_node_name(v4l2->vdev));
if (dev->vbi_dev)
if (v4l2->vbi_dev)
em28xx_info("V4L2 VBI device registered as %s\n",
video_device_node_name(dev->vbi_dev));
video_device_node_name(v4l2->vbi_dev));
/* Save some power by putting tuner to sleep */
v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0);

7
drivers/media/usb/em28xx/em28xx.h
View File

@ -505,6 +505,10 @@ struct em28xx_v4l2 {
struct v4l2_device v4l2_dev;
struct v4l2_ctrl_handler ctrl_handler;
struct v4l2_clk *clk;
struct video_device *vdev;
struct video_device *vbi_dev;
struct video_device *radio_dev;
};
struct em28xx_audio {
@ -615,7 +619,6 @@ struct em28xx {
/* video for linux */
int users; /* user count for exclusive use */
int streaming_users; /* Number of actively streaming users */
struct video_device *vdev; /* video for linux device struct */
v4l2_std_id norm; /* selected tv norm */
int ctl_freq; /* selected frequency */
unsigned int ctl_input; /* selected input */
@ -646,8 +649,6 @@ struct em28xx {
/* locks */
struct mutex lock;
struct mutex ctrl_urb_lock; /* protects urb_buf */
struct video_device *vbi_dev;
struct video_device *radio_dev;
/* Videobuf2 */
struct vb2_queue vb_vidq;