blob: b91d66a767d70a3fa825d9c309941fc358d9ee94 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#include <asm/uaccess.h>
55#include <asm/system.h>
56#include <asm/pgtable.h>
57#include <asm/io.h>
58#include <asm/div64.h>
Mauro Carvalho Chehab401998f2006-06-04 10:06:18 -030059#define __OLD_VIDIOC_ /* To allow fixing old calls*/
Michael Krufky5e453dc2006-01-09 15:32:31 -020060#include <media/v4l2-common.h>
Hans Verkuildd991202008-11-23 12:19:45 -030061#include <media/v4l2-device.h>
Hans Verkuil3434eb72007-04-27 12:31:08 -030062#include <media/v4l2-chip-ident.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
Hans Verkuil33b687c2008-07-25 05:32:50 -030064#include <linux/videodev2.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
67MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
68MODULE_LICENSE("GPL");
69
70/*
71 *
72 * V 4 L 2 D R I V E R H E L P E R A P I
73 *
74 */
75
76/*
77 * Video Standard Operations (contributed by Michael Schimek)
78 */
79
Linus Torvalds1da177e2005-04-16 15:20:36 -070080
Linus Torvalds1da177e2005-04-16 15:20:36 -070081/* ----------------------------------------------------------------- */
82/* priority handling */
83
84#define V4L2_PRIO_VALID(val) (val == V4L2_PRIORITY_BACKGROUND || \
85 val == V4L2_PRIORITY_INTERACTIVE || \
86 val == V4L2_PRIORITY_RECORD)
87
88int v4l2_prio_init(struct v4l2_prio_state *global)
89{
90 memset(global,0,sizeof(*global));
91 return 0;
92}
Mauro Carvalho Chehab057596e2008-02-02 11:25:31 -030093EXPORT_SYMBOL(v4l2_prio_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
95int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
96 enum v4l2_priority new)
97{
98 if (!V4L2_PRIO_VALID(new))
99 return -EINVAL;
100 if (*local == new)
101 return 0;
102
103 atomic_inc(&global->prios[new]);
104 if (V4L2_PRIO_VALID(*local))
105 atomic_dec(&global->prios[*local]);
106 *local = new;
107 return 0;
108}
Mauro Carvalho Chehab057596e2008-02-02 11:25:31 -0300109EXPORT_SYMBOL(v4l2_prio_change);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111int v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
112{
113 return v4l2_prio_change(global,local,V4L2_PRIORITY_DEFAULT);
114}
Mauro Carvalho Chehab057596e2008-02-02 11:25:31 -0300115EXPORT_SYMBOL(v4l2_prio_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
117int v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority *local)
118{
119 if (V4L2_PRIO_VALID(*local))
120 atomic_dec(&global->prios[*local]);
121 return 0;
122}
Mauro Carvalho Chehab057596e2008-02-02 11:25:31 -0300123EXPORT_SYMBOL(v4l2_prio_close);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124
125enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global)
126{
127 if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0)
128 return V4L2_PRIORITY_RECORD;
129 if (atomic_read(&global->prios[V4L2_PRIORITY_INTERACTIVE]) > 0)
130 return V4L2_PRIORITY_INTERACTIVE;
131 if (atomic_read(&global->prios[V4L2_PRIORITY_BACKGROUND]) > 0)
132 return V4L2_PRIORITY_BACKGROUND;
133 return V4L2_PRIORITY_UNSET;
134}
Mauro Carvalho Chehab057596e2008-02-02 11:25:31 -0300135EXPORT_SYMBOL(v4l2_prio_max);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
137int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority *local)
138{
139 if (*local < v4l2_prio_max(global))
140 return -EBUSY;
141 return 0;
142}
Mauro Carvalho Chehab057596e2008-02-02 11:25:31 -0300143EXPORT_SYMBOL(v4l2_prio_check);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
145/* ----------------------------------------------------------------- */
146
Hans Verkuil9cb23182006-06-18 14:11:08 -0300147/* 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. */
152int 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;
159 if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
160 qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
161 qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
162 return 0;
163 if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
164 return -ERANGE;
165 if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
166 if (menu_items[ctrl->value] == NULL ||
167 menu_items[ctrl->value][0] == '\0')
168 return -EINVAL;
169 }
170 return 0;
171}
Mauro Carvalho Chehab057596e2008-02-02 11:25:31 -0300172EXPORT_SYMBOL(v4l2_ctrl_check);
Hans Verkuil9cb23182006-06-18 14:11:08 -0300173
174/* Returns NULL or a character pointer array containing the menu for
175 the given control ID. The pointer array ends with a NULL pointer.
176 An empty string signifies a menu entry that is invalid. This allows
177 drivers to disable certain options if it is not supported. */
178const char **v4l2_ctrl_get_menu(u32 id)
179{
180 static const char *mpeg_audio_sampling_freq[] = {
181 "44.1 kHz",
182 "48 kHz",
183 "32 kHz",
184 NULL
185 };
186 static const char *mpeg_audio_encoding[] = {
Hans Verkuile6b5da82008-08-08 07:38:07 -0300187 "MPEG-1/2 Layer I",
188 "MPEG-1/2 Layer II",
189 "MPEG-1/2 Layer III",
190 "MPEG-2/4 AAC",
191 "AC-3",
Hans Verkuil9cb23182006-06-18 14:11:08 -0300192 NULL
193 };
194 static const char *mpeg_audio_l1_bitrate[] = {
195 "32 kbps",
196 "64 kbps",
197 "96 kbps",
198 "128 kbps",
199 "160 kbps",
200 "192 kbps",
201 "224 kbps",
202 "256 kbps",
203 "288 kbps",
204 "320 kbps",
205 "352 kbps",
206 "384 kbps",
207 "416 kbps",
208 "448 kbps",
209 NULL
210 };
211 static const char *mpeg_audio_l2_bitrate[] = {
212 "32 kbps",
213 "48 kbps",
214 "56 kbps",
215 "64 kbps",
216 "80 kbps",
217 "96 kbps",
218 "112 kbps",
219 "128 kbps",
220 "160 kbps",
221 "192 kbps",
222 "224 kbps",
223 "256 kbps",
224 "320 kbps",
225 "384 kbps",
226 NULL
227 };
228 static const char *mpeg_audio_l3_bitrate[] = {
229 "32 kbps",
230 "40 kbps",
231 "48 kbps",
232 "56 kbps",
233 "64 kbps",
234 "80 kbps",
235 "96 kbps",
236 "112 kbps",
237 "128 kbps",
238 "160 kbps",
239 "192 kbps",
240 "224 kbps",
241 "256 kbps",
242 "320 kbps",
243 NULL
244 };
Hans Verkuile6b5da82008-08-08 07:38:07 -0300245 static const char *mpeg_audio_ac3_bitrate[] = {
246 "32 kbps",
247 "40 kbps",
248 "48 kbps",
249 "56 kbps",
250 "64 kbps",
251 "80 kbps",
252 "96 kbps",
253 "112 kbps",
254 "128 kbps",
255 "160 kbps",
256 "192 kbps",
257 "224 kbps",
258 "256 kbps",
259 "320 kbps",
260 "384 kbps",
261 "448 kbps",
262 "512 kbps",
263 "576 kbps",
264 "640 kbps",
265 NULL
266 };
Hans Verkuil9cb23182006-06-18 14:11:08 -0300267 static const char *mpeg_audio_mode[] = {
268 "Stereo",
269 "Joint Stereo",
270 "Dual",
271 "Mono",
272 NULL
273 };
274 static const char *mpeg_audio_mode_extension[] = {
275 "Bound 4",
276 "Bound 8",
277 "Bound 12",
278 "Bound 16",
279 NULL
280 };
281 static const char *mpeg_audio_emphasis[] = {
282 "No Emphasis",
283 "50/15 us",
284 "CCITT J17",
285 NULL
286 };
287 static const char *mpeg_audio_crc[] = {
288 "No CRC",
289 "16-bit CRC",
290 NULL
291 };
292 static const char *mpeg_video_encoding[] = {
293 "MPEG-1",
294 "MPEG-2",
Janne Grunau188919a2008-08-08 07:21:00 -0300295 "MPEG-4 AVC",
Hans Verkuil9cb23182006-06-18 14:11:08 -0300296 NULL
297 };
298 static const char *mpeg_video_aspect[] = {
299 "1x1",
300 "4x3",
301 "16x9",
302 "2.21x1",
303 NULL
304 };
305 static const char *mpeg_video_bitrate_mode[] = {
306 "Variable Bitrate",
307 "Constant Bitrate",
308 NULL
309 };
310 static const char *mpeg_stream_type[] = {
311 "MPEG-2 Program Stream",
312 "MPEG-2 Transport Stream",
313 "MPEG-1 System Stream",
314 "MPEG-2 DVD-compatible Stream",
315 "MPEG-1 VCD-compatible Stream",
316 "MPEG-2 SVCD-compatible Stream",
317 NULL
318 };
Hans Verkuil8cbde942006-06-24 14:36:02 -0300319 static const char *mpeg_stream_vbi_fmt[] = {
320 "No VBI",
Hans Verkuil99523512006-06-25 11:18:54 -0300321 "Private packet, IVTV format",
Hans Verkuil8cbde942006-06-24 14:36:02 -0300322 NULL
323 };
Laurent Pinchart74980152008-12-14 16:24:04 -0300324 static const char *camera_power_line_frequency[] = {
325 "Disabled",
326 "50 Hz",
327 "60 Hz",
328 NULL
329 };
330 static const char *camera_exposure_auto[] = {
331 "Auto Mode",
332 "Manual Mode",
333 "Shutter Priority Mode",
334 "Aperture Priority Mode",
335 NULL
336 };
Hans Verkuil11c469e2009-02-20 05:50:52 -0300337 static const char *colorfx[] = {
338 "None",
339 "Black & White",
340 "Sepia",
341 NULL
342 };
Hans Verkuil9cb23182006-06-18 14:11:08 -0300343
344 switch (id) {
345 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
346 return mpeg_audio_sampling_freq;
347 case V4L2_CID_MPEG_AUDIO_ENCODING:
348 return mpeg_audio_encoding;
349 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
350 return mpeg_audio_l1_bitrate;
351 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
352 return mpeg_audio_l2_bitrate;
353 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
354 return mpeg_audio_l3_bitrate;
Hans Verkuile6b5da82008-08-08 07:38:07 -0300355 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
356 return mpeg_audio_ac3_bitrate;
Hans Verkuil9cb23182006-06-18 14:11:08 -0300357 case V4L2_CID_MPEG_AUDIO_MODE:
358 return mpeg_audio_mode;
359 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
360 return mpeg_audio_mode_extension;
361 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
362 return mpeg_audio_emphasis;
363 case V4L2_CID_MPEG_AUDIO_CRC:
364 return mpeg_audio_crc;
365 case V4L2_CID_MPEG_VIDEO_ENCODING:
366 return mpeg_video_encoding;
367 case V4L2_CID_MPEG_VIDEO_ASPECT:
368 return mpeg_video_aspect;
369 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
370 return mpeg_video_bitrate_mode;
371 case V4L2_CID_MPEG_STREAM_TYPE:
372 return mpeg_stream_type;
Hans Verkuil8cbde942006-06-24 14:36:02 -0300373 case V4L2_CID_MPEG_STREAM_VBI_FMT:
374 return mpeg_stream_vbi_fmt;
Laurent Pinchart74980152008-12-14 16:24:04 -0300375 case V4L2_CID_POWER_LINE_FREQUENCY:
376 return camera_power_line_frequency;
377 case V4L2_CID_EXPOSURE_AUTO:
378 return camera_exposure_auto;
Hans Verkuil11c469e2009-02-20 05:50:52 -0300379 case V4L2_CID_COLORFX:
380 return colorfx;
Hans Verkuil9cb23182006-06-18 14:11:08 -0300381 default:
382 return NULL;
383 }
384}
Mauro Carvalho Chehab057596e2008-02-02 11:25:31 -0300385EXPORT_SYMBOL(v4l2_ctrl_get_menu);
Hans Verkuil9cb23182006-06-18 14:11:08 -0300386
Hans Verkuil69028d72008-08-08 07:55:00 -0300387/* Return the control name. */
388const char *v4l2_ctrl_get_name(u32 id)
389{
390 switch (id) {
391 /* USER controls */
Laurent Pinchart74980152008-12-14 16:24:04 -0300392 case V4L2_CID_USER_CLASS: return "User Controls";
Laurent Pinchart74980152008-12-14 16:24:04 -0300393 case V4L2_CID_BRIGHTNESS: return "Brightness";
394 case V4L2_CID_CONTRAST: return "Contrast";
395 case V4L2_CID_SATURATION: return "Saturation";
396 case V4L2_CID_HUE: return "Hue";
Hans Verkuil81dde912009-02-20 06:30:12 -0300397 case V4L2_CID_AUDIO_VOLUME: return "Volume";
398 case V4L2_CID_AUDIO_BALANCE: return "Balance";
399 case V4L2_CID_AUDIO_BASS: return "Bass";
400 case V4L2_CID_AUDIO_TREBLE: return "Treble";
401 case V4L2_CID_AUDIO_MUTE: return "Mute";
402 case V4L2_CID_AUDIO_LOUDNESS: return "Loudness";
Laurent Pinchart74980152008-12-14 16:24:04 -0300403 case V4L2_CID_BLACK_LEVEL: return "Black Level";
404 case V4L2_CID_AUTO_WHITE_BALANCE: return "White Balance, Automatic";
405 case V4L2_CID_DO_WHITE_BALANCE: return "Do White Balance";
406 case V4L2_CID_RED_BALANCE: return "Red Balance";
407 case V4L2_CID_BLUE_BALANCE: return "Blue Balance";
408 case V4L2_CID_GAMMA: return "Gamma";
409 case V4L2_CID_EXPOSURE: return "Exposure";
410 case V4L2_CID_AUTOGAIN: return "Gain, Automatic";
411 case V4L2_CID_GAIN: return "Gain";
412 case V4L2_CID_HFLIP: return "Horizontal Flip";
413 case V4L2_CID_VFLIP: return "Vertical Flip";
414 case V4L2_CID_HCENTER: return "Horizontal Center";
415 case V4L2_CID_VCENTER: return "Vertical Center";
416 case V4L2_CID_POWER_LINE_FREQUENCY: return "Power Line Frequency";
417 case V4L2_CID_HUE_AUTO: return "Hue, Automatic";
418 case V4L2_CID_WHITE_BALANCE_TEMPERATURE: return "White Balance Temperature";
419 case V4L2_CID_SHARPNESS: return "Sharpness";
420 case V4L2_CID_BACKLIGHT_COMPENSATION: return "Backlight Compensation";
421 case V4L2_CID_CHROMA_AGC: return "Chroma AGC";
422 case V4L2_CID_COLOR_KILLER: return "Color Killer";
Hans Verkuil11c469e2009-02-20 05:50:52 -0300423 case V4L2_CID_COLORFX: return "Color Effects";
Hans Verkuil69028d72008-08-08 07:55:00 -0300424
425 /* MPEG controls */
426 case V4L2_CID_MPEG_CLASS: return "MPEG Encoder Controls";
427 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: return "Audio Sampling Frequency";
428 case V4L2_CID_MPEG_AUDIO_ENCODING: return "Audio Encoding";
429 case V4L2_CID_MPEG_AUDIO_L1_BITRATE: return "Audio Layer I Bitrate";
430 case V4L2_CID_MPEG_AUDIO_L2_BITRATE: return "Audio Layer II Bitrate";
431 case V4L2_CID_MPEG_AUDIO_L3_BITRATE: return "Audio Layer III Bitrate";
Hans Verkuilf723af12008-08-09 10:35:29 -0300432 case V4L2_CID_MPEG_AUDIO_AAC_BITRATE: return "Audio AAC Bitrate";
Hans Verkuil69028d72008-08-08 07:55:00 -0300433 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE: return "Audio AC-3 Bitrate";
434 case V4L2_CID_MPEG_AUDIO_MODE: return "Audio Stereo Mode";
435 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: return "Audio Stereo Mode Extension";
436 case V4L2_CID_MPEG_AUDIO_EMPHASIS: return "Audio Emphasis";
437 case V4L2_CID_MPEG_AUDIO_CRC: return "Audio CRC";
438 case V4L2_CID_MPEG_AUDIO_MUTE: return "Audio Mute";
439 case V4L2_CID_MPEG_VIDEO_ENCODING: return "Video Encoding";
440 case V4L2_CID_MPEG_VIDEO_ASPECT: return "Video Aspect";
441 case V4L2_CID_MPEG_VIDEO_B_FRAMES: return "Video B Frames";
442 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: return "Video GOP Size";
443 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE: return "Video GOP Closure";
444 case V4L2_CID_MPEG_VIDEO_PULLDOWN: return "Video Pulldown";
445 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: return "Video Bitrate Mode";
446 case V4L2_CID_MPEG_VIDEO_BITRATE: return "Video Bitrate";
447 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK: return "Video Peak Bitrate";
448 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: return "Video Temporal Decimation";
449 case V4L2_CID_MPEG_VIDEO_MUTE: return "Video Mute";
450 case V4L2_CID_MPEG_VIDEO_MUTE_YUV: return "Video Mute YUV";
451 case V4L2_CID_MPEG_STREAM_TYPE: return "Stream Type";
452 case V4L2_CID_MPEG_STREAM_PID_PMT: return "Stream PMT Program ID";
453 case V4L2_CID_MPEG_STREAM_PID_AUDIO: return "Stream Audio Program ID";
454 case V4L2_CID_MPEG_STREAM_PID_VIDEO: return "Stream Video Program ID";
455 case V4L2_CID_MPEG_STREAM_PID_PCR: return "Stream PCR Program ID";
456 case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: return "Stream PES Audio ID";
457 case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: return "Stream PES Video ID";
458 case V4L2_CID_MPEG_STREAM_VBI_FMT: return "Stream VBI Format";
459
Laurent Pinchart74980152008-12-14 16:24:04 -0300460 /* CAMERA controls */
461 case V4L2_CID_CAMERA_CLASS: return "Camera Controls";
462 case V4L2_CID_EXPOSURE_AUTO: return "Auto Exposure";
463 case V4L2_CID_EXPOSURE_ABSOLUTE: return "Exposure Time, Absolute";
464 case V4L2_CID_EXPOSURE_AUTO_PRIORITY: return "Exposure, Dynamic Framerate";
465 case V4L2_CID_PAN_RELATIVE: return "Pan, Relative";
466 case V4L2_CID_TILT_RELATIVE: return "Tilt, Relative";
467 case V4L2_CID_PAN_RESET: return "Pan, Reset";
468 case V4L2_CID_TILT_RESET: return "Tilt, Reset";
469 case V4L2_CID_PAN_ABSOLUTE: return "Pan, Absolute";
470 case V4L2_CID_TILT_ABSOLUTE: return "Tilt, Absolute";
471 case V4L2_CID_FOCUS_ABSOLUTE: return "Focus, Absolute";
472 case V4L2_CID_FOCUS_RELATIVE: return "Focus, Relative";
473 case V4L2_CID_FOCUS_AUTO: return "Focus, Automatic";
474 case V4L2_CID_ZOOM_ABSOLUTE: return "Zoom, Absolute";
475 case V4L2_CID_ZOOM_RELATIVE: return "Zoom, Relative";
476 case V4L2_CID_ZOOM_CONTINUOUS: return "Zoom, Continuous";
477 case V4L2_CID_PRIVACY: return "Privacy";
478
Hans Verkuil69028d72008-08-08 07:55:00 -0300479 default:
480 return NULL;
481 }
482}
483EXPORT_SYMBOL(v4l2_ctrl_get_name);
484
Hans Verkuil9cb23182006-06-18 14:11:08 -0300485/* Fill in a struct v4l2_queryctrl */
486int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
487{
Hans Verkuil69028d72008-08-08 07:55:00 -0300488 const char *name = v4l2_ctrl_get_name(qctrl->id);
Hans Verkuil9cb23182006-06-18 14:11:08 -0300489
490 qctrl->flags = 0;
Hans Verkuil69028d72008-08-08 07:55:00 -0300491 if (name == NULL)
Hans Verkuil9cb23182006-06-18 14:11:08 -0300492 return -EINVAL;
Hans Verkuil69028d72008-08-08 07:55:00 -0300493
Hans Verkuil9cb23182006-06-18 14:11:08 -0300494 switch (qctrl->id) {
495 case V4L2_CID_AUDIO_MUTE:
496 case V4L2_CID_AUDIO_LOUDNESS:
Laurent Pinchart74980152008-12-14 16:24:04 -0300497 case V4L2_CID_AUTO_WHITE_BALANCE:
498 case V4L2_CID_AUTOGAIN:
499 case V4L2_CID_HFLIP:
500 case V4L2_CID_VFLIP:
501 case V4L2_CID_HUE_AUTO:
Hans Verkuil81dde912009-02-20 06:30:12 -0300502 case V4L2_CID_CHROMA_AGC:
503 case V4L2_CID_COLOR_KILLER:
Hans Verkuil5eee72e2007-04-27 12:31:00 -0300504 case V4L2_CID_MPEG_AUDIO_MUTE:
Hans Verkuil01f1e442007-08-21 18:32:42 -0300505 case V4L2_CID_MPEG_VIDEO_MUTE:
Hans Verkuil9cb23182006-06-18 14:11:08 -0300506 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
507 case V4L2_CID_MPEG_VIDEO_PULLDOWN:
Laurent Pinchart74980152008-12-14 16:24:04 -0300508 case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
Hans Verkuil81dde912009-02-20 06:30:12 -0300509 case V4L2_CID_FOCUS_AUTO:
Laurent Pinchart74980152008-12-14 16:24:04 -0300510 case V4L2_CID_PRIVACY:
Hans Verkuil9cb23182006-06-18 14:11:08 -0300511 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
512 min = 0;
513 max = step = 1;
514 break;
Hans Verkuil81dde912009-02-20 06:30:12 -0300515 case V4L2_CID_PAN_RESET:
516 case V4L2_CID_TILT_RESET:
517 qctrl->type = V4L2_CTRL_TYPE_BUTTON;
518 qctrl->flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
519 min = max = step = def = 0;
520 break;
Laurent Pinchart74980152008-12-14 16:24:04 -0300521 case V4L2_CID_POWER_LINE_FREQUENCY:
Hans Verkuil9cb23182006-06-18 14:11:08 -0300522 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
523 case V4L2_CID_MPEG_AUDIO_ENCODING:
524 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
525 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
526 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
Hans Verkuile6b5da82008-08-08 07:38:07 -0300527 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
Hans Verkuil9cb23182006-06-18 14:11:08 -0300528 case V4L2_CID_MPEG_AUDIO_MODE:
529 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
530 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
531 case V4L2_CID_MPEG_AUDIO_CRC:
532 case V4L2_CID_MPEG_VIDEO_ENCODING:
533 case V4L2_CID_MPEG_VIDEO_ASPECT:
534 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
535 case V4L2_CID_MPEG_STREAM_TYPE:
Hans Verkuil8cbde942006-06-24 14:36:02 -0300536 case V4L2_CID_MPEG_STREAM_VBI_FMT:
Laurent Pinchart74980152008-12-14 16:24:04 -0300537 case V4L2_CID_EXPOSURE_AUTO:
Hans Verkuil11c469e2009-02-20 05:50:52 -0300538 case V4L2_CID_COLORFX:
Hans Verkuil9cb23182006-06-18 14:11:08 -0300539 qctrl->type = V4L2_CTRL_TYPE_MENU;
540 step = 1;
541 break;
542 case V4L2_CID_USER_CLASS:
Laurent Pinchart74980152008-12-14 16:24:04 -0300543 case V4L2_CID_CAMERA_CLASS:
Hans Verkuil9cb23182006-06-18 14:11:08 -0300544 case V4L2_CID_MPEG_CLASS:
545 qctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS;
546 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
547 min = max = step = def = 0;
548 break;
549 default:
550 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
551 break;
552 }
553 switch (qctrl->id) {
554 case V4L2_CID_MPEG_AUDIO_ENCODING:
555 case V4L2_CID_MPEG_AUDIO_MODE:
556 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
557 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
558 case V4L2_CID_MPEG_STREAM_TYPE:
559 qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
560 break;
561 case V4L2_CID_AUDIO_VOLUME:
562 case V4L2_CID_AUDIO_BALANCE:
563 case V4L2_CID_AUDIO_BASS:
564 case V4L2_CID_AUDIO_TREBLE:
565 case V4L2_CID_BRIGHTNESS:
566 case V4L2_CID_CONTRAST:
567 case V4L2_CID_SATURATION:
568 case V4L2_CID_HUE:
Hans Verkuil81dde912009-02-20 06:30:12 -0300569 case V4L2_CID_RED_BALANCE:
570 case V4L2_CID_BLUE_BALANCE:
571 case V4L2_CID_GAMMA:
Janne Grunau8c84cfd2009-03-18 17:00:39 -0300572 case V4L2_CID_SHARPNESS:
Hans Verkuil9cb23182006-06-18 14:11:08 -0300573 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
574 break;
Hans Verkuil81dde912009-02-20 06:30:12 -0300575 case V4L2_CID_PAN_RELATIVE:
576 case V4L2_CID_TILT_RELATIVE:
577 case V4L2_CID_FOCUS_RELATIVE:
578 case V4L2_CID_ZOOM_RELATIVE:
579 qctrl->flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
580 break;
Hans Verkuil9cb23182006-06-18 14:11:08 -0300581 }
582 qctrl->minimum = min;
583 qctrl->maximum = max;
584 qctrl->step = step;
585 qctrl->default_value = def;
586 qctrl->reserved[0] = qctrl->reserved[1] = 0;
Hans Verkuilb634a932009-01-17 11:26:59 -0300587 strlcpy(qctrl->name, name, sizeof(qctrl->name));
Hans Verkuil9cb23182006-06-18 14:11:08 -0300588 return 0;
589}
Mauro Carvalho Chehab057596e2008-02-02 11:25:31 -0300590EXPORT_SYMBOL(v4l2_ctrl_query_fill);
Hans Verkuil9cb23182006-06-18 14:11:08 -0300591
Hans Verkuil9cb23182006-06-18 14:11:08 -0300592/* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
Hans Verkuile281db582008-08-08 12:43:59 -0300593 the menu. The qctrl pointer may be NULL, in which case it is ignored.
594 If menu_items is NULL, then the menu items are retrieved using
595 v4l2_ctrl_get_menu. */
Hans Verkuil9cb23182006-06-18 14:11:08 -0300596int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
597 const char **menu_items)
598{
599 int i;
600
Hans Verkuil1e551262008-08-08 08:34:19 -0300601 qmenu->reserved = 0;
Hans Verkuile281db582008-08-08 12:43:59 -0300602 if (menu_items == NULL)
603 menu_items = v4l2_ctrl_get_menu(qmenu->id);
Hans Verkuil9cb23182006-06-18 14:11:08 -0300604 if (menu_items == NULL ||
605 (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
606 return -EINVAL;
607 for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
608 if (menu_items[i] == NULL || menu_items[i][0] == '\0')
609 return -EINVAL;
Hans Verkuilb634a932009-01-17 11:26:59 -0300610 strlcpy(qmenu->name, menu_items[qmenu->index], sizeof(qmenu->name));
Hans Verkuil9cb23182006-06-18 14:11:08 -0300611 return 0;
612}
Mauro Carvalho Chehab057596e2008-02-02 11:25:31 -0300613EXPORT_SYMBOL(v4l2_ctrl_query_menu);
Hans Verkuil9cb23182006-06-18 14:11:08 -0300614
Hans Verkuil1e551262008-08-08 08:34:19 -0300615/* Fill in a struct v4l2_querymenu based on the specified array of valid
616 menu items (terminated by V4L2_CTRL_MENU_IDS_END).
617 Use this if there are 'holes' in the list of valid menu items. */
618int v4l2_ctrl_query_menu_valid_items(struct v4l2_querymenu *qmenu, const u32 *ids)
619{
620 const char **menu_items = v4l2_ctrl_get_menu(qmenu->id);
621
622 qmenu->reserved = 0;
623 if (menu_items == NULL || ids == NULL)
624 return -EINVAL;
625 while (*ids != V4L2_CTRL_MENU_IDS_END) {
626 if (*ids++ == qmenu->index) {
Hans Verkuilb634a932009-01-17 11:26:59 -0300627 strlcpy(qmenu->name, menu_items[qmenu->index],
628 sizeof(qmenu->name));
Hans Verkuil1e551262008-08-08 08:34:19 -0300629 return 0;
630 }
631 }
632 return -EINVAL;
633}
634EXPORT_SYMBOL(v4l2_ctrl_query_menu_valid_items);
635
Hans Verkuil9cb23182006-06-18 14:11:08 -0300636/* ctrl_classes points to an array of u32 pointers, the last element is
637 a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
638 Each array must be sorted low to high and belong to the same control
Hans Verkuil2ba58892009-02-13 10:57:48 -0300639 class. The array of u32 pointers must also be sorted, from low class IDs
Hans Verkuil9cb23182006-06-18 14:11:08 -0300640 to high class IDs.
641
642 This function returns the first ID that follows after the given ID.
643 When no more controls are available 0 is returned. */
644u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
645{
Hans Verkuila46c5fb2007-07-19 04:53:36 -0300646 u32 ctrl_class = V4L2_CTRL_ID2CLASS(id);
Hans Verkuil9cb23182006-06-18 14:11:08 -0300647 const u32 *pctrl;
648
Hans Verkuil9cb23182006-06-18 14:11:08 -0300649 if (ctrl_classes == NULL)
650 return 0;
Hans Verkuila46c5fb2007-07-19 04:53:36 -0300651
652 /* if no query is desired, then check if the ID is part of ctrl_classes */
653 if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) {
654 /* find class */
655 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) != ctrl_class)
656 ctrl_classes++;
657 if (*ctrl_classes == NULL)
658 return 0;
659 pctrl = *ctrl_classes;
660 /* find control ID */
661 while (*pctrl && *pctrl != id) pctrl++;
662 return *pctrl ? id : 0;
663 }
Hans Verkuil9cb23182006-06-18 14:11:08 -0300664 id &= V4L2_CTRL_ID_MASK;
Hans Verkuil9cb23182006-06-18 14:11:08 -0300665 id++; /* select next control */
666 /* find first class that matches (or is greater than) the class of
667 the ID */
668 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
669 ctrl_classes++;
670 /* no more classes */
671 if (*ctrl_classes == NULL)
672 return 0;
673 pctrl = *ctrl_classes;
674 /* find first ctrl within the class that is >= ID */
675 while (*pctrl && *pctrl < id) pctrl++;
676 if (*pctrl)
677 return *pctrl;
678 /* we are at the end of the controls of the current class. */
679 /* continue with next class if available */
680 ctrl_classes++;
681 if (*ctrl_classes == NULL)
682 return 0;
683 return **ctrl_classes;
684}
Mauro Carvalho Chehab057596e2008-02-02 11:25:31 -0300685EXPORT_SYMBOL(v4l2_ctrl_next);
Hans Verkuil9cb23182006-06-18 14:11:08 -0300686
Hans Verkuilaecde8b52008-12-30 07:14:19 -0300687int v4l2_chip_match_host(const struct v4l2_dbg_match *match)
Mauro Carvalho Chehaba9254472008-01-29 18:32:35 -0300688{
Hans Verkuilaecde8b52008-12-30 07:14:19 -0300689 switch (match->type) {
Mauro Carvalho Chehaba9254472008-01-29 18:32:35 -0300690 case V4L2_CHIP_MATCH_HOST:
Hans Verkuilaecde8b52008-12-30 07:14:19 -0300691 return match->addr == 0;
Mauro Carvalho Chehaba9254472008-01-29 18:32:35 -0300692 default:
693 return 0;
694 }
695}
696EXPORT_SYMBOL(v4l2_chip_match_host);
697
698#if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
Hans Verkuilaecde8b52008-12-30 07:14:19 -0300699int v4l2_chip_match_i2c_client(struct i2c_client *c, const struct v4l2_dbg_match *match)
Hans Verkuilf3d092b2007-02-23 20:55:14 -0300700{
Hans Verkuilaecde8b52008-12-30 07:14:19 -0300701 int len;
702
703 if (c == NULL || match == NULL)
704 return 0;
705
706 switch (match->type) {
Hans Verkuilf3d092b2007-02-23 20:55:14 -0300707 case V4L2_CHIP_MATCH_I2C_DRIVER:
Hans Verkuilaecde8b52008-12-30 07:14:19 -0300708 if (c->driver == NULL || c->driver->driver.name == NULL)
709 return 0;
710 len = strlen(c->driver->driver.name);
711 /* legacy drivers have a ' suffix, don't try to match that */
712 if (len && c->driver->driver.name[len - 1] == '\'')
713 len--;
714 return len && !strncmp(c->driver->driver.name, match->name, len);
Hans Verkuilf3d092b2007-02-23 20:55:14 -0300715 case V4L2_CHIP_MATCH_I2C_ADDR:
Hans Verkuilaecde8b52008-12-30 07:14:19 -0300716 return c->addr == match->addr;
Hans Verkuilf3d092b2007-02-23 20:55:14 -0300717 default:
718 return 0;
719 }
720}
Mauro Carvalho Chehaba9254472008-01-29 18:32:35 -0300721EXPORT_SYMBOL(v4l2_chip_match_i2c_client);
Hans Verkuilf3d092b2007-02-23 20:55:14 -0300722
Hans Verkuilaecde8b52008-12-30 07:14:19 -0300723int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_dbg_chip_ident *chip,
Hans Verkuil3434eb72007-04-27 12:31:08 -0300724 u32 ident, u32 revision)
725{
Hans Verkuilaecde8b52008-12-30 07:14:19 -0300726 if (!v4l2_chip_match_i2c_client(c, &chip->match))
Hans Verkuil3434eb72007-04-27 12:31:08 -0300727 return 0;
728 if (chip->ident == V4L2_IDENT_NONE) {
729 chip->ident = ident;
730 chip->revision = revision;
731 }
732 else {
733 chip->ident = V4L2_IDENT_AMBIGUOUS;
734 chip->revision = 0;
735 }
736 return 0;
737}
Mauro Carvalho Chehaba9254472008-01-29 18:32:35 -0300738EXPORT_SYMBOL(v4l2_chip_ident_i2c_client);
Hans Verkuilf3d092b2007-02-23 20:55:14 -0300739
Hans Verkuil9cb23182006-06-18 14:11:08 -0300740/* ----------------------------------------------------------------- */
741
Hans Verkuil78a3b4d2009-04-01 03:41:09 -0300742/* I2C Helper functions */
Hans Verkuil8ffbc652007-09-12 08:32:50 -0300743
Hans Verkuildd991202008-11-23 12:19:45 -0300744
745void v4l2_i2c_subdev_init(struct v4l2_subdev *sd, struct i2c_client *client,
746 const struct v4l2_subdev_ops *ops)
747{
748 v4l2_subdev_init(sd, ops);
Hans Verkuilb5b2b7e2009-05-02 10:58:51 -0300749 sd->flags |= V4L2_SUBDEV_FL_IS_I2C;
Hans Verkuildd991202008-11-23 12:19:45 -0300750 /* the owner is the same as the i2c_client's driver owner */
751 sd->owner = client->driver->driver.owner;
752 /* i2c_client and v4l2_subdev point to one another */
753 v4l2_set_subdevdata(sd, client);
754 i2c_set_clientdata(client, sd);
755 /* initialize name */
756 snprintf(sd->name, sizeof(sd->name), "%s %d-%04x",
757 client->driver->driver.name, i2c_adapter_id(client->adapter),
758 client->addr);
759}
760EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init);
761
762
763
Hans Verkuile6574f22009-04-01 03:57:53 -0300764/* Load an i2c sub-device. */
765struct v4l2_subdev *v4l2_i2c_new_subdev(struct v4l2_device *v4l2_dev,
766 struct i2c_adapter *adapter,
Hans Verkuildd991202008-11-23 12:19:45 -0300767 const char *module_name, const char *client_type, u8 addr)
768{
Hans Verkuildd991202008-11-23 12:19:45 -0300769 struct v4l2_subdev *sd = NULL;
770 struct i2c_client *client;
771 struct i2c_board_info info;
772
Hans Verkuile6574f22009-04-01 03:57:53 -0300773 BUG_ON(!v4l2_dev);
Hans Verkuild64260d2009-03-18 15:48:01 -0300774
Hans Verkuildd991202008-11-23 12:19:45 -0300775 if (module_name)
776 request_module(module_name);
Hans Verkuild64260d2009-03-18 15:48:01 -0300777
Hans Verkuildd991202008-11-23 12:19:45 -0300778 /* Setup the i2c board info with the device type and
779 the device address. */
780 memset(&info, 0, sizeof(info));
781 strlcpy(info.type, client_type, sizeof(info.type));
782 info.addr = addr;
783
784 /* Create the i2c client */
785 client = i2c_new_device(adapter, &info);
786 /* Note: it is possible in the future that
787 c->driver is NULL if the driver is still being loaded.
788 We need better support from the kernel so that we
789 can easily wait for the load to finish. */
790 if (client == NULL || client->driver == NULL)
Hans Verkuil7c026c32009-03-12 18:56:15 -0300791 goto error;
Hans Verkuildd991202008-11-23 12:19:45 -0300792
793 /* Lock the module so we can safely get the v4l2_subdev pointer */
794 if (!try_module_get(client->driver->driver.owner))
Hans Verkuil7c026c32009-03-12 18:56:15 -0300795 goto error;
Hans Verkuildd991202008-11-23 12:19:45 -0300796 sd = i2c_get_clientdata(client);
797
798 /* Register with the v4l2_device which increases the module's
799 use count as well. */
Hans Verkuile6574f22009-04-01 03:57:53 -0300800 if (v4l2_device_register_subdev(v4l2_dev, sd))
Hans Verkuildd991202008-11-23 12:19:45 -0300801 sd = NULL;
802 /* Decrease the module use count to match the first try_module_get. */
803 module_put(client->driver->driver.owner);
Hans Verkuildd991202008-11-23 12:19:45 -0300804
Hans Verkuilf0222c72009-06-09 17:12:33 -0300805 if (sd) {
806 /* We return errors from v4l2_subdev_call only if we have the
807 callback as the .s_config is not mandatory */
808 int err = v4l2_subdev_call(sd, core, s_config, 0, NULL);
809
810 if (err && err != -ENOIOCTLCMD) {
811 v4l2_device_unregister_subdev(sd);
812 sd = NULL;
813 }
814 }
815
Hans Verkuil7c026c32009-03-12 18:56:15 -0300816error:
817 /* If we have a client but no subdev, then something went wrong and
818 we must unregister the client. */
819 if (client && sd == NULL)
820 i2c_unregister_device(client);
821 return sd;
Hans Verkuildd991202008-11-23 12:19:45 -0300822}
823EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev);
824
Hans Verkuile6574f22009-04-01 03:57:53 -0300825/* Probe and load an i2c sub-device. */
826struct v4l2_subdev *v4l2_i2c_new_probed_subdev(struct v4l2_device *v4l2_dev,
827 struct i2c_adapter *adapter,
Hans Verkuildd991202008-11-23 12:19:45 -0300828 const char *module_name, const char *client_type,
829 const unsigned short *addrs)
830{
Hans Verkuildd991202008-11-23 12:19:45 -0300831 struct v4l2_subdev *sd = NULL;
832 struct i2c_client *client = NULL;
833 struct i2c_board_info info;
834
Hans Verkuile6574f22009-04-01 03:57:53 -0300835 BUG_ON(!v4l2_dev);
Hans Verkuild64260d2009-03-18 15:48:01 -0300836
Hans Verkuildd991202008-11-23 12:19:45 -0300837 if (module_name)
838 request_module(module_name);
Hans Verkuild64260d2009-03-18 15:48:01 -0300839
Hans Verkuildd991202008-11-23 12:19:45 -0300840 /* Setup the i2c board info with the device type and
841 the device address. */
842 memset(&info, 0, sizeof(info));
843 strlcpy(info.type, client_type, sizeof(info.type));
844
845 /* Probe and create the i2c client */
846 client = i2c_new_probed_device(adapter, &info, addrs);
847 /* Note: it is possible in the future that
848 c->driver is NULL if the driver is still being loaded.
849 We need better support from the kernel so that we
850 can easily wait for the load to finish. */
851 if (client == NULL || client->driver == NULL)
Hans Verkuil7c026c32009-03-12 18:56:15 -0300852 goto error;
Hans Verkuildd991202008-11-23 12:19:45 -0300853
854 /* Lock the module so we can safely get the v4l2_subdev pointer */
855 if (!try_module_get(client->driver->driver.owner))
Hans Verkuil7c026c32009-03-12 18:56:15 -0300856 goto error;
Hans Verkuildd991202008-11-23 12:19:45 -0300857 sd = i2c_get_clientdata(client);
858
859 /* Register with the v4l2_device which increases the module's
860 use count as well. */
Hans Verkuile6574f22009-04-01 03:57:53 -0300861 if (v4l2_device_register_subdev(v4l2_dev, sd))
Hans Verkuildd991202008-11-23 12:19:45 -0300862 sd = NULL;
863 /* Decrease the module use count to match the first try_module_get. */
864 module_put(client->driver->driver.owner);
Hans Verkuil7c026c32009-03-12 18:56:15 -0300865
Hans Verkuilf0222c72009-06-09 17:12:33 -0300866 if (sd) {
867 /* We return errors from v4l2_subdev_call only if we have the
868 callback as the .s_config is not mandatory */
869 int err = v4l2_subdev_call(sd, core, s_config, 0, NULL);
870
871 if (err && err != -ENOIOCTLCMD) {
872 v4l2_device_unregister_subdev(sd);
873 sd = NULL;
874 }
875 }
876
Hans Verkuil7c026c32009-03-12 18:56:15 -0300877error:
878 /* If we have a client but no subdev, then something went wrong and
879 we must unregister the client. */
880 if (client && sd == NULL)
881 i2c_unregister_device(client);
Hans Verkuildd991202008-11-23 12:19:45 -0300882 return sd;
883}
884EXPORT_SYMBOL_GPL(v4l2_i2c_new_probed_subdev);
885
Hans Verkuil868f9852009-03-30 11:40:54 -0300886struct v4l2_subdev *v4l2_i2c_new_probed_subdev_addr(struct v4l2_device *v4l2_dev,
887 struct i2c_adapter *adapter,
888 const char *module_name, const char *client_type, u8 addr)
889{
890 unsigned short addrs[2] = { addr, I2C_CLIENT_END };
891
892 return v4l2_i2c_new_probed_subdev(v4l2_dev, adapter,
893 module_name, client_type, addrs);
894}
895EXPORT_SYMBOL_GPL(v4l2_i2c_new_probed_subdev_addr);
896
Hans Verkuilf0222c72009-06-09 17:12:33 -0300897/* Load an i2c sub-device. */
898struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev,
899 struct i2c_adapter *adapter, const char *module_name,
900 struct i2c_board_info *info, const unsigned short *probe_addrs)
901{
902 struct v4l2_subdev *sd = NULL;
903 struct i2c_client *client;
904
905 BUG_ON(!v4l2_dev);
906
907 if (module_name)
908 request_module(module_name);
909
910 /* Create the i2c client */
911 if (info->addr == 0 && probe_addrs)
912 client = i2c_new_probed_device(adapter, info, probe_addrs);
913 else
914 client = i2c_new_device(adapter, info);
915
916 /* Note: by loading the module first we are certain that c->driver
917 will be set if the driver was found. If the module was not loaded
918 first, then the i2c core tries to delay-load the module for us,
919 and then c->driver is still NULL until the module is finally
920 loaded. This delay-load mechanism doesn't work if other drivers
921 want to use the i2c device, so explicitly loading the module
922 is the best alternative. */
923 if (client == NULL || client->driver == NULL)
924 goto error;
925
926 /* Lock the module so we can safely get the v4l2_subdev pointer */
927 if (!try_module_get(client->driver->driver.owner))
928 goto error;
929 sd = i2c_get_clientdata(client);
930
931 /* Register with the v4l2_device which increases the module's
932 use count as well. */
933 if (v4l2_device_register_subdev(v4l2_dev, sd))
934 sd = NULL;
935 /* Decrease the module use count to match the first try_module_get. */
936 module_put(client->driver->driver.owner);
937
938 if (sd) {
939 /* We return errors from v4l2_subdev_call only if we have the
940 callback as the .s_config is not mandatory */
941 int err = v4l2_subdev_call(sd, core, s_config,
942 info->irq, info->platform_data);
943
944 if (err && err != -ENOIOCTLCMD) {
945 v4l2_device_unregister_subdev(sd);
946 sd = NULL;
947 }
948 }
949
950error:
951 /* If we have a client but no subdev, then something went wrong and
952 we must unregister the client. */
953 if (client && sd == NULL)
954 i2c_unregister_device(client);
955 return sd;
956}
957EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_board);
958
959struct v4l2_subdev *v4l2_i2c_new_subdev_cfg(struct v4l2_device *v4l2_dev,
960 struct i2c_adapter *adapter,
961 const char *module_name, const char *client_type,
962 int irq, void *platform_data,
963 u8 addr, const unsigned short *probe_addrs)
964{
965 struct i2c_board_info info;
966
967 /* Setup the i2c board info with the device type and
968 the device address. */
969 memset(&info, 0, sizeof(info));
970 strlcpy(info.type, client_type, sizeof(info.type));
971 info.addr = addr;
972 info.irq = irq;
973 info.platform_data = platform_data;
974
975 return v4l2_i2c_new_subdev_board(v4l2_dev, adapter, module_name,
976 &info, probe_addrs);
977}
978EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_cfg);
979
Hans Verkuilab3731902009-02-21 18:08:41 -0300980/* Return i2c client address of v4l2_subdev. */
981unsigned short v4l2_i2c_subdev_addr(struct v4l2_subdev *sd)
982{
983 struct i2c_client *client = v4l2_get_subdevdata(sd);
984
985 return client ? client->addr : I2C_CLIENT_END;
986}
987EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_addr);
988
Hans Verkuilc7d29e22009-01-18 19:37:59 -0300989/* Return a list of I2C tuner addresses to probe. Use only if the tuner
990 addresses are unknown. */
991const unsigned short *v4l2_i2c_tuner_addrs(enum v4l2_i2c_tuner_type type)
992{
993 static const unsigned short radio_addrs[] = {
994#if defined(CONFIG_MEDIA_TUNER_TEA5761) || defined(CONFIG_MEDIA_TUNER_TEA5761_MODULE)
995 0x10,
996#endif
997 0x60,
998 I2C_CLIENT_END
999 };
1000 static const unsigned short demod_addrs[] = {
1001 0x42, 0x43, 0x4a, 0x4b,
1002 I2C_CLIENT_END
1003 };
1004 static const unsigned short tv_addrs[] = {
1005 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
Hans Verkuil416a7aa2009-05-02 09:42:57 -03001006 0x60, 0x61, 0x62, 0x63, 0x64,
Hans Verkuilc7d29e22009-01-18 19:37:59 -03001007 I2C_CLIENT_END
1008 };
1009
1010 switch (type) {
1011 case ADDRS_RADIO:
1012 return radio_addrs;
1013 case ADDRS_DEMOD:
1014 return demod_addrs;
1015 case ADDRS_TV:
1016 return tv_addrs;
1017 case ADDRS_TV_WITH_DEMOD:
1018 return tv_addrs + 4;
1019 }
1020 return NULL;
1021}
1022EXPORT_SYMBOL_GPL(v4l2_i2c_tuner_addrs);
1023
Trent Piephod8b29962009-06-12 16:31:29 -03001024#endif /* defined(CONFIG_I2C) */
1025
Trent Piephob0d31592009-05-30 21:45:46 -03001026/* Clamp x to be between min and max, aligned to a multiple of 2^align. min
1027 * and max don't have to be aligned, but there must be at least one valid
1028 * value. E.g., min=17,max=31,align=4 is not allowed as there are no multiples
1029 * of 16 between 17 and 31. */
1030static unsigned int clamp_align(unsigned int x, unsigned int min,
1031 unsigned int max, unsigned int align)
1032{
1033 /* Bits that must be zero to be aligned */
1034 unsigned int mask = ~((1 << align) - 1);
1035
1036 /* Round to nearest aligned value */
1037 if (align)
1038 x = (x + (1 << (align - 1))) & mask;
1039
1040 /* Clamp to aligned value of min and max */
1041 if (x < min)
1042 x = (min + ~mask) & mask;
1043 else if (x > max)
1044 x = max & mask;
1045
1046 return x;
1047}
1048
1049/* Bound an image to have a width between wmin and wmax, and height between
1050 * hmin and hmax, inclusive. Additionally, the width will be a multiple of
1051 * 2^walign, the height will be a multiple of 2^halign, and the overall size
1052 * (width*height) will be a multiple of 2^salign. The image may be shrunk
1053 * or enlarged to fit the alignment constraints.
1054 *
1055 * The width or height maximum must not be smaller than the corresponding
1056 * minimum. The alignments must not be so high there are no possible image
1057 * sizes within the allowed bounds. wmin and hmin must be at least 1
1058 * (don't use 0). If you don't care about a certain alignment, specify 0,
1059 * as 2^0 is 1 and one byte alignment is equivalent to no alignment. If
1060 * you only want to adjust downward, specify a maximum that's the same as
1061 * the initial value.
1062 */
1063void v4l_bound_align_image(u32 *w, unsigned int wmin, unsigned int wmax,
1064 unsigned int walign,
1065 u32 *h, unsigned int hmin, unsigned int hmax,
1066 unsigned int halign, unsigned int salign)
1067{
1068 *w = clamp_align(*w, wmin, wmax, walign);
1069 *h = clamp_align(*h, hmin, hmax, halign);
1070
1071 /* Usually we don't need to align the size and are done now. */
1072 if (!salign)
1073 return;
1074
1075 /* How much alignment do we have? */
1076 walign = __ffs(*w);
1077 halign = __ffs(*h);
1078 /* Enough to satisfy the image alignment? */
1079 if (walign + halign < salign) {
1080 /* Max walign where there is still a valid width */
1081 unsigned int wmaxa = __fls(wmax ^ (wmin - 1));
1082 /* Max halign where there is still a valid height */
1083 unsigned int hmaxa = __fls(hmax ^ (hmin - 1));
1084
1085 /* up the smaller alignment until we have enough */
1086 do {
1087 if (halign >= hmaxa ||
1088 (walign <= halign && walign < wmaxa)) {
1089 *w = clamp_align(*w, wmin, wmax, walign + 1);
1090 walign = __ffs(*w);
1091 } else {
1092 *h = clamp_align(*h, hmin, hmax, halign + 1);
1093 halign = __ffs(*h);
1094 }
1095 } while (halign + walign < salign);
1096 }
1097}
1098EXPORT_SYMBOL_GPL(v4l_bound_align_image);