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