| /* |
| * 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 <linux/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 */ |
| |
| /* 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; |
| s64 min = _min; |
| s64 max = _max; |
| u64 step = _step; |
| s64 def = _def; |
| |
| 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); |
| |
| /* 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 (!sd) |
| 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); |
| |
| /* Clamp to aligned min and max */ |
| x = clamp(x, (min + ~mask) & mask, max & mask); |
| |
| /* Round to nearest aligned value */ |
| if (align) |
| x = (x + (1 << (align - 1))) & mask; |
| |
| return x; |
| } |
| |
| 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_frmsize_discrete *sizes, |
| size_t num_sizes, |
| s32 width, s32 height) |
| { |
| int i; |
| u32 error, min_error = UINT_MAX; |
| const struct v4l2_frmsize_discrete *size, *best = NULL; |
| |
| if (!sizes) |
| return NULL; |
| |
| for (i = 0, size = sizes; i < 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); |