“fe67c913f1ec2a01aaa9176c80ef36eaf87d705d”上不存在“git@gitcode.net:openeuler/kernel.git”
v4l2-device.c 5.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
    V4L2 device support.

    Copyright (C) 2008  Hans Verkuil <hverkuil@xs4all.nl>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <linux/types.h>
#include <linux/ioctl.h>
#include <linux/i2c.h>
24 25 26
#if defined(CONFIG_SPI)
#include <linux/spi/spi.h>
#endif
27 28
#include <linux/videodev2.h>
#include <media/v4l2-device.h>
29
#include <media/v4l2-ctrls.h>
30 31 32

int v4l2_device_register(struct device *dev, struct v4l2_device *v4l2_dev)
{
33
	if (v4l2_dev == NULL)
34
		return -EINVAL;
35

36 37
	INIT_LIST_HEAD(&v4l2_dev->subdevs);
	spin_lock_init(&v4l2_dev->lock);
38
	mutex_init(&v4l2_dev->ioctl_lock);
39
	v4l2_dev->dev = dev;
40 41 42 43 44 45 46 47 48
	if (dev == NULL) {
		/* If dev == NULL, then name must be filled in by the caller */
		WARN_ON(!v4l2_dev->name[0]);
		return 0;
	}

	/* Set name to driver name + device name if it is empty. */
	if (!v4l2_dev->name[0])
		snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "%s %s",
49
			dev->driver->name, dev_name(dev));
50 51
	if (dev_get_drvdata(dev))
		v4l2_warn(v4l2_dev, "Non-NULL drvdata on register\n");
52 53 54 55 56
	dev_set_drvdata(dev, v4l2_dev);
	return 0;
}
EXPORT_SYMBOL_GPL(v4l2_device_register);

57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
int v4l2_device_set_name(struct v4l2_device *v4l2_dev, const char *basename,
						atomic_t *instance)
{
	int num = atomic_inc_return(instance) - 1;
	int len = strlen(basename);

	if (basename[len - 1] >= '0' && basename[len - 1] <= '9')
		snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
				"%s-%d", basename, num);
	else
		snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
				"%s%d", basename, num);
	return num;
}
EXPORT_SYMBOL_GPL(v4l2_device_set_name);

73 74 75 76 77 78 79 80 81
void v4l2_device_disconnect(struct v4l2_device *v4l2_dev)
{
	if (v4l2_dev->dev) {
		dev_set_drvdata(v4l2_dev->dev, NULL);
		v4l2_dev->dev = NULL;
	}
}
EXPORT_SYMBOL_GPL(v4l2_device_disconnect);

82 83 84 85
void v4l2_device_unregister(struct v4l2_device *v4l2_dev)
{
	struct v4l2_subdev *sd, *next;

86
	if (v4l2_dev == NULL)
87
		return;
88 89
	v4l2_device_disconnect(v4l2_dev);

90
	/* Unregister subdevs */
91
	list_for_each_entry_safe(sd, next, &v4l2_dev->subdevs, list) {
92
		v4l2_device_unregister_subdev(sd);
93
#if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
94 95 96 97 98 99 100 101 102
		if (sd->flags & V4L2_SUBDEV_FL_IS_I2C) {
			struct i2c_client *client = v4l2_get_subdevdata(sd);

			/* We need to unregister the i2c client explicitly.
			   We cannot rely on i2c_del_adapter to always
			   unregister clients for us, since if the i2c bus
			   is a platform bus, then it is never deleted. */
			if (client)
				i2c_unregister_device(client);
103
			continue;
104
		}
105 106 107 108 109 110 111
#endif
#if defined(CONFIG_SPI)
		if (sd->flags & V4L2_SUBDEV_FL_IS_SPI) {
			struct spi_device *spi = v4l2_get_subdevdata(sd);

			if (spi)
				spi_unregister_device(spi);
112
			continue;
113
		}
114
#endif
115
	}
116 117 118
}
EXPORT_SYMBOL_GPL(v4l2_device_unregister);

119 120
int v4l2_device_register_subdev(struct v4l2_device *v4l2_dev,
						struct v4l2_subdev *sd)
121
{
122 123
	int err;

124
	/* Check for valid input */
125
	if (v4l2_dev == NULL || sd == NULL || !sd->name[0])
126
		return -EINVAL;
127

128
	/* Warn if we apparently re-register a subdev */
129
	WARN_ON(sd->v4l2_dev != NULL);
130

131 132
	if (!try_module_get(sd->owner))
		return -ENODEV;
133

134 135 136 137 138 139
	sd->v4l2_dev = v4l2_dev;
	if (sd->internal_ops && sd->internal_ops->registered) {
		err = sd->internal_ops->registered(sd);
		if (err)
			return err;
	}
140

141 142
	/* This just returns 0 if either of the two args is NULL */
	err = v4l2_ctrl_add_handler(v4l2_dev->ctrl_handler, sd->ctrl_handler);
143 144 145
	if (err) {
		if (sd->internal_ops && sd->internal_ops->unregistered)
			sd->internal_ops->unregistered(sd);
146
		return err;
147
	}
148

149 150 151
	spin_lock(&v4l2_dev->lock);
	list_add_tail(&sd->list, &v4l2_dev->subdevs);
	spin_unlock(&v4l2_dev->lock);
152

153 154 155 156
	return 0;
}
EXPORT_SYMBOL_GPL(v4l2_device_register_subdev);

157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
int v4l2_device_register_subdev_nodes(struct v4l2_device *v4l2_dev)
{
	struct video_device *vdev;
	struct v4l2_subdev *sd;
	int err;

	/* Register a device node for every subdev marked with the
	 * V4L2_SUBDEV_FL_HAS_DEVNODE flag.
	 */
	list_for_each_entry(sd, &v4l2_dev->subdevs, list) {
		if (!(sd->flags & V4L2_SUBDEV_FL_HAS_DEVNODE))
			continue;

		vdev = &sd->devnode;
		strlcpy(vdev->name, sd->name, sizeof(vdev->name));
		vdev->v4l2_dev = v4l2_dev;
		vdev->fops = &v4l2_subdev_fops;
		vdev->release = video_device_release_empty;
		err = __video_register_device(vdev, VFL_TYPE_SUBDEV, -1, 1,
					      sd->owner);
		if (err < 0)
			return err;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(v4l2_device_register_subdev_nodes);

185 186 187
void v4l2_device_unregister_subdev(struct v4l2_subdev *sd)
{
	/* return if it isn't registered */
188
	if (sd == NULL || sd->v4l2_dev == NULL)
189
		return;
190

191
	spin_lock(&sd->v4l2_dev->lock);
192
	list_del(&sd->list);
193
	spin_unlock(&sd->v4l2_dev->lock);
194 195
	if (sd->internal_ops && sd->internal_ops->unregistered)
		sd->internal_ops->unregistered(sd);
196
	sd->v4l2_dev = NULL;
197 198

	video_unregister_device(&sd->devnode);
199 200 201
	module_put(sd->owner);
}
EXPORT_SYMBOL_GPL(v4l2_device_unregister_subdev);
新手
引导
客服 返回
顶部