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 bool read_only) 191 { 192 struct video_device *vdev; 193 struct v4l2_subdev *sd; 194 int err; 195 196 /* Register a device node for every subdev marked with the 197 * V4L2_SUBDEV_FL_HAS_DEVNODE flag. 198 */ 199 list_for_each_entry(sd, &v4l2_dev->subdevs, list) { 200 if (!(sd->flags & V4L2_SUBDEV_FL_HAS_DEVNODE)) 201 continue; 202 203 if (sd->devnode) 204 continue; 205 206 vdev = kzalloc(sizeof(*vdev), GFP_KERNEL); 207 if (!vdev) { 208 err = -ENOMEM; 209 goto clean_up; 210 } 211 212 video_set_drvdata(vdev, sd); 213 strscpy(vdev->name, sd->name, sizeof(vdev->name)); 214 vdev->dev_parent = sd->dev; 215 vdev->v4l2_dev = v4l2_dev; 216 vdev->fops = &v4l2_subdev_fops; 217 vdev->release = v4l2_device_release_subdev_node; 218 vdev->ctrl_handler = sd->ctrl_handler; 219 if (read_only) 220 set_bit(V4L2_FL_SUBDEV_RO_DEVNODE, &vdev->flags); 221 sd->devnode = vdev; 222 err = __video_register_device(vdev, VFL_TYPE_SUBDEV, -1, 1, 223 sd->owner); 224 if (err < 0) { 225 sd->devnode = NULL; 226 kfree(vdev); 227 goto clean_up; 228 } 229 #if defined(CONFIG_MEDIA_CONTROLLER) 230 sd->entity.info.dev.major = VIDEO_MAJOR; 231 sd->entity.info.dev.minor = vdev->minor; 232 233 /* Interface is created by __video_register_device() */ 234 if (vdev->v4l2_dev->mdev) { 235 struct media_link *link; 236 237 link = media_create_intf_link(&sd->entity, 238 &vdev->intf_devnode->intf, 239 MEDIA_LNK_FL_ENABLED | 240 MEDIA_LNK_FL_IMMUTABLE); 241 if (!link) { 242 err = -ENOMEM; 243 goto clean_up; 244 } 245 } 246 #endif 247 } 248 return 0; 249 250 clean_up: 251 list_for_each_entry(sd, &v4l2_dev->subdevs, list) { 252 if (!sd->devnode) 253 break; 254 video_unregister_device(sd->devnode); 255 } 256 257 return err; 258 } 259 EXPORT_SYMBOL_GPL(__v4l2_device_register_subdev_nodes); 260 261 void v4l2_device_unregister_subdev(struct v4l2_subdev *sd) 262 { 263 struct v4l2_device *v4l2_dev; 264 265 /* return if it isn't registered */ 266 if (sd == NULL || sd->v4l2_dev == NULL) 267 return; 268 269 v4l2_dev = sd->v4l2_dev; 270 271 spin_lock(&v4l2_dev->lock); 272 list_del(&sd->list); 273 spin_unlock(&v4l2_dev->lock); 274 275 if (sd->internal_ops && sd->internal_ops->unregistered) 276 sd->internal_ops->unregistered(sd); 277 sd->v4l2_dev = NULL; 278 279 #if defined(CONFIG_MEDIA_CONTROLLER) 280 if (v4l2_dev->mdev) { 281 /* 282 * No need to explicitly remove links, as both pads and 283 * links are removed by the function below, in the right order 284 */ 285 media_device_unregister_entity(&sd->entity); 286 } 287 #endif 288 if (sd->devnode) 289 video_unregister_device(sd->devnode); 290 else 291 v4l2_subdev_release(sd); 292 } 293 EXPORT_SYMBOL_GPL(v4l2_device_unregister_subdev); 294