[media] cx231xx: embed video_device

Embed the video_device struct to simplify the error handling and in
order to (eventually) get rid of video_device_alloc/release.

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

diff --git a/drivers/media/usb/cx231xx/cx231xx-417.c b/drivers/media/usb/cx231xx/cx231xx-417.c
index 3f295b4d1a3dc25c76f76adb670b00fd49c57cc3..983ea83391540a0600635a418d8c6f56a48092b0 100644 (file)
--- a/drivers/media/usb/cx231xx/cx231xx-417.c
+++ b/drivers/media/usb/cx231xx/cx231xx-417.c
@@ -1868,13 +1868,9 @@ void cx231xx_417_unregister(struct cx231xx *dev)
        dprintk(1, "%s()\n", __func__);
        dprintk(3, "%s()\n", __func__);
 
-       if (dev->v4l_device) {
-               if (-1 != dev->v4l_device->minor)
-                       video_unregister_device(dev->v4l_device);
-               else
-                       video_device_release(dev->v4l_device);
+       if (video_is_registered(&dev->v4l_device)) {
+               video_unregister_device(&dev->v4l_device);
                v4l2_ctrl_handler_free(&dev->mpeg_ctrl_handler.hdl);
-               dev->v4l_device = NULL;
        }
 }
 
@@ -1911,25 +1907,21 @@ static struct cx2341x_handler_ops cx231xx_ops = {
        .s_video_encoding = cx231xx_s_video_encoding,
 };
 
-static struct video_device *cx231xx_video_dev_alloc(
+static void cx231xx_video_dev_init(
        struct cx231xx *dev,
        struct usb_device *usbdev,
-       struct video_device *template,
-       char *type)
+       struct video_device *vfd,
+       const struct video_device *template,
+       const char *type)
 {
-       struct video_device *vfd;
-
        dprintk(1, "%s()\n", __func__);
-       vfd = video_device_alloc();
-       if (NULL == vfd)
-               return NULL;
        *vfd = *template;
        snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", dev->name,
                type, cx231xx_boards[dev->model].name);
 
        vfd->v4l2_dev = &dev->v4l2_dev;
        vfd->lock = &dev->lock;
-       vfd->release = video_device_release;
+       vfd->release = video_device_release_empty;
        vfd->ctrl_handler = &dev->mpeg_ctrl_handler.hdl;
        video_set_drvdata(vfd, dev);
        if (dev->tuner_type == TUNER_ABSENT) {
@@ -1938,9 +1930,6 @@ static struct video_device *cx231xx_video_dev_alloc(
                v4l2_disable_ioctl(vfd, VIDIOC_G_TUNER);
                v4l2_disable_ioctl(vfd, VIDIOC_S_TUNER);
        }
-
-       return vfd;
-
 }
 
 int cx231xx_417_register(struct cx231xx *dev)
@@ -1983,9 +1972,9 @@ int cx231xx_417_register(struct cx231xx *dev)
        cx2341x_handler_set_50hz(&dev->mpeg_ctrl_handler, false);
 
        /* Allocate and initialize V4L video device */
-       dev->v4l_device = cx231xx_video_dev_alloc(dev,
-               dev->udev, &cx231xx_mpeg_template, "mpeg");
-       err = video_register_device(dev->v4l_device,
+       cx231xx_video_dev_init(dev, dev->udev,
+                       &dev->v4l_device, &cx231xx_mpeg_template, "mpeg");
+       err = video_register_device(&dev->v4l_device,
                VFL_TYPE_GRABBER, -1);
        if (err < 0) {
                dprintk(3, "%s: can't register mpeg device\n", dev->name);
@@ -1994,7 +1983,7 @@ int cx231xx_417_register(struct cx231xx *dev)
        }
 
        dprintk(3, "%s: registered device video%d [mpeg]\n",
-              dev->name, dev->v4l_device->num);
+              dev->name, dev->v4l_device.num);
 
        return 0;
 }

diff --git a/drivers/media/usb/cx231xx/cx231xx-cards.c b/drivers/media/usb/cx231xx/cx231xx-cards.c
index 85220b97e8b2e742372e3c4972efc2b5398b8e01..fe00da105e77519bbf7c15684db8ae55593dac7e 100644 (file)
--- a/drivers/media/usb/cx231xx/cx231xx-cards.c
+++ b/drivers/media/usb/cx231xx/cx231xx-cards.c
@@ -1230,9 +1230,9 @@ static void cx231xx_create_media_graph(struct cx231xx *dev)
        if (tuner)
                media_entity_create_link(tuner, 0, decoder, 0,
                                         MEDIA_LNK_FL_ENABLED);
