sound/oss/gus_wave.c

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