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 <[email protected]>
   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, struct module *module)
 113 {
 114         int err;
 115
 116         /* Check for valid input */
 117         if (!v4l2_dev || !sd || sd->v4l2_dev || !sd->name[0])
 118                 return -EINVAL;
 119
 120         /*
 121          * The reason to acquire the module here is to avoid unloading
 122          * a module of sub-device which is registered to a media
 123          * device. To make it possible to unload modules for media
 124          * devices that also register sub-devices, do not
 125          * try_module_get() such sub-device owners.
 126          */
 127         sd->owner_v4l2_dev = v4l2_dev->dev && v4l2_dev->dev->driver &&
 128                 module == v4l2_dev->dev->driver->owner;
 129
 130         if (!sd->owner_v4l2_dev && !try_module_get(module))
 131                 return -ENODEV;
 132
 133         sd->v4l2_dev = v4l2_dev;
 134         /* This just returns 0 if either of the two args is NULL */
 135         err = v4l2_ctrl_add_handler(v4l2_dev->ctrl_handler, sd->ctrl_handler,
 136                                     NULL, true);
 137         if (err)
 138                 goto error_module;
 139
 140 #if defined(CONFIG_MEDIA_CONTROLLER)
 141         /* Register the entity. */
 142         if (v4l2_dev->mdev) {
 143                 err = media_device_register_entity(v4l2_dev->mdev, &sd->entity);
 144                 if (err < 0)
 145                         goto error_module;
 146         }
 147 #endif
 148
 149         if (sd->internal_ops && sd->internal_ops->registered) {
 150                 err = sd->internal_ops->registered(sd);
 151                 if (err)
 152                         goto error_unregister;
 153         }
 154
 155         sd->owner = module;
 156
 157         spin_lock(&v4l2_dev->lock);
 158         list_add_tail(&sd->list, &v4l2_dev->subdevs);
 159         spin_unlock(&v4l2_dev->lock);
 160
 161         return 0;
 162
 163 error_unregister:
 164 #if defined(CONFIG_MEDIA_CONTROLLER)
 165         media_device_unregister_entity(&sd->entity);
 166 #endif
 167 error_module:
 168         if (!sd->owner_v4l2_dev)
 169                 module_put(sd->owner);
 170         sd->v4l2_dev = NULL;
 171         return err;
 172 }
 173 EXPORT_SYMBOL_GPL(__v4l2_device_register_subdev);
 174
 175 static void v4l2_subdev_release(struct v4l2_subdev *sd)
 176 {
 177         struct module *owner = !sd->owner_v4l2_dev ? sd->owner : NULL;
 178
 179         if (sd->internal_ops && sd->internal_ops->release)
 180                 sd->internal_ops->release(sd);
 181         sd->devnode = NULL;
 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                                         bool read_only)
 193 {
 194         struct video_device *vdev;
 195         struct v4l2_subdev *sd;
 196         int err;
 197
 198         /* Register a device node for every subdev marked with the
 199          * V4L2_SUBDEV_FL_HAS_DEVNODE flag.
 200          */
 201         list_for_each_entry(sd, &v4l2_dev->subdevs, list) {
 202                 if (!(sd->flags & V4L2_SUBDEV_FL_HAS_DEVNODE))
 203                         continue;
 204
 205                 if (sd->devnode)
 206                         continue;
 207
 208                 vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
 209                 if (!vdev) {
 210                         err = -ENOMEM;
 211                         goto clean_up;
 212                 }
 213
 214                 video_set_drvdata(vdev, sd);
 215                 strscpy(vdev->name, sd->name, sizeof(vdev->name));
 216                 vdev->dev_parent = sd->dev;
 217                 vdev->v4l2_dev = v4l2_dev;
 218                 vdev->fops = &v4l2_subdev_fops;
 219                 vdev->release = v4l2_device_release_subdev_node;
 220                 vdev->ctrl_handler = sd->ctrl_handler;
 221                 if (read_only)
 222                         set_bit(V4L2_FL_SUBDEV_RO_DEVNODE, &vdev->flags);
 223                 sd->devnode = vdev;
 224                 err = __video_register_device(vdev, VFL_TYPE_SUBDEV, -1, 1,
 225                                               sd->owner);
 226                 if (err < 0) {
 227                         sd->devnode = NULL;
 228                         kfree(vdev);
 229                         goto clean_up;
 230                 }
 231 #if defined(CONFIG_MEDIA_CONTROLLER)
 232                 sd->entity.info.dev.major = VIDEO_MAJOR;
 233                 sd->entity.info.dev.minor = vdev->minor;
 234
 235                 /* Interface is created by __video_register_device() */
 236                 if (vdev->v4l2_dev->mdev) {
 237                         struct media_link *link;
 238
 239                         link = media_create_intf_link(&sd->entity,
 240                                                       &vdev->intf_devnode->intf,
 241                                                       MEDIA_LNK_FL_ENABLED |
 242                                                       MEDIA_LNK_FL_IMMUTABLE);
 243                         if (!link) {
 244                                 err = -ENOMEM;
 245                                 goto clean_up;
 246                         }
 247                 }
 248 #endif
 249         }
 250         return 0;
 251
 252 clean_up:
 253         list_for_each_entry(sd, &v4l2_dev->subdevs, list) {
 254                 if (!sd->devnode)
 255                         break;
 256                 video_unregister_device(sd->devnode);
 257         }
 258
 259         return err;
 260 }
 261 EXPORT_SYMBOL_GPL(__v4l2_device_register_subdev_nodes);
 262
 263 void v4l2_device_unregister_subdev(struct v4l2_subdev *sd)
 264 {
 265         struct v4l2_device *v4l2_dev;
 266
 267         /* return if it isn't registered */
 268         if (sd == NULL || sd->v4l2_dev == NULL)
 269                 return;
 270
 271         v4l2_dev = sd->v4l2_dev;
 272
 273         spin_lock(&v4l2_dev->lock);
 274         list_del(&sd->list);
 275         spin_unlock(&v4l2_dev->lock);
 276
 277         if (sd->internal_ops && sd->internal_ops->unregistered)
 278                 sd->internal_ops->unregistered(sd);
 279         sd->v4l2_dev = NULL;
 280
 281 #if defined(CONFIG_MEDIA_CONTROLLER)
 282         if (v4l2_dev->mdev) {
 283                 /*
 284                  * No need to explicitly remove links, as both pads and
 285                  * links are removed by the function below, in the right order
 286                  */
 287                 media_device_unregister_entity(&sd->entity);
 288         }
 289 #endif
 290         if (sd->devnode)
 291                 video_unregister_device(sd->devnode);
 292         else
 293                 v4l2_subdev_release(sd);
 294 }
 295 EXPORT_SYMBOL_GPL(v4l2_device_unregister_subdev);