release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/staging/easycap/easycap_sound.c

   1 /******************************************************************************
   2 *                                                                             *
   3 *  easycap_sound.c                                                            *
   4 *                                                                             *
   5 *  Audio 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_debug.h"
  33 #include "easycap_sound.h"
  34
  35 /*****************************************************************************/
  36 /*---------------------------------------------------------------------------*/
  37 /*
  38  *  ON COMPLETION OF AN AUDIO URB ITS DATA IS COPIED TO THE AUDIO BUFFERS
  39  *  PROVIDED peasycap->audio_idle IS ZER0.  REGARDLESS OF THIS BEING TRUE,
  40  *  IT IS RESUBMITTED PROVIDED peasycap->audio_isoc_streaming IS NOT ZERO.
  41  */
  42 /*---------------------------------------------------------------------------*/
  43 void
  44 easysnd_complete(struct urb *purb)
  45 {
  46 static int mt;
  47 struct easycap *peasycap;
  48 struct data_buffer *paudio_buffer;
  49 char errbuf[16];
  50 __u8 *p1, *p2;
  51 __s16 s16;
  52 int i, j, more, much, leap, rc;
  53 #if defined(UPSAMPLE)
  54 int k;
  55 __s16 oldaudio, newaudio, delta;
  56 #endif /*UPSAMPLE*/
  57
  58 JOT(16, "\n");
  59
  60 if (NULL == purb) {
  61         SAY("ERROR: purb is NULL\n");
  62         return;
  63 }
  64 peasycap = purb->context;
  65 if (NULL == peasycap) {
  66         SAY("ERROR: peasycap is NULL\n");
  67         return;
  68 }
  69 much = 0;
  70
  71
  72 if (peasycap->audio_idle) {
  73         JOT(16, "%i=audio_idle  %i=audio_isoc_streaming\n", \
  74                         peasycap->audio_idle, peasycap->audio_isoc_streaming);
  75         if (peasycap->audio_isoc_streaming) {
  76                 rc = usb_submit_urb(purb, GFP_ATOMIC);
  77                 if (0 != rc) {
  78                         SAY("ERROR: while %i=audio_idle, " \
  79                                         "usb_submit_urb() failed with rc:\n", \
  80                                                         peasycap->audio_idle);
  81                         switch (rc) {
  82                         case -ENOMEM: {
  83                                 SAY("ENOMEM\n");    break;
  84                         }
  85                         case -ENODEV: {
  86                                 SAY("ENODEV\n");    break;
  87                         }
  88                         case -ENXIO: {
  89                                 SAY("ENXIO\n");     break;
  90                         }
  91                         case -EINVAL: {
  92                                 SAY("EINVAL\n");    break;
  93                         }
  94                         case -EAGAIN: {
  95                                 SAY("EAGAIN\n");    break;
  96                         }
  97                         case -EFBIG: {
  98                                 SAY("EFBIG\n");     break;
  99                         }
 100                         case -EPIPE: {
 101                                 SAY("EPIPE\n");     break;
 102                         }
 103                         case -EMSGSIZE: {
 104                                 SAY("EMSGSIZE\n");  break;
 105                         }
 106                         case -ENOSPC: {
 107                                 SAY("ENOSPC\n");  break;
 108                         }
 109                         default: {
 110                                 SAY("0x%08X\n", rc); break;
 111                         }
 112                         }
 113                 }
 114         }
 115 return;
 116 }
 117 /*---------------------------------------------------------------------------*/
 118 if (purb->status) {
 119         if (-ESHUTDOWN == purb->status) {
 120                 JOT(16, "immediate return because -ESHUTDOWN=purb->status\n");
 121                 return;
 122         }
 123         SAY("ERROR: non-zero urb status:\n");
 124         switch (purb->status) {
 125         case -EINPROGRESS: {
 126                 SAY("-EINPROGRESS\n"); break;
 127         }
 128         case -ENOSR: {
 129                 SAY("-ENOSR\n"); break;
 130         }
 131         case -EPIPE: {
 132                 SAY("-EPIPE\n"); break;
 133         }
 134         case -EOVERFLOW: {
 135                 SAY("-EOVERFLOW\n"); break;
 136         }
 137         case -EPROTO: {
 138                 SAY("-EPROTO\n"); break;
 139         }
 140         case -EILSEQ: {
 141                 SAY("-EILSEQ\n"); break;
 142         }
 143         case -ETIMEDOUT: {
 144                 SAY("-ETIMEDOUT\n"); break;
 145         }
 146         case -EMSGSIZE: {
 147                 SAY("-EMSGSIZE\n"); break;
 148         }
 149         case -EOPNOTSUPP: {
 150                 SAY("-EOPNOTSUPP\n"); break;
 151         }
 152         case -EPFNOSUPPORT: {
 153                 SAY("-EPFNOSUPPORT\n"); break;
 154         }
 155         case -EAFNOSUPPORT: {
 156                 SAY("-EAFNOSUPPORT\n"); break;
 157         }
 158         case -EADDRINUSE: {
 159                 SAY("-EADDRINUSE\n"); break;
 160         }
 161         case -EADDRNOTAVAIL: {
 162                 SAY("-EADDRNOTAVAIL\n"); break;
 163         }
 164         case -ENOBUFS: {
 165                 SAY("-ENOBUFS\n"); break;
 166         }
 167         case -EISCONN: {
 168                 SAY("-EISCONN\n"); break;
 169         }
 170         case -ENOTCONN: {
 171                 SAY("-ENOTCONN\n"); break;
 172         }
 173         case -ESHUTDOWN: {
 174                 SAY("-ESHUTDOWN\n"); break;
 175         }
 176         case -ENOENT: {
 177                 SAY("-ENOENT\n"); break;
 178         }
 179         case -ECONNRESET: {
 180                 SAY("-ECONNRESET\n"); break;
 181         }
 182         case -ENOSPC: {
 183                 SAY("ENOSPC\n");  break;
 184         }
 185         default: {
 186                 SAY("unknown error code 0x%08X\n", purb->status); break;
 187         }
 188         }
 189 /*---------------------------------------------------------------------------*/
 190 /*
 191  *  RESUBMIT THIS URB AFTER AN ERROR
 192  *
 193  *  (THIS IS DUPLICATE CODE TO REDUCE INDENTATION OF THE NO-ERROR PATH)
 194  */
 195 /*---------------------------------------------------------------------------*/
 196         if (peasycap->audio_isoc_streaming) {
 197                 rc = usb_submit_urb(purb, GFP_ATOMIC);
 198                 if (0 != rc) {
 199                         SAY("ERROR: while %i=audio_idle, usb_submit_urb() "
 200                                 "failed with rc:\n", peasycap->audio_idle);
 201                         switch (rc) {
 202                         case -ENOMEM: {
 203                                 SAY("ENOMEM\n");    break;
 204                         }
 205                         case -ENODEV: {
 206                                 SAY("ENODEV\n");    break;
 207                         }
 208                         case -ENXIO: {
 209                                 SAY("ENXIO\n");     break;
 210                         }
 211                         case -EINVAL: {
 212                                 SAY("EINVAL\n");    break;
 213                         }
 214                         case -EAGAIN: {
 215                                 SAY("EAGAIN\n");    break;
 216                         }
 217                         case -EFBIG: {
 218                                 SAY("EFBIG\n");     break;
 219                         }
 220                         case -EPIPE: {
 221                                 SAY("EPIPE\n");     break;
 222                         }
 223                         case -EMSGSIZE: {
 224                                 SAY("EMSGSIZE\n");  break;
 225                         }
 226                         default: {
 227                                 SAY("0x%08X\n", rc); break;
 228                         }
 229                         }
 230                 }
 231         }
 232         return;
 233 }
 234 /*---------------------------------------------------------------------------*/
 235 /*
 236  *  PROCEED HERE WHEN NO ERROR
 237  */
 238 /*---------------------------------------------------------------------------*/
 239 #if defined(UPSAMPLE)
 240 oldaudio = peasycap->oldaudio;
 241 #endif /*UPSAMPLE*/
 242
 243 for (i = 0;  i < purb->number_of_packets; i++) {
 244         switch (purb->iso_frame_desc[i].status) {
 245         case  0: {
 246                 strcpy(&errbuf[0], "OK"); break;
 247         }
 248         case -ENOENT: {
 249                 strcpy(&errbuf[0], "-ENOENT"); break;
 250         }
 251         case -EINPROGRESS: {
 252                 strcpy(&errbuf[0], "-EINPROGRESS"); break;
 253         }
 254         case -EPROTO: {
 255                 strcpy(&errbuf[0], "-EPROTO"); break;
 256         }
 257         case -EILSEQ: {
 258                 strcpy(&errbuf[0], "-EILSEQ"); break;
 259         }
 260         case -ETIME: {
 261                 strcpy(&errbuf[0], "-ETIME"); break;
 262         }
 263         case -ETIMEDOUT: {
 264                 strcpy(&errbuf[0], "-ETIMEDOUT"); break;
 265         }
 266         case -EPIPE: {
 267                 strcpy(&errbuf[0], "-EPIPE"); break;
 268         }
 269         case -ECOMM: {
 270                 strcpy(&errbuf[0], "-ECOMM"); break;
 271         }
 272         case -ENOSR: {
 273                 strcpy(&errbuf[0], "-ENOSR"); break;
 274         }
 275         case -EOVERFLOW: {
 276                 strcpy(&errbuf[0], "-EOVERFLOW"); break;
 277         }
 278         case -EREMOTEIO: {
 279                 strcpy(&errbuf[0], "-EREMOTEIO"); break;
 280         }
 281         case -ENODEV: {
 282                 strcpy(&errbuf[0], "-ENODEV"); break;
 283         }
 284         case -EXDEV: {
 285                 strcpy(&errbuf[0], "-EXDEV"); break;
 286         }
 287         case -EINVAL: {
 288                 strcpy(&errbuf[0], "-EINVAL"); break;
 289         }
 290         case -ECONNRESET: {
 291                 strcpy(&errbuf[0], "-ECONNRESET"); break;
 292         }
 293         case -ENOSPC: {
 294                 strcpy(&errbuf[0], "-ENOSPC"); break;
 295         }
 296         case -ESHUTDOWN: {
 297                 strcpy(&errbuf[0], "-ESHUTDOWN"); break;
 298         }
 299         default: {
 300                 strcpy(&errbuf[0], "UNKNOWN"); break;
 301         }
 302         }
 303         if ((!purb->iso_frame_desc[i].status) && 0) {
 304                 JOT(16, "frame[%2i]: %i=status{=%16s}  "  \
 305                                                 "%5i=actual  "  \
 306                                                 "%5i=length  "  \
 307                                                 "%3i=offset\n", \
 308                                 i, purb->iso_frame_desc[i].status, &errbuf[0],
 309                                 purb->iso_frame_desc[i].actual_length,
 310                                 purb->iso_frame_desc[i].length,
 311                                 purb->iso_frame_desc[i].offset);
 312         }
 313         if (!purb->iso_frame_desc[i].status) {
 314                 more = purb->iso_frame_desc[i].actual_length;
 315
 316 #if defined(TESTTONE)
 317                 if (!more)
 318                         more = purb->iso_frame_desc[i].length;
 319 #endif
 320
 321                 if (!more)
 322                         mt++;
 323                 else {
 324                         if (mt) {
 325                                 JOT(16, "%4i empty audio urb frames\n", mt);
 326                                 mt = 0;
 327                         }
 328
 329                         p1 = (__u8 *)(purb->transfer_buffer + \
 330                                         purb->iso_frame_desc[i].offset);
 331
 332                         leap = 0;
 333                         p1 += leap;
 334                         more -= leap;
 335 /*---------------------------------------------------------------------------*/
 336 /*
 337  *  COPY more BYTES FROM ISOC BUFFER TO AUDIO BUFFER,
 338  *  CONVERTING 8-BIT MONO TO 16-BIT SIGNED LITTLE-ENDIAN SAMPLES IF NECESSARY
 339  */
 340 /*---------------------------------------------------------------------------*/
 341                         while (more) {
 342                                 if (0 > more) {
 343                                         SAY("easysnd_complete: MISTAKE: " \
 344                                                         "more is negative\n");
 345                                         return;
 346                                 }
 347                                 if (peasycap->audio_buffer_page_many <= \
 348                                                         peasycap->audio_fill) {
 349                                         SAY("ERROR: bad " \
 350                                                 "peasycap->audio_fill\n");
 351                                         return;
 352                                 }
 353
 354                                 paudio_buffer = &peasycap->audio_buffer\
 355                                                         [peasycap->audio_fill];
 356                                 if (PAGE_SIZE < (paudio_buffer->pto - \
 357                                                 paudio_buffer->pgo)) {
 358                                         SAY("ERROR: bad paudio_buffer->pto\n");
 359                                         return;
 360                                 }
 361                                 if (PAGE_SIZE == (paudio_buffer->pto - \
 362                                                         paudio_buffer->pgo)) {
 363
 364 #if defined(TESTTONE)
 365                                         easysnd_testtone(peasycap, \
 366                                                         peasycap->audio_fill);
 367 #endif /*TESTTONE*/
 368
 369                                         paudio_buffer->pto = \
 370                                                         paudio_buffer->pgo;
 371                                         (peasycap->audio_fill)++;
 372                                         if (peasycap->\
 373                                                 audio_buffer_page_many <= \
 374                                                         peasycap->audio_fill)
 375                                                 peasycap->audio_fill = 0;
 376
 377                                         JOT(12, "bumped peasycap->" \
 378                                                         "audio_fill to %i\n", \
 379                                                         peasycap->audio_fill);
 380
 381                                         paudio_buffer = &peasycap->\
 382                                                         audio_buffer\
 383                                                         [peasycap->audio_fill];
 384                                         paudio_buffer->pto = \
 385                                                         paudio_buffer->pgo;
 386
 387                                         if (!(peasycap->audio_fill % \
 388                                                 peasycap->\
 389                                                 audio_pages_per_fragment)) {
 390                                                 JOT(12, "wakeup call on wq_" \
 391                                                 "audio, %i=frag reading  %i" \
 392                                                 "=fragment fill\n", \
 393                                                 (peasycap->audio_read / \
 394                                                 peasycap->\
 395                                                 audio_pages_per_fragment), \
 396                                                 (peasycap->audio_fill / \
 397                                                 peasycap->\
 398                                                 audio_pages_per_fragment));
 399                                                 wake_up_interruptible\
 400                                                 (&(peasycap->wq_audio));
 401                                         }
 402                                 }
 403
 404                                 much = PAGE_SIZE - (int)(paudio_buffer->pto -\
 405                                                          paudio_buffer->pgo);
 406
 407                                 if (false == peasycap->microphone) {
 408                                         if (much > more)
 409                                                 much = more;
 410
 411                                         memcpy(paudio_buffer->pto, p1, much);
 412                                         p1 += much;
 413                                         more -= much;
 414                                 } else {
 415 #if defined(UPSAMPLE)
 416                                         if (much % 16)
 417                                                 JOT(8, "MISTAKE? much" \
 418                                                 " is not divisible by 16\n");
 419                                         if (much > (16 * \
 420                                                         more))
 421                                                 much = 16 * \
 422                                                         more;
 423                                         p2 = (__u8 *)paudio_buffer->pto;
 424
 425                                         for (j = 0;  j < (much/16);  j++) {
 426                                                 newaudio =  ((int) *p1) - 128;
 427                                                 newaudio = 128 * \
 428                                                                 newaudio;
 429
 430                                                 delta = (newaudio - oldaudio) \
 431                                                                         / 4;
 432                                                 s16 = oldaudio + delta;
 433
 434                                                 for (k = 0;  k < 4;  k++) {
 435                                                         *p2 = (0x00FF & s16);
 436                                                         *(p2 + 1) = (0xFF00 & \
 437                                                                 s16) >> 8;
 438                                                         p2 += 2;
 439                                                         *p2 = (0x00FF & s16);
 440                                                         *(p2 + 1) = (0xFF00 & \
 441                                                                 s16) >> 8;
 442                                                         p2 += 2;
 443
 444                                                         s16 += delta;
 445                                                 }
 446                                                 p1++;
 447                                                 more--;
 448                                                 oldaudio = s16;
 449                                         }
 450 #else
 451                                         if (much > (2 * more))
 452                                                 much = 2 * more;
 453                                         p2 = (__u8 *)paudio_buffer->pto;
 454
 455                                         for (j = 0;  j < (much / 2);  j++) {
 456                                                 s16 =  ((int) *p1) - 128;
 457                                                 s16 = 128 * \
 458                                                                 s16;
 459                                                 *p2 = (0x00FF & s16);
 460                                                 *(p2 + 1) = (0xFF00 & s16) >> \
 461                                                                         8;
 462                                                 p1++;  p2 += 2;
 463                                                 more--;
 464                                         }
 465 #endif /*UPSAMPLE*/
 466                                 }
 467                                 (paudio_buffer->pto) += much;
 468                         }
 469                 }
 470         } else {
 471                 JOT(12, "discarding audio samples because " \
 472                         "%i=purb->iso_frame_desc[i].status\n", \
 473                                 purb->iso_frame_desc[i].status);
 474         }
 475
 476 #if defined(UPSAMPLE)
 477 peasycap->oldaudio = oldaudio;
 478 #endif /*UPSAMPLE*/
 479
 480 }
 481 /*---------------------------------------------------------------------------*/
 482 /*
 483  *  RESUBMIT THIS URB AFTER NO ERROR
 484  */
 485 /*---------------------------------------------------------------------------*/
 486 if (peasycap->audio_isoc_streaming) {
 487         rc = usb_submit_urb(purb, GFP_ATOMIC);
 488         if (0 != rc) {
 489                 SAY("ERROR: while %i=audio_idle, usb_submit_urb() failed " \
 490                                         "with rc:\n", peasycap->audio_idle);
 491                 switch (rc) {
 492                 case -ENOMEM: {
 493                         SAY("ENOMEM\n");    break;
 494                 }
 495                 case -ENODEV: {
 496                         SAY("ENODEV\n");    break;
 497                 }
 498                 case -ENXIO: {
 499                         SAY("ENXIO\n");     break;
 500                 }
 501                 case -EINVAL: {
 502                         SAY("EINVAL\n");    break;
 503                 }
 504                 case -EAGAIN: {
 505                         SAY("EAGAIN\n");    break;
 506                 }
 507                 case -EFBIG: {
 508                         SAY("EFBIG\n");     break;
 509                 }
 510                 case -EPIPE: {
 511                         SAY("EPIPE\n");     break;
 512                 }
 513                 case -EMSGSIZE: {
 514                         SAY("EMSGSIZE\n");  break;
 515                 }
 516                 case -ENOSPC: {
 517                         SAY("ENOSPC\n");  break;
 518                 }
 519                 default: {
 520                         SAY("0x%08X\n", rc); break;
 521                 }
 522                 }
 523         }
 524 }
 525 return;
 526 }
 527 /*****************************************************************************/
 528 /*---------------------------------------------------------------------------*/
 529 /*
 530  *  THE AUDIO URBS ARE SUBMITTED AT THIS EARLY STAGE SO THAT IT IS POSSIBLE TO
 531  *  STREAM FROM /dev/easysnd1 WITH SIMPLE PROGRAMS SUCH AS cat WHICH DO NOT
 532  *  HAVE AN IOCTL INTERFACE.  THE VIDEO URBS, BY CONTRAST, MUST BE SUBMITTED
 533  *  MUCH LATER: SEE COMMENTS IN FILE easycap_main.c.
 534  */
 535 /*---------------------------------------------------------------------------*/
 536 int
 537 easysnd_open(struct inode *inode, struct file *file)
 538 {
 539 struct usb_interface *pusb_interface;
 540 struct easycap *peasycap;
 541 int subminor, rc;
 542
 543 JOT(4, "begins.\n");
 544
 545 subminor = iminor(inode);
 546
 547 pusb_interface = usb_find_interface(&easycap_usb_driver, subminor);
 548 if (NULL == pusb_interface) {
 549         SAY("ERROR: pusb_interface is NULL\n");
 550         SAY("ending unsuccessfully\n");
 551         return -1;
 552 }
 553 peasycap = usb_get_intfdata(pusb_interface);
 554 if (NULL == peasycap) {
 555         SAY("ERROR: peasycap is NULL\n");
 556         SAY("ending unsuccessfully\n");
 557         return -1;
 558 }
 559
 560 file->private_data = peasycap;
 561
 562 /*---------------------------------------------------------------------------*/
 563 /*
 564  *  INITIALIZATION.
 565  */
 566 /*---------------------------------------------------------------------------*/
 567 JOT(4, "starting initialization\n");
 568
 569 if ((struct usb_device *)NULL == peasycap->pusb_device) {
 570         SAY("ERROR: peasycap->pusb_device is NULL\n");
 571         return -EFAULT;
 572 } else {
 573         JOT(16, "0x%08lX=peasycap->pusb_device\n", \
 574                                         (long int)peasycap->pusb_device);
 575 }
 576
 577 rc = audio_setup(peasycap);
 578 if (0 <= rc)
 579         JOT(8, "audio_setup() returned %i\n", rc);
 580 else
 581         JOT(8, "easysnd open(): ERROR: audio_setup() returned %i\n", rc);
 582
 583 if ((struct usb_device *)NULL == peasycap->pusb_device) {
 584         SAY("ERROR: peasycap->pusb_device has become NULL\n");
 585         return -EFAULT;
 586 }
 587 rc = adjust_volume(peasycap, -8192);
 588 if (0 != rc) {
 589         SAY("ERROR: adjust_volume(default) returned %i\n", rc);
 590         return -EFAULT;
 591 }
 592 /*---------------------------------------------------------------------------*/
 593 if ((struct usb_device *)NULL == peasycap->pusb_device) {
 594         SAY("ERROR: peasycap->pusb_device has become NULL\n");
 595         return -EFAULT;
 596 }
 597 rc = usb_set_interface(peasycap->pusb_device, peasycap->audio_interface, \
 598                                         peasycap->audio_altsetting_on);
 599 JOT(8, "usb_set_interface(.,%i,%i) returned %i\n", peasycap->audio_interface, \
 600                                         peasycap->audio_altsetting_on, rc);
 601
 602 if ((struct usb_device *)NULL == peasycap->pusb_device) {
 603         SAY("ERROR: peasycap->pusb_device has become NULL\n");
 604         return -EFAULT;
 605 }
 606 rc = wakeup_device(peasycap->pusb_device);
 607 if (0 == rc)
 608         JOT(8, "wakeup_device() returned %i\n", rc);
 609 else
 610         JOT(8, "easysnd open(): ERROR: wakeup_device() returned %i\n", rc);
 611
 612 if ((struct usb_device *)NULL == peasycap->pusb_device) {
 613         SAY("ERROR: peasycap->pusb_device has become NULL\n");
 614         return -EFAULT;
 615 }
 616 submit_audio_urbs(peasycap);
 617 peasycap->audio_idle = 0;
 618
 619 peasycap->timeval1.tv_sec  = 0;
 620 peasycap->timeval1.tv_usec = 0;
 621
 622 JOT(4, "finished initialization\n");
 623 return 0;
 624 }
 625 /*****************************************************************************/
 626 int
 627 easysnd_release(struct inode *inode, struct file *file)
 628 {
 629 struct easycap *peasycap;
 630
 631 JOT(4, "begins\n");
 632
 633 peasycap = file->private_data;
 634 if (NULL == peasycap) {
 635         SAY("ERROR:  peasycap is NULL.\n");
 636         return -EFAULT;
 637 }
 638 if (0 != kill_audio_urbs(peasycap)) {
 639         SAY("ERROR: kill_audio_urbs() failed\n");
 640         return -EFAULT;
 641 }
 642 JOT(4, "ending successfully\n");
 643 return 0;
 644 }
 645 /*****************************************************************************/
 646 ssize_t
 647 easysnd_read(struct file *file, char __user *puserspacebuffer, \
 648                                                 size_t kount, loff_t *poff)
 649 {
 650 struct timeval timeval;
 651 static struct timeval timeval1;
 652 static long long int audio_bytes, above, below, mean;
 653 struct signed_div_result sdr;
 654 unsigned char *p0;
 655 long int kount1, more, rc, l0, lm;
 656 int fragment;
 657 struct easycap *peasycap;
 658 struct data_buffer *pdata_buffer;
 659 size_t szret;
 660
 661 /*---------------------------------------------------------------------------*/
 662 /*
 663  *  DO A BLOCKING READ TO TRANSFER DATA TO USER SPACE.
 664  *
 665  ******************************************************************************
 666  *****  N.B.  IF THIS FUNCTION RETURNS 0, NOTHING IS SEEN IN USER SPACE. ******
 667  *****        THIS CONDITION SIGNIFIES END-OF-FILE.                      ******
 668  ******************************************************************************
 669  */
 670 /*---------------------------------------------------------------------------*/
 671
 672 JOT(8, "===== easysnd_read(): kount=%i, *poff=%i\n", (int)kount, (int)(*poff));
 673
 674 peasycap = (struct easycap *)(file->private_data);
 675 if (NULL == peasycap) {
 676         SAY("ERROR in easysnd_read(): peasycap is NULL\n");
 677         return -EFAULT;
 678 }
 679 /*---------------------------------------------------------------------------*/
 680 if ((0 > peasycap->audio_read) || \
 681                 (peasycap->audio_buffer_page_many <= peasycap->audio_read)) {
 682         SAY("ERROR: peasycap->audio_read out of range\n");
 683         return -EFAULT;
 684 }
 685 pdata_buffer = &peasycap->audio_buffer[peasycap->audio_read];
 686 if ((struct data_buffer *)NULL == pdata_buffer) {
 687         SAY("ERROR: pdata_buffer is NULL\n");
 688         return -EFAULT;
 689 }
 690 JOT(12, "before wait, %i=frag read  %i=frag fill\n", \
 691                 (peasycap->audio_read / peasycap->audio_pages_per_fragment), \
 692                 (peasycap->audio_fill / peasycap->audio_pages_per_fragment));
 693 fragment = (peasycap->audio_read / peasycap->audio_pages_per_fragment);
 694 while ((fragment == (peasycap->audio_fill / \
 695                                 peasycap->audio_pages_per_fragment)) || \
 696                 (0 == (PAGE_SIZE - (pdata_buffer->pto - pdata_buffer->pgo)))) {
 697         if (file->f_flags & O_NONBLOCK) {
 698                 JOT(16, "returning -EAGAIN as instructed\n");
 699                 return -EAGAIN;
 700         }
 701         rc = wait_event_interruptible(peasycap->wq_audio, \
 702                 (peasycap->audio_idle  || peasycap->audio_eof   || \
 703                 ((fragment != (peasycap->audio_fill / \
 704                                 peasycap->audio_pages_per_fragment)) && \
 705                 (0 < (PAGE_SIZE - (pdata_buffer->pto - pdata_buffer->pgo))))));
 706         if (0 != rc) {
 707                 SAY("aborted by signal\n");
 708                 return -ERESTARTSYS;
 709         }
 710         if (peasycap->audio_eof) {
 711                 JOT(8, "returning 0 because  %i=audio_eof\n", \
 712                                                         peasycap->audio_eof);
 713                 kill_audio_urbs(peasycap);
 714                 msleep(500);
 715                 return 0;
 716         }
 717         if (peasycap->audio_idle) {
 718                 JOT(16, "returning 0 because  %i=audio_idle\n", \
 719                                                         peasycap->audio_idle);
 720                 return 0;
 721         }
 722         if (!peasycap->audio_isoc_streaming) {
 723                 JOT(16, "returning 0 because audio urbs not streaming\n");
 724                 return 0;
 725         }
 726 }
 727 JOT(12, "after  wait, %i=frag read  %i=frag fill\n", \
 728                 (peasycap->audio_read / peasycap->audio_pages_per_fragment), \
 729                 (peasycap->audio_fill / peasycap->audio_pages_per_fragment));
 730 szret = (size_t)0;
 731 while (fragment == (peasycap->audio_read / \
 732                                 peasycap->audio_pages_per_fragment)) {
 733         if (NULL == pdata_buffer->pgo) {
 734                 SAY("ERROR: pdata_buffer->pgo is NULL\n");
 735                 return -EFAULT;
 736         }
 737         if (NULL == pdata_buffer->pto) {
 738                 SAY("ERROR: pdata_buffer->pto is NULL\n");
 739                 return -EFAULT;
 740         }
 741         kount1 = PAGE_SIZE - (pdata_buffer->pto - pdata_buffer->pgo);
 742         if (0 > kount1) {
 743                 SAY("easysnd_read: MISTAKE: kount1 is negative\n");
 744                 return -ERESTARTSYS;
 745         }
 746         if (!kount1) {
 747                 (peasycap->audio_read)++;
 748                 if (peasycap->audio_buffer_page_many <= peasycap->audio_read)
 749                         peasycap->audio_read = 0;
 750                 JOT(12, "bumped peasycap->audio_read to %i\n", \
 751                                                 peasycap->audio_read);
 752
 753                 if (fragment != (peasycap->audio_read / \
 754                                         peasycap->audio_pages_per_fragment))
 755                         break;
 756
 757                 if ((0 > peasycap->audio_read) || \
 758                         (peasycap->audio_buffer_page_many <= \
 759                                         peasycap->audio_read)) {
 760                         SAY("ERROR: peasycap->audio_read out of range\n");
 761                         return -EFAULT;
 762                 }
 763                 pdata_buffer = &peasycap->audio_buffer[peasycap->audio_read];
 764                 if ((struct data_buffer *)NULL == pdata_buffer) {
 765                         SAY("ERROR: pdata_buffer is NULL\n");
 766                         return -EFAULT;
 767                 }
 768                 if (NULL == pdata_buffer->pgo) {
 769                         SAY("ERROR: pdata_buffer->pgo is NULL\n");
 770                         return -EFAULT;
 771                 }
 772                 if (NULL == pdata_buffer->pto) {
 773                         SAY("ERROR: pdata_buffer->pto is NULL\n");
 774                         return -EFAULT;
 775                 }
 776                 kount1 = PAGE_SIZE - (pdata_buffer->pto - pdata_buffer->pgo);
 777         }
 778         JOT(12, "ready  to send %li bytes\n", (long int) kount1);
 779         JOT(12, "still  to send %li bytes\n", (long int) kount);
 780         more = kount1;
 781         if (more > kount)
 782                 more = kount;
 783         JOT(12, "agreed to send %li bytes from page %i\n", \
 784                                                 more, peasycap->audio_read);
 785         if (!more)
 786                 break;
 787
 788 /*---------------------------------------------------------------------------*/
 789 /*
 790  *  ACCUMULATE DYNAMIC-RANGE INFORMATION
 791  */
 792 /*---------------------------------------------------------------------------*/
 793         p0 = (unsigned char *)pdata_buffer->pgo;  l0 = 0;  lm = more/2;
 794         while (l0 < lm) {
 795                 SUMMER(p0, &peasycap->audio_sample, &peasycap->audio_niveau, \
 796                                 &peasycap->audio_square);  l0++;  p0 += 2;
 797         }
 798 /*---------------------------------------------------------------------------*/
 799         rc = copy_to_user(puserspacebuffer, pdata_buffer->pto, more);
 800         if (0 != rc) {
 801                 SAY("ERROR: copy_to_user() returned %li\n", rc);
 802                 return -EFAULT;
 803         }
 804         *poff += (loff_t)more;
 805         szret += (size_t)more;
 806         pdata_buffer->pto += more;
 807         puserspacebuffer += more;
 808         kount -= (size_t)more;
 809 }
 810 JOT(12, "after  read, %i=frag read  %i=frag fill\n", \
 811                 (peasycap->audio_read / peasycap->audio_pages_per_fragment), \
 812                 (peasycap->audio_fill / peasycap->audio_pages_per_fragment));
 813 if (kount < 0) {
 814         SAY("MISTAKE:  %li=kount  %li=szret\n", \
 815                                         (long int)kount, (long int)szret);
 816 }
 817 /*---------------------------------------------------------------------------*/
 818 /*
 819  *  CALCULATE DYNAMIC RANGE FOR (VAPOURWARE) AUTOMATIC VOLUME CONTROL
 820  */
 821 /*---------------------------------------------------------------------------*/
 822 if (peasycap->audio_sample) {
 823         below = peasycap->audio_sample;
 824         above = peasycap->audio_square;
 825         sdr = signed_div(above, below);
 826         above = sdr.quotient;
 827         mean = peasycap->audio_niveau;
 828         sdr = signed_div(mean, peasycap->audio_sample);
 829
 830         JOT(8, "%8lli=mean  %8lli=meansquare after %lli samples, =>\n", \
 831                                 sdr.quotient, above, peasycap->audio_sample);
 832
 833         sdr = signed_div(above, 32768);
 834         JOT(8, "audio dynamic range is roughly %lli\n", sdr.quotient);
 835 }
 836 /*---------------------------------------------------------------------------*/
 837 /*
 838  *  UPDATE THE AUDIO CLOCK
 839  */
 840 /*---------------------------------------------------------------------------*/
 841 do_gettimeofday(&timeval);
 842 if (!peasycap->timeval1.tv_sec) {
 843         audio_bytes = 0;
 844         timeval1 = timeval;
 845
 846         if (mutex_lock_interruptible(&(peasycap->mutex_timeval1)))
 847                 return -ERESTARTSYS;
 848         peasycap->timeval1 = timeval1;
 849         mutex_unlock(&(peasycap->mutex_timeval1));
 850         sdr.quotient = 192000;
 851 } else {
 852         audio_bytes += (long long int) szret;
 853         below = ((long long int)(1000000)) * \
 854                 ((long long int)(timeval.tv_sec  - timeval1.tv_sec)) + \
 855                 (long long int)(timeval.tv_usec - timeval1.tv_usec);
 856         above = 1000000 * ((long long int) audio_bytes);
 857
 858         if (below)
 859                 sdr = signed_div(above, below);
 860         else
 861                 sdr.quotient = 192000;
 862 }
 863 JOT(8, "audio streaming at %lli bytes/second\n", sdr.quotient);
 864 if (mutex_lock_interruptible(&(peasycap->mutex_timeval1)))
 865         return -ERESTARTSYS;
 866 peasycap->dnbydt = sdr.quotient;
 867 mutex_unlock(&(peasycap->mutex_timeval1));
 868
 869 JOT(8, "returning %li\n", (long int)szret);
 870 return szret;
 871 }
 872 /*****************************************************************************/
 873 /*---------------------------------------------------------------------------*/
 874 /*
 875  *  SUBMIT ALL AUDIO URBS.
 876  */
 877 /*---------------------------------------------------------------------------*/
 878 int
 879 submit_audio_urbs(struct easycap *peasycap)
 880 {
 881 struct data_urb *pdata_urb;
 882 struct urb *purb;
 883 struct list_head *plist_head;
 884 int j, isbad, m, rc;
 885 int isbuf;
 886
 887 if ((struct list_head *)NULL == peasycap->purb_audio_head) {
 888         SAY("ERROR: peasycap->urb_audio_head uninitialized\n");
 889         return -EFAULT;
 890 }
 891 if ((struct usb_device *)NULL == peasycap->pusb_device) {
 892         SAY("ERROR: peasycap->pusb_device is NULL\n");
 893         return -EFAULT;
 894 }
 895 if (!peasycap->audio_isoc_streaming) {
 896         JOT(4, "initial submission of all audio urbs\n");
 897         rc = usb_set_interface(peasycap->pusb_device,
 898                                         peasycap->audio_interface, \
 899                                         peasycap->audio_altsetting_on);
 900         JOT(8, "usb_set_interface(.,%i,%i) returned %i\n", \
 901                                         peasycap->audio_interface, \
 902                                         peasycap->audio_altsetting_on, rc);
 903
 904         isbad = 0;  m = 0;
 905         list_for_each(plist_head, (peasycap->purb_audio_head)) {
 906                 pdata_urb = list_entry(plist_head, struct data_urb, list_head);
 907                 if (NULL != pdata_urb) {
 908                         purb = pdata_urb->purb;
 909                         if (NULL != purb) {
 910                                 isbuf = pdata_urb->isbuf;
 911
 912                                 purb->interval = 1;
 913                                 purb->dev = peasycap->pusb_device;
 914                                 purb->pipe = \
 915                                         usb_rcvisocpipe(peasycap->pusb_device,\
 916                                         peasycap->audio_endpointnumber);
 917                                 purb->transfer_flags = URB_ISO_ASAP;
 918                                 purb->transfer_buffer = \
 919                                         peasycap->audio_isoc_buffer[isbuf].pgo;
 920                                 purb->transfer_buffer_length = \
 921                                         peasycap->audio_isoc_buffer_size;
 922                                 purb->complete = easysnd_complete;
 923                                 purb->context = peasycap;
 924                                 purb->start_frame = 0;
 925                                 purb->number_of_packets = \
 926                                         peasycap->audio_isoc_framesperdesc;
 927                                 for (j = 0;  j < peasycap->\
 928                                                 audio_isoc_framesperdesc; \
 929                                                                         j++) {
 930                                         purb->iso_frame_desc[j].offset = j * \
 931                                                 peasycap->\
 932                                                 audio_isoc_maxframesize;
 933                                         purb->iso_frame_desc[j].length = \
 934                                                 peasycap->\
 935                                                 audio_isoc_maxframesize;
 936                                 }
 937
 938                                 rc = usb_submit_urb(purb, GFP_KERNEL);
 939                                 if (0 != rc) {
 940                                         isbad++;
 941                                         SAY("ERROR: usb_submit_urb() failed" \
 942                                                         " for urb with rc:\n");
 943                                         switch (rc) {
 944                                         case -ENOMEM: {
 945                                                 SAY("ENOMEM\n"); break;
 946                                         }
 947                                         case -ENODEV: {
 948                                                 SAY("ENODEV\n"); break;
 949                                         }
 950                                         case -ENXIO: {
 951                                                 SAY("ENXIO\n"); break;
 952                                         }
 953                                         case -EINVAL: {
 954                                                 SAY("EINVAL\n"); break;
 955                                         }
 956                                         case -EAGAIN: {
 957                                                 SAY("EAGAIN\n"); break;
 958                                         }
 959                                         case -EFBIG: {
 960                                                 SAY("EFBIG\n"); break;
 961                                         }
 962                                         case -EPIPE: {
 963                                                 SAY("EPIPE\n"); break;
 964                                         }
 965                                         case -EMSGSIZE: {
 966                                                 SAY("EMSGSIZE\n"); break;
 967                                         }
 968                                         case -ENOSPC: {
 969                                                 SAY("ENOSPC\n"); break;
 970                                         }
 971                                         default: {
 972                                                 SAY("unknown error code %i\n",\
 973                                                                  rc); break;
 974                                         }
 975                                         }
 976                                 } else {
 977                                          m++;
 978                                 }
 979                         } else {
 980                                 isbad++;
 981                         }
 982                 } else {
 983                         isbad++;
 984                 }
 985         }
 986         if (isbad) {
 987                 JOT(4, "attempting cleanup instead of submitting\n");
 988                 list_for_each(plist_head, (peasycap->purb_audio_head)) {
 989                         pdata_urb = list_entry(plist_head, struct data_urb, \
 990                                                                 list_head);
 991                         if (NULL != pdata_urb) {
 992                                 purb = pdata_urb->purb;
 993                                 if (NULL != purb)
 994                                         usb_kill_urb(purb);
 995                         }
 996                 }
 997                 peasycap->audio_isoc_streaming = 0;
 998         } else {
 999                 peasycap->audio_isoc_streaming = 1;
1000                 JOT(4, "submitted %i audio urbs\n", m);
1001         }
1002 } else
1003         JOT(4, "already streaming audio urbs\n");
1004
1005 return 0;
1006 }
1007 /*****************************************************************************/
1008 /*---------------------------------------------------------------------------*/
1009 /*
1010  *  KILL ALL AUDIO URBS.
1011  */
1012 /*---------------------------------------------------------------------------*/
1013 int
1014 kill_audio_urbs(struct easycap *peasycap)
1015 {
1016 int m;
1017 struct list_head *plist_head;
1018 struct data_urb *pdata_urb;
1019
1020 if (peasycap->audio_isoc_streaming) {
1021         if ((struct list_head *)NULL != peasycap->purb_audio_head) {
1022                 peasycap->audio_isoc_streaming = 0;
1023                 JOT(4, "killing audio urbs\n");
1024                 m = 0;
1025                 list_for_each(plist_head, (peasycap->purb_audio_head)) {
1026                         pdata_urb = list_entry(plist_head, struct data_urb,
1027                                                                 list_head);
1028                         if ((struct data_urb *)NULL != pdata_urb) {
1029                                 if ((struct urb *)NULL != pdata_urb->purb) {
1030                                         usb_kill_urb(pdata_urb->purb);
1031                                         m++;
1032                                 }
1033                         }
1034                 }
1035                 JOT(4, "%i audio urbs killed\n", m);
1036         } else {
1037                 SAY("ERROR: peasycap->purb_audio_head is NULL\n");
1038                 return -EFAULT;
1039         }
1040 } else {
1041         JOT(8, "%i=audio_isoc_streaming, no audio urbs killed\n", \
1042                                         peasycap->audio_isoc_streaming);
1043 }
1044 return 0;
1045 }
1046 /*****************************************************************************/