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