blob: 1baec8393306de0c1c781c88987615a24701c91f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 *
Mauro Carvalho Chehab43db48d2007-01-09 11:20:59 -030015 * Author: Bill Dirks <bill@thedirks.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 * 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 *
Alan Coxd9b01442008-10-27 15:13:47 -030031 * Author: Alan Cox, <alan@lxorguk.ukuu.org.uk>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 *
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
Jan Engelhardt96de0e22007-10-19 23:21:04 +020040 * Iñaki García Etxebarria <garetxe@euskalnet.net>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include <linux/module.h>
48#include <linux/types.h>
49#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#include <linux/mm.h>
51#include <linux/string.h>
52#include <linux/errno.h>
Hans Verkuilf3d092b2007-02-23 20:55:14 -030053#include <linux/i2c.h>
Dmitri Belimov85e09212010-03-23 11:23:29 -030054#if defined(CONFIG_SPI)
55#include <linux/spi/spi.h>
56#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070057#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070058#include <asm/pgtable.h>
59#include <asm/io.h>
60#include <asm/div64.h>
Michael Krufky5e453dc2006-01-09 15:32:31 -020061#include <media/v4l2-common.h>
Hans Verkuildd991202008-11-23 12:19:45 -030062#include <media/v4l2-device.h>
Hans Verkuil09965172010-08-01 14:32:42 -030063#include <media/v4l2-ctrls.h>
Hans Verkuil3434eb72007-04-27 12:31:08 -030064#include <media/v4l2-chip-ident.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Hans Verkuil33b687c2008-07-25 05:32:50 -030066#include <linux/videodev2.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
68MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
69MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
70MODULE_LICENSE("GPL");
71
72/*
73 *
74 * V 4 L 2 D R I V E R H E L P E R A P I
75 *
76 */
77
78/*
79 * Video Standard Operations (contributed by Michael Schimek)
80 */
81
Hans Verkuil9cb23182006-06-18 14:11:08 -030082/* Helper functions for control handling */
83
84/* Check for correctness of the ctrl's value based on the data from
85 struct v4l2_queryctrl and the available menu items. Note that
86 menu_items may be NULL, in that case it is ignored. */
87int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
Hans Verkuil513521e2010-12-29 14:25:52 -030088 const char * const *menu_items)
Hans Verkuil9cb23182006-06-18 14:11:08 -030089{
90 if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
91 return -EINVAL;
92 if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
93 return -EBUSY;
Hans Verkuil6b5a9492009-08-11 18:47:18 -030094 if (qctrl->type == V4L2_CTRL_TYPE_STRING)
95 return 0;
Hans Verkuil9cb23182006-06-18 14:11:08 -030096 if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
97 qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
98 qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
99 return 0;
100 if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
101 return -ERANGE;
102 if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
103 if (menu_items[ctrl->value] == NULL ||
104 menu_items[ctrl->value][0] == '\0')
105 return -EINVAL;
106 }
Hans Verkuilfa4d7092011-05-23 04:07:05 -0300107 if (qctrl->type == V4L2_CTRL_TYPE_BITMASK &&
108 (ctrl->value & ~qctrl->maximum))
109 return -ERANGE;
Hans Verkuil9cb23182006-06-18 14:11:08 -0300110 return 0;
111}
Mauro Carvalho Chehab057596e2008-02-02 11:25:31 -0300112EXPORT_SYMBOL(v4l2_ctrl_check);
Hans Verkuil9cb23182006-06-18 14:11:08 -0300113
Hans Verkuil9cb23182006-06-18 14:11:08 -0300114/* Fill in a struct v4l2_queryctrl */
115int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
116{
Hans Verkuil09965172010-08-01 14:32:42 -0300117 const char *name;
Hans Verkuil9cb23182006-06-18 14:11:08 -0300118
Hans Verkuil09965172010-08-01 14:32:42 -0300119 v4l2_ctrl_fill(qctrl->id, &name, &qctrl->type,
120 &min, &max, &step, &def, &qctrl->flags);
121
Hans Verkuil69028d72008-08-08 07:55:00 -0300122 if (name == NULL)
Hans Verkuil9cb23182006-06-18 14:11:08 -0300123 return -EINVAL;
Hans Verkuil69028d72008-08-08 07:55:00 -0300124
Hans Verkuil9cb23182006-06-18 14:11:08 -0300125 qctrl->minimum = min;
126 qctrl->maximum = max;
127 qctrl->step = step;
128 qctrl->default_value = def;
129 qctrl->reserved[0] = qctrl->reserved[1] = 0;
Hans Verkuilb634a932009-01-17 11:26:59 -0300130 strlcpy(qctrl->name, name, sizeof(qctrl->name));
Hans Verkuil9cb23182006-06-18 14:11:08 -0300131 return 0;
132}
Mauro Carvalho Chehab057596e2008-02-02 11:25:31 -0300133EXPORT_SYMBOL(v4l2_ctrl_query_fill);
Hans Verkuil9cb23182006-06-18 14:11:08 -0300134
Hans Verkuil9cb23182006-06-18 14:11:08 -0300135/* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
Hans Verkuile281db582008-08-08 12:43:59 -0300136 the menu. The qctrl pointer may be NULL, in which case it is ignored.
137 If menu_items is NULL, then the menu items are retrieved using
138 v4l2_ctrl_get_menu. */
Hans Verkuil9cb23182006-06-18 14:11:08 -0300139int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
Hans Verkuil513521e2010-12-29 14:25:52 -0300140 const char * const *menu_items)
Hans Verkuil9cb23182006-06-18 14:11:08 -0300141{
142 int i;
143
Hans Verkuil1e551262008-08-08 08:34:19 -0300144 qmenu->reserved = 0;
Hans Verkuile281db582008-08-08 12:43:59 -0300145 if (menu_items == NULL)
146 menu_items = v4l2_ctrl_get_menu(qmenu->id);
Hans Verkuil9cb23182006-06-18 14:11:08 -0300147 if (menu_items == NULL ||
148 (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
149 return -EINVAL;
150 for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
151 if (menu_items[i] == NULL || menu_items[i][0] == '\0')
152 return -EINVAL;
Hans Verkuilb634a932009-01-17 11:26:59 -0300153 strlcpy(qmenu->name, menu_items[qmenu->index], sizeof(qmenu->name));
Hans Verkuil9cb23182006-06-18 14:11:08 -0300154 return 0;
155}
Mauro Carvalho Chehab057596e2008-02-02 11:25:31 -0300156EXPORT_SYMBOL(v4l2_ctrl_query_menu);
Hans Verkuil9cb23182006-06-18 14:11:08 -0300157
Hans Verkuil1e551262008-08-08 08:34:19 -0300158/* Fill in a struct v4l2_querymenu based on the specified array of valid
159 menu items (terminated by V4L2_CTRL_MENU_IDS_END).
160 Use this if there are 'holes' in the list of valid menu items. */
161int v4l2_ctrl_query_menu_valid_items(struct v4l2_querymenu *qmenu, const u32 *ids)
162{
Hans Verkuil513521e2010-12-29 14:25:52 -0300163 const char * const *menu_items = v4l2_ctrl_get_menu(qmenu->id);
Hans Verkuil1e551262008-08-08 08:34:19 -0300164
165 qmenu->reserved = 0;
166 if (menu_items == NULL || ids == NULL)
167 return -EINVAL;
168 while (*ids != V4L2_CTRL_MENU_IDS_END) {
169 if (*ids++ == qmenu->index) {
Hans Verkuilb634a932009-01-17 11:26:59 -0300170 strlcpy(qmenu->name, menu_items[qmenu->index],
171 sizeof(qmenu->name));
Hans Verkuil1e551262008-08-08 08:34:19 -0300172 return 0;
173 }
174 }
175 return -EINVAL;
176}
177EXPORT_SYMBOL(v4l2_ctrl_query_menu_valid_items);
178
Hans Verkuil9cb23182006-06-18 14:11:08 -0300179/* ctrl_classes points to an array of u32 pointers, the last element is
180 a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
181 Each array must be sorted low to high and belong to the same control
Hans Verkuil2ba58892009-02-13 10:57:48 -0300182 class. The array of u32 pointers must also be sorted, from low class IDs
Hans Verkuil9cb23182006-06-18 14:11:08 -0300183 to high class IDs.
184
185 This function returns the first ID that follows after the given ID.
186 When no more controls are available 0 is returned. */
187u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
188{
Hans Verkuila46c5fb2007-07-19 04:53:36 -0300189 u32 ctrl_class = V4L2_CTRL_ID2CLASS(id);
Hans Verkuil9cb23182006-06-18 14:11:08 -0300190 const u32 *pctrl;
191
Hans Verkuil9cb23182006-06-18 14:11:08 -0300192 if (ctrl_classes == NULL)
193 return 0;
Hans Verkuila46c5fb2007-07-19 04:53:36 -0300194
195 /* if no query is desired, then check if the ID is part of ctrl_classes */
196 if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) {
197 /* find class */
198 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) != ctrl_class)
199 ctrl_classes++;
200 if (*ctrl_classes == NULL)
201 return 0;
202 pctrl = *ctrl_classes;
203 /* find control ID */
204 while (*pctrl && *pctrl != id) pctrl++;
205 return *pctrl ? id : 0;
206 }
Hans Verkuil9cb23182006-06-18 14:11:08 -0300207 id &= V4L2_CTRL_ID_MASK;
Hans Verkuil9cb23182006-06-18 14:11:08 -0300208 id++; /* select next control */
209 /* find first class that matches (or is greater than) the class of
210 the ID */
211 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
212 ctrl_classes++;
213 /* no more classes */
214 if (*ctrl_classes == NULL)
215 return 0;
216 pctrl = *ctrl_classes;
217 /* find first ctrl within the class that is >= ID */
218 while (*pctrl && *pctrl < id) pctrl++;
219 if (*pctrl)
220 return *pctrl;
221 /* we are at the end of the controls of the current class. */
222 /* continue with next class if available */
223 ctrl_classes++;
224 if (*ctrl_classes == NULL)
225 return 0;
226 return **ctrl_classes;
227}
Mauro Carvalho Chehab057596e2008-02-02 11:25:31 -0300228EXPORT_SYMBOL(v4l2_ctrl_next);
Hans Verkuil9cb23182006-06-18 14:11:08 -0300229
Hans Verkuilaecde8b2008-12-30 07:14:19 -0300230int v4l2_chip_match_host(const struct v4l2_dbg_match *match)
Mauro Carvalho Chehaba9254472008-01-29 18:32:35 -0300231{
Hans Verkuilaecde8b2008-12-30 07:14:19 -0300232 switch (match->type) {
Mauro Carvalho Chehaba9254472008-01-29 18:32:35 -0300233 case V4L2_CHIP_MATCH_HOST:
Hans Verkuilaecde8b2008-12-30 07:14:19 -0300234 return match->addr == 0;
Mauro Carvalho Chehaba9254472008-01-29 18:32:35 -0300235 default:
236 return 0;
237 }
238}
239EXPORT_SYMBOL(v4l2_chip_match_host);
240
241#if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
Hans Verkuilaecde8b2008-12-30 07:14:19 -0300242int v4l2_chip_match_i2c_client(struct i2c_client *c, const struct v4l2_dbg_match *match)
Hans Verkuilf3d092b2007-02-23 20:55:14 -0300243{
Hans Verkuilaecde8b2008-12-30 07:14:19 -0300244 int len;
245
246 if (c == NULL || match == NULL)
247 return 0;
248
249 switch (match->type) {
Hans Verkuilf3d092b2007-02-23 20:55:14 -0300250 case V4L2_CHIP_MATCH_I2C_DRIVER:
Hans Verkuilaecde8b2008-12-30 07:14:19 -0300251 if (c->driver == NULL || c->driver->driver.name == NULL)
252 return 0;
253 len = strlen(c->driver->driver.name);
254 /* legacy drivers have a ' suffix, don't try to match that */
255 if (len && c->driver->driver.name[len - 1] == '\'')
256 len--;
257 return len && !strncmp(c->driver->driver.name, match->name, len);
Hans Verkuilf3d092b2007-02-23 20:55:14 -0300258 case V4L2_CHIP_MATCH_I2C_ADDR:
Hans Verkuilaecde8b2008-12-30 07:14:19 -0300259 return c->addr == match->addr;
Hans Verkuilf3d092b2007-02-23 20:55:14 -0300260 default:
261 return 0;
262 }
263}
Mauro Carvalho Chehaba9254472008-01-29 18:32:35 -0300264EXPORT_SYMBOL(v4l2_chip_match_i2c_client);
Hans Verkuilf3d092b2007-02-23 20:55:14 -0300265
Hans Verkuilaecde8b2008-12-30 07:14:19 -0300266int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_dbg_chip_ident *chip,
Hans Verkuil3434eb72007-04-27 12:31:08 -0300267 u32 ident, u32 revision)
268{
Hans Verkuilaecde8b2008-12-30 07:14:19 -0300269 if (!v4l2_chip_match_i2c_client(c, &chip->match))
Hans Verkuil3434eb72007-04-27 12:31:08 -0300270 return 0;
271 if (chip->ident == V4L2_IDENT_NONE) {
272 chip->ident = ident;
273 chip->revision = revision;
274 }
275 else {
276 chip->ident = V4L2_IDENT_AMBIGUOUS;
277 chip->revision = 0;
278 }
279 return 0;
280}
Mauro Carvalho Chehaba9254472008-01-29 18:32:35 -0300281EXPORT_SYMBOL(v4l2_chip_ident_i2c_client);
Hans Verkuilf3d092b2007-02-23 20:55:14 -0300282
Hans Verkuil9cb23182006-06-18 14:11:08 -0300283/* ----------------------------------------------------------------- */
284
Hans Verkuil78a3b4d2009-04-01 03:41:09 -0300285/* I2C Helper functions */
Hans Verkuil8ffbc652007-09-12 08:32:50 -0300286
Hans Verkuildd991202008-11-23 12:19:45 -0300287
288void v4l2_i2c_subdev_init(struct v4l2_subdev *sd, struct i2c_client *client,
289 const struct v4l2_subdev_ops *ops)
290{
291 v4l2_subdev_init(sd, ops);
Hans Verkuilb5b2b7e2009-05-02 10:58:51 -0300292 sd->flags |= V4L2_SUBDEV_FL_IS_I2C;
Hans Verkuildd991202008-11-23 12:19:45 -0300293 /* the owner is the same as the i2c_client's driver owner */
294 sd->owner = client->driver->driver.owner;
295 /* i2c_client and v4l2_subdev point to one another */
296 v4l2_set_subdevdata(sd, client);
297 i2c_set_clientdata(client, sd);
298 /* initialize name */
299 snprintf(sd->name, sizeof(sd->name), "%s %d-%04x",
300 client->driver->driver.name, i2c_adapter_id(client->adapter),
301 client->addr);
302}
303EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init);
304
305
306
Hans Verkuile6574f22009-04-01 03:57:53 -0300307/* Load an i2c sub-device. */
Hans Verkuilf0222c72009-06-09 17:12:33 -0300308struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev,
Laurent Pinchart9a1f8b32010-09-24 10:16:44 -0300309 struct i2c_adapter *adapter, struct i2c_board_info *info,
310 const unsigned short *probe_addrs)
Hans Verkuilf0222c72009-06-09 17:12:33 -0300311{
312 struct v4l2_subdev *sd = NULL;
313 struct i2c_client *client;
314
315 BUG_ON(!v4l2_dev);
316
Laurent Pinchart9a1f8b32010-09-24 10:16:44 -0300317 request_module(I2C_MODULE_PREFIX "%s", info->type);
Hans Verkuilf0222c72009-06-09 17:12:33 -0300318
319 /* Create the i2c client */
320 if (info->addr == 0 && probe_addrs)
Jean Delvare9a942412010-08-11 18:20:56 +0200321 client = i2c_new_probed_device(adapter, info, probe_addrs,
322 NULL);
Hans Verkuilf0222c72009-06-09 17:12:33 -0300323 else
324 client = i2c_new_device(adapter, info);
325
326 /* Note: by loading the module first we are certain that c->driver
327 will be set if the driver was found. If the module was not loaded
328 first, then the i2c core tries to delay-load the module for us,
329 and then c->driver is still NULL until the module is finally
330 loaded. This delay-load mechanism doesn't work if other drivers
331 want to use the i2c device, so explicitly loading the module
332 is the best alternative. */
333 if (client == NULL || client->driver == NULL)
334 goto error;
335
336 /* Lock the module so we can safely get the v4l2_subdev pointer */
337 if (!try_module_get(client->driver->driver.owner))
338 goto error;
339 sd = i2c_get_clientdata(client);
340
341 /* Register with the v4l2_device which increases the module's
342 use count as well. */
343 if (v4l2_device_register_subdev(v4l2_dev, sd))
344 sd = NULL;
345 /* Decrease the module use count to match the first try_module_get. */
346 module_put(client->driver->driver.owner);
347
Hans Verkuilf0222c72009-06-09 17:12:33 -0300348error:
349 /* If we have a client but no subdev, then something went wrong and
350 we must unregister the client. */
351 if (client && sd == NULL)
352 i2c_unregister_device(client);
353 return sd;
354}
355EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_board);
356
Hans Verkuil3c7c9372011-01-08 07:08:02 -0300357struct v4l2_subdev *v4l2_i2c_new_subdev(struct v4l2_device *v4l2_dev,
Laurent Pinchart9a1f8b32010-09-24 10:16:44 -0300358 struct i2c_adapter *adapter, const char *client_type,
Hans Verkuilf0222c72009-06-09 17:12:33 -0300359 u8 addr, const unsigned short *probe_addrs)
360{
361 struct i2c_board_info info;
362
363 /* Setup the i2c board info with the device type and
364 the device address. */
365 memset(&info, 0, sizeof(info));
366 strlcpy(info.type, client_type, sizeof(info.type));
367 info.addr = addr;
Hans Verkuilf0222c72009-06-09 17:12:33 -0300368
Laurent Pinchart9a1f8b32010-09-24 10:16:44 -0300369 return v4l2_i2c_new_subdev_board(v4l2_dev, adapter, &info, probe_addrs);
Hans Verkuilf0222c72009-06-09 17:12:33 -0300370}
Hans Verkuil3c7c9372011-01-08 07:08:02 -0300371EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev);
Hans Verkuilf0222c72009-06-09 17:12:33 -0300372
Hans Verkuilab373192009-02-21 18:08:41 -0300373/* Return i2c client address of v4l2_subdev. */
374unsigned short v4l2_i2c_subdev_addr(struct v4l2_subdev *sd)
375{
376 struct i2c_client *client = v4l2_get_subdevdata(sd);
377
378 return client ? client->addr : I2C_CLIENT_END;
379}
380EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_addr);
381
Hans Verkuilc7d29e22009-01-18 19:37:59 -0300382/* Return a list of I2C tuner addresses to probe. Use only if the tuner
383 addresses are unknown. */
384const unsigned short *v4l2_i2c_tuner_addrs(enum v4l2_i2c_tuner_type type)
385{
386 static const unsigned short radio_addrs[] = {
387#if defined(CONFIG_MEDIA_TUNER_TEA5761) || defined(CONFIG_MEDIA_TUNER_TEA5761_MODULE)
388 0x10,
389#endif
390 0x60,
391 I2C_CLIENT_END
392 };
393 static const unsigned short demod_addrs[] = {
394 0x42, 0x43, 0x4a, 0x4b,
395 I2C_CLIENT_END
396 };
397 static const unsigned short tv_addrs[] = {
398 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
Hans Verkuil416a7aa2009-05-02 09:42:57 -0300399 0x60, 0x61, 0x62, 0x63, 0x64,
Hans Verkuilc7d29e22009-01-18 19:37:59 -0300400 I2C_CLIENT_END
401 };
402
403 switch (type) {
404 case ADDRS_RADIO:
405 return radio_addrs;
406 case ADDRS_DEMOD:
407 return demod_addrs;
408 case ADDRS_TV:
409 return tv_addrs;
410 case ADDRS_TV_WITH_DEMOD:
411 return tv_addrs + 4;
412 }
413 return NULL;
414}
415EXPORT_SYMBOL_GPL(v4l2_i2c_tuner_addrs);
416
Trent Piephod8b29962009-06-12 16:31:29 -0300417#endif /* defined(CONFIG_I2C) */
418
Dmitri Belimov85e09212010-03-23 11:23:29 -0300419#if defined(CONFIG_SPI)
420
421/* Load a spi sub-device. */
422
423void v4l2_spi_subdev_init(struct v4l2_subdev *sd, struct spi_device *spi,
424 const struct v4l2_subdev_ops *ops)
425{
426 v4l2_subdev_init(sd, ops);
427 sd->flags |= V4L2_SUBDEV_FL_IS_SPI;
428 /* the owner is the same as the spi_device's driver owner */
429 sd->owner = spi->dev.driver->owner;
430 /* spi_device and v4l2_subdev point to one another */
431 v4l2_set_subdevdata(sd, spi);
432 spi_set_drvdata(spi, sd);
433 /* initialize name */
434 strlcpy(sd->name, spi->dev.driver->name, sizeof(sd->name));
435}
436EXPORT_SYMBOL_GPL(v4l2_spi_subdev_init);
437
438struct v4l2_subdev *v4l2_spi_new_subdev(struct v4l2_device *v4l2_dev,
439 struct spi_master *master, struct spi_board_info *info)
440{
441 struct v4l2_subdev *sd = NULL;
442 struct spi_device *spi = NULL;
443
444 BUG_ON(!v4l2_dev);
445
446 if (info->modalias)
447 request_module(info->modalias);
448
449 spi = spi_new_device(master, info);
450
451 if (spi == NULL || spi->dev.driver == NULL)
452 goto error;
453
454 if (!try_module_get(spi->dev.driver->owner))
455 goto error;
456
457 sd = spi_get_drvdata(spi);
458
459 /* Register with the v4l2_device which increases the module's
460 use count as well. */
461 if (v4l2_device_register_subdev(v4l2_dev, sd))
462 sd = NULL;
463
464 /* Decrease the module use count to match the first try_module_get. */
465 module_put(spi->dev.driver->owner);
466
467error:
468 /* If we have a client but no subdev, then something went wrong and
469 we must unregister the client. */
470 if (spi && sd == NULL)
471 spi_unregister_device(spi);
472
473 return sd;
474}
475EXPORT_SYMBOL_GPL(v4l2_spi_new_subdev);
476
477#endif /* defined(CONFIG_SPI) */
478
Trent Piephob0d31592009-05-30 21:45:46 -0300479/* Clamp x to be between min and max, aligned to a multiple of 2^align. min
480 * and max don't have to be aligned, but there must be at least one valid
481 * value. E.g., min=17,max=31,align=4 is not allowed as there are no multiples
482 * of 16 between 17 and 31. */
483static unsigned int clamp_align(unsigned int x, unsigned int min,
484 unsigned int max, unsigned int align)
485{
486 /* Bits that must be zero to be aligned */
487 unsigned int mask = ~((1 << align) - 1);
488
489 /* Round to nearest aligned value */
490 if (align)
491 x = (x + (1 << (align - 1))) & mask;
492
493 /* Clamp to aligned value of min and max */
494 if (x < min)
495 x = (min + ~mask) & mask;
496 else if (x > max)
497 x = max & mask;
498
499 return x;
500}
501
502/* Bound an image to have a width between wmin and wmax, and height between
503 * hmin and hmax, inclusive. Additionally, the width will be a multiple of
504 * 2^walign, the height will be a multiple of 2^halign, and the overall size
505 * (width*height) will be a multiple of 2^salign. The image may be shrunk
506 * or enlarged to fit the alignment constraints.
507 *
508 * The width or height maximum must not be smaller than the corresponding
509 * minimum. The alignments must not be so high there are no possible image
510 * sizes within the allowed bounds. wmin and hmin must be at least 1
511 * (don't use 0). If you don't care about a certain alignment, specify 0,
512 * as 2^0 is 1 and one byte alignment is equivalent to no alignment. If
513 * you only want to adjust downward, specify a maximum that's the same as
514 * the initial value.
515 */
516void v4l_bound_align_image(u32 *w, unsigned int wmin, unsigned int wmax,
517 unsigned int walign,
518 u32 *h, unsigned int hmin, unsigned int hmax,
519 unsigned int halign, unsigned int salign)
520{
521 *w = clamp_align(*w, wmin, wmax, walign);
522 *h = clamp_align(*h, hmin, hmax, halign);
523
524 /* Usually we don't need to align the size and are done now. */
525 if (!salign)
526 return;
527
528 /* How much alignment do we have? */
529 walign = __ffs(*w);
530 halign = __ffs(*h);
531 /* Enough to satisfy the image alignment? */
532 if (walign + halign < salign) {
533 /* Max walign where there is still a valid width */
534 unsigned int wmaxa = __fls(wmax ^ (wmin - 1));
535 /* Max halign where there is still a valid height */
536 unsigned int hmaxa = __fls(hmax ^ (hmin - 1));
537
538 /* up the smaller alignment until we have enough */
539 do {
540 if (halign >= hmaxa ||
541 (walign <= halign && walign < wmaxa)) {
542 *w = clamp_align(*w, wmin, wmax, walign + 1);
543 walign = __ffs(*w);
544 } else {
545 *h = clamp_align(*h, hmin, hmax, halign + 1);
546 halign = __ffs(*h);
547 }
548 } while (halign + walign < salign);
549 }
550}
551EXPORT_SYMBOL_GPL(v4l_bound_align_image);
Muralidharan Karicheri2e535ed2009-12-10 04:39:47 -0300552
553/**
554 * v4l_fill_dv_preset_info - fill description of a digital video preset
555 * @preset - preset value
556 * @info - pointer to struct v4l2_dv_enum_preset
557 *
558 * drivers can use this helper function to fill description of dv preset
559 * in info.
560 */
561int v4l_fill_dv_preset_info(u32 preset, struct v4l2_dv_enum_preset *info)
562{
563 static const struct v4l2_dv_preset_info {
564 u16 width;
565 u16 height;
566 const char *name;
567 } dv_presets[] = {
568 { 0, 0, "Invalid" }, /* V4L2_DV_INVALID */
569 { 720, 480, "480p@59.94" }, /* V4L2_DV_480P59_94 */
570 { 720, 576, "576p@50" }, /* V4L2_DV_576P50 */
571 { 1280, 720, "720p@24" }, /* V4L2_DV_720P24 */
572 { 1280, 720, "720p@25" }, /* V4L2_DV_720P25 */
573 { 1280, 720, "720p@30" }, /* V4L2_DV_720P30 */
574 { 1280, 720, "720p@50" }, /* V4L2_DV_720P50 */
575 { 1280, 720, "720p@59.94" }, /* V4L2_DV_720P59_94 */
576 { 1280, 720, "720p@60" }, /* V4L2_DV_720P60 */
577 { 1920, 1080, "1080i@29.97" }, /* V4L2_DV_1080I29_97 */
578 { 1920, 1080, "1080i@30" }, /* V4L2_DV_1080I30 */
579 { 1920, 1080, "1080i@25" }, /* V4L2_DV_1080I25 */
580 { 1920, 1080, "1080i@50" }, /* V4L2_DV_1080I50 */
581 { 1920, 1080, "1080i@60" }, /* V4L2_DV_1080I60 */
582 { 1920, 1080, "1080p@24" }, /* V4L2_DV_1080P24 */
583 { 1920, 1080, "1080p@25" }, /* V4L2_DV_1080P25 */
584 { 1920, 1080, "1080p@30" }, /* V4L2_DV_1080P30 */
585 { 1920, 1080, "1080p@50" }, /* V4L2_DV_1080P50 */
586 { 1920, 1080, "1080p@60" }, /* V4L2_DV_1080P60 */
587 };
588
589 if (info == NULL || preset >= ARRAY_SIZE(dv_presets))
590 return -EINVAL;
591
592 info->preset = preset;
593 info->width = dv_presets[preset].width;
594 info->height = dv_presets[preset].height;
595 strlcpy(info->name, dv_presets[preset].name, sizeof(info->name));
596 return 0;
597}
598EXPORT_SYMBOL_GPL(v4l_fill_dv_preset_info);
Guennadi Liakhovetski79c6ff92010-08-27 13:41:44 -0300599
Hans Verkuil3fd8e642010-09-30 09:29:37 -0300600const struct v4l2_frmsize_discrete *v4l2_find_nearest_format(
601 const struct v4l2_discrete_probe *probe,
602 s32 width, s32 height)
Guennadi Liakhovetski79c6ff92010-08-27 13:41:44 -0300603{
604 int i;
605 u32 error, min_error = UINT_MAX;
Hans Verkuil3fd8e642010-09-30 09:29:37 -0300606 const struct v4l2_frmsize_discrete *size, *best = NULL;
Guennadi Liakhovetski79c6ff92010-08-27 13:41:44 -0300607
608 if (!probe)
609 return best;
610
611 for (i = 0, size = probe->sizes; i < probe->num_sizes; i++, size++) {
612 error = abs(size->width - width) + abs(size->height - height);
613 if (error < min_error) {
614 min_error = error;
615 best = size;
616 }
617 if (!error)
618 break;
619 }
620
621 return best;
622}
623EXPORT_SYMBOL_GPL(v4l2_find_nearest_format);