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