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