[deliverable/linux.git] / drivers / media / v4l2-core / v4l2-common.c

/*
 *	Video for Linux Two
 *
 *	A generic video device interface for the LINUX operating system
 *	using a set of device structures/vectors for low level operations.
 *
 *	This file replaces the videodev.c file that comes with the
 *	regular kernel distribution.
 *
 *	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.
 *
 * Author:	Bill Dirks <bill@thedirks.org>
 *		based on code by Alan Cox, <alan@cymru.net>
 *
 */

/*
 * Video capture interface for Linux
 *
 *	A generic video device interface for the LINUX operating system
 *	using a set of device structures/vectors for low level operations.
 *
 *		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.
 *
 * Author:	Alan Cox, <alan@lxorguk.ukuu.org.uk>
 *
 * Fixes:
 */

/*
 * Video4linux 1/2 integration by Justin Schoeman
 * <justin@suntiger.ee.up.ac.za>
 * 2.4 PROCFS support ported from 2.4 kernels by
 *  Iñaki García Etxebarria <garetxe@euskalnet.net>
 * Makefile fix by "W. Michael Petullo" <mike@flyn.org>
 * 2.4 devfs support ported from 2.4 kernels by
 *  Dan Merillat <dan@merillat.org>
 * Added Gerd Knorrs v4l1 enhancements (Justin Schoeman)
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/i2c.h>
#if defined(CONFIG_SPI)
#include <linux/spi/spi.h>
#endif
#include <asm/uaccess.h>
#include <asm/pgtable.h>
#include <asm/io.h>
#include <asm/div64.h>
#include <media/v4l2-common.h>
#include <media/v4l2-device.h>
#include <media/v4l2-ctrls.h>

#include <linux/videodev2.h>

MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
MODULE_LICENSE("GPL");

/*
 *
 *	V 4 L 2   D R I V E R   H E L P E R   A P I
 *
 */

/*
 *  Video Standard Operations (contributed by Michael Schimek)
 */

/* Helper functions for control handling			     */

/* Check for correctness of the ctrl's value based on the data from
   struct v4l2_queryctrl and the available menu items. Note that
   menu_items may be NULL, in that case it is ignored. */
int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
		const char * const *menu_items)
{
	if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
		return -EINVAL;
	if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
		return -EBUSY;
	if (qctrl->type == V4L2_CTRL_TYPE_STRING)
		return 0;
	if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
	    qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
	    qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
		return 0;
	if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
		return -ERANGE;
	if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
		if (menu_items[ctrl->value] == NULL ||
		    menu_items[ctrl->value][0] == '\0')
			return -EINVAL;
	}
	if (qctrl->type == V4L2_CTRL_TYPE_BITMASK &&
			(ctrl->value & ~qctrl->maximum))
		return -ERANGE;
	return 0;
}
EXPORT_SYMBOL(v4l2_ctrl_check);

/* Fill in a struct v4l2_queryctrl */
int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
{
	const char *name;

	v4l2_ctrl_fill(qctrl->id, &name, &qctrl->type,
		       &min, &max, &step, &def, &qctrl->flags);

	if (name == NULL)
		return -EINVAL;

	qctrl->minimum = min;
	qctrl->maximum = max;
	qctrl->step = step;
	qctrl->default_value = def;
	qctrl->reserved[0] = qctrl->reserved[1] = 0;
	strlcpy(qctrl->name, name, sizeof(qctrl->name));
	return 0;
}
EXPORT_SYMBOL(v4l2_ctrl_query_fill);

/* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
   the menu. The qctrl pointer may be NULL, in which case it is ignored.
   If menu_items is NULL, then the menu items are retrieved using
   v4l2_ctrl_get_menu. */
