sound/oss/emu10k1/audio.c

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