drivers/sound/gus

/* */
This source file includes following definitions.
reset_sample_memory
gus_delay
gus_poke
gus_peek
gus_write8
gus_read8
gus_look8
gus_write16
gus_read16
gus_write_addr
gus_select_voice
gus_select_max_voices
gus_voice_on
gus_voice_off
gus_voice_mode
gus_voice_freq
gus_voice_volume
gus_voice_balance
gus_ramp_range
gus_ramp_rate
gus_rampon
gus_ramp_mode
gus_rampoff
gus_set_voice_pos
gus_voice_init
gus_voice_init2
step_envelope
init_envelope
start_release
gus_voice_fade
gus_reset
gus_initialize
gus_wave_detect
guswave_ioctl
guswave_set_instr
guswave_kill_note
guswave_aftertouch
guswave_panning
compute_volume
compute_and_set_volume
dynamic_volume_change
guswave_controller
guswave_start_note2
guswave_start_note
guswave_reset
guswave_open
guswave_close
guswave_load_patch
guswave_hw_control
gus_sampling_set_speed
gus_sampling_set_channels
gus_sampling_set_bits
gus_sampling_ioctl
gus_sampling_reset
gus_sampling_open
gus_sampling_close
gus_sampling_update_volume
play_next_pcm_block
gus_transfer_output_block
gus_sampling_output_block
gus_sampling_start_input
gus_sampling_prepare_for_input
gus_sampling_prepare_for_output
gus_has_output_drained
gus_copy_from_user
guswave_bender
guswave_patchmgr
set_input_volumes
gus_mixer_ioctl
gus_wave_init
do_loop_irq
do_volume_irq
gus_voice_irq
guswave_dma_irq
   1 
   2 /* 
   3  * sound/gus_wave.c
   4  * 
   5  * Driver for the Gravis UltraSound wave table synth.
   6  * 
   7  * Copyright by Hannu Savolainen 1993
   8  * 
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions are
  11  * met: 1. Redistributions of source code must retain the above copyright
  12  * notice, this list of conditions and the following disclaimer. 2.
  13  * Redistributions in binary form must reproduce the above copyright notice,
  14  * this list of conditions and the following disclaimer in the documentation
  15  * and/or other materials provided with the distribution.
  16  * 
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  21  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  23  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  24  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  * 
  29  */
  30 
  31 #include "sound_config.h"
  32 #include <linux/ultrasound.h>
  33 #include "gus_hw.h"
  34 
  35 #if defined(CONFIGURE_SOUNDCARD) && !defined(EXCLUDE_GUS)
  36 
  37 #define MAX_SAMPLE      128
  38 #define MAX_PATCH       256
  39 
  40 struct voice_info
  41   {
  42     unsigned long   orig_freq;
  43     unsigned long   current_freq;
  44     unsigned long   mode;
  45     int             bender;
  46     int             bender_range;
  47     int             panning;
  48     int             midi_volume;
  49     unsigned int    initial_volume;
  50     unsigned int    current_volume;
  51     int             loop_irq_mode, loop_irq_parm;
  52 #define LMODE_FINISH            1
  53 #define LMODE_PCM               2
  54 #define LMODE_PCM_STOP          3
  55     int             volume_irq_mode, volume_irq_parm;
  56 #define VMODE_HALT              1
  57 #define VMODE_ENVELOPE          2
  58 #define VMODE_START_NOTE        3
  59 
  60     int             env_phase;
  61     unsigned char   env_rate[6];
  62     unsigned char   env_offset[6];
  63 
  64     /* 
  65      * Volume computation parameters for gus_adagio_vol()
  66      */
  67     int             main_vol, expression_vol, patch_vol;
  68 
  69     /* Variables for "Ultraclick" removal */
  70     int             dev_pending, note_pending, volume_pending, sample_pending;
  71     char            kill_pending;
  72     long            offset_pending;
  73 
  74   };
  75 
  76 extern int      gus_base;
  77 extern int      gus_irq, gus_dma;
  78 extern char    *snd_raw_buf[MAX_DSP_DEV][DSP_BUFFCOUNT];
  79 extern unsigned long snd_raw_buf_phys[MAX_DSP_DEV][DSP_BUFFCOUNT];
  80 extern int      snd_raw_count[MAX_DSP_DEV];
  81 static long     gus_mem_size = 0;
  82 static long     free_mem_ptr = 0;
  83 static int      gus_busy = 0;
  84 static int      nr_voices = 0;
  85 static int      gus_devnum = 0;
  86 static int      volume_base, volume_scale, volume_method;
  87 static int      gus_line_vol = 100, gus_mic_vol = 0;
  88 static int      gus_recmask = SOUND_MASK_MIC;
  89 static int      recording_active = 0;
  90 
  91 #define VOL_METHOD_ADAGIO       1
  92 int             gus_wave_volume = 60;
  93 int             gus_pcm_volume = 80;
  94 static unsigned char mix_image = 0x00;
  95 
  96 /* 
  97  * Current version of this driver doesn't allow synth and PCM functions
  98  * at the same time. The active_device specifies the active driver
  99  */
 100 static int      active_device = 0;
 101 
 102 #define GUS_DEV_WAVE            1       /* 
 103                                          * * * Wave table synth   */
 104 #define GUS_DEV_PCM_DONE        2       /* 
 105                                          * * * PCM device, transfer done   */
 106 #define GUS_DEV_PCM_CONTINUE    3       /* 
 107                                          * * * PCM device, transfer the
 108                                          * second * * * chn   */
 109 
 110 static int      gus_sampling_speed;
 111 static int      gus_sampling_channels;
 112 static int      gus_sampling_bits;
 113 
 114 DEFINE_WAIT_QUEUE (dram_sleeper, dram_sleep_flag);
 115 
 116 /* 
 117  * Variables and buffers for PCM output
 118  */
 119 #define MAX_PCM_BUFFERS         (32*MAX_REALTIME_FACTOR)        /* 
 120                                                                  * * * Don't
 121                                                                  * * * change 
 122                                                                  * 
 123                                                                  */
 124 
 125 static int      pcm_bsize,      /* 
 126                                  * Current blocksize 
 127                                  */
 128                 pcm_nblk,       /* 
 129                                  * Current # of blocks 
 130                                  */
 131                 pcm_banksize;   /* 
 132 
 133                                  * 
 134                                  * *  * * # bytes allocated for channels   */
 135 static int      pcm_datasize[MAX_PCM_BUFFERS];  /* 
 136 
 137                                                  * 
 138                                                  * *  * * Actual # of bytes
 139                                                  * in blk  *  */
 140 static volatile int pcm_head, pcm_tail, pcm_qlen;       /* 
 141 
 142                                                          * 
 143                                                          * *  * * DRAM queue
 144                                                          *  */
 145 static volatile int pcm_active;
 146 static int      pcm_opened = 0;
 147 static int      pcm_current_dev;
 148 static int      pcm_current_block;
 149 static unsigned long pcm_current_buf;
 150 static int      pcm_current_count;
 151 static int      pcm_current_intrflag;
 152 
 153 struct voice_info voices[32];
 154 
 155 static int      freq_div_table[] =
 156 {
 157   44100,                        /* 
 158                                  * 14 
 159                                  */
 160   41160,                        /* 
 161                                  * 15 
 162                                  */
 163   38587,                        /* 
 164                                  * 16 
 165                                  */
 166   36317,                        /* 
 167                                  * 17 
 168                                  */
 169   34300,                        /* 
 170                                  * 18 
 171                                  */
 172   32494,                        /* 
 173                                  * 19 
 174                                  */
 175   30870,                        /* 
 176                                  * 20 
 177                                  */
 178   29400,                        /* 
 179                                  * 21 
 180                                  */
 181   28063,                        /* 
 182                                  * 22 
 183                                  */
 184   26843,                        /* 
 185                                  * 23 
 186                                  */
 187   25725,                        /* 
 188                                  * 24 
 189                                  */
 190   24696,                        /* 
 191                                  * 25 
 192                                  */
 193   23746,                        /* 
 194                                  * 26 
 195                                  */
 196   22866,                        /* 
 197                                  * 27 
 198                                  */
 199   22050,                        /* 
 200                                  * 28 
 201                                  */
 202   21289,                        /* 
 203                                  * 29 
 204                                  */
 205   20580,                        /* 
 206                                  * 30 
 207                                  */
 208   19916,                        /* 
 209                                  * 31 
 210                                  */
 211   19293                         /* 
 212                                  * 32 
 213                                  */
 214 };
 215 
 216 static struct patch_info *samples;
 217 static long     sample_ptrs[MAX_SAMPLE + 1];
 218 static int      sample_map[32];
 219 static int      free_sample;
 220 
 221 
 222 static int      patch_table[MAX_PATCH];
 223 static int      patch_map[32];
 224 
 225 static struct synth_info gus_info =
 226 {"Gravis UltraSound", 0, SYNTH_TYPE_SAMPLE, SAMPLE_TYPE_GUS, 0, 16, 0, MAX_PATCH};
 227 
 228 static void     gus_poke (long addr, unsigned char data);
 229 static void     compute_and_set_volume (int voice, int volume, int ramp_time);
 230 extern unsigned short gus_adagio_vol (int vel, int mainv, int xpn, int voicev);
 231 static void     compute_volume (int voice, int volume);
 232 static void     do_volume_irq (int voice);
 233 static void     set_input_volumes(void);
 234 
 235 #define INSTANT_RAMP            -1      /* 
 236                                          * * * Dont use ramping   */
 237 #define FAST_RAMP               0       /* 
 238                                          * * * Fastest possible ramp   */
 239 
 240 static void
 241 reset_sample_memory (void)
     /*  */
 242 {
 243   int             i;
 244 
 245   for (i = 0; i <= MAX_SAMPLE; i++)
 246     sample_ptrs[i] = -1;
 247   for (i = 0; i < 32; i++)
 248     sample_map[i] = -1;
 249   for (i = 0; i < 32; i++)
 250     patch_map[i] = -1;
 251 
 252   gus_poke (0, 0);              /* 
 253                                  * Put silence here 
 254                                  */
 255   gus_poke (1, 0);
 256 
 257   free_mem_ptr = 2;
 258   free_sample = 0;
 259 
 260   for (i = 0; i < MAX_PATCH; i++)
 261     patch_table[i] = -1;
 262 }
 263 
 264 void
 265 gus_delay (void)
     /*  */
 266 {
 267   int             i;
 268 
 269   for (i = 0; i < 7; i++)
 270     INB (u_DRAMIO);
 271 }
 272 
 273 static void
 274 gus_poke (long addr, unsigned char data)
     /*  */
 275 {
 276   unsigned long   flags;
 277 
 278   DISABLE_INTR (flags);
 279   OUTB (0x43, u_Command);
 280   OUTB (addr & 0xff, u_DataLo);
 281   OUTB ((addr >> 8) & 0xff, u_DataHi);
 282 
 283   OUTB (0x44, u_Command);
 284   OUTB ((addr >> 16) & 0xff, u_DataHi);
 285   OUTB (data, u_DRAMIO);
 286   RESTORE_INTR (flags);
 287 }
 288 
 289 static unsigned char
 290 gus_peek (long addr)
     /*  */
 291 {
 292   unsigned long   flags;
 293   unsigned char   tmp;
 294 
 295   DISABLE_INTR (flags);
 296   OUTB (0x43, u_Command);
 297   OUTB (addr & 0xff, u_DataLo);
 298   OUTB ((addr >> 8) & 0xff, u_DataHi);
 299 
 300   OUTB (0x44, u_Command);
 301   OUTB ((addr >> 16) & 0xff, u_DataHi);
 302   tmp = INB (u_DRAMIO);
 303   RESTORE_INTR (flags);
 304 
 305   return tmp;
 306 }
 307 
 308 void
 309 gus_write8 (int reg, unsigned int data)
     /*  */
 310 {
 311   unsigned long   flags;
 312 
 313   DISABLE_INTR (flags);
 314 
 315   OUTB (reg, u_Command);
 316   OUTB ((unsigned char) (data & 0xff), u_DataHi);
 317 
 318   RESTORE_INTR (flags);
 319 }
 320 
 321 unsigned char
 322 gus_read8 (int reg)
     /*  */
 323 {
 324   unsigned long   flags;
 325   unsigned char   val;
 326 
 327   DISABLE_INTR (flags);
 328   OUTB (reg | 0x80, u_Command);
 329   val = INB (u_DataHi);
 330   RESTORE_INTR (flags);
 331 
 332   return val;
 333 }
 334 
 335 unsigned char
 336 gus_look8 (int reg)
     /*  */
 337 {
 338   unsigned long   flags;
 339   unsigned char   val;
 340 
 341   DISABLE_INTR (flags);
 342   OUTB (reg, u_Command);
 343   val = INB (u_DataHi);
 344   RESTORE_INTR (flags);
 345 
 346   return val;
 347 }
 348 
 349 void
 350 gus_write16 (int reg, unsigned int data)
     /*  */
 351 {
 352   unsigned long   flags;
 353 
 354   DISABLE_INTR (flags);
 355 
 356   OUTB (reg, u_Command);
 357 
 358   OUTB ((unsigned char) (data & 0xff), u_DataLo);
 359   OUTB ((unsigned char) ((data >> 8) & 0xff), u_DataHi);
 360 
 361   RESTORE_INTR (flags);
 362 }
 363 
 364 unsigned short
 365 gus_read16 (int reg)
     /*  */
 366 {
 367   unsigned long   flags;
 368   unsigned char   hi, lo;
 369 
 370   DISABLE_INTR (flags);
 371 
 372   OUTB (reg | 0x80, u_Command);
 373 
 374   lo = INB (u_DataLo);
 375   hi = INB (u_DataHi);
 376 
 377   RESTORE_INTR (flags);
 378 
 379   return ((hi << 8) & 0xff00) | lo;
 380 }
 381 
 382 void
 383 gus_write_addr (int reg, unsigned long address, int is16bit)
     /*  */
 384 {
 385   unsigned long   hold_address;
 386 
 387   if (is16bit)
 388     {
 389       /* 
 390        * Special processing required for 16 bit patches
 391        */
 392 
 393       hold_address = address;
 394       address = address >> 1;
 395       address &= 0x0001ffffL;
 396       address |= (hold_address & 0x000c0000L);
 397     }
 398 
 399   gus_write16 (reg, (unsigned short) ((address >> 7) & 0xffff));
 400   gus_write16 (reg + 1, (unsigned short) ((address << 9) & 0xffff));
 401 }
 402 
 403 static void
 404 gus_select_voice (int voice)
     /*  */
 405 {
 406   if (voice < 0 || voice > 31)
 407     return;
 408 
 409   OUTB (voice, u_Voice);
 410 }
 411 
 412 static void
 413 gus_select_max_voices (int nvoices)
     /*  */
 414 {
 415   if (nvoices < 14)
 416     nvoices = 14;
 417   if (nvoices > 32)
 418     nvoices = 32;
 419 
 420   nr_voices = nvoices;
 421 
 422   gus_write8 (0x0e, (nvoices - 1) | 0xc0);
 423 }
 424 
 425 static void
 426 gus_voice_on (unsigned int mode)
     /*  */
 427 {
 428   gus_write8 (0x00, (unsigned char) (mode & 0xfc));
 429   gus_delay ();
 430   gus_write8 (0x00, (unsigned char) (mode & 0xfc));
 431 }
 432 
 433 static void
 434 gus_voice_off (void)
     /*  */
 435 {
 436   gus_write8 (0x00, gus_read8 (0x00) | 0x03);
 437 }
 438 
 439 static void
 440 gus_voice_mode (unsigned int m)
     /*  */
 441 {
 442   unsigned char   mode = (unsigned char) (m & 0xff);
 443 
 444   gus_write8 (0x00, (gus_read8 (0x00) & 0x03) | (mode & 0xfc));         /* 
 445                                                                          * Don't 
 446                                                                          * start 
 447                                                                          * or 
 448                                                                          * stop
 449                                                                          * *
 450                                                                          * voice 
 451                                                                          */
 452   gus_delay ();
 453   gus_write8 (0x00, (gus_read8 (0x00) & 0x03) | (mode & 0xfc));
 454 }
 455 
 456 static void
 457 gus_voice_freq (unsigned long freq)
     /*  */
 458 {
 459   unsigned long   divisor = freq_div_table[nr_voices - 14];
 460   unsigned short  fc;
 461 
 462   fc = (unsigned short) (((freq << 9) + (divisor >> 1)) / divisor);
 463   fc = fc << 1;
 464 
 465   gus_write16 (0x01, fc);
 466 }
 467 
 468 static void
 469 gus_voice_volume (unsigned int vol)
     /*  */
 470 {
 471   gus_write8 (0x0d, 0x03);      /* 
 472                                  * Stop ramp before setting volume 
 473                                  */
 474   gus_write16 (0x09, (unsigned short) (vol << 4));
 475 }
 476 
 477 static void
 478 gus_voice_balance (unsigned int balance)
     /*  */
 479 {
 480   gus_write8 (0x0c, (unsigned char) (balance & 0xff));
 481 }
 482 
 483 static void
 484 gus_ramp_range (unsigned int low, unsigned int high)
     /*  */
 485 {
 486   gus_write8 (0x07, (unsigned char) ((low >> 4) & 0xff));
 487   gus_write8 (0x08, (unsigned char) ((high >> 4) & 0xff));
 488 }
 489 
 490 static void
 491 gus_ramp_rate (unsigned int scale, unsigned int rate)
     /*  */
 492 {
 493   gus_write8 (0x06, (unsigned char) (((scale & 0x03) << 6) | (rate & 0x3f)));
 494 }
 495 
 496 static void
 497 gus_rampon (unsigned int m)
     /*  */
 498 {
 499   unsigned char   mode = (unsigned char) (m & 0xff);
 500 
 501   gus_write8 (0x0d, mode & 0xfc);
 502   gus_delay ();
 503   gus_write8 (0x0d, mode & 0xfc);
 504 }
 505 
 506 static void
 507 gus_ramp_mode (unsigned int m)
     /*  */
 508 {
 509   unsigned char   mode = (unsigned char) (m & 0xff);
 510 
 511   gus_write8 (0x0d, (gus_read8 (0x0d) & 0x03) | (mode & 0xfc));         /* 
 512                                                                          * Don't 
 513                                                                          * start 
 514                                                                          * or 
 515                                                                          * stop
 516                                                                          * *
 517                                                                          * ramping 
 518                                                                          */
 519   gus_delay ();
 520   gus_write8 (0x0d, (gus_read8 (0x0d) & 0x03) | (mode & 0xfc));
 521 }
 522 
 523 static void
 524 gus_rampoff (void)
     /*  */
 525 {
 526   gus_write8 (0x0d, 0x03);
 527 }
 528 
 529 static void
 530 gus_set_voice_pos (int voice, long position)
     /*  */
 531 {
 532   int             sample_no;
 533 
 534   if ((sample_no = sample_map[voice]) != -1)
 535     if (position < samples[sample_no].len)
 536       if (voices[voice].volume_irq_mode == VMODE_START_NOTE)
 537         voices[voice].offset_pending = position;
 538       else
 539         gus_write_addr (0x0a, sample_ptrs[sample_no] + position,
 540                         samples[sample_no].mode & WAVE_16_BITS);
 541 }
 542 
 543 static void
 544 gus_voice_init (int voice)
     /*  */
 545 {
 546   unsigned long   flags;
 547 
 548   DISABLE_INTR (flags);
 549   gus_select_voice (voice);
 550   gus_voice_volume (0);
 551   gus_write_addr (0x0a, 0, 0);  /* 
 552                                  * Set current position to 0 
 553                                  */
 554   gus_write8 (0x00, 0x03);      /* 
 555                                  * Voice off 
 556                                  */
 557   gus_write8 (0x0d, 0x03);      /* 
 558                                  * Ramping off 
 559                                  */
 560   RESTORE_INTR (flags);
 561 
 562 }
 563 
 564 static void
 565 gus_voice_init2 (int voice)
     /*  */
 566 {
 567   voices[voice].panning = 0;
 568   voices[voice].mode = 0;
 569   voices[voice].orig_freq = 20000;
 570   voices[voice].current_freq = 20000;
 571   voices[voice].bender = 0;
 572   voices[voice].bender_range = 200;
 573   voices[voice].initial_volume = 0;
 574   voices[voice].current_volume = 0;
 575   voices[voice].loop_irq_mode = 0;
 576   voices[voice].loop_irq_parm = 0;
 577   voices[voice].volume_irq_mode = 0;
 578   voices[voice].volume_irq_parm = 0;
 579   voices[voice].env_phase = 0;
 580   voices[voice].main_vol = 127;
 581   voices[voice].patch_vol = 127;
 582   voices[voice].expression_vol = 127;
 583   voices[voice].sample_pending = -1;
 584 }
 585 
 586 static void
 587 step_envelope (int voice)
     /*  */
 588 {
 589   unsigned        vol, prev_vol, phase;
 590   unsigned char   rate;
 591 
 592   if (voices[voice].mode & WAVE_SUSTAIN_ON && voices[voice].env_phase == 2)
 593     {
 594       gus_rampoff ();
 595       return;                   /* 
 596                                  * Sustain 
 597                                  */
 598     }
 599 
 600   if (voices[voice].env_phase >= 5)
 601     {
 602       /* 
 603        * Shoot the voice off
 604        */
 605 
 606       gus_voice_init (voice);
 607       return;
 608     }
 609 
 610   prev_vol = voices[voice].current_volume;
 611   gus_voice_volume (prev_vol);
 612   phase = ++voices[voice].env_phase;
 613 
 614   compute_volume (voice, voices[voice].midi_volume);
 615 
 616   vol = voices[voice].initial_volume * voices[voice].env_offset[phase] / 255;
 617   rate = voices[voice].env_rate[phase];
 618   gus_write8 (0x06, rate);      /* 
 619                                  * Ramping rate 
 620                                  */
 621 
 622   voices[voice].volume_irq_mode = VMODE_ENVELOPE;
 623 
 624   if (((vol - prev_vol) / 64) == 0)     /* 
 625                                          * No significant volume change 
 626                                          */
 627     {
 628       step_envelope (voice);    /* 
 629                                  * Continue with the next phase 
 630                                  */
 631       return;
 632     }
 633 
 634   if (vol > prev_vol)
 635     {
 636       if (vol >= (4096 - 64))
 637         vol = 4096 - 65;
 638       gus_ramp_range (0, vol);
 639       gus_rampon (0x20);        /* 
 640                                  * Increasing, irq 
 641                                  */
 642     }
 643   else
 644     {
 645       if (vol <= 64)
 646         vol = 65;
 647       gus_ramp_range (vol, 4030);
 648       gus_rampon (0x60);        /* 
 649                                  * Decreasing, irq 
 650                                  */
 651     }
 652   voices[voice].current_volume = vol;
 653 }
 654 
 655 static void
 656 init_envelope (int voice)
     /*  */
 657 {
 658   voices[voice].env_phase = -1;
 659   voices[voice].current_volume = 64;
 660 
 661   step_envelope (voice);
 662 }
 663 
 664 static void
 665 start_release (int voice)
     /*  */
 666 {
 667   if (gus_read8 (0x00) & 0x03)
 668     return;                     /* 
 669                                  * Voice already stopped 
 670                                  */
 671 
 672   voices[voice].env_phase = 2;  /* 
 673                                  * Will be incremented by step_envelope 
 674                                  */
 675 
 676   voices[voice].current_volume =
 677     voices[voice].initial_volume =
 678     gus_read16 (0x09) >> 4;     /* 
 679                                  * Get current volume 
 680                                  */
 681 
 682   voices[voice].mode &= ~WAVE_SUSTAIN_ON;
 683   gus_rampoff ();
 684   step_envelope (voice);
 685 }
 686 
 687 static void
 688 gus_voice_fade (int voice)
     /*  */
 689 {
 690   int             instr_no = sample_map[voice], is16bits;
 691 
 692   if (instr_no < 0 || instr_no > MAX_SAMPLE)
 693     {
 694       gus_write8 (0x00, 0x03);  /* 
 695                                  * Hard stop 
 696                                  */
 697       return;
 698     }
 699 
 700   is16bits = (samples[instr_no].mode & WAVE_16_BITS) ? 1 : 0;   /* 
 701                                                                  * 8 or 16
 702                                                                  * bit
 703                                                                  * samples 
 704                                                                  */
 705 
 706   if (voices[voice].mode & WAVE_ENVELOPES)
 707     {
 708       start_release (voice);
 709       return;
 710     }
 711 
 712   /* 
 713    * Ramp the volume down but not too quickly.
 714    */
 715   if ((gus_read16 (0x09) >> 4) < 100)   /* 
 716                                          * Get current volume 
 717                                          */
 718     {
 719       gus_voice_off ();
 720       gus_rampoff ();
 721       gus_voice_init (voice);
 722       return;
 723     }
 724 
 725   gus_ramp_range (65, 4030);
 726   gus_ramp_rate (2, 4);
 727   gus_rampon (0x40 | 0x20);     /* 
 728                                  * Down, once, irq 
 729                                  */
 730   voices[voice].volume_irq_mode = VMODE_HALT;
 731 }
 732 
 733 static void
 734 gus_reset (void)
     /*  */
 735 {
 736   int             i;
 737 
 738   gus_select_max_voices (24);
 739   volume_base = 3071;
 740   volume_scale = 4;
 741   volume_method = VOL_METHOD_ADAGIO;
 742 
 743   for (i = 0; i < 32; i++)
 744     {
 745       gus_voice_init (i);       /* 
 746                                  * Turn voice off 
 747                                  */
 748       gus_voice_init2 (i);
 749     }
 750 
 751   INB (u_Status);               /* 
 752                                  * Touch the status register 
 753                                  */
 754 
 755   gus_look8 (0x41);             /* 
 756                                  * Clear any pending DMA IRQs 
 757                                  */
 758   gus_look8 (0x49);             /* 
 759                                  * Clear any pending sample IRQs 
 760                                  */
 761   gus_read8 (0x0f);             /* 
 762                                  * Clear pending IRQs 
 763                                  */
 764 
 765 }
 766 
 767 static void
 768 gus_initialize (void)
     /*  */
 769 {
 770   unsigned long   flags;
 771   unsigned char   dma_image, irq_image, tmp;
 772 
 773   static unsigned char gus_irq_map[16] =
 774   {0, 0, 1, 3, 0, 2, 0, 4, 0, 0, 0, 5, 6, 0, 0, 7};
 775 
 776   static unsigned char gus_dma_map[8] =
 777   {0, 1, 0, 2, 0, 3, 4, 5};
 778 
 779   DISABLE_INTR (flags);
 780 
 781   gus_write8 (0x4c, 0);         /* 
 782                                  * Reset GF1 
 783                                  */
 784   gus_delay ();
 785   gus_delay ();
 786 
 787   gus_write8 (0x4c, 1);         /* 
 788                                  * Release Reset 
 789                                  */
 790   gus_delay ();
 791   gus_delay ();
 792 
 793   /* 
 794    * Clear all interrupts
 795    */
 796 
 797   gus_write8 (0x41, 0);         /* 
 798                                  * DMA control 
 799                                  */
 800   gus_write8 (0x45, 0);         /* 
 801                                  * Timer control 
 802                                  */
 803   gus_write8 (0x49, 0);         /* 
 804                                  * Sample control 
 805                                  */
 806 
 807   gus_select_max_voices (24);
 808 
 809   INB (u_Status);               /* 
 810                                  * Touch the status register 
 811                                  */
 812 
 813   gus_look8 (0x41);             /* 
 814                                  * Clear any pending DMA IRQs 
 815                                  */
 816   gus_look8 (0x49);             /* 
 817                                  * Clear any pending sample IRQs 
 818                                  */
 819   gus_read8 (0x0f);             /* 
 820                                  * Clear pending IRQs 
 821                                  */
 822 
 823   gus_reset ();                 /* 
 824                                  * Resets all voices 
 825                                  */
 826 
 827   gus_look8 (0x41);             /* 
 828                                  * Clear any pending DMA IRQs 
 829                                  */
 830   gus_look8 (0x49);             /* 
 831                                  * Clear any pending sample IRQs 
 832                                  */
 833   gus_read8 (0x0f);             /* 
 834                                  * Clear pending IRQs 
 835                                  */
 836 
 837   gus_write8 (0x4c, 7);         /* 
 838                                  * Master reset | DAC enable | IRQ enable 
 839                                  */
 840 
 841   /* 
 842    * Set up for Digital ASIC
 843    */
 844 
 845   OUTB (0x05, gus_base + 0x0f);
 846 
 847   mix_image |= 0x02;            /* 
 848                                  * Disable line out 
 849                                  */
 850   OUTB (mix_image, u_Mixer);
 851 
 852   OUTB (0x00, u_IRQDMAControl);
 853 
 854   OUTB (0x00, gus_base + 0x0f);
 855 
 856   /* 
 857    * Now set up the DMA and IRQ interface
 858    * 
 859    * The GUS supports two IRQs and two DMAs.
 860    * 
 861    * Just one DMA channel is used. This prevents simultaneous ADC and DAC.
 862    * Adding this support requires significant changes to the dmabuf.c, dsp.c
 863    * and audio.c also.
 864    */
 865 
 866   irq_image = 0;
 867   tmp = gus_irq_map[gus_irq];
 868   if (!tmp)
 869     printk ("Warning! GUS IRQ not selected\n");
 870   irq_image |= tmp;
 871   irq_image |= 0x40;            /* 
 872                                  * Combine IRQ1 (GF1) and IRQ2 (Midi) 
 873                                  */
 874 
 875   dma_image = 0x40;             /* 
 876                                  * Combine DMA1 (DRAM) and IRQ2 (ADC) 
 877                                  */
 878   tmp = gus_dma_map[gus_dma];
 879   if (!tmp)
 880     printk ("Warning! GUS DMA not selected\n");
 881   dma_image |= tmp;
 882 
 883   /* 
 884    * For some reason the IRQ and DMA addresses must be written twice
 885    */
 886 
 887   /* 
 888    * Doing it first time 
 889    */
 890 
 891   OUTB (mix_image, u_Mixer);    /* 
 892                                  * Select DMA control 
 893                                  */
 894   OUTB (dma_image | 0x80, u_IRQDMAControl);     /* 
 895                                                  * Set DMA address 
 896                                                  */
 897 
 898   OUTB (mix_image | 0x40, u_Mixer);     /* 
 899                                          * Select IRQ control 
 900                                          */
 901   OUTB (irq_image, u_IRQDMAControl);    /* 
 902                                          * Set IRQ address 
 903                                          */
 904 
 905   /* 
 906    * Doing it second time 
 907    */
 908 
 909   OUTB (mix_image, u_Mixer);    /* 
 910                                  * Select DMA control 
 911                                  */
 912   OUTB (dma_image, u_IRQDMAControl);    /* 
 913                                          * Set DMA address 
 914                                          */
 915 
 916   OUTB (mix_image | 0x40, u_Mixer);     /* 
 917                                          * Select IRQ control 
 918                                          */
 919   OUTB (irq_image, u_IRQDMAControl);    /* 
 920                                          * Set IRQ address 
 921                                          */
 922 
 923   gus_select_voice (0);         /* 
 924                                  * This disables writes to IRQ/DMA reg 
 925                                  */
 926 
 927   mix_image &= ~0x02;           /* 
 928                                  * Enable line out 
 929                                  */
 930   mix_image |= 0x08;            /* 
 931                                  * Enable IRQ 
 932                                  */
 933   OUTB (mix_image, u_Mixer);    /* 
 934                                  * Turn mixer channels on 
 935                                  * Note! Mic in is left off.
 936                                  */
 937 
 938   gus_select_voice (0);         /* 
 939                                  * This disables writes to IRQ/DMA reg 
 940                                  */
 941 
 942   gusintr (0);                  /* 
 943                                  * Serve pending interrupts 
 944                                  */
 945   RESTORE_INTR (flags);
 946 }
 947 
 948 int
 949 gus_wave_detect (int baseaddr)
     /*  */
 950 {
 951   unsigned long   i;
 952   unsigned long   loc;
 953 
 954   gus_base = baseaddr;
 955 
 956   gus_write8 (0x4c, 0);         /* Reset GF1 */
 957   gus_delay ();
 958   gus_delay ();
 959 
 960   gus_write8 (0x4c, 1);         /* Release Reset */
 961   gus_delay ();
 962   gus_delay ();
 963 
 964   /* See if there is first block there.... */
 965   gus_poke (0L, 0xaa);
 966   if (gus_peek (0L) != 0xaa)
 967     return (0);
 968 
 969   /* Now zero it out so that I can check for mirroring .. */
 970   gus_poke (0L, 0x00);
 971   for (i = 1L; i < 1024L; i++)
 972     {
 973       int             n, failed;
 974 
 975       /* check for mirroring ... */
 976       if (gus_peek (0L) != 0)
 977         break;
 978       loc = i << 10;
 979 
 980       for (n = loc - 1, failed = 0; n <= loc; n++)
 981         {
 982           gus_poke (loc, 0xaa);
 983           if (gus_peek (loc) != 0xaa)
 984             failed = 1;
 985 
 986           gus_poke (loc, 0x55);
 987           if (gus_peek (loc) != 0x55)
 988             failed = 1;
 989         }
 990 
 991       if (failed)
 992         break;
 993     }
 994   gus_mem_size = i << 10;
 995   return 1;
 996 }
 997 
 998 static int
 999 guswave_ioctl (int dev,
     /*  */
1000                unsigned int cmd, unsigned int arg)
1001 {
1002 
1003   switch (cmd)
1004     {
1005     case SNDCTL_SYNTH_INFO:
1006       gus_info.nr_voices = nr_voices;
1007       IOCTL_TO_USER ((char *) arg, 0, &gus_info, sizeof (gus_info));
1008       return 0;
1009       break;
1010 
1011     case SNDCTL_SEQ_RESETSAMPLES:
1012       reset_sample_memory ();
1013       return 0;
1014       break;
1015 
1016     case SNDCTL_SEQ_PERCMODE:
1017       return 0;
1018       break;
1019 
1020     case SNDCTL_SYNTH_MEMAVL:
1021       return gus_mem_size - free_mem_ptr - 32;
1022 
1023     default:
1024       return RET_ERROR (EINVAL);
1025     }
1026 }
1027 
1028 static int
1029 guswave_set_instr (int dev, int voice, int instr_no)
     /*  */