int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
	       const char * const *menu_items)
{
	int i;

	qmenu->reserved = 0;
	if (menu_items == NULL)
		menu_items = v4l2_ctrl_get_menu(qmenu->id);
	if (menu_items == NULL ||
	    (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
		return -EINVAL;
	for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
	if (menu_items[i] == NULL || menu_items[i][0] == '\0')
		return -EINVAL;
	strlcpy(qmenu->name, menu_items[qmenu->index], sizeof(qmenu->name));
	return 0;
}
EXPORT_SYMBOL(v4l2_ctrl_query_menu);

/* Fill in a struct v4l2_querymenu based on the specified array of valid
   menu items (terminated by V4L2_CTRL_MENU_IDS_END).
   Use this if there are 'holes' in the list of valid menu items. */
int v4l2_ctrl_query_menu_valid_items(struct v4l2_querymenu *qmenu, const u32 *ids)
{
	const char * const *menu_items = v4l2_ctrl_get_menu(qmenu->id);

	qmenu->reserved = 0;
	if (menu_items == NULL || ids == NULL)
		return -EINVAL;
	while (*ids != V4L2_CTRL_MENU_IDS_END) {
		if (*ids++ == qmenu->index) {
			strlcpy(qmenu->name, menu_items[qmenu->index],
					sizeof(qmenu->name));
			return 0;
		}
	}
	return -EINVAL;
}
EXPORT_SYMBOL(v4l2_ctrl_query_menu_valid_items);

/* ctrl_classes points to an array of u32 pointers, the last element is
   a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
   Each array must be sorted low to high and belong to the same control
   class. The array of u32 pointers must also be sorted, from low class IDs
   to high class IDs.

   This function returns the first ID that follows after the given ID.
   When no more controls are available 0 is returned. */
u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
{
	u32 ctrl_class = V4L2_CTRL_ID2CLASS(id);
	const u32 *pctrl;

	if (ctrl_classes == NULL)
		return 0;

	/* if no query is desired, then check if the ID is part of ctrl_classes */
	if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) {
		/* find class */
		while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) != ctrl_class)
			ctrl_classes++;
		if (*ctrl_classes == NULL)
			return 0;
		pctrl = *ctrl_classes;
		/* find control ID */
		while (*pctrl && *pctrl != id) pctrl++;
		return *pctrl ? id : 0;
	}
	id &= V4L2_CTRL_ID_MASK;
	id++;	/* select next control */
	/* find first class that matches (or is greater than) the class of
	   the ID */
	while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
		ctrl_classes++;
	/* no more classes */
	if (*ctrl_classes == NULL)
		return 0;
	pctrl = *ctrl_classes;
	/* find first ctrl within the class that is >= ID */
	while (*pctrl && *pctrl < id) pctrl++;
	if (*pctrl)
		return *pctrl;
	/* we are at the end of the controls of the current class. */
	/* continue with next class if available */
	ctrl_classes++;
	if (*ctrl_classes == NULL)
		return 0;
	return **ctrl_classes;
}
EXPORT_SYMBOL(v4l2_ctrl_next);

/* I2C Helper functions */

#if IS_ENABLED(CONFIG_I2C)

void v4l2_i2c_subdev_init(struct v4l2_subdev *sd, struct i2c_client *client,
		const struct v4l2_subdev_ops *ops)
{
	v4l2_subdev_init(sd, ops);
	sd->flags |= V4L2_SUBDEV_FL_IS_I2C;
	/* the owner is the same as the i2c_client's driver owner */
	sd->owner = client->dev.driver->owner;
	sd->dev = &client->dev;
	/* i2c_client and v4l2_subdev point to one another */
	v4l2_set_subdevdata(sd, client);
	i2c_set_clientdata(client, sd);
	/* initialize name */
	snprintf(sd->name, sizeof(sd->name), "%s %d-%04x",
		client->dev.driver->name, i2c_adapter_id(client->adapter),
		client->addr);
}
EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init);

/* Load an i2c sub-device. */
struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev,
		struct i2c_adapter *adapter, struct i2c_board_info *info,
		const unsigned short *probe_addrs)
{
	struct v4l2_subdev *sd = NULL;
	struct i2c_client *client;

	BUG_ON(!v4l2_dev);

	request_module(I2C_MODULE_PREFIX "%s", info->type);

	/* Create the i2c client */
	if (info->addr == 0 && probe_addrs)
		client = i2c_new_probed_device(adapter, info, probe_addrs,
					       NULL);
	else
		client = i2c_new_device(adapter, info);

	/* Note: by loading the module first we are certain that c->driver
	   will be set if the driver was found. If the module was not loaded
	   first, then the i2c core tries to delay-load the module for us,
	   and then c->driver is still NULL until the module is finally
	   loaded. This delay-load mechanism doesn't work if other drivers
	   want to use the i2c device, so explicitly loading the module
	   is the best alternative. */
	if (client == NULL || client->dev.driver == NULL)
		goto error;

	/* Lock the module so we can safely get the v4l2_subdev pointer */
	if (!try_module_get(client->dev.driver->owner))
		goto error;
	sd = i2c_get_clientdata(client);

	/* Register with the v4l2_device which increases the module's
	   use count as well. */
	if (v4l2_device_register_subdev(v4l2_dev, sd))
		sd = NULL;
	/* Decrease the module use count to match the first try_module_get. */
	module_put(client->dev.driver->owner);

error:
	/* If we have a client but no subdev, then something went wrong and
	   we must unregister the client. */
	if (client && sd == NULL)
		i2c_unregister_device(client);
	return sd;
}
EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_board);

struct v4l2_subdev *v4l2_i2c_new_subdev(struct v4l2_device *v4l2_dev,
		struct i2c_adapter *adapter, const char *client_type,
		u8 addr, const unsigned short *probe_addrs)
{
	struct i2c_board_info info;

	/* Setup the i2c board info with the device type and
	   the device address. */
	memset(&info, 0, sizeof(info));
	strlcpy(info.type, client_type, sizeof(info.type));
	info.addr = addr;

	return v4l2_i2c_new_subdev_board(v4l2_dev, adapter, &info, probe_addrs);
}
EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev);

/* Return i2c client address of v4l2_subdev. */
unsigned short v4l2_i2c_subdev_addr(struct v4l2_subdev *sd)
{
	struct i2c_client *client = v4l2_get_subdevdata(sd);

	return client ? client->addr : I2C_CLIENT_END;
}
EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_addr);

/* Return a list of I2C tuner addresses to probe. Use only if the tuner
   addresses are unknown. */
