drivers/staging/easycap/easycap_main.c

   1 /******************************************************************************
   2 *                                                                             *
   3 *  easycap_main.c                                                             *
   4 *                                                                             *
   5 *  Video driver for EasyCAP USB2.0 Video Capture Device DC60                  *
   6 *                                                                             *
   7 *                                                                             *
   8 ******************************************************************************/
   9 /*
  10  *
  11  *  Copyright (C) 2010 R.M. Thomas <rmthomas@sciolus.org>
  12  *
  13  *
  14  *  This is free software; you can redistribute it and/or modify
  15  *  it under the terms of the GNU General Public License as published by
  16  *  the Free Software Foundation; either version 2 of the License, or
  17  *  (at your option) any later version.
  18  *
  19  *  The software is distributed in the hope that it will be useful,
  20  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  *  GNU General Public License for more details.
  23  *
  24  *  You should have received a copy of the GNU General Public License
  25  *  along with this software; if not, write to the Free Software
  26  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  27  *
  28 */
  29 /*****************************************************************************/
  30
  31 #include "easycap.h"
  32 #include "easycap_standard.h"
  33
  34 int easycap_debug;
  35 module_param(easycap_debug, int, S_IRUGO | S_IWUSR);
  36
  37 /*---------------------------------------------------------------------------*/
  38 /*
  39  *  PARAMETERS APPLICABLE TO ENTIRE DRIVER, I.E. BOTH VIDEO AND AUDIO
  40  */
  41 /*---------------------------------------------------------------------------*/
  42 struct usb_device_id easycap_usb_device_id_table[] = {
  43 { USB_DEVICE(USB_EASYCAP_VENDOR_ID, USB_EASYCAP_PRODUCT_ID) },
  44 { }
  45 };
  46 MODULE_DEVICE_TABLE(usb, easycap_usb_device_id_table);
  47 struct usb_driver easycap_usb_driver = {
  48 .name = "easycap",
  49 .id_table = easycap_usb_device_id_table,
  50 .probe = easycap_usb_probe,
  51 .disconnect = easycap_usb_disconnect,
  52 };
  53 /*---------------------------------------------------------------------------*/
  54 /*
  55  *  PARAMETERS USED WHEN REGISTERING THE VIDEO INTERFACE
  56  *
  57  *  NOTE: SOME KERNELS IGNORE usb_class_driver.minor_base, AS MENTIONED BY
  58  *        CORBET ET AL. "LINUX DEVICE DRIVERS", 3rd EDITION, PAGE 253.
  59  *        THIS IS THE CASE FOR OpenSUSE.
  60  */
  61 /*---------------------------------------------------------------------------*/
  62 const struct file_operations easycap_fops = {
  63         .owner          = THIS_MODULE,
  64         .open           = easycap_open,
  65         .release        = easycap_release,
  66         .unlocked_ioctl = easycap_ioctl,
  67         .poll           = easycap_poll,
  68         .mmap           = easycap_mmap,
  69         .llseek         = no_llseek,
  70 };
  71 struct vm_operations_struct easycap_vm_ops = {
  72 .open  = easycap_vma_open,
  73 .close = easycap_vma_close,
  74 .fault = easycap_vma_fault,
  75 };
  76 struct usb_class_driver easycap_class = {
  77 .name = "usb/easycap%d",
  78 .fops = &easycap_fops,
  79 .minor_base = USB_SKEL_MINOR_BASE,
  80 };
  81
  82 /*vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
  83 #if defined(EASYCAP_IS_VIDEODEV_CLIENT)
  84 #if defined(EASYCAP_NEEDS_V4L2_FOPS)
  85 const struct v4l2_file_operations v4l2_fops = {
  86         .owner          = THIS_MODULE,
  87         .open           = easycap_open_noinode,
  88         .release        = easycap_release_noinode,
  89         .unlocked_ioctl = easycap_ioctl,
  90         .poll           = easycap_poll,
  91         .mmap           = easycap_mmap,
  92 };
  93 #endif /*EASYCAP_NEEDS_V4L2_FOPS*/
  94 int video_device_many /*=0*/;
  95 struct video_device *pvideo_array[VIDEO_DEVICE_MANY], *pvideo_device;
  96 #endif /*EASYCAP_IS_VIDEODEV_CLIENT*/
  97 /*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
  98
  99 /*--------------------------------------------------------------------------*/
 100 /*
 101  *  PARAMETERS USED WHEN REGISTERING THE AUDIO INTERFACE
 102  */
 103 /*--------------------------------------------------------------------------*/
 104 const struct file_operations easysnd_fops = {
 105         .owner          = THIS_MODULE,
 106         .open           = easysnd_open,
 107         .release        = easysnd_release,
 108         .unlocked_ioctl = easysnd_ioctl,
 109         .read           = easysnd_read,
 110         .llseek         = no_llseek,
 111 };
 112 struct usb_class_driver easysnd_class = {
 113 .name = "usb/easysnd%d",
 114 .fops = &easysnd_fops,
 115 .minor_base = USB_SKEL_MINOR_BASE,
 116 };
 117 /****************************************************************************/
 118 /*--------------------------------------------------------------------------*/
 119 /*
 120  *  IT IS NOT APPROPRIATE FOR easycap_open() TO SUBMIT THE VIDEO URBS HERE,
 121  *  BECAUSE THERE WILL ALWAYS BE SUBSEQUENT NEGOTIATION OF TV STANDARD AND
 122  *  FORMAT BY IOCTL AND IT IS INADVISABLE TO HAVE THE URBS RUNNING WHILE
 123  *  REGISTERS OF THE SA7113H ARE BEING MANIPULATED.
 124  *
 125  *  THE SUBMISSION OF VIDEO URBS IS THEREFORE DELAYED UNTIL THE IOCTL COMMAND
 126  *  STREAMON IS RECEIVED.
 127  */
 128 /*--------------------------------------------------------------------------*/
 129 /*vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 130 #if defined(EASYCAP_IS_VIDEODEV_CLIENT)
 131 int
 132 easycap_open_noinode(struct file *file)
 133 {
 134 return easycap_open((struct inode *)NULL, file);
 135 }
 136 #endif /*EASYCAP_IS_VIDEODEV_CLIENT*/
 137 /*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
 138 int
 139 easycap_open(struct inode *inode, struct file *file)
 140 {
 141 #if (!defined(EASYCAP_IS_VIDEODEV_CLIENT))
 142 struct usb_interface *pusb_interface;
 143 #endif /*EASYCAP_IS_VIDEODEV_CLIENT*/
 144 struct usb_device *p;
 145 struct easycap *peasycap;
 146 int i, k, m, rc;
 147
 148 JOT(4, "\n");
 149 SAY("==========OPEN=========\n");
 150
 151 peasycap = (struct easycap *)NULL;
 152 #if (!defined(EASYCAP_IS_VIDEODEV_CLIENT))
 153 if ((struct inode *)NULL == inode) {
 154         SAY("ERROR: inode is NULL.\n");
 155         return -EFAULT;
 156 }
 157 pusb_interface = usb_find_interface(&easycap_usb_driver, iminor(inode));
 158 if (!pusb_interface) {
 159         SAY("ERROR: pusb_interface is NULL.\n");
 160         return -EFAULT;
 161 }
 162 peasycap = usb_get_intfdata(pusb_interface);
 163 /*vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 164 #else
 165 for (i = 0;  i < video_device_many;  i++) {
 166         pvideo_device = pvideo_array[i];
 167         if ((struct video_device *)NULL != pvideo_device) {
 168                 peasycap = (struct easycap *)video_get_drvdata(pvideo_device);
 169                 break;
 170         }
 171 }
 172 /*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
 173 #endif /*EASYCAP_IS_VIDEODEV_CLIENT*/
 174 if ((struct easycap *)NULL == peasycap) {
 175         SAY("MISTAKE: peasycap is NULL\n");
 176         return -EFAULT;
 177 }
 178 file->private_data = peasycap;
 179 /*---------------------------------------------------------------------------*/
 180 /*
 181  *  INITIALIZATION
 182  */
 183 /*---------------------------------------------------------------------------*/
 184 JOT(4, "starting initialization\n");
 185
 186 for (k = 0;  k < FRAME_BUFFER_MANY;  k++) {
 187         for (m = 0;  m < FRAME_BUFFER_SIZE/PAGE_SIZE;  m++)
 188                 memset(peasycap->frame_buffer[k][m].pgo, 0, PAGE_SIZE);
 189 }
 190 p = peasycap->pusb_device;
 191 if ((struct usb_device *)NULL == p) {
 192         SAY("ERROR: peasycap->pusb_device is NULL\n");
 193         return -EFAULT;
 194 } else {
 195         JOT(16, "0x%08lX=peasycap->pusb_device\n", \
 196                                         (long int)peasycap->pusb_device);
 197 }
 198 rc = wakeup_device(peasycap->pusb_device);
 199 if (0 == rc)
 200         JOT(8, "wakeup_device() OK\n");
 201 else {
 202         SAY("ERROR: wakeup_device() returned %i\n", rc);
 203         return -EFAULT;
 204 }
 205 rc = setup_stk(p);  peasycap->input = 0;
 206 if (0 == rc)
 207         JOT(8, "setup_stk() OK\n");
 208 else {
 209         SAY("ERROR: setup_stk() returned %i\n", rc);
 210         return -EFAULT;
 211 }
 212 rc = setup_saa(p);
 213 if (0 == rc)
 214         JOT(8, "setup_saa() OK\n");
 215 else {
 216         SAY("ERROR: setup_saa() returned %i\n", rc);
 217         return -EFAULT;
 218 }
 219 rc = check_saa(p);
 220 if (0 == rc)
 221         JOT(8, "check_saa() OK\n");
 222 else if (-8 < rc)
 223         SAY("check_saa() returned %i\n", rc);
 224 else {
 225         SAY("ERROR: check_saa() returned %i\n", rc);
 226         return -EFAULT;
 227 }
 228 peasycap->standard_offset = -1;
 229 /*---------------------------------------------------------------------------*/
 230 #if defined(PREFER_NTSC)
 231
 232 rc = adjust_standard(peasycap, V4L2_STD_NTSC_M);
 233 if (0 == rc)
 234         JOT(8, "adjust_standard(.,NTSC_M) OK\n");
 235 else {
 236         SAY("ERROR: adjust_standard(.,NTSC_M) returned %i\n", rc);
 237         return -EFAULT;
 238 }
 239 rc = adjust_format(peasycap, 640, 480, V4L2_PIX_FMT_UYVY, V4L2_FIELD_NONE, \
 240                                                                         false);
 241 if (0 <= rc)
 242         JOT(8, "adjust_format(.,640,480,UYVY) OK\n");
 243 else {
 244         SAY("ERROR: adjust_format(.,640,480,UYVY) returned %i\n", rc);
 245         return -EFAULT;
 246 }
 247
 248 #else
 249
 250 rc = adjust_standard(peasycap, \
 251                 (V4L2_STD_PAL_B | V4L2_STD_PAL_G | V4L2_STD_PAL_H | \
 252                 V4L2_STD_PAL_I | V4L2_STD_PAL_N));
 253 if (0 == rc)
 254         JOT(8, "adjust_standard(.,PAL_BGHIN) OK\n");
 255 else {
 256         SAY("ERROR: adjust_standard(.,PAL_BGHIN) returned %i\n", rc);
 257         return -EFAULT;
 258 }
 259 rc = adjust_format(peasycap, 640, 480, V4L2_PIX_FMT_UYVY, V4L2_FIELD_NONE, \
 260                                                                         false);
 261 if (0 <= rc)
 262         JOT(8, "adjust_format(.,640,480,uyvy,false) OK\n");
 263 else {
 264         SAY("ERROR: adjust_format(.,640,480,uyvy,false) returned %i\n", rc);
 265         return -EFAULT;
 266 }
 267
 268 #endif /* !PREFER_NTSC*/
 269 /*---------------------------------------------------------------------------*/
 270 rc = adjust_brightness(peasycap, -8192);
 271 if (0 != rc) {
 272         SAY("ERROR: adjust_brightness(default) returned %i\n", rc);
 273         return -EFAULT;
 274 }
 275 rc = adjust_contrast(peasycap, -8192);
 276 if (0 != rc) {
 277         SAY("ERROR: adjust_contrast(default) returned %i\n", rc);
 278         return -EFAULT;
 279 }
 280 rc = adjust_saturation(peasycap, -8192);
 281 if (0 != rc) {
 282         SAY("ERROR: adjust_saturation(default) returned %i\n", rc);
 283         return -EFAULT;
 284 }
 285 rc = adjust_hue(peasycap, -8192);
 286 if (0 != rc) {
 287         SAY("ERROR: adjust_hue(default) returned %i\n", rc);
 288         return -EFAULT;
 289 }
 290 /*---------------------------------------------------------------------------*/
 291 rc = usb_set_interface(peasycap->pusb_device, peasycap->video_interface, \
 292                                                 peasycap->video_altsetting_on);
 293 if (0 == rc)
 294         JOT(8, "usb_set_interface(.,%i,%i) OK\n", peasycap->video_interface, \
 295                                                 peasycap->video_altsetting_on);
 296 else {
 297         SAY("ERROR: usb_set_interface() returned %i\n", rc);
 298         return -EFAULT;
 299 }
 300 rc = start_100(p);
 301 if (0 == rc)
 302         JOT(8, "start_100() OK\n");
 303 else {
 304         SAY("ERROR: start_100() returned %i\n", rc);
 305         return -EFAULT;
 306 }
 307 peasycap->video_isoc_sequence = VIDEO_ISOC_BUFFER_MANY - 1;
 308 peasycap->video_idle = 0;
 309 peasycap->video_junk = 0;
 310 for (i = 0; i < 180; i++)
 311         peasycap->merit[i] = 0;
 312 peasycap->video_eof = 0;
 313 peasycap->audio_eof = 0;
 314
 315 do_gettimeofday(&peasycap->timeval7);
 316
 317 peasycap->fudge = 0;
 318
 319 JOT(4, "finished initialization\n");
 320 return 0;
 321 }
 322 /*****************************************************************************/
 323 int
 324 submit_video_urbs(struct easycap *peasycap)
 325 {
 326 struct data_urb *pdata_urb;
 327 struct urb *purb;
 328 struct list_head *plist_head;
 329 int j, isbad, m, rc;
 330 int isbuf;
 331
 332 if ((struct list_head *)NULL == peasycap->purb_video_head) {
 333         SAY("ERROR: peasycap->urb_video_head uninitialized\n");
 334         return -EFAULT;
 335 }
 336 if ((struct usb_device *)NULL == peasycap->pusb_device) {
 337         SAY("ERROR: peasycap->pusb_device is NULL\n");
 338         return -EFAULT;
 339 }
 340 if (!peasycap->video_isoc_streaming) {
 341
 342
 343
 344
 345
 346
 347
 348
 349         JOT(4, "submission of all video urbs\n");
 350         if (0 != ready_saa(peasycap->pusb_device)) {
 351                 SAY("ERROR: not ready to capture after waiting " \
 352                                                         "one second\n");
 353                 SAY(".....  continuing anyway\n");
 354         }
 355         isbad = 0;  m = 0;
 356         list_for_each(plist_head, (peasycap->purb_video_head)) {
 357                 pdata_urb = list_entry(plist_head, struct data_urb, list_head);
 358                 if (NULL != pdata_urb) {
 359                         purb = pdata_urb->purb;
 360                         if (NULL != purb) {
 361                                 isbuf = pdata_urb->isbuf;
 362                                 purb->interval = 1;
 363                                 purb->dev = peasycap->pusb_device;
 364                                 purb->pipe = \
 365                                         usb_rcvisocpipe(peasycap->pusb_device,\
 366                                         peasycap->video_endpointnumber);
 367                                 purb->transfer_flags = URB_ISO_ASAP;
 368                                 purb->transfer_buffer = \
 369                                         peasycap->video_isoc_buffer[isbuf].pgo;
 370                                 purb->transfer_buffer_length = \
 371                                         peasycap->video_isoc_buffer_size;
 372                                 purb->complete = easycap_complete;
 373                                 purb->context = peasycap;
 374                                 purb->start_frame = 0;
 375                                 purb->number_of_packets = \
 376                                         peasycap->video_isoc_framesperdesc;
 377
 378                                 for (j = 0;  j < peasycap->\
 379                                         video_isoc_framesperdesc; j++) {
 380                                                 purb->iso_frame_desc[j].\
 381                                                 offset = j * \
 382                                                 peasycap->\
 383                                                 video_isoc_maxframesize;
 384                                                 purb->iso_frame_desc[j].\
 385                                                 length = peasycap->\
 386                                                 video_isoc_maxframesize;
 387                                         }
 388
 389                                 rc = usb_submit_urb(purb, GFP_KERNEL);
 390                                 if (0 != rc) {
 391                                         isbad++;
 392                                         SAY("ERROR: usb_submit_urb() failed " \
 393                                                         "for urb with rc:\n");
 394                                         switch (rc) {
 395                                         case -ENOMEM: {
 396                                                 SAY("ENOMEM\n");
 397                                                 break;
 398                                         }
 399                                         case -ENODEV: {
 400                                                 SAY("ENODEV\n");
 401                                                 break;
 402                                         }
 403                                         case -ENXIO: {
 404                                                 SAY("ENXIO\n");
 405                                                 break;
 406                                         }
 407                                         case -EINVAL: {
 408                                                 SAY("EINVAL\n");
 409                                                 break;
 410                                         }
 411                                         case -EAGAIN: {
 412                                                 SAY("EAGAIN\n");
 413                                                 break;
 414                                         }
 415                                         case -EFBIG: {
 416                                                 SAY("EFBIG\n");
 417                                                 break;
 418                                         }
 419                                         case -EPIPE: {
 420                                                 SAY("EPIPE\n");
 421                                                 break;
 422                                         }
 423                                         case -EMSGSIZE: {
 424                                                 SAY("EMSGSIZE\n");
 425                                                 break;
 426                                         }
 427                                         default: {
 428                                                 SAY("unknown error code %i\n",\
 429                                                                          rc);
 430                                                 break;
 431                                         }
 432                                         }
 433                                 } else {
 434                                         m++;
 435                                 }
 436                                 } else {
 437                                         isbad++;
 438                                 }
 439                         } else {
 440                                  isbad++;
 441                         }
 442                 }
 443         if (isbad) {
 444                 JOT(4, "attempting cleanup instead of submitting\n");
 445                 list_for_each(plist_head, (peasycap->purb_video_head)) {
 446                         pdata_urb = list_entry(plist_head, struct data_urb, \
 447                                                                 list_head);
 448                         if (NULL != pdata_urb) {
 449                                 purb = pdata_urb->purb;
 450                                 if (NULL != purb)
 451                                         usb_kill_urb(purb);
 452                         }
 453                 }
 454                 peasycap->video_isoc_streaming = 0;
 455         } else {
 456                 peasycap->video_isoc_streaming = 1;
 457                 JOT(4, "submitted %i video urbs\n", m);
 458         }
 459
 460
 461
 462
 463
 464
 465 } else {
 466         JOT(4, "already streaming video urbs\n");
 467 }
 468 return 0;
 469 }
 470 /*****************************************************************************/
 471 int
 472 kill_video_urbs(struct easycap *peasycap)
 473 {
 474 int m;
 475 struct list_head *plist_head;
 476 struct data_urb *pdata_urb;
 477
 478 if ((struct easycap *)NULL == peasycap) {
 479         SAY("ERROR: peasycap is NULL\n");
 480         return -EFAULT;
 481 }
 482 if (peasycap->video_isoc_streaming) {
 483
 484
 485
 486         if ((struct list_head *)NULL != peasycap->purb_video_head) {
 487                 peasycap->video_isoc_streaming = 0;
 488                 JOT(4, "killing video urbs\n");
 489                 m = 0;
 490                 list_for_each(plist_head, (peasycap->purb_video_head)) {
 491                         pdata_urb = list_entry(plist_head, struct data_urb, \
 492                                                                 list_head);
 493                         if ((struct data_urb *)NULL != pdata_urb) {
 494                                 if ((struct urb *)NULL != pdata_urb->purb) {
 495                                         usb_kill_urb(pdata_urb->purb);
 496                                         m++;
 497                                 }
 498                         }
 499                 }
 500                 JOT(4, "%i video urbs killed\n", m);
 501         } else {
 502                 SAY("ERROR: peasycap->purb_video_head is NULL\n");
 503                 return -EFAULT;
 504         }
 505 } else {
 506         JOT(8, "%i=video_isoc_streaming, no video urbs killed\n", \
 507                                         peasycap->video_isoc_streaming);
 508 }
 509 return 0;
 510 }
 511 /****************************************************************************/
 512 /*vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 513 #if defined(EASYCAP_IS_VIDEODEV_CLIENT)
 514 int
 515 easycap_release_noinode(struct file *file)
 516 {
 517 return easycap_release((struct inode *)NULL, file);
 518 }
 519 #endif /*EASYCAP_IS_VIDEODEV_CLIENT*/
 520 /*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
 521 /*--------------------------------------------------------------------------*/
 522 int
 523 easycap_release(struct inode *inode, struct file *file)
 524 {
 525 #if (!defined(EASYCAP_IS_VIDEODEV_CLIENT))
 526 struct easycap *peasycap;
 527
 528 JOT(4, "\n");
 529
 530 peasycap = file->private_data;
 531 if (NULL == peasycap) {
 532         SAY("ERROR:  peasycap is NULL.\n");
 533         SAY("ending unsuccessfully\n");
 534         return -EFAULT;
 535 }
 536 if (0 != kill_video_urbs(peasycap)) {
 537         SAY("ERROR: kill_video_urbs() failed\n");
 538         return -EFAULT;
 539 }
 540 JOT(4, "ending successfully\n");
 541 /*vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 542 #else
 543 #
 544 /*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
 545 #endif /*EASYCAP_IS_VIDEODEV_CLIENT*/
 546
 547 return 0;
 548 }
 549 /****************************************************************************/
 550 /*vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 551 #if defined(EASYCAP_IS_VIDEODEV_CLIENT)
 552 int
 553 videodev_release(struct video_device *pvd)
 554 {
 555 struct easycap *peasycap;
 556 int i, j, k;
 557
 558 JOT(4, "\n");
 559
 560 k = 0;
 561 for (i = 0;  i < video_device_many;  i++) {
 562         pvideo_device = pvideo_array[i];
 563         if ((struct video_device *)NULL != pvideo_device) {
 564                 if (pvd->minor == pvideo_device->minor) {
 565                         peasycap = (struct easycap *)\
 566                                         video_get_drvdata(pvideo_device);
 567                         if ((struct easycap *)NULL == peasycap) {
 568                                 SAY("ERROR:  peasycap is NULL\n");
 569                                 SAY("ending unsuccessfully\n");
 570                                 return -EFAULT;
 571                         }
 572                         if (0 != kill_video_urbs(peasycap)) {
 573                                 SAY("ERROR: kill_video_urbs() failed\n");
 574                                 return -EFAULT;
 575                         }
 576                         JOT(4, "freeing video_device structure: " \
 577                                                         "/dev/video%i\n", i);
 578                         kfree((void *)pvideo_device);
 579                         for (j = i;  j < (VIDEO_DEVICE_MANY - 1);  j++)
 580                                 pvideo_array[j] = pvideo_array[j + 1];
 581                         video_device_many--;  k++;
 582                         break;
 583                 }
 584         }
 585 }
 586 if (!k) {
 587         SAY("ERROR: lost video_device structure for %i=minor\n", pvd->minor);
 588         SAY("cannot free: may cause memory leak\n");
 589         SAY("ending unsuccessfully\n");
 590         return -EFAULT;
 591 }
 592
 593 JOT(4, "ending successfully\n");
 594 return 0;
 595 }
 596 #endif /*EASYCAP_IS_VIDEODEV_CLIENT*/
 597 /*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
 598 /****************************************************************************/
 599 /*--------------------------------------------------------------------------*/
 600 /*
 601  *  THIS FUNCTION IS CALLED FROM WITHIN easycap_usb_disconnect().
 602  *  BY THIS STAGE THE DEVICE HAS ALREADY BEEN PHYSICALLY UNPLUGGED.
 603  *  peasycap->pusb_device IS NO LONGER VALID AND SHOULD HAVE BEEN SET TO NULL.
 604  */
 605 /*---------------------------------------------------------------------------*/
 606 void
 607 easycap_delete(struct kref *pkref)
 608 {
 609 int k, m, lost;
 610 int allocation_video_urb, allocation_video_page, allocation_video_struct;
 611 int allocation_audio_urb, allocation_audio_page, allocation_audio_struct;
 612 int registered_video, registered_audio;
 613 struct easycap *peasycap;
 614 struct data_urb *pdata_urb;
 615 struct list_head *plist_head, *plist_next;
 616
 617 JOT(4, "\n");
 618
 619 peasycap = container_of(pkref, struct easycap, kref);
 620 if ((struct easycap *)NULL == peasycap) {
 621         SAY("ERROR: peasycap is NULL: cannot perform deletions\n");
 622         return;
 623 }
 624 /*---------------------------------------------------------------------------*/
 625 /*
 626  *  FREE VIDEO.
 627  */
 628 /*---------------------------------------------------------------------------*/
 629 if ((struct list_head *)NULL != peasycap->purb_video_head) {
 630         JOT(4, "freeing video urbs\n");
 631         m = 0;
 632         list_for_each(plist_head, (peasycap->purb_video_head)) {
 633                 pdata_urb = list_entry(plist_head, struct data_urb, list_head);
 634                 if (NULL == pdata_urb)
 635                         JOT(4, "ERROR: pdata_urb is NULL\n");
 636                 else {
 637                         if ((struct urb *)NULL != pdata_urb->purb) {
 638                                 usb_free_urb(pdata_urb->purb);
 639                                 pdata_urb->purb = (struct urb *)NULL;
 640                                 peasycap->allocation_video_urb -= 1;
 641                                 m++;
 642                         }
 643                 }
 644         }
 645
 646         JOT(4, "%i video urbs freed\n", m);
 647 /*---------------------------------------------------------------------------*/
 648         JOT(4, "freeing video data_urb structures.\n");
 649         m = 0;
 650         list_for_each_safe(plist_head, plist_next, peasycap->purb_video_head) {
 651                 pdata_urb = list_entry(plist_head, struct data_urb, list_head);
 652                 if ((struct data_urb *)NULL != pdata_urb) {
 653                         kfree(pdata_urb);  pdata_urb = (struct data_urb *)NULL;
 654                         peasycap->allocation_video_struct -= \
 655                                                 sizeof(struct data_urb);
 656                         m++;
 657                 }
 658         }
 659         JOT(4, "%i video data_urb structures freed\n", m);
 660         JOT(4, "setting peasycap->purb_video_head=NULL\n");
 661         peasycap->purb_video_head = (struct list_head *)NULL;
 662         } else {
 663 JOT(4, "peasycap->purb_video_head is NULL\n");
 664 }
 665 /*---------------------------------------------------------------------------*/
 666 JOT(4, "freeing video isoc buffers.\n");
 667 m = 0;
 668 for (k = 0;  k < VIDEO_ISOC_BUFFER_MANY;  k++) {
 669         if ((void *)NULL != peasycap->video_isoc_buffer[k].pgo) {
 670                 free_pages((unsigned long)\
 671                                 (peasycap->video_isoc_buffer[k].pgo), \
 672                                 VIDEO_ISOC_ORDER);
 673                 peasycap->video_isoc_buffer[k].pgo = (void *)NULL;
 674                 peasycap->allocation_video_page -= \
 675                                 ((unsigned int)(0x01 << VIDEO_ISOC_ORDER));
 676                 m++;
 677         }
 678 }
 679 JOT(4, "isoc video buffers freed: %i pages\n", m * (0x01 << VIDEO_ISOC_ORDER));
 680 /*---------------------------------------------------------------------------*/
 681 JOT(4, "freeing video field buffers.\n");
 682 lost = 0;
 683 for (k = 0;  k < FIELD_BUFFER_MANY;  k++) {
 684         for (m = 0;  m < FIELD_BUFFER_SIZE/PAGE_SIZE;  m++) {
 685                 if ((void *)NULL != peasycap->field_buffer[k][m].pgo) {
 686                         free_page((unsigned long)\
 687                                         (peasycap->field_buffer[k][m].pgo));
 688                         peasycap->field_buffer[k][m].pgo = (void *)NULL;
 689                         peasycap->allocation_video_page -= 1;
 690                         lost++;
 691                 }
 692         }
 693 }
 694 JOT(4, "video field buffers freed: %i pages\n", lost);
 695 /*---------------------------------------------------------------------------*/
 696 JOT(4, "freeing video frame buffers.\n");
 697 lost = 0;
 698 for (k = 0;  k < FRAME_BUFFER_MANY;  k++) {
 699         for (m = 0;  m < FRAME_BUFFER_SIZE/PAGE_SIZE;  m++) {
 700                 if ((void *)NULL != peasycap->frame_buffer[k][m].pgo) {
 701                         free_page((unsigned long)\
 702                                         (peasycap->frame_buffer[k][m].pgo));
 703                         peasycap->frame_buffer[k][m].pgo = (void *)NULL;
 704                         peasycap->allocation_video_page -= 1;
 705                         lost++;
 706                 }
 707         }
 708 }
 709 JOT(4, "video frame buffers freed: %i pages\n", lost);
 710 /*---------------------------------------------------------------------------*/
 711 /*
 712  *  FREE AUDIO.
 713  */
 714 /*---------------------------------------------------------------------------*/
 715 if ((struct list_head *)NULL != peasycap->purb_audio_head) {
 716         JOT(4, "freeing audio urbs\n");
 717         m = 0;
 718         list_for_each(plist_head, (peasycap->purb_audio_head)) {
 719                 pdata_urb = list_entry(plist_head, struct data_urb, list_head);
 720                 if (NULL == pdata_urb)
 721                         JOT(4, "ERROR: pdata_urb is NULL\n");
 722                 else {
 723                         if ((struct urb *)NULL != pdata_urb->purb) {
 724                                 usb_free_urb(pdata_urb->purb);
 725                                 pdata_urb->purb = (struct urb *)NULL;
 726                                 peasycap->allocation_audio_urb -= 1;
 727                                 m++;
 728                         }
 729                 }
 730         }
 731         JOT(4, "%i audio urbs freed\n", m);
 732 /*---------------------------------------------------------------------------*/
 733         JOT(4, "freeing audio data_urb structures.\n");
 734         m = 0;
 735         list_for_each_safe(plist_head, plist_next, peasycap->purb_audio_head) {
 736                 pdata_urb = list_entry(plist_head, struct data_urb, list_head);
 737                 if ((struct data_urb *)NULL != pdata_urb) {
 738                         kfree(pdata_urb);  pdata_urb = (struct data_urb *)NULL;
 739                         peasycap->allocation_audio_struct -= \
 740                                                 sizeof(struct data_urb);
 741                         m++;
 742                 }
 743         }
 744 JOT(4, "%i audio data_urb structures freed\n", m);
 745 JOT(4, "setting peasycap->purb_audio_head=NULL\n");
 746 peasycap->purb_audio_head = (struct list_head *)NULL;
 747 } else {
 748 JOT(4, "peasycap->purb_audio_head is NULL\n");
 749 }
 750 /*---------------------------------------------------------------------------*/
 751 JOT(4, "freeing audio isoc buffers.\n");
 752 m = 0;
 753 for (k = 0;  k < AUDIO_ISOC_BUFFER_MANY;  k++) {
 754         if ((void *)NULL != peasycap->audio_isoc_buffer[k].pgo) {
 755                 free_pages((unsigned long)\
 756                                 (peasycap->audio_isoc_buffer[k].pgo), \
 757                                 AUDIO_ISOC_ORDER);
 758                 peasycap->audio_isoc_buffer[k].pgo = (void *)NULL;
 759                 peasycap->allocation_audio_page -= \
 760                                 ((unsigned int)(0x01 << AUDIO_ISOC_ORDER));
 761                 m++;
 762         }
 763 }
 764 JOT(4, "easysnd_delete(): isoc audio buffers freed: %i pages\n", \
 765                                         m * (0x01 << AUDIO_ISOC_ORDER));
 766 /*---------------------------------------------------------------------------*/
 767 JOT(4, "freeing audio buffers.\n");
 768 lost = 0;
 769 for (k = 0;  k < peasycap->audio_buffer_page_many;  k++) {
 770         if ((void *)NULL != peasycap->audio_buffer[k].pgo) {
 771                 free_page((unsigned long)(peasycap->audio_buffer[k].pgo));
 772                 peasycap->audio_buffer[k].pgo = (void *)NULL;
 773                 peasycap->allocation_audio_page -= 1;
 774                 lost++;
 775         }
 776 }
 777 JOT(4, "easysnd_delete(): audio buffers freed: %i pages\n", lost);
 778 /*---------------------------------------------------------------------------*/
 779 JOT(4, "freeing easycap structure.\n");
 780 allocation_video_urb    = peasycap->allocation_video_urb;
 781 allocation_video_page   = peasycap->allocation_video_page;
 782 allocation_video_struct = peasycap->allocation_video_struct;
 783 registered_video        = peasycap->registered_video;
 784 allocation_audio_urb    = peasycap->allocation_audio_urb;
 785 allocation_audio_page   = peasycap->allocation_audio_page;
 786 allocation_audio_struct = peasycap->allocation_audio_struct;
 787 registered_audio        = peasycap->registered_audio;
 788 m = 0;
 789 if ((struct easycap *)NULL != peasycap) {
 790         kfree(peasycap);  peasycap = (struct easycap *)NULL;
 791         allocation_video_struct -= sizeof(struct easycap);
 792         m++;
 793 }
 794 JOT(4, "%i easycap structure freed\n", m);
 795 /*---------------------------------------------------------------------------*/
 796
 797 SAY("%8i= video urbs     after all deletions\n", allocation_video_urb);
 798 SAY("%8i= video pages    after all deletions\n", allocation_video_page);
 799 SAY("%8i= video structs  after all deletions\n", allocation_video_struct);
 800 SAY("%8i= video devices  after all deletions\n", registered_video);
 801 SAY("%8i= audio urbs     after all deletions\n", allocation_audio_urb);
 802 SAY("%8i= audio pages    after all deletions\n", allocation_audio_page);
 803 SAY("%8i= audio structs  after all deletions\n", allocation_audio_struct);
 804 SAY("%8i= audio devices  after all deletions\n", registered_audio);
 805
 806 JOT(4, "ending.\n");
 807 return;
 808 }
 809 /*****************************************************************************/
 810 unsigned int easycap_poll(struct file *file, poll_table *wait)
 811 {
 812 struct easycap *peasycap;
 813
 814 JOT(8, "\n");
 815
 816 if (NULL == ((poll_table *)wait))
 817         JOT(8, "WARNING:  poll table pointer is NULL ... continuing\n");
 818 if (NULL == ((struct file *)file)) {
 819         SAY("ERROR:  file pointer is NULL\n");
 820         return -EFAULT;
 821 }
 822 peasycap = file->private_data;
 823 if (NULL == peasycap) {
 824         SAY("ERROR:  peasycap is NULL\n");
 825         return -EFAULT;
 826 }
 827 peasycap->polled = 1;
 828
 829 if (0 == easycap_dqbuf(peasycap, 0))
 830         return POLLIN | POLLRDNORM;
 831 else
 832         return POLLERR;
 833
 834 }
 835 /*****************************************************************************/
 836 /*---------------------------------------------------------------------------*/
 837 /*
 838  *  IF mode IS NONZERO THIS ROUTINE RETURNS -EAGAIN RATHER THAN BLOCKING.
 839  */
 840 /*---------------------------------------------------------------------------*/
 841 int
 842 easycap_dqbuf(struct easycap *peasycap, int mode)
 843 {
 844 int miss, rc;
 845
 846 JOT(8, "\n");
 847
 848 if (NULL == peasycap) {
 849         SAY("ERROR:  peasycap is NULL\n");
 850         return -EFAULT;
 851 }
 852 /*---------------------------------------------------------------------------*/
 853 /*
 854  *  WAIT FOR FIELD 0
 855  */
 856 /*---------------------------------------------------------------------------*/
 857 miss = 0;
 858 if (mutex_lock_interruptible(&(peasycap->mutex_mmap_video[0])))
 859         return -ERESTARTSYS;
 860 while ((peasycap->field_read == peasycap->field_fill) || \
 861                                 (0 != (0xFF00 & peasycap->field_buffer\
 862                                         [peasycap->field_read][0].kount)) || \
 863                                 (0 != (0x00FF & peasycap->field_buffer\
 864                                         [peasycap->field_read][0].kount))) {
 865         mutex_unlock(&(peasycap->mutex_mmap_video[0]));
 866
 867         if (mode)
 868                 return -EAGAIN;
 869
 870         JOT(8, "first wait  on wq_video, " \
 871                                 "%i=field_read  %i=field_fill\n", \
 872                                 peasycap->field_read, peasycap->field_fill);
 873
 874         msleep(1);
 875         if (0 != (wait_event_interruptible(peasycap->wq_video, \
 876                         (peasycap->video_idle || peasycap->video_eof  || \
 877                         ((peasycap->field_read != peasycap->field_fill) && \
 878                                 (0 == (0xFF00 & peasycap->field_buffer\
 879                                         [peasycap->field_read][0].kount)) && \
 880                                 (0 == (0x00FF & peasycap->field_buffer\
 881                                         [peasycap->field_read][0].kount))))))){
 882                 SAY("aborted by signal\n");
 883                 return -EIO;
 884                 }
 885         if (peasycap->video_idle) {
 886                 JOT(8, "%i=peasycap->video_idle\n", peasycap->video_idle);
 887                 return -EIO;
 888         }
 889         if (peasycap->video_eof) {
 890                 JOT(8, "%i=peasycap->video_eof\n", peasycap->video_eof);
 891                 debrief(peasycap);
 892                 kill_video_urbs(peasycap);
 893                 return -EIO;
 894         }
 895 miss++;
 896 if (mutex_lock_interruptible(&(peasycap->mutex_mmap_video[0])))
 897         return -ERESTARTSYS;
 898 }
 899 mutex_unlock(&(peasycap->mutex_mmap_video[0]));
 900 JOT(8, "first awakening on wq_video after %i waits\n", miss);
 901
 902 rc = field2frame(peasycap);
 903 if (0 != rc)
 904         SAY("ERROR: field2frame() returned %i\n", rc);
 905
 906 if (true == peasycap->offerfields) {
 907         peasycap->frame_read = peasycap->frame_fill;
 908         (peasycap->frame_fill)++;
 909         if (peasycap->frame_buffer_many <= peasycap->frame_fill)
 910                 peasycap->frame_fill = 0;
 911
 912         if (0x01 & easycap_standard[peasycap->standard_offset].mask) {
 913                 peasycap->frame_buffer[peasycap->frame_read][0].kount = \
 914                                                         V4L2_FIELD_BOTTOM;
 915         } else {
 916                 peasycap->frame_buffer[peasycap->frame_read][0].kount = \
 917                                                         V4L2_FIELD_TOP;
 918         }
 919 JOT(8, "setting:    %i=peasycap->frame_read\n", peasycap->frame_read);
 920 JOT(8, "bumped to:  %i=peasycap->frame_fill\n", peasycap->frame_fill);
 921 }
 922 /*---------------------------------------------------------------------------*/
 923 /*
 924  *  WAIT FOR FIELD 1
 925  */
 926 /*---------------------------------------------------------------------------*/
 927 miss = 0;
 928 if (mutex_lock_interruptible(&(peasycap->mutex_mmap_video[0])))
 929         return -ERESTARTSYS;
 930 while ((peasycap->field_read == peasycap->field_fill) || \
 931                                 (0 != (0xFF00 & peasycap->field_buffer\
 932                                         [peasycap->field_read][0].kount)) || \
 933                                 (0 == (0x00FF & peasycap->field_buffer\
 934                                         [peasycap->field_read][0].kount))) {
 935         mutex_unlock(&(peasycap->mutex_mmap_video[0]));
 936
 937         if (mode)
 938                 return -EAGAIN;
 939
 940         JOT(8, "second wait on wq_video, " \
 941                                 "%i=field_read  %i=field_fill\n", \
 942                                 peasycap->field_read, peasycap->field_fill);
 943         msleep(1);
 944         if (0 != (wait_event_interruptible(peasycap->wq_video, \
 945                         (peasycap->video_idle || peasycap->video_eof  || \
 946                         ((peasycap->field_read != peasycap->field_fill) && \
 947                                 (0 == (0xFF00 & peasycap->field_buffer\
 948                                         [peasycap->field_read][0].kount)) && \
 949                                 (0 != (0x00FF & peasycap->field_buffer\
 950                                         [peasycap->field_read][0].kount))))))){
 951                 SAY("aborted by signal\n");
 952                 return -EIO;
 953         }
 954         if (peasycap->video_idle) {
 955                 JOT(8, "%i=peasycap->video_idle\n", peasycap->video_idle);
 956                 return -EIO;
 957         }
 958         if (peasycap->video_eof) {
 959                 JOT(8, "%i=peasycap->video_eof\n", peasycap->video_eof);
 960                 debrief(peasycap);
 961                 kill_video_urbs(peasycap);
 962                 return -EIO;
 963         }
 964 miss++;
 965 if (mutex_lock_interruptible(&(peasycap->mutex_mmap_video[0])))
 966         return -ERESTARTSYS;
 967 }
 968 mutex_unlock(&(peasycap->mutex_mmap_video[0]));
 969 JOT(8, "second awakening on wq_video after %i waits\n", miss);
 970
 971 rc = field2frame(peasycap);
 972 if (0 != rc)
 973         SAY("ERROR: field2frame() returned %i\n", rc);
 974
 975 peasycap->frame_read = peasycap->frame_fill;
 976 peasycap->queued[peasycap->frame_read] = 0;
 977 peasycap->done[peasycap->frame_read]   = V4L2_BUF_FLAG_DONE;
 978
 979 (peasycap->frame_fill)++;
 980 if (peasycap->frame_buffer_many <= peasycap->frame_fill)
 981         peasycap->frame_fill = 0;
 982
 983 if (0x01 & easycap_standard[peasycap->standard_offset].mask) {
 984         peasycap->frame_buffer[peasycap->frame_read][0].kount = \
 985                                                         V4L2_FIELD_TOP;
 986 } else {
 987         peasycap->frame_buffer[peasycap->frame_read][0].kount = \
 988                                                         V4L2_FIELD_BOTTOM;
 989 }
 990
 991 JOT(8, "setting:    %i=peasycap->frame_read\n", peasycap->frame_read);
 992 JOT(8, "bumped to:  %i=peasycap->frame_fill\n", peasycap->frame_fill);
 993
 994 return 0;
 995 }
 996 /*****************************************************************************/
 997 /*---------------------------------------------------------------------------*/
 998 /*
 999  *  BY DEFINITION, odd IS true  FOR THE FIELD OCCUPYING LINES 1,3,5,...,479
1000  *                 odd IS false FOR THE FIELD OCCUPYING LINES 0,2,4,...,478
1001  *
1002  *  WHEN BOOLEAN PARAMETER decimatepixel IS true, ONLY THE FIELD FOR WHICH
1003  *  odd==false IS TRANSFERRED TO THE FRAME BUFFER.
1004  *
1005  *  THE BOOLEAN PARAMETER offerfields IS true ONLY WHEN THE USER PROGRAM
1006  *  CHOOSES THE OPTION V4L2_FIELD_ALTERNATE.  NO USERSPACE PROGRAM TESTED
1007  *  TO DATE HAS DONE THIS.  BUGS ARE LIKELY.
1008  */
1009 /*---------------------------------------------------------------------------*/
1010 int
1011 field2frame(struct easycap *peasycap)
1012 {
1013 static struct timeval timeval0;
1014 struct timeval timeval;
1015 long long int above, below;
1016 __u32 remainder;
1017 struct signed_div_result sdr;
1018
1019 void *pex, *pad;
1020 int kex, kad, mex, mad, rex, rad, rad2;
1021 int c2, c3, w2, w3, cz, wz;
1022 int rc, bytesperpixel, multiplier, much, more, over, rump, caches;
1023 __u8 mask, margin;
1024 bool odd, isuy, decimatepixel, offerfields;
1025
1026 JOT(8, "=====  parity %i, field buffer %i --> frame buffer %i\n", \
1027                         peasycap->field_buffer[peasycap->field_read][0].kount,\
1028                         peasycap->field_read, peasycap->frame_fill);
1029 JOT(8, "=====  %i=bytesperpixel\n", peasycap->bytesperpixel);
1030 if (true == peasycap->offerfields)
1031         JOT(8, "===== offerfields\n");
1032
1033 /*---------------------------------------------------------------------------*/
1034 /*
1035  *  REJECT OR CLEAN BAD FIELDS
1036  */
1037 /*---------------------------------------------------------------------------*/
1038 if (peasycap->field_read == peasycap->field_fill) {
1039         SAY("ERROR: on entry, still filling field buffer %i\n", \
1040                                                         peasycap->field_read);
1041         return 0;
1042 }
1043 #if defined(EASYCAP_TESTCARD)
1044 easycap_testcard(peasycap, peasycap->field_read);
1045 #else
1046 if (0 != (0x0400 & peasycap->field_buffer[peasycap->field_read][0].kount))
1047         easycap_testcard(peasycap, peasycap->field_read);
1048 #endif /*EASYCAP_TESTCARD*/
1049 /*---------------------------------------------------------------------------*/
1050
1051 offerfields = peasycap->offerfields;
1052 bytesperpixel = peasycap->bytesperpixel;
1053 decimatepixel = peasycap->decimatepixel;
1054
1055 if ((2 != bytesperpixel) && \
1056                         (3 != bytesperpixel) && \
1057                         (4 != bytesperpixel)) {
1058         SAY("MISTAKE: %i=bytesperpixel\n", bytesperpixel);
1059         return -EFAULT;
1060 }
1061 if (true == decimatepixel)
1062         multiplier = 2;
1063 else
1064         multiplier = 1;
1065
1066 w2 = 2 * multiplier * (peasycap->width);
1067 w3 = bytesperpixel * \
1068                 multiplier * \
1069                 (peasycap->width);
1070 wz = multiplier * \
1071                 (peasycap->height) * \
1072                 multiplier * \
1073                 (peasycap->width);
1074
1075 kex = peasycap->field_read;  mex = 0;
1076 kad = peasycap->frame_fill;  mad = 0;
1077
1078 pex = peasycap->field_buffer[kex][0].pgo;  rex = PAGE_SIZE;
1079 pad = peasycap->frame_buffer[kad][0].pgo;  rad = PAGE_SIZE;
1080 if (peasycap->field_buffer[kex][0].kount)
1081         odd = true;
1082 else
1083         odd = false;
1084
1085 if ((true == odd) && (false == offerfields) &&(false == decimatepixel)) {
1086         JOT(8, "  initial skipping    %4i          bytes p.%4i\n", \
1087                                                         w3/multiplier, mad);
1088         pad += (w3 / multiplier);  rad -= (w3 / multiplier);
1089 }
1090 isuy = true;
1091 mask = 0;  rump = 0;  caches = 0;
1092
1093 cz = 0;
1094 while (cz < wz) {
1095         /*-------------------------------------------------------------------*/
1096         /*
1097         **  PROCESS ONE LINE OF FRAME AT FULL RESOLUTION:
1098         **  READ   w2   BYTES FROM FIELD BUFFER,
1099         **  WRITE  w3   BYTES TO FRAME BUFFER
1100         **/
1101         /*-------------------------------------------------------------------*/
1102         if (false == decimatepixel) {
1103                 over = w2;
1104                 do {
1105                         much = over;  more = 0;  margin = 0;  mask = 0x00;
1106                         if (rex < much)
1107                                 much = rex;
1108                         rump = 0;
1109
1110                         if (much % 2) {
1111                                 SAY("MISTAKE: much is odd\n");
1112                                 return -EFAULT;
1113                         }
1114
1115                         more = (bytesperpixel * \
1116                                         much) / 2;
1117 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1118                         if (1 < bytesperpixel) {
1119                                 if ((rad * \
1120                                         2) < (much * \
1121                                                 bytesperpixel)) {
1122                                         /*
1123                                         **   INJUDICIOUS ALTERATION OF THIS
1124                                         **   BLOCK WILL CAUSE BREAKAGE.
1125                                         **   BEWARE.
1126                                         **/
1127                                         rad2 = rad + bytesperpixel - 1;
1128                                         much = ((((2 * \
1129                                                 rad2)/bytesperpixel)/2) * 2);
1130                                         rump = ((bytesperpixel * \
1131                                                         much) / 2) - rad;
1132                                         more = rad;
1133                                         }
1134                                 mask = (__u8)rump;
1135                                 margin = 0;
1136                                 if (much == rex) {
1137                                         mask |= 0x04;
1138                                         if ((mex + 1) < FIELD_BUFFER_SIZE/ \
1139                                                                 PAGE_SIZE) {
1140                                                 margin = *((__u8 *)(peasycap->\
1141                                                         field_buffer\
1142                                                         [kex][mex + 1].pgo));
1143                                         } else
1144                                                 mask |= 0x08;
1145                                 }
1146 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1147                         } else {
1148                                 SAY("MISTAKE: %i=bytesperpixel\n", \
1149                                                 bytesperpixel);
1150                                 return -EFAULT;
1151                         }
1152 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1153                         if (rump)
1154                                 caches++;
1155
1156                         rc = redaub(peasycap, pad, pex, much, more, \
1157                                                         mask, margin, isuy);
1158                         if (0 > rc) {
1159                                 SAY("ERROR: redaub() failed\n");
1160                                 return -EFAULT;
1161                         }
1162                         if (much % 4) {
1163                                 if (isuy)
1164                                         isuy = false;
1165                                 else
1166                                         isuy = true;
1167                         }
1168                         over -= much;   cz += much;
1169                         pex  += much;  rex -= much;
1170                         if (!rex) {
1171                                 mex++;
1172                                 pex = peasycap->field_buffer[kex][mex].pgo;
1173                                 rex = PAGE_SIZE;
1174                         }
1175                         pad  += more;
1176                         rad -= more;
1177                         if (!rad) {
1178                                 mad++;
1179                                 pad = peasycap->frame_buffer[kad][mad].pgo;
1180                                 rad = PAGE_SIZE;
1181                                 if (rump) {
1182                                         pad += rump;
1183                                         rad -= rump;
1184                                 }
1185                         }
1186                 } while (over);
1187 /*---------------------------------------------------------------------------*/
1188 /*
1189  *  SKIP  w3 BYTES IN TARGET FRAME BUFFER,
1190  *  UNLESS IT IS THE LAST LINE OF AN ODD FRAME
1191  */
1192 /*---------------------------------------------------------------------------*/
1193                 if (((false == odd) || (cz != wz))&&(false == offerfields)) {
1194                         over = w3;
1195                         do {
1196                                 if (!rad) {
1197                                         mad++;
1198                                         pad = peasycap->frame_buffer\
1199                                                 [kad][mad].pgo;
1200                                         rad = PAGE_SIZE;
1201                                 }
1202                                 more = over;
1203                                 if (rad < more)
1204                                         more = rad;
1205                                 over -= more;
1206                                 pad  += more;
1207                                 rad  -= more;
1208                         } while (over);
1209                 }
1210 /*---------------------------------------------------------------------------*/
1211 /*
1212  *  PROCESS ONE LINE OF FRAME AT REDUCED RESOLUTION:
1213  *  ONLY IF false==odd,
1214  *  READ   w2   BYTES FROM FIELD BUFFER,
1215  *  WRITE  w3 / 2  BYTES TO FRAME BUFFER
1216  */
1217 /*---------------------------------------------------------------------------*/
1218         } else if (false == odd) {
1219                 over = w2;
1220                 do {
1221                         much = over;  more = 0;  margin = 0;  mask = 0x00;
1222                         if (rex < much)
1223                                 much = rex;
1224                         rump = 0;
1225
1226                         if (much % 2) {
1227                                 SAY("MISTAKE: much is odd\n");
1228                                 return -EFAULT;
1229                         }
1230
1231                         more = (bytesperpixel * \
1232                                         much) / 4;
1233 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1234                         if (1 < bytesperpixel) {
1235                                 if ((rad * 4) < (much * \
1236                                                 bytesperpixel)) {
1237                                         /*
1238                                         **   INJUDICIOUS ALTERATION OF THIS
1239                                         **   BLOCK WILL CAUSE BREAKAGE.
1240                                         **   BEWARE.
1241                                         **/
1242                                         rad2 = rad + bytesperpixel - 1;
1243                                         much = ((((2 * rad2)/bytesperpixel)/2)\
1244                                                                         * 4);
1245                                         rump = ((bytesperpixel * \
1246                                                         much) / 4) - rad;
1247                                         more = rad;
1248                                         }
1249                                 mask = (__u8)rump;
1250                                 margin = 0;
1251                                 if (much == rex) {
1252                                         mask |= 0x04;
1253                                         if ((mex + 1) < FIELD_BUFFER_SIZE/ \
1254                                                                 PAGE_SIZE) {
1255                                                 margin = *((__u8 *)(peasycap->\
1256                                                         field_buffer\
1257                                                         [kex][mex + 1].pgo));
1258                                                 }
1259                                         else
1260                                                 mask |= 0x08;
1261                                         }
1262 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1263                                 } else {
1264                                         SAY("MISTAKE: %i=bytesperpixel\n", \
1265                                                 bytesperpixel);
1266                                         return -EFAULT;
1267                                 }
1268 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1269                         if (rump)
1270                                 caches++;
1271
1272                         rc = redaub(peasycap, pad, pex, much, more, \
1273                                                         mask, margin, isuy);
1274                         if (0 > rc) {
1275                                 SAY("ERROR: redaub() failed\n");
1276                                 return -EFAULT;
1277                         }
1278                         over -= much;   cz += much;
1279                         pex  += much;  rex -= much;
1280                         if (!rex) {
1281                                 mex++;
1282                                 pex = peasycap->field_buffer[kex][mex].pgo;
1283                                 rex = PAGE_SIZE;
1284                         }
1285                         pad  += more;
1286                         rad -= more;
1287                         if (!rad) {
1288                                 mad++;
1289                                 pad = peasycap->frame_buffer[kad][mad].pgo;
1290                                 rad = PAGE_SIZE;
1291                                 if (rump) {
1292                                         pad += rump;
1293                                         rad -= rump;
1294                                 }
1295                         }
1296                 } while (over);
1297 /*---------------------------------------------------------------------------*/
1298 /*
1299  *  OTHERWISE JUST
1300  *  READ   w2   BYTES FROM FIELD BUFFER AND DISCARD THEM
1301  */
1302 /*---------------------------------------------------------------------------*/
1303         } else {
1304                 over = w2;
1305                 do {
1306                         if (!rex) {
1307                                 mex++;
1308                                 pex = peasycap->field_buffer[kex][mex].pgo;
1309                                 rex = PAGE_SIZE;
1310                         }
1311                         much = over;
1312                         if (rex < much)
1313                                 much = rex;
1314                         over -= much;
1315                         cz += much;
1316                         pex  += much;
1317                         rex -= much;
1318                 } while (over);
1319         }
1320 }
1321 /*---------------------------------------------------------------------------*/
1322 /*
1323  *  SANITY CHECKS
1324  */
1325 /*---------------------------------------------------------------------------*/
1326 c2 = (mex + 1)*PAGE_SIZE - rex;
1327 if (cz != c2)
1328         SAY("ERROR: discrepancy %i in bytes read\n", c2 - cz);
1329 c3 = (mad + 1)*PAGE_SIZE - rad;
1330
1331 if (false == decimatepixel) {
1332         if (bytesperpixel * \
1333                 cz != c3) \
1334                 SAY("ERROR: discrepancy %i in bytes written\n", \
1335                                                 c3 - (bytesperpixel * \
1336                                                                         cz));
1337 } else {
1338         if (false == odd) {
1339                 if (bytesperpixel * \
1340                         cz != (4 * c3))
1341                         SAY("ERROR: discrepancy %i in bytes written\n", \
1342                                                 (2*c3)-(bytesperpixel * \
1343                                                                         cz));
1344                 } else {
1345                         if (0 != c3)
1346                                 SAY("ERROR: discrepancy %i " \
1347                                                 "in bytes written\n", c3);
1348                 }
1349 }
1350 if (rump)
1351         SAY("ERROR: undischarged cache at end of line in frame buffer\n");
1352
1353 JOT(8, "===== field2frame(): %i bytes --> %i bytes (incl skip)\n", c2, c3);
1354 JOT(8, "===== field2frame(): %i=mad  %i=rad\n", mad, rad);
1355
1356 if (true == odd)
1357         JOT(8, "+++++ field2frame():  frame buffer %i is full\n", kad);
1358
1359 if (peasycap->field_read == peasycap->field_fill)
1360         SAY("WARNING: on exit, filling field buffer %i\n", \
1361                                                         peasycap->field_read);
1362 /*---------------------------------------------------------------------------*/
1363 /*
1364  *  CALCULATE VIDEO STREAMING RATE
1365  */
1366 /*---------------------------------------------------------------------------*/
1367 do_gettimeofday(&timeval);
1368 if (timeval0.tv_sec) {
1369         below = ((long long int)(1000000)) * \
1370                 ((long long int)(timeval.tv_sec  - timeval0.tv_sec)) + \
1371                          (long long int)(timeval.tv_usec - timeval0.tv_usec);
1372         above = (long long int)1000000;
1373
1374         sdr = signed_div(above, below);
1375         above = sdr.quotient;
1376         remainder = (__u32)sdr.remainder;
1377
1378         JOT(8, "video streaming at %3lli.%03i fields per second\n", above, \
1379                                                         (remainder/1000));
1380 }
1381 timeval0 = timeval;
1382
1383 if (caches)
1384         JOT(8, "%i=caches\n", caches);
1385 return 0;
1386 }
1387 /*****************************************************************************/
1388 struct signed_div_result
1389 signed_div(long long int above, long long int below)
1390 {
1391 struct signed_div_result sdr;
1392
1393 if (((0 <= above) && (0 <= below)) || ((0  > above) && (0  > below))) {
1394         sdr.remainder = (unsigned long long int) do_div(above, below);
1395         sdr.quotient  = (long long int) above;
1396 } else {
1397         if (0 > above)
1398                 above = -above;
1399         if (0 > below)
1400                 below = -below;
1401         sdr.remainder = (unsigned long long int) do_div(above, below);
1402         sdr.quotient  = -((long long int) above);
1403 }
1404 return sdr;
1405 }
1406 /*****************************************************************************/
1407 /*---------------------------------------------------------------------------*/
1408 /*
1409  *  DECIMATION AND COLOURSPACE CONVERSION.
1410  *
1411  *  THIS ROUTINE REQUIRES THAT ALL THE DATA TO BE READ RESIDES ON ONE PAGE
1412  *  AND THAT ALL THE DATA TO BE WRITTEN RESIDES ON ONE (DIFFERENT) PAGE.
1413  *  THE CALLING ROUTINE MUST ENSURE THAT THIS REQUIREMENT IS MET, AND MUST
1414  *  ALSO ENSURE THAT much IS EVEN.
1415  *
1416  *  much BYTES ARE READ, AT LEAST (bytesperpixel * much)/2 BYTES ARE WRITTEN
1417  *  IF THERE IS NO DECIMATION, HALF THIS AMOUNT IF THERE IS DECIMATION.
1418  *
1419  *  mask IS ZERO WHEN NO SPECIAL BEHAVIOUR REQUIRED. OTHERWISE IT IS SET THUS:
1420  *     0x03 & mask =  number of bytes to be written to cache instead of to
1421  *                    frame buffer
1422  *     0x04 & mask => use argument margin to set the chrominance for last pixel
1423  *     0x08 & mask => do not set the chrominance for last pixel
1424  *
1425  *  YUV to RGB CONVERSION IS (OR SHOULD BE) ITU-R BT 601.
1426  *
1427  *  THERE IS A LOT OF CODE REPETITION IN THIS ROUTINE IN ORDER TO AVOID
1428  *  INEFFICIENT SWITCHING INSIDE INNER LOOPS.  REARRANGING THE LOGIC TO
1429  *  REDUCE CODE LENGTH WILL GENERALLY IMPAIR RUNTIME PERFORMANCE.  BEWARE.
1430  */
1431 /*---------------------------------------------------------------------------*/
1432 int
1433 redaub(struct easycap *peasycap, void *pad, void *pex, int much, int more, \
1434                                         __u8 mask, __u8 margin, bool isuy)
1435 {
1436 static __s32 ay[256], bu[256], rv[256], gu[256], gv[256];
1437 static __u8 cache[8], *pcache;
1438 __u8 r, g, b, y, u, v, c, *p2, *p3, *pz, *pr;
1439 int  bytesperpixel;
1440 bool byteswaporder, decimatepixel, last;
1441 int j, rump;
1442 __s32 s32;
1443
1444 if (much % 2) {
1445         SAY("MISTAKE: much is odd\n");
1446         return -EFAULT;
1447 }
1448 bytesperpixel = peasycap->bytesperpixel;
1449 byteswaporder = peasycap->byteswaporder;
1450 decimatepixel = peasycap->decimatepixel;
1451
1452 /*---------------------------------------------------------------------------*/
1453 if (!bu[255]) {
1454         for (j = 0; j < 112; j++) {
1455                 s32 = (0xFF00 & (453 * j)) >> 8;
1456                 bu[j + 128] =  s32; bu[127 - j] = -s32;
1457                 s32 = (0xFF00 & (359 * j)) >> 8;
1458                 rv[j + 128] =  s32; rv[127 - j] = -s32;
1459                 s32 = (0xFF00 & (88 * j)) >> 8;
1460                 gu[j + 128] =  s32; gu[127 - j] = -s32;
1461                 s32 = (0xFF00 & (183 * j)) >> 8;
1462                 gv[j + 128] =  s32; gv[127 - j] = -s32;
1463         }
1464         for (j = 0; j < 16; j++) {
1465                 bu[j] = bu[16]; rv[j] = rv[16];
1466                 gu[j] = gu[16]; gv[j] = gv[16];
1467         }
1468         for (j = 240; j < 256; j++) {
1469                 bu[j] = bu[239]; rv[j] = rv[239];
1470                 gu[j] = gu[239]; gv[j] = gv[239];
1471         }
1472         for (j =  16; j < 236; j++)
1473                 ay[j] = j;
1474         for (j =   0; j <  16; j++)
1475                 ay[j] = ay[16];
1476         for (j = 236; j < 256; j++)
1477                 ay[j] = ay[235];
1478         JOT(8, "lookup tables are prepared\n");
1479 }
1480 if ((__u8 *)NULL == pcache)
1481         pcache = &cache[0];
1482 /*---------------------------------------------------------------------------*/
1483 /*
1484  *  TRANSFER CONTENTS OF CACHE TO THE FRAME BUFFER
1485  */
1486 /*---------------------------------------------------------------------------*/
1487 if (!pcache) {
1488         SAY("MISTAKE: pcache is NULL\n");
1489         return -EFAULT;
1490 }
1491
1492 if (pcache != &cache[0])
1493         JOT(16, "cache has %i bytes\n", (int)(pcache - &cache[0]));
1494 p2 = &cache[0];
1495 p3 = (__u8 *)pad - (int)(pcache - &cache[0]);
1496 while (p2 < pcache) {
1497         *p3++ = *p2;  p2++;
1498 }
1499 pcache = &cache[0];
1500 if (p3 != pad) {
1501         SAY("MISTAKE: pointer misalignment\n");
1502         return -EFAULT;
1503 }
1504 /*---------------------------------------------------------------------------*/
1505 rump = (int)(0x03 & mask);
1506 u = 0; v = 0;
1507 p2 = (__u8 *)pex;  pz = p2 + much;  pr = p3 + more;  last = false;
1508 p2++;
1509
1510 if (true == isuy)
1511         u = *(p2 - 1);
1512 else
1513         v = *(p2 - 1);
1514
1515 if (rump)
1516         JOT(16, "%4i=much  %4i=more  %i=rump\n", much, more, rump);
1517
1518 /*---------------------------------------------------------------------------*/
1519 switch (bytesperpixel) {
1520 case 2: {
1521         if (false == decimatepixel) {
1522                 memcpy(pad, pex, (size_t)much);
1523                 if (false == byteswaporder)
1524                         /*---------------------------------------------------*/
1525                         /*
1526                         **  UYVY
1527                         */
1528                         /*---------------------------------------------------*/
1529                         return 0;
1530                 else {
1531                         /*---------------------------------------------------*/
1532                         /*
1533                         **  YUYV
1534                         */
1535                         /*---------------------------------------------------*/
1536                         p3 = (__u8 *)pad;  pz = p3 + much;
1537                         while  (pz > p3) {
1538                                 c = *p3;
1539                                 *p3 = *(p3 + 1);
1540                                 *(p3 + 1) = c;
1541                                 p3 += 2;
1542                         }
1543                         return 0;
1544                 }
1545         } else {
1546                 if (false == byteswaporder) {
1547                         /*---------------------------------------------------*/
1548                         /*
1549                         **  UYVY DECIMATED
1550                         */
1551                         /*---------------------------------------------------*/
1552                         p2 = (__u8 *)pex;  p3 = (__u8 *)pad;  pz = p2 + much;
1553                         while (pz > p2) {
1554                                 *p3 = *p2;
1555                                 *(p3 + 1) = *(p2 + 1);
1556                                 *(p3 + 2) = *(p2 + 2);
1557                                 *(p3 + 3) = *(p2 + 3);
1558                                 p3 += 4;  p2 += 8;
1559                         }
1560                         return 0;
1561                 } else {
1562                         /*---------------------------------------------------*/
1563                         /*
1564                         **  YUYV DECIMATED
1565                         **/
1566                         /*---------------------------------------------------*/
1567                         p2 = (__u8 *)pex;  p3 = (__u8 *)pad;  pz = p2 + much;
1568                         while (pz > p2) {
1569                                 *p3 = *(p2 + 1);
1570                                 *(p3 + 1) = *p2;
1571                                 *(p3 + 2) = *(p2 + 3);
1572                                 *(p3 + 3) = *(p2 + 2);
1573                                 p3 += 4;  p2 += 8;
1574                         }
1575                         return 0;
1576                 }
1577         }
1578         break;
1579         }
1580 case 3:
1581         {
1582         if (false == decimatepixel) {
1583                 if (false == byteswaporder) {
1584                         /*---------------------------------------------------*/
1585                         /*
1586                         **  RGB
1587                         **/
1588                         /*---------------------------------------------------*/
1589                         while (pz > p2) {
1590                                 if (pr <= (p3 + bytesperpixel))
1591                                         last = true;
1592                                 else
1593                                         last = false;
1594                                 y = *p2;
1595                                 if ((true == last) && (0x0C & mask)) {
1596                                         if (0x04 & mask) {
1597                                                 if (true == isuy)
1598                                                         v = margin;
1599                                                 else
1600                                                         u = margin;
1601                                         } else
1602                                                 if (0x08 & mask)
1603                                                         ;
1604                                 } else {
1605                                         if (true == isuy)
1606                                                 v = *(p2 + 1);
1607                                         else
1608                                                 u = *(p2 + 1);
1609                                 }
1610
1611                                 s32 = ay[(int)y] + rv[(int)v];
1612                                 r = (255 < s32) ? 255 : ((0 > s32) ? \
1613                                                         0 : (__u8)s32);
1614                                 s32 = ay[(int)y] - gu[(int)u] - gv[(int)v];
1615                                 g = (255 < s32) ? 255 : ((0 > s32) ? \
1616                                                         0 : (__u8)s32);
1617                                 s32 = ay[(int)y] + bu[(int)u];
1618                                 b = (255 < s32) ? 255 : ((0 > s32) ? \
1619                                                         0 : (__u8)s32);
1620
1621                                 if ((true == last) && rump) {
1622                                         pcache = &cache[0];
1623                                         switch (bytesperpixel - rump) {
1624                                         case 1: {
1625                                                 *p3 = r;
1626                                                 *pcache++ = g;
1627                                                 *pcache++ = b;
1628                                                 break;
1629                                         }
1630                                         case 2: {
1631                                                 *p3 = r;
1632                                                 *(p3 + 1) = g;
1633                                                 *pcache++ = b;
1634                                                 break;
1635                                         }
1636                                         default: {
1637                                                 SAY("MISTAKE: %i=rump\n", \
1638                                                         bytesperpixel - rump);
1639                                                 return -EFAULT;
1640                                         }
1641                                         }
1642                                 } else {
1643                                         *p3 = r;
1644                                         *(p3 + 1) = g;
1645                                         *(p3 + 2) = b;
1646                                 }
1647                                 p2 += 2;
1648                                 if (true == isuy)
1649                                         isuy = false;
1650                                 else
1651                                         isuy = true;
1652                                 p3 += bytesperpixel;
1653                         }
1654                         return 0;
1655                 } else {
1656                         /*---------------------------------------------------*/
1657                         /*
1658                         **  BGR
1659                         */
1660                         /*---------------------------------------------------*/
1661                         while (pz > p2) {
1662                                 if (pr <= (p3 + bytesperpixel))
1663                                         last = true;
1664                                 else
1665                                         last = false;
1666                                 y = *p2;
1667                                 if ((true == last) && (0x0C & mask)) {
1668                                         if (0x04 & mask) {
1669                                                 if (true == isuy)
1670                                                         v = margin;
1671                                                 else
1672                                                         u = margin;
1673                                         }
1674                                 else
1675                                         if (0x08 & mask)
1676                                                 ;
1677                                 } else {
1678                                         if (true == isuy)
1679                                                 v = *(p2 + 1);
1680                                         else
1681                                                 u = *(p2 + 1);
1682                                 }
1683
1684                                 s32 = ay[(int)y] + rv[(int)v];
1685                                 r = (255 < s32) ? 255 : ((0 > s32) ? \
1686                                                                 0 : (__u8)s32);
1687                                 s32 = ay[(int)y] - gu[(int)u] - gv[(int)v];
1688                                 g = (255 < s32) ? 255 : ((0 > s32) ? \
1689                                                                 0 : (__u8)s32);
1690                                 s32 = ay[(int)y] + bu[(int)u];
1691                                 b = (255 < s32) ? 255 : ((0 > s32) ? \
1692                                                                 0 : (__u8)s32);
1693
1694                                 if ((true == last) && rump) {
1695                                         pcache = &cache[0];
1696                                         switch (bytesperpixel - rump) {
1697                                         case 1: {
1698                                                 *p3 = b;
1699                                                 *pcache++ = g;
1700                                                 *pcache++ = r;
1701                                                 break;
1702                                         }
1703                                         case 2: {
1704                                                 *p3 = b;
1705                                                 *(p3 + 1) = g;
1706                                                 *pcache++ = r;
1707                                                 break;
1708                                         }
1709                                         default: {
1710                                                 SAY("MISTAKE: %i=rump\n", \
1711                                                         bytesperpixel - rump);
1712                                                 return -EFAULT;
1713                                         }
1714                                         }
1715                                 } else {
1716                                         *p3 = b;
1717                                         *(p3 + 1) = g;
1718                                         *(p3 + 2) = r;
1719                                         }
1720                                 p2 += 2;
1721                                 if (true == isuy)
1722                                         isuy = false;
1723                                 else
1724                                         isuy = true;
1725                                 p3 += bytesperpixel;
1726                                 }
1727                         }
1728                 return 0;
1729         } else {
1730                 if (false == byteswaporder) {
1731                         /*---------------------------------------------------*/
1732                         /*
1733                         **  RGB DECIMATED
1734                         */
1735                         /*---------------------------------------------------*/
1736                         while (pz > p2) {
1737                                 if (pr <= (p3 + bytesperpixel))
1738                                         last = true;
1739                                 else
1740                                         last = false;
1741                                 y = *p2;
1742                                 if ((true == last) && (0x0C & mask)) {
1743                                         if (0x04 & mask) {
1744                                                 if (true == isuy)
1745                                                         v = margin;
1746                                                 else
1747                                                         u = margin;
1748                                         } else
1749                                                 if (0x08 & mask)
1750                                                         ;
1751                                 } else {
1752                                         if (true == isuy)
1753                                                 v = *(p2 + 1);
1754                                         else
1755                                                 u = *(p2 + 1);
1756                                 }
1757
1758                                 if (true == isuy) {
1759                                         s32 = ay[(int)y] + rv[(int)v];
1760                                         r = (255 < s32) ? 255 : ((0 > s32) ? \
1761                                                                 0 : (__u8)s32);
1762                                         s32 = ay[(int)y] - gu[(int)u] - \
1763                                                                 gv[(int)v];
1764                                         g = (255 < s32) ? 255 : ((0 > s32) ? \
1765                                                                 0 : (__u8)s32);
1766                                         s32 = ay[(int)y] + bu[(int)u];
1767                                         b = (255 < s32) ? 255 : ((0 > s32) ? \
1768                                                                 0 : (__u8)s32);
1769
1770                                         if ((true == last) && rump) {
1771                                                 pcache = &cache[0];
1772                                                 switch (bytesperpixel - rump) {
1773                                                 case 1: {
1774                                                         *p3 = r;
1775                                                         *pcache++ = g;
1776                                                         *pcache++ = b;
1777                                                         break;
1778                                                 }
1779                                                 case 2: {
1780                                                         *p3 = r;
1781                                                         *(p3 + 1) = g;
1782                                                         *pcache++ = b;
1783                                                         break;
1784                                                 }
1785                                                 default: {
1786                                                         SAY("MISTAKE: " \
1787                                                         "%i=rump\n", \
1788                                                         bytesperpixel - rump);
1789                                                         return -EFAULT;
1790                                                 }
1791                                                 }
1792                                         } else {
1793                                                 *p3 = r;
1794                                                 *(p3 + 1) = g;
1795                                                 *(p3 + 2) = b;
1796                                         }
1797                                         isuy = false;
1798                                         p3 += bytesperpixel;
1799                                 } else {
1800                                         isuy = true;
1801                                 }
1802                                 p2 += 2;
1803                         }
1804                         return 0;
1805                 } else {
1806                         /*---------------------------------------------------*/
1807                         /*
1808                          *  BGR DECIMATED
1809                          */
1810                         /*---------------------------------------------------*/
1811                         while (pz > p2) {
1812                                 if (pr <= (p3 + bytesperpixel))
1813                                         last = true;
1814                                 else
1815                                         last = false;
1816                                 y = *p2;
1817                                 if ((true == last) && (0x0C & mask)) {
1818                                         if (0x04 & mask) {
1819                                                 if (true == isuy)
1820                                                         v = margin;
1821                                                 else
1822                                                         u = margin;
1823                                         } else
1824                                                 if (0x08 & mask)
1825                                                         ;
1826                                 } else {
1827                                         if (true == isuy)
1828                                                 v = *(p2 + 1);
1829                                         else
1830                                                 u = *(p2 + 1);
1831                                 }
1832
1833                                 if (true == isuy) {
1834
1835                                         s32 = ay[(int)y] + rv[(int)v];
1836                                         r = (255 < s32) ? 255 : ((0 > s32) ? \
1837                                                                 0 : (__u8)s32);
1838                                         s32 = ay[(int)y] - gu[(int)u] - \
1839                                                                 gv[(int)v];
1840                                         g = (255 < s32) ? 255 : ((0 > s32) ? \
1841                                                                 0 : (__u8)s32);
1842                                         s32 = ay[(int)y] + bu[(int)u];
1843                                         b = (255 < s32) ? 255 : ((0 > s32) ? \
1844                                                                 0 : (__u8)s32);
1845
1846                                         if ((true == last) && rump) {
1847                                                 pcache = &cache[0];
1848                                                 switch (bytesperpixel - rump) {
1849                                                 case 1: {
1850                                                         *p3 = b;
1851                                                         *pcache++ = g;
1852                                                         *pcache++ = r;
1853                                                         break;
1854                                                 }
1855                                                 case 2: {
1856                                                         *p3 = b;
1857                                                         *(p3 + 1) = g;
1858                                                         *pcache++ = r;
1859                                                         break;
1860                                                 }
1861                                                 default: {
1862                                                         SAY("MISTAKE: " \
1863                                                         "%i=rump\n", \
1864                                                         bytesperpixel - rump);
1865                                                         return -EFAULT;
1866                                                 }
1867                                                 }
1868                                         } else {
1869                                                 *p3 = b;
1870                                                 *(p3 + 1) = g;
1871                                                 *(p3 + 2) = r;
1872                                                 }
1873                                         isuy = false;
1874                                         p3 += bytesperpixel;
1875                                         }
1876                                 else
1877                                         isuy = true;
1878                                 p2 += 2;
1879                                 }
1880                         return 0;
1881                         }
1882                 }
1883         break;
1884         }
1885 case 4:
1886         {
1887         if (false == decimatepixel) {
1888                 if (false == byteswaporder) {
1889                         /*---------------------------------------------------*/
1890                         /*
1891                         **  RGBA
1892                         */
1893                         /*---------------------------------------------------*/
1894                         while (pz > p2) {
1895                                 if (pr <= (p3 + bytesperpixel))
1896                                         last = true;
1897                                 else
1898                                         last = false;
1899                                 y = *p2;
1900                                 if ((true == last) && (0x0C & mask)) {
1901                                         if (0x04 & mask) {
1902                                                 if (true == isuy)
1903                                                         v = margin;
1904                                                 else
1905                                                         u = margin;
1906                                         } else
1907                                                  if (0x08 & mask)
1908                                                         ;
1909                                 } else {
1910                                         if (true == isuy)
1911                                                 v = *(p2 + 1);
1912                                         else
1913                                                 u = *(p2 + 1);
1914                                 }
1915
1916                                 s32 = ay[(int)y] + rv[(int)v];
1917                                 r = (255 < s32) ? 255 : ((0 > s32) ? \
1918                                                                 0 : (__u8)s32);
1919                                 s32 = ay[(int)y] - gu[(int)u] - gv[(int)v];
1920                                 g = (255 < s32) ? 255 : ((0 > s32) ? \
1921                                                                 0 : (__u8)s32);
1922                                 s32 = ay[(int)y] + bu[(int)u];
1923                                 b = (255 < s32) ? 255 : ((0 > s32) ? \
1924                                                                 0 : (__u8)s32);
1925
1926                                 if ((true == last) && rump) {
1927                                         pcache = &cache[0];
1928                                         switch (bytesperpixel - rump) {
1929                                         case 1: {
1930                                                 *p3 = r;
1931                                                 *pcache++ = g;
1932                                                 *pcache++ = b;
1933                                                 *pcache++ = 0;
1934                                                 break;
1935                                         }
1936                                         case 2: {
1937                                                 *p3 = r;
1938                                                 *(p3 + 1) = g;
1939                                                 *pcache++ = b;
1940                                                 *pcache++ = 0;
1941                                                 break;
1942                                         }
1943                                         case 3: {
1944                                                 *p3 = r;
1945                                                 *(p3 + 1) = g;
1946                                                 *(p3 + 2) = b;
1947                                                 *pcache++ = 0;
1948                                                 break;
1949                                         }
1950                                         default: {
1951                                                 SAY("MISTAKE: %i=rump\n", \
1952                                                         bytesperpixel - rump);
1953                                                 return -EFAULT;
1954                                         }
1955                                         }
1956                                 } else {
1957                                         *p3 = r;
1958                                         *(p3 + 1) = g;
1959                                         *(p3 + 2) = b;
1960                                         *(p3 + 3) = 0;
1961                                 }
1962                                 p2 += 2;
1963                                 if (true == isuy)
1964                                         isuy = false;
1965                                 else
1966                                         isuy = true;
1967                                 p3 += bytesperpixel;
1968                         }
1969                         return 0;
1970                 } else {
1971                         /*---------------------------------------------------*/
1972                         /*
1973                         **  BGRA
1974                         */
1975                         /*---------------------------------------------------*/
1976                         while (pz > p2) {
1977                                 if (pr <= (p3 + bytesperpixel))
1978                                         last = true;
1979                                 else
1980                                         last = false;
1981                                 y = *p2;
1982                                 if ((true == last) && (0x0C & mask)) {
1983                                         if (0x04 & mask) {
1984                                                 if (true == isuy)
1985                                                         v = margin;
1986                                                 else
1987                                                         u = margin;
1988                                         } else
1989                                                  if (0x08 & mask)
1990                                                         ;
1991                                 } else {
1992                                         if (true == isuy)
1993                                                 v = *(p2 + 1);
1994                                         else
1995                                                 u = *(p2 + 1);
1996                                 }
1997
1998                                 s32 = ay[(int)y] + rv[(int)v];
1999                                 r = (255 < s32) ? 255 : ((0 > s32) ? \
2000                                                                 0 : (__u8)s32);
2001                                 s32 = ay[(int)y] - gu[(int)u] - gv[(int)v];
2002                                 g = (255 < s32) ? 255 : ((0 > s32) ? \
2003                                                                 0 : (__u8)s32);
2004                                 s32 = ay[(int)y] + bu[(int)u];
2005                                 b = (255 < s32) ? 255 : ((0 > s32) ? \
2006                                                                 0 : (__u8)s32);
2007
2008                                 if ((true == last) && rump) {
2009                                         pcache = &cache[0];
2010                                         switch (bytesperpixel - rump) {
2011                                         case 1: {
2012                                                 *p3 = b;
2013                                                 *pcache++ = g;
2014                                                 *pcache++ = r;
2015                                                 *pcache++ = 0;
2016                                                 break;
2017                                         }
2018                                         case 2: {
2019                                                 *p3 = b;
2020                                                 *(p3 + 1) = g;
2021                                                 *pcache++ = r;
2022                                                 *pcache++ = 0;
2023                                                 break;
2024                                         }
2025                                         case 3: {
2026                                                 *p3 = b;
2027                                                 *(p3 + 1) = g;
2028                                                 *(p3 + 2) = r;
2029                                                 *pcache++ = 0;
2030                                                 break;
2031                                         }
2032                                         default: {
2033                                                 SAY("MISTAKE: %i=rump\n", \
2034                                                         bytesperpixel - rump);
2035                                                 return -EFAULT;
2036                                         }
2037                                         }
2038                                 } else {
2039                                         *p3 = b;
2040                                         *(p3 + 1) = g;
2041                                         *(p3 + 2) = r;
2042                                         *(p3 + 3) = 0;
2043                                 }
2044                                 p2 += 2;
2045                                 if (true == isuy)
2046                                         isuy = false;
2047                                 else
2048                                         isuy = true;
2049                                 p3 += bytesperpixel;
2050                         }
2051                 }
2052                 return 0;
2053         } else {
2054                 if (false == byteswaporder) {
2055                         /*---------------------------------------------------*/
2056                         /*
2057                         **  RGBA DECIMATED
2058                         */
2059                         /*---------------------------------------------------*/
2060                         while (pz > p2) {
2061                                 if (pr <= (p3 + bytesperpixel))
2062                                         last = true;
2063                                 else
2064                                         last = false;
2065                                 y = *p2;
2066                                 if ((true == last) && (0x0C & mask)) {
2067                                         if (0x04 & mask) {
2068                                                 if (true == isuy)
2069                                                         v = margin;
2070                                                 else
2071                                                         u = margin;
2072                                         } else
2073                                                 if (0x08 & mask)
2074                                                         ;
2075                                 } else {
2076                                         if (true == isuy)
2077                                                 v = *(p2 + 1);
2078                                         else
2079                                                 u = *(p2 + 1);
2080                                 }
2081
2082                                 if (true == isuy) {
2083
2084                                         s32 = ay[(int)y] + rv[(int)v];
2085                                         r = (255 < s32) ? 255 : ((0 > s32) ? \
2086                                                                 0 : (__u8)s32);
2087                                         s32 = ay[(int)y] - gu[(int)u] - \
2088                                                                 gv[(int)v];
2089                                         g = (255 < s32) ? 255 : ((0 > s32) ? \
2090                                                                 0 : (__u8)s32);
2091                                         s32 = ay[(int)y] + bu[(int)u];
2092                                         b = (255 < s32) ? 255 : ((0 > s32) ? \
2093                                                                 0 : (__u8)s32);
2094
2095                                         if ((true == last) && rump) {
2096                                                 pcache = &cache[0];
2097                                                 switch (bytesperpixel - rump) {
2098                                                 case 1: {
2099                                                         *p3 = r;
2100                                                         *pcache++ = g;
2101                                                         *pcache++ = b;
2102                                                         *pcache++ = 0;
2103                                                         break;
2104                                                 }
2105                                                 case 2: {
2106                                                         *p3 = r;
2107                                                         *(p3 + 1) = g;
2108                                                         *pcache++ = b;
2109                                                         *pcache++ = 0;
2110                                                         break;
2111                                                 }
2112                                                 case 3: {
2113                                                         *p3 = r;
2114                                                         *(p3 + 1) = g;
2115                                                         *(p3 + 2) = b;
2116                                                         *pcache++ = 0;
2117                                                         break;
2118                                                 }
2119                                                 default: {
2120                                                         SAY("MISTAKE: " \
2121                                                         "%i=rump\n", \
2122                                                         bytesperpixel - \
2123                                                         rump);
2124                                                         return -EFAULT;
2125                                                         }
2126                                                 }
2127                                         } else {
2128                                                 *p3 = r;
2129                                                 *(p3 + 1) = g;
2130                                                 *(p3 + 2) = b;
2131                                                 *(p3 + 3) = 0;
2132                                                 }
2133                                         isuy = false;
2134                                         p3 += bytesperpixel;
2135                                 } else
2136                                         isuy = true;
2137                                 p2 += 2;
2138                         }
2139                         return 0;
2140                 } else {
2141                         /*---------------------------------------------------*/
2142                         /*
2143                         **  BGRA DECIMATED
2144                         */
2145                         /*---------------------------------------------------*/
2146                         while (pz > p2) {
2147                                 if (pr <= (p3 + bytesperpixel))
2148                                         last = true;
2149                                 else
2150                                         last = false;
2151                                 y = *p2;
2152                                 if ((true == last) && (0x0C & mask)) {
2153                                         if (0x04 & mask) {
2154                                                 if (true == isuy)
2155                                                         v = margin;
2156                                                 else
2157                                                         u = margin;
2158                                         } else
2159                                                 if (0x08 & mask)
2160                                                         ;
2161                                 } else {
2162                                         if (true == isuy)
2163                                                 v = *(p2 + 1);
2164                                         else
2165                                                 u = *(p2 + 1);
2166                                 }
2167
2168                                 if (true == isuy) {
2169                                         s32 = ay[(int)y] + rv[(int)v];
2170                                         r = (255 < s32) ? 255 : ((0 > s32) ? \
2171                                                                 0 : (__u8)s32);
2172                                         s32 = ay[(int)y] - gu[(int)u] - \
2173                                                                 gv[(int)v];
2174                                         g = (255 < s32) ? 255 : ((0 > s32) ? \
2175                                                                 0 : (__u8)s32);
2176                                         s32 = ay[(int)y] + bu[(int)u];
2177                                         b = (255 < s32) ? 255 : ((0 > s32) ? \
2178                                                                 0 : (__u8)s32);
2179
2180                                         if ((true == last) && rump) {
2181                                                 pcache = &cache[0];
2182                                                 switch (bytesperpixel - rump) {
2183                                                 case 1: {
2184                                                         *p3 = b;
2185                                                         *pcache++ = g;
2186                                                         *pcache++ = r;
2187                                                         *pcache++ = 0;
2188                                                         break;
2189                                                 }
2190                                                 case 2: {
2191                                                         *p3 = b;
2192                                                         *(p3 + 1) = g;
2193                                                         *pcache++ = r;
2194                                                         *pcache++ = 0;
2195                                                         break;
2196                                                 }
2197                                                 case 3: {
2198                                                         *p3 = b;
2199                                                         *(p3 + 1) = g;
2200                                                         *(p3 + 2) = r;
2201                                                         *pcache++ = 0;
2202                                                         break;
2203                                                 }
2204                                                 default: {
2205                                                         SAY("MISTAKE: " \
2206                                                         "%i=rump\n", \
2207                                                         bytesperpixel - rump);
2208                                                         return -EFAULT;
2209                                                 }
2210                                                 }
2211                                         } else {
2212                                                 *p3 = b;
2213                                                 *(p3 + 1) = g;
2214                                                 *(p3 + 2) = r;
2215                                                 *(p3 + 3) = 0;
2216                                         }
2217                                         isuy = false;
2218                                         p3 += bytesperpixel;
2219                                 } else
2220                                         isuy = true;
2221                                         p2 += 2;
2222                                 }
2223                                 return 0;
2224                         }
2225                 }
2226         break;
2227         }
2228 default: {
2229         SAY("MISTAKE: %i=bytesperpixel\n", bytesperpixel);
2230         return -EFAULT;
2231         }
2232 }
2233 return 0;
2234 }
2235 /*****************************************************************************/
2236 void
2237 debrief(struct easycap *peasycap)
2238 {
2239 if ((struct usb_device *)NULL != peasycap->pusb_device) {
2240         check_stk(peasycap->pusb_device);
2241         check_saa(peasycap->pusb_device);
2242         sayreadonly(peasycap);
2243         SAY("%i=peasycap->field_fill\n", peasycap->field_fill);
2244         SAY("%i=peasycap->field_read\n", peasycap->field_read);
2245         SAY("%i=peasycap->frame_fill\n", peasycap->frame_fill);
2246         SAY("%i=peasycap->frame_read\n", peasycap->frame_read);
2247 }
2248 return;
2249 }
2250 /*****************************************************************************/
2251 void
2252 sayreadonly(struct easycap *peasycap)
2253 {
2254 static int done;
2255 int got00, got1F, got60, got61, got62;
2256
2257 if ((!done) && ((struct usb_device *)NULL != peasycap->pusb_device)) {
2258         done = 1;
2259         got00 = read_saa(peasycap->pusb_device, 0x00);
2260         got1F = read_saa(peasycap->pusb_device, 0x1F);
2261         got60 = read_saa(peasycap->pusb_device, 0x60);
2262         got61 = read_saa(peasycap->pusb_device, 0x61);
2263         got62 = read_saa(peasycap->pusb_device, 0x62);
2264         SAY("0x%02X=reg0x00  0x%02X=reg0x1F\n", got00, got1F);
2265         SAY("0x%02X=reg0x60  0x%02X=reg0x61  0x%02X=reg0x62\n", \
2266                                                         got60, got61, got62);
2267 }
2268 return;
2269 }
2270 /*****************************************************************************/
2271 /*---------------------------------------------------------------------------*/
2272 /*
2273  *  SEE CORBET ET AL. "LINUX DEVICE DRIVERS", 3rd EDITION, PAGES 430-434
2274  */
2275 /*---------------------------------------------------------------------------*/
2276 int easycap_mmap(struct file *file, struct vm_area_struct *pvma)
2277 {
2278
2279 JOT(8, "\n");
2280
2281 pvma->vm_ops = &easycap_vm_ops;
2282 pvma->vm_flags |= VM_RESERVED;
2283 if (NULL != file)
2284         pvma->vm_private_data = file->private_data;
2285 easycap_vma_open(pvma);
2286 return 0;
2287 }
2288 /*****************************************************************************/
2289 void
2290 easycap_vma_open(struct vm_area_struct *pvma)
2291 {
2292 struct easycap *peasycap;
2293
2294 peasycap = pvma->vm_private_data;
2295 if (NULL != peasycap)
2296         peasycap->vma_many++;
2297
2298 JOT(8, "%i=peasycap->vma_many\n", peasycap->vma_many);
2299
2300 return;
2301 }
2302 /*****************************************************************************/
2303 void
2304 easycap_vma_close(struct vm_area_struct *pvma)
2305 {
2306 struct easycap *peasycap;
2307
2308 peasycap = pvma->vm_private_data;
2309 if (NULL != peasycap) {
2310         peasycap->vma_many--;
2311         JOT(8, "%i=peasycap->vma_many\n", peasycap->vma_many);
2312 }
2313 return;
2314 }
2315 /*****************************************************************************/
2316 int
2317 easycap_vma_fault(struct vm_area_struct *pvma, struct vm_fault *pvmf)
2318 {
2319 int k, m, retcode;
2320 void *pbuf;
2321 struct page *page;
2322 struct easycap *peasycap;
2323
2324 retcode = VM_FAULT_NOPAGE;
2325 pbuf = (void *)NULL;
2326 page = (struct page *)NULL;
2327
2328 if (NULL == pvma) {
2329         SAY("pvma is NULL\n");
2330         return retcode;
2331 }
2332 if (NULL == pvmf) {
2333         SAY("pvmf is NULL\n");
2334         return retcode;
2335 }
2336
2337 k = (pvmf->pgoff) / (FRAME_BUFFER_SIZE/PAGE_SIZE);
2338 m = (pvmf->pgoff) % (FRAME_BUFFER_SIZE/PAGE_SIZE);
2339
2340 if (!m)
2341         JOT(4, "%4i=k, %4i=m\n", k, m);
2342 else
2343         JOT(16, "%4i=k, %4i=m\n", k, m);
2344
2345 if ((0 > k) || (FRAME_BUFFER_MANY <= k)) {
2346         SAY("ERROR: buffer index %i out of range\n", k);
2347         return retcode;
2348 }
2349 if ((0 > m) || (FRAME_BUFFER_SIZE/PAGE_SIZE <= m)) {
2350         SAY("ERROR: page number  %i out of range\n", m);
2351         return retcode;
2352 }
2353 peasycap = pvma->vm_private_data;
2354 if (NULL == peasycap) {
2355         SAY("ERROR: peasycap is NULL\n");
2356         return retcode;
2357 }
2358 mutex_lock(&(peasycap->mutex_mmap_video[0]));
2359 /*---------------------------------------------------------------------------*/
2360 pbuf = peasycap->frame_buffer[k][m].pgo;
2361 if (NULL == pbuf) {
2362         SAY("ERROR:  pbuf is NULL\n");
2363         goto finish;
2364 }
2365 page = virt_to_page(pbuf);
2366 if (NULL == page) {
2367         SAY("ERROR:  page is NULL\n");
2368         goto finish;
2369 }
2370 get_page(page);
2371 /*---------------------------------------------------------------------------*/
2372 finish:
2373 mutex_unlock(&(peasycap->mutex_mmap_video[0]));
2374 if (NULL == page) {
2375         SAY("ERROR:  page is NULL after get_page(page)\n");
2376 } else {
2377         pvmf->page = page;
2378         retcode = VM_FAULT_MINOR;
2379 }
2380 return retcode;
2381 }
2382 /*****************************************************************************/
2383 /*---------------------------------------------------------------------------*/
2384 /*
2385  *  ON COMPLETION OF A VIDEO URB ITS DATA IS COPIED TO THE FIELD BUFFERS
2386  *  PROVIDED peasycap->video_idle IS ZER0.  REGARDLESS OF THIS BEING TRUE,
2387  *  IT IS RESUBMITTED PROVIDED peasycap->video_isoc_streaming IS NOT ZERO.
2388  *
2389  *  THIS FUNCTION IS AN INTERRUPT SERVICE ROUTINE AND MUST NOT SLEEP.
2390  *
2391  *  INFORMATION ABOUT THE VALIDITY OF THE CONTENTS OF THE FIELD BUFFER ARE
2392  *  STORED IN THE TWO-BYTE STATUS PARAMETER
2393  *        peasycap->field_buffer[peasycap->field_fill][0].kount
2394  *  NOTICE THAT THE INFORMATION IS STORED ONLY WITH PAGE 0 OF THE FIELD BUFFER.
2395  *
2396  *  THE LOWER BYTE CONTAINS THE FIELD PARITY BYTE FURNISHED BY THE SAA7113H
2397  *  CHIP.
2398  *
2399  *  THE UPPER BYTE IS ZERO IF NO PROBLEMS, OTHERWISE:
2400  *      0 != (kount & 0x8000)   => AT LEAST ONE URB COMPLETED WITH ERRORS
2401  *      0 != (kount & 0x4000)   => BUFFER HAS TOO MUCH DATA
2402  *      0 != (kount & 0x2000)   => BUFFER HAS NOT ENOUGH DATA
2403  *      0 != (kount & 0x0400)   => FIELD WAS SUBMITTED BY BRIDGER ROUTINE
2404  *      0 != (kount & 0x0200)   => FIELD BUFFER NOT YET CHECKED
2405  *      0 != (kount & 0x0100)   => BUFFER HAS TWO EXTRA BYTES - WHY?
2406  */
2407 /*---------------------------------------------------------------------------*/
2408 void
2409 easycap_complete(struct urb *purb)
2410 {
2411 static int mt;
2412 struct easycap *peasycap;
2413 struct data_buffer *pfield_buffer;
2414 char errbuf[16];
2415 int i, more, much, leap, rc, last;
2416 int videofieldamount;
2417 unsigned int override;
2418 int framestatus, framelength, frameactual, frameoffset;
2419 __u8 *pu;
2420 #if defined(BRIDGER)
2421 struct timeval timeval;
2422 long long usec;
2423 #endif /*BRIDGER*/
2424
2425 if (NULL == purb) {
2426         SAY("ERROR: easycap_complete(): purb is NULL\n");
2427         return;
2428 }
2429 peasycap = purb->context;
2430 if (NULL == peasycap) {
2431         SAY("ERROR: easycap_complete(): peasycap is NULL\n");
2432         return;
2433 }
2434
2435 if (peasycap->video_eof)
2436         return;
2437
2438 for (i = 0; i < VIDEO_ISOC_BUFFER_MANY; i++)
2439         if (purb->transfer_buffer == peasycap->video_isoc_buffer[i].pgo)
2440                 break;
2441 JOT(16, "%2i=urb\n", i);
2442 last = peasycap->video_isoc_sequence;
2443 if ((((VIDEO_ISOC_BUFFER_MANY - 1) == last) && \
2444                                                 (0 != i)) || \
2445         (((VIDEO_ISOC_BUFFER_MANY - 1) != last) && \
2446                                                 ((last + 1) != i))) {
2447         SAY("ERROR: out-of-order urbs %i,%i ... continuing\n", last, i);
2448 }
2449 peasycap->video_isoc_sequence = i;
2450
2451 if (peasycap->video_idle) {
2452         JOT(16, "%i=video_idle  %i=video_isoc_streaming\n", \
2453                         peasycap->video_idle, peasycap->video_isoc_streaming);
2454         if (peasycap->video_isoc_streaming) {
2455                 rc = usb_submit_urb(purb, GFP_ATOMIC);
2456                 if (0 != rc) {
2457                         SAY("ERROR: while %i=video_idle, " \
2458                                         "usb_submit_urb() failed with rc:\n", \
2459                                                         peasycap->video_idle);
2460                         switch (rc) {
2461                         case -ENOMEM: {
2462                                 SAY("ENOMEM\n");
2463                                 break;
2464                         }
2465                         case -ENODEV: {
2466                                 SAY("ENODEV\n");
2467                                 break;
2468                         }
2469                         case -ENXIO: {
2470                                 SAY("ENXIO\n");
2471                                 break;
2472                         }
2473                         case -EINVAL: {
2474                                 SAY("EINVAL\n");
2475                                 break;
2476                         }
2477                         case -EAGAIN: {
2478                                 SAY("EAGAIN\n");
2479                                 break;
2480                         }
2481                         case -EFBIG: {
2482                                 SAY("EFBIG\n");
2483                                 break;
2484                         }
2485                         case -EPIPE: {
2486                                 SAY("EPIPE\n");
2487                                 break;
2488                         }
2489                         case -EMSGSIZE: {
2490                                 SAY("EMSGSIZE\n");
2491                                 break;
2492                         }
2493                         case -ENOSPC: {
2494                                 SAY("ENOSPC\n");
2495                                 break;
2496                         }
2497                         default: {
2498                                 SAY("0x%08X\n", rc);
2499                                 break;
2500                         }
2501                         }
2502                 }
2503         }
2504 return;
2505 }
2506 override = 0;
2507 /*---------------------------------------------------------------------------*/
2508 if (FIELD_BUFFER_MANY <= peasycap->field_fill) {
2509         SAY("ERROR: bad peasycap->field_fill\n");
2510         return;
2511 }
2512 if (purb->status) {
2513         if ((-ESHUTDOWN == purb->status) || (-ENOENT == purb->status)) {
2514                 JOT(8, "urb status -ESHUTDOWN or -ENOENT\n");
2515                 return;
2516         }
2517
2518         (peasycap->field_buffer[peasycap->field_fill][0].kount) |= 0x8000 ;
2519         SAY("ERROR: bad urb status:\n");
2520         switch (purb->status) {
2521         case -EINPROGRESS: {
2522                 SAY("-EINPROGRESS\n"); break;
2523         }
2524         case -ENOSR: {
2525                 SAY("-ENOSR\n"); break;
2526         }
2527         case -EPIPE: {
2528                 SAY("-EPIPE\n"); break;
2529         }
2530         case -EOVERFLOW: {
2531                 SAY("-EOVERFLOW\n"); break;
2532         }
2533         case -EPROTO: {
2534                 SAY("-EPROTO\n"); break;
2535         }
2536         case -EILSEQ: {
2537                 SAY("-EILSEQ\n"); break;
2538         }
2539         case -ETIMEDOUT: {
2540                 SAY("-ETIMEDOUT\n"); break;
2541         }
2542         case -EMSGSIZE: {
2543                 SAY("-EMSGSIZE\n"); break;
2544         }
2545         case -EOPNOTSUPP: {
2546                 SAY("-EOPNOTSUPP\n"); break;
2547         }
2548         case -EPFNOSUPPORT: {
2549                 SAY("-EPFNOSUPPORT\n"); break;
2550         }
2551         case -EAFNOSUPPORT: {
2552                 SAY("-EAFNOSUPPORT\n"); break;
2553         }
2554         case -EADDRINUSE: {
2555                 SAY("-EADDRINUSE\n"); break;
2556         }
2557         case -EADDRNOTAVAIL: {
2558                 SAY("-EADDRNOTAVAIL\n"); break;
2559         }
2560         case -ENOBUFS: {
2561                 SAY("-ENOBUFS\n"); break;
2562         }
2563         case -EISCONN: {
2564                 SAY("-EISCONN\n"); break;
2565         }
2566         case -ENOTCONN: {
2567                 SAY("-ENOTCONN\n"); break;
2568         }
2569         case -ESHUTDOWN: {
2570                 SAY("-ESHUTDOWN\n"); break;
2571         }
2572         case -ENOENT: {
2573                 SAY("-ENOENT\n"); break;
2574         }
2575         case -ECONNRESET: {
2576                 SAY("-ECONNRESET\n"); break;
2577         }
2578         case -ENOSPC: {
2579                 SAY("ENOSPC\n"); break;
2580         }
2581         default: {
2582                 SAY("unknown error code 0x%08X\n", purb->status); break;
2583         }
2584         }
2585 /*---------------------------------------------------------------------------*/
2586 } else {
2587         for (i = 0;  i < purb->number_of_packets; i++) {
2588                 if (0 != purb->iso_frame_desc[i].status) {
2589                         (peasycap->field_buffer\
2590                                 [peasycap->field_fill][0].kount) |= 0x8000 ;
2591                         switch (purb->iso_frame_desc[i].status) {
2592                         case  0: {
2593                                 strcpy(&errbuf[0], "OK"); break;
2594                         }
2595                         case -ENOENT: {
2596                                 strcpy(&errbuf[0], "-ENOENT"); break;
2597                         }
2598                         case -EINPROGRESS: {
2599                                 strcpy(&errbuf[0], "-EINPROGRESS"); break;
2600                         }
2601                         case -EPROTO: {
2602                                 strcpy(&errbuf[0], "-EPROTO"); break;
2603                         }
2604                         case -EILSEQ: {
2605                                 strcpy(&errbuf[0], "-EILSEQ"); break;
2606                         }
2607                         case -ETIME: {
2608                                 strcpy(&errbuf[0], "-ETIME"); break;
2609                         }
2610                         case -ETIMEDOUT: {
2611                                 strcpy(&errbuf[0], "-ETIMEDOUT"); break;
2612                         }
2613                         case -EPIPE: {
2614                                 strcpy(&errbuf[0], "-EPIPE"); break;
2615                         }
2616                         case -ECOMM: {
2617                                 strcpy(&errbuf[0], "-ECOMM"); break;
2618                         }
2619                         case -ENOSR: {
2620                                 strcpy(&errbuf[0], "-ENOSR"); break;
2621                         }
2622                         case -EOVERFLOW: {
2623                                 strcpy(&errbuf[0], "-EOVERFLOW"); break;
2624                         }
2625                         case -EREMOTEIO: {
2626                                 strcpy(&errbuf[0], "-EREMOTEIO"); break;
2627                         }
2628                         case -ENODEV: {
2629                                 strcpy(&errbuf[0], "-ENODEV"); break;
2630                         }
2631                         case -EXDEV: {
2632                                 strcpy(&errbuf[0], "-EXDEV"); break;
2633                         }
2634                         case -EINVAL: {
2635                                 strcpy(&errbuf[0], "-EINVAL"); break;
2636                         }
2637                         case -ECONNRESET: {
2638                                 strcpy(&errbuf[0], "-ECONNRESET"); break;
2639                         }
2640                         case -ENOSPC: {
2641                                 SAY("ENOSPC\n"); break;
2642                         }
2643                         case -ESHUTDOWN: {
2644                                 strcpy(&errbuf[0], "-ESHUTDOWN"); break;
2645                         }
2646                         default: {
2647                                 strcpy(&errbuf[0], "unknown error"); break;
2648                         }
2649                         }
2650                 }
2651                 framestatus = purb->iso_frame_desc[i].status;
2652                 framelength = purb->iso_frame_desc[i].length;
2653                 frameactual = purb->iso_frame_desc[i].actual_length;
2654                 frameoffset = purb->iso_frame_desc[i].offset;
2655
2656                 JOT(16, "frame[%2i]:" \
2657                                 "%4i=status "  \
2658                                 "%4i=actual "  \
2659                                 "%4i=length "  \
2660                                 "%5i=offset\n", \
2661                         i, framestatus, frameactual, framelength, frameoffset);
2662                 if (!purb->iso_frame_desc[i].status) {
2663                         more = purb->iso_frame_desc[i].actual_length;
2664                         pfield_buffer = &peasycap->field_buffer\
2665                                   [peasycap->field_fill][peasycap->field_page];
2666                         videofieldamount = (peasycap->field_page * \
2667                                 PAGE_SIZE) + \
2668                                 (int)(pfield_buffer->pto - pfield_buffer->pgo);
2669                 if (4 == more)
2670                         mt++;
2671                 if (4 < more) {
2672                         if (mt) {
2673                                 JOT(8, "%4i empty video urb frames\n", mt);
2674                                 mt = 0;
2675                         }
2676                         if (FIELD_BUFFER_MANY <= peasycap->field_fill) {
2677                                 SAY("ERROR: bad peasycap->field_fill\n");
2678                                 return;
2679                         }
2680                         if (FIELD_BUFFER_SIZE/PAGE_SIZE <= \
2681                                                         peasycap->field_page) {
2682                                 SAY("ERROR: bad peasycap->field_page\n");
2683                                 return;
2684                         }
2685                         pfield_buffer = &peasycap->field_buffer\
2686                                 [peasycap->field_fill][peasycap->field_page];
2687                         pu = (__u8 *)(purb->transfer_buffer + \
2688                                         purb->iso_frame_desc[i].offset);
2689                         if (0x80 & *pu)
2690                                 leap = 8;
2691                         else
2692                                 leap = 4;
2693 /*--------------------------------------------------------------------------*/
2694 /*
2695  *  EIGHT-BYTE END-OF-VIDEOFIELD MARKER.
2696  *  NOTE:  A SUCCESSION OF URB FRAMES FOLLOWING THIS ARE EMPTY,
2697  *         CORRESPONDING TO THE FIELD FLYBACK (VERTICAL BLANKING) PERIOD.
2698  *
2699  *  PROVIDED THE FIELD BUFFER CONTAINS GOOD DATA AS INDICATED BY A ZERO UPPER
2700  *  BYTE OF
2701  *        peasycap->field_buffer[peasycap->field_fill][0].kount
2702  *  THE CONTENTS OF THE FIELD BUFFER ARE OFFERED TO dqbuf(), field_read IS
2703  *  UPDATED AND field_fill IS BUMPED.  IF THE FIELD BUFFER CONTAINS BAD DATA
2704  *  NOTHING IS OFFERED TO dqbuf().
2705  *
2706  *  THE DECISION ON WHETHER THE PARITY OF THE OFFERED FIELD BUFFER IS RIGHT
2707  *  RESTS WITH dqbuf().
2708  */
2709 /*---------------------------------------------------------------------------*/
2710                         if ((8 == more) || override) {
2711                                 if (videofieldamount > \
2712                                                 peasycap->videofieldamount) {
2713                                         if (2 == videofieldamount - \
2714                                                         peasycap->\
2715                                                         videofieldamount)
2716                                                 (peasycap->field_buffer\
2717                                                 [peasycap->field_fill]\
2718                                                         [0].kount) |= 0x0100;
2719                                         else
2720                                                 (peasycap->field_buffer\
2721                                                 [peasycap->field_fill]\
2722                                                         [0].kount) |= 0x4000;
2723                                         } else if (videofieldamount < \
2724                                                         peasycap->\
2725                                                         videofieldamount) {
2726                                                 (peasycap->field_buffer\
2727                                                 [peasycap->field_fill]\
2728                                                         [0].kount) |= 0x2000;
2729                                         }
2730                                 if (!(0xFF00 & peasycap->field_buffer\
2731                                                 [peasycap->field_fill]\
2732                                                 [0].kount)) {
2733                                         (peasycap->video_junk)--;
2734                                         if (-16 > peasycap->video_junk)
2735                                                 peasycap->video_junk = -16;
2736                                         peasycap->field_read = \
2737                                                         (peasycap->\
2738                                                                 field_fill)++;
2739
2740                                         if (FIELD_BUFFER_MANY <= \
2741                                                 peasycap->field_fill)
2742                                                 peasycap->field_fill = 0;
2743                                         peasycap->field_page = 0;
2744                                         pfield_buffer = &peasycap->\
2745                                                 field_buffer\
2746                                                 [peasycap->field_fill]\
2747                                                 [peasycap->field_page];
2748                                         pfield_buffer->pto = \
2749                                                         pfield_buffer->pgo;
2750
2751                                         JOT(8, "bumped to: %i=peasycap->" \
2752                                                 "field_fill  %i=parity\n", \
2753                                                 peasycap->field_fill, \
2754                                                 0x00FF & pfield_buffer->kount);
2755                                         JOT(8, "field buffer %i has %i " \
2756                                                 "bytes fit to be read\n", \
2757                                                 peasycap->field_read, \
2758                                                 videofieldamount);
2759                                         JOT(8, "wakeup call to wq_video, " \
2760                                                 "%i=field_read %i=field_fill "\
2761                                                 "%i=parity\n", \
2762                                                 peasycap->field_read, \
2763                                                 peasycap->field_fill, \
2764                                                 0x00FF & peasycap->\
2765                                                 field_buffer[peasycap->\
2766                                                 field_read][0].kount);
2767                                         wake_up_interruptible(&(peasycap->\
2768                                                                 wq_video));
2769                                         do_gettimeofday(&peasycap->timeval7);
2770                                         } else {
2771                                         peasycap->video_junk++;
2772                                         JOT(8, "field buffer %i had %i " \
2773                                                 "bytes, now discarded\n", \
2774                                                 peasycap->field_fill, \
2775                                                 videofieldamount);
2776
2777                                         (peasycap->field_fill)++;
2778
2779                                         if (FIELD_BUFFER_MANY <= \
2780                                                         peasycap->field_fill)
2781                                                 peasycap->field_fill = 0;
2782                                         peasycap->field_page = 0;
2783                                         pfield_buffer = \
2784                                                 &peasycap->field_buffer\
2785                                                 [peasycap->field_fill]\
2786                                                 [peasycap->field_page];
2787                                         pfield_buffer->pto = \
2788                                                         pfield_buffer->pgo;
2789
2790                                         JOT(8, "bumped to: %i=peasycap->" \
2791                                                 "field_fill  %i=parity\n", \
2792                                                 peasycap->field_fill, \
2793                                                 0x00FF & pfield_buffer->kount);
2794                                 }
2795                                 if (8 == more) {
2796                                         JOT(8, "end-of-field: received " \
2797                                                 "parity byte 0x%02X\n", \
2798                                                 (0xFF & *pu));
2799                                         if (0x40 & *pu)
2800                                                 pfield_buffer->kount = 0x0000;
2801                                         else
2802                                                 pfield_buffer->kount = 0x0001;
2803                                         JOT(8, "end-of-field: 0x%02X=kount\n",\
2804                                                 0xFF & pfield_buffer->kount);
2805                                 }
2806                         }
2807 /*---------------------------------------------------------------------------*/
2808 /*
2809  *  COPY more BYTES FROM ISOC BUFFER TO FIELD BUFFER
2810  */
2811 /*---------------------------------------------------------------------------*/
2812                         pu += leap;
2813                         more -= leap;
2814
2815                         if (FIELD_BUFFER_MANY <= peasycap->field_fill) {
2816                                 SAY("ERROR: bad peasycap->field_fill\n");
2817                                 return;
2818                         }
2819                         if (FIELD_BUFFER_SIZE/PAGE_SIZE <= \
2820                                                         peasycap->field_page) {
2821                                 SAY("ERROR: bad peasycap->field_page\n");
2822                                 return;
2823                         }
2824                         pfield_buffer = &peasycap->field_buffer\
2825                                 [peasycap->field_fill][peasycap->field_page];
2826                         while (more) {
2827                                 pfield_buffer = &peasycap->field_buffer\
2828                                                 [peasycap->field_fill]\
2829                                                 [peasycap->field_page];
2830                                 if (PAGE_SIZE < (pfield_buffer->pto - \
2831                                                         pfield_buffer->pgo)) {
2832                                         SAY("ERROR: bad pfield_buffer->pto\n");
2833                                         return;
2834                                 }
2835                                 if (PAGE_SIZE == (pfield_buffer->pto - \
2836                                                         pfield_buffer->pgo)) {
2837                                         (peasycap->field_page)++;
2838                                         if (FIELD_BUFFER_SIZE/PAGE_SIZE <= \
2839                                                         peasycap->field_page) {
2840                                                 JOT(16, "wrapping peasycap->" \
2841                                                         "field_page\n");
2842                                                 peasycap->field_page = 0;
2843                                         }
2844                                         pfield_buffer = &peasycap->\
2845                                                         field_buffer\
2846                                                         [peasycap->field_fill]\
2847                                                         [peasycap->field_page];
2848                                         pfield_buffer->pto = \
2849                                                         pfield_buffer->pgo;
2850                                 }
2851
2852                                 much = PAGE_SIZE - (int)(pfield_buffer->pto - \
2853                                                         pfield_buffer->pgo);
2854
2855                                 if (much > more)
2856                                         much = more;
2857                                 memcpy(pfield_buffer->pto, pu, much);
2858                                 pu += much;
2859                                 (pfield_buffer->pto) += much;
2860                                 more -= much;
2861                                 }
2862                         }
2863                 }
2864         }
2865 }
2866 /*---------------------------------------------------------------------------*/
2867 /*
2868  *
2869  *
2870  *             *** UNDER DEVELOPMENT/TESTING - NOT READY YET! ***
2871  *
2872  *
2873  *
2874  *  VIDEOTAPES MAY HAVE BEEN MANUALLY PAUSED AND RESTARTED DURING RECORDING.
2875  *  THIS CAUSES LOSS OF SYNC, CONFUSING DOWNSTREAM USERSPACE PROGRAMS WHICH
2876  *  MAY INTERPRET THE INTERRUPTION AS A SYMPTOM OF LATENCY.  TO OVERCOME THIS
2877  *  THE DRIVER BRIDGES THE HIATUS BY SENDING DUMMY VIDEO FRAMES AT ROUGHLY
2878  *  THE RIGHT TIME INTERVALS IN THE HOPE OF PERSUADING THE DOWNSTREAM USERSPACE
2879  *  PROGRAM TO RESUME NORMAL SERVICE WHEN THE INTERRUPTION IS OVER.
2880  */
2881 /*---------------------------------------------------------------------------*/
2882 #if defined(BRIDGER)
2883 do_gettimeofday(&timeval);
2884 if (peasycap->timeval7.tv_sec) {
2885         usec = 1000000*(timeval.tv_sec  - peasycap->timeval7.tv_sec) + \
2886                         (timeval.tv_usec - peasycap->timeval7.tv_usec);
2887         if (usec > (peasycap->usec + peasycap->tolerate)) {
2888                 JOT(8, "bridging hiatus\n");
2889                 peasycap->video_junk = 0;
2890                 peasycap->field_buffer[peasycap->field_fill][0].kount |= 0x0400;
2891
2892                 peasycap->field_read = (peasycap->field_fill)++;
2893
2894                 if (FIELD_BUFFER_MANY <= peasycap->field_fill) \
2895                                                 peasycap->field_fill = 0;
2896                 peasycap->field_page = 0;
2897                 pfield_buffer = &peasycap->field_buffer\
2898                                 [peasycap->field_fill][peasycap->field_page];
2899                 pfield_buffer->pto = pfield_buffer->pgo;
2900
2901                 JOT(8, "bumped to: %i=peasycap->field_fill  %i=parity\n", \
2902                         peasycap->field_fill, 0x00FF & pfield_buffer->kount);
2903                 JOT(8, "field buffer %i has %i bytes to be overwritten\n", \
2904                         peasycap->field_read, videofieldamount);
2905                 JOT(8, "wakeup call to wq_video, " \
2906                         "%i=field_read %i=field_fill %i=parity\n", \
2907                         peasycap->field_read, peasycap->field_fill, \
2908                         0x00FF & \
2909                         peasycap->field_buffer[peasycap->field_read][0].kount);
2910                 wake_up_interruptible(&(peasycap->wq_video));
2911                 do_gettimeofday(&peasycap->timeval7);
2912         }
2913 }
2914 #endif /*BRIDGER*/
2915 /*---------------------------------------------------------------------------*/
2916 /*
2917  *  RESUBMIT THIS URB, UNLESS A SEVERE PERSISTENT ERROR CONDITION EXISTS.
2918  *
2919  *  IF THE WAIT QUEUES ARE NOT CLEARED IN RESPONSE TO AN ERROR CONDITION
2920  *  THE USERSPACE PROGRAM, E.G. mplayer, MAY HANG ON EXIT.   BEWARE.
2921  */
2922 /*---------------------------------------------------------------------------*/
2923 if (VIDEO_ISOC_BUFFER_MANY <= peasycap->video_junk) {
2924         SAY("easycap driver shutting down on condition green\n");
2925         peasycap->video_eof = 1;
2926         peasycap->audio_eof = 1;
2927         peasycap->video_junk = -VIDEO_ISOC_BUFFER_MANY;
2928         wake_up_interruptible(&(peasycap->wq_video));
2929         wake_up_interruptible(&(peasycap->wq_audio));
2930         return;
2931 }
2932 if (peasycap->video_isoc_streaming) {
2933         rc = usb_submit_urb(purb, GFP_ATOMIC);
2934         if (0 != rc) {
2935                 SAY("ERROR: while %i=video_idle, usb_submit_urb() failed " \
2936                                         "with rc:\n", peasycap->video_idle);
2937                 switch (rc) {
2938                 case -ENOMEM: {
2939                         SAY("ENOMEM\n"); break;
2940                 }
2941                 case -ENODEV: {
2942                         SAY("ENODEV\n"); break;
2943                 }
2944                 case -ENXIO: {
2945                         SAY("ENXIO\n"); break;
2946                 }
2947                 case -EINVAL: {
2948                         SAY("EINVAL\n"); break;
2949                 }
2950                 case -EAGAIN: {
2951                         SAY("EAGAIN\n"); break;
2952                 }
2953                 case -EFBIG: {
2954                         SAY("EFBIG\n"); break;
2955                 }
2956                 case -EPIPE: {
2957                         SAY("EPIPE\n"); break;
2958                 }
2959                 case -EMSGSIZE: {
2960                         SAY("EMSGSIZE\n");  break;
2961                 }
2962                 case -ENOSPC: {
2963                         SAY("ENOSPC\n"); break;
2964                 }
2965                 default: {
2966                         SAY("0x%08X\n", rc); break;
2967                 }
2968                 }
2969         }
2970 }
2971 return;
2972 }
2973 /*****************************************************************************/
2974 /*---------------------------------------------------------------------------*/
2975 /*
2976  *
2977  *                                  FIXME
2978  *
2979  *
2980  *  THIS FUNCTION ASSUMES THAT, ON EACH AND EVERY OCCASION THAT THE DEVICE IS
2981  *  PHYSICALLY PLUGGED IN, INTERFACE 0 IS PROBED FIRST.
2982  *  IF THIS IS NOT TRUE, THERE IS THE POSSIBILITY OF AN Oops.
2983  *
2984  *  THIS HAS NEVER BEEN A PROBLEM IN PRACTICE, BUT SOMETHING SEEMS WRONG HERE.
2985  */
2986 /*---------------------------------------------------------------------------*/
2987 int
2988 easycap_usb_probe(struct usb_interface *pusb_interface, \
2989                                                 const struct usb_device_id *id)
2990 {
2991 struct usb_device *pusb_device, *pusb_device1;
2992 struct usb_host_interface *pusb_host_interface;
2993 struct usb_endpoint_descriptor *pepd;
2994 struct usb_interface_descriptor *pusb_interface_descriptor;
2995 struct usb_interface_assoc_descriptor *pusb_interface_assoc_descriptor;
2996 struct urb *purb;
2997 static struct easycap *peasycap /*=NULL*/;
2998 struct data_urb *pdata_urb;
2999 size_t wMaxPacketSize;
3000 int ISOCwMaxPacketSize;
3001 int BULKwMaxPacketSize;
3002 int INTwMaxPacketSize;
3003 int CTRLwMaxPacketSize;
3004 __u8 bEndpointAddress;
3005 __u8 ISOCbEndpointAddress;
3006 __u8 INTbEndpointAddress;
3007 int isin, i, j, k, m;
3008 __u8 bInterfaceNumber;
3009 __u8 bInterfaceClass;
3010 __u8 bInterfaceSubClass;
3011 void *pbuf;
3012 int okalt[8], isokalt;
3013 int okepn[8], isokepn;
3014 int okmps[8], isokmps;
3015 int maxpacketsize;
3016 int rc;
3017
3018 JOT(4, "\n");
3019
3020 if ((struct usb_interface *)NULL == pusb_interface) {
3021         SAY("ERROR: pusb_interface is NULL\n");
3022         return -EFAULT;
3023 }
3024 /*---------------------------------------------------------------------------*/
3025 /*
3026  *  GET POINTER TO STRUCTURE usb_device
3027  */
3028 /*---------------------------------------------------------------------------*/
3029 pusb_device1 = container_of(pusb_interface->dev.parent, \
3030                                                 struct usb_device, dev);
3031 if ((struct usb_device *)NULL == pusb_device1) {
3032         SAY("ERROR: pusb_device1 is NULL\n");
3033         return -EFAULT;
3034 }
3035 pusb_device = usb_get_dev(pusb_device1);
3036 if ((struct usb_device *)NULL == pusb_device) {
3037         SAY("ERROR: pusb_device is NULL\n");
3038         return -EFAULT;
3039 }
3040 if ((unsigned long int)pusb_device1 != (unsigned long int)pusb_device) {
3041         JOT(4, "ERROR: pusb_device1 != pusb_device\n");
3042         return -EFAULT;
3043 }
3044
3045 JOT(4, "bNumConfigurations=%i\n", pusb_device->descriptor.bNumConfigurations);
3046
3047 /*---------------------------------------------------------------------------*/
3048 pusb_host_interface = pusb_interface->cur_altsetting;
3049 if (NULL == pusb_host_interface) {
3050         SAY("ERROR: pusb_host_interface is NULL\n");
3051         return -EFAULT;
3052 }
3053 pusb_interface_descriptor = &(pusb_host_interface->desc);
3054 if (NULL == pusb_interface_descriptor) {
3055         SAY("ERROR: pusb_interface_descriptor is NULL\n");
3056         return -EFAULT;
3057 }
3058 /*---------------------------------------------------------------------------*/
3059 /*
3060  *  GET PROPERTIES OF PROBED INTERFACE
3061  */
3062 /*---------------------------------------------------------------------------*/
3063 bInterfaceNumber = pusb_interface_descriptor->bInterfaceNumber;
3064 bInterfaceClass = pusb_interface_descriptor->bInterfaceClass;
3065 bInterfaceSubClass = pusb_interface_descriptor->bInterfaceSubClass;
3066
3067 JOT(4, "intf[%i]: pusb_interface->num_altsetting=%i\n", \
3068                         bInterfaceNumber, pusb_interface->num_altsetting);
3069 JOT(4, "intf[%i]: pusb_interface->cur_altsetting - " \
3070                         "pusb_interface->altsetting=%li\n", bInterfaceNumber, \
3071                         (long int)(pusb_interface->cur_altsetting - \
3072                                                 pusb_interface->altsetting));
3073 switch (bInterfaceClass) {
3074 case USB_CLASS_AUDIO: {
3075         JOT(4, "intf[%i]: bInterfaceClass=0x%02X=USB_CLASS_AUDIO\n", \
3076                                 bInterfaceNumber, bInterfaceClass); break;
3077         }
3078 case USB_CLASS_VIDEO: {
3079         JOT(4, "intf[%i]: bInterfaceClass=0x%02X=USB_CLASS_VIDEO\n", \
3080                                 bInterfaceNumber, bInterfaceClass); break;
3081         }
3082 case USB_CLASS_VENDOR_SPEC: {
3083         JOT(4, "intf[%i]: bInterfaceClass=0x%02X=USB_CLASS_VENDOR_SPEC\n", \
3084                                 bInterfaceNumber, bInterfaceClass); break;
3085         }
3086 default:
3087         break;
3088 }
3089 switch (bInterfaceSubClass) {
3090 case 0x01: {
3091         JOT(4, "intf[%i]: bInterfaceSubClass=0x%02X=AUDIOCONTROL\n", \
3092                         bInterfaceNumber, bInterfaceSubClass); break;
3093 }
3094 case 0x02: {
3095         JOT(4, "intf[%i]: bInterfaceSubClass=0x%02X=AUDIOSTREAMING\n", \
3096                         bInterfaceNumber, bInterfaceSubClass); break;
3097 }
3098 case 0x03: {
3099         JOT(4, "intf[%i]: bInterfaceSubClass=0x%02X=MIDISTREAMING\n", \
3100                         bInterfaceNumber, bInterfaceSubClass); break;
3101 }
3102 default:
3103         break;
3104 }
3105 /*---------------------------------------------------------------------------*/
3106 pusb_interface_assoc_descriptor = pusb_interface->intf_assoc;
3107 if (NULL != pusb_interface_assoc_descriptor) {
3108         JOT(4, "intf[%i]: bFirstInterface=0x%02X  bInterfaceCount=0x%02X\n", \
3109                         bInterfaceNumber, \
3110                         pusb_interface_assoc_descriptor->bFirstInterface, \
3111                         pusb_interface_assoc_descriptor->bInterfaceCount);
3112 } else {
3113 JOT(4, "intf[%i]: pusb_interface_assoc_descriptor is NULL\n", \
3114                                                         bInterfaceNumber);
3115 }
3116 /*---------------------------------------------------------------------------*/
3117 /*
3118  *  A NEW struct easycap IS ALWAYS ALLOCATED WHEN INTERFACE 0 IS PROBED.
3119  *  IT IS NOT POSSIBLE HERE TO FREE ANY EXISTING struct easycap.  THIS
3120  *  SHOULD HAVE BEEN DONE BY easycap_delete() WHEN THE DEVICE WAS PHYSICALLY
3121  *  UNPLUGGED.
3122  */
3123 /*---------------------------------------------------------------------------*/
3124 if (0 == bInterfaceNumber) {
3125         peasycap = kzalloc(sizeof(struct easycap), GFP_KERNEL);
3126         if (NULL == peasycap) {
3127                 SAY("ERROR: Could not allocate peasycap\n");
3128                 return -ENOMEM;
3129         } else {
3130                 peasycap->allocation_video_struct = sizeof(struct easycap);
3131                 peasycap->allocation_video_page = 0;
3132                 peasycap->allocation_video_urb = 0;
3133                 peasycap->allocation_audio_struct = 0;
3134                 peasycap->allocation_audio_page = 0;
3135                 peasycap->allocation_audio_urb = 0;
3136         }
3137 /*---------------------------------------------------------------------------*/
3138 /*
3139  *  INITIALIZE THE NEW easycap STRUCTURE.
3140  *  NO PARAMETERS ARE SPECIFIED HERE REQUIRING THE SETTING OF REGISTERS.
3141  *  THAT IS DONE FIRST BY easycap_open() AND LATER BY easycap_ioctl().
3142  */
3143 /*---------------------------------------------------------------------------*/
3144         peasycap->pusb_device = pusb_device;
3145         peasycap->pusb_interface = pusb_interface;
3146
3147         kref_init(&peasycap->kref);
3148         JOT(8, "intf[%i]: after kref_init(..._video) " \
3149                         "%i=peasycap->kref.refcount.counter\n", \
3150                         bInterfaceNumber, peasycap->kref.refcount.counter);
3151
3152         init_waitqueue_head(&(peasycap->wq_video));
3153         init_waitqueue_head(&(peasycap->wq_audio));
3154
3155         mutex_init(&(peasycap->mutex_timeval0));
3156         mutex_init(&(peasycap->mutex_timeval1));
3157
3158         for (k = 0; k < FRAME_BUFFER_MANY; k++)
3159                 mutex_init(&(peasycap->mutex_mmap_video[k]));
3160
3161         peasycap->ilk = 0;
3162         peasycap->microphone = false;
3163
3164         peasycap->video_interface = -1;
3165         peasycap->video_altsetting_on = -1;
3166         peasycap->video_altsetting_off = -1;
3167         peasycap->video_endpointnumber = -1;
3168         peasycap->video_isoc_maxframesize = -1;
3169         peasycap->video_isoc_buffer_size = -1;
3170
3171         peasycap->audio_interface = -1;
3172         peasycap->audio_altsetting_on = -1;
3173         peasycap->audio_altsetting_off = -1;
3174         peasycap->audio_endpointnumber = -1;
3175         peasycap->audio_isoc_maxframesize = -1;
3176         peasycap->audio_isoc_buffer_size = -1;
3177
3178         peasycap->frame_buffer_many = FRAME_BUFFER_MANY;
3179
3180         if ((struct mutex *)NULL == &(peasycap->mutex_mmap_video[0])) {
3181                 SAY("ERROR: &(peasycap->mutex_mmap_video[%i]) is NULL\n", 0);
3182                 return -EFAULT;
3183         }
3184 /*---------------------------------------------------------------------------*/
3185 /*
3186  *  DYNAMICALLY FILL IN THE AVAILABLE FORMATS.
3187  */
3188 /*---------------------------------------------------------------------------*/
3189         rc = fillin_formats();
3190         if (0 > rc) {
3191                 SAY("ERROR: fillin_formats() returned %i\n", rc);
3192                 return -EFAULT;
3193         }
3194         JOT(4, "%i formats available\n", rc);
3195         } else {
3196 /*---------------------------------------------------------------------------*/
3197                 if ((struct easycap *)NULL == peasycap) {
3198                         SAY("ERROR: peasycap is NULL " \
3199                                         "when probing interface %i\n", \
3200                                                         bInterfaceNumber);
3201                         return -EFAULT;
3202                 }
3203
3204         JOT(8, "kref_get() with %i=peasycap->kref.refcount.counter\n", \
3205                                         (int)peasycap->kref.refcount.counter);
3206         kref_get(&peasycap->kref);
3207 }
3208 /*---------------------------------------------------------------------------*/
3209 if ((USB_CLASS_VIDEO == bInterfaceClass) || \
3210         (USB_CLASS_VENDOR_SPEC == bInterfaceClass)) {
3211         if (-1 == peasycap->video_interface) {
3212                 peasycap->video_interface = bInterfaceNumber;
3213                 JOT(4, "setting peasycap->video_interface=%i\n", \
3214                                                 peasycap->video_interface);
3215         } else {
3216                 if (peasycap->video_interface != bInterfaceNumber) {
3217                         SAY("ERROR: attempting to reset " \
3218                                         "peasycap->video_interface\n");
3219                         SAY("...... continuing with " \
3220                                         "%i=peasycap->video_interface\n", \
3221                                         peasycap->video_interface);
3222                 }
3223         }
3224 } else if ((USB_CLASS_AUDIO == bInterfaceClass) && \
3225                                                 (0x02 == bInterfaceSubClass)) {
3226         if (-1 == peasycap->audio_interface) {
3227                 peasycap->audio_interface = bInterfaceNumber;
3228                 JOT(4, "setting peasycap->audio_interface=%i\n", \
3229                                                  peasycap->audio_interface);
3230         } else {
3231                 if (peasycap->audio_interface != bInterfaceNumber) {
3232                         SAY("ERROR: attempting to reset " \
3233                                         "peasycap->audio_interface\n");
3234                         SAY("...... continuing with " \
3235                                         "%i=peasycap->audio_interface\n", \
3236                                         peasycap->audio_interface);
3237                 }
3238         }
3239 }
3240 /*---------------------------------------------------------------------------*/
3241 /*
3242  *  INVESTIGATE ALL ALTSETTINGS.
3243  *  DONE IN DETAIL BECAUSE USB DEVICE 05e1:0408 HAS DISPARATE INCARNATIONS.
3244  */
3245 /*---------------------------------------------------------------------------*/
3246 isokalt = 0;
3247 isokepn = 0;
3248 isokmps = 0;
3249
3250 for (i = 0; i < pusb_interface->num_altsetting; i++) {
3251         pusb_host_interface = &(pusb_interface->altsetting[i]);
3252         if ((struct usb_host_interface *)NULL == pusb_host_interface) {
3253                 SAY("ERROR: pusb_host_interface is NULL\n");
3254                 return -EFAULT;
3255         }
3256         pusb_interface_descriptor = &(pusb_host_interface->desc);
3257         if ((struct usb_interface_descriptor *)NULL == \
3258                                                 pusb_interface_descriptor) {
3259                 SAY("ERROR: pusb_interface_descriptor is NULL\n");
3260                 return -EFAULT;
3261         }
3262
3263         JOT(4, "intf[%i]alt[%i]: desc.bDescriptorType=0x%02X\n", \
3264         bInterfaceNumber, i, pusb_interface_descriptor->bDescriptorType);
3265         JOT(4, "intf[%i]alt[%i]: desc.bInterfaceNumber=0x%02X\n", \
3266         bInterfaceNumber, i, pusb_interface_descriptor->bInterfaceNumber);
3267         JOT(4, "intf[%i]alt[%i]: desc.bAlternateSetting=0x%02X\n", \
3268         bInterfaceNumber, i, pusb_interface_descriptor->bAlternateSetting);
3269         JOT(4, "intf[%i]alt[%i]: desc.bNumEndpoints=0x%02X\n", \
3270         bInterfaceNumber, i, pusb_interface_descriptor->bNumEndpoints);
3271         JOT(4, "intf[%i]alt[%i]: desc.bInterfaceClass=0x%02X\n", \
3272         bInterfaceNumber, i, pusb_interface_descriptor->bInterfaceClass);
3273         JOT(4, "intf[%i]alt[%i]: desc.bInterfaceSubClass=0x%02X\n", \
3274         bInterfaceNumber, i, pusb_interface_descriptor->bInterfaceSubClass);
3275         JOT(4, "intf[%i]alt[%i]: desc.bInterfaceProtocol=0x%02X\n", \
3276         bInterfaceNumber, i, pusb_interface_descriptor->bInterfaceProtocol);
3277         JOT(4, "intf[%i]alt[%i]: desc.iInterface=0x%02X\n", \
3278         bInterfaceNumber, i, pusb_interface_descriptor->iInterface);
3279
3280         ISOCwMaxPacketSize = -1;
3281         BULKwMaxPacketSize = -1;
3282         INTwMaxPacketSize = -1;
3283         CTRLwMaxPacketSize = -1;
3284         ISOCbEndpointAddress = 0;
3285         INTbEndpointAddress = 0;
3286
3287         if (0 == pusb_interface_descriptor->bNumEndpoints)
3288                                 JOT(4, "intf[%i]alt[%i] has no endpoints\n", \
3289                                                         bInterfaceNumber, i);
3290 /*---------------------------------------------------------------------------*/
3291         for (j = 0; j < pusb_interface_descriptor->bNumEndpoints; j++) {
3292                 pepd = &(pusb_host_interface->endpoint[j].desc);
3293                 if ((struct usb_endpoint_descriptor *)NULL == pepd) {
3294                         SAY("ERROR:  pepd is NULL.\n");
3295                         SAY("...... skipping\n");
3296                         continue;
3297                 }
3298                 wMaxPacketSize = le16_to_cpu(pepd->wMaxPacketSize);
3299                 bEndpointAddress = pepd->bEndpointAddress;
3300
3301                 JOT(4, "intf[%i]alt[%i]end[%i]: bEndpointAddress=0x%X\n", \
3302                                 bInterfaceNumber, i, j, \
3303                                 pepd->bEndpointAddress);
3304                 JOT(4, "intf[%i]alt[%i]end[%i]: bmAttributes=0x%X\n", \
3305                                 bInterfaceNumber, i, j, \
3306                                 pepd->bmAttributes);
3307                 JOT(4, "intf[%i]alt[%i]end[%i]: wMaxPacketSize=%i\n", \
3308                                 bInterfaceNumber, i, j, \
3309                                 pepd->wMaxPacketSize);
3310                 JOT(4, "intf[%i]alt[%i]end[%i]: bInterval=%i\n",
3311                                 bInterfaceNumber, i, j, \
3312                                 pepd->bInterval);
3313
3314                 if (pepd->bEndpointAddress & USB_DIR_IN) {
3315                         JOT(4, "intf[%i]alt[%i]end[%i] is an  IN  endpoint\n",\
3316                                                 bInterfaceNumber, i, j);
3317                         isin = 1;
3318                 } else {
3319                         JOT(4, "intf[%i]alt[%i]end[%i] is an  OUT endpoint\n",\
3320                                                 bInterfaceNumber, i, j);
3321                         SAY("ERROR: OUT endpoint unexpected\n");
3322                         SAY("...... continuing\n");
3323                         isin = 0;
3324                 }
3325                 if ((pepd->bmAttributes & \
3326                                 USB_ENDPOINT_XFERTYPE_MASK) == \
3327                                 USB_ENDPOINT_XFER_ISOC) {
3328                         JOT(4, "intf[%i]alt[%i]end[%i] is an ISOC endpoint\n",\
3329                                                 bInterfaceNumber, i, j);
3330                         if (isin) {
3331                                 switch (bInterfaceClass) {
3332                                 case USB_CLASS_VIDEO:
3333                                 case USB_CLASS_VENDOR_SPEC: {
3334                                         if (!peasycap) {
3335                                                 SAY("MISTAKE: " \
3336                                                         "peasycap is NULL\n");
3337                                                 return -EFAULT;
3338                                         }
3339                                         if (pepd->wMaxPacketSize) {
3340                                                 if (8 > isokalt) {
3341                                                         okalt[isokalt] = i;
3342                                                         JOT(4,\
3343                                                         "%i=okalt[%i]\n", \
3344                                                         okalt[isokalt], \
3345                                                         isokalt);
3346                                                         isokalt++;
3347                                                 }
3348                                                 if (8 > isokepn) {
3349                                                         okepn[isokepn] = \
3350                                                         pepd->\
3351                                                         bEndpointAddress & \
3352                                                         0x0F;
3353                                                         JOT(4,\
3354                                                         "%i=okepn[%i]\n", \
3355                                                         okepn[isokepn], \
3356                                                         isokepn);
3357                                                         isokepn++;
3358                                                 }
3359                                                 if (8 > isokmps) {
3360                                                         okmps[isokmps] = \
3361                                                         le16_to_cpu(pepd->\
3362                                                         wMaxPacketSize);
3363                                                         JOT(4,\
3364                                                         "%i=okmps[%i]\n", \
3365                                                         okmps[isokmps], \
3366                                                         isokmps);
3367                                                         isokmps++;
3368                                                 }
3369                                         } else {
3370                                                 if (-1 == peasycap->\
3371                                                         video_altsetting_off) {
3372                                                         peasycap->\
3373                                                         video_altsetting_off =\
3374                                                                          i;
3375                                                         JOT(4, "%i=video_" \
3376                                                         "altsetting_off " \
3377                                                                 "<====\n", \
3378                                                         peasycap->\
3379                                                         video_altsetting_off);
3380                                                 } else {
3381                                                         SAY("ERROR: peasycap" \
3382                                                         "->video_altsetting_" \
3383                                                         "off already set\n");
3384                                                         SAY("...... " \
3385                                                         "continuing with " \
3386                                                         "%i=peasycap->video_" \
3387                                                         "altsetting_off\n", \
3388                                                         peasycap->\
3389                                                         video_altsetting_off);
3390                                                 }
3391                                         }
3392                                         break;
3393                                 }
3394                                 case USB_CLASS_AUDIO: {
3395                                         if (0x02 != bInterfaceSubClass)
3396                                                 break;
3397                                         if (!peasycap) {
3398                                                 SAY("MISTAKE: " \
3399                                                 "peasycap is NULL\n");
3400                                                 return -EFAULT;
3401                                         }
3402                                         if (pepd->wMaxPacketSize) {
3403                                                 if (8 > isokalt) {
3404                                                         okalt[isokalt] = i ;
3405                                                         JOT(4,\
3406                                                         "%i=okalt[%i]\n", \
3407                                                         okalt[isokalt], \
3408                                                         isokalt);
3409                                                         isokalt++;
3410                                                 }
3411                                                 if (8 > isokepn) {
3412                                                         okepn[isokepn] = \
3413                                                         pepd->\
3414                                                         bEndpointAddress & \
3415                                                         0x0F;
3416                                                         JOT(4,\
3417                                                         "%i=okepn[%i]\n", \
3418                                                         okepn[isokepn], \
3419                                                         isokepn);
3420                                                         isokepn++;
3421                                                 }
3422                                                 if (8 > isokmps) {
3423                                                         okmps[isokmps] = \
3424                                                         le16_to_cpu(pepd->\
3425                                                         wMaxPacketSize);
3426                                                         JOT(4,\
3427                                                         "%i=okmps[%i]\n",\
3428                                                         okmps[isokmps], \
3429                                                         isokmps);
3430                                                         isokmps++;
3431                                                 }
3432                                         } else {
3433                                                 if (-1 == peasycap->\
3434                                                         audio_altsetting_off) {
3435                                                         peasycap->\
3436                                                         audio_altsetting_off =\
3437                                                                          i;
3438                                                         JOT(4, "%i=audio_" \
3439                                                         "altsetting_off " \
3440                                                         "<====\n", \
3441                                                         peasycap->\
3442                                                         audio_altsetting_off);
3443                                                 } else {
3444                                                         SAY("ERROR: peasycap" \
3445                                                         "->audio_altsetting_" \
3446                                                         "off already set\n");
3447                                                         SAY("...... " \
3448                                                         "continuing with " \
3449                                                         "%i=peasycap->\
3450                                                         audio_altsetting_" \
3451                                                         "off\n",
3452                                                         peasycap->\
3453                                                         audio_altsetting_off);
3454                                                 }
3455                                         }
3456                                 break;
3457                                 }
3458                                 default:
3459                                         break;
3460                                 }
3461                         }
3462                 } else if ((pepd->bmAttributes & \
3463                                                 USB_ENDPOINT_XFERTYPE_MASK) ==\
3464                                                 USB_ENDPOINT_XFER_BULK) {
3465                         JOT(4, "intf[%i]alt[%i]end[%i] is a  BULK endpoint\n",\
3466                                                 bInterfaceNumber, i, j);
3467                 } else if ((pepd->bmAttributes & \
3468                                                 USB_ENDPOINT_XFERTYPE_MASK) ==\
3469                                                 USB_ENDPOINT_XFER_INT) {
3470                         JOT(4, "intf[%i]alt[%i]end[%i] is an  INT endpoint\n",\
3471                                                 bInterfaceNumber, i, j);
3472                 } else {
3473                         JOT(4, "intf[%i]alt[%i]end[%i] is a  CTRL endpoint\n",\
3474                                                 bInterfaceNumber, i, j);
3475                 }
3476                 if (0 == pepd->wMaxPacketSize) {
3477                         JOT(4, "intf[%i]alt[%i]end[%i] " \
3478                                                 "has zero packet size\n", \
3479                                                 bInterfaceNumber, i, j);
3480                 }
3481         }
3482 }
3483 /*---------------------------------------------------------------------------*/
3484 /*
3485  *  PERFORM INITIALIZATION OF THE PROBED INTERFACE
3486  */
3487 /*---------------------------------------------------------------------------*/
3488 JOT(4, "initialization begins for interface %i\n", \
3489                                 pusb_interface_descriptor->bInterfaceNumber);
3490 switch (bInterfaceNumber) {
3491 /*---------------------------------------------------------------------------*/
3492 /*
3493  *  INTERFACE 0 IS THE VIDEO INTERFACE
3494  */
3495 /*---------------------------------------------------------------------------*/
3496 case 0: {
3497         if (!peasycap) {
3498                 SAY("MISTAKE: peasycap is NULL\n");
3499                 return -EFAULT;
3500         }
3501         if (!isokalt) {
3502                 SAY("ERROR:  no viable video_altsetting_on\n");
3503                 return -ENOENT;
3504         } else {
3505                 peasycap->video_altsetting_on = okalt[isokalt - 1];
3506                 JOT(4, "%i=video_altsetting_on <====\n", \
3507                                         peasycap->video_altsetting_on);
3508         }
3509         if (!isokepn) {
3510                 SAY("ERROR:  no viable video_endpointnumber\n");
3511                 return -ENOENT;
3512         } else {
3513                 peasycap->video_endpointnumber = okepn[isokepn - 1];
3514                 JOT(4, "%i=video_endpointnumber\n", \
3515                                         peasycap->video_endpointnumber);
3516                 }
3517         if (!isokmps) {
3518                 SAY("ERROR:  no viable video_maxpacketsize\n");
3519                 return -ENOENT;
3520 /*---------------------------------------------------------------------------*/
3521 /*
3522  *  DECIDE THE VIDEO STREAMING PARAMETERS
3523  */
3524 /*---------------------------------------------------------------------------*/
3525         } else {
3526                 maxpacketsize = okmps[isokmps - 1] - 1024;
3527                 if (USB_2_0_MAXPACKETSIZE > maxpacketsize) {
3528                         peasycap->video_isoc_maxframesize = maxpacketsize;
3529                 } else {
3530                         peasycap->video_isoc_maxframesize = \
3531                                                         USB_2_0_MAXPACKETSIZE;
3532                 }
3533                 JOT(4, "%i=video_isoc_maxframesize\n", \
3534                                         peasycap->video_isoc_maxframesize);
3535                 if (0 >= peasycap->video_isoc_maxframesize) {
3536                         SAY("ERROR:  bad video_isoc_maxframesize\n");
3537                         return -ENOENT;
3538                 }
3539                 peasycap->video_isoc_framesperdesc = VIDEO_ISOC_FRAMESPERDESC;
3540                 JOT(4, "%i=video_isoc_framesperdesc\n", \
3541                                         peasycap->video_isoc_framesperdesc);
3542                 if (0 >= peasycap->video_isoc_framesperdesc) {
3543                         SAY("ERROR:  bad video_isoc_framesperdesc\n");
3544                         return -ENOENT;
3545                 }
3546                 peasycap->video_isoc_buffer_size = \
3547                                         peasycap->video_isoc_maxframesize * \
3548                                         peasycap->video_isoc_framesperdesc;
3549                 JOT(4, "%i=video_isoc_buffer_size\n", \
3550                                         peasycap->video_isoc_buffer_size);
3551                 if ((PAGE_SIZE << VIDEO_ISOC_ORDER) < \
3552                                         peasycap->video_isoc_buffer_size) {
3553                         SAY("MISTAKE: " \
3554                                 "peasycap->video_isoc_buffer_size too big\n");
3555                         return -EFAULT;
3556                 }
3557         }
3558 /*---------------------------------------------------------------------------*/
3559         if (-1 == peasycap->video_interface) {
3560                 SAY("MISTAKE:  video_interface is unset\n");
3561                 return -EFAULT;
3562         }
3563         if (-1 == peasycap->video_altsetting_on) {
3564                 SAY("MISTAKE:  video_altsetting_on is unset\n");
3565                 return -EFAULT;
3566         }
3567         if (-1 == peasycap->video_altsetting_off) {
3568                 SAY("MISTAKE:  video_interface_off is unset\n");
3569                 return -EFAULT;
3570         }
3571         if (-1 == peasycap->video_endpointnumber) {
3572                 SAY("MISTAKE:  video_endpointnumber is unset\n");
3573                 return -EFAULT;
3574         }
3575         if (-1 == peasycap->video_isoc_maxframesize) {
3576                 SAY("MISTAKE:  video_isoc_maxframesize is unset\n");
3577                 return -EFAULT;
3578         }
3579         if (-1 == peasycap->video_isoc_buffer_size) {
3580                 SAY("MISTAKE:  video_isoc_buffer_size is unset\n");
3581                 return -EFAULT;
3582         }
3583 /*---------------------------------------------------------------------------*/
3584 /*
3585  *  ALLOCATE MEMORY FOR VIDEO BUFFERS.  LISTS MUST BE INITIALIZED FIRST.
3586  */
3587 /*---------------------------------------------------------------------------*/
3588         INIT_LIST_HEAD(&(peasycap->urb_video_head));
3589         peasycap->purb_video_head = &(peasycap->urb_video_head);
3590 /*---------------------------------------------------------------------------*/
3591         JOT(4, "allocating %i frame buffers of size %li\n",  \
3592                         FRAME_BUFFER_MANY, (long int)FRAME_BUFFER_SIZE);
3593         JOT(4, ".... each scattered over %li pages\n", \
3594                                                 FRAME_BUFFER_SIZE/PAGE_SIZE);
3595
3596         for (k = 0;  k < FRAME_BUFFER_MANY;  k++) {
3597                 for (m = 0;  m < FRAME_BUFFER_SIZE/PAGE_SIZE;  m++) {
3598                         if ((void *)NULL != peasycap->frame_buffer[k][m].pgo)
3599                                 SAY("attempting to reallocate frame " \
3600                                                                 " buffers\n");
3601                         else {
3602                                 pbuf = (void *)__get_free_page(GFP_KERNEL);
3603                                 if ((void *)NULL == pbuf) {
3604                                         SAY("ERROR: Could not allocate frame "\
3605                                                 "buffer %i page %i\n", k, m);
3606                                         return -ENOMEM;
3607                                 } else
3608                                         peasycap->allocation_video_page += 1;
3609                                 peasycap->frame_buffer[k][m].pgo = pbuf;
3610                         }
3611                         peasycap->frame_buffer[k][m].pto = \
3612                                         peasycap->frame_buffer[k][m].pgo;
3613                 }
3614         }
3615
3616         peasycap->frame_fill = 0;
3617         peasycap->frame_read = 0;
3618         JOT(4, "allocation of frame buffers done:  %i pages\n", k * \
3619                                                                 m);
3620 /*---------------------------------------------------------------------------*/
3621         JOT(4, "allocating %i field buffers of size %li\n",  \
3622                         FIELD_BUFFER_MANY, (long int)FIELD_BUFFER_SIZE);
3623         JOT(4, ".... each scattered over %li pages\n", \
3624                                         FIELD_BUFFER_SIZE/PAGE_SIZE);
3625
3626         for (k = 0;  k < FIELD_BUFFER_MANY;  k++) {
3627                 for (m = 0;  m < FIELD_BUFFER_SIZE/PAGE_SIZE;  m++) {
3628                         if ((void *)NULL != peasycap->field_buffer[k][m].pgo) {
3629                                 SAY("ERROR: attempting to reallocate " \
3630                                                         "field buffers\n");
3631                         } else {
3632                                 pbuf = (void *) __get_free_page(GFP_KERNEL);
3633                                 if ((void *)NULL == pbuf) {
3634                                         SAY("ERROR: Could not allocate field" \
3635                                                 " buffer %i page %i\n", k, m);
3636                                         return -ENOMEM;
3637                                         }
3638                                 else
3639                                         peasycap->allocation_video_page += 1;
3640                                 peasycap->field_buffer[k][m].pgo = pbuf;
3641                                 }
3642                         peasycap->field_buffer[k][m].pto = \
3643                                         peasycap->field_buffer[k][m].pgo;
3644                 }
3645                 peasycap->field_buffer[k][0].kount = 0x0200;
3646         }
3647         peasycap->field_fill = 0;
3648         peasycap->field_page = 0;
3649         peasycap->field_read = 0;
3650         JOT(4, "allocation of field buffers done:  %i pages\n", k * \
3651                                                                 m);
3652 /*---------------------------------------------------------------------------*/
3653         JOT(4, "allocating %i isoc video buffers of size %i\n",  \
3654                                         VIDEO_ISOC_BUFFER_MANY, \
3655                                         peasycap->video_isoc_buffer_size);
3656         JOT(4, ".... each occupying contiguous memory pages\n");
3657
3658         for (k = 0;  k < VIDEO_ISOC_BUFFER_MANY; k++) {
3659                 pbuf = (void *)__get_free_pages(GFP_KERNEL, VIDEO_ISOC_ORDER);
3660                 if (NULL == pbuf) {
3661                         SAY("ERROR: Could not allocate isoc video buffer " \
3662                                                                 "%i\n", k);
3663                         return -ENOMEM;
3664                 } else
3665                         peasycap->allocation_video_page += \
3666                                 ((unsigned int)(0x01 << VIDEO_ISOC_ORDER));
3667
3668                 peasycap->video_isoc_buffer[k].pgo = pbuf;
3669                 peasycap->video_isoc_buffer[k].pto = pbuf + \
3670                                         peasycap->video_isoc_buffer_size;
3671                 peasycap->video_isoc_buffer[k].kount = k;
3672         }
3673         JOT(4, "allocation of isoc video buffers done: %i pages\n", \
3674                                         k * (0x01 << VIDEO_ISOC_ORDER));
3675 /*---------------------------------------------------------------------------*/
3676 /*
3677  *  ALLOCATE AND INITIALIZE MULTIPLE struct urb ...
3678  */
3679 /*---------------------------------------------------------------------------*/
3680         JOT(4, "allocating %i struct urb.\n", VIDEO_ISOC_BUFFER_MANY);
3681         JOT(4, "using %i=peasycap->video_isoc_framesperdesc\n", \
3682                                         peasycap->video_isoc_framesperdesc);
3683         JOT(4, "using %i=peasycap->video_isoc_maxframesize\n", \
3684                                         peasycap->video_isoc_maxframesize);
3685         JOT(4, "using %i=peasycap->video_isoc_buffer_sizen", \
3686                                         peasycap->video_isoc_buffer_size);
3687
3688         for (k = 0;  k < VIDEO_ISOC_BUFFER_MANY; k++) {
3689                 purb = usb_alloc_urb(peasycap->video_isoc_framesperdesc, \
3690                                                                 GFP_KERNEL);
3691                 if (NULL == purb) {
3692                         SAY("ERROR: usb_alloc_urb returned NULL for buffer " \
3693                                                                 "%i\n", k);
3694                         return -ENOMEM;
3695                 } else
3696                         peasycap->allocation_video_urb += 1;
3697 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
3698                 pdata_urb = kzalloc(sizeof(struct data_urb), GFP_KERNEL);
3699                 if (NULL == pdata_urb) {
3700                         SAY("ERROR: Could not allocate struct data_urb.\n");
3701                         return -ENOMEM;
3702                 } else
3703                         peasycap->allocation_video_struct += \
3704                                                 sizeof(struct data_urb);
3705
3706                 pdata_urb->purb = purb;
3707                 pdata_urb->isbuf = k;
3708                 pdata_urb->length = 0;
3709                 list_add_tail(&(pdata_urb->list_head), \
3710                                                 peasycap->purb_video_head);
3711 /*---------------------------------------------------------------------------*/
3712 /*
3713  *  ... AND INITIALIZE THEM
3714  */
3715 /*---------------------------------------------------------------------------*/
3716                 if (!k) {
3717                         JOT(4, "initializing video urbs thus:\n");
3718                         JOT(4, "  purb->interval = 1;\n");
3719                         JOT(4, "  purb->dev = peasycap->pusb_device;\n");
3720                         JOT(4, "  purb->pipe = usb_rcvisocpipe" \
3721                                         "(peasycap->pusb_device,%i);\n", \
3722                                         peasycap->video_endpointnumber);
3723                         JOT(4, "  purb->transfer_flags = URB_ISO_ASAP;\n");
3724                         JOT(4, "  purb->transfer_buffer = peasycap->" \
3725                                         "video_isoc_buffer[.].pgo;\n");
3726                         JOT(4, "  purb->transfer_buffer_length = %i;\n", \
3727                                         peasycap->video_isoc_buffer_size);
3728                         JOT(4, "  purb->complete = easycap_complete;\n");
3729                         JOT(4, "  purb->context = peasycap;\n");
3730                         JOT(4, "  purb->start_frame = 0;\n");
3731                         JOT(4, "  purb->number_of_packets = %i;\n", \
3732                                         peasycap->video_isoc_framesperdesc);
3733                         JOT(4, "  for (j = 0; j < %i; j++)\n", \
3734                                         peasycap->video_isoc_framesperdesc);
3735                         JOT(4, "    {\n");
3736                         JOT(4, "    purb->iso_frame_desc[j].offset = j*%i;\n",\
3737                                         peasycap->video_isoc_maxframesize);
3738                         JOT(4, "    purb->iso_frame_desc[j].length = %i;\n", \
3739                                         peasycap->video_isoc_maxframesize);
3740                         JOT(4, "    }\n");
3741                 }
3742
3743                 purb->interval = 1;
3744                 purb->dev = peasycap->pusb_device;
3745                 purb->pipe = usb_rcvisocpipe(peasycap->pusb_device, \
3746                                         peasycap->video_endpointnumber);
3747                 purb->transfer_flags = URB_ISO_ASAP;
3748                 purb->transfer_buffer = peasycap->video_isoc_buffer[k].pgo;
3749                 purb->transfer_buffer_length = \
3750                                         peasycap->video_isoc_buffer_size;
3751                 purb->complete = easycap_complete;
3752                 purb->context = peasycap;
3753                 purb->start_frame = 0;
3754                 purb->number_of_packets = peasycap->video_isoc_framesperdesc;
3755                 for (j = 0;  j < peasycap->video_isoc_framesperdesc; j++) {
3756                         purb->iso_frame_desc[j].offset = j * \
3757                                         peasycap->video_isoc_maxframesize;
3758                         purb->iso_frame_desc[j].length = \
3759                                         peasycap->video_isoc_maxframesize;
3760                 }
3761         }
3762         JOT(4, "allocation of %i struct urb done.\n", k);
3763 /*--------------------------------------------------------------------------*/
3764 /*
3765  *  SAVE POINTER peasycap IN THIS INTERFACE.
3766  */
3767 /*--------------------------------------------------------------------------*/
3768         usb_set_intfdata(pusb_interface, peasycap);
3769 /*--------------------------------------------------------------------------*/
3770 /*
3771  *  THE VIDEO DEVICE CAN BE REGISTERED NOW, AS IT IS READY.
3772  */
3773 /*--------------------------------------------------------------------------*/
3774 #if (!defined(EASYCAP_IS_VIDEODEV_CLIENT))
3775         if (0 != (usb_register_dev(pusb_interface, &easycap_class))) {
3776                 err("Not able to get a minor for this device");
3777                 usb_set_intfdata(pusb_interface, NULL);
3778                 return -ENODEV;
3779         } else
3780                 (peasycap->registered_video)++;
3781         SAY("easycap attached to minor #%d\n", pusb_interface->minor);
3782         break;
3783 /*vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
3784 #else
3785         pvideo_device = (struct video_device *)\
3786                         kzalloc(sizeof(struct video_device), GFP_KERNEL);
3787         if ((struct video_device *)NULL == pvideo_device) {
3788                 SAY("ERROR: Could not allocate structure video_device\n");
3789                 return -ENOMEM;
3790         }
3791         if (VIDEO_DEVICE_MANY <= video_device_many) {
3792                 SAY("ERROR: Too many /dev/videos\n");
3793                 return -ENOMEM;
3794         }
3795         pvideo_array[video_device_many] = pvideo_device;  video_device_many++;
3796
3797         strcpy(&pvideo_device->name[0], "easycapdc60");
3798 #if defined(EASYCAP_NEEDS_V4L2_FOPS)
3799         pvideo_device->fops = &v4l2_fops;
3800 #else
3801         pvideo_device->fops = &easycap_fops;
3802 #endif /*EASYCAP_NEEDS_V4L2_FOPS*/
3803         pvideo_device->minor = -1;
3804         pvideo_device->release = (void *)(&videodev_release);
3805
3806         video_set_drvdata(pvideo_device, (void *)peasycap);
3807
3808         rc = video_register_device(pvideo_device, VFL_TYPE_GRABBER, -1);
3809         if (0 != rc) {
3810                 err("Not able to register with videodev");
3811                 videodev_release(pvideo_device);
3812                 return -ENODEV;
3813         } else {
3814                 peasycap->pvideo_device = pvideo_device;
3815                 (peasycap->registered_video)++;
3816                 JOT(4, "registered with videodev: %i=minor\n", \
3817                                                         pvideo_device->minor);
3818         }
3819 /*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
3820 #endif /*EASYCAP_IS_VIDEODEV_CLIENT*/
3821         break;
3822 }
3823 /*--------------------------------------------------------------------------*/
3824 /*
3825  *  INTERFACE 1 IS THE AUDIO CONTROL INTERFACE
3826  *  INTERFACE 2 IS THE AUDIO STREAMING INTERFACE
3827  */
3828 /*--------------------------------------------------------------------------*/
3829 case 1: {
3830 /*--------------------------------------------------------------------------*/
3831 /*
3832  *  SAVE POINTER peasycap IN INTERFACE 1
3833  */
3834 /*--------------------------------------------------------------------------*/
3835         usb_set_intfdata(pusb_interface, peasycap);
3836         JOT(4, "no initialization required for interface %i\n", \
3837                                 pusb_interface_descriptor->bInterfaceNumber);
3838         break;
3839 }
3840 /*--------------------------------------------------------------------------*/
3841 case 2: {
3842         if (!peasycap) {
3843                 SAY("MISTAKE: peasycap is NULL\n");
3844                 return -EFAULT;
3845         }
3846         if (!isokalt) {
3847                 SAY("ERROR:  no viable audio_altsetting_on\n");
3848                 return -ENOENT;
3849         } else {
3850                 peasycap->audio_altsetting_on = okalt[isokalt - 1];
3851                 JOT(4, "%i=audio_altsetting_on <====\n", \
3852                                                 peasycap->audio_altsetting_on);
3853         }
3854         if (!isokepn) {
3855                 SAY("ERROR:  no viable audio_endpointnumber\n");
3856                 return -ENOENT;
3857         } else {
3858                 peasycap->audio_endpointnumber = okepn[isokepn - 1];
3859                 JOT(4, "%i=audio_endpointnumber\n", \
3860                                         peasycap->audio_endpointnumber);
3861         }
3862         if (!isokmps) {
3863                 SAY("ERROR:  no viable audio_maxpacketsize\n");
3864                 return -ENOENT;
3865         } else {
3866                 peasycap->audio_isoc_maxframesize = okmps[isokmps - 1];
3867                 JOT(4, "%i=audio_isoc_maxframesize\n", \
3868                                         peasycap->audio_isoc_maxframesize);
3869                 if (0 >= peasycap->audio_isoc_maxframesize) {
3870                         SAY("ERROR:  bad audio_isoc_maxframesize\n");
3871                         return -ENOENT;
3872                 }
3873                 if (9 == peasycap->audio_isoc_maxframesize) {
3874                         peasycap->ilk |= 0x02;
3875                         SAY("hardware is FOUR-CVBS\n");
3876                         peasycap->microphone = true;
3877                         peasycap->audio_pages_per_fragment = 4;
3878                 } else if (256 == peasycap->audio_isoc_maxframesize) {
3879                         peasycap->ilk &= ~0x02;
3880                         SAY("hardware is CVBS+S-VIDEO\n");
3881                         peasycap->microphone = false;
3882                         peasycap->audio_pages_per_fragment = 4;
3883                 } else {
3884                         SAY("hardware is unidentified:\n");
3885                         SAY("%i=audio_isoc_maxframesize\n", \
3886                                         peasycap->audio_isoc_maxframesize);
3887                         return -ENOENT;
3888                 }
3889
3890                 peasycap->audio_bytes_per_fragment = \
3891                                         peasycap->audio_pages_per_fragment * \
3892                                                                 PAGE_SIZE ;
3893                 peasycap->audio_buffer_page_many = (AUDIO_FRAGMENT_MANY * \
3894                                         peasycap->audio_pages_per_fragment);
3895
3896                 JOT(4, "%6i=AUDIO_FRAGMENT_MANY\n", AUDIO_FRAGMENT_MANY);
3897                 JOT(4, "%6i=audio_pages_per_fragment\n", \
3898                                         peasycap->audio_pages_per_fragment);
3899                 JOT(4, "%6i=audio_bytes_per_fragment\n", \
3900                                         peasycap->audio_bytes_per_fragment);
3901                 JOT(4, "%6i=audio_buffer_page_many\n", \
3902                                         peasycap->audio_buffer_page_many);
3903
3904                 peasycap->audio_isoc_framesperdesc = 128;
3905
3906                 JOT(4, "%i=audio_isoc_framesperdesc\n", \
3907                                         peasycap->audio_isoc_framesperdesc);
3908                 if (0 >= peasycap->audio_isoc_framesperdesc) {
3909                         SAY("ERROR:  bad audio_isoc_framesperdesc\n");
3910                         return -ENOENT;
3911                 }
3912
3913                 peasycap->audio_isoc_buffer_size = \
3914                                 peasycap->audio_isoc_maxframesize * \
3915                                 peasycap->audio_isoc_framesperdesc;
3916                 JOT(4, "%i=audio_isoc_buffer_size\n", \
3917                                         peasycap->audio_isoc_buffer_size);
3918                 if (AUDIO_ISOC_BUFFER_SIZE < \
3919                                         peasycap->audio_isoc_buffer_size) {
3920                         SAY("MISTAKE:  audio_isoc_buffer_size bigger "
3921                         "than %li=AUDIO_ISOC_BUFFER_SIZE\n", \
3922                                                 AUDIO_ISOC_BUFFER_SIZE);
3923                         return -EFAULT;
3924                 }
3925         }
3926
3927         if (-1 == peasycap->audio_interface) {
3928                 SAY("MISTAKE:  audio_interface is unset\n");
3929                 return -EFAULT;
3930         }
3931         if (-1 == peasycap->audio_altsetting_on) {
3932                 SAY("MISTAKE:  audio_altsetting_on is unset\n");
3933                 return -EFAULT;
3934         }
3935         if (-1 == peasycap->audio_altsetting_off) {
3936                 SAY("MISTAKE:  audio_interface_off is unset\n");
3937                 return -EFAULT;
3938         }
3939         if (-1 == peasycap->audio_endpointnumber) {
3940                 SAY("MISTAKE:  audio_endpointnumber is unset\n");
3941                 return -EFAULT;
3942         }
3943         if (-1 == peasycap->audio_isoc_maxframesize) {
3944                 SAY("MISTAKE:  audio_isoc_maxframesize is unset\n");
3945                 return -EFAULT;
3946         }
3947         if (-1 == peasycap->audio_isoc_buffer_size) {
3948                 SAY("MISTAKE:  audio_isoc_buffer_size is unset\n");
3949                 return -EFAULT;
3950         }
3951 /*---------------------------------------------------------------------------*/
3952 /*
3953  *  ALLOCATE MEMORY FOR AUDIO BUFFERS.  LISTS MUST BE INITIALIZED FIRST.
3954  */
3955 /*---------------------------------------------------------------------------*/
3956         INIT_LIST_HEAD(&(peasycap->urb_audio_head));
3957         peasycap->purb_audio_head = &(peasycap->urb_audio_head);
3958
3959         JOT(4, "allocating an audio buffer\n");
3960         JOT(4, ".... scattered over %i pages\n", \
3961                                         peasycap->audio_buffer_page_many);
3962
3963         for (k = 0;  k < peasycap->audio_buffer_page_many;  k++) {
3964                 if ((void *)NULL != peasycap->audio_buffer[k].pgo) {
3965                         SAY("ERROR: attempting to reallocate audio buffers\n");
3966                 } else {
3967                         pbuf = (void *) __get_free_page(GFP_KERNEL);
3968                         if ((void *)NULL == pbuf) {
3969                                 SAY("ERROR: Could not allocate audio " \
3970                                                         "buffer page %i\n", k);
3971                                 return -ENOMEM;
3972                         } else
3973                                 peasycap->allocation_audio_page += 1;
3974
3975                         peasycap->audio_buffer[k].pgo = pbuf;
3976                 }
3977                 peasycap->audio_buffer[k].pto = peasycap->audio_buffer[k].pgo;
3978         }
3979
3980         peasycap->audio_fill = 0;
3981         peasycap->audio_read = 0;
3982         JOT(4, "allocation of audio buffer done:  %i pages\n", k);
3983 /*---------------------------------------------------------------------------*/
3984         JOT(4, "allocating %i isoc audio buffers of size %i\n",  \
3985                 AUDIO_ISOC_BUFFER_MANY, peasycap->audio_isoc_buffer_size);
3986         JOT(4, ".... each occupying contiguous memory pages\n");
3987
3988         for (k = 0;  k < AUDIO_ISOC_BUFFER_MANY;  k++) {
3989                 pbuf = (void *)__get_free_pages(GFP_KERNEL, AUDIO_ISOC_ORDER);
3990                 if (NULL == pbuf) {
3991                         SAY("ERROR: Could not allocate isoc audio buffer " \
3992                                                         "%i\n", k);
3993                         return -ENOMEM;
3994                 } else
3995                         peasycap->allocation_audio_page += \
3996                                 ((unsigned int)(0x01 << AUDIO_ISOC_ORDER));
3997
3998                 peasycap->audio_isoc_buffer[k].pgo = pbuf;
3999                 peasycap->audio_isoc_buffer[k].pto = pbuf + \
4000                 peasycap->audio_isoc_buffer_size;
4001                 peasycap->audio_isoc_buffer[k].kount = k;
4002         }
4003         JOT(4, "allocation of isoc audio buffers done.\n");
4004 /*---------------------------------------------------------------------------*/
4005 /*
4006  *  ALLOCATE AND INITIALIZE MULTIPLE struct urb ...
4007  */
4008 /*---------------------------------------------------------------------------*/
4009         JOT(4, "allocating %i struct urb.\n", AUDIO_ISOC_BUFFER_MANY);
4010         JOT(4, "using %i=peasycap->audio_isoc_framesperdesc\n", \
4011                                         peasycap->audio_isoc_framesperdesc);
4012         JOT(4, "using %i=peasycap->audio_isoc_maxframesize\n", \
4013                                         peasycap->audio_isoc_maxframesize);
4014         JOT(4, "using %i=peasycap->audio_isoc_buffer_size\n", \
4015                                         peasycap->audio_isoc_buffer_size);
4016
4017         for (k = 0;  k < AUDIO_ISOC_BUFFER_MANY; k++) {
4018                 purb = usb_alloc_urb(peasycap->audio_isoc_framesperdesc, \
4019                                                                 GFP_KERNEL);
4020                 if (NULL == purb) {
4021                         SAY("ERROR: usb_alloc_urb returned NULL for buffer " \
4022                                                         "%i\n", k);
4023                         return -ENOMEM;
4024                 } else
4025                         peasycap->allocation_audio_urb += 1 ;
4026 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
4027                 pdata_urb = kzalloc(sizeof(struct data_urb), GFP_KERNEL);
4028                 if (NULL == pdata_urb) {
4029                         SAY("ERROR: Could not allocate struct data_urb.\n");
4030                         return -ENOMEM;
4031                 } else
4032                         peasycap->allocation_audio_struct += \
4033                                                 sizeof(struct data_urb);
4034
4035                 pdata_urb->purb = purb;
4036                 pdata_urb->isbuf = k;
4037                 pdata_urb->length = 0;
4038                 list_add_tail(&(pdata_urb->list_head), \
4039                                                 peasycap->purb_audio_head);
4040 /*---------------------------------------------------------------------------*/
4041 /*
4042  *  ... AND INITIALIZE THEM
4043  */
4044 /*---------------------------------------------------------------------------*/
4045                 if (!k) {
4046                         JOT(4, "initializing audio urbs thus:\n");
4047                         JOT(4, "  purb->interval = 1;\n");
4048                         JOT(4, "  purb->dev = peasycap->pusb_device;\n");
4049                         JOT(4, "  purb->pipe = usb_rcvisocpipe(peasycap->" \
4050                                         "pusb_device,%i);\n", \
4051                                         peasycap->audio_endpointnumber);
4052                         JOT(4, "  purb->transfer_flags = URB_ISO_ASAP;\n");
4053                         JOT(4, "  purb->transfer_buffer = " \
4054                                 "peasycap->audio_isoc_buffer[.].pgo;\n");
4055                         JOT(4, "  purb->transfer_buffer_length = %i;\n", \
4056                                         peasycap->audio_isoc_buffer_size);
4057                         JOT(4, "  purb->complete = easysnd_complete;\n");
4058                         JOT(4, "  purb->context = peasycap;\n");
4059                         JOT(4, "  purb->start_frame = 0;\n");
4060                         JOT(4, "  purb->number_of_packets = %i;\n", \
4061                                         peasycap->audio_isoc_framesperdesc);
4062                         JOT(4, "  for (j = 0; j < %i; j++)\n", \
4063                                         peasycap->audio_isoc_framesperdesc);
4064                         JOT(4, "    {\n");
4065                         JOT(4, "    purb->iso_frame_desc[j].offset = j*%i;\n",\
4066                                         peasycap->audio_isoc_maxframesize);
4067                         JOT(4, "    purb->iso_frame_desc[j].length = %i;\n", \
4068                                         peasycap->audio_isoc_maxframesize);
4069                         JOT(4, "    }\n");
4070                         }
4071
4072                 purb->interval = 1;
4073                 purb->dev = peasycap->pusb_device;
4074                 purb->pipe = usb_rcvisocpipe(peasycap->pusb_device, \
4075                                         peasycap->audio_endpointnumber);
4076                 purb->transfer_flags = URB_ISO_ASAP;
4077                 purb->transfer_buffer = peasycap->audio_isoc_buffer[k].pgo;
4078                 purb->transfer_buffer_length = \
4079                                         peasycap->audio_isoc_buffer_size;
4080                 purb->complete = easysnd_complete;
4081                 purb->context = peasycap;
4082                 purb->start_frame = 0;
4083                 purb->number_of_packets = peasycap->audio_isoc_framesperdesc;
4084                 for (j = 0;  j < peasycap->audio_isoc_framesperdesc; j++) {
4085                         purb->iso_frame_desc[j].offset = j * \
4086                                         peasycap->audio_isoc_maxframesize;
4087                         purb->iso_frame_desc[j].length = \
4088                                         peasycap->audio_isoc_maxframesize;
4089                 }
4090         }
4091         JOT(4, "allocation of %i struct urb done.\n", k);
4092 /*---------------------------------------------------------------------------*/
4093 /*
4094  *  SAVE POINTER peasycap IN THIS INTERFACE.
4095  */
4096 /*---------------------------------------------------------------------------*/
4097         usb_set_intfdata(pusb_interface, peasycap);
4098 /*---------------------------------------------------------------------------*/
4099 /*
4100  *  THE AUDIO DEVICE CAN BE REGISTERED NOW, AS IT IS READY.
4101  */
4102 /*---------------------------------------------------------------------------*/
4103         rc = usb_register_dev(pusb_interface, &easysnd_class);
4104         if (0 != rc) {
4105                 err("Not able to get a minor for this device.");
4106                 usb_set_intfdata(pusb_interface, NULL);
4107                 return -ENODEV;
4108         } else
4109                 (peasycap->registered_audio)++;
4110 /*---------------------------------------------------------------------------*/
4111 /*
4112  *  LET THE USER KNOW WHAT NODE THE AUDIO DEVICE IS ATTACHED TO.
4113  */
4114 /*---------------------------------------------------------------------------*/
4115         SAY("easysnd attached to minor #%d\n", pusb_interface->minor);
4116         break;
4117 }
4118 /*---------------------------------------------------------------------------*/
4119 /*
4120  *  INTERFACES OTHER THAN 0, 1 AND 2 ARE UNEXPECTED
4121  */
4122 /*---------------------------------------------------------------------------*/
4123 default: {
4124         JOT(4, "ERROR: unexpected interface %i\n", bInterfaceNumber);
4125         return -EINVAL;
4126 }
4127 }
4128 JOT(4, "ends successfully for interface %i\n", \
4129                                 pusb_interface_descriptor->bInterfaceNumber);
4130 return 0;
4131 }
4132 /*****************************************************************************/
4133 /*---------------------------------------------------------------------------*/
4134 /*
4135  *  WHEN THIS FUNCTION IS CALLED THE DEVICE HAS ALREADY BEEN PHYSICALLY
4136  *  UNPLUGGED.
4137  *  HENCE peasycap->pusb_device IS NO LONGER VALID AND MUST BE SET TO NULL.
4138  */
4139 /*---------------------------------------------------------------------------*/
4140 void
4141 easycap_usb_disconnect(struct usb_interface *pusb_interface)
4142 {
4143 struct usb_host_interface *pusb_host_interface;
4144 struct usb_interface_descriptor *pusb_interface_descriptor;
4145 __u8 bInterfaceNumber;
4146 struct easycap *peasycap;
4147
4148 struct list_head *plist_head;
4149 struct data_urb *pdata_urb;
4150 int minor, m;
4151
4152 JOT(4, "\n");
4153
4154 if ((struct usb_interface *)NULL == pusb_interface) {
4155         JOT(4, "ERROR: pusb_interface is NULL\n");
4156         return;
4157 }
4158 pusb_host_interface = pusb_interface->cur_altsetting;
4159 if ((struct usb_host_interface *)NULL == pusb_host_interface) {
4160         JOT(4, "ERROR: pusb_host_interface is NULL\n");
4161         return;
4162 }
4163 pusb_interface_descriptor = &(pusb_host_interface->desc);
4164 if ((struct usb_interface_descriptor *)NULL == pusb_interface_descriptor) {
4165         JOT(4, "ERROR: pusb_interface_descriptor is NULL\n");
4166         return;
4167 }
4168 bInterfaceNumber = pusb_interface_descriptor->bInterfaceNumber;
4169 minor = pusb_interface->minor;
4170 JOT(4, "intf[%i]: minor=%i\n", bInterfaceNumber, minor);
4171
4172 peasycap = usb_get_intfdata(pusb_interface);
4173 if ((struct easycap *)NULL == peasycap)
4174         SAY("ERROR: peasycap is NULL\n");
4175 else {
4176         peasycap->pusb_device = (struct usb_device *)NULL;
4177         switch (bInterfaceNumber) {
4178 /*---------------------------------------------------------------------------*/
4179         case 0: {
4180                 if ((struct list_head *)NULL != peasycap->purb_video_head) {
4181                         JOT(4, "killing video urbs\n");
4182                         m = 0;
4183                         list_for_each(plist_head, (peasycap->purb_video_head))
4184                                 {
4185                                 pdata_urb = list_entry(plist_head, \
4186                                                 struct data_urb, list_head);
4187                                 if ((struct data_urb *)NULL != pdata_urb) {
4188                                         if ((struct urb *)NULL != \
4189                                                         pdata_urb->purb) {
4190                                                 usb_kill_urb(pdata_urb->purb);
4191                                                 m++;
4192                                         }
4193                                 }
4194                         }
4195                         JOT(4, "%i video urbs killed\n", m);
4196                 } else
4197                         SAY("ERROR: peasycap->purb_video_head is NULL\n");
4198                 break;
4199         }
4200 /*---------------------------------------------------------------------------*/
4201         case 2: {
4202                 if ((struct list_head *)NULL != peasycap->purb_audio_head) {
4203                         JOT(4, "killing audio urbs\n");
4204                         m = 0;
4205                         list_for_each(plist_head, \
4206                                                 (peasycap->purb_audio_head)) {
4207                                 pdata_urb = list_entry(plist_head, \
4208                                                 struct data_urb, list_head);
4209                                 if ((struct data_urb *)NULL != pdata_urb) {
4210                                         if ((struct urb *)NULL != \
4211                                                         pdata_urb->purb) {
4212                                                 usb_kill_urb(pdata_urb->purb);
4213                                                 m++;
4214                                         }
4215                                 }
4216                         }
4217                         JOT(4, "%i audio urbs killed\n", m);
4218                 } else
4219                         SAY("ERROR: peasycap->purb_audio_head is NULL\n");
4220                 break;
4221         }
4222 /*---------------------------------------------------------------------------*/
4223         default:
4224                 break;
4225         }
4226 }
4227 /*--------------------------------------------------------------------------*/
4228 /*
4229  *  DEREGISTER
4230  */
4231 /*--------------------------------------------------------------------------*/
4232 switch (bInterfaceNumber) {
4233 case 0: {
4234 #if (!defined(EASYCAP_IS_VIDEODEV_CLIENT))
4235         if ((struct easycap *)NULL == peasycap) {
4236                 SAY("ERROR: peasycap has become NULL\n");
4237         } else {
4238                 lock_kernel();
4239                 usb_deregister_dev(pusb_interface, &easycap_class);
4240                 (peasycap->registered_video)--;
4241
4242                 JOT(4, "intf[%i]: usb_deregister_dev()\n", bInterfaceNumber);
4243                 unlock_kernel();
4244                 SAY("easycap detached from minor #%d\n", minor);
4245         }
4246 /*vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
4247 #else
4248         if ((struct easycap *)NULL == peasycap)
4249                 SAY("ERROR: peasycap has become NULL\n");
4250         else {
4251                 lock_kernel();
4252                 video_unregister_device(peasycap->pvideo_device);
4253                 (peasycap->registered_video)--;
4254                 unlock_kernel();
4255                 JOT(4, "unregistered with videodev: %i=minor\n", \
4256                                                         pvideo_device->minor);
4257         }
4258 /*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
4259 #endif /*EASYCAP_IS_VIDEODEV_CLIENT*/
4260         break;
4261 }
4262 case 2: {
4263         lock_kernel();
4264
4265         usb_deregister_dev(pusb_interface, &easysnd_class);
4266         if ((struct easycap *)NULL != peasycap)
4267                 (peasycap->registered_audio)--;
4268
4269         JOT(4, "intf[%i]: usb_deregister_dev()\n", bInterfaceNumber);
4270         unlock_kernel();
4271
4272         SAY("easysnd detached from minor #%d\n", minor);
4273         break;
4274 }
4275 default:
4276         break;
4277 }
4278 /*---------------------------------------------------------------------------*/
4279 /*
4280  *  CALL easycap_delete() IF NO REMAINING REFERENCES TO peasycap
4281  */
4282 /*---------------------------------------------------------------------------*/
4283 if ((struct easycap *)NULL == peasycap) {
4284         SAY("ERROR: peasycap has become NULL\n");
4285         SAY("cannot call kref_put()\n");
4286         SAY("ending unsuccessfully: may cause memory leak\n");
4287         return;
4288 }
4289 if (!peasycap->kref.refcount.counter) {
4290         SAY("ERROR: peasycap->kref.refcount.counter is zero " \
4291                                                 "so cannot call kref_put()\n");
4292         SAY("ending unsuccessfully: may cause memory leak\n");
4293         return;
4294 }
4295 JOT(4, "intf[%i]: kref_put() with %i=peasycap->kref.refcount.counter\n", \
4296                 bInterfaceNumber, (int)peasycap->kref.refcount.counter);
4297 kref_put(&peasycap->kref, easycap_delete);
4298 JOT(4, "intf[%i]: kref_put() done.\n", bInterfaceNumber);
4299 /*---------------------------------------------------------------------------*/
4300
4301 JOT(4, "ends\n");
4302 return;
4303 }
4304 /*****************************************************************************/
4305 int __init
4306 easycap_module_init(void)
4307 {
4308 int result;
4309
4310 SAY("========easycap=======\n");
4311 JOT(4, "begins.  %i=debug\n", easycap_debug);
4312 SAY("version: " EASYCAP_DRIVER_VERSION "\n");
4313 /*---------------------------------------------------------------------------*/
4314 /*
4315  *  REGISTER THIS DRIVER WITH THE USB SUBSYTEM.
4316  */
4317 /*---------------------------------------------------------------------------*/
4318 JOT(4, "registering driver easycap\n");
4319
4320 result = usb_register(&easycap_usb_driver);
4321 if (0 != result)
4322         SAY("ERROR:  usb_register returned %i\n", result);
4323
4324 JOT(4, "ends\n");
4325 return result;
4326 }
4327 /*****************************************************************************/
4328 void __exit
4329 easycap_module_exit(void)
4330 {
4331 JOT(4, "begins\n");
4332
4333 /*---------------------------------------------------------------------------*/
4334 /*
4335  *  DEREGISTER THIS DRIVER WITH THE USB SUBSYTEM.
4336  */
4337 /*---------------------------------------------------------------------------*/
4338 usb_deregister(&easycap_usb_driver);
4339
4340 JOT(4, "ends\n");
4341 }
4342 /*****************************************************************************/
4343
4344 module_init(easycap_module_init);
4345 module_exit(easycap_module_exit);
4346
4347 MODULE_LICENSE("GPL");
4348 MODULE_AUTHOR("R.M. Thomas <rmthomas@sciolus.org>");
4349 MODULE_DESCRIPTION(EASYCAP_DRIVER_DESCRIPTION);
4350 MODULE_VERSION(EASYCAP_DRIVER_VERSION);
4351 #if defined(EASYCAP_DEBUG)
4352 MODULE_PARM_DESC(easycap_debug, "debug: 0 (default), 1, 2,...");
4353 #endif /*EASYCAP_DEBUG*/
4354 /*****************************************************************************/