1030 {
1031   int             sample_no;
1032 
1033   if (instr_no < 0 || instr_no > MAX_PATCH)
1034     return RET_ERROR (EINVAL);
1035 
1036   if (voice < 0 || voice > 31)
1037     return RET_ERROR (EINVAL);
1038 
1039   if (voices[voice].volume_irq_mode == VMODE_START_NOTE)
1040     {
1041       voices[voice].sample_pending = instr_no;
1042       return 0;
1043     }
1044 
1045   sample_no = patch_table[instr_no];
1046   patch_map[voice] = -1;
1047 
1048   if (sample_no < 0)
1049     {
1050       printk ("GUS: Undefined patch %d for voice %d\n", instr_no, voice);
1051       return RET_ERROR (EINVAL);        /* 
1052                                          * Patch not defined 
1053                                          */
1054     }
1055 
1056   if (sample_ptrs[sample_no] == -1)     /* 
1057                                          * Sample not loaded 
1058                                          */
1059     {
1060       printk ("GUS: Sample #%d not loaded for patch %d (voice %d)\n", sample_no, instr_no, voice);
1061       return RET_ERROR (EINVAL);
1062     }
1063 
1064   sample_map[voice] = sample_no;
1065   patch_map[voice] = instr_no;
1066   return 0;
1067 }
1068 
1069 static int
1070 #ifdef FUTURE_VERSION
1071 guswave_kill_note (int dev, int voice, int note, int velocity)
     /*  */