const unsigned short *v4l2_i2c_tuner_addrs(enum v4l2_i2c_tuner_type type)
{
	static const unsigned short radio_addrs[] = {
#if IS_ENABLED(CONFIG_MEDIA_TUNER_TEA5761)
		0x10,
#endif
		0x60,
		I2C_CLIENT_END
	};
	static const unsigned short demod_addrs[] = {
		0x42, 0x43, 0x4a, 0x4b,
		I2C_CLIENT_END
	};
	static const unsigned short tv_addrs[] = {
		0x42, 0x43, 0x4a, 0x4b,		/* tda8290 */
		0x60, 0x61, 0x62, 0x63, 0x64,
		I2C_CLIENT_END
	};

	switch (type) {
	case ADDRS_RADIO:
		return radio_addrs;
	case ADDRS_DEMOD:
		return demod_addrs;
	case ADDRS_TV:
		return tv_addrs;
	case ADDRS_TV_WITH_DEMOD:
		return tv_addrs + 4;
	}
	return NULL;
}
EXPORT_SYMBOL_GPL(v4l2_i2c_tuner_addrs);

#endif /* defined(CONFIG_I2C) */

#if defined(CONFIG_SPI)

/* Load an spi sub-device. */

void v4l2_spi_subdev_init(struct v4l2_subdev *sd, struct spi_device *spi,
		const struct v4l2_subdev_ops *ops)
{
	v4l2_subdev_init(sd, ops);
	sd->flags |= V4L2_SUBDEV_FL_IS_SPI;
	/* the owner is the same as the spi_device's driver owner */
	sd->owner = spi->dev.driver->owner;
	sd->dev = &spi->dev;
	/* spi_device and v4l2_subdev point to one another */
	v4l2_set_subdevdata(sd, spi);
	spi_set_drvdata(spi, sd);
	/* initialize name */
	strlcpy(sd->name, spi->dev.driver->name, sizeof(sd->name));
}
EXPORT_SYMBOL_GPL(v4l2_spi_subdev_init);

struct v4l2_subdev *v4l2_spi_new_subdev(struct v4l2_device *v4l2_dev,
		struct spi_master *master, struct spi_board_info *info)
{
	struct v4l2_subdev *sd = NULL;
	struct spi_device *spi = NULL;

	BUG_ON(!v4l2_dev);

	if (info->modalias[0])
		request_module(info->modalias);

	spi = spi_new_device(master, info);

	if (spi == NULL || spi->dev.driver == NULL)
		goto error;

	if (!try_module_get(spi->dev.driver->owner))
		goto error;

	sd = spi_get_drvdata(spi);

	/* Register with the v4l2_device which increases the module's
	   use count as well. */
	if (v4l2_device_register_subdev(v4l2_dev, sd))
		sd = NULL;

	/* Decrease the module use count to match the first try_module_get. */
	module_put(spi->dev.driver->owner);

error:
	/* If we have a client but no subdev, then something went wrong and
	   we must unregister the client. */
	if (spi && sd == NULL)
		spi_unregister_device(spi);

	return sd;
}
EXPORT_SYMBOL_GPL(v4l2_spi_new_subdev);

#endif /* defined(CONFIG_SPI) */

/* Clamp x to be between min and max, aligned to a multiple of 2^align.  min
 * and max don't have to be aligned, but there must be at least one valid
 * value.  E.g., min=17,max=31,align=4 is not allowed as there are no multiples
 * of 16 between 17 and 31.  */
static unsigned int clamp_align(unsigned int x, unsigned int min,
				unsigned int max, unsigned int align)
{
	/* Bits that must be zero to be aligned */
	unsigned int mask = ~((1 << align) - 1);

	/* Round to nearest aligned value */
	if (align)
		x = (x + (1 << (align - 1))) & mask;

	/* Clamp to aligned value of min and max */
	if (x < min)
		x = (min + ~mask) & mask;
	else if (x > max)
		x = max & mask;

	return x;
}

/* Bound an image to have a width between wmin and wmax, and height between
 * hmin and hmax, inclusive.  Additionally, the width will be a multiple of
 * 2^walign, the height will be a multiple of 2^halign, and the overall size
 * (width*height) will be a multiple of 2^salign.  The image may be shrunk
 * or enlarged to fit the alignment constraints.
 *
 * The width or height maximum must not be smaller than the corresponding
 * minimum.  The alignments must not be so high there are no possible image
 * sizes within the allowed bounds.  wmin and hmin must be at least 1
 * (don't use 0).  If you don't care about a certain alignment, specify 0,
 * as 2^0 is 1 and one byte alignment is equivalent to no alignment.  If
 * you only want to adjust downward, specify a maximum that's the same as
 * the initial value.
 */
