Branch data     Line data    Source code

       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                 :          3 : int v4l2_device_register(struct device *dev, struct v4l2_device *v4l2_dev)
      18                 :            : {
      19                 :          3 :         if (v4l2_dev == NULL)
      20                 :            :                 return -EINVAL;
      21                 :            : 
      22                 :          3 :         INIT_LIST_HEAD(&v4l2_dev->subdevs);
      23                 :          3 :         spin_lock_init(&v4l2_dev->lock);
      24                 :          3 :         v4l2_prio_init(&v4l2_dev->prio);
      25                 :            :         kref_init(&v4l2_dev->ref);
      26                 :          3 :         get_device(dev);
      27                 :          3 :         v4l2_dev->dev = dev;
      28                 :          3 :         if (dev == NULL) {
      29                 :            :                 /* If dev == NULL, then name must be filled in by the caller */
      30                 :          0 :                 if (WARN_ON(!v4l2_dev->name[0]))
      31                 :            :                         return -EINVAL;
      32                 :          0 :                 return 0;
      33                 :            :         }
      34                 :            : 
      35                 :            :         /* Set name to driver name + device name if it is empty. */
      36                 :          3 :         if (!v4l2_dev->name[0])
      37                 :          3 :                 snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "%s %s",
      38                 :          3 :                         dev->driver->name, dev_name(dev));
      39                 :          3 :         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                 :          0 : static void v4l2_device_release(struct kref *ref)
      46                 :            : {
      47                 :            :         struct v4l2_device *v4l2_dev =
      48                 :          0 :                 container_of(ref, struct v4l2_device, ref);
      49                 :            : 
      50                 :          0 :         if (v4l2_dev->release)
      51                 :          0 :                 v4l2_dev->release(v4l2_dev);
      52                 :          0 : }
      53                 :            : 
      54                 :          0 : int v4l2_device_put(struct v4l2_device *v4l2_dev)
      55                 :            : {
      56                 :          0 :         return kref_put(&v4l2_dev->ref, v4l2_device_release);
      57                 :            : }
      58                 :            : EXPORT_SYMBOL_GPL(v4l2_device_put);
      59                 :            : 
      60                 :          0 : int v4l2_device_set_name(struct v4l2_device *v4l2_dev, const char *basename,
      61                 :            :                                                 atomic_t *instance)
      62                 :            : {
      63                 :          0 :         int num = atomic_inc_return(instance) - 1;
      64                 :          0 :         int len = strlen(basename);
      65                 :            : 
      66                 :          0 :         if (basename[len - 1] >= '0' && basename[len - 1] <= '9')
      67                 :          0 :                 snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
      68                 :            :                                 "%s-%d", basename, num);
      69                 :            :         else
      70                 :          0 :                 snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
      71                 :            :                                 "%s%d", basename, num);
      72                 :          0 :         return num;
      73                 :            : }
      74                 :            : EXPORT_SYMBOL_GPL(v4l2_device_set_name);
      75                 :            : 
      76                 :          0 : void v4l2_device_disconnect(struct v4l2_device *v4l2_dev)
      77                 :            : {
      78                 :          0 :         if (v4l2_dev->dev == NULL)
      79                 :          0 :                 return;
      80                 :            : 
      81                 :          0 :         if (dev_get_drvdata(v4l2_dev->dev) == v4l2_dev)
      82                 :            :                 dev_set_drvdata(v4l2_dev->dev, NULL);
      83                 :          0 :         put_device(v4l2_dev->dev);
      84                 :          0 :         v4l2_dev->dev = NULL;
      85                 :            : }
      86                 :            : EXPORT_SYMBOL_GPL(v4l2_device_disconnect);
      87                 :            : 
      88                 :          0 : 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                 :          0 :         if (v4l2_dev == NULL || !v4l2_dev->name[0])
      95                 :          0 :                 return;
      96                 :          0 :         v4l2_device_disconnect(v4l2_dev);
      97                 :            : 
      98                 :            :         /* Unregister subdevs */
      99                 :          0 :         list_for_each_entry_safe(sd, next, &v4l2_dev->subdevs, list) {
     100                 :          0 :                 v4l2_device_unregister_subdev(sd);
     101                 :          0 :                 if (sd->flags & V4L2_SUBDEV_FL_IS_I2C)
     102                 :          0 :                         v4l2_i2c_subdev_unregister(sd);
     103                 :          0 :                 else if (sd->flags & V4L2_SUBDEV_FL_IS_SPI)
     104                 :          0 :                         v4l2_spi_subdev_unregister(sd);
     105                 :            :         }
     106                 :            :         /* Mark as unregistered, thus preventing duplicate unregistrations */
     107                 :          0 :         v4l2_dev->name[0] = '\0';
     108                 :            : }
     109                 :            : EXPORT_SYMBOL_GPL(v4l2_device_unregister);
     110                 :            : 
     111                 :          0 : int v4l2_device_register_subdev(struct v4l2_device *v4l2_dev,
     112                 :            :                                 struct v4l2_subdev *sd)
     113                 :            : {
     114                 :            : #if defined(CONFIG_MEDIA_CONTROLLER)
     115                 :          0 :         struct media_entity *entity = &sd->entity;
     116                 :            : #endif
     117                 :            :         int err;
     118                 :            : 
     119                 :            :         /* Check for valid input */
     120                 :          0 :         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                 :          0 :         sd->owner_v4l2_dev = v4l2_dev->dev && v4l2_dev->dev->driver &&
     131                 :          0 :                 sd->owner == v4l2_dev->dev->driver->owner;
     132                 :            : 
     133                 :          0 :         if (!sd->owner_v4l2_dev && !try_module_get(sd->owner))
     134                 :            :                 return -ENODEV;
     135                 :            : 
     136                 :          0 :         sd->v4l2_dev = v4l2_dev;
     137                 :            :         /* This just returns 0 if either of the two args is NULL */
     138                 :          0 :         err = v4l2_ctrl_add_handler(v4l2_dev->ctrl_handler, sd->ctrl_handler,
     139                 :            :                                     NULL, true);
     140                 :          0 :         if (err)
     141                 :            :                 goto error_module;
     142                 :            : 
     143                 :            : #if defined(CONFIG_MEDIA_CONTROLLER)
     144                 :            :         /* Register the entity. */
     145                 :          0 :         if (v4l2_dev->mdev) {
     146                 :          0 :                 err = media_device_register_entity(v4l2_dev->mdev, entity);
     147                 :          0 :                 if (err < 0)
     148                 :            :                         goto error_module;
     149                 :            :         }
     150                 :            : #endif
     151                 :            : 
     152                 :          0 :         if (sd->internal_ops && sd->internal_ops->registered) {
     153                 :          0 :                 err = sd->internal_ops->registered(sd);
     154                 :          0 :                 if (err)
     155                 :            :                         goto error_unregister;
     156                 :            :         }
     157                 :            : 
     158                 :            :         spin_lock(&v4l2_dev->lock);
     159                 :          0 :         list_add_tail(&sd->list, &v4l2_dev->subdevs);
     160                 :            :         spin_unlock(&v4l2_dev->lock);
     161                 :            : 
     162                 :          0 :         return 0;
     163                 :            : 
     164                 :            : error_unregister:
     165                 :            : #if defined(CONFIG_MEDIA_CONTROLLER)
     166                 :          0 :         media_device_unregister_entity(entity);
     167                 :            : #endif
     168                 :            : error_module:
     169                 :          0 :         if (!sd->owner_v4l2_dev)
     170                 :          0 :                 module_put(sd->owner);
     171                 :          0 :         sd->v4l2_dev = NULL;
     172                 :          0 :         return err;
     173                 :            : }
     174                 :            : EXPORT_SYMBOL_GPL(v4l2_device_register_subdev);
     175                 :            : 
     176                 :          0 : static void v4l2_subdev_release(struct v4l2_subdev *sd)
     177                 :            : {
     178                 :          0 :         struct module *owner = !sd->owner_v4l2_dev ? sd->owner : NULL;
     179                 :            : 
     180                 :          0 :         if (sd->internal_ops && sd->internal_ops->release)
     181                 :          0 :                 sd->internal_ops->release(sd);
     182                 :          0 :         sd->devnode = NULL;
     183                 :          0 :         module_put(owner);
     184                 :          0 : }
     185                 :            : 
     186                 :          0 : static void v4l2_device_release_subdev_node(struct video_device *vdev)
     187                 :            : {
     188                 :          0 :         v4l2_subdev_release(video_get_drvdata(vdev));
     189                 :          0 :         kfree(vdev);
     190                 :          0 : }
     191                 :            : 
     192                 :          0 : int __v4l2_device_register_subdev_nodes(struct v4l2_device *v4l2_dev,
     193                 :            :                                         bool read_only)
     194                 :            : {
     195                 :            :         struct video_device *vdev;
     196                 :            :         struct v4l2_subdev *sd;
     197                 :            :         int err;
     198                 :            : 
     199                 :            :         /* Register a device node for every subdev marked with the
     200                 :            :          * V4L2_SUBDEV_FL_HAS_DEVNODE flag.
     201                 :            :          */
     202                 :          0 :         list_for_each_entry(sd, &v4l2_dev->subdevs, list) {
     203                 :          0 :                 if (!(sd->flags & V4L2_SUBDEV_FL_HAS_DEVNODE))
     204                 :          0 :                         continue;
     205                 :            : 
     206                 :          0 :                 if (sd->devnode)
     207                 :          0 :                         continue;
     208                 :            : 
     209                 :          0 :                 vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
     210                 :          0 :                 if (!vdev) {
     211                 :            :                         err = -ENOMEM;
     212                 :            :                         goto clean_up;
     213                 :            :                 }
     214                 :            : 
     215                 :            :                 video_set_drvdata(vdev, sd);
     216                 :          0 :                 strscpy(vdev->name, sd->name, sizeof(vdev->name));
     217                 :          0 :                 vdev->dev_parent = sd->dev;
     218                 :          0 :                 vdev->v4l2_dev = v4l2_dev;
     219                 :          0 :                 vdev->fops = &v4l2_subdev_fops;
     220                 :          0 :                 vdev->release = v4l2_device_release_subdev_node;
     221                 :          0 :                 vdev->ctrl_handler = sd->ctrl_handler;
     222                 :          0 :                 if (read_only)
     223                 :          0 :                         set_bit(V4L2_FL_SUBDEV_RO_DEVNODE, &vdev->flags);
     224                 :          0 :                 err = __video_register_device(vdev, VFL_TYPE_SUBDEV, -1, 1,
     225                 :            :                                               sd->owner);
     226                 :          0 :                 if (err < 0) {
     227                 :          0 :                         kfree(vdev);
     228                 :          0 :                         goto clean_up;
     229                 :            :                 }
     230                 :          0 :                 sd->devnode = vdev;
     231                 :            : #if defined(CONFIG_MEDIA_CONTROLLER)
     232                 :          0 :                 sd->entity.info.dev.major = VIDEO_MAJOR;
     233                 :          0 :                 sd->entity.info.dev.minor = vdev->minor;
     234                 :            : 
     235                 :            :                 /* Interface is created by __video_register_device() */
     236                 :          0 :                 if (vdev->v4l2_dev->mdev) {
     237                 :            :                         struct media_link *link;
     238                 :            : 
     239                 :          0 :                         link = media_create_intf_link(&sd->entity,
     240                 :          0 :                                                       &vdev->intf_devnode->intf,
     241                 :            :                                                       MEDIA_LNK_FL_ENABLED |
     242                 :            :                                                       MEDIA_LNK_FL_IMMUTABLE);
     243                 :          0 :                         if (!link) {
     244                 :            :                                 err = -ENOMEM;
     245                 :            :                                 goto clean_up;
     246                 :            :                         }
     247                 :            :                 }
     248                 :            : #endif
     249                 :            :         }
     250                 :            :         return 0;
     251                 :            : 
     252                 :            : clean_up:
     253                 :          0 :         list_for_each_entry(sd, &v4l2_dev->subdevs, list) {
     254                 :          0 :                 if (!sd->devnode)
     255                 :            :                         break;
     256                 :          0 :                 video_unregister_device(sd->devnode);
     257                 :            :         }
     258                 :            : 
     259                 :            :         return err;
     260                 :            : }
     261                 :            : EXPORT_SYMBOL_GPL(__v4l2_device_register_subdev_nodes);
     262                 :            : 
     263                 :          0 : 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                 :          0 :         if (sd == NULL || sd->v4l2_dev == NULL)
     269                 :          0 :                 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                 :          0 :         if (sd->internal_ops && sd->internal_ops->unregistered)
     278                 :          0 :                 sd->internal_ops->unregistered(sd);
     279                 :          0 :         sd->v4l2_dev = NULL;
     280                 :            : 
     281                 :            : #if defined(CONFIG_MEDIA_CONTROLLER)
     282                 :          0 :         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                 :          0 :                 media_device_unregister_entity(&sd->entity);
     288                 :            :         }
     289                 :            : #endif
     290                 :          0 :         if (sd->devnode)
     291                 :          0 :                 video_unregister_device(sd->devnode);
     292                 :            :         else
     293                 :          0 :                 v4l2_subdev_release(sd);
     294                 :            : }
     295                 :            : EXPORT_SYMBOL_GPL(v4l2_device_unregister_subdev);