1072 #else
1073 guswave_kill_note (int dev, int voice, int velocity)
1074 #endif
1075 {
1076   unsigned long   flags;
1077 
1078   DISABLE_INTR (flags);
1079   if (voices[voice].volume_irq_mode == VMODE_START_NOTE)
1080     voices[voice].kill_pending = 1;
1081   else
1082     {
1083       gus_select_voice (voice);
1084       gus_voice_fade (voice);
1085     }
1086   RESTORE_INTR (flags);
1087 
1088   return 0;
1089 }
1090 
1091 static void
1092 guswave_aftertouch (int dev, int voice, int pressure)
     /*  */
1093 {
1094   short           lo_limit, hi_limit;
1095   unsigned long   flags;
1096 
1097   return;                       /* 
1098                                  * Currently disabled 
1099                                  */
1100 
1101   if (voice < 0 || voice > 31)
1102     return;
1103 
1104   if (voices[voice].mode & WAVE_ENVELOPES && voices[voice].env_phase != 2)
1105     return;                     /* 
1106                                  * Don't mix with envelopes 
1107                                  */
1108 
1109   if (pressure < 32)
1110     {
1111       DISABLE_INTR (flags);
1112       gus_select_voice (voice);
1113       gus_rampoff ();
1114       compute_and_set_volume (voice, 255, 0);   /* 
1115                                                  * Back to original volume 
1116                                                  */
1117       RESTORE_INTR (flags);
1118       return;
1119     }
1120 
1121   hi_limit = voices[voice].current_volume;
1122   lo_limit = hi_limit * 99 / 100;
1123   if (lo_limit < 65)
1124     lo_limit = 65;
1125 
1126   DISABLE_INTR (flags);
1127   gus_select_voice (voice);
1128   if (hi_limit > (4095 - 65))
1129     {
1130       hi_limit = 4095 - 65;
1131       gus_voice_volume (hi_limit);
1132     }
1133   gus_ramp_range (lo_limit, hi_limit);
1134   gus_ramp_rate (3, 8);
1135   gus_rampon (0x58);            /* 
1136                                  * Bidirectional, Down, Loop 
1137                                  */
1138   RESTORE_INTR (flags);
1139 }
1140 
1141 static void
1142 guswave_panning (int dev, int voice, int value)
     /*  */
1143 {
1144   if (voice >= 0 || voice < 32)
1145     voices[voice].panning = value;
1146 }
1147 
1148 static void
1149 compute_volume (int voice, int volume)
     /*  */
1150 {
1151   if (volume < 128)
1152     voices[voice].midi_volume = volume;
1153 
1154     switch (volume_method)
1155       {
1156       case VOL_METHOD_ADAGIO:
1157         voices[voice].initial_volume =
1158           gus_adagio_vol (voices[voice].midi_volume, voices[voice].main_vol,
1159                           voices[voice].expression_vol,
1160                           voices[voice].patch_vol);
1161         break;
1162 
1163       default:
1164         voices[voice].initial_volume = volume_base +
1165           (voices[voice].midi_volume * volume_scale);
1166       }
1167 
1168   if (voices[voice].initial_volume > 4030)
1169     voices[voice].initial_volume = 4030;
1170 }
1171 
1172 static void
1173 compute_and_set_volume (int voice, int volume, int ramp_time)
     /*  */
1174 {
1175   int             current, target, rate;
1176   unsigned long   flags;
1177 
1178   DISABLE_INTR (flags);
1179 /* 
1180  * CAUTION! Interrupts disabled. Enable them before returning
1181  */
1182 
1183   gus_select_voice (voice);
1184 
1185   compute_volume (voice, volume);
1186   voices[voice].current_volume = voices[voice].initial_volume;
1187 
1188   current = gus_read16 (0x09) >> 4;
1189   target = voices[voice].initial_volume;
1190 
1191   if (ramp_time == INSTANT_RAMP)
1192     {
1193       gus_rampoff ();
1194       gus_voice_volume (target);
1195       RESTORE_INTR (flags);
1196       return;
1197     }
1198 
1199   if (ramp_time == FAST_RAMP)
1200     rate = 63;
1201   else
1202     rate = 16;
1203   gus_ramp_rate (0, rate);
1204 
1205   if ((target - current) / 64 == 0)     /* 
1206                                          * Too close 
1207                                          */
1208     {
1209       gus_rampoff ();
1210       gus_voice_volume (target);
1211       RESTORE_INTR (flags);
1212       return;
1213     }
1214 
1215   if (target > current)
1216     {
1217       if (target > (4095 - 65))
1218         target = 4095 - 65;
1219       gus_ramp_range (current, target);
1220       gus_rampon (0x00);        /* 
1221                                  * Ramp up, once, no irq 
1222                                  */
1223     }
1224   else
1225     {
1226       if (target < 65)
1227         target = 65;
1228 
1229       gus_ramp_range (target, current);
1230       gus_rampon (0x40);        /* 
1231                                  * Ramp down, once, no irq 
1232                                  */
1233     }
1234   RESTORE_INTR (flags);
1235 }
1236 
1237 static void
1238 dynamic_volume_change (int voice)
     /*  */
1239 {
1240   unsigned char   status;
1241   unsigned long   flags;
1242 
1243   DISABLE_INTR (flags);
1244   gus_select_voice (voice);
1245   status = gus_read8 (0x00);    /* 
1246                                  * Voice status 
1247                                  */
1248   RESTORE_INTR (flags);
1249 
1250   if (status & 0x03)
1251     return;                     /* 
1252                                  * Voice not started 
1253                                  */
1254 
1255   if (!(voices[voice].mode & WAVE_ENVELOPES))
1256     {
1257       compute_and_set_volume (voice, voices[voice].midi_volume, 1);
1258       return;
1259     }
1260 
1261   /* 
1262    * Voice is running and has envelopes.
1263    */
1264 
1265   DISABLE_INTR (flags);
1266   gus_select_voice (voice);
1267   status = gus_read8 (0x0d);    /* 
1268                                  * Ramping status 
1269                                  */
1270   RESTORE_INTR (flags);
1271 
1272   if (status & 0x03)            /* 
1273                                  * Sustain phase? 
1274                                  */
1275     {
1276       compute_and_set_volume (voice, voices[voice].midi_volume, 1);
1277       return;
1278     }
1279 
1280   if (voices[voice].env_phase < 0)
1281     return;
1282 
1283   compute_volume (voice, voices[voice].midi_volume);
1284 
1285 #if 0                           /* 
1286                                  * * * Is this really required   */
1287   voices[voice].current_volume =
1288     gus_read16 (0x09) >> 4;     /* 
1289                                  * Get current volume 
1290                                  */
1291 
1292   voices[voice].env_phase--;
1293   step_envelope (voice);
1294 #endif
1295 }
1296 
1297 static void
1298 guswave_controller (int dev, int voice, int ctrl_num, int value)
     /*  */