void v4l_bound_align_image(u32 *w, unsigned int wmin, unsigned int wmax,
			   unsigned int walign,
			   u32 *h, unsigned int hmin, unsigned int hmax,
			   unsigned int halign, unsigned int salign)
{
	*w = clamp_align(*w, wmin, wmax, walign);
	*h = clamp_align(*h, hmin, hmax, halign);

	/* Usually we don't need to align the size and are done now. */
	if (!salign)
		return;

	/* How much alignment do we have? */
	walign = __ffs(*w);
	halign = __ffs(*h);
	/* Enough to satisfy the image alignment? */
	if (walign + halign < salign) {
		/* Max walign where there is still a valid width */
		unsigned int wmaxa = __fls(wmax ^ (wmin - 1));
		/* Max halign where there is still a valid height */
		unsigned int hmaxa = __fls(hmax ^ (hmin - 1));

		/* up the smaller alignment until we have enough */
		do {
			if (halign >= hmaxa ||
			    (walign <= halign && walign < wmaxa)) {
				*w = clamp_align(*w, wmin, wmax, walign + 1);
				walign = __ffs(*w);
			} else {
				*h = clamp_align(*h, hmin, hmax, halign + 1);
				halign = __ffs(*h);
			}
		} while (halign + walign < salign);
	}
}
EXPORT_SYMBOL_GPL(v4l_bound_align_image);

const struct v4l2_frmsize_discrete *v4l2_find_nearest_format(
		const struct v4l2_discrete_probe *probe,
		s32 width, s32 height)
{
	int i;
	u32 error, min_error = UINT_MAX;
	const struct v4l2_frmsize_discrete *size, *best = NULL;

	if (!probe)
		return best;

	for (i = 0, size = probe->sizes; i < probe->num_sizes; i++, size++) {
		error = abs(size->width - width) + abs(size->height - height);
		if (error < min_error) {
			min_error = error;
			best = size;
		}
		if (!error)
			break;
	}

	return best;
}
EXPORT_SYMBOL_GPL(v4l2_find_nearest_format);

void v4l2_get_timestamp(struct timeval *tv)
{
	struct timespec ts;

	ktime_get_ts(&ts);
	tv->tv_sec = ts.tv_sec;
	tv->tv_usec = ts.tv_nsec / NSEC_PER_USEC;
}
EXPORT_SYMBOL_GPL(v4l2_get_timestamp);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Video for Linux Two
	3	*
	4	* A generic video device interface for the LINUX operating system
	5	* using a set of device structures/vectors for low level operations.
	6	*
	7	* This file replaces the videodev.c file that comes with the
	8	* regular kernel distribution.
	9	*
	10	* This program is free software; you can redistribute it and/or
	11	* modify it under the terms of the GNU General Public License
	12	* as published by the Free Software Foundation; either version
	13	* 2 of the License, or (at your option) any later version.
	14	*
43db48d3	15	* Author: Bill Dirks <bill@thedirks.org>
1da177e4 LT	16	* based on code by Alan Cox, <alan@cymru.net>
	17	*
	18	*/
	19
	20	/*
	21	* Video capture interface for Linux
	22	*
	23	* A generic video device interface for the LINUX operating system
	24	* using a set of device structures/vectors for low level operations.
	25	*
	26	* This program is free software; you can redistribute it and/or
	27	* modify it under the terms of the GNU General Public License
	28	* as published by the Free Software Foundation; either version
	29	* 2 of the License, or (at your option) any later version.
	30	*
d9b01449	31	* Author: Alan Cox, <alan@lxorguk.ukuu.org.uk>
1da177e4 LT	32	*
	33	* Fixes:
	34	*/
	35
	36	/*
	37	* Video4linux 1/2 integration by Justin Schoeman
	38	* <justin@suntiger.ee.up.ac.za>
	39	* 2.4 PROCFS support ported from 2.4 kernels by
96de0e25	40	* Iñaki García Etxebarria <garetxe@euskalnet.net>
1da177e4 LT	41	* Makefile fix by "W. Michael Petullo" <mike@flyn.org>
	42	* 2.4 devfs support ported from 2.4 kernels by
	43	* Dan Merillat <dan@merillat.org>
	44	* Added Gerd Knorrs v4l1 enhancements (Justin Schoeman)
	45	*/
	46
1da177e4 LT	47	#include <linux/module.h>
	48	#include <linux/types.h>
	49	#include <linux/kernel.h>
1da177e4 LT	50	#include <linux/mm.h>
	51	#include <linux/string.h>
	52	#include <linux/errno.h>
f3d092b8	53	#include <linux/i2c.h>
85e09219 DB	54	#if defined(CONFIG_SPI)
	55	#include <linux/spi/spi.h>
	56	#endif
1da177e4	57	#include <asm/uaccess.h>
1da177e4 LT	58	#include <asm/pgtable.h>
	59	#include <asm/io.h>
	60	#include <asm/div64.h>
5e453dc7	61	#include <media/v4l2-common.h>
dd99120c	62	#include <media/v4l2-device.h>
0996517c	63	#include <media/v4l2-ctrls.h>
1da177e4	64
33b687cf	65	#include <linux/videodev2.h>
1da177e4 LT	66
	67	MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
	68	MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
	69	MODULE_LICENSE("GPL");
	70
	71	/*
	72	*
	73	* V 4 L 2 D R I V E R H E L P E R A P I
	74	*
	75	*/
	76
	77	/*
	78	* Video Standard Operations (contributed by Michael Schimek)
	79	*/
	80
