[deliverable/linux.git] / drivers / media / video / v4l2-device.c

/*
    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>
#if defined(CONFIG_SPI)
#include <linux/spi/spi.h>
#endif
#include <linux/videodev2.h>
#include <media/v4l2-device.h>

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

	INIT_LIST_HEAD(&v4l2_dev->subdevs);
	spin_lock_init(&v4l2_dev->lock);
	v4l2_dev->dev = dev;
	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",
			dev->driver->name, dev_name(dev));
	if (dev_get_drvdata(dev))
		v4l2_warn(v4l2_dev, "Non-NULL drvdata on register\n");
	dev_set_drvdata(dev, v4l2_dev);
	return 0;
}
EXPORT_SYMBOL_GPL(v4l2_device_register);

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);

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);

void v4l2_device_unregister(struct v4l2_device *v4l2_dev)
{
	struct v4l2_subdev *sd, *next;

	if (v4l2_dev == NULL)
		return;
	v4l2_device_disconnect(v4l2_dev);

	/* Unregister subdevs */
	list_for_each_entry_safe(sd, next, &v4l2_dev->subdevs, list) {
		v4l2_device_unregister_subdev(sd);
#if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
		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);
		}
#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);
		}
#endif
	}
}
EXPORT_SYMBOL_GPL(v4l2_device_unregister);

int v4l2_device_register_subdev(struct v4l2_device *v4l2_dev,
						struct v4l2_subdev *sd)
{
	/* Check for valid input */
	if (v4l2_dev == NULL || sd == NULL || !sd->name[0])
		return -EINVAL;
	/* Warn if we apparently re-register a subdev */
	WARN_ON(sd->v4l2_dev != NULL);
	if (!try_module_get(sd->owner))
		return -ENODEV;
	sd->v4l2_dev = v4l2_dev;
	spin_lock(&v4l2_dev->lock);
	list_add_tail(&sd->list, &v4l2_dev->subdevs);
	spin_unlock(&v4l2_dev->lock);
	return 0;
}
EXPORT_SYMBOL_GPL(v4l2_device_register_subdev);

void v4l2_device_unregister_subdev(struct v4l2_subdev *sd)
{
	/* return if it isn't registered */
	if (sd == NULL || sd->v4l2_dev == NULL)
		return;
	spin_lock(&sd->v4l2_dev->lock);
	list_del(&sd->list);
	spin_unlock(&sd->v4l2_dev->lock);
	sd->v4l2_dev = NULL;
	module_put(sd->owner);
}
EXPORT_SYMBOL_GPL(v4l2_device_unregister_subdev);
Commit	Line	Data
2a1fcdf0 HV	1	/*
	2	V4L2 device support.
	3
	4	Copyright (C) 2008 Hans Verkuil <hverkuil@xs4all.nl>
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*/
	20
	21	#include <linux/types.h>
	22	#include <linux/ioctl.h>
	23	#include <linux/i2c.h>
85e09219 DB	24	#if defined(CONFIG_SPI)
	25	#include <linux/spi/spi.h>
	26	#endif
2a1fcdf0 HV	27	#include <linux/videodev2.h>
	28	#include <media/v4l2-device.h>
	29
	30	int v4l2_device_register(struct device dev, struct v4l2_device v4l2_dev)
	31	{
3a63e449	32	if (v4l2_dev == NULL)
2a1fcdf0	33	return -EINVAL;
3a63e449	34
2a1fcdf0 HV	35	INIT_LIST_HEAD(&v4l2_dev->subdevs);
	36	spin_lock_init(&v4l2_dev->lock);
	37	v4l2_dev->dev = dev;
3a63e449 HV	38	if (dev == NULL) {
	39	/* If dev == NULL, then name must be filled in by the caller */
	40	WARN_ON(!v4l2_dev->name[0]);
	41	return 0;
	42	}
	43
	44	/* Set name to driver name + device name if it is empty. */
	45	if (!v4l2_dev->name[0])
	46	snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "%s %s",
c3ef01ce	47	dev->driver->name, dev_name(dev));
3a63e449 HV	48	if (dev_get_drvdata(dev))
3a63e449 HV	49	v4l2_warn(v4l2_dev, "Non-NULL drvdata on register\n");
2a1fcdf0 HV	50	dev_set_drvdata(dev, v4l2_dev);
	51	return 0;
	52	}
	53	EXPORT_SYMBOL_GPL(v4l2_device_register);
	54