1299 {
1300   unsigned long   flags;
1301   unsigned long   freq;
1302 
1303   if (voice < 0 || voice > 31)
1304     return;
1305 
1306   switch (ctrl_num)
1307     {
1308     case CTRL_PITCH_BENDER:
1309       voices[voice].bender = value;
1310 
1311       if (voices[voice].volume_irq_mode != VMODE_START_NOTE)
1312         {
1313           freq = compute_finetune (voices[voice].orig_freq, value, voices[voice].bender_range);
1314           voices[voice].current_freq = freq;
1315 
1316           DISABLE_INTR (flags);
1317           gus_select_voice (voice);
1318           gus_voice_freq (freq);
1319           RESTORE_INTR (flags);
1320         }
1321       break;
1322 
1323     case CTRL_PITCH_BENDER_RANGE:
1324       voices[voice].bender_range = value;
1325       break;
1326 #ifdef FUTURE_VERSION
1327     case CTL_EXPRESSION:
1328       value /= 128;
1329 #endif
1330     case CTRL_EXPRESSION:
1331       volume_method = VOL_METHOD_ADAGIO;
1332       voices[voice].expression_vol = value;
1333       if (voices[voice].volume_irq_mode != VMODE_START_NOTE)
1334          dynamic_volume_change (voice);
1335       break;
1336 
1337 #ifdef FUTURE_VERSION
1338     case CTL_PAN:
1339       voices[voice].panning = (value * 2) - 128;
1340       break;
1341 
1342     case CTL_MAIN_VOLUME:
1343       value = (value * 100) / 16383;
1344 #endif
1345 
1346     case CTRL_MAIN_VOLUME:
1347       volume_method = VOL_METHOD_ADAGIO;
1348       voices[voice].main_vol = value;
1349       if (voices[voice].volume_irq_mode != VMODE_START_NOTE)
1350          dynamic_volume_change (voice);
1351       break;
1352 
1353     default:                    /* 
1354                                  * Ignore 
1355                                  */
1356       break;
1357     }
1358 }
1359 
1360 static int
1361 guswave_start_note2 (int dev, int voice, int note_num, int volume)
     /*  */
1362 {
1363   int             sample, best_sample, best_delta, delta_freq;
1364   int             is16bits, samplep, patch, pan;
1365   unsigned long   note_freq, base_note, freq, flags;
1366   unsigned char   mode = 0;
1367 
1368   if (voice < 0 || voice > 31)
1369     {
1370       printk ("GUS: Invalid voice\n");
1371       return RET_ERROR (EINVAL);
1372     }
1373 
1374   if (note_num == 255)
1375     {
1376       if (voices[voice].mode & WAVE_ENVELOPES)
1377         {
1378           voices[voice].midi_volume = volume;
1379           dynamic_volume_change (voice);
1380           return 0;
1381         }
1382 
1383       compute_and_set_volume (voice, volume, 1);
1384       return 0;
1385     }
1386 
1387   if ((patch = patch_map[voice]) == -1)
1388     {
1389       return RET_ERROR (EINVAL);
1390     }
1391 
1392   if ((samplep = patch_table[patch]) == -1)
1393     {
1394       return RET_ERROR (EINVAL);
1395     }
1396 
1397   note_freq = note_to_freq (note_num);
1398 
1399   /* 
1400    * Find a sample within a patch so that the note_freq is between low_note
1401    * and high_note.
1402    */
1403   sample = -1;
1404 
1405   best_sample = samplep;
1406   best_delta = 1000000;
1407   while (samplep >= 0 && sample == -1)
1408     {
1409       delta_freq = note_freq - samples[samplep].base_note;
1410       if (delta_freq < 0)
1411         delta_freq = -delta_freq;
1412       if (delta_freq < best_delta)
1413         {
1414           best_sample = samplep;
1415           best_delta = delta_freq;
1416         }
1417       if (samples[samplep].low_note <= note_freq && note_freq <= samples[samplep].high_note)
1418         sample = samplep;
1419       else
1420         samplep = samples[samplep].key;         /* 
1421                                                  * Follow link 
1422                                                  */
1423     }
1424   if (sample == -1)
1425     sample = best_sample;
1426 
1427   if (sample == -1)
1428     {
1429       printk ("GUS: Patch %d not defined for note %d\n", patch, note_num);
1430       return 0;                 /* 
1431                                  * Should play default patch ??? 
1432                                  */
1433     }
1434 
1435   is16bits = (samples[sample].mode & WAVE_16_BITS) ? 1 : 0;     /* 
1436                                                                  * 8 or 16
1437                                                                  * bit
1438                                                                  * samples 
1439                                                                  */
1440   voices[voice].mode = samples[sample].mode;
1441   voices[voice].patch_vol = samples[sample].volume;
1442 
1443   if (voices[voice].mode & WAVE_ENVELOPES)
1444     {
1445       int             i;
1446 
1447       for (i = 0; i < 6; i++)
1448         {
1449           voices[voice].env_rate[i] = samples[sample].env_rate[i];
1450           voices[voice].env_offset[i] = samples[sample].env_offset[i];
1451         }
1452     }
1453 
1454   sample_map[voice] = sample;
1455 
1456   base_note = samples[sample].base_note / 100;  /* 
1457                                                  * To avoid overflows 
1458                                                  */
1459   note_freq /= 100;
1460 
1461   freq = samples[sample].base_freq * note_freq / base_note;
1462 
1463   voices[voice].orig_freq = freq;
1464 
1465   /* 
1466    * Since the pitch bender may have been set before playing the note, we
1467    * have to calculate the bending now.
1468    */
1469 
1470   freq = compute_finetune (voices[voice].orig_freq, voices[voice].bender, voices[voice].bender_range);
1471   voices[voice].current_freq = freq;
1472 
1473   pan = (samples[sample].panning + voices[voice].panning) / 32;
1474   pan += 7;
1475   if (pan < 0)
1476     pan = 0;
1477   if (pan > 15)
1478     pan = 15;
1479 
1480   if (samples[sample].mode & WAVE_16_BITS)
1481     {
1482       mode |= 0x04;             /* 
1483                                  * 16 bits 
1484                                  */
1485       if ((sample_ptrs[sample] >> 18) !=
1486           ((sample_ptrs[sample] + samples[sample].len) >> 18))
1487         printk ("GUS: Sample address error\n");
1488     }
1489 
1490   /*************************************************************************
1491    *    CAUTION!        Interrupts disabled. Don't return before enabling
1492    *************************************************************************/
1493 
1494   DISABLE_INTR (flags);
1495   gus_select_voice (voice);
1496   gus_voice_off ();             /* 
1497                                  * It may still be running 
1498                                  */
1499   gus_rampoff ();
1500   if (voices[voice].mode & WAVE_ENVELOPES)
1501     {
1502       compute_volume (voice, volume);
1503       init_envelope (voice);
1504     }
1505   else
1506     compute_and_set_volume (voice, volume, 0);
1507 
1508   if (samples[sample].mode & WAVE_LOOP_BACK)
1509     gus_write_addr (0x0a, sample_ptrs[sample] + samples[sample].len -
1510                     voices[voice].offset_pending, is16bits);    /* Sample
1511                                                                  * start=end */
1512   else
1513     gus_write_addr (0x0a, sample_ptrs[sample] + voices[voice].offset_pending,
1514                     is16bits);  /* Sample start=begin */
1515 
1516   if (samples[sample].mode & WAVE_LOOPING)
1517     {
1518       mode |= 0x08;             /* 
1519                                  * Looping on 
1520                                  */
1521 
1522       if (samples[sample].mode & WAVE_BIDIR_LOOP)
1523         mode |= 0x10;           /* 
1524                                  * Bidirectional looping on 
1525                                  */
1526 
1527       if (samples[sample].mode & WAVE_LOOP_BACK)
1528         {
1529           gus_write_addr (0x0a,
1530                           sample_ptrs[sample] + samples[sample].loop_end -
1531                           voices[voice].offset_pending, is16bits);
1532           mode |= 0x40;
1533         }
1534 
1535       gus_write_addr (0x02, sample_ptrs[sample] + samples[sample].loop_start, is16bits);        /* 
1536                                                                                                  * Loop 
1537                                                                                                  * start 
1538                                                                                                  * location 
1539                                                                                                  */
1540       gus_write_addr (0x04, sample_ptrs[sample] + samples[sample].loop_end, is16bits);  /* 
1541                                                                                          * Loop 
1542                                                                                          * end 
1543                                                                                          * location 
1544                                                                                          */
1545     }
1546   else
1547     {
1548       mode |= 0x20;             /* 
1549                                  * Loop irq at the end 
1550                                  */
1551       voices[voice].loop_irq_mode = LMODE_FINISH;       /* 
1552                                                          * Ramp it down at
1553                                                          * the * end 
1554                                                          */
1555       voices[voice].loop_irq_parm = 1;
1556       gus_write_addr (0x02, sample_ptrs[sample], is16bits);     /* 
1557                                                                  * Loop start 
1558                                                                  * location 
1559                                                                  */
1560       gus_write_addr (0x04, sample_ptrs[sample] + samples[sample].len-1, is16bits);     /* 
1561                                                                                          * Loop 
1562                                                                                          * end 
1563                                                                                          * location 
1564                                                                                          */
1565     }
1566   gus_voice_freq (freq);
1567   gus_voice_balance (pan);
1568   gus_voice_on (mode);
1569   RESTORE_INTR (flags);
1570 
1571   return 0;
1572 }
1573 
1574 /* 
1575  * * New guswave_start_note by Andrew J. Robinson attempts to minimize
1576  * clicking  * when the note playing on the voice is changed.  It uses volume 
1577  * ramping. */
1578 
1579 static int
1580 guswave_start_note (int dev, int voice, int note_num, int volume)
     /*  */
1581 {
1582   long int        flags;
1583   int             mode;
1584   int             ret_val = 0;
1585 
1586   DISABLE_INTR (flags);
1587   if (note_num == 255)
1588     {
1589       if (voices[voice].volume_irq_mode == VMODE_START_NOTE)
1590         voices[voice].volume_pending = volume;
1591       else
1592         ret_val = guswave_start_note2 (dev, voice, note_num, volume);
1593     }
1594   else
1595     {
1596        gus_select_voice (voice);
1597        mode = gus_read8 (0x00);
1598        if (mode & 0x20)
1599          gus_write8 (0x00, mode & 0xdf);    /* No interrupt! */
1600 
1601        voices[voice].offset_pending = 0;
1602        voices[voice].kill_pending = 0;
1603        voices[voice].volume_irq_mode = 0;
1604        voices[voice].loop_irq_mode = 0;
1605 
1606        if (voices[voice].sample_pending >= 0)
1607        {
1608          guswave_set_instr (voices[voice].dev_pending, voice,
1609          voices[voice].sample_pending);
1610          voices[voice].sample_pending = -1;
1611        }
1612 
1613       if ((mode & 0x01) || ((gus_read16 (0x09) >> 4) < 2065))
1614         {
1615           ret_val = guswave_start_note2 (dev, voice, note_num, volume);
1616         }
1617       else
1618         {
1619           voices[voice].dev_pending = dev;
1620           voices[voice].note_pending = note_num;
1621           voices[voice].volume_pending = volume;
1622           voices[voice].volume_irq_mode = VMODE_START_NOTE;
1623 
1624           gus_rampoff ();
1625           gus_ramp_range (2000, 4065);
1626           gus_ramp_rate (0, 63);        /* Fastest possible rate */
1627           gus_rampon (0x20 | 0x40);     /* Ramp down, once, irq */
1628         }
1629     }
1630   RESTORE_INTR (flags);
1631   return ret_val;
1632 }
1633 
1634 static void
1635 guswave_reset (int dev)
     /*  */
1636 {
1637   int             i;
1638 
1639   for (i = 0; i < 32; i++)
1640     {
1641       gus_voice_init (i);
1642       gus_voice_init2 (i);
1643     }
1644 }
1645 
1646 static int
1647 guswave_open (int dev, int mode)
     /*  */
1648 {
1649   int             err;
1650 
1651   if (gus_busy)
1652     return RET_ERROR (EBUSY);
1653 
1654   gus_initialize ();
1655 
1656   if ((err = DMAbuf_open_dma (gus_devnum)))
1657     return err;
1658 
1659   RESET_WAIT_QUEUE (dram_sleeper, dram_sleep_flag);
1660   gus_busy = 1;
1661   active_device = GUS_DEV_WAVE;
1662 
1663   gus_reset ();
1664 
1665   return 0;
1666 }
1667 
1668 static void
1669 guswave_close (int dev)
     /*  */
