sound/oss/emu10k1/audio.c

   1 /*
   2  **********************************************************************
   3  *     audio.c -- /dev/dsp interface for emu10k1 driver
   4  *     Copyright 1999, 2000 Creative Labs, Inc.
   5  *
   6  **********************************************************************
   7  *
   8  *     Date                 Author          Summary of changes
   9  *     ----                 ------          ------------------
  10  *     October 20, 1999     Bertrand Lee    base code release
  11  *     November 2, 1999     Alan Cox        cleaned up types/leaks
  12  *
  13  **********************************************************************
  14  *
  15  *     This program is free software; you can redistribute it and/or
  16  *     modify it under the terms of the GNU General Public License as
  17  *     published by the Free Software Foundation; either version 2 of
  18  *     the License, or (at your option) any later version.
  19  *
  20  *     This program is distributed in the hope that it will be useful,
  21  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  *     GNU General Public License for more details.
  24  *
  25  *     You should have received a copy of the GNU General Public
  26  *     License along with this program; if not, write to the Free
  27  *     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
  28  *     USA.
  29  *
  30  **********************************************************************
  31  */
  32
  33 #include <linux/module.h>
  34 #include <linux/poll.h>
  35 #include <linux/slab.h>
  36 #include <linux/bitops.h>
  37 #include <asm/io.h>
  38 #include <linux/sched.h>
  39 #include <linux/smp_lock.h>
  40
  41 #include "hwaccess.h"
  42 #include "cardwo.h"
  43 #include "cardwi.h"
  44 #include "recmgr.h"
  45 #include "irqmgr.h"
  46 #include "audio.h"
  47 #include "8010.h"
  48
  49 static void calculate_ofrag(struct woinst *);
  50 static void calculate_ifrag(struct wiinst *);
  51
  52 /* Audio file operations */
  53 static ssize_t emu10k1_audio_read(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
  54 {
  55         struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
  56         struct wiinst *wiinst = wave_dev->wiinst;
  57         ssize_t ret = 0;
  58         unsigned long flags;
  59
  60         DPD(3, "emu10k1_audio_read(), buffer=%p, count=%d\n", buffer, (u32) count);
  61
  62         if (ppos != &file->f_pos)
  63                 return -ESPIPE;
  64
  65         if (!access_ok(VERIFY_WRITE, buffer, count))
  66                 return -EFAULT;
  67
  68         spin_lock_irqsave(&wiinst->lock, flags);
  69
  70         if (wiinst->mmapped) {
  71                 spin_unlock_irqrestore(&wiinst->lock, flags);
  72                 return -ENXIO;
  73         }
  74
  75         if (wiinst->state == WAVE_STATE_CLOSED) {
  76                 calculate_ifrag(wiinst);
  77
  78                 while (emu10k1_wavein_open(wave_dev) < 0) {
  79                         spin_unlock_irqrestore(&wiinst->lock, flags);
  80
  81                         if (file->f_flags & O_NONBLOCK)
  82                                 return -EAGAIN;
  83
  84                         interruptible_sleep_on(&wave_dev->card->open_wait);
  85
  86                         if (signal_pending(current))
  87                                 return -ERESTARTSYS;
  88
  89                         spin_lock_irqsave(&wiinst->lock, flags);
  90                 }
  91         }
  92
  93         spin_unlock_irqrestore(&wiinst->lock, flags);
  94
  95         while (count > 0) {
  96                 u32 bytestocopy;
  97
  98                 spin_lock_irqsave(&wiinst->lock, flags);
  99
 100                 if (!(wiinst->state & WAVE_STATE_STARTED)
 101                     && (wave_dev->enablebits & PCM_ENABLE_INPUT))
 102                         emu10k1_wavein_start(wave_dev);
 103
 104                 emu10k1_wavein_update(wave_dev->card, wiinst);
 105                 emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
 106
 107                 spin_unlock_irqrestore(&wiinst->lock, flags);
 108
 109                 DPD(3, "bytestocopy --> %d\n", bytestocopy);
 110
 111                 if ((bytestocopy >= wiinst->buffer.fragment_size)
 112                     || (bytestocopy >= count)) {
 113                         bytestocopy = min_t(u32, bytestocopy, count);
 114
 115                         emu10k1_wavein_xferdata(wiinst, (u8 __user *)buffer, &bytestocopy);
 116
 117                         count -= bytestocopy;
 118                         buffer += bytestocopy;
 119                         ret += bytestocopy;
 120                 }
 121
 122                 if (count > 0) {
 123                         if ((file->f_flags & O_NONBLOCK)
 124                             || (!(wave_dev->enablebits & PCM_ENABLE_INPUT)))
 125                                 return (ret ? ret : -EAGAIN);
 126
 127                         interruptible_sleep_on(&wiinst->wait_queue);
 128
 129                         if (signal_pending(current))
 130                                 return (ret ? ret : -ERESTARTSYS);
 131
 132                 }
 133         }
 134
 135         DPD(3, "bytes copied -> %d\n", (u32) ret);
 136
 137         return ret;
 138 }
 139
 140 static ssize_t emu10k1_audio_write(struct file *file, const char __user *buffer, size_t count, loff_t * ppos)
 141 {
 142         struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
 143         struct woinst *woinst = wave_dev->woinst;
 144         ssize_t ret;
 145         unsigned long flags;
 146
 147         DPD(3, "emu10k1_audio_write(), buffer=%p, count=%d\n", buffer, (u32) count);
 148
 149         if (ppos != &file->f_pos)
 150                 return -ESPIPE;
 151
 152         if (!access_ok(VERIFY_READ, buffer, count))
 153                 return -EFAULT;
 154
 155         spin_lock_irqsave(&woinst->lock, flags);
 156
 157         if (woinst->mmapped) {
 158                 spin_unlock_irqrestore(&woinst->lock, flags);
 159                 return -ENXIO;
 160         }
 161         // This is for emu10k1 revs less than 7, we need to go through tram
 162         if (woinst->format.passthrough == 1) {
 163                 int r;
 164
 165                 woinst->buffer.ossfragshift = PT_BLOCKSIZE_LOG2;
 166                 woinst->buffer.numfrags = PT_BLOCKCOUNT;
 167                 calculate_ofrag(woinst);
 168
 169                 r = emu10k1_pt_write(file, buffer, count);
 170                 spin_unlock_irqrestore(&woinst->lock, flags);
 171                 return r;
 172         }
 173
 174         if (woinst->state == WAVE_STATE_CLOSED) {
 175                 calculate_ofrag(woinst);
 176
 177                 while (emu10k1_waveout_open(wave_dev) < 0) {
 178                         spin_unlock_irqrestore(&woinst->lock, flags);
 179
 180                         if (file->f_flags & O_NONBLOCK)
 181                                 return -EAGAIN;
 182
 183                         interruptible_sleep_on(&wave_dev->card->open_wait);
 184
 185                         if (signal_pending(current))
 186                                 return -ERESTARTSYS;
 187
 188                         spin_lock_irqsave(&woinst->lock, flags);
 189                 }
 190         }
 191
 192         spin_unlock_irqrestore(&woinst->lock, flags);
 193
 194         ret = 0;
 195         if (count % woinst->format.bytespersample)
 196                 return -EINVAL;
 197
 198         count /= woinst->num_voices;
 199
 200         while (count > 0) {
 201                 u32 bytestocopy;
 202
 203                 spin_lock_irqsave(&woinst->lock, flags);
 204                 emu10k1_waveout_update(woinst);
 205                 emu10k1_waveout_getxfersize(woinst, &bytestocopy);
 206                 spin_unlock_irqrestore(&woinst->lock, flags);
 207
 208                 DPD(3, "bytestocopy --> %d\n", bytestocopy);
 209
 210                 if ((bytestocopy >= woinst->buffer.fragment_size)
 211                     || (bytestocopy >= count)) {
 212
 213                         bytestocopy = min_t(u32, bytestocopy, count);
 214
 215                         emu10k1_waveout_xferdata(woinst, (u8 __user *) buffer, &bytestocopy);
 216
 217                         count -= bytestocopy;
 218                         buffer += bytestocopy * woinst->num_voices;
 219                         ret += bytestocopy * woinst->num_voices;
 220
 221                         spin_lock_irqsave(&woinst->lock, flags);
 222                         woinst->total_copied += bytestocopy;
 223
 224                         if (!(woinst->state & WAVE_STATE_STARTED)
 225                             && (wave_dev->enablebits & PCM_ENABLE_OUTPUT)
 226                             && (woinst->total_copied >= woinst->buffer.fragment_size))
 227                                 emu10k1_waveout_start(wave_dev);
 228
 229                         spin_unlock_irqrestore(&woinst->lock, flags);
 230                 }
 231
 232                 if (count > 0) {
 233                         if ((file->f_flags & O_NONBLOCK)
 234                             || (!(wave_dev->enablebits & PCM_ENABLE_OUTPUT)))
 235                                 return (ret ? ret : -EAGAIN);
 236
 237                         interruptible_sleep_on(&woinst->wait_queue);
 238
 239                         if (signal_pending(current))
 240                                 return (ret ? ret : -ERESTARTSYS);
 241                 }
 242         }
 243
 244         DPD(3, "bytes copied -> %d\n", (u32) ret);
 245
 246         return ret;
 247 }
 248
 249 static int emu10k1_audio_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 250 {
 251         struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
 252         struct woinst *woinst = NULL;
 253         struct wiinst *wiinst = NULL;
 254         int val = 0;
 255         u32 bytestocopy;
 256         unsigned long flags;
 257         int __user *p = (int __user *)arg;
 258
 259         DPF(4, "emu10k1_audio_ioctl()\n");
 260
 261         if (file->f_mode & FMODE_WRITE)
 262                 woinst = wave_dev->woinst;
 263
 264         if (file->f_mode & FMODE_READ)
 265                 wiinst = wave_dev->wiinst;
 266
 267         switch (cmd) {
 268         case OSS_GETVERSION:
 269                 DPF(2, "OSS_GETVERSION:\n");
 270                 return put_user(SOUND_VERSION, p);
 271
 272         case SNDCTL_DSP_RESET:
 273                 DPF(2, "SNDCTL_DSP_RESET:\n");
 274                 wave_dev->enablebits = PCM_ENABLE_OUTPUT | PCM_ENABLE_INPUT;
 275
 276                 if (file->f_mode & FMODE_WRITE) {
 277                         spin_lock_irqsave(&woinst->lock, flags);
 278
 279                         if (woinst->state & WAVE_STATE_OPEN) {
 280                                 emu10k1_waveout_close(wave_dev);
 281                         }
 282
 283                         woinst->mmapped = 0;
 284                         woinst->total_copied = 0;
 285                         woinst->total_played = 0;
 286                         woinst->blocks = 0;
 287
 288                         spin_unlock_irqrestore(&woinst->lock, flags);
 289                 }
 290
 291                 if (file->f_mode & FMODE_READ) {
 292                         spin_lock_irqsave(&wiinst->lock, flags);
 293
 294                         if (wiinst->state & WAVE_STATE_OPEN) {
 295                                 emu10k1_wavein_close(wave_dev);
 296                         }
 297
 298                         wiinst->mmapped = 0;
 299                         wiinst->total_recorded = 0;
 300                         wiinst->blocks = 0;
 301                         spin_unlock_irqrestore(&wiinst->lock, flags);
 302                 }
 303
 304                 break;
 305
 306         case SNDCTL_DSP_SYNC:
 307                 DPF(2, "SNDCTL_DSP_SYNC:\n");
 308
 309                 if (file->f_mode & FMODE_WRITE) {
 310
 311                         spin_lock_irqsave(&woinst->lock, flags);
 312
 313                         if (woinst->state & WAVE_STATE_OPEN) {
 314
 315                                 if (woinst->state & WAVE_STATE_STARTED)
 316                                         while ((woinst->total_played < woinst->total_copied)
 317                                                && !signal_pending(current)) {
 318                                                 spin_unlock_irqrestore(&woinst->lock, flags);
 319                                                 interruptible_sleep_on(&woinst->wait_queue);
 320                                                 spin_lock_irqsave(&woinst->lock, flags);
 321                                         }
 322                                 emu10k1_waveout_close(wave_dev);
 323                         }
 324
 325                         woinst->mmapped = 0;
 326                         woinst->total_copied = 0;
 327                         woinst->total_played = 0;
 328                         woinst->blocks = 0;
 329
 330                         spin_unlock_irqrestore(&woinst->lock, flags);
 331                 }
 332
 333                 if (file->f_mode & FMODE_READ) {
 334                         spin_lock_irqsave(&wiinst->lock, flags);
 335
 336                         if (wiinst->state & WAVE_STATE_OPEN) {
 337                                 emu10k1_wavein_close(wave_dev);
 338                         }
 339
 340                         wiinst->mmapped = 0;
 341                         wiinst->total_recorded = 0;
 342                         wiinst->blocks = 0;
 343                         spin_unlock_irqrestore(&wiinst->lock, flags);
 344                 }
 345
 346                 break;
 347
 348         case SNDCTL_DSP_SETDUPLEX:
 349                 DPF(2, "SNDCTL_DSP_SETDUPLEX:\n");
 350                 break;
 351
 352         case SNDCTL_DSP_GETCAPS:
 353                 DPF(2, "SNDCTL_DSP_GETCAPS:\n");
 354                 return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME |
 355                                 DSP_CAP_TRIGGER | DSP_CAP_MMAP |
 356                                 DSP_CAP_COPROC| DSP_CAP_MULTI, p);
 357         case SNDCTL_DSP_SPEED:
 358                 DPF(2, "SNDCTL_DSP_SPEED:\n");
 359
 360                 if (get_user(val, p))
 361                         return -EFAULT;
 362
 363                 DPD(2, "val is %d\n", val);
 364
 365                 if (val > 0) {
 366                         if (file->f_mode & FMODE_READ) {
 367                                 struct wave_format format;
 368
 369                                 spin_lock_irqsave(&wiinst->lock, flags);
 370
 371                                 format = wiinst->format;
 372                                 format.samplingrate = val;
 373
 374                                 if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
 375                                         spin_unlock_irqrestore(&wiinst->lock, flags);
 376                                         return -EINVAL;
 377                                 }
 378
 379                                 val = wiinst->format.samplingrate;
 380
 381                                 spin_unlock_irqrestore(&wiinst->lock, flags);
 382
 383                                 DPD(2, "set recording sampling rate -> %d\n", val);
 384                         }
 385
 386                         if (file->f_mode & FMODE_WRITE) {
 387                                 struct wave_format format;
 388
 389                                 spin_lock_irqsave(&woinst->lock, flags);
 390
 391                                 format = woinst->format;
 392                                 format.samplingrate = val;
 393
 394                                 if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
 395                                         spin_unlock_irqrestore(&woinst->lock, flags);
 396                                         return -EINVAL;
 397                                 }
 398
 399                                 val = woinst->format.samplingrate;
 400
 401                                 spin_unlock_irqrestore(&woinst->lock, flags);
 402
 403                                 DPD(2, "set playback sampling rate -> %d\n", val);
 404                         }
 405
 406                         return put_user(val, p);
 407                 } else {
 408                         if (file->f_mode & FMODE_READ)
 409                                 val = wiinst->format.samplingrate;
 410                         else if (file->f_mode & FMODE_WRITE)
 411                                 val = woinst->format.samplingrate;
 412
 413                         return put_user(val, p);
 414                 }
 415                 break;
 416
 417         case SNDCTL_DSP_STEREO:
 418                 DPF(2, "SNDCTL_DSP_STEREO:\n");
 419
 420                 if (get_user(val, p))
 421                         return -EFAULT;
 422
 423                 DPD(2, " val is %d\n", val);
 424
 425                 if (file->f_mode & FMODE_READ) {
 426                         struct wave_format format;
 427
 428                         spin_lock_irqsave(&wiinst->lock, flags);
 429
 430                         format = wiinst->format;
 431                         format.channels = val ? 2 : 1;
 432
 433                         if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
 434                                 spin_unlock_irqrestore(&wiinst->lock, flags);
 435                                 return -EINVAL;
 436                         }
 437
 438                         val = wiinst->format.channels - 1;
 439
 440                         spin_unlock_irqrestore(&wiinst->lock, flags);
 441                         DPD(2, "set recording stereo -> %d\n", val);
 442                 }
 443
 444                 if (file->f_mode & FMODE_WRITE) {
 445                         struct wave_format format;
 446
 447                         spin_lock_irqsave(&woinst->lock, flags);
 448
 449                         format = woinst->format;
 450                         format.channels = val ? 2 : 1;
 451
 452                         if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
 453                                 spin_unlock_irqrestore(&woinst->lock, flags);
 454                                 return -EINVAL;
 455                         }
 456
 457                         val = woinst->format.channels - 1;
 458
 459                         spin_unlock_irqrestore(&woinst->lock, flags);
 460
 461                         DPD(2, "set playback stereo -> %d\n", val);
 462                 }
 463
 464                 return put_user(val, p);
 465
 466                 break;
 467
 468         case SNDCTL_DSP_CHANNELS:
 469                 DPF(2, "SNDCTL_DSP_CHANNELS:\n");
 470
 471                 if (get_user(val, p))
 472                         return -EFAULT;
 473
 474                 DPD(2, " val is %d\n", val);
 475
 476                 if (val > 0) {
 477                         if (file->f_mode & FMODE_READ) {
 478                                 struct wave_format format;
 479
 480                                 spin_lock_irqsave(&wiinst->lock, flags);
 481
 482                                 format = wiinst->format;
 483                                 format.channels = val;
 484
 485                                 if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
 486                                         spin_unlock_irqrestore(&wiinst->lock, flags);
 487                                         return -EINVAL;
 488                                 }
 489                                 val = wiinst->format.channels;
 490
 491                                 spin_unlock_irqrestore(&wiinst->lock, flags);
 492                                 DPD(2, "set recording number of channels -> %d\n", val);
 493                         }
 494
 495                         if (file->f_mode & FMODE_WRITE) {
 496                                 struct wave_format format;
 497
 498                                 spin_lock_irqsave(&woinst->lock, flags);
 499
 500                                 format = woinst->format;
 501                                 format.channels = val;
 502
 503                                 if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
 504                                         spin_unlock_irqrestore(&woinst->lock, flags);
 505                                         return -EINVAL;
 506                                 }
 507
 508                                 val = woinst->format.channels;
 509
 510                                 spin_unlock_irqrestore(&woinst->lock, flags);
 511                                 DPD(2, "set playback number of channels -> %d\n", val);
 512                         }
 513
 514                         return put_user(val, p);
 515                 } else {
 516                         if (file->f_mode & FMODE_READ)
 517                                 val = wiinst->format.channels;
 518                         else if (file->f_mode & FMODE_WRITE)
 519                                 val = woinst->format.channels;
 520
 521                         return put_user(val, p);
 522                 }
 523                 break;
 524
 525         case SNDCTL_DSP_GETFMTS:
 526                 DPF(2, "SNDCTL_DSP_GETFMTS:\n");
 527
 528                 if (file->f_mode & FMODE_READ)
 529                         val = AFMT_S16_LE;
 530                 else if (file->f_mode & FMODE_WRITE) {
 531                         val = AFMT_S16_LE | AFMT_U8;
 532                         if (emu10k1_find_control_gpr(&wave_dev->card->mgr,
 533                                                      wave_dev->card->pt.patch_name,
 534                                                      wave_dev->card->pt.enable_gpr_name) >= 0)
 535                                 val |= AFMT_AC3;
 536                 }
 537                 return put_user(val, p);
 538
 539         case SNDCTL_DSP_SETFMT: /* Same as SNDCTL_DSP_SAMPLESIZE */
 540                 DPF(2, "SNDCTL_DSP_SETFMT:\n");
 541
 542                 if (get_user(val, p))
 543                         return -EFAULT;
 544
 545                 DPD(2, " val is %d\n", val);
 546
 547                 if (val != AFMT_QUERY) {
 548                         if (file->f_mode & FMODE_READ) {
 549                                 struct wave_format format;
 550
 551                                 spin_lock_irqsave(&wiinst->lock, flags);
 552
 553                                 format = wiinst->format;
 554                                 format.id = val;
 555
 556                                 if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
 557                                         spin_unlock_irqrestore(&wiinst->lock, flags);
 558                                         return -EINVAL;
 559                                 }
 560
 561                                 val = wiinst->format.id;
 562
 563                                 spin_unlock_irqrestore(&wiinst->lock, flags);
 564                                 DPD(2, "set recording format -> %d\n", val);
 565                         }
 566
 567                         if (file->f_mode & FMODE_WRITE) {
 568                                 struct wave_format format;
 569
 570                                 spin_lock_irqsave(&woinst->lock, flags);
 571
 572                                 format = woinst->format;
 573                                 format.id = val;
 574
 575                                 if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
 576                                         spin_unlock_irqrestore(&woinst->lock, flags);
 577                                         return -EINVAL;
 578                                 }
 579
 580                                 val = woinst->format.id;
 581
 582                                 spin_unlock_irqrestore(&woinst->lock, flags);
 583                                 DPD(2, "set playback format -> %d\n", val);
 584                         }
 585
 586                         return put_user(val, p);
 587                 } else {
 588                         if (file->f_mode & FMODE_READ)
 589                                 val = wiinst->format.id;
 590                         else if (file->f_mode & FMODE_WRITE)
 591                                 val = woinst->format.id;
 592
 593                         return put_user(val, p);
 594                 }
 595                 break;
 596
 597         case SOUND_PCM_READ_BITS:
 598
 599                 if (file->f_mode & FMODE_READ)
 600                         val = wiinst->format.bitsperchannel;
 601                 else if (file->f_mode & FMODE_WRITE)
 602                         val = woinst->format.bitsperchannel;
 603
 604                 return put_user(val, p);
 605
 606         case SOUND_PCM_READ_RATE:
 607
 608                 if (file->f_mode & FMODE_READ)
 609                         val = wiinst->format.samplingrate;
 610                 else if (file->f_mode & FMODE_WRITE)
 611                         val = woinst->format.samplingrate;
 612
 613                 return put_user(val, p);
 614
 615         case SOUND_PCM_READ_CHANNELS:
 616
 617                 if (file->f_mode & FMODE_READ)
 618                         val = wiinst->format.channels;
 619                 else if (file->f_mode & FMODE_WRITE)
 620                         val = woinst->format.channels;
 621
 622                 return put_user(val, p);
 623
 624         case SOUND_PCM_WRITE_FILTER:
 625                 DPF(2, "SOUND_PCM_WRITE_FILTER: not implemented\n");
 626                 break;
 627
 628         case SOUND_PCM_READ_FILTER:
 629                 DPF(2, "SOUND_PCM_READ_FILTER: not implemented\n");
 630                 break;
 631
 632         case SNDCTL_DSP_SETSYNCRO:
 633                 DPF(2, "SNDCTL_DSP_SETSYNCRO: not implemented\n");
 634                 break;
 635
 636         case SNDCTL_DSP_GETTRIGGER:
 637                 DPF(2, "SNDCTL_DSP_GETTRIGGER:\n");
 638
 639                 if (file->f_mode & FMODE_WRITE && (wave_dev->enablebits & PCM_ENABLE_OUTPUT))
 640                         val |= PCM_ENABLE_OUTPUT;
 641
 642                 if (file->f_mode & FMODE_READ && (wave_dev->enablebits & PCM_ENABLE_INPUT))
 643                         val |= PCM_ENABLE_INPUT;
 644
 645                 return put_user(val, p);
 646
 647         case SNDCTL_DSP_SETTRIGGER:
 648                 DPF(2, "SNDCTL_DSP_SETTRIGGER:\n");
 649
 650                 if (get_user(val, p))
 651                         return -EFAULT;
 652
 653                 if (file->f_mode & FMODE_WRITE) {
 654                         spin_lock_irqsave(&woinst->lock, flags);
 655
 656                         if (val & PCM_ENABLE_OUTPUT) {
 657                                 wave_dev->enablebits |= PCM_ENABLE_OUTPUT;
 658                                 if (woinst->state & WAVE_STATE_OPEN)
 659                                         emu10k1_waveout_start(wave_dev);
 660                         } else {
 661                                 wave_dev->enablebits &= ~PCM_ENABLE_OUTPUT;
 662                                 if (woinst->state & WAVE_STATE_STARTED)
 663                                         emu10k1_waveout_stop(wave_dev);
 664                         }
 665
 666                         spin_unlock_irqrestore(&woinst->lock, flags);
 667                 }
 668
 669                 if (file->f_mode & FMODE_READ) {
 670                         spin_lock_irqsave(&wiinst->lock, flags);
 671
 672                         if (val & PCM_ENABLE_INPUT) {
 673                                 wave_dev->enablebits |= PCM_ENABLE_INPUT;
 674                                 if (wiinst->state & WAVE_STATE_OPEN)
 675                                         emu10k1_wavein_start(wave_dev);
 676                         } else {
 677                                 wave_dev->enablebits &= ~PCM_ENABLE_INPUT;
 678                                 if (wiinst->state & WAVE_STATE_STARTED)
 679                                         emu10k1_wavein_stop(wave_dev);
 680                         }
 681
 682                         spin_unlock_irqrestore(&wiinst->lock, flags);
 683                 }
 684                 break;
 685
 686         case SNDCTL_DSP_GETOSPACE:
 687                 {
 688                         audio_buf_info info;
 689
 690                         DPF(4, "SNDCTL_DSP_GETOSPACE:\n");
 691
 692                         if (!(file->f_mode & FMODE_WRITE))
 693                                 return -EINVAL;
 694
 695                         spin_lock_irqsave(&woinst->lock, flags);
 696
 697                         if (woinst->state & WAVE_STATE_OPEN) {
 698                                 emu10k1_waveout_update(woinst);
 699                                 emu10k1_waveout_getxfersize(woinst, &bytestocopy);
 700                                 info.bytes = bytestocopy;
 701                         } else {
 702                                 calculate_ofrag(woinst);
 703                                 info.bytes = woinst->buffer.size;
 704                         }
 705                         spin_unlock_irqrestore(&woinst->lock, flags);
 706
 707                         info.bytes *= woinst->num_voices;
 708                         info.fragsize = woinst->buffer.fragment_size * woinst->num_voices;
 709                         info.fragstotal = woinst->buffer.numfrags * woinst->num_voices;
 710                         info.fragments = info.bytes / info.fragsize;
 711
 712                         if (copy_to_user(p, &info, sizeof(info)))
 713                                 return -EFAULT;
 714                 }
 715                 break;
 716
 717         case SNDCTL_DSP_GETISPACE:
 718                 {
 719                         audio_buf_info info;
 720
 721                         DPF(4, "SNDCTL_DSP_GETISPACE:\n");
 722
 723                         if (!(file->f_mode & FMODE_READ))
 724                                 return -EINVAL;
 725
 726                         spin_lock_irqsave(&wiinst->lock, flags);
 727                         if (wiinst->state & WAVE_STATE_OPEN) {
 728                                 emu10k1_wavein_update(wave_dev->card, wiinst);
 729                                 emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
 730                                 info.bytes = bytestocopy;
 731                         } else {
 732                                 calculate_ifrag(wiinst);
 733                                 info.bytes = 0;
 734                         }
 735                         spin_unlock_irqrestore(&wiinst->lock, flags);
 736
 737                         info.fragstotal = wiinst->buffer.numfrags;
 738                         info.fragments = info.bytes / wiinst->buffer.fragment_size;
 739                         info.fragsize = wiinst->buffer.fragment_size;
 740
 741                         if (copy_to_user(p, &info, sizeof(info)))
 742                                 return -EFAULT;
 743                 }
 744                 break;
 745
 746         case SNDCTL_DSP_NONBLOCK:
 747                 DPF(2, "SNDCTL_DSP_NONBLOCK:\n");
 748
 749                 file->f_flags |= O_NONBLOCK;
 750                 break;
 751
 752         case SNDCTL_DSP_GETODELAY:
 753                 DPF(4, "SNDCTL_DSP_GETODELAY:\n");
 754
 755                 if (!(file->f_mode & FMODE_WRITE))
 756                         return -EINVAL;
 757
 758                 spin_lock_irqsave(&woinst->lock, flags);
 759                 if (woinst->state & WAVE_STATE_OPEN) {
 760                         emu10k1_waveout_update(woinst);
 761                         emu10k1_waveout_getxfersize(woinst, &bytestocopy);
 762                         val = woinst->buffer.size - bytestocopy;
 763                 } else
 764                         val = 0;
 765
 766                 val *= woinst->num_voices;
 767                 spin_unlock_irqrestore(&woinst->lock, flags);
 768
 769                 return put_user(val, p);
 770
 771         case SNDCTL_DSP_GETIPTR:
 772                 {
 773                         count_info cinfo;
 774
 775                         DPF(4, "SNDCTL_DSP_GETIPTR: \n");
 776
 777                         if (!(file->f_mode & FMODE_READ))
 778                                 return -EINVAL;
 779
 780                         spin_lock_irqsave(&wiinst->lock, flags);
 781
 782                         if (wiinst->state & WAVE_STATE_OPEN) {
 783                                 emu10k1_wavein_update(wave_dev->card, wiinst);
 784                                 cinfo.ptr = wiinst->buffer.hw_pos;
 785                                 cinfo.bytes = cinfo.ptr + wiinst->total_recorded - wiinst->total_recorded % wiinst->buffer.size;
 786                                 cinfo.blocks = cinfo.bytes / wiinst->buffer.fragment_size - wiinst->blocks;
 787                                 wiinst->blocks = cinfo.bytes / wiinst->buffer.fragment_size;
 788                         } else {
 789                                 cinfo.ptr = 0;
 790                                 cinfo.bytes = 0;
 791                                 cinfo.blocks = 0;
 792                         }
 793
 794                         if (wiinst->mmapped)
 795                                 wiinst->buffer.bytestocopy %= wiinst->buffer.fragment_size;
 796
 797                         spin_unlock_irqrestore(&wiinst->lock, flags);
 798
 799                         if (copy_to_user(p, &cinfo, sizeof(cinfo)))
 800                                 return -EFAULT;
 801                 }
 802                 break;
 803
 804         case SNDCTL_DSP_GETOPTR:
 805                 {
 806                         count_info cinfo;
 807
 808                         DPF(4, "SNDCTL_DSP_GETOPTR:\n");
 809
 810                         if (!(file->f_mode & FMODE_WRITE))
 811                                 return -EINVAL;
 812
 813                         spin_lock_irqsave(&woinst->lock, flags);
 814
 815                         if (woinst->state & WAVE_STATE_OPEN ||
 816                             ((woinst->format.passthrough == 1) && wave_dev->card->pt.state)) {
 817                                 int num_fragments;
 818
 819                                 if (woinst->format.passthrough == 1) {
 820                                         emu10k1_pt_waveout_update(wave_dev);
 821                                         cinfo.bytes = woinst->total_played;
 822                                 } else {
 823                                         emu10k1_waveout_update(woinst);
 824                                         cinfo.bytes = woinst->total_played;
 825                                 }
 826
 827                                 cinfo.ptr = woinst->buffer.hw_pos;
 828                                 num_fragments = cinfo.bytes / woinst->buffer.fragment_size;
 829                                 cinfo.blocks = num_fragments - woinst->blocks;
 830                                 woinst->blocks = num_fragments;
 831
 832                                 cinfo.bytes *= woinst->num_voices;
 833                                 cinfo.ptr *= woinst->num_voices;
 834                         } else {
 835                                 cinfo.ptr = 0;
 836                                 cinfo.bytes = 0;
 837                                 cinfo.blocks = 0;
 838                         }
 839
 840                         if (woinst->mmapped)
 841                                 woinst->buffer.free_bytes %= woinst->buffer.fragment_size;
 842
 843                         spin_unlock_irqrestore(&woinst->lock, flags);
 844
 845                         if (copy_to_user(p, &cinfo, sizeof(cinfo)))
 846                                 return -EFAULT;
 847                 }
 848                 break;
 849
 850         case SNDCTL_DSP_GETBLKSIZE:
 851                 DPF(2, "SNDCTL_DSP_GETBLKSIZE:\n");
 852
 853                 if (file->f_mode & FMODE_WRITE) {
 854                         spin_lock_irqsave(&woinst->lock, flags);
 855
 856                         calculate_ofrag(woinst);
 857                         val = woinst->buffer.fragment_size * woinst->num_voices;
 858
 859                         spin_unlock_irqrestore(&woinst->lock, flags);
 860                 }
 861
 862                 if (file->f_mode & FMODE_READ) {
 863                         spin_lock_irqsave(&wiinst->lock, flags);
 864
 865                         calculate_ifrag(wiinst);
 866                         val = wiinst->buffer.fragment_size;
 867
 868                         spin_unlock_irqrestore(&wiinst->lock, flags);
 869                 }
 870
 871                 return put_user(val, p);
 872
 873                 break;
 874
 875         case SNDCTL_DSP_POST:
 876                 if (file->f_mode & FMODE_WRITE) {
 877                         spin_lock_irqsave(&woinst->lock, flags);
 878
 879                         if (!(woinst->state & WAVE_STATE_STARTED)
 880                             && (wave_dev->enablebits & PCM_ENABLE_OUTPUT)
 881                             && (woinst->total_copied > 0))
 882                                 emu10k1_waveout_start(wave_dev);
 883
 884                         spin_unlock_irqrestore(&woinst->lock, flags);
 885                 }
 886
 887                 break;
 888
 889         case SNDCTL_DSP_SUBDIVIDE:
 890                 DPF(2, "SNDCTL_DSP_SUBDIVIDE: not implemented\n");
 891                 break;
 892
 893         case SNDCTL_DSP_SETFRAGMENT:
 894                 DPF(2, "SNDCTL_DSP_SETFRAGMENT:\n");
 895
 896                 if (get_user(val, p))
 897                         return -EFAULT;
 898
 899                 DPD(2, "val is %#x\n", val);
 900
 901                 if (val == 0)
 902                         return -EIO;
 903
 904                 if (file->f_mode & FMODE_WRITE) {
 905                         /* digital pass-through fragment count and size are fixed values */
 906                         if (woinst->state & WAVE_STATE_OPEN || (woinst->format.passthrough == 1))
 907                                 return -EINVAL; /* too late to change */
 908
 909                         woinst->buffer.ossfragshift = val & 0xffff;
 910                         woinst->buffer.numfrags = (val >> 16) & 0xffff;
 911                 }
 912
 913                 if (file->f_mode & FMODE_READ) {
 914                         if (wiinst->state & WAVE_STATE_OPEN)
 915                                 return -EINVAL; /* too late to change */
 916
 917                         wiinst->buffer.ossfragshift = val & 0xffff;
 918                         wiinst->buffer.numfrags = (val >> 16) & 0xffff;
 919                 }
 920
 921                 break;
 922
 923         case SNDCTL_COPR_LOAD:
 924                 {
 925                         copr_buffer *buf;
 926                         u32 i;
 927
 928                         DPF(4, "SNDCTL_COPR_LOAD:\n");
 929
 930                         buf = kmalloc(sizeof(copr_buffer), GFP_KERNEL);
 931                         if (!buf)
 932                                 return -ENOMEM;
 933
 934                         if (copy_from_user(buf, p, sizeof(copr_buffer))) {
 935                                 kfree (buf);
 936                                 return -EFAULT;
 937                         }
 938
 939                         if ((buf->command != CMD_READ) && (buf->command != CMD_WRITE)) {
 940                                 kfree (buf);
 941                                 return -EINVAL;
 942                         }
 943
 944                         if (buf->command == CMD_WRITE) {
 945
 946 #ifdef DBGEMU
 947                                 if ((buf->offs < 0) || (buf->offs + buf->len > 0xe00) || (buf->len > 1000)) {
 948 #else
 949                                 if (((buf->offs < 0x100) || (buf->offs + buf->len > (wave_dev->card->is_audigy ? 0xe00 : 0x800)) || (buf->len > 1000)
 950                                 ) && !(
 951                                         //any register allowed raw access to users goes here:
 952                                         (buf->offs == DBG ||
 953                                           buf->offs == A_DBG)
 954                                         && (buf->len == 1))) {
 955 #endif
 956                                         kfree(buf);
 957                                         return -EINVAL;
 958                                 }
 959                         } else {
 960                                 if ((buf->offs < 0) || (buf->offs + buf->len > 0xe00) || (buf->len > 1000)) {
 961                                         kfree(buf);
 962                                         return -EINVAL;
 963                                 }
 964                         }
 965
 966                         if (((unsigned)buf->flags) > 0x3f)
 967                                 buf->flags = 0;
 968
 969                         if (buf->command == CMD_READ) {
 970                                 for (i = 0; i < buf->len; i++)
 971                                         ((u32 *) buf->data)[i] = sblive_readptr(wave_dev->card, buf->offs + i, buf->flags);
 972
 973                                 if (copy_to_user(p, buf, sizeof(copr_buffer))) {
 974                                         kfree(buf);
 975                                         return -EFAULT;
 976                                 }
 977                         } else {
 978                                 for (i = 0; i < buf->len; i++)
 979                                         sblive_writeptr(wave_dev->card, buf->offs + i, buf->flags, ((u32 *) buf->data)[i]);
 980                         }
 981
 982                         kfree (buf);
 983                         break;
 984                 }
 985
 986         default:                /* Default is unrecognized command */
 987                 DPD(2, "default: %#x\n", cmd);
 988                 return -EINVAL;
 989         }
 990         return 0;
 991 }
 992
 993 static struct page *emu10k1_mm_nopage (struct vm_area_struct * vma, unsigned long address, int *type)
 994 {
 995         struct emu10k1_wavedevice *wave_dev = vma->vm_private_data;
 996         struct woinst *woinst = wave_dev->woinst;
 997         struct wiinst *wiinst = wave_dev->wiinst;
 998         struct page *dmapage;
 999         unsigned long pgoff;
1000         int rd, wr;
1001
1002         DPF(3, "emu10k1_mm_nopage()\n");
1003         DPD(3, "addr: %#lx\n", address);
1004
1005         if (address > vma->vm_end) {
1006                 DPF(1, "EXIT, returning NOPAGE_SIGBUS\n");
1007                 return NOPAGE_SIGBUS; /* Disallow mremap */
1008         }
1009
1010         pgoff = vma->vm_pgoff + ((address - vma->vm_start) >> PAGE_SHIFT);
1011         if (woinst != NULL)
1012                 wr = woinst->mmapped;
1013         else
1014                 wr = 0;
1015
1016         if (wiinst != NULL)
1017                 rd = wiinst->mmapped;
1018         else
1019                 rd = 0;
1020
1021         /* if full-duplex (read+write) and we have two sets of bufs,
1022         * then the playback buffers come first, sez soundcard.c */
1023         if (wr) {
1024                 if (pgoff >= woinst->buffer.pages) {
1025                         pgoff -= woinst->buffer.pages;
1026                         dmapage = virt_to_page ((u8 *) wiinst->buffer.addr + pgoff * PAGE_SIZE);
1027                 } else
1028                         dmapage = virt_to_page (woinst->voice[0].mem.addr[pgoff]);
1029         } else {
1030                 dmapage = virt_to_page ((u8 *) wiinst->buffer.addr + pgoff * PAGE_SIZE);
1031         }
1032
1033         get_page (dmapage);
1034
1035         DPD(3, "page: %#lx\n", (unsigned long) dmapage);
1036         if (type)
1037                 *type = VM_FAULT_MINOR;
1038         return dmapage;
1039 }
1040
1041 struct vm_operations_struct emu10k1_mm_ops = {
1042         .nopage         = emu10k1_mm_nopage,
1043 };
1044
1045 static int emu10k1_audio_mmap(struct file *file, struct vm_area_struct *vma)
1046 {
1047         struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
1048         unsigned long max_pages, n_pages, pgoffset;
1049         struct woinst *woinst = NULL;
1050         struct wiinst *wiinst = NULL;
1051         unsigned long flags;
1052
1053         DPF(2, "emu10k1_audio_mmap()\n");
1054
1055         max_pages = 0;
1056         if (vma->vm_flags & VM_WRITE) {
1057                 woinst = wave_dev->woinst;
1058
1059                 spin_lock_irqsave(&woinst->lock, flags);
1060
1061                 /* No m'mapping possible for multichannel */
1062                 if (woinst->num_voices > 1) {
1063                         spin_unlock_irqrestore(&woinst->lock, flags);
1064                         return -EINVAL;
1065                 }
1066
1067                 if (woinst->state == WAVE_STATE_CLOSED) {
1068                         calculate_ofrag(woinst);
1069
1070                         if (emu10k1_waveout_open(wave_dev) < 0) {
1071                                 spin_unlock_irqrestore(&woinst->lock, flags);
1072                                 ERROR();
1073                                 return -EINVAL;
1074                         }
1075                 }
1076
1077                 woinst->mmapped = 1;
1078                 max_pages += woinst->buffer.pages;
1079                 spin_unlock_irqrestore(&woinst->lock, flags);
1080         }
1081
1082         if (vma->vm_flags & VM_READ) {
1083                 wiinst = wave_dev->wiinst;
1084
1085                 spin_lock_irqsave(&wiinst->lock, flags);
1086                 if (wiinst->state == WAVE_STATE_CLOSED) {
1087                         calculate_ifrag(wiinst);
1088
1089                         if (emu10k1_wavein_open(wave_dev) < 0) {
1090                                 spin_unlock_irqrestore(&wiinst->lock, flags);
1091                                 ERROR();
1092                                 return -EINVAL;
1093                         }
1094                 }
1095
1096                 wiinst->mmapped = 1;
1097                 max_pages += wiinst->buffer.pages;
1098                 spin_unlock_irqrestore(&wiinst->lock, flags);
1099         }
1100
1101         n_pages = ((vma->vm_end - vma->vm_start) + PAGE_SIZE - 1) >> PAGE_SHIFT;
1102         pgoffset = vma->vm_pgoff;
1103
1104         DPD(2, "vma_start: %#lx, vma_end: %#lx, vma_offset: %ld\n", vma->vm_start, vma->vm_end, pgoffset);
1105         DPD(2, "n_pages: %ld, max_pages: %ld\n", n_pages, max_pages);
1106
1107         if (pgoffset + n_pages > max_pages)
1108                 return -EINVAL;
1109
1110         vma->vm_flags |= VM_RESERVED;
1111         vma->vm_ops = &emu10k1_mm_ops;
1112         vma->vm_private_data = wave_dev;
1113         return 0;
1114 }
1115
1116 static int emu10k1_audio_open(struct inode *inode, struct file *file)
1117 {
1118         int minor = iminor(inode);
1119         struct emu10k1_card *card = NULL;
1120         struct list_head *entry;
1121         struct emu10k1_wavedevice *wave_dev;
1122
1123         DPF(2, "emu10k1_audio_open()\n");
1124
1125         /* Check for correct device to open */
1126
1127         list_for_each(entry, &emu10k1_devs) {
1128                 card = list_entry(entry, struct emu10k1_card, list);
1129
1130                 if (!((card->audio_dev ^ minor) & ~0xf) || !((card->audio_dev1 ^ minor) & ~0xf))
1131                         goto match;
1132         }
1133
1134         return -ENODEV;
1135
1136 match:
1137
1138         wave_dev = (struct emu10k1_wavedevice *) kmalloc(sizeof(struct emu10k1_wavedevice), GFP_KERNEL);
1139
1140         if (wave_dev == NULL) {
1141                 ERROR();
1142                 return -ENOMEM;
1143         }
1144
1145         wave_dev->card = card;
1146         wave_dev->wiinst = NULL;
1147         wave_dev->woinst = NULL;
1148         wave_dev->enablebits = PCM_ENABLE_OUTPUT | PCM_ENABLE_INPUT;    /* Default */
1149
1150         if (file->f_mode & FMODE_READ) {
1151                 /* Recording */
1152                 struct wiinst *wiinst;
1153
1154                 if ((wiinst = (struct wiinst *) kmalloc(sizeof(struct wiinst), GFP_KERNEL)) == NULL) {
1155                         ERROR();
1156                         kfree(wave_dev);
1157                         return -ENOMEM;
1158                 }
1159
1160                 wiinst->recsrc = card->wavein.recsrc;
1161                 wiinst->fxwc = card->wavein.fxwc;
1162
1163                 switch (wiinst->recsrc) {
1164                 case WAVERECORD_AC97:
1165                         wiinst->format.id = AFMT_S16_LE;
1166                         wiinst->format.samplingrate = 8000;
1167                         wiinst->format.bitsperchannel = 16;
1168                         wiinst->format.channels = 1;
1169                         break;
1170                 case WAVERECORD_MIC:
1171                         wiinst->format.id = AFMT_S16_LE;
1172                         wiinst->format.samplingrate = 8000;
1173                         wiinst->format.bitsperchannel = 16;
1174                         wiinst->format.channels = 1;
1175                         break;
1176                 case WAVERECORD_FX:
1177                         wiinst->format.id = AFMT_S16_LE;
1178                         wiinst->format.samplingrate = 48000;
1179                         wiinst->format.bitsperchannel = 16;
1180                         wiinst->format.channels = hweight32(wiinst->fxwc);
1181                         break;
1182                 default:
1183                         kfree(wave_dev);
1184                         kfree(wiinst);
1185                         BUG();
1186                         break;
1187                 }
1188
1189                 wiinst->state = WAVE_STATE_CLOSED;
1190
1191                 wiinst->buffer.ossfragshift = 0;
1192                 wiinst->buffer.fragment_size = 0;
1193                 wiinst->buffer.numfrags = 0;
1194
1195                 init_waitqueue_head(&wiinst->wait_queue);
1196
1197                 wiinst->mmapped = 0;
1198                 wiinst->total_recorded = 0;
1199                 wiinst->blocks = 0;
1200                 wiinst->lock = SPIN_LOCK_UNLOCKED;
1201                 tasklet_init(&wiinst->timer.tasklet, emu10k1_wavein_bh, (unsigned long) wave_dev);
1202                 wave_dev->wiinst = wiinst;
1203                 emu10k1_wavein_setformat(wave_dev, &wiinst->format);
1204         }
1205
1206         if (file->f_mode & FMODE_WRITE) {
1207                 struct woinst *woinst;
1208                 int i;
1209
1210                 if ((woinst = (struct woinst *) kmalloc(sizeof(struct woinst), GFP_KERNEL)) == NULL) {
1211                         ERROR();
1212                         kfree(wave_dev);
1213                         return -ENOMEM;
1214                 }
1215
1216                 if (wave_dev->wiinst != NULL) {
1217                         woinst->format = wave_dev->wiinst->format;
1218                 } else {
1219                         woinst->format.id = AFMT_U8;
1220                         woinst->format.samplingrate = 8000;
1221                         woinst->format.bitsperchannel = 8;
1222                         woinst->format.channels = 1;
1223                 }
1224
1225                 woinst->state = WAVE_STATE_CLOSED;
1226
1227                 woinst->buffer.fragment_size = 0;
1228                 woinst->buffer.ossfragshift = 0;
1229                 woinst->buffer.numfrags = 0;
1230                 woinst->device = (card->audio_dev1 == minor);
1231                 woinst->timer.state = TIMER_STATE_UNINSTALLED;
1232                 woinst->num_voices = 1;
1233                 for (i = 0; i < WAVEOUT_MAXVOICES; i++) {
1234                         woinst->voice[i].usage = VOICE_USAGE_FREE;
1235                         woinst->voice[i].mem.emupageindex = -1;
1236                 }
1237
1238                 init_waitqueue_head(&woinst->wait_queue);
1239
1240                 woinst->mmapped = 0;
1241                 woinst->total_copied = 0;
1242                 woinst->total_played = 0;
1243                 woinst->blocks = 0;
1244                 woinst->lock = SPIN_LOCK_UNLOCKED;
1245                 tasklet_init(&woinst->timer.tasklet, emu10k1_waveout_bh, (unsigned long) wave_dev);
1246                 wave_dev->woinst = woinst;
1247                 emu10k1_waveout_setformat(wave_dev, &woinst->format);
1248         }
1249
1250         file->private_data = (void *) wave_dev;
1251
1252         return 0;
1253 }
1254
1255 static int emu10k1_audio_release(struct inode *inode, struct file *file)
1256 {
1257         struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
1258         struct emu10k1_card *card;
1259         unsigned long flags;
1260
1261         card = wave_dev->card;
1262
1263         DPF(2, "emu10k1_audio_release()\n");
1264
1265         if (file->f_mode & FMODE_WRITE) {
1266                 struct woinst *woinst = wave_dev->woinst;
1267
1268                 spin_lock_irqsave(&woinst->lock, flags);
1269                 if(woinst->format.passthrough==2)
1270                         card->pt.state=PT_STATE_PLAYING;
1271                 if (woinst->format.passthrough && card->pt.state != PT_STATE_INACTIVE){
1272                         spin_lock(&card->pt.lock);
1273                         emu10k1_pt_stop(card);
1274                         spin_unlock(&card->pt.lock);
1275                 }
1276                 if (woinst->state & WAVE_STATE_OPEN) {
1277                         if (woinst->state & WAVE_STATE_STARTED) {
1278                                 if (!(file->f_flags & O_NONBLOCK)) {
1279                                         while (!signal_pending(current)
1280                                                && (woinst->total_played < woinst->total_copied)) {
1281                                                 DPF(4, "Buffer hasn't been totally played, sleep....\n");
1282                                                 spin_unlock_irqrestore(&woinst->lock, flags);
1283                                                 interruptible_sleep_on(&woinst->wait_queue);
1284                                                 spin_lock_irqsave(&woinst->lock, flags);
1285                                         }
1286                                 }
1287                         }
1288                         emu10k1_waveout_close(wave_dev);
1289                 }
1290
1291                 spin_unlock_irqrestore(&woinst->lock, flags);
1292                 /* remove the tasklet */
1293                 tasklet_kill(&woinst->timer.tasklet);
1294                 kfree(wave_dev->woinst);
1295         }
1296
1297         if (file->f_mode & FMODE_READ) {
1298                 struct wiinst *wiinst = wave_dev->wiinst;
1299
1300                 spin_lock_irqsave(&wiinst->lock, flags);
1301
1302                 if (wiinst->state & WAVE_STATE_OPEN) {
1303                         emu10k1_wavein_close(wave_dev);
1304                 }
1305
1306                 spin_unlock_irqrestore(&wiinst->lock, flags);
1307                 tasklet_kill(&wiinst->timer.tasklet);
1308                 kfree(wave_dev->wiinst);
1309         }
1310
1311         kfree(wave_dev);
1312
1313         if (waitqueue_active(&card->open_wait))
1314                 wake_up_interruptible(&card->open_wait);
1315
1316         return 0;
1317 }
1318
1319 /* FIXME sort out poll() + mmap() */
1320 static unsigned int emu10k1_audio_poll(struct file *file, struct poll_table_struct *wait)
1321 {
1322         struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
1323         struct woinst *woinst = wave_dev->woinst;
1324         struct wiinst *wiinst = wave_dev->wiinst;
1325         unsigned int mask = 0;
1326         u32 bytestocopy;
1327         unsigned long flags;
1328
1329         DPF(4, "emu10k1_audio_poll()\n");
1330
1331         if (file->f_mode & FMODE_WRITE)
1332                 poll_wait(file, &woinst->wait_queue, wait);
1333
1334         if (file->f_mode & FMODE_READ)
1335                 poll_wait(file, &wiinst->wait_queue, wait);
1336
1337         if (file->f_mode & FMODE_WRITE) {
1338                 spin_lock_irqsave(&woinst->lock, flags);
1339
1340                 if (woinst->state & WAVE_STATE_OPEN) {
1341                         emu10k1_waveout_update(woinst);
1342                         emu10k1_waveout_getxfersize(woinst, &bytestocopy);
1343
1344                         if (bytestocopy >= woinst->buffer.fragment_size)
1345                                 mask |= POLLOUT | POLLWRNORM;
1346                 } else
1347                         mask |= POLLOUT | POLLWRNORM;
1348
1349                 spin_unlock_irqrestore(&woinst->lock, flags);
1350         }
1351
1352         if (file->f_mode & FMODE_READ) {
1353                 spin_lock_irqsave(&wiinst->lock, flags);
1354
1355                 if (wiinst->state & WAVE_STATE_OPEN) {
1356                         emu10k1_wavein_update(wave_dev->card, wiinst);
1357                         emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
1358
1359                         if (bytestocopy >= wiinst->buffer.fragment_size)
1360                                 mask |= POLLIN | POLLRDNORM;
1361                 }
1362
1363                 spin_unlock_irqrestore(&wiinst->lock, flags);
1364         }
1365
1366         return mask;
1367 }
1368
1369 static void calculate_ofrag(struct woinst *woinst)
1370 {
1371         struct waveout_buffer *buffer = &woinst->buffer;
1372         u32 fragsize;
1373
1374         if (buffer->fragment_size)
1375                 return;
1376
1377         if (!buffer->ossfragshift) {
1378                 fragsize = (woinst->format.bytespervoicesample * woinst->format.samplingrate * WAVEOUT_DEFAULTFRAGLEN) / 1000 - 1;
1379
1380                 while (fragsize) {
1381                         fragsize >>= 1;
1382                         buffer->ossfragshift++;
1383                 }
1384         }
1385
1386         if (buffer->ossfragshift < WAVEOUT_MINFRAGSHIFT)
1387                 buffer->ossfragshift = WAVEOUT_MINFRAGSHIFT;
1388
1389         buffer->fragment_size = 1 << buffer->ossfragshift;
1390
1391         while (buffer->fragment_size * WAVEOUT_MINFRAGS > WAVEOUT_MAXBUFSIZE)
1392                 buffer->fragment_size >>= 1;
1393
1394         /* now we are sure that:
1395          (2^WAVEOUT_MINFRAGSHIFT) <= (fragment_size = 2^n) <= (WAVEOUT_MAXBUFSIZE / WAVEOUT_MINFRAGS)
1396         */
1397
1398         if (!buffer->numfrags) {
1399                 u32 numfrags;
1400
1401                 numfrags = (woinst->format.bytespervoicesample * woinst->format.samplingrate * WAVEOUT_DEFAULTBUFLEN) /
1402                            (buffer->fragment_size * 1000) - 1;
1403
1404                 buffer->numfrags = 1;
1405
1406                 while (numfrags) {
1407                         numfrags >>= 1;
1408                         buffer->numfrags <<= 1;
1409                 }
1410         }
1411
1412         if (buffer->numfrags < WAVEOUT_MINFRAGS)
1413                 buffer->numfrags = WAVEOUT_MINFRAGS;
1414
1415         if (buffer->numfrags * buffer->fragment_size > WAVEOUT_MAXBUFSIZE)
1416                 buffer->numfrags = WAVEOUT_MAXBUFSIZE / buffer->fragment_size;
1417
1418         if (buffer->numfrags < WAVEOUT_MINFRAGS)
1419                 BUG();
1420
1421         buffer->size = buffer->fragment_size * buffer->numfrags;
1422         buffer->pages = buffer->size / PAGE_SIZE + ((buffer->size % PAGE_SIZE) ? 1 : 0);
1423
1424         DPD(2, " calculated playback fragment_size -> %d\n", buffer->fragment_size);
1425         DPD(2, " calculated playback numfrags -> %d\n", buffer->numfrags);
1426
1427         return;
1428 }
1429
1430 static void calculate_ifrag(struct wiinst *wiinst)
1431 {
1432         struct wavein_buffer *buffer = &wiinst->buffer;
1433         u32 fragsize, bufsize, size[4];
1434         int i, j;
1435
1436         if (buffer->fragment_size)
1437                 return;
1438
1439         if (!buffer->ossfragshift) {
1440                 fragsize = (wiinst->format.bytespersec * WAVEIN_DEFAULTFRAGLEN) / 1000 - 1;
1441
1442                 while (fragsize) {
1443                         fragsize >>= 1;
1444                         buffer->ossfragshift++;
1445                 }
1446         }
1447
1448         if (buffer->ossfragshift < WAVEIN_MINFRAGSHIFT)
1449                 buffer->ossfragshift = WAVEIN_MINFRAGSHIFT;
1450
1451         buffer->fragment_size = 1 << buffer->ossfragshift;
1452
1453         while (buffer->fragment_size * WAVEIN_MINFRAGS > WAVEIN_MAXBUFSIZE)
1454                 buffer->fragment_size >>= 1;
1455
1456         /* now we are sure that:
1457            (2^WAVEIN_MINFRAGSHIFT) <= (fragment_size = 2^n) <= (WAVEIN_MAXBUFSIZE / WAVEIN_MINFRAGS)
1458         */
1459
1460
1461         if (!buffer->numfrags)
1462                 buffer->numfrags = (wiinst->format.bytespersec * WAVEIN_DEFAULTBUFLEN) / (buffer->fragment_size * 1000) - 1;
1463
1464         if (buffer->numfrags < WAVEIN_MINFRAGS)
1465                 buffer->numfrags = WAVEIN_MINFRAGS;
1466
1467         if (buffer->numfrags * buffer->fragment_size > WAVEIN_MAXBUFSIZE)
1468                 buffer->numfrags = WAVEIN_MAXBUFSIZE / buffer->fragment_size;
1469
1470         if (buffer->numfrags < WAVEIN_MINFRAGS)
1471                 BUG();
1472
1473         bufsize = buffer->fragment_size * buffer->numfrags;
1474
1475         /* the buffer size for recording is restricted to certain values, adjust it now */
1476         if (bufsize >= 0x10000) {
1477                 buffer->size = 0x10000;
1478                 buffer->sizeregval = 0x1f;
1479         } else {
1480                 buffer->size = 0;
1481                 size[0] = 384;
1482                 size[1] = 448;
1483                 size[2] = 512;
1484                 size[3] = 640;
1485
1486                 for (i = 0; i < 8; i++)
1487                         for (j = 0; j < 4; j++)
1488                                 if (bufsize >= size[j]) {
1489                                         buffer->size = size[j];
1490                                         size[j] *= 2;
1491                                         buffer->sizeregval = i * 4 + j + 1;
1492                                 } else
1493                                         goto exitloop;
1494               exitloop:
1495                 if (buffer->size == 0) {
1496                         buffer->size = 384;
1497                         buffer->sizeregval = 0x01;
1498                 }
1499         }
1500
1501         /* adjust the fragment size so that buffer size is an integer multiple */
1502         while (buffer->size % buffer->fragment_size)
1503                 buffer->fragment_size >>= 1;
1504
1505         buffer->numfrags = buffer->size / buffer->fragment_size;
1506         buffer->pages =  buffer->size / PAGE_SIZE + ((buffer->size % PAGE_SIZE) ? 1 : 0);
1507
1508         DPD(2, " calculated recording fragment_size -> %d\n", buffer->fragment_size);
1509         DPD(2, " calculated recording numfrags -> %d\n", buffer->numfrags);
1510         DPD(2, " buffer size register -> %#04x\n", buffer->sizeregval);
1511
1512         return;
1513 }
1514
1515 void emu10k1_wavein_bh(unsigned long refdata)
1516 {
1517         struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) refdata;
1518         struct wiinst *wiinst = wave_dev->wiinst;
1519         u32 bytestocopy;
1520         unsigned long flags;
1521
1522         if (!wiinst)
1523                 return;
1524
1525         spin_lock_irqsave(&wiinst->lock, flags);
1526
1527         if (!(wiinst->state & WAVE_STATE_STARTED)) {
1528                 spin_unlock_irqrestore(&wiinst->lock, flags);
1529                 return;
1530         }
1531
1532         emu10k1_wavein_update(wave_dev->card, wiinst);
1533         emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
1534
1535         spin_unlock_irqrestore(&wiinst->lock, flags);
1536
1537         if (bytestocopy >= wiinst->buffer.fragment_size) {
1538                 if (waitqueue_active(&wiinst->wait_queue))
1539                         wake_up_interruptible(&wiinst->wait_queue);
1540         } else
1541                 DPD(3, "Not enough transfer size, %d\n", bytestocopy);
1542
1543         return;
1544 }
1545
1546 void emu10k1_waveout_bh(unsigned long refdata)
1547 {
1548         struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) refdata;
1549         struct woinst *woinst = wave_dev->woinst;
1550         u32 bytestocopy;
1551         unsigned long flags;
1552
1553         if (!woinst)
1554                 return;
1555
1556         spin_lock_irqsave(&woinst->lock, flags);
1557
1558         if (!(woinst->state & WAVE_STATE_STARTED)) {
1559                 spin_unlock_irqrestore(&woinst->lock, flags);
1560                 return;
1561         }
1562
1563         emu10k1_waveout_update(woinst);
1564         emu10k1_waveout_getxfersize(woinst, &bytestocopy);
1565
1566         if (woinst->buffer.fill_silence) {
1567                 spin_unlock_irqrestore(&woinst->lock, flags);
1568                 emu10k1_waveout_fillsilence(woinst);
1569         } else
1570                 spin_unlock_irqrestore(&woinst->lock, flags);
1571
1572         if (bytestocopy >= woinst->buffer.fragment_size) {
1573                 if (waitqueue_active(&woinst->wait_queue))
1574                         wake_up_interruptible(&woinst->wait_queue);
1575         } else
1576                 DPD(3, "Not enough transfer size -> %d\n", bytestocopy);
1577
1578         return;
1579 }
1580
1581 struct file_operations emu10k1_audio_fops = {
1582         .owner          = THIS_MODULE,
1583         .llseek         = no_llseek,
1584         .read           = emu10k1_audio_read,
1585         .write          = emu10k1_audio_write,
1586         .poll           = emu10k1_audio_poll,
1587         .ioctl          = emu10k1_audio_ioctl,
1588         .mmap           = emu10k1_audio_mmap,
1589         .open           = emu10k1_audio_open,
1590         .release        = emu10k1_audio_release,
1591 };