102e7813 HV	55	int v4l2_device_set_name(struct v4l2_device v4l2_dev, const char basename,
	56	atomic_t *instance)
	57	{
	58	int num = atomic_inc_return(instance) - 1;
	59	int len = strlen(basename);
	60
	61	if (basename[len - 1] >= '0' && basename[len - 1] <= '9')
	62	snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
	63	"%s-%d", basename, num);
	64	else
	65	snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
	66	"%s%d", basename, num);
	67	return num;
	68	}
	69	EXPORT_SYMBOL_GPL(v4l2_device_set_name);
	70
ae6cfaac HV	71	void v4l2_device_disconnect(struct v4l2_device *v4l2_dev)
	72	{
	73	if (v4l2_dev->dev) {
	74	dev_set_drvdata(v4l2_dev->dev, NULL);
	75	v4l2_dev->dev = NULL;
	76	}
	77	}
	78	EXPORT_SYMBOL_GPL(v4l2_device_disconnect);
	79
2a1fcdf0 HV	80	void v4l2_device_unregister(struct v4l2_device *v4l2_dev)
	81	{
	82	struct v4l2_subdev sd, next;
	83
3a63e449	84	if (v4l2_dev == NULL)
2a1fcdf0	85	return;
ae6cfaac HV	86	v4l2_device_disconnect(v4l2_dev);
ae6cfaac HV	87
3a63e449	88	/* Unregister subdevs */
b5b2b7ed	89	list_for_each_entry_safe(sd, next, &v4l2_dev->subdevs, list) {
2a1fcdf0	90	v4l2_device_unregister_subdev(sd);
ef5b5168	91	#if defined(CONFIG_I2C) \|\| (defined(CONFIG_I2C_MODULE) && defined(MODULE))
b5b2b7ed HV	92	if (sd->flags & V4L2_SUBDEV_FL_IS_I2C) {
	93	struct i2c_client *client = v4l2_get_subdevdata(sd);
	94
	95	/* We need to unregister the i2c client explicitly.
	96	We cannot rely on i2c_del_adapter to always
	97	unregister clients for us, since if the i2c bus
	98	is a platform bus, then it is never deleted. */
	99	if (client)
	100	i2c_unregister_device(client);
	101	}
85e09219 DB	102	#endif
	103	#if defined(CONFIG_SPI)
	104	if (sd->flags & V4L2_SUBDEV_FL_IS_SPI) {
	105	struct spi_device *spi = v4l2_get_subdevdata(sd);
	106
	107	if (spi)
	108	spi_unregister_device(spi);
	109	}
b7fd6067	110	#endif
b5b2b7ed	111	}
2a1fcdf0 HV	112	}
	113	EXPORT_SYMBOL_GPL(v4l2_device_unregister);
	114
3a63e449 HV	115	int v4l2_device_register_subdev(struct v4l2_device *v4l2_dev,
3a63e449 HV	116	struct v4l2_subdev *sd)
2a1fcdf0 HV	117	{
2a1fcdf0 HV	118	/* Check for valid input */
3a63e449	119	if (v4l2_dev == NULL \|\| sd == NULL \|\| !sd->name[0])
2a1fcdf0 HV	120	return -EINVAL;
2a1fcdf0 HV	121	/* Warn if we apparently re-register a subdev */
b0167600	122	WARN_ON(sd->v4l2_dev != NULL);
2a1fcdf0 HV	123	if (!try_module_get(sd->owner))
2a1fcdf0 HV	124	return -ENODEV;
b0167600	125	sd->v4l2_dev = v4l2_dev;
3a63e449 HV	126	spin_lock(&v4l2_dev->lock);
	127	list_add_tail(&sd->list, &v4l2_dev->subdevs);
	128	spin_unlock(&v4l2_dev->lock);
2a1fcdf0 HV	129	return 0;
	130	}
	131	EXPORT_SYMBOL_GPL(v4l2_device_register_subdev);
	132
	133	void v4l2_device_unregister_subdev(struct v4l2_subdev *sd)
	134	{
	135	/* return if it isn't registered */
b0167600	136	if (sd == NULL \|\| sd->v4l2_dev == NULL)
2a1fcdf0	137	return;
b0167600	138	spin_lock(&sd->v4l2_dev->lock);
2a1fcdf0	139	list_del(&sd->list);
b0167600 HV	140	spin_unlock(&sd->v4l2_dev->lock);
b0167600 HV	141	sd->v4l2_dev = NULL;
2a1fcdf0 HV	142	module_put(sd->owner);
	143	}
	144	EXPORT_SYMBOL_GPL(v4l2_device_unregister_subdev);