1/* 2 * Video for Linux Two 3 * 4 * A generic video device interface for the LINUX operating system 5 * using a set of device structures/vectors for low level operations. 6 * 7 * This file replaces the videodev.c file that comes with the 8 * regular kernel distribution. 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public License 12 * as published by the Free Software Foundation; either version 13 * 2 of the License, or (at your option) any later version. 14 * 15 * Author: Bill Dirks <bill@thedirks.org> 16 * based on code by Alan Cox, <alan@cymru.net> 17 * 18 */ 19 20/* 21 * Video capture interface for Linux 22 * 23 * A generic video device interface for the LINUX operating system 24 * using a set of device structures/vectors for low level operations. 25 * 26 * This program is free software; you can redistribute it and/or 27 * modify it under the terms of the GNU General Public License 28 * as published by the Free Software Foundation; either version 29 * 2 of the License, or (at your option) any later version. 30 * 31 * Author: Alan Cox, <alan@redhat.com> 32 * 33 * Fixes: 34 */ 35 36/* 37 * Video4linux 1/2 integration by Justin Schoeman 38 * <justin@suntiger.ee.up.ac.za> 39 * 2.4 PROCFS support ported from 2.4 kernels by 40 * I�aki Garc�a Etxebarria <garetxe@euskalnet.net> 41 * Makefile fix by "W. Michael Petullo" <mike@flyn.org> 42 * 2.4 devfs support ported from 2.4 kernels by 43 * Dan Merillat <dan@merillat.org> 44 * Added Gerd Knorrs v4l1 enhancements (Justin Schoeman) 45 */ 46 47#include <linux/module.h> 48#include <linux/types.h> 49#include <linux/kernel.h> 50#include <linux/mm.h> 51#include <linux/string.h> 52#include <linux/errno.h> 53#include <linux/i2c.h> 54#include <asm/uaccess.h> 55#include <asm/system.h> 56#include <asm/pgtable.h> 57#include <asm/io.h> 58#include <asm/div64.h> 59#include <linux/video_decoder.h> 60#define __OLD_VIDIOC_ /* To allow fixing old calls*/ 61#include <media/v4l2-common.h> 62#include <media/v4l2-chip-ident.h> 63 64#ifdef CONFIG_KMOD 65#include <linux/kmod.h> 66#endif 67 68#if defined(CONFIG_UST) || defined(CONFIG_UST_MODULE) 69#include <linux/ust.h> 70#endif 71 72 73#include <linux/videodev.h> 74 75MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr"); 76MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers"); 77MODULE_LICENSE("GPL"); 78 79/* 80 * 81 * V 4 L 2 D R I V E R H E L P E R A P I 82 * 83 */ 84 85/* 86 * Video Standard Operations (contributed by Michael Schimek) 87 */ 88 89 90char *v4l2_norm_to_name(v4l2_std_id id) 91{ 92 char *name; 93 u32 myid = id; 94 95 /* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle 96 64 bit comparations. So, on that architecture, with some gcc variants, 97 compilation fails. Currently, the max value is 30bit wide. 98 */ 99 BUG_ON(myid != id); 100 101 switch (myid) { 102 case V4L2_STD_PAL: 103 name="PAL"; break; 104 case V4L2_STD_PAL_BG: 105 name="PAL-BG"; break; 106 case V4L2_STD_PAL_DK: 107 name="PAL-DK"; break; 108 case V4L2_STD_PAL_B: 109 name="PAL-B"; break; 110 case V4L2_STD_PAL_B1: 111 name="PAL-B1"; break; 112 case V4L2_STD_PAL_G: 113 name="PAL-G"; break; 114 case V4L2_STD_PAL_H: 115 name="PAL-H"; break; 116 case V4L2_STD_PAL_I: 117 name="PAL-I"; break; 118 case V4L2_STD_PAL_D: 119 name="PAL-D"; break; 120 case V4L2_STD_PAL_D1: 121 name="PAL-D1"; break; 122 case V4L2_STD_PAL_K: 123 name="PAL-K"; break; 124 case V4L2_STD_PAL_M: 125 name="PAL-M"; break; 126 case V4L2_STD_PAL_N: 127 name="PAL-N"; break; 128 case V4L2_STD_PAL_Nc: 129 name="PAL-Nc"; break; 130 case V4L2_STD_PAL_60: 131 name="PAL-60"; break; 132 case V4L2_STD_NTSC: 133 name="NTSC"; break; 134 case V4L2_STD_NTSC_M: 135 name="NTSC-M"; break; 136 case V4L2_STD_NTSC_M_JP: 137 name="NTSC-M-JP"; break; 138 case V4L2_STD_NTSC_443: 139 name="NTSC-443"; break; 140 case V4L2_STD_NTSC_M_KR: 141 name="NTSC-M-KR"; break; 142 case V4L2_STD_SECAM: 143 name="SECAM"; break; 144 case V4L2_STD_SECAM_DK: 145 name="SECAM-DK"; break; 146 case V4L2_STD_SECAM_B: 147 name="SECAM-B"; break; 148 case V4L2_STD_SECAM_D: 149 name="SECAM-D"; break; 150 case V4L2_STD_SECAM_G: 151 name="SECAM-G"; break; 152 case V4L2_STD_SECAM_H: 153 name="SECAM-H"; break; 154 case V4L2_STD_SECAM_K: 155 name="SECAM-K"; break; 156 case V4L2_STD_SECAM_K1: 157 name="SECAM-K1"; break; 158 case V4L2_STD_SECAM_L: 159 name="SECAM-L"; break; 160 case V4L2_STD_SECAM_LC: 161 name="SECAM-LC"; break; 162 default: 163 name="Unknown"; break; 164 } 165 166 return name; 167} 168 169/* Fill in the fields of a v4l2_standard structure according to the 170 'id' and 'transmission' parameters. Returns negative on error. */ 171int v4l2_video_std_construct(struct v4l2_standard *vs, 172 int id, char *name) 173{ 174 u32 index = vs->index; 175 176 memset(vs, 0, sizeof(struct v4l2_standard)); 177 vs->index = index; 178 vs->id = id; 179 if (id & V4L2_STD_525_60) { 180 vs->frameperiod.numerator = 1001; 181 vs->frameperiod.denominator = 30000; 182 vs->framelines = 525; 183 } else { 184 vs->frameperiod.numerator = 1; 185 vs->frameperiod.denominator = 25; 186 vs->framelines = 625; 187 } 188 strlcpy(vs->name,name,sizeof(vs->name)); 189 return 0; 190} 191 192/* ----------------------------------------------------------------- */ 193/* priority handling */ 194 195#define V4L2_PRIO_VALID(val) (val == V4L2_PRIORITY_BACKGROUND || \ 196 val == V4L2_PRIORITY_INTERACTIVE || \ 197 val == V4L2_PRIORITY_RECORD) 198 199int v4l2_prio_init(struct v4l2_prio_state *global) 200{ 201 memset(global,0,sizeof(*global)); 202 return 0; 203} 204 205int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local, 206 enum v4l2_priority new) 207{ 208 if (!V4L2_PRIO_VALID(new)) 209 return -EINVAL; 210 if (*local == new) 211 return 0; 212 213 atomic_inc(&global->prios[new]); 214 if (V4L2_PRIO_VALID(*local)) 215 atomic_dec(&global->prios[*local]); 216 *local = new; 217 return 0; 218} 219 220int v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local) 221{ 222 return v4l2_prio_change(global,local,V4L2_PRIORITY_DEFAULT); 223} 224 225int v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority *local) 226{ 227 if (V4L2_PRIO_VALID(*local)) 228 atomic_dec(&global->prios[*local]); 229 return 0; 230} 231 232enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global) 233{ 234 if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0) 235 return V4L2_PRIORITY_RECORD; 236 if (atomic_read(&global->prios[V4L2_PRIORITY_INTERACTIVE]) > 0) 237 return V4L2_PRIORITY_INTERACTIVE; 238 if (atomic_read(&global->prios[V4L2_PRIORITY_BACKGROUND]) > 0) 239 return V4L2_PRIORITY_BACKGROUND; 240 return V4L2_PRIORITY_UNSET; 241} 242 243int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority *local) 244{ 245 if (*local < v4l2_prio_max(global)) 246 return -EBUSY; 247 return 0; 248} 249 250 251/* ----------------------------------------------------------------- */ 252/* some arrays for pretty-printing debug messages of enum types */ 253 254char *v4l2_field_names[] = { 255 [V4L2_FIELD_ANY] = "any", 256 [V4L2_FIELD_NONE] = "none", 257 [V4L2_FIELD_TOP] = "top", 258 [V4L2_FIELD_BOTTOM] = "bottom", 259 [V4L2_FIELD_INTERLACED] = "interlaced", 260 [V4L2_FIELD_SEQ_TB] = "seq-tb", 261 [V4L2_FIELD_SEQ_BT] = "seq-bt", 262 [V4L2_FIELD_ALTERNATE] = "alternate", 263 [V4L2_FIELD_INTERLACED_TB] = "interlaced-tb", 264 [V4L2_FIELD_INTERLACED_BT] = "interlaced-bt", 265}; 266 267char *v4l2_type_names[] = { 268 [V4L2_BUF_TYPE_VIDEO_CAPTURE] = "video-cap", 269 [V4L2_BUF_TYPE_VIDEO_OVERLAY] = "video-over", 270 [V4L2_BUF_TYPE_VIDEO_OUTPUT] = "video-out", 271 [V4L2_BUF_TYPE_VBI_CAPTURE] = "vbi-cap", 272 [V4L2_BUF_TYPE_VBI_OUTPUT] = "vbi-out", 273 [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-cap", 274 [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT] = "sliced-vbi-out", 275 [V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY] = "video-out-over", 276}; 277 278 279#define prt_names(a,arr) (((a)>=0)&&((a)<ARRAY_SIZE(arr)))?arr[a]:"unknown" 280 281/* ------------------------------------------------------------------ */ 282/* debug help functions */ 283 284#ifdef CONFIG_VIDEO_V4L1_COMPAT 285static const char *v4l1_ioctls[] = { 286 [_IOC_NR(VIDIOCGCAP)] = "VIDIOCGCAP", 287 [_IOC_NR(VIDIOCGCHAN)] = "VIDIOCGCHAN", 288 [_IOC_NR(VIDIOCSCHAN)] = "VIDIOCSCHAN", 289 [_IOC_NR(VIDIOCGTUNER)] = "VIDIOCGTUNER", 290 [_IOC_NR(VIDIOCSTUNER)] = "VIDIOCSTUNER", 291 [_IOC_NR(VIDIOCGPICT)] = "VIDIOCGPICT", 292 [_IOC_NR(VIDIOCSPICT)] = "VIDIOCSPICT", 293 [_IOC_NR(VIDIOCCAPTURE)] = "VIDIOCCAPTURE", 294 [_IOC_NR(VIDIOCGWIN)] = "VIDIOCGWIN", 295 [_IOC_NR(VIDIOCSWIN)] = "VIDIOCSWIN", 296 [_IOC_NR(VIDIOCGFBUF)] = "VIDIOCGFBUF", 297 [_IOC_NR(VIDIOCSFBUF)] = "VIDIOCSFBUF", 298 [_IOC_NR(VIDIOCKEY)] = "VIDIOCKEY", 299 [_IOC_NR(VIDIOCGFREQ)] = "VIDIOCGFREQ", 300 [_IOC_NR(VIDIOCSFREQ)] = "VIDIOCSFREQ", 301 [_IOC_NR(VIDIOCGAUDIO)] = "VIDIOCGAUDIO", 302 [_IOC_NR(VIDIOCSAUDIO)] = "VIDIOCSAUDIO", 303 [_IOC_NR(VIDIOCSYNC)] = "VIDIOCSYNC", 304 [_IOC_NR(VIDIOCMCAPTURE)] = "VIDIOCMCAPTURE", 305 [_IOC_NR(VIDIOCGMBUF)] = "VIDIOCGMBUF", 306 [_IOC_NR(VIDIOCGUNIT)] = "VIDIOCGUNIT", 307 [_IOC_NR(VIDIOCGCAPTURE)] = "VIDIOCGCAPTURE", 308 [_IOC_NR(VIDIOCSCAPTURE)] = "VIDIOCSCAPTURE", 309 [_IOC_NR(VIDIOCSPLAYMODE)] = "VIDIOCSPLAYMODE", 310 [_IOC_NR(VIDIOCSWRITEMODE)] = "VIDIOCSWRITEMODE", 311 [_IOC_NR(VIDIOCGPLAYINFO)] = "VIDIOCGPLAYINFO", 312 [_IOC_NR(VIDIOCSMICROCODE)] = "VIDIOCSMICROCODE", 313 [_IOC_NR(VIDIOCGVBIFMT)] = "VIDIOCGVBIFMT", 314 [_IOC_NR(VIDIOCSVBIFMT)] = "VIDIOCSVBIFMT" 315}; 316#define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls) 317#endif 318 319static const char *v4l2_ioctls[] = { 320 [_IOC_NR(VIDIOC_QUERYCAP)] = "VIDIOC_QUERYCAP", 321 [_IOC_NR(VIDIOC_RESERVED)] = "VIDIOC_RESERVED", 322 [_IOC_NR(VIDIOC_ENUM_FMT)] = "VIDIOC_ENUM_FMT", 323 [_IOC_NR(VIDIOC_G_FMT)] = "VIDIOC_G_FMT", 324 [_IOC_NR(VIDIOC_S_FMT)] = "VIDIOC_S_FMT", 325 [_IOC_NR(VIDIOC_G_MPEGCOMP)] = "VIDIOC_G_MPEGCOMP", 326 [_IOC_NR(VIDIOC_S_MPEGCOMP)] = "VIDIOC_S_MPEGCOMP", 327 [_IOC_NR(VIDIOC_REQBUFS)] = "VIDIOC_REQBUFS", 328 [_IOC_NR(VIDIOC_QUERYBUF)] = "VIDIOC_QUERYBUF", 329 [_IOC_NR(VIDIOC_G_FBUF)] = "VIDIOC_G_FBUF", 330 [_IOC_NR(VIDIOC_S_FBUF)] = "VIDIOC_S_FBUF", 331 [_IOC_NR(VIDIOC_OVERLAY)] = "VIDIOC_OVERLAY", 332 [_IOC_NR(VIDIOC_QBUF)] = "VIDIOC_QBUF", 333 [_IOC_NR(VIDIOC_DQBUF)] = "VIDIOC_DQBUF", 334 [_IOC_NR(VIDIOC_STREAMON)] = "VIDIOC_STREAMON", 335 [_IOC_NR(VIDIOC_STREAMOFF)] = "VIDIOC_STREAMOFF", 336 [_IOC_NR(VIDIOC_G_PARM)] = "VIDIOC_G_PARM", 337 [_IOC_NR(VIDIOC_S_PARM)] = "VIDIOC_S_PARM", 338 [_IOC_NR(VIDIOC_G_STD)] = "VIDIOC_G_STD", 339 [_IOC_NR(VIDIOC_S_STD)] = "VIDIOC_S_STD", 340 [_IOC_NR(VIDIOC_ENUMSTD)] = "VIDIOC_ENUMSTD", 341 [_IOC_NR(VIDIOC_ENUMINPUT)] = "VIDIOC_ENUMINPUT", 342 [_IOC_NR(VIDIOC_G_CTRL)] = "VIDIOC_G_CTRL", 343 [_IOC_NR(VIDIOC_S_CTRL)] = "VIDIOC_S_CTRL", 344 [_IOC_NR(VIDIOC_G_TUNER)] = "VIDIOC_G_TUNER", 345 [_IOC_NR(VIDIOC_S_TUNER)] = "VIDIOC_S_TUNER", 346 [_IOC_NR(VIDIOC_G_AUDIO)] = "VIDIOC_G_AUDIO", 347 [_IOC_NR(VIDIOC_S_AUDIO)] = "VIDIOC_S_AUDIO", 348 [_IOC_NR(VIDIOC_QUERYCTRL)] = "VIDIOC_QUERYCTRL", 349 [_IOC_NR(VIDIOC_QUERYMENU)] = "VIDIOC_QUERYMENU", 350 [_IOC_NR(VIDIOC_G_INPUT)] = "VIDIOC_G_INPUT", 351 [_IOC_NR(VIDIOC_S_INPUT)] = "VIDIOC_S_INPUT", 352 [_IOC_NR(VIDIOC_G_OUTPUT)] = "VIDIOC_G_OUTPUT", 353 [_IOC_NR(VIDIOC_S_OUTPUT)] = "VIDIOC_S_OUTPUT", 354 [_IOC_NR(VIDIOC_ENUMOUTPUT)] = "VIDIOC_ENUMOUTPUT", 355 [_IOC_NR(VIDIOC_G_AUDOUT)] = "VIDIOC_G_AUDOUT", 356 [_IOC_NR(VIDIOC_S_AUDOUT)] = "VIDIOC_S_AUDOUT", 357 [_IOC_NR(VIDIOC_G_MODULATOR)] = "VIDIOC_G_MODULATOR", 358 [_IOC_NR(VIDIOC_S_MODULATOR)] = "VIDIOC_S_MODULATOR", 359 [_IOC_NR(VIDIOC_G_FREQUENCY)] = "VIDIOC_G_FREQUENCY", 360 [_IOC_NR(VIDIOC_S_FREQUENCY)] = "VIDIOC_S_FREQUENCY", 361 [_IOC_NR(VIDIOC_CROPCAP)] = "VIDIOC_CROPCAP", 362 [_IOC_NR(VIDIOC_G_CROP)] = "VIDIOC_G_CROP", 363 [_IOC_NR(VIDIOC_S_CROP)] = "VIDIOC_S_CROP", 364 [_IOC_NR(VIDIOC_G_JPEGCOMP)] = "VIDIOC_G_JPEGCOMP", 365 [_IOC_NR(VIDIOC_S_JPEGCOMP)] = "VIDIOC_S_JPEGCOMP", 366 [_IOC_NR(VIDIOC_QUERYSTD)] = "VIDIOC_QUERYSTD", 367 [_IOC_NR(VIDIOC_TRY_FMT)] = "VIDIOC_TRY_FMT", 368 [_IOC_NR(VIDIOC_ENUMAUDIO)] = "VIDIOC_ENUMAUDIO", 369 [_IOC_NR(VIDIOC_ENUMAUDOUT)] = "VIDIOC_ENUMAUDOUT", 370 [_IOC_NR(VIDIOC_G_PRIORITY)] = "VIDIOC_G_PRIORITY", 371 [_IOC_NR(VIDIOC_S_PRIORITY)] = "VIDIOC_S_PRIORITY", 372 [_IOC_NR(VIDIOC_G_SLICED_VBI_CAP)] = "VIDIOC_G_SLICED_VBI_CAP", 373 [_IOC_NR(VIDIOC_LOG_STATUS)] = "VIDIOC_LOG_STATUS", 374 [_IOC_NR(VIDIOC_G_EXT_CTRLS)] = "VIDIOC_G_EXT_CTRLS", 375 [_IOC_NR(VIDIOC_S_EXT_CTRLS)] = "VIDIOC_S_EXT_CTRLS", 376 [_IOC_NR(VIDIOC_TRY_EXT_CTRLS)] = "VIDIOC_TRY_EXT_CTRLS", 377 [_IOC_NR(VIDIOC_ENUM_FRAMESIZES)] = "VIDIOC_ENUM_FRAMESIZES", 378 [_IOC_NR(VIDIOC_ENUM_FRAMEINTERVALS)] = "VIDIOC_ENUM_FRAMEINTERVALS", 379 [_IOC_NR(VIDIOC_G_ENC_INDEX)] = "VIDIOC_G_ENC_INDEX", 380 [_IOC_NR(VIDIOC_ENCODER_CMD)] = "VIDIOC_ENCODER_CMD", 381 [_IOC_NR(VIDIOC_TRY_ENCODER_CMD)] = "VIDIOC_TRY_ENCODER_CMD", 382 383 [_IOC_NR(VIDIOC_DBG_S_REGISTER)] = "VIDIOC_DBG_S_REGISTER", 384 [_IOC_NR(VIDIOC_DBG_G_REGISTER)] = "VIDIOC_DBG_G_REGISTER", 385 386 [_IOC_NR(VIDIOC_G_CHIP_IDENT)] = "VIDIOC_G_CHIP_IDENT", 387}; 388#define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls) 389 390static const char *v4l2_int_ioctls[] = { 391#ifdef CONFIG_VIDEO_V4L1_COMPAT 392 [_IOC_NR(DECODER_GET_CAPABILITIES)] = "DECODER_GET_CAPABILITIES", 393 [_IOC_NR(DECODER_GET_STATUS)] = "DECODER_GET_STATUS", 394 [_IOC_NR(DECODER_SET_NORM)] = "DECODER_SET_NORM", 395 [_IOC_NR(DECODER_SET_INPUT)] = "DECODER_SET_INPUT", 396 [_IOC_NR(DECODER_SET_OUTPUT)] = "DECODER_SET_OUTPUT", 397 [_IOC_NR(DECODER_ENABLE_OUTPUT)] = "DECODER_ENABLE_OUTPUT", 398 [_IOC_NR(DECODER_SET_PICTURE)] = "DECODER_SET_PICTURE", 399 [_IOC_NR(DECODER_SET_GPIO)] = "DECODER_SET_GPIO", 400 [_IOC_NR(DECODER_INIT)] = "DECODER_INIT", 401 [_IOC_NR(DECODER_SET_VBI_BYPASS)] = "DECODER_SET_VBI_BYPASS", 402 [_IOC_NR(DECODER_DUMP)] = "DECODER_DUMP", 403#endif 404 [_IOC_NR(AUDC_SET_RADIO)] = "AUDC_SET_RADIO", 405 406 [_IOC_NR(TUNER_SET_TYPE_ADDR)] = "TUNER_SET_TYPE_ADDR", 407 [_IOC_NR(TUNER_SET_STANDBY)] = "TUNER_SET_STANDBY", 408 [_IOC_NR(TDA9887_SET_CONFIG)] = "TDA9887_SET_CONFIG", 409 410 [_IOC_NR(VIDIOC_INT_S_TUNER_MODE)] = "VIDIOC_INT_S_TUNER_MODE", 411 [_IOC_NR(VIDIOC_INT_RESET)] = "VIDIOC_INT_RESET", 412 [_IOC_NR(VIDIOC_INT_AUDIO_CLOCK_FREQ)] = "VIDIOC_INT_AUDIO_CLOCK_FREQ", 413 [_IOC_NR(VIDIOC_INT_DECODE_VBI_LINE)] = "VIDIOC_INT_DECODE_VBI_LINE", 414 [_IOC_NR(VIDIOC_INT_S_VBI_DATA)] = "VIDIOC_INT_S_VBI_DATA", 415 [_IOC_NR(VIDIOC_INT_G_VBI_DATA)] = "VIDIOC_INT_G_VBI_DATA", 416 [_IOC_NR(VIDIOC_INT_I2S_CLOCK_FREQ)] = "VIDIOC_INT_I2S_CLOCK_FREQ", 417 [_IOC_NR(VIDIOC_INT_S_STANDBY)] = "VIDIOC_INT_S_STANDBY", 418 [_IOC_NR(VIDIOC_INT_S_AUDIO_ROUTING)] = "VIDIOC_INT_S_AUDIO_ROUTING", 419 [_IOC_NR(VIDIOC_INT_G_AUDIO_ROUTING)] = "VIDIOC_INT_G_AUDIO_ROUTING", 420 [_IOC_NR(VIDIOC_INT_S_VIDEO_ROUTING)] = "VIDIOC_INT_S_VIDEO_ROUTING", 421 [_IOC_NR(VIDIOC_INT_G_VIDEO_ROUTING)] = "VIDIOC_INT_G_VIDEO_ROUTING", 422 [_IOC_NR(VIDIOC_INT_S_CRYSTAL_FREQ)] = "VIDIOC_INT_S_CRYSTAL_FREQ", 423 [_IOC_NR(VIDIOC_INT_INIT)] = "VIDIOC_INT_INIT", 424 [_IOC_NR(VIDIOC_INT_G_STD_OUTPUT)] = "VIDIOC_INT_G_STD_OUTPUT", 425 [_IOC_NR(VIDIOC_INT_S_STD_OUTPUT)] = "VIDIOC_INT_S_STD_OUTPUT", 426}; 427#define V4L2_INT_IOCTLS ARRAY_SIZE(v4l2_int_ioctls) 428 429 430/* Common ioctl debug function. This function can be used by 431 external ioctl messages as well as internal V4L ioctl */ 432void v4l_printk_ioctl(unsigned int cmd) 433{ 434 char *dir; 435 436 switch (_IOC_DIR(cmd)) { 437 case _IOC_NONE: dir = "--"; break; 438 case _IOC_READ: dir = "r-"; break; 439 case _IOC_WRITE: dir = "-w"; break; 440 case _IOC_READ | _IOC_WRITE: dir = "rw"; break; 441 default: dir = "*ERR*"; break; 442 } 443 switch (_IOC_TYPE(cmd)) { 444 case 'd': 445 printk("v4l2_int ioctl %s, dir=%s (0x%08x)\n", 446 (_IOC_NR(cmd) < V4L2_INT_IOCTLS) ? 447 v4l2_int_ioctls[_IOC_NR(cmd)] : "UNKNOWN", dir, cmd); 448 break; 449#ifdef CONFIG_VIDEO_V4L1_COMPAT 450 case 'v': 451 printk("v4l1 ioctl %s, dir=%s (0x%08x)\n", 452 (_IOC_NR(cmd) < V4L1_IOCTLS) ? 453 v4l1_ioctls[_IOC_NR(cmd)] : "UNKNOWN", dir, cmd); 454 break; 455#endif 456 case 'V': 457 printk("v4l2 ioctl %s, dir=%s (0x%08x)\n", 458 (_IOC_NR(cmd) < V4L2_IOCTLS) ? 459 v4l2_ioctls[_IOC_NR(cmd)] : "UNKNOWN", dir, cmd); 460 break; 461 462 default: 463 printk("unknown ioctl '%c', dir=%s, #%d (0x%08x)\n", 464 _IOC_TYPE(cmd), dir, _IOC_NR(cmd), cmd); 465 } 466} 467 468 469/* ----------------------------------------------------------------- */ 470 471/* Helper functions for control handling */ 472 473/* Check for correctness of the ctrl's value based on the data from 474 struct v4l2_queryctrl and the available menu items. Note that 475 menu_items may be NULL, in that case it is ignored. */ 476int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl, 477 const char **menu_items) 478{ 479 if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED) 480 return -EINVAL; 481 if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED) 482 return -EBUSY; 483 if (qctrl->type == V4L2_CTRL_TYPE_BUTTON || 484 qctrl->type == V4L2_CTRL_TYPE_INTEGER64 || 485 qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS) 486 return 0; 487 if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum) 488 return -ERANGE; 489 if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) { 490 if (menu_items[ctrl->value] == NULL || 491 menu_items[ctrl->value][0] == '\0') 492 return -EINVAL; 493 } 494 return 0; 495} 496 497/* Returns NULL or a character pointer array containing the menu for 498 the given control ID. The pointer array ends with a NULL pointer. 499 An empty string signifies a menu entry that is invalid. This allows 500 drivers to disable certain options if it is not supported. */ 501const char **v4l2_ctrl_get_menu(u32 id) 502{ 503 static const char *mpeg_audio_sampling_freq[] = { 504 "44.1 kHz", 505 "48 kHz", 506 "32 kHz", 507 NULL 508 }; 509 static const char *mpeg_audio_encoding[] = { 510 "Layer I", 511 "Layer II", 512 "Layer III", 513 NULL 514 }; 515 static const char *mpeg_audio_l1_bitrate[] = { 516 "32 kbps", 517 "64 kbps", 518 "96 kbps", 519 "128 kbps", 520 "160 kbps", 521 "192 kbps", 522 "224 kbps", 523 "256 kbps", 524 "288 kbps", 525 "320 kbps", 526 "352 kbps", 527 "384 kbps", 528 "416 kbps", 529 "448 kbps", 530 NULL 531 }; 532 static const char *mpeg_audio_l2_bitrate[] = { 533 "32 kbps", 534 "48 kbps", 535 "56 kbps", 536 "64 kbps", 537 "80 kbps", 538 "96 kbps", 539 "112 kbps", 540 "128 kbps", 541 "160 kbps", 542 "192 kbps", 543 "224 kbps", 544 "256 kbps", 545 "320 kbps", 546 "384 kbps", 547 NULL 548 }; 549 static const char *mpeg_audio_l3_bitrate[] = { 550 "32 kbps", 551 "40 kbps", 552 "48 kbps", 553 "56 kbps", 554 "64 kbps", 555 "80 kbps", 556 "96 kbps", 557 "112 kbps", 558 "128 kbps", 559 "160 kbps", 560 "192 kbps", 561 "224 kbps", 562 "256 kbps", 563 "320 kbps", 564 NULL 565 }; 566 static const char *mpeg_audio_mode[] = { 567 "Stereo", 568 "Joint Stereo", 569 "Dual", 570 "Mono", 571 NULL 572 }; 573 static const char *mpeg_audio_mode_extension[] = { 574 "Bound 4", 575 "Bound 8", 576 "Bound 12", 577 "Bound 16", 578 NULL 579 }; 580 static const char *mpeg_audio_emphasis[] = { 581 "No Emphasis", 582 "50/15 us", 583 "CCITT J17", 584 NULL 585 }; 586 static const char *mpeg_audio_crc[] = { 587 "No CRC", 588 "16-bit CRC", 589 NULL 590 }; 591 static const char *mpeg_video_encoding[] = { 592 "MPEG-1", 593 "MPEG-2", 594 NULL 595 }; 596 static const char *mpeg_video_aspect[] = { 597 "1x1", 598 "4x3", 599 "16x9", 600 "2.21x1", 601 NULL 602 }; 603 static const char *mpeg_video_bitrate_mode[] = { 604 "Variable Bitrate", 605 "Constant Bitrate", 606 NULL 607 }; 608 static const char *mpeg_stream_type[] = { 609 "MPEG-2 Program Stream", 610 "MPEG-2 Transport Stream", 611 "MPEG-1 System Stream", 612 "MPEG-2 DVD-compatible Stream", 613 "MPEG-1 VCD-compatible Stream", 614 "MPEG-2 SVCD-compatible Stream", 615 NULL 616 }; 617 static const char *mpeg_stream_vbi_fmt[] = { 618 "No VBI", 619 "Private packet, IVTV format", 620 NULL 621 }; 622 623 switch (id) { 624 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: 625 return mpeg_audio_sampling_freq; 626 case V4L2_CID_MPEG_AUDIO_ENCODING: 627 return mpeg_audio_encoding; 628 case V4L2_CID_MPEG_AUDIO_L1_BITRATE: 629 return mpeg_audio_l1_bitrate; 630 case V4L2_CID_MPEG_AUDIO_L2_BITRATE: 631 return mpeg_audio_l2_bitrate; 632 case V4L2_CID_MPEG_AUDIO_L3_BITRATE: 633 return mpeg_audio_l3_bitrate; 634 case V4L2_CID_MPEG_AUDIO_MODE: 635 return mpeg_audio_mode; 636 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: 637 return mpeg_audio_mode_extension; 638 case V4L2_CID_MPEG_AUDIO_EMPHASIS: 639 return mpeg_audio_emphasis; 640 case V4L2_CID_MPEG_AUDIO_CRC: 641 return mpeg_audio_crc; 642 case V4L2_CID_MPEG_VIDEO_ENCODING: 643 return mpeg_video_encoding; 644 case V4L2_CID_MPEG_VIDEO_ASPECT: 645 return mpeg_video_aspect; 646 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: 647 return mpeg_video_bitrate_mode; 648 case V4L2_CID_MPEG_STREAM_TYPE: 649 return mpeg_stream_type; 650 case V4L2_CID_MPEG_STREAM_VBI_FMT: 651 return mpeg_stream_vbi_fmt; 652 default: 653 return NULL; 654 } 655} 656 657/* Fill in a struct v4l2_queryctrl */ 658int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def) 659{ 660 const char *name; 661 662 qctrl->flags = 0; 663 switch (qctrl->id) { 664 /* USER controls */ 665 case V4L2_CID_USER_CLASS: name = "User Controls"; break; 666 case V4L2_CID_AUDIO_VOLUME: name = "Volume"; break; 667 case V4L2_CID_AUDIO_MUTE: name = "Mute"; break; 668 case V4L2_CID_AUDIO_BALANCE: name = "Balance"; break; 669 case V4L2_CID_AUDIO_BASS: name = "Bass"; break; 670 case V4L2_CID_AUDIO_TREBLE: name = "Treble"; break; 671 case V4L2_CID_AUDIO_LOUDNESS: name = "Loudness"; break; 672 case V4L2_CID_BRIGHTNESS: name = "Brightness"; break; 673 case V4L2_CID_CONTRAST: name = "Contrast"; break; 674 case V4L2_CID_SATURATION: name = "Saturation"; break; 675 case V4L2_CID_HUE: name = "Hue"; break; 676 677 /* MPEG controls */ 678 case V4L2_CID_MPEG_CLASS: name = "MPEG Encoder Controls"; break; 679 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: name = "Audio Sampling Frequency"; break; 680 case V4L2_CID_MPEG_AUDIO_ENCODING: name = "Audio Encoding Layer"; break; 681 case V4L2_CID_MPEG_AUDIO_L1_BITRATE: name = "Audio Layer I Bitrate"; break; 682 case V4L2_CID_MPEG_AUDIO_L2_BITRATE: name = "Audio Layer II Bitrate"; break; 683 case V4L2_CID_MPEG_AUDIO_L3_BITRATE: name = "Audio Layer III Bitrate"; break; 684 case V4L2_CID_MPEG_AUDIO_MODE: name = "Audio Stereo Mode"; break; 685 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: name = "Audio Stereo Mode Extension"; break; 686 case V4L2_CID_MPEG_AUDIO_EMPHASIS: name = "Audio Emphasis"; break; 687 case V4L2_CID_MPEG_AUDIO_CRC: name = "Audio CRC"; break; 688 case V4L2_CID_MPEG_AUDIO_MUTE: name = "Audio Mute"; break; 689 case V4L2_CID_MPEG_VIDEO_ENCODING: name = "Video Encoding"; break; 690 case V4L2_CID_MPEG_VIDEO_ASPECT: name = "Video Aspect"; break; 691 case V4L2_CID_MPEG_VIDEO_B_FRAMES: name = "Video B Frames"; break; 692 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: name = "Video GOP Size"; break; 693 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE: name = "Video GOP Closure"; break; 694 case V4L2_CID_MPEG_VIDEO_PULLDOWN: name = "Video Pulldown"; break; 695 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: name = "Video Bitrate Mode"; break; 696 case V4L2_CID_MPEG_VIDEO_BITRATE: name = "Video Bitrate"; break; 697 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK: name = "Video Peak Bitrate"; break; 698 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: name = "Video Temporal Decimation"; break; 699 case V4L2_CID_MPEG_VIDEO_MUTE: name = "Video Mute"; break; 700 case V4L2_CID_MPEG_VIDEO_MUTE_YUV: name = "Video Mute YUV"; break; 701 case V4L2_CID_MPEG_STREAM_TYPE: name = "Stream Type"; break; 702 case V4L2_CID_MPEG_STREAM_PID_PMT: name = "Stream PMT Program ID"; break; 703 case V4L2_CID_MPEG_STREAM_PID_AUDIO: name = "Stream Audio Program ID"; break; 704 case V4L2_CID_MPEG_STREAM_PID_VIDEO: name = "Stream Video Program ID"; break; 705 case V4L2_CID_MPEG_STREAM_PID_PCR: name = "Stream PCR Program ID"; break; 706 case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: name = "Stream PES Audio ID"; break; 707 case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: name = "Stream PES Video ID"; break; 708 case V4L2_CID_MPEG_STREAM_VBI_FMT: name = "Stream VBI Format"; break; 709 710 default: 711 return -EINVAL; 712 } 713 switch (qctrl->id) { 714 case V4L2_CID_AUDIO_MUTE: 715 case V4L2_CID_AUDIO_LOUDNESS: 716 case V4L2_CID_MPEG_AUDIO_MUTE: 717 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE: 718 case V4L2_CID_MPEG_VIDEO_PULLDOWN: 719 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN; 720 min = 0; 721 max = step = 1; 722 break; 723 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: 724 case V4L2_CID_MPEG_AUDIO_ENCODING: 725 case V4L2_CID_MPEG_AUDIO_L1_BITRATE: 726 case V4L2_CID_MPEG_AUDIO_L2_BITRATE: 727 case V4L2_CID_MPEG_AUDIO_L3_BITRATE: 728 case V4L2_CID_MPEG_AUDIO_MODE: 729 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: 730 case V4L2_CID_MPEG_AUDIO_EMPHASIS: 731 case V4L2_CID_MPEG_AUDIO_CRC: 732 case V4L2_CID_MPEG_VIDEO_ENCODING: 733 case V4L2_CID_MPEG_VIDEO_ASPECT: 734 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: 735 case V4L2_CID_MPEG_STREAM_TYPE: 736 case V4L2_CID_MPEG_STREAM_VBI_FMT: 737 qctrl->type = V4L2_CTRL_TYPE_MENU; 738 step = 1; 739 break; 740 case V4L2_CID_USER_CLASS: 741 case V4L2_CID_MPEG_CLASS: 742 qctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS; 743 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 744 min = max = step = def = 0; 745 break; 746 default: 747 qctrl->type = V4L2_CTRL_TYPE_INTEGER; 748 break; 749 } 750 switch (qctrl->id) { 751 case V4L2_CID_MPEG_AUDIO_ENCODING: 752 case V4L2_CID_MPEG_AUDIO_MODE: 753 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: 754 case V4L2_CID_MPEG_VIDEO_B_FRAMES: 755 case V4L2_CID_MPEG_STREAM_TYPE: 756 qctrl->flags |= V4L2_CTRL_FLAG_UPDATE; 757 break; 758 case V4L2_CID_AUDIO_VOLUME: 759 case V4L2_CID_AUDIO_BALANCE: 760 case V4L2_CID_AUDIO_BASS: 761 case V4L2_CID_AUDIO_TREBLE: 762 case V4L2_CID_BRIGHTNESS: 763 case V4L2_CID_CONTRAST: 764 case V4L2_CID_SATURATION: 765 case V4L2_CID_HUE: 766 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER; 767 break; 768 } 769 qctrl->minimum = min; 770 qctrl->maximum = max; 771 qctrl->step = step; 772 qctrl->default_value = def; 773 qctrl->reserved[0] = qctrl->reserved[1] = 0; 774 snprintf(qctrl->name, sizeof(qctrl->name), name); 775 return 0; 776} 777 778/* Fill in a struct v4l2_queryctrl with standard values based on 779 the control ID. */ 780int v4l2_ctrl_query_fill_std(struct v4l2_queryctrl *qctrl) 781{ 782 switch (qctrl->id) { 783 /* USER controls */ 784 case V4L2_CID_USER_CLASS: 785 case V4L2_CID_MPEG_CLASS: 786 return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0); 787 case V4L2_CID_AUDIO_VOLUME: 788 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 58880); 789 case V4L2_CID_AUDIO_MUTE: 790 case V4L2_CID_AUDIO_LOUDNESS: 791 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0); 792 case V4L2_CID_AUDIO_BALANCE: 793 case V4L2_CID_AUDIO_BASS: 794 case V4L2_CID_AUDIO_TREBLE: 795 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 32768); 796 case V4L2_CID_BRIGHTNESS: 797 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 128); 798 case V4L2_CID_CONTRAST: 799 case V4L2_CID_SATURATION: 800 return v4l2_ctrl_query_fill(qctrl, 0, 127, 1, 64); 801 case V4L2_CID_HUE: 802 return v4l2_ctrl_query_fill(qctrl, -128, 127, 1, 0); 803 804 /* MPEG controls */ 805 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: 806 return v4l2_ctrl_query_fill(qctrl, 807 V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100, 808 V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 1, 809 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000); 810 case V4L2_CID_MPEG_AUDIO_ENCODING: 811 return v4l2_ctrl_query_fill(qctrl, 812 V4L2_MPEG_AUDIO_ENCODING_LAYER_1, 813 V4L2_MPEG_AUDIO_ENCODING_LAYER_3, 1, 814 V4L2_MPEG_AUDIO_ENCODING_LAYER_2); 815 case V4L2_CID_MPEG_AUDIO_L1_BITRATE: 816 return v4l2_ctrl_query_fill(qctrl, 817 V4L2_MPEG_AUDIO_L1_BITRATE_32K, 818 V4L2_MPEG_AUDIO_L1_BITRATE_448K, 1, 819 V4L2_MPEG_AUDIO_L1_BITRATE_256K); 820 case V4L2_CID_MPEG_AUDIO_L2_BITRATE: 821 return v4l2_ctrl_query_fill(qctrl, 822 V4L2_MPEG_AUDIO_L2_BITRATE_32K, 823 V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1, 824 V4L2_MPEG_AUDIO_L2_BITRATE_224K); 825 case V4L2_CID_MPEG_AUDIO_L3_BITRATE: 826 return v4l2_ctrl_query_fill(qctrl, 827 V4L2_MPEG_AUDIO_L3_BITRATE_32K, 828 V4L2_MPEG_AUDIO_L3_BITRATE_320K, 1, 829 V4L2_MPEG_AUDIO_L3_BITRATE_192K); 830 case V4L2_CID_MPEG_AUDIO_MODE: 831 return v4l2_ctrl_query_fill(qctrl, 832 V4L2_MPEG_AUDIO_MODE_STEREO, 833 V4L2_MPEG_AUDIO_MODE_MONO, 1, 834 V4L2_MPEG_AUDIO_MODE_STEREO); 835 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: 836 return v4l2_ctrl_query_fill(qctrl, 837 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4, 838 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 1, 839 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4); 840 case V4L2_CID_MPEG_AUDIO_EMPHASIS: 841 return v4l2_ctrl_query_fill(qctrl, 842 V4L2_MPEG_AUDIO_EMPHASIS_NONE, 843 V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 1, 844 V4L2_MPEG_AUDIO_EMPHASIS_NONE); 845 case V4L2_CID_MPEG_AUDIO_CRC: 846 return v4l2_ctrl_query_fill(qctrl, 847 V4L2_MPEG_AUDIO_CRC_NONE, 848 V4L2_MPEG_AUDIO_CRC_CRC16, 1, 849 V4L2_MPEG_AUDIO_CRC_NONE); 850 case V4L2_CID_MPEG_AUDIO_MUTE: 851 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0); 852 case V4L2_CID_MPEG_VIDEO_ENCODING: 853 return v4l2_ctrl_query_fill(qctrl, 854 V4L2_MPEG_VIDEO_ENCODING_MPEG_1, 855 V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 1, 856 V4L2_MPEG_VIDEO_ENCODING_MPEG_2); 857 case V4L2_CID_MPEG_VIDEO_ASPECT: 858 return v4l2_ctrl_query_fill(qctrl, 859 V4L2_MPEG_VIDEO_ASPECT_1x1, 860 V4L2_MPEG_VIDEO_ASPECT_221x100, 1, 861 V4L2_MPEG_VIDEO_ASPECT_4x3); 862 case V4L2_CID_MPEG_VIDEO_B_FRAMES: 863 return v4l2_ctrl_query_fill(qctrl, 0, 33, 1, 2); 864 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: 865 return v4l2_ctrl_query_fill(qctrl, 1, 34, 1, 12); 866 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE: 867 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1); 868 case V4L2_CID_MPEG_VIDEO_PULLDOWN: 869 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0); 870 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: 871 return v4l2_ctrl_query_fill(qctrl, 872 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR, 873 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 1, 874 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR); 875 case V4L2_CID_MPEG_VIDEO_BITRATE: 876 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 6000000); 877 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK: 878 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 8000000); 879 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: 880 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0); 881 case V4L2_CID_MPEG_VIDEO_MUTE: 882 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0); 883 case V4L2_CID_MPEG_VIDEO_MUTE_YUV: /* Init YUV (really YCbCr) to black */ 884 return v4l2_ctrl_query_fill(qctrl, 0, 0xffffff, 1, 0x008080); 885 case V4L2_CID_MPEG_STREAM_TYPE: 886 return v4l2_ctrl_query_fill(qctrl, 887 V4L2_MPEG_STREAM_TYPE_MPEG2_PS, 888 V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, 1, 889 V4L2_MPEG_STREAM_TYPE_MPEG2_PS); 890 case V4L2_CID_MPEG_STREAM_PID_PMT: 891 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 16); 892 case V4L2_CID_MPEG_STREAM_PID_AUDIO: 893 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 260); 894 case V4L2_CID_MPEG_STREAM_PID_VIDEO: 895 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 256); 896 case V4L2_CID_MPEG_STREAM_PID_PCR: 897 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 259); 898 case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: 899 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0); 900 case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: 901 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0); 902 case V4L2_CID_MPEG_STREAM_VBI_FMT: 903 return v4l2_ctrl_query_fill(qctrl, 904 V4L2_MPEG_STREAM_VBI_FMT_NONE, 905 V4L2_MPEG_STREAM_VBI_FMT_IVTV, 1, 906 V4L2_MPEG_STREAM_VBI_FMT_NONE); 907 default: 908 return -EINVAL; 909 } 910} 911 912/* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and 913 the menu. The qctrl pointer may be NULL, in which case it is ignored. */ 914int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl, 915 const char **menu_items) 916{ 917 int i; 918 919 if (menu_items == NULL || 920 (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum))) 921 return -EINVAL; 922 for (i = 0; i < qmenu->index && menu_items[i]; i++) ; 923 if (menu_items[i] == NULL || menu_items[i][0] == '\0') 924 return -EINVAL; 925 snprintf(qmenu->name, sizeof(qmenu->name), menu_items[qmenu->index]); 926 qmenu->reserved = 0; 927 return 0; 928} 929 930/* ctrl_classes points to an array of u32 pointers, the last element is 931 a NULL pointer. Each u32 array is a 0-terminated array of control IDs. 932 Each array must be sorted low to high and belong to the same control 933 class. The array of u32 pointer must also be sorted, from low class IDs 934 to high class IDs. 935 936 This function returns the first ID that follows after the given ID. 937 When no more controls are available 0 is returned. */ 938u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id) 939{ 940 u32 ctrl_class; 941 const u32 *pctrl; 942 943 /* if no query is desired, then just return the control ID */ 944 if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) 945 return id; 946 if (ctrl_classes == NULL) 947 return 0; 948 id &= V4L2_CTRL_ID_MASK; 949 ctrl_class = V4L2_CTRL_ID2CLASS(id); 950 id++; /* select next control */ 951 /* find first class that matches (or is greater than) the class of 952 the ID */ 953 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class) 954 ctrl_classes++; 955 /* no more classes */ 956 if (*ctrl_classes == NULL) 957 return 0; 958 pctrl = *ctrl_classes; 959 /* find first ctrl within the class that is >= ID */ 960 while (*pctrl && *pctrl < id) pctrl++; 961 if (*pctrl) 962 return *pctrl; 963 /* we are at the end of the controls of the current class. */ 964 /* continue with next class if available */ 965 ctrl_classes++; 966 if (*ctrl_classes == NULL) 967 return 0; 968 return **ctrl_classes; 969} 970 971int v4l2_chip_match_i2c_client(struct i2c_client *c, u32 match_type, u32 match_chip) 972{ 973 switch (match_type) { 974 case V4L2_CHIP_MATCH_I2C_DRIVER: 975 return (c != NULL && c->driver != NULL && c->driver->id == match_chip); 976 case V4L2_CHIP_MATCH_I2C_ADDR: 977 return (c != NULL && c->addr == match_chip); 978 default: 979 return 0; 980 } 981} 982 983int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_chip_ident *chip, 984 u32 ident, u32 revision) 985{ 986 if (!v4l2_chip_match_i2c_client(c, chip->match_type, chip->match_chip)) 987 return 0; 988 if (chip->ident == V4L2_IDENT_NONE) { 989 chip->ident = ident; 990 chip->revision = revision; 991 } 992 else { 993 chip->ident = V4L2_IDENT_AMBIGUOUS; 994 chip->revision = 0; 995 } 996 return 0; 997} 998 999int v4l2_chip_match_host(u32 match_type, u32 match_chip) 1000{ 1001 switch (match_type) { 1002 case V4L2_CHIP_MATCH_HOST: 1003 return match_chip == 0; 1004 default: 1005 return 0; 1006 } 1007} 1008 1009/* ----------------------------------------------------------------- */ 1010 1011EXPORT_SYMBOL(v4l2_norm_to_name); 1012EXPORT_SYMBOL(v4l2_video_std_construct); 1013 1014EXPORT_SYMBOL(v4l2_prio_init); 1015EXPORT_SYMBOL(v4l2_prio_change); 1016EXPORT_SYMBOL(v4l2_prio_open); 1017EXPORT_SYMBOL(v4l2_prio_close); 1018EXPORT_SYMBOL(v4l2_prio_max); 1019EXPORT_SYMBOL(v4l2_prio_check); 1020 1021EXPORT_SYMBOL(v4l2_field_names); 1022EXPORT_SYMBOL(v4l2_type_names); 1023EXPORT_SYMBOL(v4l_printk_ioctl); 1024 1025EXPORT_SYMBOL(v4l2_ctrl_next); 1026EXPORT_SYMBOL(v4l2_ctrl_check); 1027EXPORT_SYMBOL(v4l2_ctrl_get_menu); 1028EXPORT_SYMBOL(v4l2_ctrl_query_menu); 1029EXPORT_SYMBOL(v4l2_ctrl_query_fill); 1030EXPORT_SYMBOL(v4l2_ctrl_query_fill_std); 1031 1032EXPORT_SYMBOL(v4l2_chip_match_i2c_client); 1033EXPORT_SYMBOL(v4l2_chip_ident_i2c_client); 1034EXPORT_SYMBOL(v4l2_chip_match_host); 1035 1036/* 1037 * Local variables: 1038 * c-basic-offset: 8 1039 * End: 1040 */ 1041