1670 {
1671   gus_busy = 0;
1672   active_device = 0;
1673   gus_reset ();
1674 
1675   DMAbuf_close_dma (gus_devnum);
1676 }
1677 
1678 static int
1679 guswave_load_patch (int dev, int format, snd_rw_buf * addr,
     /*  */
1680                     int offs, int count, int pmgr_flag)
1681 {
1682   struct patch_info patch;
1683   int             instr;
1684   long            sizeof_patch;
1685 
1686   unsigned long   blk_size, blk_end, left, src_offs, target;
1687 
1688   sizeof_patch = (long) &patch.data[0] - (long) &patch;         /* 
1689                                                                  * Size of
1690                                                                  * the header
1691                                                                  * * info 
1692                                                                  */
1693 
1694   if (format != GUS_PATCH)
1695     {
1696       printk ("GUS Error: Invalid patch format (key) 0x%x\n", format);
1697       return RET_ERROR (EINVAL);
1698     }
1699 
1700   if (count < sizeof_patch)
1701     {
1702       printk ("GUS Error: Patch header too short\n");
1703       return RET_ERROR (EINVAL);
1704     }
1705 
1706   count -= sizeof_patch;
1707 
1708   if (free_sample >= MAX_SAMPLE)
1709     {
1710       printk ("GUS: Sample table full\n");
1711       return RET_ERROR (ENOSPC);
1712     }
1713 
1714   /* 
1715    * Copy the header from user space but ignore the first bytes which have
1716    * been transferred already.
1717    */
1718 
1719   COPY_FROM_USER (&((char *) &patch)[offs], addr, offs, sizeof_patch - offs);
1720 
1721   instr = patch.instr_no;
1722 
1723   if (instr < 0 || instr > MAX_PATCH)
1724     {
1725       printk ("GUS: Invalid patch number %d\n", instr);
1726       return RET_ERROR (EINVAL);
1727     }
1728 
1729   if (count < patch.len)
1730     {
1731       printk ("GUS Warning: Patch record too short (%d<%d)\n",
1732               count, (int) patch.len);
1733       patch.len = count;
1734     }
1735 
1736   if (patch.len <= 0 || patch.len > gus_mem_size)
1737     {
1738       printk ("GUS: Invalid sample length %d\n", (int) patch.len);
1739       return RET_ERROR (EINVAL);
1740     }
1741 
1742   if (patch.mode & WAVE_LOOPING)
1743     {
1744       if (patch.loop_start < 0 || patch.loop_start >= patch.len)
1745         {
1746           printk ("GUS: Invalid loop start\n");
1747           return RET_ERROR (EINVAL);
1748         }
1749 
1750       if (patch.loop_end < patch.loop_start || patch.loop_end > patch.len)
1751         {
1752           printk ("GUS: Invalid loop end\n");
1753           return RET_ERROR (EINVAL);
1754         }
1755     }
1756 
1757   free_mem_ptr = (free_mem_ptr + 31) & ~31;     /* 
1758                                                  * Alignment 32 bytes 
1759                                                  */
1760 
1761 #define GUS_BANK_SIZE (256*1024)
1762 
1763   if (patch.mode & WAVE_16_BITS)
1764     {
1765       /* 
1766        * 16 bit samples must fit one 256k bank.
1767        */
1768       if (patch.len >= GUS_BANK_SIZE)
1769         {
1770           printk ("GUS: Sample (16 bit) too long %d\n", (int) patch.len);
1771           return RET_ERROR (ENOSPC);
1772         }
1773 
1774       if ((free_mem_ptr / GUS_BANK_SIZE) !=
1775           ((free_mem_ptr + patch.len) / GUS_BANK_SIZE))
1776         {
1777           unsigned long   tmp_mem =     /* 
1778                                          * Align to 256K*N 
1779                                          */
1780           ((free_mem_ptr / GUS_BANK_SIZE) + 1) * GUS_BANK_SIZE;
1781 
1782           if ((tmp_mem + patch.len) > gus_mem_size)
1783             return RET_ERROR (ENOSPC);
1784 
1785           free_mem_ptr = tmp_mem;       /* 
1786                                          * This leaves unusable memory 
1787                                          */
1788         }
1789     }
1790 
1791   if ((free_mem_ptr + patch.len) > gus_mem_size)
1792     return RET_ERROR (ENOSPC);
1793 
1794   sample_ptrs[free_sample] = free_mem_ptr;
1795 
1796   /* 
1797    * Tremolo is not possible with envelopes 
1798    */
1799 
1800   if (patch.mode & WAVE_ENVELOPES)
1801     patch.mode &= ~WAVE_TREMOLO;
1802 
1803   memcpy ((char *) &samples[free_sample], &patch, sizeof_patch);
1804 
1805   /* 
1806    * Link this_one sample to the list of samples for patch 'instr'.
1807    */
1808 
1809   samples[free_sample].key = patch_table[instr];
1810   patch_table[instr] = free_sample;
1811 
1812   /* 
1813    * Use DMA to transfer the wave data to the DRAM
1814    */
1815 
1816   left = patch.len;
1817   src_offs = 0;
1818   target = free_mem_ptr;
1819 
1820   while (left)                  /* 
1821                                  * Not all moved 
1822                                  */
1823     {
1824       blk_size = sound_buffsizes[gus_devnum];
1825       if (blk_size > left)
1826         blk_size = left;
1827 
1828       /* 
1829        * DMA cannot cross 256k bank boundaries. Check for that.
1830        */
1831       blk_end = target + blk_size;
1832 
1833       if ((target >> 18) != (blk_end >> 18))
1834         {                       /* 
1835                                  * Have to split the block 
1836                                  */
1837 
1838           blk_end &= ~(256 * 1024 - 1);
1839           blk_size = blk_end - target;
1840         }
1841 
1842 #if defined(GUS_NO_DMA) || defined(GUS_PATCH_NO_DMA)
1843       /* 
1844        * For some reason the DMA is not possible. We have to use PIO.
1845        */
1846       {
1847         long            i;
1848         unsigned char   data;
1849 
1850         for (i = 0; i < blk_size; i++)
1851           {
1852             GET_BYTE_FROM_USER (data, addr, sizeof_patch + i);
1853             if (patch.mode & WAVE_UNSIGNED)
1854 
1855               if (!(patch.mode & WAVE_16_BITS) || (i & 0x01))
1856                 data ^= 0x80;   /* 
1857                                  * Convert to signed 
1858                                  */
1859             gus_poke (target + i, data);
1860           }
1861       }
1862 #else /* 
1863        * * * GUS_NO_DMA   */
1864       {
1865         unsigned long   address, hold_address;
1866         unsigned char   dma_command;
1867         unsigned long   flags;
1868 
1869         /* 
1870          * OK, move now. First in and then out.
1871          */
1872 
1873         COPY_FROM_USER (snd_raw_buf[gus_devnum][0],
1874                         addr, sizeof_patch + src_offs,
1875                         blk_size);
1876 
1877         DISABLE_INTR (flags);   /******** INTERRUPTS DISABLED NOW ********/
1878         gus_write8 (0x41, 0);   /* 
1879                                  * Disable GF1 DMA 
1880                                  */
1881         DMAbuf_start_dma (gus_devnum, snd_raw_buf_phys[gus_devnum][0],
1882                           blk_size, DMA_MODE_WRITE);
1883 
1884         /* 
1885          * Set the DRAM address for the wave data
1886          */
1887 
1888         address = target;
1889 
1890         if (sound_dsp_dmachan[gus_devnum] > 3)
1891           {
1892             hold_address = address;
1893             address = address >> 1;
1894             address &= 0x0001ffffL;
1895             address |= (hold_address & 0x000c0000L);
1896           }
1897 
1898         gus_write16 (0x42, (address >> 4) & 0xffff);    /* 
1899                                                          * DRAM DMA address 
1900                                                          */
1901 
1902         /* 
1903          * Start the DMA transfer
1904          */
1905 
1906         dma_command = 0x21;     /* 
1907                                  * IRQ enable, DMA start 
1908                                  */
1909         if (patch.mode & WAVE_UNSIGNED)
1910           dma_command |= 0x80;  /* 
1911                                  * Invert MSB 
1912                                  */
1913         if (patch.mode & WAVE_16_BITS)
1914           dma_command |= 0x40;  /* 
1915                                  * 16 bit _DATA_ 
1916                                  */
1917         if (sound_dsp_dmachan[gus_devnum] > 3)
1918           dma_command |= 0x04;  /* 
1919                                  * 16 bit DMA channel 
1920                                  */
1921 
1922         gus_write8 (0x41, dma_command);         /* 
1923                                                  * Let's go luteet (=bugs) 
1924                                                  */
1925 
1926         /* 
1927          * Sleep here until the DRAM DMA done interrupt is served
1928          */
1929         active_device = GUS_DEV_WAVE;
1930 
1931         DO_SLEEP (dram_sleeper, dram_sleep_flag, HZ);
1932         if (TIMED_OUT (dram_sleeper, dram_sleep_flag))
1933           printk ("GUS: DMA Transfer timed out\n");
1934         RESTORE_INTR (flags);
1935       }
1936 #endif /* 
1937         * * * GUS_NO_DMA   */
1938 
1939       /* 
1940        * Now the next part
1941        */
1942 
1943       left -= blk_size;
1944       src_offs += blk_size;
1945       target += blk_size;
1946 
1947       gus_write8 (0x41, 0);     /* 
1948                                  * Stop DMA 
1949                                  */
1950     }
1951 
1952   free_mem_ptr += patch.len;
1953 
1954   if (!pmgr_flag)
1955     pmgr_inform (dev, PM_E_PATCH_LOADED, instr, free_sample, 0, 0);
1956   free_sample++;
1957   return 0;
1958 }
1959 
1960 static void
1961 guswave_hw_control (int dev, unsigned char *event)
     /*  */
1962 {
1963   int             voice, cmd;
1964   unsigned short  p1, p2;
1965   unsigned long   plong, flags;
1966 
1967   cmd = event[2];
1968   voice = event[3];
1969   p1 = *(unsigned short *) &event[4];
1970   p2 = *(unsigned short *) &event[6];
1971   plong = *(unsigned long *) &event[4];
1972 
1973   if ((voices[voice].volume_irq_mode == VMODE_START_NOTE) &&
1974       (cmd != _GUS_VOICESAMPLE) && (cmd != _GUS_VOICE_POS))
1975     do_volume_irq (voice);
1976 
1977   switch (cmd)
1978     {
1979 
1980     case _GUS_NUMVOICES:
1981       DISABLE_INTR (flags);
1982       gus_select_voice (voice);
1983       gus_select_max_voices (p1);
1984       RESTORE_INTR (flags);
1985       break;
1986 
1987     case _GUS_VOICESAMPLE:
1988       guswave_set_instr (dev, voice, p1);
1989       break;
1990 
1991     case _GUS_VOICEON:
1992       DISABLE_INTR (flags);
1993       gus_select_voice (voice);
1994       p1 &= ~0x20;              /* 
1995                                  * Disable intr 
1996                                  */
1997       gus_voice_on (p1);
1998       RESTORE_INTR (flags);
1999       break;
2000 
2001     case _GUS_VOICEOFF:
2002       DISABLE_INTR (flags);
2003       gus_select_voice (voice);
2004       gus_voice_off ();
2005       RESTORE_INTR (flags);
2006       break;
2007 
2008     case _GUS_VOICEFADE:
2009       DISABLE_INTR (flags);
2010       gus_select_voice (voice);
2011       gus_voice_fade (voice);
2012       RESTORE_INTR (flags);
2013       break;
2014 
2015     case _GUS_VOICEMODE:
2016       DISABLE_INTR (flags);
2017       gus_select_voice (voice);
2018       p1 &= ~0x20;              /* 
2019                                  * Disable intr 
2020                                  */
2021       gus_voice_mode (p1);
2022       RESTORE_INTR (flags);
2023       break;
2024 
2025     case _GUS_VOICEBALA:
2026       DISABLE_INTR (flags);
2027       gus_select_voice (voice);
2028       gus_voice_balance (p1);
2029       RESTORE_INTR (flags);
2030       break;
2031 
2032     case _GUS_VOICEFREQ:
2033       DISABLE_INTR (flags);
2034       gus_select_voice (voice);
2035       gus_voice_freq (plong);
2036       RESTORE_INTR (flags);
2037       break;
2038 
2039     case _GUS_VOICEVOL:
2040       DISABLE_INTR (flags);
2041       gus_select_voice (voice);
2042       gus_voice_volume (p1);
2043       RESTORE_INTR (flags);
2044       break;
2045 
2046     case _GUS_VOICEVOL2:        /* 
2047                                  * Just update the voice value 
2048                                  */
2049       voices[voice].initial_volume =
2050         voices[voice].current_volume = p1;
2051       break;
2052 
2053     case _GUS_RAMPRANGE:
2054       if (voices[voice].mode & WAVE_ENVELOPES)
2055         break;                  /* 
2056                                  * NO-NO 
2057                                  */
2058       DISABLE_INTR (flags);
2059       gus_select_voice (voice);
2060       gus_ramp_range (p1, p2);
2061       RESTORE_INTR (flags);
2062       break;
2063 
2064     case _GUS_RAMPRATE:
2065       if (voices[voice].mode & WAVE_ENVELOPES)
2066         break;                  /* 
2067                                  * NO-NO 
2068                                  */
2069       DISABLE_INTR (flags);
2070       gus_select_voice (voice);
2071       gus_ramp_rate (p1, p2);
2072       RESTORE_INTR (flags);
2073       break;
2074 
2075     case _GUS_RAMPMODE:
2076       if (voices[voice].mode & WAVE_ENVELOPES)
2077         break;                  /* 
2078                                  * NO-NO 
2079                                  */
2080       DISABLE_INTR (flags);
2081       gus_select_voice (voice);
2082       p1 &= ~0x20;              /* 
2083                                  * Disable intr 
2084                                  */
2085       gus_ramp_mode (p1);
2086       RESTORE_INTR (flags);
2087       break;
2088 
2089     case _GUS_RAMPON:
2090       if (voices[voice].mode & WAVE_ENVELOPES)
2091         break;                  /* 
2092                                  * NO-NO 
2093                                  */
2094       DISABLE_INTR (flags);
2095       gus_select_voice (voice);
2096       p1 &= ~0x20;              /* 
2097                                  * Disable intr 
2098                                  */
2099       gus_rampon (p1);
2100       RESTORE_INTR (flags);
2101       break;
2102 
2103     case _GUS_RAMPOFF:
2104       if (voices[voice].mode & WAVE_ENVELOPES)
2105         break;                  /* 
2106                                  * NO-NO 
2107                                  */
2108       DISABLE_INTR (flags);
2109       gus_select_voice (voice);
2110       gus_rampoff ();
2111       RESTORE_INTR (flags);
2112       break;
2113 
2114     case _GUS_VOLUME_SCALE:
2115       volume_base = p1;
2116       volume_scale = p2;
2117       break;
2118 
2119     case _GUS_VOICE_POS:
2120       DISABLE_INTR (flags);
2121       gus_select_voice (voice);
2122       gus_set_voice_pos (voice, plong);
2123       RESTORE_INTR (flags);
2124       break;
2125 
2126     default:;
2127     }
2128 }
2129 
2130 static int
2131 gus_sampling_set_speed (int speed)
     /*  */
