drivers/media/v4l2-core/v4l2-device.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3     V4L2 device support.
   4
   5     Copyright (C) 2008  Hans Verkuil <hverkuil@xs4all.nl>
   6
   7  */
   8
   9 #include <linux/types.h>
  10 #include <linux/ioctl.h>
  11 #include <linux/module.h>
  12 #include <linux/slab.h>
  13 #include <linux/videodev2.h>
  14 #include <media/v4l2-device.h>
  15 #include <media/v4l2-ctrls.h>
  16
  17 int v4l2_device_register(struct device *dev, struct v4l2_device *v4l2_dev)
  18 {
  19         if (v4l2_dev == NULL)
  20                 return -EINVAL;
  21
  22         INIT_LIST_HEAD(&v4l2_dev->subdevs);
  23         spin_lock_init(&v4l2_dev->lock);
  24         v4l2_prio_init(&v4l2_dev->prio);
  25         kref_init(&v4l2_dev->ref);
  26         get_device(dev);
  27         v4l2_dev->dev = dev;
  28         if (dev == NULL) {
  29                 /* If dev == NULL, then name must be filled in by the caller */
  30                 if (WARN_ON(!v4l2_dev->name[0]))
  31                         return -EINVAL;
  32                 return 0;
  33         }
  34
  35         /* Set name to driver name + device name if it is empty. */
  36         if (!v4l2_dev->name[0])
  37                 snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "%s %s",
  38                         dev->driver->name, dev_name(dev));
  39         if (!dev_get_drvdata(dev))
  40                 dev_set_drvdata(dev, v4l2_dev);
  41         return 0;
  42 }
  43 EXPORT_SYMBOL_GPL(v4l2_device_register);
  44
  45 static void v4l2_device_release(struct kref *ref)
  46 {
  47         struct v4l2_device *v4l2_dev =
  48                 container_of(ref, struct v4l2_device, ref);
  49
  50         if (v4l2_dev->release)
  51                 v4l2_dev->release(v4l2_dev);
  52 }
  53
  54 int v4l2_device_put(struct v4l2_device *v4l2_dev)
  55 {
  56         return kref_put(&v4l2_dev->ref, v4l2_device_release);
  57 }
  58 EXPORT_SYMBOL_GPL(v4l2_device_put);
  59
  60 int v4l2_device_set_name(struct v4l2_device *v4l2_dev, const char *basename,
  61                                                 atomic_t *instance)
  62 {
  63         int num = atomic_inc_return(instance) - 1;
  64         int len = strlen(basename);
  65
  66         if (basename[len - 1] >= '0' && basename[len - 1] <= '9')
  67                 snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
  68                                 "%s-%d", basename, num);
  69         else
  70                 snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
  71                                 "%s%d", basename, num);
  72         return num;
  73 }
  74 EXPORT_SYMBOL_GPL(v4l2_device_set_name);
  75
  76 void v4l2_device_disconnect(struct v4l2_device *v4l2_dev)
  77 {
  78         if (v4l2_dev->dev == NULL)
  79                 return;
  80
  81         if (dev_get_drvdata(v4l2_dev->dev) == v4l2_dev)
  82                 dev_set_drvdata(v4l2_dev->dev, NULL);
  83         put_device(v4l2_dev->dev);
  84         v4l2_dev->dev = NULL;
  85 }
  86 EXPORT_SYMBOL_GPL(v4l2_device_disconnect);
  87
  88 void v4l2_device_unregister(struct v4l2_device *v4l2_dev)
  89 {
  90         struct v4l2_subdev *sd, *next;
  91
  92         /* Just return if v4l2_dev is NULL or if it was already
  93          * unregistered before. */
  94         if (v4l2_dev == NULL || !v4l2_dev->name[0])
  95                 return;
  96         v4l2_device_disconnect(v4l2_dev);
  97
  98         /* Unregister subdevs */
  99         list_for_each_entry_safe(sd, next, &v4l2_dev->subdevs, list) {
 100                 v4l2_device_unregister_subdev(sd);
 101                 if (sd->flags & V4L2_SUBDEV_FL_IS_I2C)
 102                         v4l2_i2c_subdev_unregister(sd);
 103                 else if (sd->flags & V4L2_SUBDEV_FL_IS_SPI)
 104                         v4l2_spi_subdev_unregister(sd);
 105         }
 106         /* Mark as unregistered, thus preventing duplicate unregistrations */
 107         v4l2_dev->name[0] = '\0';
 108 }
 109 EXPORT_SYMBOL_GPL(v4l2_device_unregister);
 110
 111 int v4l2_device_register_subdev(struct v4l2_device *v4l2_dev,
 112                                 struct v4l2_subdev *sd)
 113 {
 114 #if defined(CONFIG_MEDIA_CONTROLLER)
 115         struct media_entity *entity = &sd->entity;
 116 #endif
 117         int err;
 118
 119         /* Check for valid input */
 120         if (!v4l2_dev || !sd || sd->v4l2_dev || !sd->name[0])
 121                 return -EINVAL;
 122
 123         /*
 124          * The reason to acquire the module here is to avoid unloading
 125          * a module of sub-device which is registered to a media
 126          * device. To make it possible to unload modules for media
 127          * devices that also register sub-devices, do not
 128          * try_module_get() such sub-device owners.
 129          */
 130         sd->owner_v4l2_dev = v4l2_dev->dev && v4l2_dev->dev->driver &&
 131                 sd->owner == v4l2_dev->dev->driver->owner;
 132
 133         if (!sd->owner_v4l2_dev && !try_module_get(sd->owner))
 134                 return -ENODEV;
 135
 136         sd->v4l2_dev = v4l2_dev;
 137         /* This just returns 0 if either of the two args is NULL */
 138         err = v4l2_ctrl_add_handler(v4l2_dev->ctrl_handler, sd->ctrl_handler,
 139                                     NULL, true);
 140         if (err)
 141                 goto error_module;
 142
 143 #if defined(CONFIG_MEDIA_CONTROLLER)
 144         /* Register the entity. */
 145         if (v4l2_dev->mdev) {
 146                 err = media_device_register_entity(v4l2_dev->mdev, entity);
 147                 if (err < 0)
 148                         goto error_module;
 149         }
 150 #endif
 151
 152         if (sd->internal_ops && sd->internal_ops->registered) {
 153                 err = sd->internal_ops->registered(sd);
 154                 if (err)
 155                         goto error_unregister;
 156         }
 157
 158         spin_lock(&v4l2_dev->lock);
 159         list_add_tail(&sd->list, &v4l2_dev->subdevs);
 160         spin_unlock(&v4l2_dev->lock);
 161
 162         return 0;
 163
 164 error_unregister:
 165 #if defined(CONFIG_MEDIA_CONTROLLER)
 166         media_device_unregister_entity(entity);
 167 #endif
 168 error_module:
 169         if (!sd->owner_v4l2_dev)
 170                 module_put(sd->owner);
 171         sd->v4l2_dev = NULL;
 172         return err;
 173 }
 174 EXPORT_SYMBOL_GPL(v4l2_device_register_subdev);
 175
 176 static void v4l2_subdev_release(struct v4l2_subdev *sd)
 177 {
 178         struct module *owner = !sd->owner_v4l2_dev ? sd->owner : NULL;
 179
 180         if (sd->internal_ops && sd->internal_ops->release)
 181                 sd->internal_ops->release(sd);
 182         module_put(owner);
 183 }
 184
 185 static void v4l2_device_release_subdev_node(struct video_device *vdev)
 186 {
 187         v4l2_subdev_release(video_get_drvdata(vdev));
 188         kfree(vdev);
 189 }
 190
 191 int v4l2_device_register_subdev_nodes(struct v4l2_device *v4l2_dev)
 192 {
 193         struct video_device *vdev;
 194         struct v4l2_subdev *sd;
 195         int err;
 196
 197         /* Register a device node for every subdev marked with the
 198          * V4L2_SUBDEV_FL_HAS_DEVNODE flag.
 199          */
 200         list_for_each_entry(sd, &v4l2_dev->subdevs, list) {
 201                 if (!(sd->flags & V4L2_SUBDEV_FL_HAS_DEVNODE))
 202                         continue;
 203
 204                 if (sd->devnode)
 205                         continue;
 206
 207                 vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
 208                 if (!vdev) {
 209                         err = -ENOMEM;
 210                         goto clean_up;
 211                 }
 212
 213                 video_set_drvdata(vdev, sd);
 214                 strscpy(vdev->name, sd->name, sizeof(vdev->name));
 215                 vdev->dev_parent = sd->dev;
 216                 vdev->v4l2_dev = v4l2_dev;
 217                 vdev->fops = &v4l2_subdev_fops;
 218                 vdev->release = v4l2_device_release_subdev_node;
 219                 vdev->ctrl_handler = sd->ctrl_handler;
 220                 err = __video_register_device(vdev, VFL_TYPE_SUBDEV, -1, 1,
 221                                               sd->owner);
 222                 if (err < 0) {
 223                         kfree(vdev);
 224                         goto clean_up;
 225                 }
 226                 sd->devnode = vdev;
 227 #if defined(CONFIG_MEDIA_CONTROLLER)
 228                 sd->entity.info.dev.major = VIDEO_MAJOR;
 229                 sd->entity.info.dev.minor = vdev->minor;
 230
 231                 /* Interface is created by __video_register_device() */
 232                 if (vdev->v4l2_dev->mdev) {
 233                         struct media_link *link;
 234
 235                         link = media_create_intf_link(&sd->entity,
 236                                                       &vdev->intf_devnode->intf,
 237                                                       MEDIA_LNK_FL_ENABLED |
 238                                                       MEDIA_LNK_FL_IMMUTABLE);
 239                         if (!link) {
 240                                 err = -ENOMEM;
 241                                 goto clean_up;
 242                         }
 243                 }
 244 #endif
 245         }
 246         return 0;
 247
 248 clean_up:
 249         list_for_each_entry(sd, &v4l2_dev->subdevs, list) {
 250                 if (!sd->devnode)
 251                         break;
 252                 video_unregister_device(sd->devnode);
 253         }
 254
 255         return err;
 256 }
 257 EXPORT_SYMBOL_GPL(v4l2_device_register_subdev_nodes);
 258
 259 void v4l2_device_unregister_subdev(struct v4l2_subdev *sd)
 260 {
 261         struct v4l2_device *v4l2_dev;
 262
 263         /* return if it isn't registered */
 264         if (sd == NULL || sd->v4l2_dev == NULL)
 265                 return;
 266
 267         v4l2_dev = sd->v4l2_dev;
 268
 269         spin_lock(&v4l2_dev->lock);
 270         list_del(&sd->list);
 271         spin_unlock(&v4l2_dev->lock);
 272
 273         if (sd->internal_ops && sd->internal_ops->unregistered)
 274                 sd->internal_ops->unregistered(sd);
 275         sd->v4l2_dev = NULL;
 276
 277 #if defined(CONFIG_MEDIA_CONTROLLER)
 278         if (v4l2_dev->mdev) {
 279                 /*
 280                  * No need to explicitly remove links, as both pads and
 281                  * links are removed by the function below, in the right order
 282                  */
 283                 media_device_unregister_entity(&sd->entity);
 284         }
 285 #endif
 286         if (sd->devnode)
 287                 video_unregister_device(sd->devnode);
 288         else
 289                 v4l2_subdev_release(sd);
 290 }
 291 EXPORT_SYMBOL_GPL(v4l2_device_unregister_subdev);