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