Pileus Git - ~andy/linux/blob - drivers/staging/easycap/easycap_ioctl.c

   1 /******************************************************************************
   2 *                                                                             *
   3 *  easycap_ioctl.c                                                            *
   4 *                                                                             *
   5 ******************************************************************************/
   6 /*
   7  *
   8  *  Copyright (C) 2010 R.M. Thomas  <rmthomas@sciolus.org>
   9  *
  10  *
  11  *  This is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  The software is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this software; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24  *
  25 */
  26 /*****************************************************************************/
  27
  28 #include "easycap.h"
  29 #include "easycap_debug.h"
  30 #include "easycap_standard.h"
  31 #include "easycap_ioctl.h"
  32
  33 /*--------------------------------------------------------------------------*/
  34 /*
  35  *  UNLESS THERE IS A PREMATURE ERROR RETURN THIS ROUTINE UPDATES THE
  36  *  FOLLOWING:
  37  *          peasycap->standard_offset
  38  *          peasycap->fps
  39  *          peasycap->usec
  40  *          peasycap->tolerate
  41  */
  42 /*---------------------------------------------------------------------------*/
  43 int adjust_standard(struct easycap *peasycap, v4l2_std_id std_id)
  44 {
  45 struct easycap_standard const *peasycap_standard;
  46 __u16 reg, set;
  47 int ir, rc, need;
  48 unsigned int itwas, isnow;
  49
  50 if ((struct usb_device *)NULL == peasycap->pusb_device) {
  51         SAY("ERROR: peasycap->pusb_device is NULL\n");
  52         return -EFAULT;
  53 }
  54 peasycap_standard = &easycap_standard[0];
  55 while (0xFFFF != peasycap_standard->mask) {
  56         if (std_id & peasycap_standard->v4l2_standard.id)
  57                 break;
  58         peasycap_standard++;
  59 }
  60 if (0xFFFF == peasycap_standard->mask) {
  61         SAY("ERROR: 0x%08X=std_id: standard not found\n", \
  62                                                         (unsigned int)std_id);
  63         return -EINVAL;
  64 }
  65 SAY("user requests standard: %s\n", \
  66                         &(peasycap_standard->v4l2_standard.name[0]));
  67 if (peasycap->standard_offset == \
  68                         (int)(peasycap_standard - &easycap_standard[0])) {
  69         SAY("requested standard already in effect\n");
  70         return 0;
  71 }
  72 peasycap->standard_offset = (int)(peasycap_standard - &easycap_standard[0]);
  73 peasycap->fps = peasycap_standard->v4l2_standard.frameperiod.denominator / \
  74                 peasycap_standard->v4l2_standard.frameperiod.numerator;
  75 if (!peasycap->fps) {
  76         SAY("MISTAKE: frames-per-second is zero\n");
  77         return -EFAULT;
  78 }
  79 JOT(8, "%i frames-per-second\n", peasycap->fps);
  80 peasycap->usec = 1000000 / (2 * peasycap->fps);
  81 peasycap->tolerate = 1000 * (25 / peasycap->fps);
  82
  83 kill_video_urbs(peasycap);
  84
  85 /*--------------------------------------------------------------------------*/
  86 /*
  87  *  SAA7113H DATASHEET PAGE 44, TABLE 42
  88  */
  89 /*--------------------------------------------------------------------------*/
  90 need = 0;  itwas = 0;  reg = 0x00;  set = 0x00;
  91 switch (peasycap_standard->mask & 0x000F) {
  92 case NTSC_M_JP: {
  93         reg = 0x0A;  set = 0x95;
  94         ir = read_saa(peasycap->pusb_device, reg);
  95         if (0 > ir)
  96                 SAY("ERROR: cannot read SAA register 0x%02X\n", reg);
  97         else
  98                 itwas = (unsigned int)ir;
  99
 100
 101         set2to78(peasycap->pusb_device);
 102
 103
 104         rc = write_saa(peasycap->pusb_device, reg, set);
 105         if (0 != rc)
 106                 SAY("ERROR: failed to set SAA register " \
 107                         "0x%02X to 0x%02X for JP standard\n", reg, set);
 108         else {
 109                 isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
 110                 if (0 > ir)
 111                         JOT(8, "SAA register 0x%02X changed " \
 112                                 "to 0x%02X\n", reg, isnow);
 113                 else
 114                         JOT(8, "SAA register 0x%02X changed " \
 115                                 "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
 116
 117                 set2to78(peasycap->pusb_device);
 118
 119         }
 120
 121         reg = 0x0B;  set = 0x48;
 122         ir = read_saa(peasycap->pusb_device, reg);
 123         if (0 > ir)
 124                 SAY("ERROR: cannot read SAA register 0x%02X\n", reg);
 125         else
 126                 itwas = (unsigned int)ir;
 127
 128         set2to78(peasycap->pusb_device);
 129
 130         rc = write_saa(peasycap->pusb_device, reg, set);
 131         if (0 != rc)
 132                 SAY("ERROR: failed to set SAA register 0x%02X to 0x%02X " \
 133                                                 "for JP standard\n", reg, set);
 134         else {
 135                 isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
 136                 if (0 > ir)
 137                         JOT(8, "SAA register 0x%02X changed " \
 138                                 "to 0x%02X\n", reg, isnow);
 139                 else
 140                         JOT(8, "SAA register 0x%02X changed " \
 141                                 "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
 142
 143                 set2to78(peasycap->pusb_device);
 144
 145         }
 146 /*--------------------------------------------------------------------------*/
 147 /*
 148  *  NOTE:  NO break HERE:  RUN ON TO NEXT CASE
 149  */
 150 /*--------------------------------------------------------------------------*/
 151 }
 152 case NTSC_M:
 153 case PAL_BGHIN: {
 154         reg = 0x0E;  set = 0x01;  need = 1;  break;
 155 }
 156 case NTSC_N_443:
 157 case PAL_60: {
 158         reg = 0x0E;  set = 0x11;  need = 1;  break;
 159 }
 160 case NTSC_443:
 161 case PAL_Nc: {
 162         reg = 0x0E;  set = 0x21;  need = 1;  break;
 163 }
 164 case NTSC_N:
 165 case PAL_M: {
 166         reg = 0x0E;  set = 0x31;  need = 1;  break;
 167 }
 168 case SECAM: {
 169         reg = 0x0E;  set = 0x51;  need = 1;  break;
 170 }
 171 default:
 172         break;
 173 }
 174 /*--------------------------------------------------------------------------*/
 175 if (need) {
 176         ir = read_saa(peasycap->pusb_device, reg);
 177         if (0 > ir)
 178                 SAY("ERROR: failed to read SAA register 0x%02X\n", reg);
 179         else
 180                 itwas = (unsigned int)ir;
 181
 182         set2to78(peasycap->pusb_device);
 183
 184         rc = write_saa(peasycap->pusb_device, reg, set);
 185         if (0 != write_saa(peasycap->pusb_device, reg, set)) {
 186                 SAY("ERROR: failed to set SAA register " \
 187                         "0x%02X to 0x%02X for table 42\n", reg, set);
 188         } else {
 189                 isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
 190                 if (0 > ir)
 191                         JOT(8, "SAA register 0x%02X changed " \
 192                                 "to 0x%02X\n", reg, isnow);
 193                 else
 194                         JOT(8, "SAA register 0x%02X changed " \
 195                                 "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
 196         }
 197 }
 198 /*--------------------------------------------------------------------------*/
 199 /*
 200  *  SAA7113H DATASHEET PAGE 41
 201  */
 202 /*--------------------------------------------------------------------------*/
 203 reg = 0x08;
 204 ir = read_saa(peasycap->pusb_device, reg);
 205 if (0 > ir)
 206         SAY("ERROR: failed to read SAA register 0x%02X " \
 207                                                 "so cannot reset\n", reg);
 208 else {
 209         itwas = (unsigned int)ir;
 210         if (peasycap_standard->mask & 0x0001)
 211                 set = itwas | 0x40 ;
 212         else
 213                 set = itwas & ~0x40 ;
 214
 215 set2to78(peasycap->pusb_device);
 216
 217 rc  = write_saa(peasycap->pusb_device, reg, set);
 218 if (0 != rc)
 219         SAY("ERROR: failed to set SAA register 0x%02X to 0x%02X\n", reg, set);
 220 else {
 221         isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
 222         if (0 > ir)
 223                 JOT(8, "SAA register 0x%02X changed to 0x%02X\n", reg, isnow);
 224         else
 225                 JOT(8, "SAA register 0x%02X changed " \
 226                         "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
 227         }
 228 }
 229 /*--------------------------------------------------------------------------*/
 230 /*
 231  *  SAA7113H DATASHEET PAGE 51, TABLE 57
 232  */
 233 /*---------------------------------------------------------------------------*/
 234 reg = 0x40;
 235 ir = read_saa(peasycap->pusb_device, reg);
 236 if (0 > ir)
 237         SAY("ERROR: failed to read SAA register 0x%02X " \
 238                                                 "so cannot reset\n", reg);
 239 else {
 240         itwas = (unsigned int)ir;
 241         if (peasycap_standard->mask & 0x0001)
 242                 set = itwas | 0x80 ;
 243         else
 244                 set = itwas & ~0x80 ;
 245
 246 set2to78(peasycap->pusb_device);
 247
 248 rc = write_saa(peasycap->pusb_device, reg, set);
 249 if (0 != rc)
 250         SAY("ERROR: failed to set SAA register 0x%02X to 0x%02X\n", reg, set);
 251 else {
 252         isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
 253         if (0 > ir)
 254                 JOT(8, "SAA register 0x%02X changed to 0x%02X\n", reg, isnow);
 255         else
 256                 JOT(8, "SAA register 0x%02X changed " \
 257                         "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
 258         }
 259 }
 260 /*--------------------------------------------------------------------------*/
 261 /*
 262  *  SAA7113H DATASHEET PAGE 53, TABLE 66
 263  */
 264 /*--------------------------------------------------------------------------*/
 265 reg = 0x5A;
 266 ir = read_saa(peasycap->pusb_device, reg);
 267 if (0 > ir)
 268         SAY("ERROR: failed to read SAA register 0x%02X but continuing\n", reg);
 269         itwas = (unsigned int)ir;
 270         if (peasycap_standard->mask & 0x0001)
 271                 set = 0x0A ;
 272         else
 273                 set = 0x07 ;
 274
 275         set2to78(peasycap->pusb_device);
 276
 277         if (0 != write_saa(peasycap->pusb_device, reg, set))
 278                 SAY("ERROR: failed to set SAA register 0x%02X to 0x%02X\n", \
 279                                                                 reg, set);
 280         else {
 281                 isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
 282                 if (0 > ir)
 283                         JOT(8, "SAA register 0x%02X changed "
 284                                 "to 0x%02X\n", reg, isnow);
 285                 else
 286                         JOT(8, "SAA register 0x%02X changed "
 287                                 "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
 288         }
 289         if (0 != check_saa(peasycap->pusb_device))
 290                 SAY("ERROR: check_saa() failed\n");
 291 return 0;
 292 }
 293 /*****************************************************************************/
 294 /*--------------------------------------------------------------------------*/
 295 /*
 296  *  THE ALGORITHM FOR RESPONDING TO THE VIDIO_S_FMT IOCTL DEPENDS ON THE
 297  *  CURRENT VALUE OF peasycap->standard_offset.
 298  *  PROVIDED THE ARGUMENT try IS false AND THERE IS NO PREMATURE ERROR RETURN
 299  *  THIS ROUTINE UPDATES THE FOLLOWING:
 300  *          peasycap->format_offset
 301  *          peasycap->pixelformat
 302  *          peasycap->field
 303  *          peasycap->height
 304  *          peasycap->width
 305  *          peasycap->bytesperpixel
 306  *          peasycap->byteswaporder
 307  *          peasycap->decimatepixel
 308  *          peasycap->frame_buffer_used
 309  *          peasycap->videofieldamount
 310  *          peasycap->offerfields
 311  *
 312  *  IF SUCCESSFUL THE FUNCTION RETURNS THE OFFSET IN easycap_format[]
 313  *  IDENTIFYING THE FORMAT WHICH IS TO RETURNED TO THE USER.
 314  *  ERRORS RETURN A NEGATIVE NUMBER.
 315  */
 316 /*--------------------------------------------------------------------------*/
 317 int adjust_format(struct easycap *peasycap, \
 318         __u32 width, __u32 height, __u32 pixelformat, int field, bool try)
 319 {
 320 struct easycap_format *peasycap_format, *peasycap_best_format;
 321 __u16 mask;
 322 struct usb_device *p;
 323 int miss, multiplier, best;
 324 char bf[5], *pc;
 325 __u32 uc;
 326
 327 if ((struct easycap *)NULL == peasycap) {
 328         SAY("ERROR: peasycap is NULL\n");
 329         return -EFAULT;
 330 }
 331 p = peasycap->pusb_device;
 332 if ((struct usb_device *)NULL == p) {
 333         SAY("ERROR: peaycap->pusb_device is NULL\n");
 334         return -EFAULT;
 335 }
 336 pc = &bf[0];
 337 uc = pixelformat;  memcpy((void *)pc, (void *)(&uc), 4);  bf[4] = 0;
 338 mask = easycap_standard[peasycap->standard_offset].mask;
 339 SAY("sought:    %ix%i,%s(0x%08X),%i=field,0x%02X=std mask\n", \
 340                                 width, height, pc, pixelformat, field, mask);
 341 if (V4L2_FIELD_ANY == field) {
 342         field = V4L2_FIELD_INTERLACED;
 343         SAY("prefer:    V4L2_FIELD_INTERLACED=field, was V4L2_FIELD_ANY\n");
 344 }
 345 peasycap_best_format = (struct easycap_format *)NULL;
 346 peasycap_format = &easycap_format[0];
 347 while (0 != peasycap_format->v4l2_format.fmt.pix.width) {
 348         JOT(16, ".> %i %i 0x%08X %ix%i\n", \
 349                 peasycap_format->mask & 0x01,
 350                 peasycap_format->v4l2_format.fmt.pix.field,
 351                 peasycap_format->v4l2_format.fmt.pix.pixelformat,
 352                 peasycap_format->v4l2_format.fmt.pix.width,
 353                 peasycap_format->v4l2_format.fmt.pix.height);
 354
 355         if (((peasycap_format->mask & 0x0F) == (mask & 0x0F)) && \
 356                 (peasycap_format->v4l2_format.fmt.pix.field == field) && \
 357                 (peasycap_format->v4l2_format.fmt.pix.pixelformat == \
 358                                                         pixelformat) && \
 359                 (peasycap_format->v4l2_format.fmt.pix.width  == width) && \
 360                 (peasycap_format->v4l2_format.fmt.pix.height == height)) {
 361                         peasycap_best_format = peasycap_format;
 362                         break;
 363                 }
 364         peasycap_format++;
 365 }
 366 if (0 == peasycap_format->v4l2_format.fmt.pix.width) {
 367         SAY("cannot do: %ix%i with standard mask 0x%02X\n", \
 368                                                         width, height, mask);
 369         peasycap_format = &easycap_format[0];  best = -1;
 370         while (0 != peasycap_format->v4l2_format.fmt.pix.width) {
 371                 if (((peasycap_format->mask & 0x0F) == (mask & 0x0F)) && \
 372                                  (peasycap_format->v4l2_format.fmt.pix\
 373                                                 .field == field) && \
 374                                  (peasycap_format->v4l2_format.fmt.pix\
 375                                                 .pixelformat == pixelformat)) {
 376                         miss = abs(peasycap_format->\
 377                                         v4l2_format.fmt.pix.width  - width);
 378                         if ((best > miss) || (best < 0)) {
 379                                 best = miss;
 380                                 peasycap_best_format = peasycap_format;
 381                                 if (!miss)
 382                                         break;
 383                         }
 384                 }
 385                 peasycap_format++;
 386         }
 387         if (-1 == best) {
 388                 SAY("cannot do %ix... with standard mask 0x%02X\n", \
 389                                                                 width, mask);
 390                 SAY("cannot do ...x%i with standard mask 0x%02X\n", \
 391                                                                 height, mask);
 392                 SAY("           %ix%i unmatched\n", width, height);
 393                 return peasycap->format_offset;
 394         }
 395 }
 396 if ((struct easycap_format *)NULL == peasycap_best_format) {
 397         SAY("MISTAKE: peasycap_best_format is NULL");
 398         return -EINVAL;
 399 }
 400 peasycap_format = peasycap_best_format;
 401
 402 /*...........................................................................*/
 403 if (true == try)
 404         return (int)(peasycap_best_format - &easycap_format[0]);
 405 /*...........................................................................*/
 406
 407 if (false != try) {
 408         SAY("MISTAKE: true==try where is should be false\n");
 409         return -EINVAL;
 410 }
 411 SAY("actioning: %ix%i %s\n", \
 412                         peasycap_format->v4l2_format.fmt.pix.width, \
 413                         peasycap_format->v4l2_format.fmt.pix.height,
 414                         &peasycap_format->name[0]);
 415 peasycap->height        = peasycap_format->v4l2_format.fmt.pix.height;
 416 peasycap->width         = peasycap_format->v4l2_format.fmt.pix.width;
 417 peasycap->pixelformat   = peasycap_format->v4l2_format.fmt.pix.pixelformat;
 418 peasycap->field         = peasycap_format->v4l2_format.fmt.pix.field;
 419 peasycap->format_offset = (int)(peasycap_format - &easycap_format[0]);
 420 peasycap->bytesperpixel = (0x00F0 & peasycap_format->mask) >> 4 ;
 421 if (0x0100 & peasycap_format->mask)
 422         peasycap->byteswaporder = true;
 423 else
 424         peasycap->byteswaporder = false;
 425 if (0x0800 & peasycap_format->mask)
 426         peasycap->decimatepixel = true;
 427 else
 428         peasycap->decimatepixel = false;
 429 if (0x1000 & peasycap_format->mask)
 430         peasycap->offerfields = true;
 431 else
 432         peasycap->offerfields = false;
 433 if (true == peasycap->decimatepixel)
 434         multiplier = 2;
 435 else
 436         multiplier = 1;
 437 peasycap->videofieldamount = multiplier * peasycap->width * \
 438                                         multiplier * peasycap->height;
 439 peasycap->frame_buffer_used = peasycap->bytesperpixel * \
 440                                         peasycap->width * peasycap->height;
 441
 442 if (true == peasycap->offerfields) {
 443         SAY("WARNING: %i=peasycap->field is untested: " \
 444                                 "please report problems\n", peasycap->field);
 445
 446
 447 /*
 448  *    FIXME ---- THIS IS UNTESTED, MAY BE (AND PROBABLY IS) INCORRECT:
 449  *
 450  *    peasycap->frame_buffer_used = peasycap->frame_buffer_used / 2;
 451  *
 452  *    SO DO NOT RISK IT YET.
 453  *
 454  */
 455
 456
 457
 458 }
 459
 460 kill_video_urbs(peasycap);
 461
 462 /*---------------------------------------------------------------------------*/
 463 /*
 464  *  PAL
 465  */
 466 /*---------------------------------------------------------------------------*/
 467 if (0 == (0x01 & peasycap_format->mask)) {
 468         if (((720 == peasycap_format->v4l2_format.fmt.pix.width) && \
 469                         (576 == \
 470                         peasycap_format->v4l2_format.fmt.pix.height)) || \
 471                         ((360 == \
 472                         peasycap_format->v4l2_format.fmt.pix.width) && \
 473                         (288 == \
 474                         peasycap_format->v4l2_format.fmt.pix.height))) {
 475                 if (0 != set_resolution(p, 0x0000, 0x0001, 0x05A0, 0x0121)) {
 476                         SAY("ERROR: set_resolution() failed\n");
 477                         return -EINVAL;
 478                 }
 479         } else if ((704 == peasycap_format->v4l2_format.fmt.pix.width) && \
 480                         (576 == peasycap_format->v4l2_format.fmt.pix.height)) {
 481                 if (0 != set_resolution(p, 0x0004, 0x0001, 0x0584, 0x0121)) {
 482                         SAY("ERROR: set_resolution() failed\n");
 483                         return -EINVAL;
 484                 }
 485         } else if (((640 == peasycap_format->v4l2_format.fmt.pix.width) && \
 486                         (480 == \
 487                         peasycap_format->v4l2_format.fmt.pix.height)) || \
 488                         ((320 == \
 489                         peasycap_format->v4l2_format.fmt.pix.width) && \
 490                         (240 == \
 491                         peasycap_format->v4l2_format.fmt.pix.height))) {
 492                 if (0 != set_resolution(p, 0x0014, 0x0020, 0x0514, 0x0110)) {
 493                         SAY("ERROR: set_resolution() failed\n");
 494                         return -EINVAL;
 495                 }
 496         } else {
 497                 SAY("MISTAKE: bad format, cannot set resolution\n");
 498                 return -EINVAL;
 499         }
 500 /*---------------------------------------------------------------------------*/
 501 /*
 502  *  NTSC
 503  */
 504 /*---------------------------------------------------------------------------*/
 505 } else {
 506         if (((720 == peasycap_format->v4l2_format.fmt.pix.width) && \
 507                         (480 == \
 508                         peasycap_format->v4l2_format.fmt.pix.height)) || \
 509                         ((360 == \
 510                         peasycap_format->v4l2_format.fmt.pix.width) && \
 511                         (240 == \
 512                         peasycap_format->v4l2_format.fmt.pix.height))) {
 513                 if (0 != set_resolution(p, 0x0000, 0x0003, 0x05A0, 0x00F3)) {
 514                         SAY("ERROR: set_resolution() failed\n");
 515                         return -EINVAL;
 516                 }
 517         } else if (((640 == peasycap_format->v4l2_format.fmt.pix.width) && \
 518                         (480 == \
 519                         peasycap_format->v4l2_format.fmt.pix.height)) || \
 520                         ((320 == \
 521                         peasycap_format->v4l2_format.fmt.pix.width) && \
 522                         (240 == \
 523                         peasycap_format->v4l2_format.fmt.pix.height))) {
 524                 if (0 != set_resolution(p, 0x0014, 0x0003, 0x0514, 0x00F3)) {
 525                         SAY("ERROR: set_resolution() failed\n");
 526                         return -EINVAL;
 527                 }
 528         } else {
 529                 SAY("MISTAKE: bad format, cannot set resolution\n");
 530                 return -EINVAL;
 531         }
 532 }
 533 /*---------------------------------------------------------------------------*/
 534
 535 check_stk(peasycap->pusb_device);
 536
 537 return (int)(peasycap_best_format - &easycap_format[0]);
 538 }
 539 /*****************************************************************************/
 540 int adjust_brightness(struct easycap *peasycap, int value)
 541 {
 542 unsigned int mood;
 543 int i1;
 544
 545 if ((struct usb_device *)NULL == peasycap->pusb_device) {
 546         SAY("ERROR: peasycap->pusb_device is NULL\n");
 547         return -EFAULT;
 548 }
 549 i1 = 0;
 550 while (0xFFFFFFFF != easycap_control[i1].id) {
 551         if (V4L2_CID_BRIGHTNESS == easycap_control[i1].id) {
 552                 if ((easycap_control[i1].minimum > value) || \
 553                                         (easycap_control[i1].maximum < value))
 554                         value = easycap_control[i1].default_value;
 555                 peasycap->brightness = value;
 556                 mood = 0x00FF & (unsigned int)peasycap->brightness;
 557
 558                 set2to78(peasycap->pusb_device);
 559
 560                 if (!write_saa(peasycap->pusb_device, 0x0A, mood)) {
 561                         SAY("adjusting brightness to  0x%02X\n", mood);
 562                         return 0;
 563                 } else {
 564                         SAY("WARNING: failed to adjust brightness " \
 565                                                         "to 0x%02X\n", mood);
 566                         return -ENOENT;
 567                 }
 568
 569                 set2to78(peasycap->pusb_device);
 570
 571                 break;
 572         }
 573         i1++;
 574 }
 575 SAY("WARNING: failed to adjust brightness: control not found\n");
 576 return -ENOENT;
 577 }
 578 /*****************************************************************************/
 579 int adjust_contrast(struct easycap *peasycap, int value)
 580 {
 581 unsigned int mood;
 582 int i1;
 583
 584 if ((struct usb_device *)NULL == peasycap->pusb_device) {
 585         SAY("ERROR: peasycap->pusb_device is NULL\n");
 586         return -EFAULT;
 587 }
 588 i1 = 0;
 589 while (0xFFFFFFFF != easycap_control[i1].id) {
 590         if (V4L2_CID_CONTRAST == easycap_control[i1].id) {
 591                 if ((easycap_control[i1].minimum > value) || \
 592                                         (easycap_control[i1].maximum < value))
 593                         value = easycap_control[i1].default_value;
 594                 peasycap->contrast = value;
 595                 mood = 0x00FF & (unsigned int) (peasycap->contrast - 128);
 596
 597                 set2to78(peasycap->pusb_device);
 598
 599                 if (!write_saa(peasycap->pusb_device, 0x0B, mood)) {
 600                         SAY("adjusting contrast to  0x%02X\n", mood);
 601                         return 0;
 602                 } else {
 603                         SAY("WARNING: failed to adjust contrast to " \
 604                                                         "0x%02X\n", mood);
 605                         return -ENOENT;
 606                 }
 607
 608                 set2to78(peasycap->pusb_device);
 609
 610                 break;
 611         }
 612         i1++;
 613 }
 614 SAY("WARNING: failed to adjust contrast: control not found\n");
 615 return -ENOENT;
 616 }
 617 /*****************************************************************************/
 618 int adjust_saturation(struct easycap *peasycap, int value)
 619 {
 620 unsigned int mood;
 621 int i1;
 622
 623 if ((struct usb_device *)NULL == peasycap->pusb_device) {
 624         SAY("ERROR: peasycap->pusb_device is NULL\n");
 625         return -EFAULT;
 626 }
 627 i1 = 0;
 628 while (0xFFFFFFFF != easycap_control[i1].id) {
 629         if (V4L2_CID_SATURATION == easycap_control[i1].id) {
 630                 if ((easycap_control[i1].minimum > value) || \
 631                                         (easycap_control[i1].maximum < value))
 632                         value = easycap_control[i1].default_value;
 633                 peasycap->saturation = value;
 634                 mood = 0x00FF & (unsigned int) (peasycap->saturation - 128);
 635
 636                 set2to78(peasycap->pusb_device);
 637
 638                 if (!write_saa(peasycap->pusb_device, 0x0C, mood)) {
 639                         SAY("adjusting saturation to  0x%02X\n", mood);
 640                         return 0;
 641                 } else {
 642                         SAY("WARNING: failed to adjust saturation to " \
 643                                                         "0x%02X\n", mood);
 644                         return -ENOENT;
 645                 }
 646                 break;
 647
 648                 set2to78(peasycap->pusb_device);
 649
 650         }
 651         i1++;
 652 }
 653 SAY("WARNING: failed to adjust saturation: control not found\n");
 654 return -ENOENT;
 655 }
 656 /*****************************************************************************/
 657 int adjust_hue(struct easycap *peasycap, int value)
 658 {
 659 unsigned int mood;
 660 int i1, i2;
 661
 662 if ((struct usb_device *)NULL == peasycap->pusb_device) {
 663         SAY("ERROR: peasycap->pusb_device is NULL\n");
 664         return -EFAULT;
 665 }
 666 i1 = 0;
 667 while (0xFFFFFFFF != easycap_control[i1].id) {
 668         if (V4L2_CID_HUE == easycap_control[i1].id) {
 669                 if ((easycap_control[i1].minimum > value) || \
 670                                         (easycap_control[i1].maximum < value))
 671                         value = easycap_control[i1].default_value;
 672                 peasycap->hue = value;
 673                 i2 = peasycap->hue - 128;
 674                 mood = 0x00FF & ((int) i2);
 675
 676                 set2to78(peasycap->pusb_device);
 677
 678                 if (!write_saa(peasycap->pusb_device, 0x0D, mood)) {
 679                         SAY("adjusting hue to  0x%02X\n", mood);
 680                         return 0;
 681                 } else {
 682                         SAY("WARNING: failed to adjust hue to 0x%02X\n", mood);
 683                         return -ENOENT;
 684                 }
 685
 686                 set2to78(peasycap->pusb_device);
 687
 688                 break;
 689         }
 690         i1++;
 691 }
 692 SAY("WARNING: failed to adjust hue: control not found\n");
 693 return -ENOENT;
 694 }
 695 /*****************************************************************************/
 696 int adjust_volume(struct easycap *peasycap, int value)
 697 {
 698 __s8 mood;
 699 int i1;
 700
 701 if ((struct usb_device *)NULL == peasycap->pusb_device) {
 702         SAY("ERROR: peasycap->pusb_device is NULL\n");
 703         return -EFAULT;
 704 }
 705 i1 = 0;
 706 while (0xFFFFFFFF != easycap_control[i1].id) {
 707         if (V4L2_CID_AUDIO_VOLUME == easycap_control[i1].id) {
 708                 if ((easycap_control[i1].minimum > value) || \
 709                         (easycap_control[i1].maximum < value))
 710                         value = easycap_control[i1].default_value;
 711                 peasycap->volume = value;
 712                 mood = (16 > peasycap->volume) ? 16 : \
 713                         ((31 < peasycap->volume) ? 31 : \
 714                         (__s8) peasycap->volume);
 715                 if (!audio_gainset(peasycap->pusb_device, mood)) {
 716                         SAY("adjusting volume to 0x%01X\n", mood);
 717                         return 0;
 718                 } else {
 719                         SAY("WARNING: failed to adjust volume to " \
 720                                                         "0x%1X\n", mood);
 721                         return -ENOENT;
 722                 }
 723                 break;
 724         }
 725 i1++;
 726 }
 727 SAY("WARNING: failed to adjust volume: control not found\n");
 728 return -ENOENT;
 729 }
 730 /*****************************************************************************/
 731 /*---------------------------------------------------------------------------*/
 732 /*
 733  *  AN ALTERNATIVE METHOD OF MUTING MIGHT SEEM TO BE:
 734  *            usb_set_interface(peasycap->pusb_device, \
 735  *                              peasycap->audio_interface, \
 736  *                              peasycap->audio_altsetting_off);
 737  *  HOWEVER, AFTER THIS COMMAND IS ISSUED ALL SUBSEQUENT URBS RECEIVE STATUS
 738  *  -ESHUTDOWN.  THE HANDLER ROUTINE easysnd_complete() DECLINES TO RESUBMIT
 739  *  THE URB AND THE PIPELINE COLLAPSES IRRETRIEVABLY.  BEWARE.
 740  */
 741 /*---------------------------------------------------------------------------*/
 742 int adjust_mute(struct easycap *peasycap, int value)
 743 {
 744 int i1;
 745
 746 if ((struct usb_device *)NULL == peasycap->pusb_device) {
 747         SAY("ERROR: peasycap->pusb_device is NULL\n");
 748         return -EFAULT;
 749 }
 750 i1 = 0;
 751 while (0xFFFFFFFF != easycap_control[i1].id) {
 752         if (V4L2_CID_AUDIO_MUTE == easycap_control[i1].id) {
 753                 peasycap->mute = value;
 754                 switch (peasycap->mute) {
 755                 case 1: {
 756                         peasycap->audio_idle = 1;
 757                         peasycap->timeval0.tv_sec = 0;
 758                         SAY("adjusting mute: %i=peasycap->audio_idle\n", \
 759                                                         peasycap->audio_idle);
 760                         return 0;
 761                 }
 762                 default: {
 763                         peasycap->audio_idle = 0;
 764                         SAY("adjusting mute: %i=peasycap->audio_idle\n", \
 765                                                         peasycap->audio_idle);
 766                         return 0;
 767                 }
 768                 }
 769                 break;
 770         }
 771         i1++;
 772 }
 773 SAY("WARNING: failed to adjust mute: control not found\n");
 774 return -ENOENT;
 775 }
 776 /****************************************************************************/
 777 /*vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 778 #if defined(EASYCAP_IS_VIDEODEV_CLIENT)
 779 long
 780 easycap_ioctl_noinode(struct file *file, unsigned int cmd, unsigned long arg)\
 781                                                                         {
 782         return easycap_ioctl((struct inode *)NULL, file, cmd, arg);
 783 }
 784 #endif /*EASYCAP_IS_VIDEODEV_CLIENT*/
 785 /*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
 786 /*--------------------------------------------------------------------------*/
 787 int easycap_ioctl(struct inode *inode, struct file *file, \
 788                                         unsigned int cmd, unsigned long arg)
 789 {
 790 static struct easycap *peasycap;
 791 static struct usb_device *p;
 792 static __u32 isequence;
 793
 794 peasycap = (struct easycap *)file->private_data;
 795 if (NULL == peasycap) {
 796         SAY("ERROR:  peasycap is NULL\n");
 797         return -1;
 798 }
 799 p = peasycap->pusb_device;
 800 if ((struct usb_device *)NULL == p) {
 801         SAY("ERROR: peasycap->pusb_device is NULL\n");
 802         return -EFAULT;
 803 }
 804 /*---------------------------------------------------------------------------*/
 805 /*
 806  *  MOST OF THE VARIABLES DECLARED static IN THE case{} BLOCKS BELOW ARE SO
 807  *  DECLARED SIMPLY TO AVOID A COMPILER WARNING OF THE KIND:
 808  *  easycap_ioctl.c: warning:
 809  *                       the frame size of ... bytes is larger than 1024 bytes
 810  */
 811 /*---------------------------------------------------------------------------*/
 812 switch (cmd) {
 813 case VIDIOC_QUERYCAP: {
 814         static struct v4l2_capability v4l2_capability;
 815         static char version[16], *p1, *p2;
 816         static int i, rc, k[3];
 817         static long lng;
 818
 819         JOT(8, "VIDIOC_QUERYCAP\n");
 820
 821         if (16 <= strlen(EASYCAP_DRIVER_VERSION)) {
 822                 SAY("ERROR: bad driver version string\n"); return -EINVAL;
 823         }
 824         strcpy(&version[0], EASYCAP_DRIVER_VERSION);
 825         for (i = 0; i < 3; i++)
 826                 k[i] = 0;
 827         p2 = &version[0];  i = 0;
 828         while (*p2) {
 829                 p1 = p2;
 830                 while (*p2 && ('.' != *p2))
 831                         p2++;
 832                 if (*p2)
 833                         *p2++ = 0;
 834                 if (3 > i) {
 835                         rc = (int) strict_strtol(p1, 10, &lng);
 836                         if (0 != rc) {
 837                                 SAY("ERROR: %i=strict_strtol(%s,.,,)\n", \
 838                                                                 rc, p1);
 839                                 return -EINVAL;
 840                         }
 841                         k[i] = (int)lng;
 842                 }
 843                 i++;
 844         }
 845
 846         memset(&v4l2_capability, 0, sizeof(struct v4l2_capability));
 847         strlcpy(&v4l2_capability.driver[0], "easycap", \
 848                                         sizeof(v4l2_capability.driver));
 849
 850         v4l2_capability.capabilities = \
 851                                 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING | \
 852                                 V4L2_CAP_AUDIO         | V4L2_CAP_READWRITE;
 853
 854         v4l2_capability.version = KERNEL_VERSION(k[0], k[1], k[2]);
 855         JOT(8, "v4l2_capability.version=(%i,%i,%i)\n", k[0], k[1], k[2]);
 856
 857         strlcpy(&v4l2_capability.card[0], "EasyCAP DC60", \
 858                 sizeof(v4l2_capability.card));
 859
 860         if (usb_make_path(peasycap->pusb_device, &v4l2_capability.bus_info[0],\
 861                                 sizeof(v4l2_capability.bus_info)) < 0) {
 862                 strlcpy(&v4l2_capability.bus_info[0], "EasyCAP bus_info", \
 863                                         sizeof(v4l2_capability.bus_info));
 864                 JOT(8, "%s=v4l2_capability.bus_info\n", \
 865                                         &v4l2_capability.bus_info[0]);
 866         }
 867         if (0 != copy_to_user((void __user *)arg, &v4l2_capability, \
 868                                         sizeof(struct v4l2_capability))) {
 869                 POUT;
 870                 return -EFAULT;
 871         }
 872         break;
 873 }
 874 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 875 case VIDIOC_ENUMINPUT: {
 876         static struct v4l2_input v4l2_input;
 877         static __u32 index;
 878
 879         JOT(8, "VIDIOC_ENUMINPUT\n");
 880
 881         if (0 != copy_from_user(&v4l2_input, (void __user *)arg, \
 882                                         sizeof(struct v4l2_input))) {
 883                 POUT;
 884                 return -EFAULT;
 885         }
 886
 887         index = v4l2_input.index;
 888         memset(&v4l2_input, 0, sizeof(struct v4l2_input));
 889
 890         switch (index) {
 891         case 0: {
 892                 v4l2_input.index = index;
 893                 strcpy(&v4l2_input.name[0], "CVBS0");
 894                 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
 895                 v4l2_input.audioset = 0x01;
 896                 v4l2_input.tuner = 0;
 897                 v4l2_input.std = V4L2_STD_PAL | V4L2_STD_SECAM | \
 898                                 V4L2_STD_NTSC ;
 899                 v4l2_input.status = 0;
 900                 JOT(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
 901                 break;
 902         }
 903         case 1: {
 904                 v4l2_input.index = index;
 905                 strcpy(&v4l2_input.name[0], "CVBS1");
 906                 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
 907                 v4l2_input.audioset = 0x01;
 908                 v4l2_input.tuner = 0;
 909                 v4l2_input.std = V4L2_STD_PAL | V4L2_STD_SECAM | \
 910                                 V4L2_STD_NTSC ;
 911                 v4l2_input.status = 0;
 912                 JOT(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
 913                 break;
 914         }
 915         case 2: {
 916                 v4l2_input.index = index;
 917                 strcpy(&v4l2_input.name[0], "CVBS2");
 918                 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
 919                 v4l2_input.audioset = 0x01;
 920                 v4l2_input.tuner = 0;
 921                 v4l2_input.std = V4L2_STD_PAL | V4L2_STD_SECAM | \
 922                                 V4L2_STD_NTSC ;
 923                 v4l2_input.status = 0;
 924                 JOT(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
 925                 break;
 926         }
 927         case 3: {
 928                 v4l2_input.index = index;
 929                 strcpy(&v4l2_input.name[0], "CVBS3");
 930                 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
 931                 v4l2_input.audioset = 0x01;
 932                 v4l2_input.tuner = 0;
 933                 v4l2_input.std = V4L2_STD_PAL | V4L2_STD_SECAM | \
 934                                 V4L2_STD_NTSC ;
 935                 v4l2_input.status = 0;
 936                 JOT(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
 937                 break;
 938         }
 939         case 4: {
 940                 v4l2_input.index = index;
 941                 strcpy(&v4l2_input.name[0], "CVBS4");
 942                 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
 943                 v4l2_input.audioset = 0x01;
 944                 v4l2_input.tuner = 0;
 945                 v4l2_input.std = V4L2_STD_PAL | V4L2_STD_SECAM | \
 946                                 V4L2_STD_NTSC ;
 947                 v4l2_input.status = 0;
 948                 JOT(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
 949                 break;
 950         }
 951         case 5: {
 952                 v4l2_input.index = index;
 953                 strcpy(&v4l2_input.name[0], "S-VIDEO");
 954                 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
 955                 v4l2_input.audioset = 0x01;
 956                 v4l2_input.tuner = 0;
 957                 v4l2_input.std = V4L2_STD_PAL | V4L2_STD_SECAM | \
 958                                 V4L2_STD_NTSC ;
 959                 v4l2_input.status = 0;
 960                 JOT(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
 961                 break;
 962         }
 963         default: {
 964                 JOT(8, "%i=index: exhausts inputs\n", index);
 965                 return -EINVAL;
 966         }
 967         }
 968
 969         if (0 != copy_to_user((void __user *)arg, &v4l2_input, \
 970                                                 sizeof(struct v4l2_input))) {
 971                 POUT;
 972                 return -EFAULT;
 973         }
 974         break;
 975 }
 976 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 977 case VIDIOC_G_INPUT: {
 978         static __u32 index;
 979
 980         JOT(8, "VIDIOC_G_INPUT\n");
 981         index = (__u32)peasycap->input;
 982         JOT(8, "user is told: %i\n", index);
 983         if (0 != copy_to_user((void __user *)arg, &index, sizeof(__u32))) {
 984                 POUT;
 985                 return -EFAULT;
 986         }
 987         break;
 988 }
 989 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 990 case VIDIOC_S_INPUT:
 991         {
 992         static __u32 index;
 993
 994         JOT(8, "VIDIOC_S_INPUT\n");
 995
 996         if (0 != copy_from_user(&index, (void __user *)arg, sizeof(__u32))) {
 997                 POUT;
 998                 return -EFAULT;
 999         }
1000
1001         JOT(8, "user requests input %i\n", index);
1002
1003         if ((int)index == peasycap->input) {
1004                 SAY("requested input already in effect\n");
1005                 break;
1006         }
1007
1008         if ((0 > index) || (5 < index)) {
1009                 JOT(8, "ERROR:  bad requested input: %i\n", index);
1010                 return -EINVAL;
1011         }
1012         peasycap->input = (int)index;
1013
1014         select_input(peasycap->pusb_device, peasycap->input, 9);
1015
1016         break;
1017 }
1018 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1019 case VIDIOC_ENUMAUDIO: {
1020         JOT(8, "VIDIOC_ENUMAUDIO\n");
1021         return -EINVAL;
1022 }
1023 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1024 case VIDIOC_ENUMAUDOUT: {
1025         static struct v4l2_audioout v4l2_audioout;
1026
1027         JOT(8, "VIDIOC_ENUMAUDOUT\n");
1028
1029         if (0 != copy_from_user(&v4l2_audioout, (void __user *)arg, \
1030                                         sizeof(struct v4l2_audioout))) {
1031                 POUT;
1032                 return -EFAULT;
1033         }
1034
1035         if (0 != v4l2_audioout.index)
1036                 return -EINVAL;
1037         memset(&v4l2_audioout, 0, sizeof(struct v4l2_audioout));
1038         v4l2_audioout.index = 0;
1039         strcpy(&v4l2_audioout.name[0], "Soundtrack");
1040
1041         if (0 != copy_to_user((void __user *)arg, &v4l2_audioout, \
1042                                         sizeof(struct v4l2_audioout))) {
1043                 POUT;
1044                 return -EFAULT;
1045         }
1046         break;
1047 }
1048 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1049 case VIDIOC_QUERYCTRL: {
1050         static int i1;
1051         static struct v4l2_queryctrl v4l2_queryctrl;
1052
1053         JOT(8, "VIDIOC_QUERYCTRL\n");
1054
1055         if (0 != copy_from_user(&v4l2_queryctrl, (void __user *)arg, \
1056                                         sizeof(struct v4l2_queryctrl))) {
1057                 POUT;
1058                 return -EFAULT;
1059         }
1060
1061         i1 = 0;
1062         while (0xFFFFFFFF != easycap_control[i1].id) {
1063                 if (easycap_control[i1].id == v4l2_queryctrl.id) {
1064                         JOT(8, "VIDIOC_QUERYCTRL  %s=easycap_control[%i]" \
1065                                 ".name\n", &easycap_control[i1].name[0], i1);
1066                         memcpy(&v4l2_queryctrl, &easycap_control[i1], \
1067                                                 sizeof(struct v4l2_queryctrl));
1068                         break;
1069                 }
1070                 i1++;
1071         }
1072         if (0xFFFFFFFF == easycap_control[i1].id) {
1073                 JOT(8, "%i=index: exhausts controls\n", i1);
1074                 return -EINVAL;
1075         }
1076         if (0 != copy_to_user((void __user *)arg, &v4l2_queryctrl, \
1077                                         sizeof(struct v4l2_queryctrl))) {
1078                 POUT;
1079                 return -EFAULT;
1080         }
1081         break;
1082 }
1083 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1084 case VIDIOC_QUERYMENU: {
1085         JOT(8, "VIDIOC_QUERYMENU unsupported\n");
1086         return -EINVAL;
1087         break;
1088 }
1089 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1090 case VIDIOC_G_CTRL: {
1091         static struct v4l2_control v4l2_control;
1092
1093         JOT(8, "VIDIOC_G_CTRL\n");
1094
1095         if (0 != copy_from_user(&v4l2_control, (void __user *)arg, \
1096                                         sizeof(struct v4l2_control))) {
1097                 POUT;
1098                 return -EFAULT;
1099         }
1100
1101         switch (v4l2_control.id) {
1102         case V4L2_CID_BRIGHTNESS: {
1103                 v4l2_control.value = peasycap->brightness;
1104                 JOT(8, "user enquires brightness: %i\n", v4l2_control.value);
1105                 break;
1106         }
1107         case V4L2_CID_CONTRAST: {
1108                 v4l2_control.value = peasycap->contrast;
1109                 JOT(8, "user enquires contrast: %i\n", v4l2_control.value);
1110                 break;
1111         }
1112         case V4L2_CID_SATURATION: {
1113                 v4l2_control.value = peasycap->saturation;
1114                 JOT(8, "user enquires saturation: %i\n", v4l2_control.value);
1115                 break;
1116         }
1117         case V4L2_CID_HUE: {
1118                 v4l2_control.value = peasycap->hue;
1119                 JOT(8, "user enquires hue: %i\n", v4l2_control.value);
1120                 break;
1121         }
1122         case V4L2_CID_AUDIO_VOLUME: {
1123                 v4l2_control.value = peasycap->volume;
1124                 JOT(8, "user enquires volume: %i\n", v4l2_control.value);
1125                 break;
1126         }
1127         case V4L2_CID_AUDIO_MUTE: {
1128                 if (1 == peasycap->mute)
1129                         v4l2_control.value = true;
1130                 else
1131                         v4l2_control.value = false;
1132                 JOT(8, "user enquires mute: %i\n", v4l2_control.value);
1133                 break;
1134         }
1135         default: {
1136                 SAY("ERROR: unknown V4L2 control: 0x%08X=id\n", \
1137                                                         v4l2_control.id);
1138                 explain_cid(v4l2_control.id);
1139                 return -EINVAL;
1140         }
1141         }
1142         if (0 != copy_to_user((void __user *)arg, &v4l2_control, \
1143                                         sizeof(struct v4l2_control))) {
1144                 POUT;
1145                 return -EFAULT;
1146         }
1147         break;
1148 }
1149 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1150 #if defined(VIDIOC_S_CTRL_OLD)
1151 case VIDIOC_S_CTRL_OLD: {
1152         JOT(8, "VIDIOC_S_CTRL_OLD required at least for xawtv\n");
1153 }
1154 #endif /*VIDIOC_S_CTRL_OLD*/
1155 case VIDIOC_S_CTRL:
1156         {
1157         static struct v4l2_control v4l2_control;
1158
1159         JOT(8, "VIDIOC_S_CTRL\n");
1160
1161         if (0 != copy_from_user(&v4l2_control, (void __user *)arg, \
1162                                         sizeof(struct v4l2_control))) {
1163                 POUT;
1164                 return -EFAULT;
1165         }
1166
1167         switch (v4l2_control.id) {
1168         case V4L2_CID_BRIGHTNESS: {
1169                 JOT(8, "user requests brightness %i\n", v4l2_control.value);
1170                 if (0 != adjust_brightness(peasycap, v4l2_control.value))
1171                         ;
1172                 break;
1173         }
1174         case V4L2_CID_CONTRAST: {
1175                 JOT(8, "user requests contrast %i\n", v4l2_control.value);
1176                 if (0 != adjust_contrast(peasycap, v4l2_control.value))
1177                         ;
1178                 break;
1179         }
1180         case V4L2_CID_SATURATION: {
1181                 JOT(8, "user requests saturation %i\n", v4l2_control.value);
1182                 if (0 != adjust_saturation(peasycap, v4l2_control.value))
1183                         ;
1184                 break;
1185         }
1186         case V4L2_CID_HUE: {
1187                 JOT(8, "user requests hue %i\n", v4l2_control.value);
1188                 if (0 != adjust_hue(peasycap, v4l2_control.value))
1189                         ;
1190                 break;
1191         }
1192         case V4L2_CID_AUDIO_VOLUME: {
1193                 JOT(8, "user requests volume %i\n", v4l2_control.value);
1194                 if (0 != adjust_volume(peasycap, v4l2_control.value))
1195                         ;
1196                 break;
1197         }
1198         case V4L2_CID_AUDIO_MUTE: {
1199                 int mute;
1200
1201                 JOT(8, "user requests mute %i\n", v4l2_control.value);
1202                 if (true == v4l2_control.value)
1203                         mute = 1;
1204                 else
1205                         mute = 0;
1206
1207                 if (0 != adjust_mute(peasycap, mute))
1208                         SAY("WARNING: failed to adjust mute to %i\n", mute);
1209                 break;
1210         }
1211         default: {
1212                 SAY("ERROR: unknown V4L2 control: 0x%08X=id\n", \
1213                                                         v4l2_control.id);
1214                 explain_cid(v4l2_control.id);
1215         return -EINVAL;
1216                         }
1217                 }
1218         break;
1219 }
1220 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1221 case VIDIOC_S_EXT_CTRLS: {
1222         JOT(8, "VIDIOC_S_EXT_CTRLS unsupported\n");
1223         return -EINVAL;
1224 }
1225 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1226 case VIDIOC_ENUM_FMT: {
1227         static __u32 index;
1228         static struct v4l2_fmtdesc v4l2_fmtdesc;
1229
1230         JOT(8, "VIDIOC_ENUM_FMT\n");
1231
1232         if (0 != copy_from_user(&v4l2_fmtdesc, (void __user *)arg, \
1233                                         sizeof(struct v4l2_fmtdesc))) {
1234                 POUT;
1235                 return -EFAULT;
1236         }
1237
1238         index = v4l2_fmtdesc.index;
1239         memset(&v4l2_fmtdesc, 0, sizeof(struct v4l2_fmtdesc));
1240
1241         v4l2_fmtdesc.index = index;
1242         v4l2_fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1243
1244         switch (index) {
1245         case 0: {
1246                 v4l2_fmtdesc.flags = 0;
1247                 strcpy(&v4l2_fmtdesc.description[0], "uyvy");
1248                 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_UYVY;
1249                 JOT(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1250                 break;
1251         }
1252         case 1: {
1253                 v4l2_fmtdesc.flags = 0;
1254                 strcpy(&v4l2_fmtdesc.description[0], "yuy2");
1255                 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_YUYV;
1256                 JOT(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1257                 break;
1258         }
1259         case 2: {
1260                 v4l2_fmtdesc.flags = 0;
1261                 strcpy(&v4l2_fmtdesc.description[0], "rgb24");
1262                 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_RGB24;
1263                 JOT(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1264                 break;
1265         }
1266         case 3: {
1267                 v4l2_fmtdesc.flags = 0;
1268                 strcpy(&v4l2_fmtdesc.description[0], "rgb32");
1269                 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_RGB32;
1270                 JOT(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1271                 break;
1272         }
1273         case 4: {
1274                 v4l2_fmtdesc.flags = 0;
1275                 strcpy(&v4l2_fmtdesc.description[0], "bgr24");
1276                 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_BGR24;
1277                 JOT(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1278                 break;
1279         }
1280         case 5: {
1281                 v4l2_fmtdesc.flags = 0;
1282                 strcpy(&v4l2_fmtdesc.description[0], "bgr32");
1283                 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_BGR32;
1284                 JOT(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1285                 break;
1286         }
1287         default: {
1288                 JOT(8, "%i=index: exhausts formats\n", index);
1289                 return -EINVAL;
1290         }
1291         }
1292         if (0 != copy_to_user((void __user *)arg, &v4l2_fmtdesc, \
1293                                         sizeof(struct v4l2_fmtdesc))) {
1294                 POUT;
1295                 return -EFAULT;
1296         }
1297         break;
1298 }
1299 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1300 case VIDIOC_ENUM_FRAMESIZES: {
1301         JOT(8, "VIDIOC_ENUM_FRAMESIZES unsupported\n");
1302         return -EINVAL;
1303 }
1304 case VIDIOC_ENUM_FRAMEINTERVALS: {
1305         JOT(8, "VIDIOC_ENUM_FRAME_INTERVALS unsupported\n");
1306         return -EINVAL;
1307 }
1308 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1309 case VIDIOC_G_FMT: {
1310         static struct v4l2_format v4l2_format;
1311         static struct v4l2_pix_format v4l2_pix_format;
1312
1313         JOT(8, "VIDIOC_G_FMT\n");
1314
1315         if (0 != copy_from_user(&v4l2_format, (void __user *)arg, \
1316                                         sizeof(struct v4l2_format))) {
1317                 POUT;
1318                 return -EFAULT;
1319         }
1320
1321         if (v4l2_format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1322                 POUT;
1323                 return -EINVAL;
1324         }
1325
1326         memset(&v4l2_pix_format, 0, sizeof(struct v4l2_pix_format));
1327         v4l2_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1328         memcpy(&(v4l2_format.fmt.pix), \
1329                          &(easycap_format[peasycap->format_offset]\
1330                         .v4l2_format.fmt.pix), sizeof(v4l2_pix_format));
1331         JOT(8, "user is told: %s\n", \
1332                         &easycap_format[peasycap->format_offset].name[0]);
1333
1334         if (0 != copy_to_user((void __user *)arg, &v4l2_format, \
1335                                         sizeof(struct v4l2_format))) {
1336                 POUT;
1337                 return -EFAULT;
1338         }
1339         break;
1340 }
1341 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1342 case VIDIOC_TRY_FMT:
1343 case VIDIOC_S_FMT: {
1344         static struct v4l2_format v4l2_format;
1345         static struct v4l2_pix_format v4l2_pix_format;
1346         static bool try;
1347         static int best_format;
1348
1349         if (VIDIOC_TRY_FMT == cmd) {
1350                 JOT(8, "VIDIOC_TRY_FMT\n");
1351                 try = true;
1352         } else {
1353                 JOT(8, "VIDIOC_S_FMT\n");
1354                 try = false;
1355         }
1356
1357         if (0 != copy_from_user(&v4l2_format, (void __user *)arg, \
1358                                         sizeof(struct v4l2_format))) {
1359                 POUT;
1360                 return -EFAULT;
1361         }
1362
1363         best_format = adjust_format(peasycap, \
1364                                         v4l2_format.fmt.pix.width, \
1365                                         v4l2_format.fmt.pix.height, \
1366                                         v4l2_format.fmt.pix.pixelformat, \
1367                                         v4l2_format.fmt.pix.field, \
1368                                         try);
1369         if (0 > best_format) {
1370                 JOT(8, "WARNING: adjust_format() returned %i\n", best_format);
1371                 return -ENOENT;
1372         }
1373 /*...........................................................................*/
1374         memset(&v4l2_pix_format, 0, sizeof(struct v4l2_pix_format));
1375         v4l2_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1376
1377         memcpy(&(v4l2_format.fmt.pix), &(easycap_format[best_format]\
1378                         .v4l2_format.fmt.pix), sizeof(v4l2_pix_format));
1379         JOT(8, "user is told: %s\n", &easycap_format[best_format].name[0]);
1380
1381         if (0 != copy_to_user((void __user *)arg, &v4l2_format, \
1382                                         sizeof(struct v4l2_format))) {
1383                 POUT;
1384                 return -EFAULT;
1385         }
1386         break;
1387 }
1388 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1389 case VIDIOC_CROPCAP: {
1390         static struct v4l2_cropcap v4l2_cropcap;
1391
1392         JOT(8, "VIDIOC_CROPCAP\n");
1393
1394         if (0 != copy_from_user(&v4l2_cropcap, (void __user *)arg, \
1395                                         sizeof(struct v4l2_cropcap))) {
1396                 POUT;
1397                 return -EFAULT;
1398         }
1399
1400         if (v4l2_cropcap.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1401                 JOT(8, "v4l2_cropcap.type != V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
1402
1403         memset(&v4l2_cropcap, 0, sizeof(struct v4l2_cropcap));
1404         v4l2_cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1405         v4l2_cropcap.bounds.left      = 0;
1406         v4l2_cropcap.bounds.top       = 0;
1407         v4l2_cropcap.bounds.width     = peasycap->width;
1408         v4l2_cropcap.bounds.height    = peasycap->height;
1409         v4l2_cropcap.defrect.left     = 0;
1410         v4l2_cropcap.defrect.top      = 0;
1411         v4l2_cropcap.defrect.width    = peasycap->width;
1412         v4l2_cropcap.defrect.height   = peasycap->height;
1413         v4l2_cropcap.pixelaspect.numerator = 1;
1414         v4l2_cropcap.pixelaspect.denominator = 1;
1415
1416         JOT(8, "user is told: %ix%i\n", peasycap->width, peasycap->height);
1417
1418         if (0 != copy_to_user((void __user *)arg, &v4l2_cropcap, \
1419                                         sizeof(struct v4l2_cropcap))) {
1420                 POUT;
1421                 return -EFAULT;
1422         }
1423         break;
1424 }
1425 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1426 case VIDIOC_G_CROP:
1427 case VIDIOC_S_CROP: {
1428         JOT(8, "VIDIOC_G_CROP|VIDIOC_S_CROP  unsupported\n");
1429         return -EINVAL;
1430 }
1431 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1432 case VIDIOC_QUERYSTD: {
1433         JOT(8, "VIDIOC_QUERYSTD: " \
1434                         "EasyCAP is incapable of detecting standard\n");
1435         return -EINVAL;
1436         break;
1437 }
1438 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1439 /*---------------------------------------------------------------------------*/
1440 /*
1441  *  THE MANIPULATIONS INVOLVING last0,last1,last2,last3 CONSTITUTE A WORKAROUND
1442  *  FOR WHAT APPEARS TO BE A BUG IN 64-BIT mplayer.
1443  *  NOT NEEDED, BUT HOPEFULLY HARMLESS, FOR 32-BIT mplayer.
1444  */
1445 /*---------------------------------------------------------------------------*/
1446 case VIDIOC_ENUMSTD: {
1447         static int last0 = -1, last1 = -1, last2 = -1, last3 = -1;
1448         static struct v4l2_standard v4l2_standard;
1449         static __u32 index;
1450         static struct easycap_standard const *peasycap_standard;
1451
1452         JOT(8, "VIDIOC_ENUMSTD\n");
1453
1454         if (0 != copy_from_user(&v4l2_standard, (void __user *)arg, \
1455                                         sizeof(struct v4l2_standard))) {
1456                 POUT;
1457                 return -EFAULT;
1458         }
1459         index = v4l2_standard.index;
1460
1461         last3 = last2; last2 = last1; last1 = last0; last0 = index;
1462         if ((index == last3) && (index == last2) && \
1463                         (index == last1) && (index == last0)) {
1464                 index++;
1465                 last3 = last2; last2 = last1; last1 = last0; last0 = index;
1466         }
1467
1468         memset(&v4l2_standard, 0, sizeof(struct v4l2_standard));
1469
1470         peasycap_standard = &easycap_standard[0];
1471         while (0xFFFF != peasycap_standard->mask) {
1472                 if ((int)(peasycap_standard - &easycap_standard[0]) == index)
1473                         break;
1474                 peasycap_standard++;
1475         }
1476         if (0xFFFF == peasycap_standard->mask) {
1477                 JOT(8, "%i=index: exhausts standards\n", index);
1478                 return -EINVAL;
1479         }
1480         JOT(8, "%i=index: %s\n", index, \
1481                                 &(peasycap_standard->v4l2_standard.name[0]));
1482         memcpy(&v4l2_standard, &(peasycap_standard->v4l2_standard), \
1483                                         sizeof(struct v4l2_standard));
1484
1485         v4l2_standard.index = index;
1486
1487         if (0 != copy_to_user((void __user *)arg, &v4l2_standard, \
1488                                         sizeof(struct v4l2_standard))) {
1489                 POUT;
1490                 return -EFAULT;
1491         }
1492         break;
1493 }
1494 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1495 case VIDIOC_G_STD: {
1496         static v4l2_std_id std_id;
1497         static struct easycap_standard const *peasycap_standard;
1498
1499         JOT(8, "VIDIOC_G_STD\n");
1500
1501         if (0 != copy_from_user(&std_id, (void __user *)arg, \
1502                                                 sizeof(v4l2_std_id))) {
1503                 POUT;
1504                 return -EFAULT;
1505         }
1506
1507         peasycap_standard = &easycap_standard[peasycap->standard_offset];
1508         std_id = peasycap_standard->v4l2_standard.id;
1509
1510         JOT(8, "user is told: %s\n", \
1511                                 &peasycap_standard->v4l2_standard.name[0]);
1512
1513         if (0 != copy_to_user((void __user *)arg, &std_id, \
1514                                                 sizeof(v4l2_std_id))) {
1515                 POUT;
1516                 return -EFAULT;
1517         }
1518         break;
1519 }
1520 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1521 case VIDIOC_S_STD: {
1522         static v4l2_std_id std_id;
1523         static int rc;
1524
1525         JOT(8, "VIDIOC_S_STD\n");
1526
1527         if (0 != copy_from_user(&std_id, (void __user *)arg, \
1528                                                 sizeof(v4l2_std_id))) {
1529                 POUT;
1530                 return -EFAULT;
1531         }
1532
1533         rc = adjust_standard(peasycap, std_id);
1534         if (0 > rc) {
1535                 JOT(8, "WARNING: adjust_standard() returned %i\n", rc);
1536                 return -ENOENT;
1537         }
1538         break;
1539 }
1540 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1541 case VIDIOC_REQBUFS: {
1542         static int nbuffers;
1543         static struct v4l2_requestbuffers v4l2_requestbuffers;
1544
1545         JOT(8, "VIDIOC_REQBUFS\n");
1546
1547         if (0 != copy_from_user(&v4l2_requestbuffers, (void __user *)arg, \
1548                                 sizeof(struct v4l2_requestbuffers))) {
1549                 POUT;
1550                 return -EFAULT;
1551         }
1552
1553         if (v4l2_requestbuffers.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1554                 return -EINVAL;
1555         if (v4l2_requestbuffers.memory != V4L2_MEMORY_MMAP) {
1556                 POUT;
1557                 return -EINVAL;
1558         }
1559         nbuffers = v4l2_requestbuffers.count;
1560         JOT(8, "                   User requests %i buffers ...\n", nbuffers);
1561         if (nbuffers < 2)
1562                 nbuffers = 2;
1563         if (nbuffers > FRAME_BUFFER_MANY)
1564                 nbuffers = FRAME_BUFFER_MANY;
1565         if (v4l2_requestbuffers.count == nbuffers) {
1566                 JOT(8, "                   ... agree to  %i buffers\n", \
1567                                                                 nbuffers);
1568         } else {
1569                 JOT(8, "                  ... insist on  %i buffers\n", \
1570                                                                 nbuffers);
1571                 v4l2_requestbuffers.count = nbuffers;
1572         }
1573         peasycap->frame_buffer_many = nbuffers;
1574
1575         if (0 != copy_to_user((void __user *)arg, &v4l2_requestbuffers, \
1576                                 sizeof(struct v4l2_requestbuffers))) {
1577                 POUT;
1578                 return -EFAULT;
1579         }
1580         break;
1581 }
1582 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1583 case VIDIOC_QUERYBUF: {
1584         static __u32 index;
1585         static struct v4l2_buffer v4l2_buffer;
1586
1587         JOT(8, "VIDIOC_QUERYBUF\n");
1588
1589         if (peasycap->video_eof) {
1590                 JOT(8, "returning -1 because  %i=video_eof\n", \
1591                                                         peasycap->video_eof);
1592                 return -1;
1593         }
1594
1595         if (0 != copy_from_user(&v4l2_buffer, (void __user *)arg, \
1596                                         sizeof(struct v4l2_buffer))) {
1597                 POUT;
1598                 return -EFAULT;
1599         }
1600
1601         if (v4l2_buffer.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1602                 return -EINVAL;
1603         index = v4l2_buffer.index;
1604         if (index < 0 || index >= peasycap->frame_buffer_many)
1605                 return -EINVAL;
1606         memset(&v4l2_buffer, 0, sizeof(struct v4l2_buffer));
1607         v4l2_buffer.index = index;
1608         v4l2_buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1609         v4l2_buffer.bytesused = peasycap->frame_buffer_used;
1610         v4l2_buffer.flags = V4L2_BUF_FLAG_MAPPED | \
1611                                                 peasycap->done[index] | \
1612                                                 peasycap->queued[index];
1613         v4l2_buffer.field = peasycap->field;
1614         v4l2_buffer.memory = V4L2_MEMORY_MMAP;
1615         v4l2_buffer.m.offset = index * FRAME_BUFFER_SIZE;
1616         v4l2_buffer.length = FRAME_BUFFER_SIZE;
1617
1618         JOT(16, "  %10i=index\n", v4l2_buffer.index);
1619         JOT(16, "  0x%08X=type\n", v4l2_buffer.type);
1620         JOT(16, "  %10i=bytesused\n", v4l2_buffer.bytesused);
1621         JOT(16, "  0x%08X=flags\n", v4l2_buffer.flags);
1622         JOT(16, "  %10i=field\n", v4l2_buffer.field);
1623         JOT(16, "  %10li=timestamp.tv_usec\n", \
1624                                          (long)v4l2_buffer.timestamp.tv_usec);
1625         JOT(16, "  %10i=sequence\n", v4l2_buffer.sequence);
1626         JOT(16, "  0x%08X=memory\n", v4l2_buffer.memory);
1627         JOT(16, "  %10i=m.offset\n", v4l2_buffer.m.offset);
1628         JOT(16, "  %10i=length\n", v4l2_buffer.length);
1629
1630         if (0 != copy_to_user((void __user *)arg, &v4l2_buffer, \
1631                                         sizeof(struct v4l2_buffer))) {
1632                 POUT;
1633                 return -EFAULT;
1634         }
1635         break;
1636 }
1637 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1638 case VIDIOC_QBUF: {
1639         static struct v4l2_buffer v4l2_buffer;
1640
1641         JOT(8, "VIDIOC_QBUF\n");
1642
1643         if (0 != copy_from_user(&v4l2_buffer, (void __user *)arg, \
1644                                         sizeof(struct v4l2_buffer))) {
1645                 POUT;
1646                 return -EFAULT;
1647         }
1648
1649         if (v4l2_buffer.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1650                 return -EINVAL;
1651         if (v4l2_buffer.memory != V4L2_MEMORY_MMAP)
1652                 return -EINVAL;
1653         if (v4l2_buffer.index < 0 || \
1654                  (v4l2_buffer.index >= peasycap->frame_buffer_many))
1655                 return -EINVAL;
1656         v4l2_buffer.flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_QUEUED;
1657
1658         peasycap->done[v4l2_buffer.index]   = 0;
1659         peasycap->queued[v4l2_buffer.index] = V4L2_BUF_FLAG_QUEUED;
1660
1661         if (0 != copy_to_user((void __user *)arg, &v4l2_buffer, \
1662                                         sizeof(struct v4l2_buffer))) {
1663                 POUT;
1664                 return -EFAULT;
1665         }
1666
1667         JOT(8, ".....   user queueing frame buffer %i\n", \
1668                                                 (int)v4l2_buffer.index);
1669
1670         peasycap->frame_lock = 0;
1671
1672         break;
1673 }
1674 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1675 case VIDIOC_DQBUF:
1676         {
1677 #if defined(AUDIOTIME)
1678         static struct signed_div_result sdr;
1679         static long long int above, below, dnbydt, fudge, sll;
1680         static unsigned long long int ull;
1681         static struct timeval timeval0;
1682         struct timeval timeval1;
1683 #endif /*AUDIOTIME*/
1684         static struct timeval timeval, timeval2;
1685         static int i, j;
1686         static struct v4l2_buffer v4l2_buffer;
1687
1688         JOT(8, "VIDIOC_DQBUF\n");
1689
1690         if ((peasycap->video_idle) || (peasycap->video_eof)) {
1691                 JOT(8, "returning -EIO because  " \
1692                                 "%i=video_idle  %i=video_eof\n", \
1693                                 peasycap->video_idle, peasycap->video_eof);
1694                 return -EIO;
1695         }
1696
1697         if (0 != copy_from_user(&v4l2_buffer, (void __user *)arg, \
1698                                         sizeof(struct v4l2_buffer))) {
1699                 POUT;
1700                 return -EFAULT;
1701         }
1702
1703         if (v4l2_buffer.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1704                 return -EINVAL;
1705
1706         if (!peasycap->video_isoc_streaming) {
1707                 JOT(16, "returning -EIO because video urbs not streaming\n");
1708                 return -EIO;
1709         }
1710 /*---------------------------------------------------------------------------*/
1711 /*
1712  *  IF THE USER HAS PREVIOUSLY CALLED easycap_poll(), AS DETERMINED BY FINDING
1713  *  THE FLAG peasycap->polled SET, THERE MUST BE NO FURTHER WAIT HERE.  IN THIS
1714  *  CASE, JUST CHOOSE THE FRAME INDICATED BY peasycap->frame_read
1715  */
1716 /*---------------------------------------------------------------------------*/
1717
1718         if (!peasycap->polled) {
1719                 if (-EIO == easycap_dqbuf(peasycap, 0))
1720                         return -EIO;
1721         } else {
1722                 if (peasycap->video_eof)
1723                         return -EIO;
1724         }
1725         if (V4L2_BUF_FLAG_DONE != peasycap->done[peasycap->frame_read]) {
1726                 SAY("ERROR: V4L2_BUF_FLAG_DONE != 0x%08X\n", \
1727                                         peasycap->done[peasycap->frame_read]);
1728         }
1729         peasycap->polled = 0;
1730
1731         if (!(isequence % 10)) {
1732                 for (i = 0; i < 179; i++)
1733                         peasycap->merit[i] = peasycap->merit[i+1];
1734                 peasycap->merit[179] = merit_saa(peasycap->pusb_device);
1735                 j = 0;
1736                 for (i = 0; i < 180; i++)
1737                         j += peasycap->merit[i];
1738                 if (90 < j) {
1739                         SAY("easycap driver shutting down " \
1740                                                         "on condition blue\n");
1741                         peasycap->video_eof = 1; peasycap->audio_eof = 1;
1742                 }
1743         }
1744
1745         v4l2_buffer.index = peasycap->frame_read;
1746         v4l2_buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1747         v4l2_buffer.bytesused = peasycap->frame_buffer_used;
1748         v4l2_buffer.flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_DONE;
1749         v4l2_buffer.field =  peasycap->field;
1750         if (V4L2_FIELD_ALTERNATE == v4l2_buffer.field)
1751                 v4l2_buffer.field = \
1752                                 0x000F & (peasycap->\
1753                                 frame_buffer[peasycap->frame_read][0].kount);
1754         do_gettimeofday(&timeval);
1755         timeval2 = timeval;
1756
1757 #if defined(AUDIOTIME)
1758         if (!peasycap->timeval0.tv_sec) {
1759                 timeval0 = timeval;
1760                 timeval1 = timeval;
1761                 timeval2 = timeval;
1762                 dnbydt = 192000;
1763
1764                 if (mutex_lock_interruptible(&(peasycap->mutex_timeval0)))
1765                         return -ERESTARTSYS;
1766                 peasycap->timeval0 = timeval0;
1767                 mutex_unlock(&(peasycap->mutex_timeval0));
1768         } else {
1769                 if (mutex_lock_interruptible(&(peasycap->mutex_timeval1)))
1770                         return -ERESTARTSYS;
1771                 dnbydt = peasycap->dnbydt;
1772                 timeval1 = peasycap->timeval1;
1773                 mutex_unlock(&(peasycap->mutex_timeval1));
1774                 above = dnbydt * MICROSECONDS(timeval, timeval1);
1775                 below = 192000;
1776                 sdr = signed_div(above, below);
1777
1778                 above = sdr.quotient + timeval1.tv_usec - 350000;
1779
1780                 below = 1000000;
1781                 sdr = signed_div(above, below);
1782                 timeval2.tv_usec = sdr.remainder;
1783                 timeval2.tv_sec = timeval1.tv_sec + sdr.quotient;
1784         }
1785         if (!(isequence % 500)) {
1786                 fudge = ((long long int)(1000000)) * \
1787                                 ((long long int)(timeval.tv_sec - \
1788                                                 timeval2.tv_sec)) + \
1789                                 (long long int)(timeval.tv_usec - \
1790                                 timeval2.tv_usec);
1791                 sdr = signed_div(fudge, 1000);
1792                 sll = sdr.quotient;
1793                 ull = sdr.remainder;
1794
1795                 SAY("%5lli.%-3lli=ms timestamp fudge\n", sll, ull);
1796         }
1797 #endif /*AUDIOTIME*/
1798
1799         v4l2_buffer.timestamp = timeval2;
1800         v4l2_buffer.sequence = isequence++;
1801         v4l2_buffer.memory = V4L2_MEMORY_MMAP;
1802         v4l2_buffer.m.offset = v4l2_buffer.index * FRAME_BUFFER_SIZE;
1803         v4l2_buffer.length = FRAME_BUFFER_SIZE;
1804
1805         JOT(16, "  %10i=index\n", v4l2_buffer.index);
1806         JOT(16, "  0x%08X=type\n", v4l2_buffer.type);
1807         JOT(16, "  %10i=bytesused\n", v4l2_buffer.bytesused);
1808         JOT(16, "  0x%08X=flags\n", v4l2_buffer.flags);
1809         JOT(16, "  %10i=field\n", v4l2_buffer.field);
1810         JOT(16, "  %10li=timestamp.tv_usec\n", \
1811                                         (long)v4l2_buffer.timestamp.tv_usec);
1812         JOT(16, "  %10i=sequence\n", v4l2_buffer.sequence);
1813         JOT(16, "  0x%08X=memory\n", v4l2_buffer.memory);
1814         JOT(16, "  %10i=m.offset\n", v4l2_buffer.m.offset);
1815         JOT(16, "  %10i=length\n", v4l2_buffer.length);
1816
1817         if (0 != copy_to_user((void __user *)arg, &v4l2_buffer, \
1818                                                 sizeof(struct v4l2_buffer))) {
1819                 POUT;
1820                 return -EFAULT;
1821         }
1822
1823         JOT(8, "..... user is offered frame buffer %i\n", \
1824                                                         peasycap->frame_read);
1825         peasycap->frame_lock = 1;
1826         if (peasycap->frame_read == peasycap->frame_fill) {
1827                 if (peasycap->frame_lock) {
1828                         JOT(8, "ERROR:  filling frame buffer " \
1829                                                 "while offered to user\n");
1830                 }
1831         }
1832         break;
1833 }
1834 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1835 /*---------------------------------------------------------------------------*/
1836 /*
1837  *  AUDIO URBS HAVE ALREADY BEEN SUBMITTED WHEN THIS COMMAND IS RECEIVED;
1838  *  VIDEO URBS HAVE NOT.
1839  */
1840 /*---------------------------------------------------------------------------*/
1841 case VIDIOC_STREAMON: {
1842         static int i;
1843
1844         JOT(8, "VIDIOC_STREAMON\n");
1845
1846         isequence = 0;
1847         for (i = 0; i < 180; i++)
1848                 peasycap->merit[i] = 0;
1849         if ((struct usb_device *)NULL == peasycap->pusb_device) {
1850                 SAY("ERROR: peasycap->pusb_device is NULL\n");
1851                 return -EFAULT;
1852         }
1853         submit_video_urbs(peasycap);
1854         peasycap->video_idle = 0;
1855         peasycap->audio_idle = 0;
1856         peasycap->video_eof = 0;
1857         peasycap->audio_eof = 0;
1858         break;
1859 }
1860 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1861 case VIDIOC_STREAMOFF: {
1862         JOT(8, "VIDIOC_STREAMOFF\n");
1863
1864         if ((struct usb_device *)NULL == peasycap->pusb_device) {
1865                 SAY("ERROR: peasycap->pusb_device is NULL\n");
1866                 return -EFAULT;
1867         }
1868
1869         peasycap->video_idle = 1;
1870         peasycap->audio_idle = 1;  peasycap->timeval0.tv_sec = 0;
1871 /*---------------------------------------------------------------------------*/
1872 /*
1873  *  IF THE WAIT QUEUES ARE NOT CLEARED IN RESPONSE TO THE STREAMOFF COMMAND
1874  *  THE USERSPACE PROGRAM, E.G. mplayer, MAY HANG ON EXIT.   BEWARE.
1875  */
1876 /*---------------------------------------------------------------------------*/
1877         JOT(8, "calling wake_up on wq_video and wq_audio\n");
1878         wake_up_interruptible(&(peasycap->wq_video));
1879         wake_up_interruptible(&(peasycap->wq_audio));
1880 /*---------------------------------------------------------------------------*/
1881         break;
1882 }
1883 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1884 case VIDIOC_G_PARM: {
1885         static struct v4l2_streamparm v4l2_streamparm;
1886
1887         JOT(8, "VIDIOC_G_PARM\n");
1888
1889         if (0 != copy_from_user(&v4l2_streamparm, (void __user *)arg, \
1890                                         sizeof(struct v4l2_streamparm))) {
1891                 POUT;
1892                 return -EFAULT;
1893         }
1894
1895         if (v4l2_streamparm.type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1896                 POUT;
1897                 return -EINVAL;
1898         }
1899         v4l2_streamparm.parm.capture.capability = 0;
1900         v4l2_streamparm.parm.capture.capturemode = 0;
1901         v4l2_streamparm.parm.capture.timeperframe.numerator = 1;
1902         v4l2_streamparm.parm.capture.timeperframe.denominator = 30;
1903         v4l2_streamparm.parm.capture.readbuffers = peasycap->frame_buffer_many;
1904         v4l2_streamparm.parm.capture.extendedmode = 0;
1905         if (0 != copy_to_user((void __user *)arg, &v4l2_streamparm, \
1906                                         sizeof(struct v4l2_streamparm))) {
1907                 POUT;
1908                 return -EFAULT;
1909         }
1910         break;
1911 }
1912 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1913 case VIDIOC_S_PARM: {
1914         JOT(8, "VIDIOC_S_PARM unsupported\n");
1915         return -EINVAL;
1916 }
1917 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1918 case VIDIOC_G_AUDIO: {
1919         JOT(8, "VIDIOC_G_AUDIO unsupported\n");
1920         return -EINVAL;
1921 }
1922 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1923 case VIDIOC_S_AUDIO: {
1924         JOT(8, "VIDIOC_S_AUDIO unsupported\n");
1925         return -EINVAL;
1926 }
1927 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1928 case VIDIOC_S_TUNER: {
1929         JOT(8, "VIDIOC_S_TUNER unsupported\n");
1930         return -EINVAL;
1931 }
1932 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1933 case VIDIOC_G_FBUF:
1934 case VIDIOC_S_FBUF:
1935 case VIDIOC_OVERLAY: {
1936         JOT(8, "VIDIOC_G_FBUF|VIDIOC_S_FBUF|VIDIOC_OVERLAY unsupported\n");
1937         return -EINVAL;
1938 }
1939 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1940 case VIDIOC_G_TUNER: {
1941         JOT(8, "VIDIOC_G_TUNER unsupported\n");
1942         return -EINVAL;
1943 }
1944 case VIDIOC_G_FREQUENCY:
1945 case VIDIOC_S_FREQUENCY: {
1946         JOT(8, "VIDIOC_G_FREQUENCY|VIDIOC_S_FREQUENCY unsupported\n");
1947         return -EINVAL;
1948 }
1949 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1950 default: {
1951         JOT(8, "ERROR: unrecognized V4L2 IOCTL command: 0x%08X\n", cmd);
1952         explain_ioctl(cmd);
1953         POUT;
1954         return -ENOIOCTLCMD;
1955 }
1956 }
1957 return 0;
1958 }
1959 /****************************************************************************/
1960 /*vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
1961 #if defined(EASYCAP_IS_VIDEODEV_CLIENT)
1962 long
1963 easysnd_ioctl_noinode(struct file *file, unsigned int cmd, unsigned long arg)
1964 {
1965         return easysnd_ioctl((struct inode *)NULL, file, cmd, arg);
1966 }
1967 #endif /*EASYCAP_IS_VIDEODEV_CLIENT*/
1968 /*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
1969 /*--------------------------------------------------------------------------*/
1970 int easysnd_ioctl(struct inode *inode, struct file *file, \
1971                                         unsigned int cmd, unsigned long arg)
1972 {
1973 struct easycap *peasycap;
1974 struct usb_device *p;
1975
1976 peasycap = (struct easycap *)file->private_data;
1977 if (NULL == peasycap) {
1978         SAY("ERROR:  peasycap is NULL.\n");
1979         return -1;
1980 }
1981 p = peasycap->pusb_device;
1982 /*---------------------------------------------------------------------------*/
1983 switch (cmd) {
1984 case SNDCTL_DSP_GETCAPS: {
1985         int caps;
1986         JOT(8, "SNDCTL_DSP_GETCAPS\n");
1987
1988 #if defined(UPSAMPLE)
1989         if (true == peasycap->microphone)
1990                 caps = 0x04400000;
1991         else
1992                 caps = 0x04400000;
1993 #else
1994         if (true == peasycap->microphone)
1995                 caps = 0x02400000;
1996         else
1997                 caps = 0x04400000;
1998 #endif /*UPSAMPLE*/
1999
2000         if (0 != copy_to_user((void __user *)arg, &caps, sizeof(int)))
2001                 return -EFAULT;
2002         break;
2003 }
2004 case SNDCTL_DSP_GETFMTS: {
2005         int incoming;
2006         JOT(8, "SNDCTL_DSP_GETFMTS\n");
2007
2008 #if defined(UPSAMPLE)
2009         if (true == peasycap->microphone)
2010                 incoming = AFMT_S16_LE;
2011         else
2012                 incoming = AFMT_S16_LE;
2013 #else
2014         if (true == peasycap->microphone)
2015                 incoming = AFMT_S16_LE;
2016         else
2017                 incoming = AFMT_S16_LE;
2018 #endif /*UPSAMPLE*/
2019
2020         if (0 != copy_to_user((void __user *)arg, &incoming, sizeof(int)))
2021                 return -EFAULT;
2022         break;
2023 }
2024 case SNDCTL_DSP_SETFMT: {
2025         int incoming, outgoing;
2026         JOT(8, "SNDCTL_DSP_SETFMT\n");
2027         if (0 != copy_from_user(&incoming, (void __user *)arg, sizeof(int)))
2028                 return -EFAULT;
2029         JOT(8, "........... %i=incoming\n", incoming);
2030
2031 #if defined(UPSAMPLE)
2032         if (true == peasycap->microphone)
2033                 outgoing = AFMT_S16_LE;
2034         else
2035                 outgoing = AFMT_S16_LE;
2036 #else
2037         if (true == peasycap->microphone)
2038                 outgoing = AFMT_S16_LE;
2039         else
2040                 outgoing = AFMT_S16_LE;
2041 #endif /*UPSAMPLE*/
2042
2043         if (incoming != outgoing) {
2044                 JOT(8, "........... %i=outgoing\n", outgoing);
2045                 JOT(8, "        cf. %i=AFMT_S16_LE\n", AFMT_S16_LE);
2046                 JOT(8, "        cf. %i=AFMT_U8\n", AFMT_U8);
2047                 if (0 != copy_to_user((void __user *)arg, &outgoing, \
2048                                                                 sizeof(int)))
2049                         return -EFAULT;
2050                 return -EINVAL ;
2051         }
2052         break;
2053 }
2054 case SNDCTL_DSP_STEREO: {
2055         int incoming;
2056         JOT(8, "SNDCTL_DSP_STEREO\n");
2057         if (0 != copy_from_user(&incoming, (void __user *)arg, sizeof(int)))
2058                 return -EFAULT;
2059         JOT(8, "........... %i=incoming\n", incoming);
2060
2061 #if defined(UPSAMPLE)
2062         if (true == peasycap->microphone)
2063                 incoming = 1;
2064         else
2065                 incoming = 1;
2066 #else
2067         if (true == peasycap->microphone)
2068                 incoming = 0;
2069         else
2070                 incoming = 1;
2071 #endif /*UPSAMPLE*/
2072
2073         if (0 != copy_to_user((void __user *)arg, &incoming, sizeof(int)))
2074                 return -EFAULT;
2075         break;
2076 }
2077 case SNDCTL_DSP_SPEED: {
2078         int incoming;
2079         JOT(8, "SNDCTL_DSP_SPEED\n");
2080         if (0 != copy_from_user(&incoming, (void __user *)arg, sizeof(int)))
2081                 return -EFAULT;
2082         JOT(8, "........... %i=incoming\n", incoming);
2083
2084 #if defined(UPSAMPLE)
2085         if (true == peasycap->microphone)
2086                 incoming = 32000;
2087         else
2088                 incoming = 48000;
2089 #else
2090         if (true == peasycap->microphone)
2091                 incoming = 8000;
2092         else
2093                 incoming = 48000;
2094 #endif /*UPSAMPLE*/
2095
2096         if (0 != copy_to_user((void __user *)arg, &incoming, sizeof(int)))
2097                 return -EFAULT;
2098         break;
2099 }
2100 case SNDCTL_DSP_GETTRIGGER: {
2101         int incoming;
2102         JOT(8, "SNDCTL_DSP_GETTRIGGER\n");
2103         if (0 != copy_from_user(&incoming, (void __user *)arg, sizeof(int)))
2104                 return -EFAULT;
2105         JOT(8, "........... %i=incoming\n", incoming);
2106
2107         incoming = PCM_ENABLE_INPUT;
2108         if (0 != copy_to_user((void __user *)arg, &incoming, sizeof(int)))
2109                 return -EFAULT;
2110         break;
2111 }
2112 case SNDCTL_DSP_SETTRIGGER: {
2113         int incoming;
2114         JOT(8, "SNDCTL_DSP_SETTRIGGER\n");
2115         if (0 != copy_from_user(&incoming, (void __user *)arg, sizeof(int)))
2116                 return -EFAULT;
2117         JOT(8, "........... %i=incoming\n", incoming);
2118         JOT(8, "........... cf 0x%x=PCM_ENABLE_INPUT " \
2119                                 "0x%x=PCM_ENABLE_OUTPUT\n", \
2120                                         PCM_ENABLE_INPUT, PCM_ENABLE_OUTPUT);
2121         ;
2122         ;
2123         ;
2124         ;
2125         break;
2126 }
2127 case SNDCTL_DSP_GETBLKSIZE: {
2128         int incoming;
2129         JOT(8, "SNDCTL_DSP_GETBLKSIZE\n");
2130         if (0 != copy_from_user(&incoming, (void __user *)arg, sizeof(int)))
2131                 return -EFAULT;
2132         JOT(8, "........... %i=incoming\n", incoming);
2133         incoming = peasycap->audio_bytes_per_fragment;
2134         if (0 != copy_to_user((void __user *)arg, &incoming, sizeof(int)))
2135                 return -EFAULT;
2136         break;
2137 }
2138 case SNDCTL_DSP_GETISPACE: {
2139         struct audio_buf_info audio_buf_info;
2140
2141         JOT(8, "SNDCTL_DSP_GETISPACE\n");
2142
2143         audio_buf_info.bytes      = peasycap->audio_bytes_per_fragment;
2144         audio_buf_info.fragments  = 1;
2145         audio_buf_info.fragsize   = 0;
2146         audio_buf_info.fragstotal = 0;
2147
2148         if (0 != copy_to_user((void __user *)arg, &audio_buf_info, \
2149                                                                 sizeof(int)))
2150                 return -EFAULT;
2151         break;
2152 }
2153 default: {
2154         JOT(8, "ERROR: unrecognized DSP IOCTL command: 0x%08X\n", cmd);
2155         POUT;
2156         return -ENOIOCTLCMD;
2157 }
2158 }
2159 return 0;
2160 }
2161 /*****************************************************************************/
2162 int explain_ioctl(__u32 wot)
2163 {
2164 int k;
2165 /*---------------------------------------------------------------------------*/
2166 /*
2167  *  THE DATA FOR THE ARRAY mess BELOW WERE CONSTRUCTED BY RUNNING THE FOLLOWING
2168  *  SHELL SCRIPT:
2169  *  #
2170  *  cat /usr/src/linux-headers-`uname -r`/include/linux/videodev2.h | \
2171  *     grep "^#define VIDIOC_" - | grep -v "_OLD" - | \
2172  *     sed -e "s,_IO.*$,,;p" | sed -e "N;s,\n,, " | \
2173  *     sed -e "s/^#define /  {/;s/#define /, \"/;s/$/\"},/" | \
2174  *     sed -e "s,       ,,g;s, ,,g" >ioctl.tmp
2175  *  echo "{0xFFFFFFFF,\"\"}" >>ioctl.tmp
2176  *  exit 0
2177  *  #
2178  * AND REINSTATING THE EXCISED "_OLD" CASES WERE LATER MANUALLY.
2179  *
2180  * THE DATA FOR THE ARRAY mess1 BELOW WERE CONSTRUCTED BY RUNNING THE FOLLOWING
2181  * SHELL SCRIPT:
2182  *  cat /usr/src/linux-headers-`uname -r`/include/linux/videodev.h | \
2183  *     grep "^#define VIDIOC" - | grep -v "_OLD" - | \
2184  *     sed -e "s,_IO.*$,,;p" | sed -e "N;s,\n,, " | \
2185  *     sed -e "s/^#define /  {/;s/#define /, \"/;s/$/\"},/" | \
2186  *     sed -e "s,   ,,g;s, ,,g" >ioctl.tmp
2187  *  echo "{0xFFFFFFFF,\"\"}" >>ioctl.tmp
2188  *  exit 0
2189  *  #
2190  */
2191 /*---------------------------------------------------------------------------*/
2192 static struct mess {
2193         __u32 command;
2194         char  name[64];
2195 } mess[] = {
2196 #if defined(VIDIOC_QUERYCAP)
2197 {VIDIOC_QUERYCAP, "VIDIOC_QUERYCAP"},
2198 #endif
2199 #if defined(VIDIOC_RESERVED)
2200 {VIDIOC_RESERVED, "VIDIOC_RESERVED"},
2201 #endif
2202 #if defined(VIDIOC_ENUM_FMT)
2203 {VIDIOC_ENUM_FMT, "VIDIOC_ENUM_FMT"},
2204 #endif
2205 #if defined(VIDIOC_G_FMT)
2206 {VIDIOC_G_FMT, "VIDIOC_G_FMT"},
2207 #endif
2208 #if defined(VIDIOC_S_FMT)
2209 {VIDIOC_S_FMT, "VIDIOC_S_FMT"},
2210 #endif
2211 #if defined(VIDIOC_REQBUFS)
2212 {VIDIOC_REQBUFS, "VIDIOC_REQBUFS"},
2213 #endif
2214 #if defined(VIDIOC_QUERYBUF)
2215 {VIDIOC_QUERYBUF, "VIDIOC_QUERYBUF"},
2216 #endif
2217 #if defined(VIDIOC_G_FBUF)
2218 {VIDIOC_G_FBUF, "VIDIOC_G_FBUF"},
2219 #endif
2220 #if defined(VIDIOC_S_FBUF)
2221 {VIDIOC_S_FBUF, "VIDIOC_S_FBUF"},
2222 #endif
2223 #if defined(VIDIOC_OVERLAY)
2224 {VIDIOC_OVERLAY, "VIDIOC_OVERLAY"},
2225 #endif
2226 #if defined(VIDIOC_QBUF)
2227 {VIDIOC_QBUF, "VIDIOC_QBUF"},
2228 #endif
2229 #if defined(VIDIOC_DQBUF)
2230 {VIDIOC_DQBUF, "VIDIOC_DQBUF"},
2231 #endif
2232 #if defined(VIDIOC_STREAMON)
2233 {VIDIOC_STREAMON, "VIDIOC_STREAMON"},
2234 #endif
2235 #if defined(VIDIOC_STREAMOFF)
2236 {VIDIOC_STREAMOFF, "VIDIOC_STREAMOFF"},
2237 #endif
2238 #if defined(VIDIOC_G_PARM)
2239 {VIDIOC_G_PARM, "VIDIOC_G_PARM"},
2240 #endif
2241 #if defined(VIDIOC_S_PARM)
2242 {VIDIOC_S_PARM, "VIDIOC_S_PARM"},
2243 #endif
2244 #if defined(VIDIOC_G_STD)
2245 {VIDIOC_G_STD, "VIDIOC_G_STD"},
2246 #endif
2247 #if defined(VIDIOC_S_STD)
2248 {VIDIOC_S_STD, "VIDIOC_S_STD"},
2249 #endif
2250 #if defined(VIDIOC_ENUMSTD)
2251 {VIDIOC_ENUMSTD, "VIDIOC_ENUMSTD"},
2252 #endif
2253 #if defined(VIDIOC_ENUMINPUT)
2254 {VIDIOC_ENUMINPUT, "VIDIOC_ENUMINPUT"},
2255 #endif
2256 #if defined(VIDIOC_G_CTRL)
2257 {VIDIOC_G_CTRL, "VIDIOC_G_CTRL"},
2258 #endif
2259 #if defined(VIDIOC_S_CTRL)
2260 {VIDIOC_S_CTRL, "VIDIOC_S_CTRL"},
2261 #endif
2262 #if defined(VIDIOC_G_TUNER)
2263 {VIDIOC_G_TUNER, "VIDIOC_G_TUNER"},
2264 #endif
2265 #if defined(VIDIOC_S_TUNER)
2266 {VIDIOC_S_TUNER, "VIDIOC_S_TUNER"},
2267 #endif
2268 #if defined(VIDIOC_G_AUDIO)
2269 {VIDIOC_G_AUDIO, "VIDIOC_G_AUDIO"},
2270 #endif
2271 #if defined(VIDIOC_S_AUDIO)
2272 {VIDIOC_S_AUDIO, "VIDIOC_S_AUDIO"},
2273 #endif
2274 #if defined(VIDIOC_QUERYCTRL)
2275 {VIDIOC_QUERYCTRL, "VIDIOC_QUERYCTRL"},
2276 #endif
2277 #if defined(VIDIOC_QUERYMENU)
2278 {VIDIOC_QUERYMENU, "VIDIOC_QUERYMENU"},
2279 #endif
2280 #if defined(VIDIOC_G_INPUT)
2281 {VIDIOC_G_INPUT, "VIDIOC_G_INPUT"},
2282 #endif
2283 #if defined(VIDIOC_S_INPUT)
2284 {VIDIOC_S_INPUT, "VIDIOC_S_INPUT"},
2285 #endif
2286 #if defined(VIDIOC_G_OUTPUT)
2287 {VIDIOC_G_OUTPUT, "VIDIOC_G_OUTPUT"},
2288 #endif
2289 #if defined(VIDIOC_S_OUTPUT)
2290 {VIDIOC_S_OUTPUT, "VIDIOC_S_OUTPUT"},
2291 #endif
2292 #if defined(VIDIOC_ENUMOUTPUT)
2293 {VIDIOC_ENUMOUTPUT, "VIDIOC_ENUMOUTPUT"},
2294 #endif
2295 #if defined(VIDIOC_G_AUDOUT)
2296 {VIDIOC_G_AUDOUT, "VIDIOC_G_AUDOUT"},
2297 #endif
2298 #if defined(VIDIOC_S_AUDOUT)
2299 {VIDIOC_S_AUDOUT, "VIDIOC_S_AUDOUT"},
2300 #endif
2301 #if defined(VIDIOC_G_MODULATOR)
2302 {VIDIOC_G_MODULATOR, "VIDIOC_G_MODULATOR"},
2303 #endif
2304 #if defined(VIDIOC_S_MODULATOR)
2305 {VIDIOC_S_MODULATOR, "VIDIOC_S_MODULATOR"},
2306 #endif
2307 #if defined(VIDIOC_G_FREQUENCY)
2308 {VIDIOC_G_FREQUENCY, "VIDIOC_G_FREQUENCY"},
2309 #endif
2310 #if defined(VIDIOC_S_FREQUENCY)
2311 {VIDIOC_S_FREQUENCY, "VIDIOC_S_FREQUENCY"},
2312 #endif
2313 #if defined(VIDIOC_CROPCAP)
2314 {VIDIOC_CROPCAP, "VIDIOC_CROPCAP"},
2315 #endif
2316 #if defined(VIDIOC_G_CROP)
2317 {VIDIOC_G_CROP, "VIDIOC_G_CROP"},
2318 #endif
2319 #if defined(VIDIOC_S_CROP)
2320 {VIDIOC_S_CROP, "VIDIOC_S_CROP"},
2321 #endif
2322 #if defined(VIDIOC_G_JPEGCOMP)
2323 {VIDIOC_G_JPEGCOMP, "VIDIOC_G_JPEGCOMP"},
2324 #endif
2325 #if defined(VIDIOC_S_JPEGCOMP)
2326 {VIDIOC_S_JPEGCOMP, "VIDIOC_S_JPEGCOMP"},
2327 #endif
2328 #if defined(VIDIOC_QUERYSTD)
2329 {VIDIOC_QUERYSTD, "VIDIOC_QUERYSTD"},
2330 #endif
2331 #if defined(VIDIOC_TRY_FMT)
2332 {VIDIOC_TRY_FMT, "VIDIOC_TRY_FMT"},
2333 #endif
2334 #if defined(VIDIOC_ENUMAUDIO)
2335 {VIDIOC_ENUMAUDIO, "VIDIOC_ENUMAUDIO"},
2336 #endif
2337 #if defined(VIDIOC_ENUMAUDOUT)
2338 {VIDIOC_ENUMAUDOUT, "VIDIOC_ENUMAUDOUT"},
2339 #endif
2340 #if defined(VIDIOC_G_PRIORITY)
2341 {VIDIOC_G_PRIORITY, "VIDIOC_G_PRIORITY"},
2342 #endif
2343 #if defined(VIDIOC_S_PRIORITY)
2344 {VIDIOC_S_PRIORITY, "VIDIOC_S_PRIORITY"},
2345 #endif
2346 #if defined(VIDIOC_G_SLICED_VBI_CAP)
2347 {VIDIOC_G_SLICED_VBI_CAP, "VIDIOC_G_SLICED_VBI_CAP"},
2348 #endif
2349 #if defined(VIDIOC_LOG_STATUS)
2350 {VIDIOC_LOG_STATUS, "VIDIOC_LOG_STATUS"},
2351 #endif
2352 #if defined(VIDIOC_G_EXT_CTRLS)
2353 {VIDIOC_G_EXT_CTRLS, "VIDIOC_G_EXT_CTRLS"},
2354 #endif
2355 #if defined(VIDIOC_S_EXT_CTRLS)
2356 {VIDIOC_S_EXT_CTRLS, "VIDIOC_S_EXT_CTRLS"},
2357 #endif
2358 #if defined(VIDIOC_TRY_EXT_CTRLS)
2359 {VIDIOC_TRY_EXT_CTRLS, "VIDIOC_TRY_EXT_CTRLS"},
2360 #endif
2361 #if defined(VIDIOC_ENUM_FRAMESIZES)
2362 {VIDIOC_ENUM_FRAMESIZES, "VIDIOC_ENUM_FRAMESIZES"},
2363 #endif
2364 #if defined(VIDIOC_ENUM_FRAMEINTERVALS)
2365 {VIDIOC_ENUM_FRAMEINTERVALS, "VIDIOC_ENUM_FRAMEINTERVALS"},
2366 #endif
2367 #if defined(VIDIOC_G_ENC_INDEX)
2368 {VIDIOC_G_ENC_INDEX, "VIDIOC_G_ENC_INDEX"},
2369 #endif
2370 #if defined(VIDIOC_ENCODER_CMD)
2371 {VIDIOC_ENCODER_CMD, "VIDIOC_ENCODER_CMD"},
2372 #endif
2373 #if defined(VIDIOC_TRY_ENCODER_CMD)
2374 {VIDIOC_TRY_ENCODER_CMD, "VIDIOC_TRY_ENCODER_CMD"},
2375 #endif
2376 #if defined(VIDIOC_G_CHIP_IDENT)
2377 {VIDIOC_G_CHIP_IDENT, "VIDIOC_G_CHIP_IDENT"},
2378 #endif
2379
2380 #if defined(VIDIOC_OVERLAY_OLD)
2381 {VIDIOC_OVERLAY_OLD, "VIDIOC_OVERLAY_OLD"},
2382 #endif
2383 #if defined(VIDIOC_S_PARM_OLD)
2384 {VIDIOC_S_PARM_OLD, "VIDIOC_S_PARM_OLD"},
2385 #endif
2386 #if defined(VIDIOC_S_CTRL_OLD)
2387 {VIDIOC_S_CTRL_OLD, "VIDIOC_S_CTRL_OLD"},
2388 #endif
2389 #if defined(VIDIOC_G_AUDIO_OLD)
2390 {VIDIOC_G_AUDIO_OLD, "VIDIOC_G_AUDIO_OLD"},
2391 #endif
2392 #if defined(VIDIOC_G_AUDOUT_OLD)
2393 {VIDIOC_G_AUDOUT_OLD, "VIDIOC_G_AUDOUT_OLD"},
2394 #endif
2395 #if defined(VIDIOC_CROPCAP_OLD)
2396 {VIDIOC_CROPCAP_OLD, "VIDIOC_CROPCAP_OLD"},
2397 #endif
2398 {0xFFFFFFFF, ""}
2399 };
2400
2401 static struct mess mess1[] = \
2402 {
2403 #if defined(VIDIOCGCAP)
2404 {VIDIOCGCAP, "VIDIOCGCAP"},
2405 #endif
2406 #if defined(VIDIOCGCHAN)
2407 {VIDIOCGCHAN, "VIDIOCGCHAN"},
2408 #endif
2409 #if defined(VIDIOCSCHAN)
2410 {VIDIOCSCHAN, "VIDIOCSCHAN"},
2411 #endif
2412 #if defined(VIDIOCGTUNER)
2413 {VIDIOCGTUNER, "VIDIOCGTUNER"},
2414 #endif
2415 #if defined(VIDIOCSTUNER)
2416 {VIDIOCSTUNER, "VIDIOCSTUNER"},
2417 #endif
2418 #if defined(VIDIOCGPICT)
2419 {VIDIOCGPICT, "VIDIOCGPICT"},
2420 #endif
2421 #if defined(VIDIOCSPICT)
2422 {VIDIOCSPICT, "VIDIOCSPICT"},
2423 #endif
2424 #if defined(VIDIOCCAPTURE)
2425 {VIDIOCCAPTURE, "VIDIOCCAPTURE"},
2426 #endif
2427 #if defined(VIDIOCGWIN)
2428 {VIDIOCGWIN, "VIDIOCGWIN"},
2429 #endif
2430 #if defined(VIDIOCSWIN)
2431 {VIDIOCSWIN, "VIDIOCSWIN"},
2432 #endif
2433 #if defined(VIDIOCGFBUF)
2434 {VIDIOCGFBUF, "VIDIOCGFBUF"},
2435 #endif
2436 #if defined(VIDIOCSFBUF)
2437 {VIDIOCSFBUF, "VIDIOCSFBUF"},
2438 #endif
2439 #if defined(VIDIOCKEY)
2440 {VIDIOCKEY, "VIDIOCKEY"},
2441 #endif
2442 #if defined(VIDIOCGFREQ)
2443 {VIDIOCGFREQ, "VIDIOCGFREQ"},
2444 #endif
2445 #if defined(VIDIOCSFREQ)
2446 {VIDIOCSFREQ, "VIDIOCSFREQ"},
2447 #endif
2448 #if defined(VIDIOCGAUDIO)
2449 {VIDIOCGAUDIO, "VIDIOCGAUDIO"},
2450 #endif
2451 #if defined(VIDIOCSAUDIO)
2452 {VIDIOCSAUDIO, "VIDIOCSAUDIO"},
2453 #endif
2454 #if defined(VIDIOCSYNC)
2455 {VIDIOCSYNC, "VIDIOCSYNC"},
2456 #endif
2457 #if defined(VIDIOCMCAPTURE)
2458 {VIDIOCMCAPTURE, "VIDIOCMCAPTURE"},
2459 #endif
2460 #if defined(VIDIOCGMBUF)
2461 {VIDIOCGMBUF, "VIDIOCGMBUF"},
2462 #endif
2463 #if defined(VIDIOCGUNIT)
2464 {VIDIOCGUNIT, "VIDIOCGUNIT"},
2465 #endif
2466 #if defined(VIDIOCGCAPTURE)
2467 {VIDIOCGCAPTURE, "VIDIOCGCAPTURE"},
2468 #endif
2469 #if defined(VIDIOCSCAPTURE)
2470 {VIDIOCSCAPTURE, "VIDIOCSCAPTURE"},
2471 #endif
2472 #if defined(VIDIOCSPLAYMODE)
2473 {VIDIOCSPLAYMODE, "VIDIOCSPLAYMODE"},
2474 #endif
2475 #if defined(VIDIOCSWRITEMODE)
2476 {VIDIOCSWRITEMODE, "VIDIOCSWRITEMODE"},
2477 #endif
2478 #if defined(VIDIOCGPLAYINFO)
2479 {VIDIOCGPLAYINFO, "VIDIOCGPLAYINFO"},
2480 #endif
2481 #if defined(VIDIOCSMICROCODE)
2482 {VIDIOCSMICROCODE, "VIDIOCSMICROCODE"},
2483 #endif
2484 {0xFFFFFFFF, ""}
2485 };
2486
2487 k = 0;
2488 while (mess[k].name[0]) {
2489         if (wot == mess[k].command) {
2490                 JOT(8, "ioctl 0x%08X is %s\n", \
2491                                         mess[k].command, &mess[k].name[0]);
2492                 return 0;
2493         }
2494         k++;
2495 }
2496 JOT(8, "ioctl 0x%08X is not in videodev2.h\n", wot);
2497
2498 k = 0;
2499 while (mess1[k].name[0]) {
2500         if (wot == mess1[k].command) {
2501                 JOT(8, "ioctl 0x%08X is %s (V4L1)\n", \
2502                                         mess1[k].command, &mess1[k].name[0]);
2503                 return 0;
2504         }
2505         k++;
2506 }
2507 JOT(8, "ioctl 0x%08X is not in videodev.h\n", wot);
2508 return -1;
2509 }
2510 /*****************************************************************************/
2511 int explain_cid(__u32 wot)
2512 {
2513 int k;
2514 /*---------------------------------------------------------------------------*/
2515 /*
2516  *  THE DATA FOR THE ARRAY mess BELOW WERE CONSTRUCTED BY RUNNING THE FOLLOWING
2517  *  SHELL SCRIPT:
2518  *  #
2519  *  cat /usr/src/linux-headers-`uname -r`/include/linux/videodev2.h | \
2520  *     grep "^#define V4L2_CID_" |  \
2521  *     sed -e "s,(.*$,,;p" | sed -e "N;s,\n,, " | \
2522  *     sed -e "s/^#define /  {/;s/#define /, \"/;s/$/\"},/" | \
2523  *     sed -e "s,       ,,g;s, ,,g" | grep -v "_BASE" | grep -v "MPEG" >cid.tmp
2524  *  echo "{0xFFFFFFFF,\"\"}" >>cid.tmp
2525  *  exit 0
2526  *  #
2527  */
2528 /*---------------------------------------------------------------------------*/
2529 static struct mess
2530 {
2531 __u32 command;
2532 char  name[64];
2533 } mess[] = {
2534 #if defined(V4L2_CID_USER_CLASS)
2535 {V4L2_CID_USER_CLASS, "V4L2_CID_USER_CLASS"},
2536 #endif
2537 #if defined(V4L2_CID_BRIGHTNESS)
2538 {V4L2_CID_BRIGHTNESS, "V4L2_CID_BRIGHTNESS"},
2539 #endif
2540 #if defined(V4L2_CID_CONTRAST)
2541 {V4L2_CID_CONTRAST, "V4L2_CID_CONTRAST"},
2542 #endif
2543 #if defined(V4L2_CID_SATURATION)
2544 {V4L2_CID_SATURATION, "V4L2_CID_SATURATION"},
2545 #endif
2546 #if defined(V4L2_CID_HUE)
2547 {V4L2_CID_HUE, "V4L2_CID_HUE"},
2548 #endif
2549 #if defined(V4L2_CID_AUDIO_VOLUME)
2550 {V4L2_CID_AUDIO_VOLUME, "V4L2_CID_AUDIO_VOLUME"},
2551 #endif
2552 #if defined(V4L2_CID_AUDIO_BALANCE)
2553 {V4L2_CID_AUDIO_BALANCE, "V4L2_CID_AUDIO_BALANCE"},
2554 #endif
2555 #if defined(V4L2_CID_AUDIO_BASS)
2556 {V4L2_CID_AUDIO_BASS, "V4L2_CID_AUDIO_BASS"},
2557 #endif
2558 #if defined(V4L2_CID_AUDIO_TREBLE)
2559 {V4L2_CID_AUDIO_TREBLE, "V4L2_CID_AUDIO_TREBLE"},
2560 #endif
2561 #if defined(V4L2_CID_AUDIO_MUTE)
2562 {V4L2_CID_AUDIO_MUTE, "V4L2_CID_AUDIO_MUTE"},
2563 #endif
2564 #if defined(V4L2_CID_AUDIO_LOUDNESS)
2565 {V4L2_CID_AUDIO_LOUDNESS, "V4L2_CID_AUDIO_LOUDNESS"},
2566 #endif
2567 #if defined(V4L2_CID_BLACK_LEVEL)
2568 {V4L2_CID_BLACK_LEVEL, "V4L2_CID_BLACK_LEVEL"},
2569 #endif
2570 #if defined(V4L2_CID_AUTO_WHITE_BALANCE)
2571 {V4L2_CID_AUTO_WHITE_BALANCE, "V4L2_CID_AUTO_WHITE_BALANCE"},
2572 #endif
2573 #if defined(V4L2_CID_DO_WHITE_BALANCE)
2574 {V4L2_CID_DO_WHITE_BALANCE, "V4L2_CID_DO_WHITE_BALANCE"},
2575 #endif
2576 #if defined(V4L2_CID_RED_BALANCE)
2577 {V4L2_CID_RED_BALANCE, "V4L2_CID_RED_BALANCE"},
2578 #endif
2579 #if defined(V4L2_CID_BLUE_BALANCE)
2580 {V4L2_CID_BLUE_BALANCE, "V4L2_CID_BLUE_BALANCE"},
2581 #endif
2582 #if defined(V4L2_CID_GAMMA)
2583 {V4L2_CID_GAMMA, "V4L2_CID_GAMMA"},
2584 #endif
2585 #if defined(V4L2_CID_WHITENESS)
2586 {V4L2_CID_WHITENESS, "V4L2_CID_WHITENESS"},
2587 #endif
2588 #if defined(V4L2_CID_EXPOSURE)
2589 {V4L2_CID_EXPOSURE, "V4L2_CID_EXPOSURE"},
2590 #endif
2591 #if defined(V4L2_CID_AUTOGAIN)
2592 {V4L2_CID_AUTOGAIN, "V4L2_CID_AUTOGAIN"},
2593 #endif
2594 #if defined(V4L2_CID_GAIN)
2595 {V4L2_CID_GAIN, "V4L2_CID_GAIN"},
2596 #endif
2597 #if defined(V4L2_CID_HFLIP)
2598 {V4L2_CID_HFLIP, "V4L2_CID_HFLIP"},
2599 #endif
2600 #if defined(V4L2_CID_VFLIP)
2601 {V4L2_CID_VFLIP, "V4L2_CID_VFLIP"},
2602 #endif
2603 #if defined(V4L2_CID_HCENTER)
2604 {V4L2_CID_HCENTER, "V4L2_CID_HCENTER"},
2605 #endif
2606 #if defined(V4L2_CID_VCENTER)
2607 {V4L2_CID_VCENTER, "V4L2_CID_VCENTER"},
2608 #endif
2609 #if defined(V4L2_CID_POWER_LINE_FREQUENCY)
2610 {V4L2_CID_POWER_LINE_FREQUENCY, "V4L2_CID_POWER_LINE_FREQUENCY"},
2611 #endif
2612 #if defined(V4L2_CID_HUE_AUTO)
2613 {V4L2_CID_HUE_AUTO, "V4L2_CID_HUE_AUTO"},
2614 #endif
2615 #if defined(V4L2_CID_WHITE_BALANCE_TEMPERATURE)
2616 {V4L2_CID_WHITE_BALANCE_TEMPERATURE, "V4L2_CID_WHITE_BALANCE_TEMPERATURE"},
2617 #endif
2618 #if defined(V4L2_CID_SHARPNESS)
2619 {V4L2_CID_SHARPNESS, "V4L2_CID_SHARPNESS"},
2620 #endif
2621 #if defined(V4L2_CID_BACKLIGHT_COMPENSATION)
2622 {V4L2_CID_BACKLIGHT_COMPENSATION, "V4L2_CID_BACKLIGHT_COMPENSATION"},
2623 #endif
2624 #if defined(V4L2_CID_CHROMA_AGC)
2625 {V4L2_CID_CHROMA_AGC, "V4L2_CID_CHROMA_AGC"},
2626 #endif
2627 #if defined(V4L2_CID_COLOR_KILLER)
2628 {V4L2_CID_COLOR_KILLER, "V4L2_CID_COLOR_KILLER"},
2629 #endif
2630 #if defined(V4L2_CID_LASTP1)
2631 {V4L2_CID_LASTP1, "V4L2_CID_LASTP1"},
2632 #endif
2633 #if defined(V4L2_CID_CAMERA_CLASS)
2634 {V4L2_CID_CAMERA_CLASS, "V4L2_CID_CAMERA_CLASS"},
2635 #endif
2636 #if defined(V4L2_CID_EXPOSURE_AUTO)
2637 {V4L2_CID_EXPOSURE_AUTO, "V4L2_CID_EXPOSURE_AUTO"},
2638 #endif
2639 #if defined(V4L2_CID_EXPOSURE_ABSOLUTE)
2640 {V4L2_CID_EXPOSURE_ABSOLUTE, "V4L2_CID_EXPOSURE_ABSOLUTE"},
2641 #endif
2642 #if defined(V4L2_CID_EXPOSURE_AUTO_PRIORITY)
2643 {V4L2_CID_EXPOSURE_AUTO_PRIORITY, "V4L2_CID_EXPOSURE_AUTO_PRIORITY"},
2644 #endif
2645 #if defined(V4L2_CID_PAN_RELATIVE)
2646 {V4L2_CID_PAN_RELATIVE, "V4L2_CID_PAN_RELATIVE"},
2647 #endif
2648 #if defined(V4L2_CID_TILT_RELATIVE)
2649 {V4L2_CID_TILT_RELATIVE, "V4L2_CID_TILT_RELATIVE"},
2650 #endif
2651 #if defined(V4L2_CID_PAN_RESET)
2652 {V4L2_CID_PAN_RESET, "V4L2_CID_PAN_RESET"},
2653 #endif
2654 #if defined(V4L2_CID_TILT_RESET)
2655 {V4L2_CID_TILT_RESET, "V4L2_CID_TILT_RESET"},
2656 #endif
2657 #if defined(V4L2_CID_PAN_ABSOLUTE)
2658 {V4L2_CID_PAN_ABSOLUTE, "V4L2_CID_PAN_ABSOLUTE"},
2659 #endif
2660 #if defined(V4L2_CID_TILT_ABSOLUTE)
2661 {V4L2_CID_TILT_ABSOLUTE, "V4L2_CID_TILT_ABSOLUTE"},
2662 #endif
2663 #if defined(V4L2_CID_FOCUS_ABSOLUTE)
2664 {V4L2_CID_FOCUS_ABSOLUTE, "V4L2_CID_FOCUS_ABSOLUTE"},
2665 #endif
2666 #if defined(V4L2_CID_FOCUS_RELATIVE)
2667 {V4L2_CID_FOCUS_RELATIVE, "V4L2_CID_FOCUS_RELATIVE"},
2668 #endif
2669 #if defined(V4L2_CID_FOCUS_AUTO)
2670 {V4L2_CID_FOCUS_AUTO, "V4L2_CID_FOCUS_AUTO"},
2671 #endif
2672 {0xFFFFFFFF, ""}
2673 };
2674
2675 k = 0;
2676 while (mess[k].name[0]) {
2677         if (wot == mess[k].command) {
2678                 JOT(8, "ioctl 0x%08X is %s\n", \
2679                                         mess[k].command, &mess[k].name[0]);
2680                 return 0;
2681         }
2682         k++;
2683 }
2684 JOT(8, "cid 0x%08X is not in videodev2.h\n", wot);
2685 return -1;
2686 }
2687 /*****************************************************************************/