9cb2318b HV	81	/* Helper functions for control handling */
	82
	83	/* Check for correctness of the ctrl's value based on the data from
	84	struct v4l2_queryctrl and the available menu items. Note that
	85	menu_items may be NULL, in that case it is ignored. */
	86	int v4l2_ctrl_check(struct v4l2_ext_control ctrl, struct v4l2_queryctrl qctrl,
513521ea	87	const char * const *menu_items)
9cb2318b HV	88	{
	89	if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
	90	return -EINVAL;
	91	if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
	92	return -EBUSY;
6b5a9492 HV	93	if (qctrl->type == V4L2_CTRL_TYPE_STRING)
6b5a9492 HV	94	return 0;
9cb2318b HV	95	if (qctrl->type == V4L2_CTRL_TYPE_BUTTON \|\|
	96	qctrl->type == V4L2_CTRL_TYPE_INTEGER64 \|\|
	97	qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
	98	return 0;
	99	if (ctrl->value < qctrl->minimum \|\| ctrl->value > qctrl->maximum)
	100	return -ERANGE;
	101	if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
	102	if (menu_items[ctrl->value] == NULL \|\|
	103	menu_items[ctrl->value][0] == '\0')
	104	return -EINVAL;
	105	}
fa4d7096 HV	106	if (qctrl->type == V4L2_CTRL_TYPE_BITMASK &&
	107	(ctrl->value & ~qctrl->maximum))
	108	return -ERANGE;
9cb2318b HV	109	return 0;
9cb2318b HV	110	}
057596ee	111	EXPORT_SYMBOL(v4l2_ctrl_check);
9cb2318b	112
69028d70 HV	113	/* Fill in a struct v4l2_queryctrl */
	114	int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
	115	{
0996517c HV	116	const char *name;
	117
	118	v4l2_ctrl_fill(qctrl->id, &name, &qctrl->type,
	119	&min, &max, &step, &def, &qctrl->flags);
69028d70	120
69028d70 HV	121	if (name == NULL)
	122	return -EINVAL;
	123
9cb2318b HV	124	qctrl->minimum = min;
	125	qctrl->maximum = max;
	126	qctrl->step = step;
	127	qctrl->default_value = def;
	128	qctrl->reserved[0] = qctrl->reserved[1] = 0;
b634a93f	129	strlcpy(qctrl->name, name, sizeof(qctrl->name));
9cb2318b HV	130	return 0;
9cb2318b HV	131	}
057596ee	132	EXPORT_SYMBOL(v4l2_ctrl_query_fill);
9cb2318b	133
9cb2318b	134	/* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
e281db58 HV	135	the menu. The qctrl pointer may be NULL, in which case it is ignored.
	136	If menu_items is NULL, then the menu items are retrieved using
	137	v4l2_ctrl_get_menu. */
9cb2318b	138	int v4l2_ctrl_query_menu(struct v4l2_querymenu qmenu, struct v4l2_queryctrl qctrl,
513521ea	139	const char * const *menu_items)
9cb2318b HV	140	{
	141	int i;
	142
1e551266	143	qmenu->reserved = 0;
e281db58 HV	144	if (menu_items == NULL)
e281db58 HV	145	menu_items = v4l2_ctrl_get_menu(qmenu->id);
9cb2318b HV	146	if (menu_items == NULL \|\|
	147	(qctrl && (qmenu->index < qctrl->minimum \|\| qmenu->index > qctrl->maximum)))
	148	return -EINVAL;
	149	for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
	150	if (menu_items[i] == NULL \|\| menu_items[i][0] == '\0')
	151	return -EINVAL;
b634a93f	152	strlcpy(qmenu->name, menu_items[qmenu->index], sizeof(qmenu->name));
9cb2318b HV	153	return 0;
9cb2318b HV	154	}
057596ee	155	EXPORT_SYMBOL(v4l2_ctrl_query_menu);
9cb2318b	156
1e551266 HV	157	/* Fill in a struct v4l2_querymenu based on the specified array of valid
	158	menu items (terminated by V4L2_CTRL_MENU_IDS_END).
	159	Use this if there are 'holes' in the list of valid menu items. */
	160	int v4l2_ctrl_query_menu_valid_items(struct v4l2_querymenu qmenu, const u32 ids)
	161	{
513521ea	162	const char * const *menu_items = v4l2_ctrl_get_menu(qmenu->id);
1e551266 HV	163
	164	qmenu->reserved = 0;
	165	if (menu_items == NULL \|\| ids == NULL)
	166	return -EINVAL;
	167	while (*ids != V4L2_CTRL_MENU_IDS_END) {
	168	if (*ids++ == qmenu->index) {
b634a93f HV	169	strlcpy(qmenu->name, menu_items[qmenu->index],
b634a93f HV	170	sizeof(qmenu->name));
1e551266 HV	171	return 0;
	172	}
	173	}
	174	return -EINVAL;
	175	}
	176	EXPORT_SYMBOL(v4l2_ctrl_query_menu_valid_items);
	177
