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 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 sd->owner == v4l2_dev->dev->driver->owner; 129 130 if (!sd->owner_v4l2_dev && !try_module_get(sd->owner)) 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 spin_lock(&v4l2_dev->lock); 156 list_add_tail(&sd->list, &v4l2_dev->subdevs); 157 spin_unlock(&v4l2_dev->lock); 158 159 return 0; 160 161 error_unregister: 162 #if defined(CONFIG_MEDIA_CONTROLLER) 163 media_device_unregister_entity(&sd->entity); 164 #endif 165 error_module: 166 if (!sd->owner_v4l2_dev) 167 module_put(sd->owner); 168 sd->v4l2_dev = NULL; 169 return err; 170 } 171 EXPORT_SYMBOL_GPL(v4l2_device_register_subdev); 172 173 static void v4l2_subdev_release(struct v4l2_subdev *sd) 174 { 175 struct module *owner = !sd->owner_v4l2_dev ? sd->owner : NULL; 176 177 if (sd->internal_ops && sd->internal_ops->release) 178 sd->internal_ops->release(sd); 179 sd->devnode = NULL; 180 module_put(owner); 181 } 182 183 static void v4l2_device_release_subdev_node(struct video_device *vdev) 184 { 185 v4l2_subdev_release(video_get_drvdata(vdev)); 186 kfree(vdev); 187 } 188 189 int v4l2_device_register_subdev_nodes(struct v4l2_device *v4l2_dev) 190 { 191 struct video_device *vdev; 192 struct v4l2_subdev *sd; 193 int err; 194 195 /* Register a device node for every subdev marked with the 196 * V4L2_SUBDEV_FL_HAS_DEVNODE flag. 197 */ 198 list_for_each_entry(sd, &v4l2_dev->subdevs, list) { 199 if (!(sd->flags & V4L2_SUBDEV_FL_HAS_DEVNODE)) 200 continue; 201 202 if (sd->devnode) 203 continue; 204 205 vdev = kzalloc(sizeof(*vdev), GFP_KERNEL); 206 if (!vdev) { 207 err = -ENOMEM; 208 goto clean_up; 209 } 210 211 video_set_drvdata(vdev, sd); 212 strscpy(vdev->name, sd->name, sizeof(vdev->name)); 213 vdev->dev_parent = sd->dev; 214 vdev->v4l2_dev = v4l2_dev; 215 vdev->fops = &v4l2_subdev_fops; 216 vdev->release = v4l2_device_release_subdev_node; 217 vdev->ctrl_handler = sd->ctrl_handler; 218 err = __video_register_device(vdev, VFL_TYPE_SUBDEV, -1, 1, 219 sd->owner); 220 if (err < 0) { 221 kfree(vdev); 222 goto clean_up; 223 } 224 sd->devnode = vdev; 225 #if defined(CONFIG_MEDIA_CONTROLLER) 226 sd->entity.info.dev.major = VIDEO_MAJOR; 227 sd->entity.info.dev.minor = vdev->minor; 228 229 /* Interface is created by __video_register_device() */ 230 if (vdev->v4l2_dev->mdev) { 231 struct media_link *link; 232 233 link = media_create_intf_link(&sd->entity, 234 &vdev->intf_devnode->intf, 235 MEDIA_LNK_FL_ENABLED | 236 MEDIA_LNK_FL_IMMUTABLE); 237 if (!link) { 238 err = -ENOMEM; 239 goto clean_up; 240 } 241 } 242 #endif 243 } 244 return 0; 245 246 clean_up: 247 list_for_each_entry(sd, &v4l2_dev->subdevs, list) { 248 if (!sd->devnode) 249 break; 250 video_unregister_device(sd->devnode); 251 } 252 253 return err; 254 } 255 EXPORT_SYMBOL_GPL(v4l2_device_register_subdev_nodes); 256 257 void v4l2_device_unregister_subdev(struct v4l2_subdev *sd) 258 { 259 struct v4l2_device *v4l2_dev; 260 261 /* return if it isn't registered */ 262 if (sd == NULL || sd->v4l2_dev == NULL) 263 return; 264 265 v4l2_dev = sd->v4l2_dev; 266 267 spin_lock(&v4l2_dev->lock); 268 list_del(&sd->list); 269 spin_unlock(&v4l2_dev->lock); 270 271 if (sd->internal_ops && sd->internal_ops->unregistered) 272 sd->internal_ops->unregistered(sd); 273 sd->v4l2_dev = NULL; 274 275 #if defined(CONFIG_MEDIA_CONTROLLER) 276 if (v4l2_dev->mdev) { 277 /* 278 * No need to explicitly remove links, as both pads and 279 * links are removed by the function below, in the right order 280 */ 281 media_device_unregister_entity(&sd->entity); 282 } 283 #endif 284 if (sd->devnode) 285 video_unregister_device(sd->devnode); 286 else 287 v4l2_subdev_release(sd); 288 } 289 EXPORT_SYMBOL_GPL(v4l2_device_unregister_subdev); 290