-       media_entity_create_link(decoder, 1, &dev->vdev->entity, 0,
+       media_entity_create_link(decoder, 1, &dev->vdev.entity, 0,
                                 MEDIA_LNK_FL_ENABLED);
-       media_entity_create_link(decoder, 2, &dev->vbi_dev->entity, 0,
+       media_entity_create_link(decoder, 2, &dev->vbi_dev.entity, 0,
                                 MEDIA_LNK_FL_ENABLED);
 #endif
 }
@@ -1748,7 +1748,7 @@ static void cx231xx_usb_disconnect(struct usb_interface *interface)
        if (dev->users) {
                dev_warn(dev->dev,
                         "device %s is open! Deregistration and memory deallocation are deferred on close.\n",
-                        video_device_node_name(dev->vdev));
+                        video_device_node_name(&dev->vdev));
 
                /* Even having users, it is safe to remove the RC i2c driver */
                cx231xx_ir_exit(dev);

diff --git a/drivers/media/usb/cx231xx/cx231xx-video.c b/drivers/media/usb/cx231xx/cx231xx-video.c
index acc1b68c408e6d59965bcd44f010eb4d51d33d8d..c261e160c158f92800669399205d2217ca85d85e 100644 (file)
--- a/drivers/media/usb/cx231xx/cx231xx-video.c
+++ b/drivers/media/usb/cx231xx/cx231xx-video.c
@@ -1129,7 +1129,7 @@ int cx231xx_enum_input(struct file *file, void *priv,
            (CX231XX_VMUX_CABLE == INPUT(n)->type))
                i->type = V4L2_INPUT_TYPE_TUNER;
 
-       i->std = dev->vdev->tvnorms;
+       i->std = dev->vdev.tvnorms;
 
        /* If they are asking about the active input, read signal status */
        if (n == dev->video_input) {
@@ -1524,7 +1524,7 @@ int cx231xx_querycap(struct file *file, void *priv,
        cap->capabilities = cap->device_caps | V4L2_CAP_READWRITE |
                V4L2_CAP_VBI_CAPTURE | V4L2_CAP_VIDEO_CAPTURE |
                V4L2_CAP_STREAMING | V4L2_CAP_DEVICE_CAPS;
-       if (dev->radio_dev)
+       if (video_is_registered(&dev->radio_dev))
                cap->capabilities |= V4L2_CAP_RADIO;
 
        return 0;
@@ -1802,34 +1802,21 @@ void cx231xx_release_analog_resources(struct cx231xx *dev)
 
        /*FIXME: I2C IR should be disconnected */
 
-       if (dev->radio_dev) {
-               if (video_is_registered(dev->radio_dev))
-                       video_unregister_device(dev->radio_dev);
-               else
-                       video_device_release(dev->radio_dev);
-               dev->radio_dev = NULL;
-       }
-       if (dev->vbi_dev) {
+       if (video_is_registered(&dev->radio_dev))
+               video_unregister_device(&dev->radio_dev);
+       if (video_is_registered(&dev->vbi_dev)) {
                dev_info(dev->dev, "V4L2 device %s deregistered\n",
-                       video_device_node_name(dev->vbi_dev));
-               if (video_is_registered(dev->vbi_dev))
-                       video_unregister_device(dev->vbi_dev);
-               else
-                       video_device_release(dev->vbi_dev);
-               dev->vbi_dev = NULL;
+                       video_device_node_name(&dev->vbi_dev));
+               video_unregister_device(&dev->vbi_dev);
        }
-       if (dev->vdev) {
+       if (video_is_registered(&dev->vdev)) {
                dev_info(dev->dev, "V4L2 device %s deregistered\n",
-                       video_device_node_name(dev->vdev));
+                       video_device_node_name(&dev->vdev));
 
                if (dev->board.has_417)
                        cx231xx_417_unregister(dev);
 
-               if (video_is_registered(dev->vdev))
-                       video_unregister_device(dev->vdev);
-               else
-                       video_device_release(dev->vdev);
-               dev->vdev = NULL;
+               video_unregister_device(&dev->vdev);
        }
        v4l2_ctrl_handler_free(&dev->ctrl_handler);
        v4l2_ctrl_handler_free(&dev->radio_ctrl_handler);
@@ -2086,7 +2073,7 @@ static struct video_device cx231xx_vbi_template;
 
 static const struct video_device cx231xx_video_template = {
        .fops         = &cx231xx_v4l_fops,
-       .release      = video_device_release,
+       .release      = video_device_release_empty,
        .ioctl_ops    = &video_ioctl_ops,
        .tvnorms      = V4L2_STD_ALL,
 };
@@ -2122,19 +2109,14 @@ static struct video_device cx231xx_radio_template = {
 
 /******************************** usb interface ******************************/
 
-static struct video_device *cx231xx_vdev_init(struct cx231xx *dev,
-               const struct video_device
-               *template, const char *type_name)
+static void cx231xx_vdev_init(struct cx231xx *dev,
+               struct video_device *vfd,
+               const struct video_device *template,
+               const char *type_name)
 {
-       struct video_device *vfd;
-
-       vfd = video_device_alloc();
-       if (NULL == vfd)
-               return NULL;
-
        *vfd = *template;
        vfd->v4l2_dev = &dev->v4l2_dev;
-       vfd->release = video_device_release;
+       vfd->release = video_device_release_empty;
        vfd->lock = &dev->lock;
 
        snprintf(vfd->name, sizeof(vfd->name), "%s %s", dev->name, type_name);
@@ -2146,7 +2128,6 @@ static struct video_device *cx231xx_vdev_init(struct cx231xx *dev,
                v4l2_disable_ioctl(vfd, VIDIOC_G_TUNER);
                v4l2_disable_ioctl(vfd, VIDIOC_S_TUNER);
        }
-       return vfd;
 }
 
 int cx231xx_register_analog_devices(struct cx231xx *dev)
@@ -2189,20 +2170,16 @@ int cx231xx_register_analog_devices(struct cx231xx *dev)
        /* write code here...  */
 
        /* allocate and fill video video_device struct */
-       dev->vdev = cx231xx_vdev_init(dev, &cx231xx_video_template, "video");
-       if (!dev->vdev) {
-               dev_err(dev->dev, "cannot allocate video_device.\n");
-               return -ENODEV;
-       }
+       cx231xx_vdev_init(dev, &dev->vdev, &cx231xx_video_template, "video");
 #if defined(CONFIG_MEDIA_CONTROLLER)
        dev->video_pad.flags = MEDIA_PAD_FL_SINK;
-       ret = media_entity_init(&dev->vdev->entity, 1, &dev->video_pad, 0);
+       ret = media_entity_init(&dev->vdev.entity, 1, &dev->video_pad, 0);
        if (ret < 0)
                dev_err(dev->dev, "failed to initialize video media entity!\n");
 #endif
-       dev->vdev->ctrl_handler = &dev->ctrl_handler;
+       dev->vdev.ctrl_handler = &dev->ctrl_handler;
        /* register v4l2 video video_device */
-       ret = video_register_device(dev->vdev, VFL_TYPE_GRABBER,
+       ret = video_register_device(&dev->vdev, VFL_TYPE_GRABBER,
                                    video_nr[dev->devno]);
        if (ret) {
                dev_err(dev->dev,
@@ -2212,28 +2189,24 @@ int cx231xx_register_analog_devices(struct cx231xx *dev)
        }
 
        dev_info(dev->dev, "Registered video device %s [v4l2]\n",
-               video_device_node_name(dev->vdev));
+               video_device_node_name(&dev->vdev));
 
        /* Initialize VBI template */
        cx231xx_vbi_template = cx231xx_video_template;
        strcpy(cx231xx_vbi_template.name, "cx231xx-vbi");
 
        /* Allocate and fill vbi video_device struct */
-       dev->vbi_dev = cx231xx_vdev_init(dev, &cx231xx_vbi_template, "vbi");
+       cx231xx_vdev_init(dev, &dev->vbi_dev, &cx231xx_vbi_template, "vbi");
 
-       if (!dev->vbi_dev) {
-               dev_err(dev->dev, "cannot allocate video_device.\n");
-               return -ENODEV;
-       }
 #if defined(CONFIG_MEDIA_CONTROLLER)
        dev->vbi_pad.flags = MEDIA_PAD_FL_SINK;
-       ret = media_entity_init(&dev->vbi_dev->entity, 1, &dev->vbi_pad, 0);
+       ret = media_entity_init(&dev->vbi_dev.entity, 1, &dev->vbi_pad, 0);
        if (ret < 0)
                dev_err(dev->dev, "failed to initialize vbi media entity!\n");
 #endif
-       dev->vbi_dev->ctrl_handler = &dev->ctrl_handler;
+       dev->vbi_dev.ctrl_handler = &dev->ctrl_handler;
        /* register v4l2 vbi video_device */
-       ret = video_register_device(dev->vbi_dev, VFL_TYPE_VBI,
+       ret = video_register_device(&dev->vbi_dev, VFL_TYPE_VBI,
                                    vbi_nr[dev->devno]);
        if (ret < 0) {
                dev_err(dev->dev, "unable to register vbi device\n");
@@ -2241,18 +2214,13 @@ int cx231xx_register_analog_devices(struct cx231xx *dev)
        }
 
        dev_info(dev->dev, "Registered VBI device %s\n",
-               video_device_node_name(dev->vbi_dev));
+               video_device_node_name(&dev->vbi_dev));
 
        if (cx231xx_boards[dev->model].radio.type == CX231XX_RADIO) {
-               dev->radio_dev = cx231xx_vdev_init(dev, &cx231xx_radio_template,
-                                                  "radio");
-               if (!dev->radio_dev) {
-                       dev_err(dev->dev,
-                               "cannot allocate video_device.\n");
-                       return -ENODEV;
-               }
-               dev->radio_dev->ctrl_handler = &dev->radio_ctrl_handler;
-               ret = video_register_device(dev->radio_dev, VFL_TYPE_RADIO,
+               cx231xx_vdev_init(dev, &dev->radio_dev,
+                               &cx231xx_radio_template, "radio");
+               dev->radio_dev.ctrl_handler = &dev->radio_ctrl_handler;
+               ret = video_register_device(&dev->radio_dev, VFL_TYPE_RADIO,
                                            radio_nr[dev->devno]);
                if (ret < 0) {
                        dev_err(dev->dev,
@@ -2260,7 +2228,7 @@ int cx231xx_register_analog_devices(struct cx231xx *dev)
                        return ret;
                }
                dev_info(dev->dev, "Registered radio device as %s\n",
-                       video_device_node_name(dev->radio_dev));
+                       video_device_node_name(&dev->radio_dev));
        }
 
        return 0;

diff --git a/drivers/media/usb/cx231xx/cx231xx.h b/drivers/media/usb/cx231xx/cx231xx.h
index 9871c79f88ff7b69c8bf370905a9cb348cb42f5a..00d3bce9a690c53aa2da077d0db805aae6c43992 100644 (file)
--- a/drivers/media/usb/cx231xx/cx231xx.h
+++ b/drivers/media/usb/cx231xx/cx231xx.h
@@ -634,7 +634,7 @@ struct cx231xx {
 
        /* video for linux */
        int users;              /* user count for exclusive use */
-       struct video_device *vdev;      /* video for linux device struct */
+       struct video_device vdev;       /* video for linux device struct */
        v4l2_std_id norm;       /* selected tv norm */
        int ctl_freq;           /* selected frequency */
        unsigned int ctl_ainput;        /* selected audio input */
@@ -656,8 +656,8 @@ struct cx231xx {
        struct mutex ctrl_urb_lock;     /* protects urb_buf */
        struct list_head inqueue, outqueue;
        wait_queue_head_t open, wait_frame, wait_stream;
-       struct video_device *vbi_dev;
-       struct video_device *radio_dev;
+       struct video_device vbi_dev;
+       struct video_device radio_dev;
 
 #if defined(CONFIG_MEDIA_CONTROLLER)
        struct media_device *media_dev;
@@ -724,7 +724,7 @@ struct cx231xx {
        u8 USE_ISO;
        struct cx231xx_tvnorm      encodernorm;
        struct cx231xx_tsport      ts1, ts2;
-       struct video_device        *v4l_device;
+       struct video_device        v4l_device;
        atomic_t                   v4l_reader_count;
        u32                        freq;
        unsigned int               input;