9cb2318b HV	178	/* ctrl_classes points to an array of u32 pointers, the last element is
	179	a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
	180	Each array must be sorted low to high and belong to the same control
2ba58894	181	class. The array of u32 pointers must also be sorted, from low class IDs
9cb2318b HV	182	to high class IDs.
	183
	184	This function returns the first ID that follows after the given ID.
	185	When no more controls are available 0 is returned. */
	186	u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
	187	{
a46c5fbc	188	u32 ctrl_class = V4L2_CTRL_ID2CLASS(id);
9cb2318b HV	189	const u32 *pctrl;
9cb2318b HV	190
9cb2318b HV	191	if (ctrl_classes == NULL)
9cb2318b HV	192	return 0;
a46c5fbc HV	193
	194	/* if no query is desired, then check if the ID is part of ctrl_classes */
	195	if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) {
	196	/* find class */
	197	while (ctrl_classes && V4L2_CTRL_ID2CLASS(*ctrl_classes) != ctrl_class)
	198	ctrl_classes++;
	199	if (*ctrl_classes == NULL)
	200	return 0;
	201	pctrl = *ctrl_classes;
	202	/* find control ID */
	203	while (pctrl && pctrl != id) pctrl++;
	204	return *pctrl ? id : 0;
	205	}
9cb2318b	206	id &= V4L2_CTRL_ID_MASK;
9cb2318b HV	207	id++; /* select next control */
	208	/* find first class that matches (or is greater than) the class of
	209	the ID */
	210	while (ctrl_classes && V4L2_CTRL_ID2CLASS(*ctrl_classes) < ctrl_class)
	211	ctrl_classes++;
	212	/* no more classes */
	213	if (*ctrl_classes == NULL)
	214	return 0;
	215	pctrl = *ctrl_classes;
	216	/* find first ctrl within the class that is >= ID */
	217	while (pctrl && pctrl < id) pctrl++;
	218	if (*pctrl)
	219	return *pctrl;
	220	/* we are at the end of the controls of the current class. */
	221	/* continue with next class if available */
	222	ctrl_classes++;
	223	if (*ctrl_classes == NULL)
	224	return 0;
	225	return **ctrl_classes;
	226	}
057596ee	227	EXPORT_SYMBOL(v4l2_ctrl_next);
9cb2318b	228
78a3b4db	229	/* I2C Helper functions */
8ffbc655	230
aee38734	231	#if IS_ENABLED(CONFIG_I2C)
dd99120c HV	232
	233	void v4l2_i2c_subdev_init(struct v4l2_subdev sd, struct i2c_client client,
	234	const struct v4l2_subdev_ops *ops)
	235	{
	236	v4l2_subdev_init(sd, ops);
b5b2b7ed	237	sd->flags \|= V4L2_SUBDEV_FL_IS_I2C;
dd99120c	238	/* the owner is the same as the i2c_client's driver owner */
f9d32f25	239	sd->owner = client->dev.driver->owner;
668773b8	240	sd->dev = &client->dev;
dd99120c HV	241	/* i2c_client and v4l2_subdev point to one another */
	242	v4l2_set_subdevdata(sd, client);
	243	i2c_set_clientdata(client, sd);
	244	/* initialize name */
	245	snprintf(sd->name, sizeof(sd->name), "%s %d-%04x",
f9d32f25	246	client->dev.driver->name, i2c_adapter_id(client->adapter),
dd99120c HV	247	client->addr);
	248	}
	249	EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init);
	250
f0222c7d HV	251	/* Load an i2c sub-device. */
f0222c7d HV	252	struct v4l2_subdev v4l2_i2c_new_subdev_board(struct v4l2_device v4l2_dev,
9a1f8b34 LP	253	struct i2c_adapter adapter, struct i2c_board_info info,
9a1f8b34 LP	254	const unsigned short *probe_addrs)
f0222c7d HV	255	{
	256	struct v4l2_subdev *sd = NULL;
	257	struct i2c_client *client;
	258
	259	BUG_ON(!v4l2_dev);
	260
9a1f8b34	261	request_module(I2C_MODULE_PREFIX "%s", info->type);
f0222c7d HV	262
	263	/* Create the i2c client */
	264	if (info->addr == 0 && probe_addrs)
9a94241a JD	265	client = i2c_new_probed_device(adapter, info, probe_addrs,
9a94241a JD	266	NULL);
f0222c7d HV	267	else
	268	client = i2c_new_device(adapter, info);
	269
	270	/* Note: by loading the module first we are certain that c->driver
	271	will be set if the driver was found. If the module was not loaded
	272	first, then the i2c core tries to delay-load the module for us,
	273	and then c->driver is still NULL until the module is finally
	274	loaded. This delay-load mechanism doesn't work if other drivers
	275	want to use the i2c device, so explicitly loading the module
	276	is the best alternative. */
f9d32f25	277	if (client == NULL \|\| client->dev.driver == NULL)
f0222c7d HV	278	goto error;
	279
	280	/* Lock the module so we can safely get the v4l2_subdev pointer */
f9d32f25	281	if (!try_module_get(client->dev.driver->owner))
f0222c7d HV	282	goto error;
	283	sd = i2c_get_clientdata(client);
	284
	285	/* Register with the v4l2_device which increases the module's
	286	use count as well. */
	287	if (v4l2_device_register_subdev(v4l2_dev, sd))
	288	sd = NULL;
	289	/* Decrease the module use count to match the first try_module_get. */
f9d32f25	290	module_put(client->dev.driver->owner);
f0222c7d	291
f0222c7d HV	292	error:
	293	/* If we have a client but no subdev, then something went wrong and
	294	we must unregister the client. */
	295	if (client && sd == NULL)
	296	i2c_unregister_device(client);
	297	return sd;
	298	}
	299	EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_board);
	300
