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