2132 {
2133   if (speed <= 0)
2134     return gus_sampling_speed;
2135 
2136   if (speed > 44100)
2137     speed = 44100;
2138 
2139   gus_sampling_speed = speed;
2140   return speed;
2141 }
2142 
2143 static int
2144 gus_sampling_set_channels (int channels)
     /*  */
2145 {
2146   if (!channels)
2147     return gus_sampling_channels;
2148   if (channels > 2)
2149     channels = 2;
2150   if (channels < 1)
2151     channels = 1;
2152   gus_sampling_channels = channels;
2153   return channels;
2154 }
2155 
2156 static int
2157 gus_sampling_set_bits (int bits)
     /*  */
2158 {
2159   if (!bits)
2160     return gus_sampling_bits;
2161 
2162   if (bits != 8 && bits != 16)
2163     bits = 8;
2164 
2165   gus_sampling_bits = bits;
2166   return bits;
2167 }
2168 
2169 static int
2170 gus_sampling_ioctl (int dev, unsigned int cmd, unsigned int arg, int local)
     /*  */
2171 {
2172   switch (cmd)
2173     {
2174     case SOUND_PCM_WRITE_RATE:
2175       if (local)
2176         return gus_sampling_set_speed (arg);
2177       return IOCTL_OUT (arg, gus_sampling_set_speed (IOCTL_IN (arg)));
2178       break;
2179 
2180     case SOUND_PCM_READ_RATE:
2181       if (local)
2182         return gus_sampling_speed;
2183       return IOCTL_OUT (arg, gus_sampling_speed);
2184       break;
2185 
2186     case SNDCTL_DSP_STEREO:
2187       if (local)
2188         return gus_sampling_set_channels (arg + 1) - 1;
2189       return IOCTL_OUT (arg, gus_sampling_set_channels (IOCTL_IN (arg) + 1) - 1);
2190       break;
2191 
2192     case SOUND_PCM_WRITE_CHANNELS:
2193       if (local)
2194         return gus_sampling_set_channels (arg);
2195       return IOCTL_OUT (arg, gus_sampling_set_channels (IOCTL_IN (arg)));
2196       break;
2197 
2198     case SOUND_PCM_READ_CHANNELS:
2199       if (local)
2200         return gus_sampling_channels;
2201       return IOCTL_OUT (arg, gus_sampling_channels);
2202       break;
2203 
2204     case SNDCTL_DSP_SAMPLESIZE:
2205       if (local)
2206         return gus_sampling_set_bits (arg);
2207       return IOCTL_OUT (arg, gus_sampling_set_bits (IOCTL_IN (arg)));
2208       break;
2209 
2210     case SOUND_PCM_READ_BITS:
2211       if (local)
2212         return gus_sampling_bits;
2213       return IOCTL_OUT (arg, gus_sampling_bits);
2214 
2215     case SOUND_PCM_WRITE_FILTER:        /* 
2216                                          * NOT YET IMPLEMENTED 
2217                                          */
2218       return IOCTL_OUT (arg, RET_ERROR (EINVAL));
2219       break;
2220 
2221     case SOUND_PCM_READ_FILTER:
2222       return IOCTL_OUT (arg, RET_ERROR (EINVAL));
2223       break;
2224 
2225     default:
2226       return RET_ERROR (EINVAL);
2227     }
2228   return RET_ERROR (EINVAL);
2229 }
2230 
2231 static void
2232 gus_sampling_reset (int dev)
     /*  */
2233 {
2234 }
2235 
2236 static int
2237 gus_sampling_open (int dev, int mode)
     /*  */
2238 {
2239 #ifdef GUS_NO_DMA
2240   printk ("GUS: DMA mode not enabled. Device not supported\n");
2241   return RET_ERROR (ENXIO);
2242 #endif
2243 
2244   if (gus_busy)
2245     return RET_ERROR (EBUSY);
2246 
2247   gus_initialize ();
2248 
2249   gus_busy = 1;
2250   active_device = 0;
2251 
2252   gus_reset ();
2253   reset_sample_memory ();
2254   gus_select_max_voices (14);
2255 
2256   pcm_active = 0;
2257   pcm_opened = 1;
2258   if (mode & OPEN_READ) 
2259   {
2260      recording_active = 1;
2261      set_input_volumes();
2262   }
2263 
2264   return 0;
2265 }
2266 
2267 static void
2268 gus_sampling_close (int dev)
     /*  */
2269 {
2270   gus_reset ();
2271   gus_busy = 0;
2272   pcm_opened = 0;
2273   active_device = 0;
2274 
2275   if (recording_active)
2276      set_input_volumes();
2277 
2278   recording_active = 0;
2279 }
2280 
2281 static void
2282 gus_sampling_update_volume (void)
     /*  */
2283 {
2284   unsigned long   flags;
2285   int             voice;
2286 
2287   DISABLE_INTR (flags);
2288   if (pcm_active && pcm_opened)
2289     for (voice = 0; voice < gus_sampling_channels; voice++)
2290       {
2291         gus_select_voice (voice);
2292         gus_rampoff ();
2293         gus_voice_volume (1530 + (25 * gus_pcm_volume));
2294         gus_ramp_range (65, 1530 + (25 * gus_pcm_volume));
2295       }
2296   RESTORE_INTR (flags);
2297 }
2298 
2299 static void
2300 play_next_pcm_block (void)
     /*  */
2301 {
2302   unsigned long   flags;
2303   int             speed = gus_sampling_speed;
2304   int             this_one, is16bits, chn;
2305   unsigned long   dram_loc;
2306   unsigned char   mode[2], ramp_mode[2];
2307 
2308   if (!pcm_qlen)
2309     return;
2310 
2311   this_one = pcm_head;
2312 
2313   for (chn = 0; chn < gus_sampling_channels; chn++)
2314     {
2315       mode[chn] = 0x00;
2316       ramp_mode[chn] = 0x03;    /* 
2317                                  * Ramping and rollover off 
2318                                  */
2319 
2320       if (chn == 0)
2321         {
2322           mode[chn] |= 0x20;    /* 
2323                                  * Loop irq 
2324                                  */
2325           voices[chn].loop_irq_mode = LMODE_PCM;
2326         }
2327 
2328       if (gus_sampling_bits != 8)
2329         {
2330           is16bits = 1;
2331           mode[chn] |= 0x04;    /* 
2332                                  * 16 bit data 
2333                                  */
2334         }
2335       else
2336         is16bits = 0;
2337 
2338       dram_loc = this_one * pcm_bsize;
2339       dram_loc += chn * pcm_banksize;
2340 
2341       if (this_one == (pcm_nblk - 1))   /* 
2342                                          * Last of the DRAM buffers 
2343                                          */
2344         {
2345           mode[chn] |= 0x08;    /* 
2346                                  * Enable loop 
2347                                  */
2348           ramp_mode[chn] = 0x03;        /* 
2349                                          * Disable rollover 
2350                                          */
2351         }
2352       else
2353         {
2354           if (chn == 0)
2355             ramp_mode[chn] = 0x04;      /* 
2356                                          * Enable rollover bit 
2357                                          */
2358         }
2359 
2360       DISABLE_INTR (flags);
2361       gus_select_voice (chn);
2362       gus_voice_freq (speed);
2363 
2364       if (gus_sampling_channels == 1)
2365         gus_voice_balance (7);  /* 
2366                                  * mono 
2367                                  */
2368       else if (chn == 0)
2369         gus_voice_balance (0);  /* 
2370                                  * left 
2371                                  */
2372       else
2373         gus_voice_balance (15); /* 
2374                                  * right 
2375                                  */
2376 
2377       if (!pcm_active)          /* 
2378                                  * Voice not started yet 
2379                                  */
2380         {
2381           /* 
2382            * The playback was not started yet (or there has been a pause).
2383            * Start the voice (again) and ask for a rollover irq at the end of
2384            * this_one block. If this_one one is last of the buffers, use just
2385            * the normal loop with irq.
2386            */
2387 
2388           gus_voice_off ();     /* 
2389                                  * It could already be running 
2390                                  */
2391           gus_rampoff ();
2392           gus_voice_volume (1530 + (25 * gus_pcm_volume));
2393           gus_ramp_range (65, 1530 + (25 * gus_pcm_volume));
2394 
2395           gus_write_addr (0x0a, dram_loc, is16bits);    /* 
2396                                                          * Starting position 
2397                                                          */
2398           gus_write_addr (0x02, chn * pcm_banksize, is16bits);  /* 
2399                                                                  * Loop start 
2400                                                                  * location 
2401                                                                  */
2402 
2403           if (chn != 0)
2404             gus_write_addr (0x04, pcm_banksize + (pcm_bsize * pcm_nblk),
2405                             is16bits);  /* 
2406                                          * Loop end location 
2407                                          */
2408         }
2409 
2410       if (chn == 0)
2411         gus_write_addr (0x04, dram_loc + pcm_datasize[this_one], is16bits);     /* 
2412                                                                                  * Loop 
2413                                                                                  * end 
2414                                                                                  * location 
2415                                                                                  */
2416       else
2417         mode[chn] |= 0x08;      /* 
2418                                  * Enable loop 
2419                                  */
2420 
2421       if (pcm_datasize[this_one] != pcm_bsize)
2422         {
2423           /* 
2424            * Incomplete block. Possibly the last one. 
2425            */
2426           if (chn == 0)
2427             {
2428               mode[chn] &= ~0x08;       /* 
2429                                          * Disable loop 
2430                                          */
2431               mode[chn] |= 0x20;        /* 
2432                                          * Enable loop IRQ 
2433                                          */
2434               voices[0].loop_irq_mode = LMODE_PCM_STOP;
2435               ramp_mode[chn] = 0x03;    /* 
2436                                          * No rollover bit 
2437                                          */
2438             }
2439           else
2440             {
2441               gus_write_addr (0x04, dram_loc + pcm_datasize[this_one], is16bits);       /* 
2442                                                                                          * Loop 
2443                                                                                          * end 
2444                                                                                          * location 
2445                                                                                          */
2446               mode[chn] &= ~0x08;       /* 
2447                                          * Disable loop 
2448                                          */
2449             }
2450         }
2451 
2452       RESTORE_INTR (flags);
2453     }
2454 
2455   for (chn = 0; chn < gus_sampling_channels; chn++)
2456     {
2457       DISABLE_INTR (flags);
2458       gus_select_voice (chn);
2459       gus_write8 (0x0d, ramp_mode[chn]);
2460       gus_voice_on (mode[chn]);
2461       RESTORE_INTR (flags);
2462     }
2463 
2464   pcm_active = 1;
2465 }
2466 
2467 static void
2468 gus_transfer_output_block (int dev, unsigned long buf,
     /*  */
2469                            int total_count, int intrflag, int chn)
2470 {
2471   /* 
2472    * This routine transfers one block of audio data to the DRAM. In mono mode
2473    * it's called just once. When in stereo mode, this_one routine is called
2474    * once for both channels.
2475    * 
2476    * The left/mono channel data is transferred to the beginning of dram and the
2477    * right data to the area pointed by gus_page_size.
2478    */
2479 
2480   int             this_one, count;
2481   unsigned long   flags;
2482   unsigned char   dma_command;
2483   unsigned long   address, hold_address;
2484 
2485   DISABLE_INTR (flags);
2486 
2487   count = total_count / gus_sampling_channels;
2488 
2489   if (chn == 0)
2490     {
2491       if (pcm_qlen >= pcm_nblk)
2492         printk ("GUS Warning: PCM buffers out of sync\n");
2493 
2494       this_one = pcm_current_block = pcm_tail;
2495       pcm_qlen++;
2496       pcm_tail = (pcm_tail + 1) % pcm_nblk;
2497       pcm_datasize[this_one] = count;
2498     }
2499   else
2500     this_one = pcm_current_block;
2501 
2502   gus_write8 (0x41, 0);         /* 
2503                                  * Disable GF1 DMA 
2504                                  */
2505   DMAbuf_start_dma (dev, buf + (chn * count), count, DMA_MODE_WRITE);
2506 
2507   address = this_one * pcm_bsize;
2508   address += chn * pcm_banksize;
2509 
2510   if (sound_dsp_dmachan[dev] > 3)
2511     {
2512       hold_address = address;
2513       address = address >> 1;
2514       address &= 0x0001ffffL;
2515       address |= (hold_address & 0x000c0000L);
2516     }
2517 
2518   gus_write16 (0x42, (address >> 4) & 0xffff);  /* 
2519                                                  * DRAM DMA address 
2520                                                  */
2521 
2522   dma_command = 0x21;           /* 
2523                                  * IRQ enable, DMA start 
2524                                  */
2525 
2526   if (gus_sampling_bits != 8)
2527     dma_command |= 0x40;        /* 
2528                                  * 16 bit _DATA_ 
2529                                  */
2530   else
2531     dma_command |= 0x80;        /* 
2532                                  * Invert MSB 
2533                                  */
2534 
2535   if (sound_dsp_dmachan[dev] > 3)
2536     dma_command |= 0x04;        /* 
2537                                  * 16 bit DMA channel 
2538                                  */
2539 
2540   gus_write8 (0x41, dma_command);       /* 
2541                                          * Kick on 
2542                                          */
2543 
2544   if (chn == (gus_sampling_channels - 1))       /* 
2545                                                  * Last channel 
2546                                                  */
2547     {
2548       /* 
2549        * Last (right or mono) channel data 
2550        */
2551       active_device = GUS_DEV_PCM_DONE;
2552       if (!pcm_active && (pcm_qlen > 2 || count < pcm_bsize))
2553         {
2554           play_next_pcm_block ();
2555         }
2556     }
2557   else                          /* 
2558                                  * * * Left channel data. The right channel
2559                                  * is * * * transferred after DMA interrupt   */
2560     active_device = GUS_DEV_PCM_CONTINUE;
2561 
2562   RESTORE_INTR (flags);
2563 }
2564 
2565 static void
2566 gus_sampling_output_block (int dev, unsigned long buf, int total_count,
     /*  */
2567                            int intrflag, int restart_dma)
2568 {
2569   pcm_current_buf = buf;
2570   pcm_current_count = total_count;
2571   pcm_current_intrflag = intrflag;
2572   pcm_current_dev = dev;
2573   gus_transfer_output_block (dev, buf, total_count, intrflag, 0);
2574 }
2575 
2576 static void
2577 gus_sampling_start_input (int dev, unsigned long buf, int count,
     /*  */
2578                           int intrflag, int restart_dma)
2579 {
2580   unsigned long   flags;
2581   unsigned char   mode;
2582 
2583   DISABLE_INTR (flags);
2584 
2585   DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ);
2586 
2587   mode = 0xa0;                  /* 
2588                                  * DMA IRQ enable, invert MSB 
2589                                  */
2590 
2591   if (sound_dsp_dmachan[dev] > 3)
2592     mode |= 0x04;               /* 
2593                                  * 16 bit DMA channel 
2594                                  */
2595   if (gus_sampling_channels > 1)
2596     mode |= 0x02;               /* 
2597                                  * Stereo 
2598                                  */
2599   mode |= 0x01;                 /* 
2600                                  * DMA enable 
2601                                  */
2602 
2603   gus_write8 (0x49, mode);
2604 
2605   RESTORE_INTR (flags);
2606 }
2607 
2608 static int
2609 gus_sampling_prepare_for_input (int dev, int bsize, int bcount)
     /*  */