3c7c9370	301	struct v4l2_subdev v4l2_i2c_new_subdev(struct v4l2_device v4l2_dev,
9a1f8b34	302	struct i2c_adapter adapter, const char client_type,
f0222c7d HV	303	u8 addr, const unsigned short *probe_addrs)
	304	{
	305	struct i2c_board_info info;
	306
	307	/* Setup the i2c board info with the device type and
	308	the device address. */
	309	memset(&info, 0, sizeof(info));
	310	strlcpy(info.type, client_type, sizeof(info.type));
	311	info.addr = addr;
f0222c7d	312
9a1f8b34	313	return v4l2_i2c_new_subdev_board(v4l2_dev, adapter, &info, probe_addrs);
f0222c7d	314	}
3c7c9370	315	EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev);
f0222c7d	316
ab373190 HV	317	/* Return i2c client address of v4l2_subdev. */
	318	unsigned short v4l2_i2c_subdev_addr(struct v4l2_subdev *sd)
	319	{
	320	struct i2c_client *client = v4l2_get_subdevdata(sd);
	321
	322	return client ? client->addr : I2C_CLIENT_END;
	323	}
	324	EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_addr);
	325
c7d29e2f HV	326	/* Return a list of I2C tuner addresses to probe. Use only if the tuner
	327	addresses are unknown. */
	328	const unsigned short *v4l2_i2c_tuner_addrs(enum v4l2_i2c_tuner_type type)
	329	{
	330	static const unsigned short radio_addrs[] = {
ffe4db06	331	#if IS_ENABLED(CONFIG_MEDIA_TUNER_TEA5761)
c7d29e2f HV	332	0x10,
	333	#endif
	334	0x60,
	335	I2C_CLIENT_END
	336	};
	337	static const unsigned short demod_addrs[] = {
	338	0x42, 0x43, 0x4a, 0x4b,
	339	I2C_CLIENT_END
	340	};
	341	static const unsigned short tv_addrs[] = {
	342	0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
416a7aa8	343	0x60, 0x61, 0x62, 0x63, 0x64,
c7d29e2f HV	344	I2C_CLIENT_END
	345	};
	346
	347	switch (type) {
	348	case ADDRS_RADIO:
	349	return radio_addrs;
	350	case ADDRS_DEMOD:
	351	return demod_addrs;
	352	case ADDRS_TV:
	353	return tv_addrs;
	354	case ADDRS_TV_WITH_DEMOD:
	355	return tv_addrs + 4;
	356	}
	357	return NULL;
	358	}
	359	EXPORT_SYMBOL_GPL(v4l2_i2c_tuner_addrs);
	360
d8b29966 TP	361	#endif /* defined(CONFIG_I2C) */
d8b29966 TP	362
85e09219 DB	363	#if defined(CONFIG_SPI)
85e09219 DB	364
9d380adf	365	/* Load an spi sub-device. */
85e09219 DB	366
	367	void v4l2_spi_subdev_init(struct v4l2_subdev sd, struct spi_device spi,
	368	const struct v4l2_subdev_ops *ops)
	369	{
	370	v4l2_subdev_init(sd, ops);
	371	sd->flags \|= V4L2_SUBDEV_FL_IS_SPI;
	372	/* the owner is the same as the spi_device's driver owner */
	373	sd->owner = spi->dev.driver->owner;
668773b8	374	sd->dev = &spi->dev;
85e09219 DB	375	/* spi_device and v4l2_subdev point to one another */
	376	v4l2_set_subdevdata(sd, spi);
	377	spi_set_drvdata(spi, sd);
	378	/* initialize name */
	379	strlcpy(sd->name, spi->dev.driver->name, sizeof(sd->name));
	380	}
	381	EXPORT_SYMBOL_GPL(v4l2_spi_subdev_init);
	382
	383	struct v4l2_subdev v4l2_spi_new_subdev(struct v4l2_device v4l2_dev,
	384	struct spi_master master, struct spi_board_info info)
	385	{
	386	struct v4l2_subdev *sd = NULL;
	387	struct spi_device *spi = NULL;
	388
	389	BUG_ON(!v4l2_dev);
	390
07ca4188	391	if (info->modalias[0])
85e09219 DB	392	request_module(info->modalias);
	393
	394	spi = spi_new_device(master, info);
	395
	396	if (spi == NULL \|\| spi->dev.driver == NULL)
	397	goto error;
	398
	399	if (!try_module_get(spi->dev.driver->owner))
	400	goto error;
	401
	402	sd = spi_get_drvdata(spi);
	403
	404	/* Register with the v4l2_device which increases the module's
	405	use count as well. */
	406	if (v4l2_device_register_subdev(v4l2_dev, sd))
	407	sd = NULL;
	408
	409	/* Decrease the module use count to match the first try_module_get. */
	410	module_put(spi->dev.driver->owner);
	411
	412	error:
	413	/* If we have a client but no subdev, then something went wrong and
	414	we must unregister the client. */
	415	if (spi && sd == NULL)
	416	spi_unregister_device(spi);
	417
	418	return sd;
	419	}
	420	EXPORT_SYMBOL_GPL(v4l2_spi_new_subdev);
	421
	422	#endif /* defined(CONFIG_SPI) */
	423
