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

DEFINITIONS
