diff options
Diffstat (limited to 'drivers/media/video/v4l2-common.c')
-rw-r--r-- | drivers/media/video/v4l2-common.c | 624 |
1 files changed, 624 insertions, 0 deletions
diff --git a/drivers/media/video/v4l2-common.c b/drivers/media/video/v4l2-common.c new file mode 100644 index 00000000000..5c6100fb407 --- /dev/null +++ b/drivers/media/video/v4l2-common.c | |||
@@ -0,0 +1,624 @@ | |||
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 | * | ||
15 | * Author: Bill Dirks <bill@thedirks.org> | ||
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 | * | ||
31 | * Author: Alan Cox, <alan@lxorguk.ukuu.org.uk> | ||
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 | ||
40 | * Iñaki García Etxebarria <garetxe@euskalnet.net> | ||
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 | |||
47 | #include <linux/module.h> | ||
48 | #include <linux/types.h> | ||
49 | #include <linux/kernel.h> | ||
50 | #include <linux/mm.h> | ||
51 | #include <linux/string.h> | ||
52 | #include <linux/errno.h> | ||
53 | #include <linux/i2c.h> | ||
54 | #if defined(CONFIG_SPI) | ||
55 | #include <linux/spi/spi.h> | ||
56 | #endif | ||
57 | #include <asm/uaccess.h> | ||
58 | #include <asm/system.h> | ||
59 | #include <asm/pgtable.h> | ||
60 | #include <asm/io.h> | ||
61 | #include <asm/div64.h> | ||
62 | #include <media/v4l2-common.h> | ||
63 | #include <media/v4l2-device.h> | ||
64 | #include <media/v4l2-ctrls.h> | ||
65 | #include <media/v4l2-chip-ident.h> | ||
66 | |||
67 | #include <linux/videodev2.h> | ||
68 | |||
69 | MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr"); | ||
70 | MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers"); | ||
71 | MODULE_LICENSE("GPL"); | ||
72 | |||
73 | /* | ||
74 | * | ||
75 | * V 4 L 2 D R I V E R H E L P E R A P I | ||
76 | * | ||
77 | */ | ||
78 | |||
79 | /* | ||
80 | * Video Standard Operations (contributed by Michael Schimek) | ||
81 | */ | ||
82 | |||
83 | /* Helper functions for control handling */ | ||
84 | |||
85 | /* Check for correctness of the ctrl's value based on the data from | ||
86 | struct v4l2_queryctrl and the available menu items. Note that | ||
87 | menu_items may be NULL, in that case it is ignored. */ | ||
88 | int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl, | ||
89 | const char * const *menu_items) | ||
90 | { | ||
91 | if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED) | ||
92 | return -EINVAL; | ||
93 | if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED) | ||
94 | return -EBUSY; | ||
95 | if (qctrl->type == V4L2_CTRL_TYPE_STRING) | ||
96 | return 0; | ||
97 | if (qctrl->type == V4L2_CTRL_TYPE_BUTTON || | ||
98 | qctrl->type == V4L2_CTRL_TYPE_INTEGER64 || | ||
99 | qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS) | ||
100 | return 0; | ||
101 | if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum) | ||
102 | return -ERANGE; | ||
103 | if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) { | ||
104 | if (menu_items[ctrl->value] == NULL || | ||
105 | menu_items[ctrl->value][0] == '\0') | ||
106 | return -EINVAL; | ||
107 | } | ||
108 | if (qctrl->type == V4L2_CTRL_TYPE_BITMASK && | ||
109 | (ctrl->value & ~qctrl->maximum)) | ||
110 | return -ERANGE; | ||
111 | return 0; | ||
112 | } | ||
113 | EXPORT_SYMBOL(v4l2_ctrl_check); | ||
114 | |||
115 | /* Fill in a struct v4l2_queryctrl */ | ||
116 | int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def) | ||
117 | { | ||
118 | const char *name; | ||
119 | |||
120 | v4l2_ctrl_fill(qctrl->id, &name, &qctrl->type, | ||
121 | &min, &max, &step, &def, &qctrl->flags); | ||
122 | |||
123 | if (name == NULL) | ||
124 | return -EINVAL; | ||
125 | |||
126 | qctrl->minimum = min; | ||
127 | qctrl->maximum = max; | ||
128 | qctrl->step = step; | ||
129 | qctrl->default_value = def; | ||
130 | qctrl->reserved[0] = qctrl->reserved[1] = 0; | ||
131 | strlcpy(qctrl->name, name, sizeof(qctrl->name)); | ||
132 | return 0; | ||
133 | } | ||
134 | EXPORT_SYMBOL(v4l2_ctrl_query_fill); | ||
135 | |||
136 | /* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and | ||
137 | the menu. The qctrl pointer may be NULL, in which case it is ignored. | ||
138 | If menu_items is NULL, then the menu items are retrieved using | ||
139 | v4l2_ctrl_get_menu. */ | ||
140 | int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl, | ||
141 | const char * const *menu_items) | ||
142 | { | ||
143 | int i; | ||
144 | |||
145 | qmenu->reserved = 0; | ||
146 | if (menu_items == NULL) | ||
147 | menu_items = v4l2_ctrl_get_menu(qmenu->id); | ||
148 | if (menu_items == NULL || | ||
149 | (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum))) | ||
150 | return -EINVAL; | ||
151 | for (i = 0; i < qmenu->index && menu_items[i]; i++) ; | ||
152 | if (menu_items[i] == NULL || menu_items[i][0] == '\0') | ||
153 | return -EINVAL; | ||
154 | strlcpy(qmenu->name, menu_items[qmenu->index], sizeof(qmenu->name)); | ||
155 | return 0; | ||
156 | } | ||
157 | EXPORT_SYMBOL(v4l2_ctrl_query_menu); | ||
158 | |||
159 | /* Fill in a struct v4l2_querymenu based on the specified array of valid | ||
160 | menu items (terminated by V4L2_CTRL_MENU_IDS_END). | ||
161 | Use this if there are 'holes' in the list of valid menu items. */ | ||
162 | int v4l2_ctrl_query_menu_valid_items(struct v4l2_querymenu *qmenu, const u32 *ids) | ||
163 | { | ||
164 | const char * const *menu_items = v4l2_ctrl_get_menu(qmenu->id); | ||
165 | |||
166 | qmenu->reserved = 0; | ||
167 | if (menu_items == NULL || ids == NULL) | ||
168 | return -EINVAL; | ||
169 | while (*ids != V4L2_CTRL_MENU_IDS_END) { | ||
170 | if (*ids++ == qmenu->index) { | ||
171 | strlcpy(qmenu->name, menu_items[qmenu->index], | ||
172 | sizeof(qmenu->name)); | ||
173 | return 0; | ||
174 | } | ||
175 | } | ||
176 | return -EINVAL; | ||
177 | } | ||
178 | EXPORT_SYMBOL(v4l2_ctrl_query_menu_valid_items); | ||
179 | |||
180 | /* ctrl_classes points to an array of u32 pointers, the last element is | ||
181 | a NULL pointer. Each u32 array is a 0-terminated array of control IDs. | ||
182 | Each array must be sorted low to high and belong to the same control | ||
183 | class. The array of u32 pointers must also be sorted, from low class IDs | ||
184 | to high class IDs. | ||
185 | |||
186 | This function returns the first ID that follows after the given ID. | ||
187 | When no more controls are available 0 is returned. */ | ||
188 | u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id) | ||
189 | { | ||
190 | u32 ctrl_class = V4L2_CTRL_ID2CLASS(id); | ||
191 | const u32 *pctrl; | ||
192 | |||
193 | if (ctrl_classes == NULL) | ||
194 | return 0; | ||
195 | |||
196 | /* if no query is desired, then check if the ID is part of ctrl_classes */ | ||
197 | if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) { | ||
198 | /* find class */ | ||
199 | while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) != ctrl_class) | ||
200 | ctrl_classes++; | ||
201 | if (*ctrl_classes == NULL) | ||
202 | return 0; | ||
203 | pctrl = *ctrl_classes; | ||
204 | /* find control ID */ | ||
205 | while (*pctrl && *pctrl != id) pctrl++; | ||
206 | return *pctrl ? id : 0; | ||
207 | } | ||
208 | id &= V4L2_CTRL_ID_MASK; | ||
209 | id++; /* select next control */ | ||
210 | /* find first class that matches (or is greater than) the class of | ||
211 | the ID */ | ||
212 | while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class) | ||
213 | ctrl_classes++; | ||
214 | /* no more classes */ | ||
215 | if (*ctrl_classes == NULL) | ||
216 | return 0; | ||
217 | pctrl = *ctrl_classes; | ||
218 | /* find first ctrl within the class that is >= ID */ | ||
219 | while (*pctrl && *pctrl < id) pctrl++; | ||
220 | if (*pctrl) | ||
221 | return *pctrl; | ||
222 | /* we are at the end of the controls of the current class. */ | ||
223 | /* continue with next class if available */ | ||
224 | ctrl_classes++; | ||
225 | if (*ctrl_classes == NULL) | ||
226 | return 0; | ||
227 | return **ctrl_classes; | ||
228 | } | ||
229 | EXPORT_SYMBOL(v4l2_ctrl_next); | ||
230 | |||
231 | int v4l2_chip_match_host(const struct v4l2_dbg_match *match) | ||
232 | { | ||
233 | switch (match->type) { | ||
234 | case V4L2_CHIP_MATCH_HOST: | ||
235 | return match->addr == 0; | ||
236 | default: | ||
237 | return 0; | ||
238 | } | ||
239 | } | ||
240 | EXPORT_SYMBOL(v4l2_chip_match_host); | ||
241 | |||
242 | #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE)) | ||
243 | int v4l2_chip_match_i2c_client(struct i2c_client *c, const struct v4l2_dbg_match *match) | ||
244 | { | ||
245 | int len; | ||
246 | |||
247 | if (c == NULL || match == NULL) | ||
248 | return 0; | ||
249 | |||
250 | switch (match->type) { | ||
251 | case V4L2_CHIP_MATCH_I2C_DRIVER: | ||
252 | if (c->driver == NULL || c->driver->driver.name == NULL) | ||
253 | return 0; | ||
254 | len = strlen(c->driver->driver.name); | ||
255 | /* legacy drivers have a ' suffix, don't try to match that */ | ||
256 | if (len && c->driver->driver.name[len - 1] == '\'') | ||
257 | len--; | ||
258 | return len && !strncmp(c->driver->driver.name, match->name, len); | ||
259 | case V4L2_CHIP_MATCH_I2C_ADDR: | ||
260 | return c->addr == match->addr; | ||
261 | default: | ||
262 | return 0; | ||
263 | } | ||
264 | } | ||
265 | EXPORT_SYMBOL(v4l2_chip_match_i2c_client); | ||
266 | |||
267 | int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_dbg_chip_ident *chip, | ||
268 | u32 ident, u32 revision) | ||
269 | { | ||
270 | if (!v4l2_chip_match_i2c_client(c, &chip->match)) | ||
271 | return 0; | ||
272 | if (chip->ident == V4L2_IDENT_NONE) { | ||
273 | chip->ident = ident; | ||
274 | chip->revision = revision; | ||
275 | } | ||
276 | else { | ||
277 | chip->ident = V4L2_IDENT_AMBIGUOUS; | ||
278 | chip->revision = 0; | ||
279 | } | ||
280 | return 0; | ||
281 | } | ||
282 | EXPORT_SYMBOL(v4l2_chip_ident_i2c_client); | ||
283 | |||
284 | /* ----------------------------------------------------------------- */ | ||
285 | |||
286 | /* I2C Helper functions */ | ||
287 | |||
288 | |||
289 | void v4l2_i2c_subdev_init(struct v4l2_subdev *sd, struct i2c_client *client, | ||
290 | const struct v4l2_subdev_ops *ops) | ||
291 | { | ||
292 | v4l2_subdev_init(sd, ops); | ||
293 | sd->flags |= V4L2_SUBDEV_FL_IS_I2C; | ||
294 | /* the owner is the same as the i2c_client's driver owner */ | ||
295 | sd->owner = client->driver->driver.owner; | ||
296 | /* i2c_client and v4l2_subdev point to one another */ | ||
297 | v4l2_set_subdevdata(sd, client); | ||
298 | i2c_set_clientdata(client, sd); | ||
299 | /* initialize name */ | ||
300 | snprintf(sd->name, sizeof(sd->name), "%s %d-%04x", | ||
301 | client->driver->driver.name, i2c_adapter_id(client->adapter), | ||
302 | client->addr); | ||
303 | } | ||
304 | EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init); | ||
305 | |||
306 | |||
307 | |||
308 | /* Load an i2c sub-device. */ | ||
309 | struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev, | ||
310 | struct i2c_adapter *adapter, struct i2c_board_info *info, | ||
311 | const unsigned short *probe_addrs) | ||
312 | { | ||
313 | struct v4l2_subdev *sd = NULL; | ||
314 | struct i2c_client *client; | ||
315 | |||
316 | BUG_ON(!v4l2_dev); | ||
317 | |||
318 | request_module(I2C_MODULE_PREFIX "%s", info->type); | ||
319 | |||
320 | /* Create the i2c client */ | ||
321 | if (info->addr == 0 && probe_addrs) | ||
322 | client = i2c_new_probed_device(adapter, info, probe_addrs, | ||
323 | NULL); | ||
324 | else | ||
325 | client = i2c_new_device(adapter, info); | ||
326 | |||
327 | /* Note: by loading the module first we are certain that c->driver | ||
328 | will be set if the driver was found. If the module was not loaded | ||
329 | first, then the i2c core tries to delay-load the module for us, | ||
330 | and then c->driver is still NULL until the module is finally | ||
331 | loaded. This delay-load mechanism doesn't work if other drivers | ||
332 | want to use the i2c device, so explicitly loading the module | ||
333 | is the best alternative. */ | ||
334 | if (client == NULL || client->driver == NULL) | ||
335 | goto error; | ||
336 | |||
337 | /* Lock the module so we can safely get the v4l2_subdev pointer */ | ||
338 | if (!try_module_get(client->driver->driver.owner)) | ||
339 | goto error; | ||
340 | sd = i2c_get_clientdata(client); | ||
341 | |||
342 | /* Register with the v4l2_device which increases the module's | ||
343 | use count as well. */ | ||
344 | if (v4l2_device_register_subdev(v4l2_dev, sd)) | ||
345 | sd = NULL; | ||
346 | /* Decrease the module use count to match the first try_module_get. */ | ||
347 | module_put(client->driver->driver.owner); | ||
348 | |||
349 | error: | ||
350 | /* If we have a client but no subdev, then something went wrong and | ||
351 | we must unregister the client. */ | ||
352 | if (client && sd == NULL) | ||
353 | i2c_unregister_device(client); | ||
354 | return sd; | ||
355 | } | ||
356 | EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_board); | ||
357 | |||
358 | struct v4l2_subdev *v4l2_i2c_new_subdev(struct v4l2_device *v4l2_dev, | ||
359 | struct i2c_adapter *adapter, const char *client_type, | ||
360 | u8 addr, const unsigned short *probe_addrs) | ||
361 | { | ||
362 | struct i2c_board_info info; | ||
363 | |||
364 | /* Setup the i2c board info with the device type and | ||
365 | the device address. */ | ||
366 | memset(&info, 0, sizeof(info)); | ||
367 | strlcpy(info.type, client_type, sizeof(info.type)); | ||
368 | info.addr = addr; | ||
369 | |||
370 | return v4l2_i2c_new_subdev_board(v4l2_dev, adapter, &info, probe_addrs); | ||
371 | } | ||
372 | EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev); | ||
373 | |||
374 | /* Return i2c client address of v4l2_subdev. */ | ||
375 | unsigned short v4l2_i2c_subdev_addr(struct v4l2_subdev *sd) | ||
376 | { | ||
377 | struct i2c_client *client = v4l2_get_subdevdata(sd); | ||
378 | |||
379 | return client ? client->addr : I2C_CLIENT_END; | ||
380 | } | ||
381 | EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_addr); | ||
382 | |||
383 | /* Return a list of I2C tuner addresses to probe. Use only if the tuner | ||
384 | addresses are unknown. */ | ||
385 | const unsigned short *v4l2_i2c_tuner_addrs(enum v4l2_i2c_tuner_type type) | ||
386 | { | ||
387 | static const unsigned short radio_addrs[] = { | ||
388 | #if defined(CONFIG_MEDIA_TUNER_TEA5761) || defined(CONFIG_MEDIA_TUNER_TEA5761_MODULE) | ||
389 | 0x10, | ||
390 | #endif | ||
391 | 0x60, | ||
392 | I2C_CLIENT_END | ||
393 | }; | ||
394 | static const unsigned short demod_addrs[] = { | ||
395 | 0x42, 0x43, 0x4a, 0x4b, | ||
396 | I2C_CLIENT_END | ||
397 | }; | ||
398 | static const unsigned short tv_addrs[] = { | ||
399 | 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */ | ||
400 | 0x60, 0x61, 0x62, 0x63, 0x64, | ||
401 | I2C_CLIENT_END | ||
402 | }; | ||
403 | |||
404 | switch (type) { | ||
405 | case ADDRS_RADIO: | ||
406 | return radio_addrs; | ||
407 | case ADDRS_DEMOD: | ||
408 | return demod_addrs; | ||
409 | case ADDRS_TV: | ||
410 | return tv_addrs; | ||
411 | case ADDRS_TV_WITH_DEMOD: | ||
412 | return tv_addrs + 4; | ||
413 | } | ||
414 | return NULL; | ||
415 | } | ||
416 | EXPORT_SYMBOL_GPL(v4l2_i2c_tuner_addrs); | ||
417 | |||
418 | #endif /* defined(CONFIG_I2C) */ | ||
419 | |||
420 | #if defined(CONFIG_SPI) | ||
421 | |||
422 | /* Load a spi sub-device. */ | ||
423 | |||
424 | void v4l2_spi_subdev_init(struct v4l2_subdev *sd, struct spi_device *spi, | ||
425 | const struct v4l2_subdev_ops *ops) | ||
426 | { | ||
427 | v4l2_subdev_init(sd, ops); | ||
428 | sd->flags |= V4L2_SUBDEV_FL_IS_SPI; | ||
429 | /* the owner is the same as the spi_device's driver owner */ | ||
430 | sd->owner = spi->dev.driver->owner; | ||
431 | /* spi_device and v4l2_subdev point to one another */ | ||
432 | v4l2_set_subdevdata(sd, spi); | ||
433 | spi_set_drvdata(spi, sd); | ||
434 | /* initialize name */ | ||
435 | strlcpy(sd->name, spi->dev.driver->name, sizeof(sd->name)); | ||
436 | } | ||
437 | EXPORT_SYMBOL_GPL(v4l2_spi_subdev_init); | ||
438 | |||
439 | struct v4l2_subdev *v4l2_spi_new_subdev(struct v4l2_device *v4l2_dev, | ||
440 | struct spi_master *master, struct spi_board_info *info) | ||
441 | { | ||
442 | struct v4l2_subdev *sd = NULL; | ||
443 | struct spi_device *spi = NULL; | ||
444 | |||
445 | BUG_ON(!v4l2_dev); | ||
446 | |||
447 | if (info->modalias) | ||
448 | request_module(info->modalias); | ||
449 | |||
450 | spi = spi_new_device(master, info); | ||
451 | |||
452 | if (spi == NULL || spi->dev.driver == NULL) | ||
453 | goto error; | ||
454 | |||
455 | if (!try_module_get(spi->dev.driver->owner)) | ||
456 | goto error; | ||
457 | |||
458 | sd = spi_get_drvdata(spi); | ||
459 | |||
460 | /* Register with the v4l2_device which increases the module's | ||
461 | use count as well. */ | ||
462 | if (v4l2_device_register_subdev(v4l2_dev, sd)) | ||
463 | sd = NULL; | ||
464 | |||
465 | /* Decrease the module use count to match the first try_module_get. */ | ||
466 | module_put(spi->dev.driver->owner); | ||
467 | |||
468 | error: | ||
469 | /* If we have a client but no subdev, then something went wrong and | ||
470 | we must unregister the client. */ | ||
471 | if (spi && sd == NULL) | ||
472 | spi_unregister_device(spi); | ||
473 | |||
474 | return sd; | ||
475 | } | ||
476 | EXPORT_SYMBOL_GPL(v4l2_spi_new_subdev); | ||
477 | |||
478 | #endif /* defined(CONFIG_SPI) */ | ||
479 | |||
480 | /* Clamp x to be between min and max, aligned to a multiple of 2^align. min | ||
481 | * and max don't have to be aligned, but there must be at least one valid | ||
482 | * value. E.g., min=17,max=31,align=4 is not allowed as there are no multiples | ||
483 | * of 16 between 17 and 31. */ | ||
484 | static unsigned int clamp_align(unsigned int x, unsigned int min, | ||
485 | unsigned int max, unsigned int align) | ||
486 | { | ||
487 | /* Bits that must be zero to be aligned */ | ||
488 | unsigned int mask = ~((1 << align) - 1); | ||
489 | |||
490 | /* Round to nearest aligned value */ | ||
491 | if (align) | ||
492 | x = (x + (1 << (align - 1))) & mask; | ||
493 | |||
494 | /* Clamp to aligned value of min and max */ | ||
495 | if (x < min) | ||
496 | x = (min + ~mask) & mask; | ||
497 | else if (x > max) | ||
498 | x = max & mask; | ||
499 | |||
500 | return x; | ||
501 | } | ||
502 | |||
503 | /* Bound an image to have a width between wmin and wmax, and height between | ||
504 | * hmin and hmax, inclusive. Additionally, the width will be a multiple of | ||
505 | * 2^walign, the height will be a multiple of 2^halign, and the overall size | ||
506 | * (width*height) will be a multiple of 2^salign. The image may be shrunk | ||
507 | * or enlarged to fit the alignment constraints. | ||
508 | * | ||
509 | * The width or height maximum must not be smaller than the corresponding | ||
510 | * minimum. The alignments must not be so high there are no possible image | ||
511 | * sizes within the allowed bounds. wmin and hmin must be at least 1 | ||
512 | * (don't use 0). If you don't care about a certain alignment, specify 0, | ||
513 | * as 2^0 is 1 and one byte alignment is equivalent to no alignment. If | ||
514 | * you only want to adjust downward, specify a maximum that's the same as | ||
515 | * the initial value. | ||
516 | */ | ||
517 | void v4l_bound_align_image(u32 *w, unsigned int wmin, unsigned int wmax, | ||
518 | unsigned int walign, | ||
519 | u32 *h, unsigned int hmin, unsigned int hmax, | ||
520 | unsigned int halign, unsigned int salign) | ||
521 | { | ||
522 | *w = clamp_align(*w, wmin, wmax, walign); | ||
523 | *h = clamp_align(*h, hmin, hmax, halign); | ||
524 | |||
525 | /* Usually we don't need to align the size and are done now. */ | ||
526 | if (!salign) | ||
527 | return; | ||
528 | |||
529 | /* How much alignment do we have? */ | ||
530 | walign = __ffs(*w); | ||
531 | halign = __ffs(*h); | ||
532 | /* Enough to satisfy the image alignment? */ | ||
533 | if (walign + halign < salign) { | ||
534 | /* Max walign where there is still a valid width */ | ||
535 | unsigned int wmaxa = __fls(wmax ^ (wmin - 1)); | ||
536 | /* Max halign where there is still a valid height */ | ||
537 | unsigned int hmaxa = __fls(hmax ^ (hmin - 1)); | ||
538 | |||
539 | /* up the smaller alignment until we have enough */ | ||
540 | do { | ||
541 | if (halign >= hmaxa || | ||
542 | (walign <= halign && walign < wmaxa)) { | ||
543 | *w = clamp_align(*w, wmin, wmax, walign + 1); | ||
544 | walign = __ffs(*w); | ||
545 | } else { | ||
546 | *h = clamp_align(*h, hmin, hmax, halign + 1); | ||
547 | halign = __ffs(*h); | ||
548 | } | ||
549 | } while (halign + walign < salign); | ||
550 | } | ||
551 | } | ||
552 | EXPORT_SYMBOL_GPL(v4l_bound_align_image); | ||
553 | |||
554 | /** | ||
555 | * v4l_fill_dv_preset_info - fill description of a digital video preset | ||
556 | * @preset - preset value | ||
557 | * @info - pointer to struct v4l2_dv_enum_preset | ||
558 | * | ||
559 | * drivers can use this helper function to fill description of dv preset | ||
560 | * in info. | ||
561 | */ | ||
562 | int v4l_fill_dv_preset_info(u32 preset, struct v4l2_dv_enum_preset *info) | ||
563 | { | ||
564 | static const struct v4l2_dv_preset_info { | ||
565 | u16 width; | ||
566 | u16 height; | ||
567 | const char *name; | ||
568 | } dv_presets[] = { | ||
569 | { 0, 0, "Invalid" }, /* V4L2_DV_INVALID */ | ||
570 | { 720, 480, "480p@59.94" }, /* V4L2_DV_480P59_94 */ | ||
571 | { 720, 576, "576p@50" }, /* V4L2_DV_576P50 */ | ||
572 | { 1280, 720, "720p@24" }, /* V4L2_DV_720P24 */ | ||
573 | { 1280, 720, "720p@25" }, /* V4L2_DV_720P25 */ | ||
574 | { 1280, 720, "720p@30" }, /* V4L2_DV_720P30 */ | ||
575 | { 1280, 720, "720p@50" }, /* V4L2_DV_720P50 */ | ||
576 | { 1280, 720, "720p@59.94" }, /* V4L2_DV_720P59_94 */ | ||
577 | { 1280, 720, "720p@60" }, /* V4L2_DV_720P60 */ | ||
578 | { 1920, 1080, "1080i@29.97" }, /* V4L2_DV_1080I29_97 */ | ||
579 | { 1920, 1080, "1080i@30" }, /* V4L2_DV_1080I30 */ | ||
580 | { 1920, 1080, "1080i@25" }, /* V4L2_DV_1080I25 */ | ||
581 | { 1920, 1080, "1080i@50" }, /* V4L2_DV_1080I50 */ | ||
582 | { 1920, 1080, "1080i@60" }, /* V4L2_DV_1080I60 */ | ||
583 | { 1920, 1080, "1080p@24" }, /* V4L2_DV_1080P24 */ | ||
584 | { 1920, 1080, "1080p@25" }, /* V4L2_DV_1080P25 */ | ||
585 | { 1920, 1080, "1080p@30" }, /* V4L2_DV_1080P30 */ | ||
586 | { 1920, 1080, "1080p@50" }, /* V4L2_DV_1080P50 */ | ||
587 | { 1920, 1080, "1080p@60" }, /* V4L2_DV_1080P60 */ | ||
588 | }; | ||
589 | |||
590 | if (info == NULL || preset >= ARRAY_SIZE(dv_presets)) | ||
591 | return -EINVAL; | ||
592 | |||
593 | info->preset = preset; | ||
594 | info->width = dv_presets[preset].width; | ||
595 | info->height = dv_presets[preset].height; | ||
596 | strlcpy(info->name, dv_presets[preset].name, sizeof(info->name)); | ||
597 | return 0; | ||
598 | } | ||
599 | EXPORT_SYMBOL_GPL(v4l_fill_dv_preset_info); | ||
600 | |||
601 | const struct v4l2_frmsize_discrete *v4l2_find_nearest_format( | ||
602 | const struct v4l2_discrete_probe *probe, | ||
603 | s32 width, s32 height) | ||
604 | { | ||
605 | int i; | ||
606 | u32 error, min_error = UINT_MAX; | ||
607 | const struct v4l2_frmsize_discrete *size, *best = NULL; | ||
608 | |||
609 | if (!probe) | ||
610 | return best; | ||
611 | |||
612 | for (i = 0, size = probe->sizes; i < probe->num_sizes; i++, size++) { | ||
613 | error = abs(size->width - width) + abs(size->height - height); | ||
614 | if (error < min_error) { | ||
615 | min_error = error; | ||
616 | best = size; | ||
617 | } | ||
618 | if (!error) | ||
619 | break; | ||
620 | } | ||
621 | |||
622 | return best; | ||
623 | } | ||
624 | EXPORT_SYMBOL_GPL(v4l2_find_nearest_format); | ||