b0d3159b TP	424	/* Clamp x to be between min and max, aligned to a multiple of 2^align. min
	425	* and max don't have to be aligned, but there must be at least one valid
	426	* value. E.g., min=17,max=31,align=4 is not allowed as there are no multiples
	427	* of 16 between 17 and 31. */
	428	static unsigned int clamp_align(unsigned int x, unsigned int min,
	429	unsigned int max, unsigned int align)
	430	{
	431	/* Bits that must be zero to be aligned */
	432	unsigned int mask = ~((1 << align) - 1);
	433
	434	/* Round to nearest aligned value */
	435	if (align)
	436	x = (x + (1 << (align - 1))) & mask;
	437
	438	/* Clamp to aligned value of min and max */
	439	if (x < min)
	440	x = (min + ~mask) & mask;
	441	else if (x > max)
	442	x = max & mask;
	443
	444	return x;
	445	}
	446
	447	/* Bound an image to have a width between wmin and wmax, and height between
	448	* hmin and hmax, inclusive. Additionally, the width will be a multiple of
	449	* 2^walign, the height will be a multiple of 2^halign, and the overall size
	450	* (width*height) will be a multiple of 2^salign. The image may be shrunk
	451	* or enlarged to fit the alignment constraints.
	452	*
	453	* The width or height maximum must not be smaller than the corresponding
	454	* minimum. The alignments must not be so high there are no possible image
	455	* sizes within the allowed bounds. wmin and hmin must be at least 1
	456	* (don't use 0). If you don't care about a certain alignment, specify 0,
	457	* as 2^0 is 1 and one byte alignment is equivalent to no alignment. If
	458	* you only want to adjust downward, specify a maximum that's the same as
	459	* the initial value.
	460	*/
	461	void v4l_bound_align_image(u32 *w, unsigned int wmin, unsigned int wmax,
	462	unsigned int walign,
	463	u32 *h, unsigned int hmin, unsigned int hmax,
	464	unsigned int halign, unsigned int salign)
	465	{
	466	w = clamp_align(w, wmin, wmax, walign);
	467	h = clamp_align(h, hmin, hmax, halign);
	468
	469	/* Usually we don't need to align the size and are done now. */
	470	if (!salign)
	471	return;
	472
	473	/* How much alignment do we have? */
	474	walign = __ffs(*w);
	475	halign = __ffs(*h);
	476	/* Enough to satisfy the image alignment? */
	477	if (walign + halign < salign) {
	478	/* Max walign where there is still a valid width */
	479	unsigned int wmaxa = __fls(wmax ^ (wmin - 1));
	480	/* Max halign where there is still a valid height */
	481	unsigned int hmaxa = __fls(hmax ^ (hmin - 1));
	482
	483	/* up the smaller alignment until we have enough */
	484	do {
	485	if (halign >= hmaxa \|\|
	486	(walign <= halign && walign < wmaxa)) {
	487	w = clamp_align(w, wmin, wmax, walign + 1);
488	walign = __ffs(*w);
489	} else {
490	h = clamp_align(h, hmin, hmax, halign + 1);
491	halign = __ffs(*h);
492	}
493	} while (halign + walign < salign);
494	}
495	}
496	EXPORT_SYMBOL_GPL(v4l_bound_align_image);
2e535ed5	497
3fd8e647 HV	498	const struct v4l2_frmsize_discrete *v4l2_find_nearest_format(
	499	const struct v4l2_discrete_probe *probe,
	500	s32 width, s32 height)
79c6ff93 GL	501	{
	502	int i;
	503	u32 error, min_error = UINT_MAX;
3fd8e647	504	const struct v4l2_frmsize_discrete size, best = NULL;
79c6ff93 GL	505
	506	if (!probe)
	507	return best;
	508
	509	for (i = 0, size = probe->sizes; i < probe->num_sizes; i++, size++) {
	510	error = abs(size->width - width) + abs(size->height - height);
	511	if (error < min_error) {
	512	min_error = error;
	513	best = size;
	514	}
	515	if (!error)
	516	break;
	517	}
	518
	519	return best;
	520	}
	521	EXPORT_SYMBOL_GPL(v4l2_find_nearest_format);
abd23295 SA	522
	523	void v4l2_get_timestamp(struct timeval *tv)
	524	{
	525	struct timespec ts;
	526
	527	ktime_get_ts(&ts);
	528	tv->tv_sec = ts.tv_sec;
	529	tv->tv_usec = ts.tv_nsec / NSEC_PER_USEC;
	530	}
	531	EXPORT_SYMBOL_GPL(v4l2_get_timestamp);