2610 {
2611   unsigned int    rate;
2612 
2613   rate = (9878400 / (gus_sampling_speed + 2)) / 16;
2614 
2615   gus_write8 (0x48, rate & 0xff);       /* 
2616                                          * Set sampling frequency 
2617                                          */
2618 
2619   if (gus_sampling_bits != 8)
2620     {
2621       printk ("GUS Error: 16 bit recording not supported\n");
2622       return RET_ERROR (EINVAL);
2623     }
2624 
2625   return 0;
2626 }
2627 
2628 static int
2629 gus_sampling_prepare_for_output (int dev, int bsize, int bcount)
     /*  */
2630 {
2631   int             i;
2632 
2633   long            mem_ptr, mem_size;
2634 
2635   mem_ptr = 0;
2636   mem_size = gus_mem_size / gus_sampling_channels;
2637 
2638   if (mem_size > (256 * 1024))
2639     mem_size = 256 * 1024;
2640 
2641   pcm_bsize = bsize / gus_sampling_channels;
2642   pcm_head = pcm_tail = pcm_qlen = 0;
2643 
2644   pcm_nblk = MAX_PCM_BUFFERS;
2645   if ((pcm_bsize * pcm_nblk) > mem_size)
2646     pcm_nblk = mem_size / pcm_bsize;
2647 
2648   for (i = 0; i < pcm_nblk; i++)
2649     pcm_datasize[i] = 0;
2650 
2651   pcm_banksize = pcm_nblk * pcm_bsize;
2652 
2653   if (gus_sampling_bits != 8 && pcm_banksize == (256 * 1024))
2654     pcm_nblk--;
2655 
2656   return 0;
2657 }
2658 
2659 static int
2660 gus_has_output_drained (int dev)
     /*  */
2661 {
2662   return !pcm_qlen;
2663 }
2664 
2665 static void
2666 gus_copy_from_user (int dev, char *localbuf, int localoffs,
     /*  */
2667                     snd_rw_buf * userbuf, int useroffs, int len)
2668 {
2669   if (gus_sampling_channels == 1)
2670     {
2671       COPY_FROM_USER (&localbuf[localoffs], userbuf, useroffs, len);
2672     }
2673   else if (gus_sampling_bits == 8)
2674     {
2675       int             in_left = useroffs;
2676       int             in_right = useroffs + 1;
2677       char           *out_left, *out_right;
2678       int             i;
2679 
2680       len /= 2;
2681       localoffs /= 2;
2682       out_left = &localbuf[localoffs];
2683       out_right = out_left + pcm_bsize;
2684 
2685       for (i = 0; i < len; i++)
2686         {
2687           GET_BYTE_FROM_USER (*out_left++, userbuf, in_left);
2688           in_left += 2;
2689           GET_BYTE_FROM_USER (*out_right++, userbuf, in_right);
2690           in_right += 2;
2691         }
2692     }
2693   else
2694     {
2695       int             in_left = useroffs;
2696       int             in_right = useroffs + 1;
2697       short          *out_left, *out_right;
2698       int             i;
2699 
2700       len /= 4;
2701       localoffs /= 4;
2702 
2703       out_left = (short *) &localbuf[localoffs];
2704       out_right = out_left + (pcm_bsize / 2);
2705 
2706       for (i = 0; i < len; i++)
2707         {
2708           GET_SHORT_FROM_USER (*out_left++, (short *) userbuf, in_left);
2709           in_left += 2;
2710           GET_SHORT_FROM_USER (*out_right++, (short *) userbuf, in_right);
2711           in_right += 2;
2712         }
2713     }
2714 }
2715 
2716 static struct audio_operations gus_sampling_operations =
2717 {
2718   "Gravis UltraSound",
2719   gus_sampling_open,
2720   gus_sampling_close,
2721   gus_sampling_output_block,
2722   gus_sampling_start_input,
2723   gus_sampling_ioctl,
2724   gus_sampling_prepare_for_input,
2725   gus_sampling_prepare_for_output,
2726   gus_sampling_reset,
2727   gus_sampling_reset,
2728   gus_has_output_drained,
2729   gus_copy_from_user
2730 };
2731 
2732 #ifdef FUTURE_VERSION
2733 static void
2734 guswave_bender (int dev, int voice, int value)
     /*  */
2735 {
2736   int             freq;
2737   unsigned long   flags;
2738 
2739   voices[voice].bender = value - 8192;
2740   freq = compute_finetune (voices[voice].orig_freq, value, voices[voice].bender_range);
2741   voices[voice].current_freq = freq;
2742 
2743   DISABLE_INTR (flags);
2744   gus_select_voice (voice);
2745   gus_voice_freq (freq);
2746   RESTORE_INTR (flags);
2747 }
2748 #endif
2749 
2750 static int
2751 guswave_patchmgr (int dev, struct patmgr_info *rec)
     /*  */
2752 {
2753   int             i, n;
2754 
2755   switch (rec->command)
2756     {
2757     case PM_GET_DEVTYPE:
2758       rec->parm1 = PMTYPE_WAVE;
2759       return 0;
2760       break;
2761 
2762     case PM_GET_NRPGM:
2763       rec->parm1 = MAX_PATCH;
2764       return 0;
2765       break;
2766 
2767     case PM_GET_PGMMAP:
2768       rec->parm1 = MAX_PATCH;
2769 
2770       for (i = 0; i < MAX_PATCH; i++)
2771         {
2772           int             ptr = patch_table[i];
2773 
2774           rec->data.data8[i] = 0;
2775 
2776           while (ptr >= 0 && ptr < free_sample)
2777             {
2778               rec->data.data8[i]++;
2779               ptr = samples[ptr].key;   /* 
2780                                          * Follow link 
2781                                          */
2782             }
2783         }
2784       return 0;
2785       break;
2786 
2787     case PM_GET_PGM_PATCHES:
2788       {
2789         int             ptr = patch_table[rec->parm1];
2790 
2791         n = 0;
2792 
2793         while (ptr >= 0 && ptr < free_sample)
2794           {
2795             rec->data.data32[n++] = ptr;
2796             ptr = samples[ptr].key;     /* 
2797                                          * Follow link 
2798                                          */
2799           }
2800       }
2801       rec->parm1 = n;
2802       return 0;
2803       break;
2804 
2805     case PM_GET_PATCH:
2806       {
2807         int             ptr = rec->parm1;
2808         struct patch_info *pat;
2809 
2810         if (ptr < 0 || ptr >= free_sample)
2811           return RET_ERROR (EINVAL);
2812 
2813         memcpy (rec->data.data8, (char *) &samples[ptr],
2814                 sizeof (struct patch_info));
2815 
2816         pat = (struct patch_info *) rec->data.data8;
2817 
2818         pat->key = GUS_PATCH;   /* 
2819                                  * Restore patch type 
2820                                  */
2821         rec->parm1 = sample_ptrs[ptr];  /* 
2822                                          * DRAM address 
2823                                          */
2824         rec->parm2 = sizeof (struct patch_info);
2825       }
2826       return 0;
2827       break;
2828 
2829     case PM_SET_PATCH:
2830       {
2831         int             ptr = rec->parm1;
2832         struct patch_info *pat;
2833 
2834         if (ptr < 0 || ptr >= free_sample)
2835           return RET_ERROR (EINVAL);
2836 
2837         pat = (struct patch_info *) rec->data.data8;
2838 
2839         if (pat->len > samples[ptr].len)        /* 
2840                                                  * Cannot expand sample 
2841                                                  */
2842           return RET_ERROR (EINVAL);
2843 
2844         pat->key = samples[ptr].key;    /* 
2845                                          * Ensure the link is correct 
2846                                          */
2847 
2848         memcpy ((char *) &samples[ptr], rec->data.data8,
2849                 sizeof (struct patch_info));
2850 
2851         pat->key = GUS_PATCH;
2852       }
2853       return 0;
2854       break;
2855 
2856     case PM_READ_PATCH: /* 
2857                                  * Returns a block of wave data from the DRAM 
2858                                  */
2859       {
2860         int             sample = rec->parm1;
2861         int             n;
2862         long            offs = rec->parm2;
2863         int             l = rec->parm3;
2864 
2865         if (sample < 0 || sample >= free_sample)
2866           return RET_ERROR (EINVAL);
2867 
2868         if (offs < 0 || offs >= samples[sample].len)
2869           return RET_ERROR (EINVAL);    /* 
2870                                          * Invalid offset 
2871                                          */
2872 
2873         n = samples[sample].len - offs;         /* 
2874                                                  * Nr of bytes left 
2875                                                  */
2876 
2877         if (l > n)
2878           l = n;
2879 
2880         if (l > sizeof (rec->data.data8))
2881           l = sizeof (rec->data.data8);
2882 
2883         if (l <= 0)
2884           return RET_ERROR (EINVAL);    /* 
2885                                          * Was there a bug? 
2886                                          */
2887 
2888         offs += sample_ptrs[sample];    /* 
2889                                          * Begin offsess + offset to DRAM 
2890                                          */
2891 
2892         for (n = 0; n < l; n++)
2893           rec->data.data8[n] = gus_peek (offs++);
2894         rec->parm1 = n;         /* 
2895                                  * Nr of bytes copied 
2896                                  */
2897       }
2898       return 0;
2899       break;
2900 
2901     case PM_WRITE_PATCH:        /* 
2902                                  * Writes a block of wave data to the DRAM 
2903                                  */
2904       {
2905         int             sample = rec->parm1;
2906         int             n;
2907         long            offs = rec->parm2;
2908         int             l = rec->parm3;
2909 
2910         if (sample < 0 || sample >= free_sample)
2911           return RET_ERROR (EINVAL);
2912 
2913         if (offs < 0 || offs >= samples[sample].len)
2914           return RET_ERROR (EINVAL);    /* 
2915                                          * Invalid offset 
2916                                          */
2917 
2918         n = samples[sample].len - offs;         /* 
2919                                                  * Nr of bytes left 
2920                                                  */
2921 
2922         if (l > n)
2923           l = n;
2924 
2925         if (l > sizeof (rec->data.data8))
2926           l = sizeof (rec->data.data8);
2927 
2928         if (l <= 0)
2929           return RET_ERROR (EINVAL);    /* 
2930                                          * Was there a bug? 
2931                                          */
2932 
2933         offs += sample_ptrs[sample];    /* 
2934                                          * Begin offsess + offset to DRAM 
2935                                          */
2936 
2937         for (n = 0; n < l; n++)
2938           gus_poke (offs++, rec->data.data8[n]);
2939         rec->parm1 = n;         /* 
2940                                  * Nr of bytes copied 
2941                                  */
2942       }
2943       return 0;
2944       break;
2945 
2946     default:
2947       return RET_ERROR (EINVAL);
2948     }
2949 }
2950 
2951 static struct synth_operations guswave_operations =
2952 {
2953   &gus_info,
2954 #ifdef FUTURE_VERSION
2955   0,
2956 #endif
2957   SYNTH_TYPE_SAMPLE,
2958   SAMPLE_TYPE_GUS,
2959   guswave_open,
2960   guswave_close,
2961   guswave_ioctl,
2962   guswave_kill_note,
2963   guswave_start_note,
2964   guswave_set_instr,
2965   guswave_reset,
2966   guswave_hw_control,
2967   guswave_load_patch,
2968   guswave_aftertouch,
2969   guswave_controller,
2970   guswave_panning,
2971   guswave_patchmgr,
2972 #ifdef FUTURE_VERSION
2973   guswave_bender
2974 #endif
2975 };
2976 
2977 static void
2978 set_input_volumes(void)
     /*  */
2979 {
2980         unsigned long flags;
2981         unsigned char mask = 0xff & ~0x06;      /* Just line out enabled */
2982 
2983         DISABLE_INTR(flags);
2984 
2985 /*
2986  *      Enable channels having vol > 10%
2987  *      Note! bit 0x01 means line in DISABLED while 0x04 means
2988  *            mic in ENABLED.
2989  */
2990         if (gus_line_vol > 10) mask &= ~0x01;
2991         if (gus_mic_vol > 10) mask |= 0x04;
2992 
2993         if (recording_active)
2994           {
2995 /*
2996  *      Disable channel, if not selected for recording
2997  */
2998                 if (!(gus_recmask & SOUND_MASK_LINE)) mask |= 0x01;
2999                 if (!(gus_recmask & SOUND_MASK_MIC)) mask &= ~0x04;
3000           }
3001 
3002         mix_image &= ~0x07;
3003         mix_image |= mask & 0x07;
3004         OUTB (mix_image, u_Mixer);
3005 
3006         RESTORE_INTR(flags);
3007 }
3008 
3009 static int
3010 gus_mixer_ioctl (int dev, unsigned int cmd, unsigned int arg)
     /*  */
