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> |
3434eb7e | 64 | #include <media/v4l2-chip-ident.h> |
1da177e4 | 65 | |
33b687cf | 66 | #include <linux/videodev2.h> |
1da177e4 LT |
67 | |
68 | MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr"); | |
69 | MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers"); | |
70 | MODULE_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 | ||
9cb2318b HV |
82 | /* 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. */ | |
87 | int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl, | |
513521ea | 88 | const char * const *menu_items) |
9cb2318b HV |
89 | { |
90 | if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED) | |
91 | return -EINVAL; | |
92 | if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED) | |
93 | return -EBUSY; | |
6b5a9492 HV |
94 | if (qctrl->type == V4L2_CTRL_TYPE_STRING) |
95 | return 0; | |
9cb2318b HV |
96 | 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 | } | |
fa4d7096 HV |
107 | if (qctrl->type == V4L2_CTRL_TYPE_BITMASK && |
108 | (ctrl->value & ~qctrl->maximum)) | |
109 | return -ERANGE; | |
9cb2318b HV |
110 | return 0; |
111 | } | |
057596ee | 112 | EXPORT_SYMBOL(v4l2_ctrl_check); |
9cb2318b | 113 | |
69028d70 HV |
114 | /* Fill in a struct v4l2_queryctrl */ |
115 | int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def) | |
116 | { | |
0996517c HV |
117 | const char *name; |
118 | ||
119 | v4l2_ctrl_fill(qctrl->id, &name, &qctrl->type, | |
120 | &min, &max, &step, &def, &qctrl->flags); | |
69028d70 | 121 | |
69028d70 HV |
122 | if (name == NULL) |
123 | return -EINVAL; | |
124 | ||
9cb2318b HV |
125 | qctrl->minimum = min; |
126 | qctrl->maximum = max; | |
127 | qctrl->step = step; | |
128 | qctrl->default_value = def; | |
129 | qctrl->reserved[0] = qctrl->reserved[1] = 0; | |
b634a93f | 130 | strlcpy(qctrl->name, name, sizeof(qctrl->name)); |
9cb2318b HV |
131 | return 0; |
132 | } | |
057596ee | 133 | EXPORT_SYMBOL(v4l2_ctrl_query_fill); |
9cb2318b | 134 | |
9cb2318b | 135 | /* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and |
e281db58 HV |
136 | 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. */ | |
9cb2318b | 139 | int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl, |
513521ea | 140 | const char * const *menu_items) |
9cb2318b HV |
141 | { |
142 | int i; | |
143 | ||
1e551266 | 144 | qmenu->reserved = 0; |
e281db58 HV |
145 | if (menu_items == NULL) |
146 | menu_items = v4l2_ctrl_get_menu(qmenu->id); | |
9cb2318b HV |
147 | 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; | |
b634a93f | 153 | strlcpy(qmenu->name, menu_items[qmenu->index], sizeof(qmenu->name)); |
9cb2318b HV |
154 | return 0; |
155 | } | |
057596ee | 156 | EXPORT_SYMBOL(v4l2_ctrl_query_menu); |
9cb2318b | 157 | |
1e551266 HV |
158 | /* 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. */ | |
161 | int v4l2_ctrl_query_menu_valid_items(struct v4l2_querymenu *qmenu, const u32 *ids) | |
162 | { | |
513521ea | 163 | const char * const *menu_items = v4l2_ctrl_get_menu(qmenu->id); |
1e551266 HV |
164 | |
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) { | |
b634a93f HV |
170 | strlcpy(qmenu->name, menu_items[qmenu->index], |
171 | sizeof(qmenu->name)); | |
1e551266 HV |
172 | return 0; |
173 | } | |
174 | } | |
175 | return -EINVAL; | |
176 | } | |
177 | EXPORT_SYMBOL(v4l2_ctrl_query_menu_valid_items); | |
178 | ||
9cb2318b HV |
179 | /* 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 | |
2ba58894 | 182 | class. The array of u32 pointers must also be sorted, from low class IDs |
9cb2318b HV |
183 | 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. */ | |
187 | u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id) | |
188 | { | |
a46c5fbc | 189 | u32 ctrl_class = V4L2_CTRL_ID2CLASS(id); |
9cb2318b HV |
190 | const u32 *pctrl; |
191 | ||
9cb2318b HV |
192 | if (ctrl_classes == NULL) |
193 | return 0; | |
a46c5fbc HV |
194 | |
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 | } | |
9cb2318b | 207 | id &= V4L2_CTRL_ID_MASK; |
9cb2318b HV |
208 | 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 | } | |
057596ee | 228 | EXPORT_SYMBOL(v4l2_ctrl_next); |
9cb2318b | 229 | |
aecde8b5 | 230 | int v4l2_chip_match_host(const struct v4l2_dbg_match *match) |
a9254475 | 231 | { |
aecde8b5 | 232 | switch (match->type) { |
a9254475 | 233 | case V4L2_CHIP_MATCH_HOST: |
aecde8b5 | 234 | return match->addr == 0; |
a9254475 MCC |
235 | default: |
236 | return 0; | |
237 | } | |
238 | } | |
239 | EXPORT_SYMBOL(v4l2_chip_match_host); | |
240 | ||
241 | #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE)) | |
aecde8b5 | 242 | int v4l2_chip_match_i2c_client(struct i2c_client *c, const struct v4l2_dbg_match *match) |
f3d092b8 | 243 | { |
aecde8b5 HV |
244 | int len; |
245 | ||
246 | if (c == NULL || match == NULL) | |
247 | return 0; | |
248 | ||
249 | switch (match->type) { | |
f3d092b8 | 250 | case V4L2_CHIP_MATCH_I2C_DRIVER: |
aecde8b5 HV |
251 | 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); | |
f3d092b8 | 258 | case V4L2_CHIP_MATCH_I2C_ADDR: |
aecde8b5 | 259 | return c->addr == match->addr; |
f3d092b8 HV |
260 | default: |
261 | return 0; | |
262 | } | |
263 | } | |
a9254475 | 264 | EXPORT_SYMBOL(v4l2_chip_match_i2c_client); |
f3d092b8 | 265 | |
aecde8b5 | 266 | int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_dbg_chip_ident *chip, |
3434eb7e HV |
267 | u32 ident, u32 revision) |
268 | { | |
aecde8b5 | 269 | if (!v4l2_chip_match_i2c_client(c, &chip->match)) |
3434eb7e HV |
270 | 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 | } | |
a9254475 | 281 | EXPORT_SYMBOL(v4l2_chip_ident_i2c_client); |
f3d092b8 | 282 | |
9cb2318b HV |
283 | /* ----------------------------------------------------------------- */ |
284 | ||
78a3b4db | 285 | /* I2C Helper functions */ |
8ffbc655 | 286 | |
dd99120c HV |
287 | |
288 | void 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); | |
b5b2b7ed | 292 | sd->flags |= V4L2_SUBDEV_FL_IS_I2C; |
dd99120c HV |
293 | /* 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 | } | |
303 | EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init); | |
304 | ||
305 | ||
306 | ||
f0222c7d HV |
307 | /* Load an i2c sub-device. */ |
308 | struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev, | |
9a1f8b34 LP |
309 | struct i2c_adapter *adapter, struct i2c_board_info *info, |
310 | const unsigned short *probe_addrs) | |
f0222c7d HV |
311 | { |
312 | struct v4l2_subdev *sd = NULL; | |
313 | struct i2c_client *client; | |
314 | ||
315 | BUG_ON(!v4l2_dev); | |
316 | ||
9a1f8b34 | 317 | request_module(I2C_MODULE_PREFIX "%s", info->type); |
f0222c7d HV |
318 | |
319 | /* Create the i2c client */ | |
320 | if (info->addr == 0 && probe_addrs) | |
9a94241a JD |
321 | client = i2c_new_probed_device(adapter, info, probe_addrs, |
322 | NULL); | |
f0222c7d HV |
323 | 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 | ||
f0222c7d HV |
348 | error: |
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 | } | |
355 | EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_board); | |
356 | ||
3c7c9370 | 357 | struct v4l2_subdev *v4l2_i2c_new_subdev(struct v4l2_device *v4l2_dev, |
9a1f8b34 | 358 | struct i2c_adapter *adapter, const char *client_type, |
f0222c7d HV |
359 | 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; | |
f0222c7d | 368 | |
9a1f8b34 | 369 | return v4l2_i2c_new_subdev_board(v4l2_dev, adapter, &info, probe_addrs); |
f0222c7d | 370 | } |
3c7c9370 | 371 | EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev); |
f0222c7d | 372 | |
ab373190 HV |
373 | /* Return i2c client address of v4l2_subdev. */ |
374 | unsigned 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 | } | |
380 | EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_addr); | |
381 | ||
c7d29e2f HV |
382 | /* Return a list of I2C tuner addresses to probe. Use only if the tuner |
383 | addresses are unknown. */ | |
384 | const 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 */ | |
416a7aa8 | 399 | 0x60, 0x61, 0x62, 0x63, 0x64, |
c7d29e2f HV |
400 | 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 | } | |
415 | EXPORT_SYMBOL_GPL(v4l2_i2c_tuner_addrs); | |
416 | ||
d8b29966 TP |
417 | #endif /* defined(CONFIG_I2C) */ |
418 | ||
85e09219 DB |
419 | #if defined(CONFIG_SPI) |
420 | ||
421 | /* Load a spi sub-device. */ | |
422 | ||
423 | void 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 | } | |
436 | EXPORT_SYMBOL_GPL(v4l2_spi_subdev_init); | |
437 | ||
438 | struct 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 | ||
467 | error: | |
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 | } | |
475 | EXPORT_SYMBOL_GPL(v4l2_spi_new_subdev); | |
476 | ||
477 | #endif /* defined(CONFIG_SPI) */ | |
478 | ||
b0d3159b TP |
479 | /* 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. */ | |
483 | static 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 | */ | |
516 | void 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 | } | |
551 | EXPORT_SYMBOL_GPL(v4l_bound_align_image); | |
2e535ed5 MK |
552 | |
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 | */ | |
561 | int 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 | } | |
598 | EXPORT_SYMBOL_GPL(v4l_fill_dv_preset_info); | |
79c6ff93 | 599 | |
3fd8e647 HV |
600 | const struct v4l2_frmsize_discrete *v4l2_find_nearest_format( |
601 | const struct v4l2_discrete_probe *probe, | |
602 | s32 width, s32 height) | |
79c6ff93 GL |
603 | { |
604 | int i; | |
605 | u32 error, min_error = UINT_MAX; | |
3fd8e647 | 606 | const struct v4l2_frmsize_discrete *size, *best = NULL; |
79c6ff93 GL |
607 | |
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 | } | |
623 | EXPORT_SYMBOL_GPL(v4l2_find_nearest_format); |