3011 {
3012 #define MIX_DEVS        (SOUND_MASK_MIC|SOUND_MASK_LINE| \
3013                          SOUND_MASK_SYNTH|SOUND_MASK_PCM)
3014   if (((cmd >> 8) & 0xff) == 'M')
3015     {
3016       if (cmd & IOC_IN)
3017         switch (cmd & 0xff)
3018           {
3019           case SOUND_MIXER_RECSRC:
3020             gus_recmask = IOCTL_IN(arg) & MIX_DEVS;
3021             if (!(gus_recmask & (SOUND_MASK_MIC|SOUND_MASK_LINE)))
3022                gus_recmask = SOUND_MASK_MIC;
3023             /* Note! Input volumes are updated during next open for recording */
3024             return IOCTL_OUT (arg, gus_recmask);
3025             break;
3026 
3027           case SOUND_MIXER_MIC:
3028             {
3029               int             vol = IOCTL_IN (arg) & 0xff;
3030               if (vol < 0) vol = 0;
3031               if (vol > 100) vol = 100;
3032               gus_mic_vol = vol;
3033               set_input_volumes();
3034               return IOCTL_OUT (arg, vol | (vol << 8));
3035             }
3036             break;
3037 
3038           case SOUND_MIXER_LINE:
3039             {
3040               int             vol = IOCTL_IN (arg) & 0xff;
3041               if (vol < 0) vol = 0;
3042               if (vol > 100) vol = 100;
3043               gus_line_vol = vol;
3044               set_input_volumes();
3045               return IOCTL_OUT (arg, vol | (vol << 8));
3046             }
3047             break;
3048 
3049           case SOUND_MIXER_PCM:
3050               gus_pcm_volume = IOCTL_IN (arg) & 0xff;
3051               if (gus_pcm_volume < 0)
3052                 gus_pcm_volume = 0;
3053               if (gus_pcm_volume > 100)
3054                 gus_pcm_volume = 100;
3055               gus_sampling_update_volume ();
3056               return IOCTL_OUT (arg, gus_pcm_volume | (gus_pcm_volume << 8));
3057             break;
3058 
3059           case SOUND_MIXER_SYNTH:
3060             {
3061               int             voice; 
3062 
3063               gus_wave_volume = IOCTL_IN (arg) & 0xff;
3064 
3065               if (gus_wave_volume < 0)
3066                 gus_wave_volume = 0;
3067               if (gus_wave_volume > 100)
3068                 gus_wave_volume = 100;
3069 
3070               if (active_device == GUS_DEV_WAVE)
3071                 for (voice = 0; voice < nr_voices; voice++)
3072                   dynamic_volume_change (voice);        /* 
3073                                                          * Apply the new
3074                                                          * volume 
3075                                                          */
3076 
3077               return IOCTL_OUT (arg, gus_wave_volume | (gus_wave_volume << 8));
3078             }
3079             break;
3080 
3081           default:
3082             return RET_ERROR (EINVAL);
3083           }
3084       else
3085         switch (cmd & 0xff)     /* 
3086                                  * Return parameters 
3087                                  */
3088           {
3089 
3090           case SOUND_MIXER_RECSRC:
3091             return IOCTL_OUT (arg, gus_recmask);
3092             break;
3093 
3094           case SOUND_MIXER_DEVMASK:
3095             return IOCTL_OUT (arg, MIX_DEVS);
3096             break;
3097 
3098           case SOUND_MIXER_STEREODEVS:
3099             return IOCTL_OUT (arg, 0);
3100             break;
3101 
3102           case SOUND_MIXER_RECMASK:
3103             return IOCTL_OUT (arg, SOUND_MASK_MIC|SOUND_MASK_LINE);
3104             break;
3105 
3106           case SOUND_MIXER_CAPS:
3107             return IOCTL_OUT (arg, 0);
3108             break;
3109 
3110           case SOUND_MIXER_MIC:
3111             return IOCTL_OUT (arg, gus_mic_vol | (gus_mic_vol << 8));
3112             break;
3113 
3114           case SOUND_MIXER_LINE:
3115             return IOCTL_OUT (arg, gus_line_vol | (gus_line_vol << 8));
3116             break;
3117 
3118           case SOUND_MIXER_PCM:
3119             return IOCTL_OUT (arg, gus_pcm_volume | (gus_pcm_volume << 8));
3120             break;
3121 
3122           case SOUND_MIXER_SYNTH:
3123             return IOCTL_OUT (arg, gus_wave_volume | (gus_wave_volume << 8));
3124             break;
3125 
3126           default:
3127             return RET_ERROR (EINVAL);
3128           }
3129     }
3130   else
3131     return RET_ERROR (EINVAL);
3132 }
3133 
3134 static struct mixer_operations gus_mixer_operations =
3135 {
3136   gus_mixer_ioctl
3137 };
3138 
3139 long
3140 gus_wave_init (long mem_start, int irq, int dma)
     /*  */
3141 {
3142   printk (" <Gravis UltraSound %dk>", (int) gus_mem_size / 1024);
3143 
3144   if (irq < 0 || irq > 15)
3145     {
3146       printk ("ERROR! Invalid IRQ#%d. GUS Disabled", irq);
3147       return mem_start;
3148     }
3149 
3150   if (dma < 0 || dma > 7)
3151     {
3152       printk ("ERROR! Invalid DMA#%d. GUS Disabled", dma);
3153       return mem_start;
3154     }
3155 
3156   gus_irq = irq;
3157   gus_dma = dma;
3158 
3159   if (num_synths >= MAX_SYNTH_DEV)
3160     printk ("GUS Error: Too many synthesizers\n");
3161   else
3162     synth_devs[num_synths++] = &guswave_operations;
3163 
3164   PERMANENT_MALLOC (struct patch_info *, samples,
3165                            (MAX_SAMPLE + 1) * sizeof (*samples), mem_start);
3166 
3167   reset_sample_memory ();
3168 
3169   gus_initialize ();
3170 
3171   if (num_dspdevs < MAX_DSP_DEV)
3172     {
3173       dsp_devs[gus_devnum = num_dspdevs++] = &gus_sampling_operations;
3174       sound_dsp_dmachan[gus_devnum] = dma;
3175       sound_buffcounts[gus_devnum] = 1;
3176       sound_buffsizes[gus_devnum] = DSP_BUFFSIZE;
3177       sound_dma_automode[gus_devnum] = 0;
3178     }
3179   else
3180     printk ("GUS: Too many PCM devices available\n");
3181 
3182   if (num_mixers < MAX_MIXER_DEV)       /* 
3183                                          * Don't install if there is another
3184                                          * mixer 
3185                                          */
3186     mixer_devs[num_mixers++] = &gus_mixer_operations;
3187 
3188   return mem_start;
3189 }
3190 
3191 static void
3192 do_loop_irq (int voice)
     /*  */
3193 {
3194   unsigned char   tmp;
3195   int             mode, parm;
3196   unsigned long   flags;
3197 
3198   DISABLE_INTR (flags);
3199   gus_select_voice (voice);
3200 
3201   tmp = gus_read8 (0x00);
3202   tmp &= ~0x20;                 /* 
3203                                  * Disable wave IRQ for this_one voice 
3204                                  */
3205   gus_write8 (0x00, tmp);
3206 
3207   mode = voices[voice].loop_irq_mode;
3208   voices[voice].loop_irq_mode = 0;
3209   parm = voices[voice].loop_irq_parm;
3210 
3211   switch (mode)
3212     {
3213 
3214     case LMODE_FINISH:          /* 
3215                                  * Final loop finished, shoot volume down 
3216                                  */
3217 
3218       if ((gus_read16 (0x09) >> 4) < 100)       /* 
3219                                                  * Get current volume 
3220                                                  */
3221         {
3222           gus_voice_off ();
3223           gus_rampoff ();
3224           gus_voice_init (voice);
3225           break;
3226         }
3227       gus_ramp_range (65, 4065);
3228       gus_ramp_rate (0, 63);    /* 
3229                                  * Fastest possible rate 
3230                                  */
3231       gus_rampon (0x20 | 0x40); /* 
3232                                  * Ramp down, once, irq 
3233                                  */
3234       voices[voice].volume_irq_mode = VMODE_HALT;
3235       break;
3236 
3237     case LMODE_PCM_STOP:
3238       pcm_active = 0;           /* 
3239                                  * Requires extensive processing 
3240                                  */
3241     case LMODE_PCM:
3242       {
3243         int             orig_qlen = pcm_qlen;
3244 
3245         pcm_qlen--;
3246         pcm_head = (pcm_head + 1) % pcm_nblk;
3247         if (pcm_qlen)
3248           {
3249             play_next_pcm_block ();
3250           }
3251         else
3252           {                     /* 
3253                                  * Out of data. Just stop the voice 
3254                                  */
3255             gus_voice_off ();
3256             gus_rampoff ();
3257             pcm_active = 0;
3258           }
3259 
3260         if (orig_qlen == pcm_nblk)
3261           {
3262             DMAbuf_outputintr (gus_devnum, 0);
3263           }
3264       }
3265       break;
3266 
3267     default:;
3268     }
3269   RESTORE_INTR (flags);
3270 }
3271 
3272 static void
3273 do_volume_irq (int voice)
     /*  */
3274 {
3275   unsigned char   tmp;
3276   int             mode, parm;
3277   unsigned long   flags;
3278 
3279   DISABLE_INTR (flags);
3280 
3281   gus_select_voice (voice);
3282 
3283   tmp = gus_read8 (0x0d);
3284   tmp &= ~0x20;                 /* 
3285                                  * Disable volume ramp IRQ 
3286                                  */
3287   gus_write8 (0x0d, tmp);
3288 
3289   mode = voices[voice].volume_irq_mode;
3290   voices[voice].volume_irq_mode = 0;
3291   parm = voices[voice].volume_irq_parm;
3292 
3293   switch (mode)
3294     {
3295     case VMODE_HALT:            /* 
3296                                  * Decay phase finished 
3297                                  */
3298       gus_voice_init (voice);
3299       break;
3300 
3301     case VMODE_ENVELOPE:
3302       gus_rampoff ();
3303       step_envelope (voice);
3304       break;
3305 
3306     case VMODE_START_NOTE:
3307       guswave_start_note2 (voices[voice].dev_pending, voice,
3308                   voices[voice].note_pending, voices[voice].volume_pending);
3309       if (voices[voice].kill_pending)
3310         guswave_kill_note (voices[voice].dev_pending, voice, 0);
3311       if (voices[voice].sample_pending >= 0)
3312         {
3313           guswave_set_instr (voices[voice].dev_pending, voice,
3314             voices[voice].sample_pending);
3315           voices[voice].sample_pending = -1;
3316         }
3317       break;
3318 
3319     default:;
3320     }
3321 
3322   RESTORE_INTR (flags);
3323 }
3324 
3325 void
3326 gus_voice_irq (void)
     /*  */
3327 {
3328   unsigned long   wave_ignore = 0, volume_ignore = 0;
3329   unsigned long   voice_bit;
3330 
3331   unsigned char   src, voice;
3332 
3333   while (1)
3334     {
3335       src = gus_read8 (0x0f);   /* 
3336                                  * Get source info 
3337                                  */
3338       voice = src & 0x1f;
3339       src &= 0xc0;
3340 
3341       if (src == (0x80 | 0x40))
3342         return;                 /* 
3343                                  * No interrupt 
3344                                  */
3345 
3346       voice_bit = 1 << voice;
3347 
3348       if (!(src & 0x80))        /* 
3349                                  * Wave IRQ pending 
3350                                  */
3351         if (!(wave_ignore & voice_bit) && voice < nr_voices)    /* 
3352                                                                  * Not done
3353                                                                  * yet 
3354                                                                  */
3355           {
3356             wave_ignore |= voice_bit;
3357             do_loop_irq (voice);
3358           }
3359 
3360       if (!(src & 0x40))        /* 
3361                                  * Volume IRQ pending 
3362                                  */
3363         if (!(volume_ignore & voice_bit) && voice < nr_voices)  /* 
3364                                                                  * Not done
3365                                                                  * yet 
3366                                                                  */
3367           {
3368             volume_ignore |= voice_bit;
3369             do_volume_irq (voice);
3370           }
3371     }
3372 }
3373 
3374 void
3375 guswave_dma_irq (void)
     /*  */
3376 {
3377   unsigned char   status;
3378 
3379   status = gus_look8 (0x41);    /* 
3380                                  * Get DMA IRQ Status 
3381                                  */
3382   if (status & 0x40)            /* 
3383                                  * DMA Irq pending 
3384                                  */
3385     switch (active_device)
3386       {
3387       case GUS_DEV_WAVE:
3388         if (SOMEONE_WAITING (dram_sleeper, dram_sleep_flag))
3389           WAKE_UP (dram_sleeper, dram_sleep_flag);
3390         break;
3391 
3392       case GUS_DEV_PCM_CONTINUE:
3393         gus_transfer_output_block (pcm_current_dev, pcm_current_buf,
3394                                    pcm_current_count,
3395                                    pcm_current_intrflag, 1);
3396         break;
3397 
3398       case GUS_DEV_PCM_DONE:
3399         if (pcm_qlen < pcm_nblk)
3400           {
3401             DMAbuf_outputintr (gus_devnum, pcm_qlen == 0);
3402           }
3403         break;
3404 
3405       default:;
3406       }
3407 
3408   status = gus_look8 (0x49);    /* 
3409                                  * Get Sampling IRQ Status 
3410                                  */
3411   if (status & 0x40)            /* 
3412                                  * Sampling Irq pending 
3413                                  */
3414     {
3415       DMAbuf_inputintr (gus_devnum);
3416     }
3417 
3418 }
3419 
3420 #endif
/* */
root/drivers/sound/gus_wave.c

DEFINITIONS
