| /* |
| * sound/gus_wave.c |
| * |
| * Driver for the Gravis UltraSound wave table synth. |
| * |
| * |
| * Copyright (C) by Hannu Savolainen 1993-1997 |
| * |
| * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL) |
| * Version 2 (June 1991). See the "COPYING" file distributed with this software |
| * for more info. |
| * |
| * |
| * Thomas Sailer : ioctl code reworked (vmalloc/vfree removed) |
| * Frank van de Pol : Fixed GUS MAX interrupt handling. Enabled simultanious |
| * usage of CS4231A codec, GUS wave and MIDI for GUS MAX. |
| * Bartlomiej Zolnierkiewicz : added some __init/__exit |
| */ |
| |
| #include <linux/init.h> |
| #include <linux/config.h> |
| #include <linux/spinlock.h> |
| |
| #define GUSPNP_AUTODETECT |
| |
| #include "sound_config.h" |
| #include <linux/ultrasound.h> |
| |
| #include "gus.h" |
| #include "gus_hw.h" |
| |
| #define GUS_BANK_SIZE (((iw_mode) ? 256*1024*1024 : 256*1024)) |
| |
| #define MAX_SAMPLE 150 |
| #define MAX_PATCH 256 |
| |
| #define NOT_SAMPLE 0xffff |
| |
| struct voice_info |
| { |
| unsigned long orig_freq; |
| unsigned long current_freq; |
| unsigned long mode; |
| int fixed_pitch; |
| int bender; |
| int bender_range; |
| int panning; |
| int midi_volume; |
| unsigned int initial_volume; |
| unsigned int current_volume; |
| int loop_irq_mode, loop_irq_parm; |
| #define LMODE_FINISH 1 |
| #define LMODE_PCM 2 |
| #define LMODE_PCM_STOP 3 |
| int volume_irq_mode, volume_irq_parm; |
| #define VMODE_HALT 1 |
| #define VMODE_ENVELOPE 2 |
| #define VMODE_START_NOTE 3 |
| |
| int env_phase; |
| unsigned char env_rate[6]; |
| unsigned char env_offset[6]; |
| |
| /* |
| * Volume computation parameters for gus_adagio_vol() |
| */ |
| int main_vol, expression_vol, patch_vol; |
| |
| /* Variables for "Ultraclick" removal */ |
| int dev_pending, note_pending, volume_pending, |
| sample_pending; |
| char kill_pending; |
| long offset_pending; |
| |
| }; |
| |
| static struct voice_alloc_info *voice_alloc; |
| static struct address_info *gus_hw_config; |
| extern int gus_base; |
| extern int gus_irq, gus_dma; |
| extern int gus_pnp_flag; |
| extern int gus_no_wave_dma; |
| static int gus_dma2 = -1; |
| static int dual_dma_mode; |
| static long gus_mem_size; |
| static long free_mem_ptr; |
| static int gus_busy; |
| static int gus_no_dma; |
| static int nr_voices; |
| static int gus_devnum; |
| static int volume_base, volume_scale, volume_method; |
| static int gus_recmask = SOUND_MASK_MIC; |
| static int recording_active; |
| static int only_read_access; |
| static int only_8_bits; |
| |
| static int iw_mode = 0; |
| int gus_wave_volume = 60; |
| int gus_pcm_volume = 80; |
| int have_gus_max = 0; |
| static int gus_line_vol = 100, gus_mic_vol; |
| static unsigned char mix_image = 0x00; |
| |
| int gus_timer_enabled = 0; |
| |
| /* |
| * Current version of this driver doesn't allow synth and PCM functions |
| * at the same time. The active_device specifies the active driver |
| */ |
| |
| static int active_device; |
| |
| #define GUS_DEV_WAVE 1 /* Wave table synth */ |
| #define GUS_DEV_PCM_DONE 2 /* PCM device, transfer done */ |
| #define GUS_DEV_PCM_CONTINUE 3 /* PCM device, transfer done ch. 1/2 */ |
| |
| static int gus_audio_speed; |
| static int gus_audio_channels; |
| static int gus_audio_bits; |
| static int gus_audio_bsize; |
| static char bounce_buf[8 * 1024]; /* Must match value set to max_fragment */ |
| |
| static DECLARE_WAIT_QUEUE_HEAD(dram_sleeper); |
| |
| /* |
| * Variables and buffers for PCM output |
| */ |
| |
| #define MAX_PCM_BUFFERS (128*MAX_REALTIME_FACTOR) /* Don't change */ |
| |
| static int pcm_bsize, pcm_nblk, pcm_banksize; |
| static int pcm_datasize[MAX_PCM_BUFFERS]; |
| static volatile int pcm_head, pcm_tail, pcm_qlen; |
| static volatile int pcm_active; |
| static volatile int dma_active; |
| static int pcm_opened; |
| static int pcm_current_dev; |
| static int pcm_current_block; |
| static unsigned long pcm_current_buf; |
| static int pcm_current_count; |
| static int pcm_current_intrflag; |
| DEFINE_SPINLOCK(gus_lock); |
| |
| extern int *gus_osp; |
| |
| static struct voice_info voices[32]; |
| |
| static int freq_div_table[] = |
| { |
| 44100, /* 14 */ |
| 41160, /* 15 */ |
| 38587, /* 16 */ |
| 36317, /* 17 */ |
| 34300, /* 18 */ |
| 32494, /* 19 */ |
| 30870, /* 20 */ |
| 29400, /* 21 */ |
| 28063, /* 22 */ |
| 26843, /* 23 */ |
| 25725, /* 24 */ |
| 24696, /* 25 */ |
| 23746, /* 26 */ |
| 22866, /* 27 */ |
| 22050, /* 28 */ |
| 21289, /* 29 */ |
| 20580, /* 30 */ |
| 19916, /* 31 */ |
| 19293 /* 32 */ |
| }; |
| |
| static struct patch_info *samples; |
| static long sample_ptrs[MAX_SAMPLE + 1]; |
| static int sample_map[32]; |
| static int free_sample; |
| static int mixer_type; |
| |
| |
| static int patch_table[MAX_PATCH]; |
| static int patch_map[32]; |
| |
| static struct synth_info gus_info = { |
| "Gravis UltraSound", 0, SYNTH_TYPE_SAMPLE, SAMPLE_TYPE_GUS, |
| 0, 16, 0, MAX_PATCH |
| }; |
| |
| static void gus_poke(long addr, unsigned char data); |
| static void compute_and_set_volume(int voice, int volume, int ramp_time); |
| extern unsigned short gus_adagio_vol(int vel, int mainv, int xpn, int voicev); |
| extern unsigned short gus_linear_vol(int vol, int mainvol); |
| static void compute_volume(int voice, int volume); |
| static void do_volume_irq(int voice); |
| static void set_input_volumes(void); |
| static void gus_tmr_install(int io_base); |
| |
| #define INSTANT_RAMP -1 /* Instant change. No ramping */ |
| #define FAST_RAMP 0 /* Fastest possible ramp */ |
| |
| static void reset_sample_memory(void) |
| { |
| int i; |
| |
| for (i = 0; i <= MAX_SAMPLE; i++) |
| sample_ptrs[i] = -1; |
| for (i = 0; i < 32; i++) |
| sample_map[i] = -1; |
| for (i = 0; i < 32; i++) |
| patch_map[i] = -1; |
| |
| gus_poke(0, 0); /* Put a silent sample to the beginning */ |
| gus_poke(1, 0); |
| free_mem_ptr = 2; |
| |
| free_sample = 0; |
| |
| for (i = 0; i < MAX_PATCH; i++) |
| patch_table[i] = NOT_SAMPLE; |
| } |
| |
| void gus_delay(void) |
| { |
| int i; |
| |
| for (i = 0; i < 7; i++) |
| inb(u_DRAMIO); |
| } |
| |
| static void gus_poke(long addr, unsigned char data) |
| { /* Writes a byte to the DRAM */ |
| outb((0x43), u_Command); |
| outb((addr & 0xff), u_DataLo); |
| outb(((addr >> 8) & 0xff), u_DataHi); |
| |
| outb((0x44), u_Command); |
| outb(((addr >> 16) & 0xff), u_DataHi); |
| outb((data), u_DRAMIO); |
| } |
| |
| static unsigned char gus_peek(long addr) |
| { /* Reads a byte from the DRAM */ |
| unsigned char tmp; |
| |
| outb((0x43), u_Command); |
| outb((addr & 0xff), u_DataLo); |
| outb(((addr >> 8) & 0xff), u_DataHi); |
| |
| outb((0x44), u_Command); |
| outb(((addr >> 16) & 0xff), u_DataHi); |
| tmp = inb(u_DRAMIO); |
| |
| return tmp; |
| } |
| |
| void gus_write8(int reg, unsigned int data) |
| { /* Writes to an indirect register (8 bit) */ |
| outb((reg), u_Command); |
| outb(((unsigned char) (data & 0xff)), u_DataHi); |
| } |
| |
| static unsigned char gus_read8(int reg) |
| { |
| /* Reads from an indirect register (8 bit). Offset 0x80. */ |
| unsigned char val; |
| |
| outb((reg | 0x80), u_Command); |
| val = inb(u_DataHi); |
| |
| return val; |
| } |
| |
| static unsigned char gus_look8(int reg) |
| { |
| /* Reads from an indirect register (8 bit). No additional offset. */ |
| unsigned char val; |
| |
| outb((reg), u_Command); |
| val = inb(u_DataHi); |
| |
| return val; |
| } |
| |
| static void gus_write16(int reg, unsigned int data) |
| { |
| /* Writes to an indirect register (16 bit) */ |
| outb((reg), u_Command); |
| |
| outb(((unsigned char) (data & 0xff)), u_DataLo); |
| outb(((unsigned char) ((data >> 8) & 0xff)), u_DataHi); |
| } |
| |
| static unsigned short gus_read16(int reg) |
| { |
| /* Reads from an indirect register (16 bit). Offset 0x80. */ |
| unsigned char hi, lo; |
| |
| outb((reg | 0x80), u_Command); |
| |
| lo = inb(u_DataLo); |
| hi = inb(u_DataHi); |
| |
| return ((hi << 8) & 0xff00) | lo; |
| } |
| |
| static unsigned short gus_look16(int reg) |
| { |
| /* Reads from an indirect register (16 bit). No additional offset. */ |
| unsigned char hi, lo; |
| |
| outb((reg), u_Command); |
| |
| lo = inb(u_DataLo); |
| hi = inb(u_DataHi); |
| |
| return ((hi << 8) & 0xff00) | lo; |
| } |
| |
| static void gus_write_addr(int reg, unsigned long address, int frac, int is16bit) |
| { |
| /* Writes an 24 bit memory address */ |
| unsigned long hold_address; |
| |
| if (is16bit) |
| { |
| if (iw_mode) |
| { |
| /* Interwave spesific address translations */ |
| address >>= 1; |
| } |
| else |
| { |
| /* |
| * Special processing required for 16 bit patches |
| */ |
| |
| hold_address = address; |
| address = address >> 1; |
| address &= 0x0001ffffL; |
| address |= (hold_address & 0x000c0000L); |
| } |
| } |
| gus_write16(reg, (unsigned short) ((address >> 7) & 0xffff)); |
| gus_write16(reg + 1, (unsigned short) ((address << 9) & 0xffff) |
| + (frac << 5)); |
| /* Could writing twice fix problems with GUS_VOICE_POS()? Let's try. */ |
| gus_delay(); |
| gus_write16(reg, (unsigned short) ((address >> 7) & 0xffff)); |
| gus_write16(reg + 1, (unsigned short) ((address << 9) & 0xffff) |
| + (frac << 5)); |
| } |
| |
| static void gus_select_voice(int voice) |
| { |
| if (voice < 0 || voice > 31) |
| return; |
| outb((voice), u_Voice); |
| } |
| |
| static void gus_select_max_voices(int nvoices) |
| { |
| if (iw_mode) |
| nvoices = 32; |
| if (nvoices < 14) |
| nvoices = 14; |
| if (nvoices > 32) |
| nvoices = 32; |
| |
| voice_alloc->max_voice = nr_voices = nvoices; |
| gus_write8(0x0e, (nvoices - 1) | 0xc0); |
| } |
| |
| static void gus_voice_on(unsigned int mode) |
| { |
| gus_write8(0x00, (unsigned char) (mode & 0xfc)); |
| gus_delay(); |
| gus_write8(0x00, (unsigned char) (mode & 0xfc)); |
| } |
| |
| static void gus_voice_off(void) |
| { |
| gus_write8(0x00, gus_read8(0x00) | 0x03); |
| } |
| |
| static void gus_voice_mode(unsigned int m) |
| { |
| unsigned char mode = (unsigned char) (m & 0xff); |
| |
| gus_write8(0x00, (gus_read8(0x00) & 0x03) | |
| (mode & 0xfc)); /* Don't touch last two bits */ |
| gus_delay(); |
| gus_write8(0x00, (gus_read8(0x00) & 0x03) | (mode & 0xfc)); |
| } |
| |
| static void gus_voice_freq(unsigned long freq) |
| { |
| unsigned long divisor = freq_div_table[nr_voices - 14]; |
| unsigned short fc; |
| |
| /* Interwave plays at 44100 Hz with any number of voices */ |
| if (iw_mode) |
| fc = (unsigned short) (((freq << 9) + (44100 >> 1)) / 44100); |
| else |
| fc = (unsigned short) (((freq << 9) + (divisor >> 1)) / divisor); |
| fc = fc << 1; |
| |
| gus_write16(0x01, fc); |
| } |
| |
| static void gus_voice_volume(unsigned int vol) |
| { |
| gus_write8(0x0d, 0x03); /* Stop ramp before setting volume */ |
| gus_write16(0x09, (unsigned short) (vol << 4)); |
| } |
| |
| static void gus_voice_balance(unsigned int balance) |
| { |
| gus_write8(0x0c, (unsigned char) (balance & 0xff)); |
| } |
| |
| static void gus_ramp_range(unsigned int low, unsigned int high) |
| { |
| gus_write8(0x07, (unsigned char) ((low >> 4) & 0xff)); |
| gus_write8(0x08, (unsigned char) ((high >> 4) & 0xff)); |
| } |
| |
| static void gus_ramp_rate(unsigned int scale, unsigned int rate) |
| { |
| gus_write8(0x06, (unsigned char) (((scale & 0x03) << 6) | (rate & 0x3f))); |
| } |
| |
| static void gus_rampon(unsigned int m) |
| { |
| unsigned char mode = (unsigned char) (m & 0xff); |
| |
| gus_write8(0x0d, mode & 0xfc); |
| gus_delay(); |
| gus_write8(0x0d, mode & 0xfc); |
| } |
| |
| static void gus_ramp_mode(unsigned int m) |
| { |
| unsigned char mode = (unsigned char) (m & 0xff); |
| |
| gus_write8(0x0d, (gus_read8(0x0d) & 0x03) | |
| (mode & 0xfc)); /* Leave the last 2 bits alone */ |
| gus_delay(); |
| gus_write8(0x0d, (gus_read8(0x0d) & 0x03) | (mode & 0xfc)); |
| } |
| |
| static void gus_rampoff(void) |
| { |
| gus_write8(0x0d, 0x03); |
| } |
| |
| static void gus_set_voice_pos(int voice, long position) |
| { |
| int sample_no; |
| |
| if ((sample_no = sample_map[voice]) != -1) { |
| if (position < samples[sample_no].len) { |
| if (voices[voice].volume_irq_mode == VMODE_START_NOTE) |
| voices[voice].offset_pending = position; |
| else |
| gus_write_addr(0x0a, sample_ptrs[sample_no] + position, 0, |
| samples[sample_no].mode & WAVE_16_BITS); |
| } |
| } |
| } |
| |
| static void gus_voice_init(int voice) |
| { |
| unsigned long flags; |
| |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| gus_voice_volume(0); |
| gus_voice_off(); |
| gus_write_addr(0x0a, 0, 0, 0); /* Set current position to 0 */ |
| gus_write8(0x00, 0x03); /* Voice off */ |
| gus_write8(0x0d, 0x03); /* Ramping off */ |
| voice_alloc->map[voice] = 0; |
| voice_alloc->alloc_times[voice] = 0; |
| spin_unlock_irqrestore(&gus_lock,flags); |
| |
| } |
| |
| static void gus_voice_init2(int voice) |
| { |
| voices[voice].panning = 0; |
| voices[voice].mode = 0; |
| voices[voice].orig_freq = 20000; |
| voices[voice].current_freq = 20000; |
| voices[voice].bender = 0; |
| voices[voice].bender_range = 200; |
| voices[voice].initial_volume = 0; |
| voices[voice].current_volume = 0; |
| voices[voice].loop_irq_mode = 0; |
| voices[voice].loop_irq_parm = 0; |
| voices[voice].volume_irq_mode = 0; |
| voices[voice].volume_irq_parm = 0; |
| voices[voice].env_phase = 0; |
| voices[voice].main_vol = 127; |
| voices[voice].patch_vol = 127; |
| voices[voice].expression_vol = 127; |
| voices[voice].sample_pending = -1; |
| voices[voice].fixed_pitch = 0; |
| } |
| |
| static void step_envelope(int voice) |
| { |
| unsigned vol, prev_vol, phase; |
| unsigned char rate; |
| unsigned long flags; |
| |
| if (voices[voice].mode & WAVE_SUSTAIN_ON && voices[voice].env_phase == 2) |
| { |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| gus_rampoff(); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| return; |
| /* |
| * Sustain phase begins. Continue envelope after receiving note off. |
| */ |
| } |
| if (voices[voice].env_phase >= 5) |
| { |
| /* Envelope finished. Shoot the voice down */ |
| gus_voice_init(voice); |
| return; |
| } |
| prev_vol = voices[voice].current_volume; |
| phase = ++voices[voice].env_phase; |
| compute_volume(voice, voices[voice].midi_volume); |
| vol = voices[voice].initial_volume * voices[voice].env_offset[phase] / 255; |
| rate = voices[voice].env_rate[phase]; |
| |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| |
| gus_voice_volume(prev_vol); |
| |
| |
| gus_write8(0x06, rate); /* Ramping rate */ |
| |
| voices[voice].volume_irq_mode = VMODE_ENVELOPE; |
| |
| if (((vol - prev_vol) / 64) == 0) /* No significant volume change */ |
| { |
| spin_unlock_irqrestore(&gus_lock,flags); |
| step_envelope(voice); /* Continue the envelope on the next step */ |
| return; |
| } |
| if (vol > prev_vol) |
| { |
| if (vol >= (4096 - 64)) |
| vol = 4096 - 65; |
| gus_ramp_range(0, vol); |
| gus_rampon(0x20); /* Increasing volume, with IRQ */ |
| } |
| else |
| { |
| if (vol <= 64) |
| vol = 65; |
| gus_ramp_range(vol, 4030); |
| gus_rampon(0x60); /* Decreasing volume, with IRQ */ |
| } |
| voices[voice].current_volume = vol; |
| spin_unlock_irqrestore(&gus_lock,flags); |
| } |
| |
| static void init_envelope(int voice) |
| { |
| voices[voice].env_phase = -1; |
| voices[voice].current_volume = 64; |
| |
| step_envelope(voice); |
| } |
| |
| static void start_release(int voice) |
| { |
| if (gus_read8(0x00) & 0x03) |
| return; /* Voice already stopped */ |
| |
| voices[voice].env_phase = 2; /* Will be incremented by step_envelope */ |
| |
| voices[voice].current_volume = voices[voice].initial_volume = |
| gus_read16(0x09) >> 4; /* Get current volume */ |
| |
| voices[voice].mode &= ~WAVE_SUSTAIN_ON; |
| gus_rampoff(); |
| step_envelope(voice); |
| } |
| |
| static void gus_voice_fade(int voice) |
| { |
| int instr_no = sample_map[voice], is16bits; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| |
| if (instr_no < 0 || instr_no > MAX_SAMPLE) |
| { |
| gus_write8(0x00, 0x03); /* Hard stop */ |
| voice_alloc->map[voice] = 0; |
| spin_unlock_irqrestore(&gus_lock,flags); |
| return; |
| } |
| is16bits = (samples[instr_no].mode & WAVE_16_BITS) ? 1 : 0; /* 8 or 16 bits */ |
| |
| if (voices[voice].mode & WAVE_ENVELOPES) |
| { |
| start_release(voice); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| return; |
| } |
| /* |
| * Ramp the volume down but not too quickly. |
| */ |
| if ((int) (gus_read16(0x09) >> 4) < 100) /* Get current volume */ |
| { |
| gus_voice_off(); |
| gus_rampoff(); |
| gus_voice_init(voice); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| return; |
| } |
| gus_ramp_range(65, 4030); |
| gus_ramp_rate(2, 4); |
| gus_rampon(0x40 | 0x20); /* Down, once, with IRQ */ |
| voices[voice].volume_irq_mode = VMODE_HALT; |
| spin_unlock_irqrestore(&gus_lock,flags); |
| } |
| |
| static void gus_reset(void) |
| { |
| int i; |
| |
| gus_select_max_voices(24); |
| volume_base = 3071; |
| volume_scale = 4; |
| volume_method = VOL_METHOD_ADAGIO; |
| |
| for (i = 0; i < 32; i++) |
| { |
| gus_voice_init(i); /* Turn voice off */ |
| gus_voice_init2(i); |
| } |
| } |
| |
| static void gus_initialize(void) |
| { |
| unsigned long flags; |
| unsigned char dma_image, irq_image, tmp; |
| |
| static unsigned char gus_irq_map[16] = { |
| 0, 0, 0, 3, 0, 2, 0, 4, 0, 1, 0, 5, 6, 0, 0, 7 |
| }; |
| |
| static unsigned char gus_dma_map[8] = { |
| 0, 1, 0, 2, 0, 3, 4, 5 |
| }; |
| |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_write8(0x4c, 0); /* Reset GF1 */ |
| gus_delay(); |
| gus_delay(); |
| |
| gus_write8(0x4c, 1); /* Release Reset */ |
| gus_delay(); |
| gus_delay(); |
| |
| /* |
| * Clear all interrupts |
| */ |
| |
| gus_write8(0x41, 0); /* DMA control */ |
| gus_write8(0x45, 0); /* Timer control */ |
| gus_write8(0x49, 0); /* Sample control */ |
| |
| gus_select_max_voices(24); |
| |
| inb(u_Status); /* Touch the status register */ |
| |
| gus_look8(0x41); /* Clear any pending DMA IRQs */ |
| gus_look8(0x49); /* Clear any pending sample IRQs */ |
| gus_read8(0x0f); /* Clear pending IRQs */ |
| |
| gus_reset(); /* Resets all voices */ |
| |
| gus_look8(0x41); /* Clear any pending DMA IRQs */ |
| gus_look8(0x49); /* Clear any pending sample IRQs */ |
| gus_read8(0x0f); /* Clear pending IRQs */ |
| |
| gus_write8(0x4c, 7); /* Master reset | DAC enable | IRQ enable */ |
| |
| /* |
| * Set up for Digital ASIC |
| */ |
| |
| outb((0x05), gus_base + 0x0f); |
| |
| mix_image |= 0x02; /* Disable line out (for a moment) */ |
| outb((mix_image), u_Mixer); |
| |
| outb((0x00), u_IRQDMAControl); |
| |
| outb((0x00), gus_base + 0x0f); |
| |
| /* |
| * Now set up the DMA and IRQ interface |
| * |
| * The GUS supports two IRQs and two DMAs. |
| * |
| * Just one DMA channel is used. This prevents simultaneous ADC and DAC. |
| * Adding this support requires significant changes to the dmabuf.c, dsp.c |
| * and audio.c also. |
| */ |
| |
| irq_image = 0; |
| tmp = gus_irq_map[gus_irq]; |
| if (!gus_pnp_flag && !tmp) |
| printk(KERN_WARNING "Warning! GUS IRQ not selected\n"); |
| irq_image |= tmp; |
| irq_image |= 0x40; /* Combine IRQ1 (GF1) and IRQ2 (Midi) */ |
| |
| dual_dma_mode = 1; |
| if (gus_dma2 == gus_dma || gus_dma2 == -1) |
| { |
| dual_dma_mode = 0; |
| dma_image = 0x40; /* Combine DMA1 (DRAM) and IRQ2 (ADC) */ |
| |
| tmp = gus_dma_map[gus_dma]; |
| if (!tmp) |
| printk(KERN_WARNING "Warning! GUS DMA not selected\n"); |
| |
| dma_image |= tmp; |
| } |
| else |
| { |
| /* Setup dual DMA channel mode for GUS MAX */ |
| |
| dma_image = gus_dma_map[gus_dma]; |
| if (!dma_image) |
| printk(KERN_WARNING "Warning! GUS DMA not selected\n"); |
| |
| tmp = gus_dma_map[gus_dma2] << 3; |
| if (!tmp) |
| { |
| printk(KERN_WARNING "Warning! Invalid GUS MAX DMA\n"); |
| tmp = 0x40; /* Combine DMA channels */ |
| dual_dma_mode = 0; |
| } |
| dma_image |= tmp; |
| } |
| |
| /* |
| * For some reason the IRQ and DMA addresses must be written twice |
| */ |
| |
| /* |
| * Doing it first time |
| */ |
| |
| outb((mix_image), u_Mixer); /* Select DMA control */ |
| outb((dma_image | 0x80), u_IRQDMAControl); /* Set DMA address */ |
| |
| outb((mix_image | 0x40), u_Mixer); /* Select IRQ control */ |
| outb((irq_image), u_IRQDMAControl); /* Set IRQ address */ |
| |
| /* |
| * Doing it second time |
| */ |
| |
| outb((mix_image), u_Mixer); /* Select DMA control */ |
| outb((dma_image), u_IRQDMAControl); /* Set DMA address */ |
| |
| outb((mix_image | 0x40), u_Mixer); /* Select IRQ control */ |
| outb((irq_image), u_IRQDMAControl); /* Set IRQ address */ |
| |
| gus_select_voice(0); /* This disables writes to IRQ/DMA reg */ |
| |
| mix_image &= ~0x02; /* Enable line out */ |
| mix_image |= 0x08; /* Enable IRQ */ |
| outb((mix_image), u_Mixer); /* |
| * Turn mixer channels on |
| * Note! Mic in is left off. |
| */ |
| |
| gus_select_voice(0); /* This disables writes to IRQ/DMA reg */ |
| |
| gusintr(gus_irq, (void *)gus_hw_config, NULL); /* Serve pending interrupts */ |
| |
| inb(u_Status); /* Touch the status register */ |
| |
| gus_look8(0x41); /* Clear any pending DMA IRQs */ |
| gus_look8(0x49); /* Clear any pending sample IRQs */ |
| |
| gus_read8(0x0f); /* Clear pending IRQs */ |
| |
| if (iw_mode) |
| gus_write8(0x19, gus_read8(0x19) | 0x01); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| } |
| |
| |
| static void __init pnp_mem_init(void) |
| { |
| #include "iwmem.h" |
| #define CHUNK_SIZE (256*1024) |
| #define BANK_SIZE (4*1024*1024) |
| #define CHUNKS_PER_BANK (BANK_SIZE/CHUNK_SIZE) |
| |
| int bank, chunk, addr, total = 0; |
| int bank_sizes[4]; |
| int i, j, bits = -1, testbits = -1, nbanks = 0; |
| |
| /* |
| * This routine determines what kind of RAM is installed in each of the four |
| * SIMM banks and configures the DRAM address decode logic accordingly. |
| */ |
| |
| /* |
| * Place the chip into enhanced mode |
| */ |
| gus_write8(0x19, gus_read8(0x19) | 0x01); |
| gus_write8(0x53, gus_look8(0x53) & ~0x02); /* Select DRAM I/O access */ |
| |
| /* |
| * Set memory configuration to 4 DRAM banks of 4M in each (16M total). |
| */ |
| |
| gus_write16(0x52, (gus_look16(0x52) & 0xfff0) | 0x000c); |
| |
| /* |
| * Perform the DRAM size detection for each bank individually. |
| */ |
| for (bank = 0; bank < 4; bank++) |
| { |
| int size = 0; |
| |
| addr = bank * BANK_SIZE; |
| |
| /* Clean check points of each chunk */ |
| for (chunk = 0; chunk < CHUNKS_PER_BANK; chunk++) |
| { |
| gus_poke(addr + chunk * CHUNK_SIZE + 0L, 0x00); |
| gus_poke(addr + chunk * CHUNK_SIZE + 1L, 0x00); |
| } |
| |
| /* Write a value to each chunk point and verify the result */ |
| for (chunk = 0; chunk < CHUNKS_PER_BANK; chunk++) |
| { |
| gus_poke(addr + chunk * CHUNK_SIZE + 0L, 0x55); |
| gus_poke(addr + chunk * CHUNK_SIZE + 1L, 0xAA); |
| |
| if (gus_peek(addr + chunk * CHUNK_SIZE + 0L) == 0x55 && |
| gus_peek(addr + chunk * CHUNK_SIZE + 1L) == 0xAA) |
| { |
| /* OK. There is RAM. Now check for possible shadows */ |
| int ok = 1, chunk2; |
| |
| for (chunk2 = 0; ok && chunk2 < chunk; chunk2++) |
| if (gus_peek(addr + chunk2 * CHUNK_SIZE + 0L) || |
| gus_peek(addr + chunk2 * CHUNK_SIZE + 1L)) |
| ok = 0; /* Addressing wraps */ |
| |
| if (ok) |
| size = (chunk + 1) * CHUNK_SIZE; |
| } |
| gus_poke(addr + chunk * CHUNK_SIZE + 0L, 0x00); |
| gus_poke(addr + chunk * CHUNK_SIZE + 1L, 0x00); |
| } |
| bank_sizes[bank] = size; |
| if (size) |
| nbanks = bank + 1; |
| DDB(printk("Interwave: Bank %d, size=%dk\n", bank, size / 1024)); |
| } |
| |
| if (nbanks == 0) /* No RAM - Give up */ |
| { |
| printk(KERN_ERR "Sound: An Interwave audio chip detected but no DRAM\n"); |
| printk(KERN_ERR "Sound: Unable to work with this card.\n"); |
| gus_write8(0x19, gus_read8(0x19) & ~0x01); |
| gus_mem_size = 0; |
| return; |
| } |
| |
| /* |
| * Now we know how much DRAM there is in each bank. The next step is |
| * to find a DRAM size encoding (0 to 12) which is best for the combination |
| * we have. |
| * |
| * First try if any of the possible alternatives matches exactly the amount |
| * of memory we have. |
| */ |
| |
| for (i = 0; bits == -1 && i < 13; i++) |
| { |
| bits = i; |
| |
| for (j = 0; bits != -1 && j < 4; j++) |
| if (mem_decode[i][j] != bank_sizes[j]) |
| bits = -1; /* No hit */ |
| } |
| |
| /* |
| * If necessary, try to find a combination where other than the last |
| * bank matches our configuration and the last bank is left oversized. |
| * In this way we don't leave holes in the middle of memory. |
| */ |
| |
| if (bits == -1) /* No luck yet */ |
| { |
| for (i = 0; bits == -1 && i < 13; i++) |
| { |
| bits = i; |
| |
| for (j = 0; bits != -1 && j < nbanks - 1; j++) |
| if (mem_decode[i][j] != bank_sizes[j]) |
| bits = -1; /* No hit */ |
| if (mem_decode[i][nbanks - 1] < bank_sizes[nbanks - 1]) |
| bits = -1; /* The last bank is too small */ |
| } |
| } |
| /* |
| * The last resort is to search for a combination where the banks are |
| * smaller than the actual SIMMs. This leaves some memory in the banks |
| * unused but doesn't leave holes in the DRAM address space. |
| */ |
| if (bits == -1) /* No luck yet */ |
| { |
| for (i = 0; i < 13; i++) |
| { |
| testbits = i; |
| for (j = 0; testbits != -1 && j < nbanks - 1; j++) |
| if (mem_decode[i][j] > bank_sizes[j]) { |
| testbits = -1; |
| } |
| if(testbits > bits) bits = testbits; |
| } |
| if (bits != -1) |
| { |
| printk(KERN_INFO "Interwave: Can't use all installed RAM.\n"); |
| printk(KERN_INFO "Interwave: Try reordering SIMMS.\n"); |
| } |
| printk(KERN_INFO "Interwave: Can't find working DRAM encoding.\n"); |
| printk(KERN_INFO "Interwave: Defaulting to 256k. Try reordering SIMMS.\n"); |
| bits = 0; |
| } |
| DDB(printk("Interwave: Selecting DRAM addressing mode %d\n", bits)); |
| |
| for (bank = 0; bank < 4; bank++) |
| { |
| DDB(printk(" Bank %d, mem=%dk (limit %dk)\n", bank, bank_sizes[bank] / 1024, mem_decode[bits][bank] / 1024)); |
| |
| if (bank_sizes[bank] > mem_decode[bits][bank]) |
| total += mem_decode[bits][bank]; |
| else |
| total += bank_sizes[bank]; |
| } |
| |
| DDB(printk("Total %dk of DRAM (enhanced mode)\n", total / 1024)); |
| |
| /* |
| * Set the memory addressing mode. |
| */ |
| gus_write16(0x52, (gus_look16(0x52) & 0xfff0) | bits); |
| |
| /* Leave the chip into enhanced mode. Disable LFO */ |
| gus_mem_size = total; |
| iw_mode = 1; |
| gus_write8(0x19, (gus_read8(0x19) | 0x01) & ~0x02); |
| } |
| |
| int __init gus_wave_detect(int baseaddr) |
| { |
| unsigned long i, max_mem = 1024L; |
| unsigned long loc; |
| unsigned char val; |
| |
| if (!request_region(baseaddr, 16, "GUS")) |
| return 0; |
| if (!request_region(baseaddr + 0x100, 12, "GUS")) { /* 0x10c-> is MAX */ |
| release_region(baseaddr, 16); |
| return 0; |
| } |
| |
| gus_base = baseaddr; |
| |
| gus_write8(0x4c, 0); /* Reset GF1 */ |
| gus_delay(); |
| gus_delay(); |
| |
| gus_write8(0x4c, 1); /* Release Reset */ |
| gus_delay(); |
| gus_delay(); |
| |
| #ifdef GUSPNP_AUTODETECT |
| val = gus_look8(0x5b); /* Version number register */ |
| gus_write8(0x5b, ~val); /* Invert all bits */ |
| |
| if ((gus_look8(0x5b) & 0xf0) == (val & 0xf0)) /* No change */ |
| { |
| if ((gus_look8(0x5b) & 0x0f) == ((~val) & 0x0f)) /* Change */ |
| { |
| DDB(printk("Interwave chip version %d detected\n", (val & 0xf0) >> 4)); |
| gus_pnp_flag = 1; |
| } |
| else |
| { |
| DDB(printk("Not an Interwave chip (%x)\n", gus_look8(0x5b))); |
| gus_pnp_flag = 0; |
| } |
| } |
| gus_write8(0x5b, val); /* Restore all bits */ |
| #endif |
| |
| if (gus_pnp_flag) |
| pnp_mem_init(); |
| if (iw_mode) |
| return 1; |
| |
| /* See if there is first block there.... */ |
| gus_poke(0L, 0xaa); |
| if (gus_peek(0L) != 0xaa) { |
| release_region(baseaddr + 0x100, 12); |
| release_region(baseaddr, 16); |
| return 0; |
| } |
| |
| /* Now zero it out so that I can check for mirroring .. */ |
| gus_poke(0L, 0x00); |
| for (i = 1L; i < max_mem; i++) |
| { |
| int n, failed; |
| |
| /* check for mirroring ... */ |
| if (gus_peek(0L) != 0) |
| break; |
| loc = i << 10; |
| |
| for (n = loc - 1, failed = 0; n <= loc; n++) |
| { |
| gus_poke(loc, 0xaa); |
| if (gus_peek(loc) != 0xaa) |
| failed = 1; |
| gus_poke(loc, 0x55); |
| if (gus_peek(loc) != 0x55) |
| failed = 1; |
| } |
| if (failed) |
| break; |
| } |
| gus_mem_size = i << 10; |
| return 1; |
| } |
| |
| static int guswave_ioctl(int dev, unsigned int cmd, void __user *arg) |
| { |
| |
| switch (cmd) |
| { |
| case SNDCTL_SYNTH_INFO: |
| gus_info.nr_voices = nr_voices; |
| if (copy_to_user(arg, &gus_info, sizeof(gus_info))) |
| return -EFAULT; |
| return 0; |
| |
| case SNDCTL_SEQ_RESETSAMPLES: |
| reset_sample_memory(); |
| return 0; |
| |
| case SNDCTL_SEQ_PERCMODE: |
| return 0; |
| |
| case SNDCTL_SYNTH_MEMAVL: |
| return (gus_mem_size == 0) ? 0 : gus_mem_size - free_mem_ptr - 32; |
| |
| default: |
| return -EINVAL; |
| } |
| } |
| |
| static int guswave_set_instr(int dev, int voice, int instr_no) |
| { |
| int sample_no; |
| |
| if (instr_no < 0 || instr_no > MAX_PATCH) |
| instr_no = 0; /* Default to acoustic piano */ |
| |
| if (voice < 0 || voice > 31) |
| return -EINVAL; |
| |
| if (voices[voice].volume_irq_mode == VMODE_START_NOTE) |
| { |
| voices[voice].sample_pending = instr_no; |
| return 0; |
| } |
| sample_no = patch_table[instr_no]; |
| patch_map[voice] = -1; |
| |
| if (sample_no == NOT_SAMPLE) |
| { |
| /* printk("GUS: Undefined patch %d for voice %d\n", instr_no, voice);*/ |
| return -EINVAL; /* Patch not defined */ |
| } |
| if (sample_ptrs[sample_no] == -1) /* Sample not loaded */ |
| { |
| /* printk("GUS: Sample #%d not loaded for patch %d (voice %d)\n", sample_no, instr_no, voice);*/ |
| return -EINVAL; |
| } |
| sample_map[voice] = sample_no; |
| patch_map[voice] = instr_no; |
| return 0; |
| } |
| |
| static int guswave_kill_note(int dev, int voice, int note, int velocity) |
| { |
| unsigned long flags; |
| |
| spin_lock_irqsave(&gus_lock,flags); |
| /* voice_alloc->map[voice] = 0xffff; */ |
| if (voices[voice].volume_irq_mode == VMODE_START_NOTE) |
| { |
| voices[voice].kill_pending = 1; |
| spin_unlock_irqrestore(&gus_lock,flags); |
| } |
| else |
| { |
| spin_unlock_irqrestore(&gus_lock,flags); |
| gus_voice_fade(voice); |
| } |
| |
| return 0; |
| } |
| |
| static void guswave_aftertouch(int dev, int voice, int pressure) |
| { |
| } |
| |
| static void guswave_panning(int dev, int voice, int value) |
| { |
| if (voice >= 0 || voice < 32) |
| voices[voice].panning = value; |
| } |
| |
| static void guswave_volume_method(int dev, int mode) |
| { |
| if (mode == VOL_METHOD_LINEAR || mode == VOL_METHOD_ADAGIO) |
| volume_method = mode; |
| } |
| |
| static void compute_volume(int voice, int volume) |
| { |
| if (volume < 128) |
| voices[voice].midi_volume = volume; |
| |
| switch (volume_method) |
| { |
| case VOL_METHOD_ADAGIO: |
| voices[voice].initial_volume = |
| gus_adagio_vol(voices[voice].midi_volume, voices[voice].main_vol, |
| voices[voice].expression_vol, |
| voices[voice].patch_vol); |
| break; |
| |
| case VOL_METHOD_LINEAR: /* Totally ignores patch-volume and expression */ |
| voices[voice].initial_volume = gus_linear_vol(volume, voices[voice].main_vol); |
| break; |
| |
| default: |
| voices[voice].initial_volume = volume_base + |
| (voices[voice].midi_volume * volume_scale); |
| } |
| |
| if (voices[voice].initial_volume > 4030) |
| voices[voice].initial_volume = 4030; |
| } |
| |
| static void compute_and_set_volume(int voice, int volume, int ramp_time) |
| { |
| int curr, target, rate; |
| unsigned long flags; |
| |
| compute_volume(voice, volume); |
| voices[voice].current_volume = voices[voice].initial_volume; |
| |
| spin_lock_irqsave(&gus_lock,flags); |
| /* |
| * CAUTION! Interrupts disabled. Enable them before returning |
| */ |
| |
| gus_select_voice(voice); |
| |
| curr = gus_read16(0x09) >> 4; |
| target = voices[voice].initial_volume; |
| |
| if (ramp_time == INSTANT_RAMP) |
| { |
| gus_rampoff(); |
| gus_voice_volume(target); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| return; |
| } |
| if (ramp_time == FAST_RAMP) |
| rate = 63; |
| else |
| rate = 16; |
| gus_ramp_rate(0, rate); |
| |
| if ((target - curr) / 64 == 0) /* Close enough to target. */ |
| { |
| gus_rampoff(); |
| gus_voice_volume(target); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| return; |
| } |
| if (target > curr) |
| { |
| if (target > (4095 - 65)) |
| target = 4095 - 65; |
| gus_ramp_range(curr, target); |
| gus_rampon(0x00); /* Ramp up, once, no IRQ */ |
| } |
| else |
| { |
| if (target < 65) |
| target = 65; |
| |
| gus_ramp_range(target, curr); |
| gus_rampon(0x40); /* Ramp down, once, no irq */ |
| } |
| spin_unlock_irqrestore(&gus_lock,flags); |
| } |
| |
| static void dynamic_volume_change(int voice) |
| { |
| unsigned char status; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| status = gus_read8(0x00); /* Get voice status */ |
| spin_unlock_irqrestore(&gus_lock,flags); |
| |
| if (status & 0x03) |
| return; /* Voice was not running */ |
| |
| if (!(voices[voice].mode & WAVE_ENVELOPES)) |
| { |
| compute_and_set_volume(voice, voices[voice].midi_volume, 1); |
| return; |
| } |
| |
| /* |
| * Voice is running and has envelopes. |
| */ |
| |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| status = gus_read8(0x0d); /* Ramping status */ |
| spin_unlock_irqrestore(&gus_lock,flags); |
| |
| if (status & 0x03) /* Sustain phase? */ |
| { |
| compute_and_set_volume(voice, voices[voice].midi_volume, 1); |
| return; |
| } |
| if (voices[voice].env_phase < 0) |
| return; |
| |
| compute_volume(voice, voices[voice].midi_volume); |
| |
| } |
| |
| static void guswave_controller(int dev, int voice, int ctrl_num, int value) |
| { |
| unsigned long flags; |
| unsigned long freq; |
| |
| if (voice < 0 || voice > 31) |
| return; |
| |
| switch (ctrl_num) |
| { |
| case CTRL_PITCH_BENDER: |
| voices[voice].bender = value; |
| |
| if (voices[voice].volume_irq_mode != VMODE_START_NOTE) |
| { |
| freq = compute_finetune(voices[voice].orig_freq, value, voices[voice].bender_range, 0); |
| voices[voice].current_freq = freq; |
| |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| gus_voice_freq(freq); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| } |
| break; |
| |
| case CTRL_PITCH_BENDER_RANGE: |
| voices[voice].bender_range = value; |
| break; |
| case CTL_EXPRESSION: |
| value /= 128; |
| case CTRL_EXPRESSION: |
| if (volume_method == VOL_METHOD_ADAGIO) |
| { |
| voices[voice].expression_vol = value; |
| if (voices[voice].volume_irq_mode != VMODE_START_NOTE) |
| dynamic_volume_change(voice); |
| } |
| break; |
| |
| case CTL_PAN: |
| voices[voice].panning = (value * 2) - 128; |
| break; |
| |
| case CTL_MAIN_VOLUME: |
| value = (value * 100) / 16383; |
| |
| case CTRL_MAIN_VOLUME: |
| voices[voice].main_vol = value; |
| if (voices[voice].volume_irq_mode != VMODE_START_NOTE) |
| dynamic_volume_change(voice); |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| static int guswave_start_note2(int dev, int voice, int note_num, int volume) |
| { |
| int sample, best_sample, best_delta, delta_freq; |
| int is16bits, samplep, patch, pan; |
| unsigned long note_freq, base_note, freq, flags; |
| unsigned char mode = 0; |
| |
| if (voice < 0 || voice > 31) |
| { |
| /* printk("GUS: Invalid voice\n");*/ |
| return -EINVAL; |
| } |
| if (note_num == 255) |
| { |
| if (voices[voice].mode & WAVE_ENVELOPES) |
| { |
| voices[voice].midi_volume = volume; |
| dynamic_volume_change(voice); |
| return 0; |
| } |
| compute_and_set_volume(voice, volume, 1); |
| return 0; |
| } |
| if ((patch = patch_map[voice]) == -1) |
| return -EINVAL; |
| if ((samplep = patch_table[patch]) == NOT_SAMPLE) |
| { |
| return -EINVAL; |
| } |
| note_freq = note_to_freq(note_num); |
| |
| /* |
| * Find a sample within a patch so that the note_freq is between low_note |
| * and high_note. |
| */ |
| sample = -1; |
| |
| best_sample = samplep; |
| best_delta = 1000000; |
| while (samplep != 0 && samplep != NOT_SAMPLE && sample == -1) |
| { |
| delta_freq = note_freq - samples[samplep].base_note; |
| if (delta_freq < 0) |
| delta_freq = -delta_freq; |
| if (delta_freq < best_delta) |
| { |
| best_sample = samplep; |
| best_delta = delta_freq; |
| } |
| if (samples[samplep].low_note <= note_freq && |
| note_freq <= samples[samplep].high_note) |
| { |
| sample = samplep; |
| } |
| else |
| samplep = samples[samplep].key; /* Link to next sample */ |
| } |
| if (sample == -1) |
| sample = best_sample; |
| |
| if (sample == -1) |
| { |
| /* printk("GUS: Patch %d not defined for note %d\n", patch, note_num);*/ |
| return 0; /* Should play default patch ??? */ |
| } |
| is16bits = (samples[sample].mode & WAVE_16_BITS) ? 1 : 0; |
| voices[voice].mode = samples[sample].mode; |
| voices[voice].patch_vol = samples[sample].volume; |
| |
| if (iw_mode) |
| gus_write8(0x15, 0x00); /* RAM, Reset voice deactivate bit of SMSI */ |
| |
| if (voices[voice].mode & WAVE_ENVELOPES) |
| { |
| int i; |
| |
| for (i = 0; i < 6; i++) |
| { |
| voices[voice].env_rate[i] = samples[sample].env_rate[i]; |
| voices[voice].env_offset[i] = samples[sample].env_offset[i]; |
| } |
| } |
| sample_map[voice] = sample; |
| |
| if (voices[voice].fixed_pitch) /* Fixed pitch */ |
| { |
| freq = samples[sample].base_freq; |
| } |
| else |
| { |
| base_note = samples[sample].base_note / 100; |
| note_freq /= 100; |
| |
| freq = samples[sample].base_freq * note_freq / base_note; |
| } |
| |
| voices[voice].orig_freq = freq; |
| |
| /* |
| * Since the pitch bender may have been set before playing the note, we |
| * have to calculate the bending now. |
| */ |
| |
| freq = compute_finetune(voices[voice].orig_freq, voices[voice].bender, |
| voices[voice].bender_range, 0); |
| voices[voice].current_freq = freq; |
| |
| pan = (samples[sample].panning + voices[voice].panning) / 32; |
| pan += 7; |
| if (pan < 0) |
| pan = 0; |
| if (pan > 15) |
| pan = 15; |
| |
| if (samples[sample].mode & WAVE_16_BITS) |
| { |
| mode |= 0x04; /* 16 bits */ |
| if ((sample_ptrs[sample] / GUS_BANK_SIZE) != |
| ((sample_ptrs[sample] + samples[sample].len) / GUS_BANK_SIZE)) |
| printk(KERN_ERR "GUS: Sample address error\n"); |
| } |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| gus_voice_off(); |
| gus_rampoff(); |
| |
| spin_unlock_irqrestore(&gus_lock,flags); |
| |
| if (voices[voice].mode & WAVE_ENVELOPES) |
| { |
| compute_volume(voice, volume); |
| init_envelope(voice); |
| } |
| else |
| { |
| compute_and_set_volume(voice, volume, 0); |
| } |
| |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| |
| if (samples[sample].mode & WAVE_LOOP_BACK) |
| gus_write_addr(0x0a, sample_ptrs[sample] + samples[sample].len - |
| voices[voice].offset_pending, 0, is16bits); /* start=end */ |
| else |
| gus_write_addr(0x0a, sample_ptrs[sample] + voices[voice].offset_pending, 0, is16bits); /* Sample start=begin */ |
| |
| if (samples[sample].mode & WAVE_LOOPING) |
| { |
| mode |= 0x08; |
| |
| if (samples[sample].mode & WAVE_BIDIR_LOOP) |
| mode |= 0x10; |
| |
| if (samples[sample].mode & WAVE_LOOP_BACK) |
| { |
| gus_write_addr(0x0a, sample_ptrs[sample] + samples[sample].loop_end - |
| voices[voice].offset_pending, |
| (samples[sample].fractions >> 4) & 0x0f, is16bits); |
| mode |= 0x40; |
| } |
| gus_write_addr(0x02, sample_ptrs[sample] + samples[sample].loop_start, |
| samples[sample].fractions & 0x0f, is16bits); /* Loop start location */ |
| gus_write_addr(0x04, sample_ptrs[sample] + samples[sample].loop_end, |
| (samples[sample].fractions >> 4) & 0x0f, is16bits); /* Loop end location */ |
| } |
| else |
| { |
| mode |= 0x20; /* Loop IRQ at the end */ |
| voices[voice].loop_irq_mode = LMODE_FINISH; /* Ramp down at the end */ |
| voices[voice].loop_irq_parm = 1; |
| gus_write_addr(0x02, sample_ptrs[sample], 0, is16bits); /* Loop start location */ |
| gus_write_addr(0x04, sample_ptrs[sample] + samples[sample].len - 1, |
| (samples[sample].fractions >> 4) & 0x0f, is16bits); /* Loop end location */ |
| } |
| gus_voice_freq(freq); |
| gus_voice_balance(pan); |
| gus_voice_on(mode); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| |
| return 0; |
| } |
| |
| /* |
| * New guswave_start_note by Andrew J. Robinson attempts to minimize clicking |
| * when the note playing on the voice is changed. It uses volume |
| * ramping. |
| */ |
| |
| static int guswave_start_note(int dev, int voice, int note_num, int volume) |
| { |
| unsigned long flags; |
| int mode; |
| int ret_val = 0; |
| |
| spin_lock_irqsave(&gus_lock,flags); |
| if (note_num == 255) |
| { |
| if (voices[voice].volume_irq_mode == VMODE_START_NOTE) |
| { |
| voices[voice].volume_pending = volume; |
| } |
| else |
| { |
| ret_val = guswave_start_note2(dev, voice, note_num, volume); |
| } |
| } |
| else |
| { |
| gus_select_voice(voice); |
| mode = gus_read8(0x00); |
| if (mode & 0x20) |
| gus_write8(0x00, mode & 0xdf); /* No interrupt! */ |
| |
| voices[voice].offset_pending = 0; |
| voices[voice].kill_pending = 0; |
| voices[voice].volume_irq_mode = 0; |
| voices[voice].loop_irq_mode = 0; |
| |
| if (voices[voice].sample_pending >= 0) |
| { |
| spin_unlock_irqrestore(&gus_lock,flags); /* Run temporarily with interrupts enabled */ |
| guswave_set_instr(voices[voice].dev_pending, voice, voices[voice].sample_pending); |
| voices[voice].sample_pending = -1; |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); /* Reselect the voice (just to be sure) */ |
| } |
| if ((mode & 0x01) || (int) ((gus_read16(0x09) >> 4) < (unsigned) 2065)) |
| { |
| ret_val = guswave_start_note2(dev, voice, note_num, volume); |
| } |
| else |
| { |
| voices[voice].dev_pending = dev; |
| voices[voice].note_pending = note_num; |
| voices[voice].volume_pending = volume; |
| voices[voice].volume_irq_mode = VMODE_START_NOTE; |
| |
| gus_rampoff(); |
| gus_ramp_range(2000, 4065); |
| gus_ramp_rate(0, 63); /* Fastest possible rate */ |
| gus_rampon(0x20 | 0x40); /* Ramp down, once, irq */ |
| } |
| } |
| spin_unlock_irqrestore(&gus_lock,flags); |
| return ret_val; |
| } |
| |
| static void guswave_reset(int dev) |
| { |
| int i; |
| |
| for (i = 0; i < 32; i++) |
| { |
| gus_voice_init(i); |
| gus_voice_init2(i); |
| } |
| } |
| |
| static int guswave_open(int dev, int mode) |
| { |
| int err; |
| |
| if (gus_busy) |
| return -EBUSY; |
| |
| voice_alloc->timestamp = 0; |
| |
| if (gus_no_wave_dma) { |
| gus_no_dma = 1; |
| } else { |
| if ((err = DMAbuf_open_dma(gus_devnum)) < 0) |
| { |
| /* printk( "GUS: Loading samples without DMA\n"); */ |
| gus_no_dma = 1; /* Upload samples using PIO */ |
| } |
| else |
| gus_no_dma = 0; |
| } |
| |
| init_waitqueue_head(&dram_sleeper); |
| gus_busy = 1; |
| active_device = GUS_DEV_WAVE; |
| |
| gusintr(gus_irq, (void *)gus_hw_config, NULL); /* Serve pending interrupts */ |
| gus_initialize(); |
| gus_reset(); |
| gusintr(gus_irq, (void *)gus_hw_config, NULL); /* Serve pending interrupts */ |
| |
| return 0; |
| } |
| |
| static void guswave_close(int dev) |
| { |
| gus_busy = 0; |
| active_device = 0; |
| gus_reset(); |
| |
| if (!gus_no_dma) |
| DMAbuf_close_dma(gus_devnum); |
| } |
| |
| static int guswave_load_patch(int dev, int format, const char __user *addr, |
| int offs, int count, int pmgr_flag) |
| { |
| struct patch_info patch; |
| int instr; |
| long sizeof_patch; |
| |
| unsigned long blk_sz, blk_end, left, src_offs, target; |
| |
| sizeof_patch = (long) &patch.data[0] - (long) &patch; /* Header size */ |
| |
| if (format != GUS_PATCH) |
| { |
| /* printk("GUS Error: Invalid patch format (key) 0x%x\n", format);*/ |
| return -EINVAL; |
| } |
| if (count < sizeof_patch) |
| { |
| /* printk("GUS Error: Patch header too short\n");*/ |
| return -EINVAL; |
| } |
| count -= sizeof_patch; |
| |
| if (free_sample >= MAX_SAMPLE) |
| { |
| /* printk("GUS: Sample table full\n");*/ |
| return -ENOSPC; |
| } |
| /* |
| * Copy the header from user space but ignore the first bytes which have |
| * been transferred already. |
| */ |
| |
| if (copy_from_user(&((char *) &patch)[offs], &(addr)[offs], |
| sizeof_patch - offs)) |
| return -EFAULT; |
| |
| if (patch.mode & WAVE_ROM) |
| return -EINVAL; |
| if (gus_mem_size == 0) |
| return -ENOSPC; |
| |
| instr = patch.instr_no; |
| |
| if (instr < 0 || instr > MAX_PATCH) |
| { |
| /* printk(KERN_ERR "GUS: Invalid patch number %d\n", instr);*/ |
| return -EINVAL; |
| } |
| if (count < patch.len) |
| { |
| /* printk(KERN_ERR "GUS Warning: Patch record too short (%d<%d)\n", count, (int) patch.len);*/ |
| patch.len = count; |
| } |
| if (patch.len <= 0 || patch.len > gus_mem_size) |
| { |
| /* printk(KERN_ERR "GUS: Invalid sample length %d\n", (int) patch.len);*/ |
| return -EINVAL; |
| } |
| if (patch.mode & WAVE_LOOPING) |
| { |
| if (patch.loop_start < 0 || patch.loop_start >= patch.len) |
| { |
| /* printk(KERN_ERR "GUS: Invalid loop start\n");*/ |
| return -EINVAL; |
| } |
| if (patch.loop_end < patch.loop_start || patch.loop_end > patch.len) |
| { |
| /* printk(KERN_ERR "GUS: Invalid loop end\n");*/ |
| return -EINVAL; |
| } |
| } |
| free_mem_ptr = (free_mem_ptr + 31) & ~31; /* 32 byte alignment */ |
| |
| if (patch.mode & WAVE_16_BITS) |
| { |
| /* |
| * 16 bit samples must fit one 256k bank. |
| */ |
| if (patch.len >= GUS_BANK_SIZE) |
| { |
| /* printk("GUS: Sample (16 bit) too long %d\n", (int) patch.len);*/ |
| return -ENOSPC; |
| } |
| if ((free_mem_ptr / GUS_BANK_SIZE) != |
| ((free_mem_ptr + patch.len) / GUS_BANK_SIZE)) |
| { |
| unsigned long tmp_mem = |
| /* Align to 256K */ |
| ((free_mem_ptr / GUS_BANK_SIZE) + 1) * GUS_BANK_SIZE; |
| |
| if ((tmp_mem + patch.len) > gus_mem_size) |
| return -ENOSPC; |
| |
| free_mem_ptr = tmp_mem; /* This leaves unusable memory */ |
| } |
| } |
| if ((free_mem_ptr + patch.len) > gus_mem_size) |
| return -ENOSPC; |
| |
| sample_ptrs[free_sample] = free_mem_ptr; |
| |
| /* |
| * Tremolo is not possible with envelopes |
| */ |
| |
| if (patch.mode & WAVE_ENVELOPES) |
| patch.mode &= ~WAVE_TREMOLO; |
| |
| if (!(patch.mode & WAVE_FRACTIONS)) |
| { |
| patch.fractions = 0; |
| } |
| memcpy((char *) &samples[free_sample], &patch, sizeof_patch); |
| |
| /* |
| * Link this_one sample to the list of samples for patch 'instr'. |
| */ |
| |
| samples[free_sample].key = patch_table[instr]; |
| patch_table[instr] = free_sample; |
| |
| /* |
| * Use DMA to transfer the wave data to the DRAM |
| */ |
| |
| left = patch.len; |
| src_offs = 0; |
| target = free_mem_ptr; |
| |
| while (left) /* Not completely transferred yet */ |
| { |
| blk_sz = audio_devs[gus_devnum]->dmap_out->bytes_in_use; |
| if (blk_sz > left) |
| blk_sz = left; |
| |
| /* |
| * DMA cannot cross bank (256k) boundaries. Check for that. |
| */ |
| |
| blk_end = target + blk_sz; |
| |
| if ((target / GUS_BANK_SIZE) != (blk_end / GUS_BANK_SIZE)) |
| { |
| /* Split the block */ |
| blk_end &= ~(GUS_BANK_SIZE - 1); |
| blk_sz = blk_end - target; |
| } |
| if (gus_no_dma) |
| { |
| /* |
| * For some reason the DMA is not possible. We have to use PIO. |
| */ |
| long i; |
| unsigned char data; |
| |
| for (i = 0; i < blk_sz; i++) |
| { |
| get_user(*(unsigned char *) &data, (unsigned char __user *) &((addr)[sizeof_patch + i])); |
| if (patch.mode & WAVE_UNSIGNED) |
| if (!(patch.mode & WAVE_16_BITS) || (i & 0x01)) |
| data ^= 0x80; /* Convert to signed */ |
| gus_poke(target + i, data); |
| } |
| } |
| else |
| { |
| unsigned long address, hold_address; |
| unsigned char dma_command; |
| unsigned long flags; |
| |
| if (audio_devs[gus_devnum]->dmap_out->raw_buf == NULL) |
| { |
| printk(KERN_ERR "GUS: DMA buffer == NULL\n"); |
| return -ENOSPC; |
| } |
| /* |
| * OK, move now. First in and then out. |
| */ |
| |
| if (copy_from_user(audio_devs[gus_devnum]->dmap_out->raw_buf, |
| &(addr)[sizeof_patch + src_offs], |
| blk_sz)) |
| return -EFAULT; |
| |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_write8(0x41, 0); /* Disable GF1 DMA */ |
| DMAbuf_start_dma(gus_devnum, audio_devs[gus_devnum]->dmap_out->raw_buf_phys, |
| blk_sz, DMA_MODE_WRITE); |
| |
| /* |
| * Set the DRAM address for the wave data |
| */ |
| |
| if (iw_mode) |
| { |
| /* Different address translation in enhanced mode */ |
| |
| unsigned char hi; |
| |
| if (gus_dma > 4) |
| address = target >> 1; /* Convert to 16 bit word address */ |
| else |
| address = target; |
| |
| hi = (unsigned char) ((address >> 16) & 0xf0); |
| hi += (unsigned char) (address & 0x0f); |
| |
| gus_write16(0x42, (address >> 4) & 0xffff); /* DMA address (low) */ |
| gus_write8(0x50, hi); |
| } |
| else |
| { |
| address = target; |
| if (audio_devs[gus_devnum]->dmap_out->dma > 3) |
| { |
| hold_address = address; |
| address = address >> 1; |
| address &= 0x0001ffffL; |
| address |= (hold_address & 0x000c0000L); |
| } |
| gus_write16(0x42, (address >> 4) & 0xffff); /* DRAM DMA address */ |
| } |
| |
| /* |
| * Start the DMA transfer |
| */ |
| |
| dma_command = 0x21; /* IRQ enable, DMA start */ |
| if (patch.mode & WAVE_UNSIGNED) |
| dma_command |= 0x80; /* Invert MSB */ |
| if (patch.mode & WAVE_16_BITS) |
| dma_command |= 0x40; /* 16 bit _DATA_ */ |
| if (audio_devs[gus_devnum]->dmap_out->dma > 3) |
| dma_command |= 0x04; /* 16 bit DMA _channel_ */ |
| |
| /* |
| * Sleep here until the DRAM DMA done interrupt is served |
| */ |
| active_device = GUS_DEV_WAVE; |
| gus_write8(0x41, dma_command); /* Lets go luteet (=bugs) */ |
| |
| spin_unlock_irqrestore(&gus_lock,flags); /* opens a race */ |
| if (!interruptible_sleep_on_timeout(&dram_sleeper, HZ)) |
| printk("GUS: DMA Transfer timed out\n"); |
| } |
| |
| /* |
| * Now the next part |
| */ |
| |
| left -= blk_sz; |
| src_offs += blk_sz; |
| target += blk_sz; |
| |
| gus_write8(0x41, 0); /* Stop DMA */ |
| } |
| |
| free_mem_ptr += patch.len; |
| free_sample++; |
| return 0; |
| } |
| |
| static void guswave_hw_control(int dev, unsigned char *event_rec) |
| { |
| int voice, cmd; |
| unsigned short p1, p2; |
| unsigned int plong; |
| unsigned long flags; |
| |
| cmd = event_rec[2]; |
| voice = event_rec[3]; |
| p1 = *(unsigned short *) &event_rec[4]; |
| p2 = *(unsigned short *) &event_rec[6]; |
| plong = *(unsigned int *) &event_rec[4]; |
| |
| if ((voices[voice].volume_irq_mode == VMODE_START_NOTE) && |
| (cmd != _GUS_VOICESAMPLE) && (cmd != _GUS_VOICE_POS)) |
| do_volume_irq(voice); |
| |
| switch (cmd) |
| { |
| case _GUS_NUMVOICES: |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| gus_select_max_voices(p1); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| break; |
| |
| case _GUS_VOICESAMPLE: |
| guswave_set_instr(dev, voice, p1); |
| break; |
| |
| case _GUS_VOICEON: |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| p1 &= ~0x20; /* Don't allow interrupts */ |
| gus_voice_on(p1); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| break; |
| |
| case _GUS_VOICEOFF: |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| gus_voice_off(); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| break; |
| |
| case _GUS_VOICEFADE: |
| gus_voice_fade(voice); |
| break; |
| |
| case _GUS_VOICEMODE: |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| p1 &= ~0x20; /* Don't allow interrupts */ |
| gus_voice_mode(p1); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| break; |
| |
| case _GUS_VOICEBALA: |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| gus_voice_balance(p1); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| break; |
| |
| case _GUS_VOICEFREQ: |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| gus_voice_freq(plong); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| break; |
| |
| case _GUS_VOICEVOL: |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| gus_voice_volume(p1); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| break; |
| |
| case _GUS_VOICEVOL2: /* Just update the software voice level */ |
| voices[voice].initial_volume = voices[voice].current_volume = p1; |
| break; |
| |
| case _GUS_RAMPRANGE: |
| if (voices[voice].mode & WAVE_ENVELOPES) |
| break; /* NO-NO */ |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| gus_ramp_range(p1, p2); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| break; |
| |
| case _GUS_RAMPRATE: |
| if (voices[voice].mode & WAVE_ENVELOPES) |
| break; /* NJET-NJET */ |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| gus_ramp_rate(p1, p2); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| break; |
| |
| case _GUS_RAMPMODE: |
| if (voices[voice].mode & WAVE_ENVELOPES) |
| break; /* NO-NO */ |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| p1 &= ~0x20; /* Don't allow interrupts */ |
| gus_ramp_mode(p1); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| break; |
| |
| case _GUS_RAMPON: |
| if (voices[voice].mode & WAVE_ENVELOPES) |
| break; /* EI-EI */ |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| p1 &= ~0x20; /* Don't allow interrupts */ |
| gus_rampon(p1); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| break; |
| |
| case _GUS_RAMPOFF: |
| if (voices[voice].mode & WAVE_ENVELOPES) |
| break; /* NEJ-NEJ */ |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| gus_rampoff(); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| break; |
| |
| case _GUS_VOLUME_SCALE: |
| volume_base = p1; |
| volume_scale = p2; |
| break; |
| |
| case _GUS_VOICE_POS: |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| gus_set_voice_pos(voice, plong); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| static int gus_audio_set_speed(int speed) |
| { |
| if (speed <= 0) |
| speed = gus_audio_speed; |
| |
| if (speed < 4000) |
| speed = 4000; |
| |
| if (speed > 44100) |
| speed = 44100; |
| |
| gus_audio_speed = speed; |
| |
| if (only_read_access) |
| { |
| /* Compute nearest valid recording speed and return it */ |
| |
| /* speed = (9878400 / (gus_audio_speed + 2)) / 16; */ |
| speed = (((9878400 + gus_audio_speed / 2) / (gus_audio_speed + 2)) + 8) / 16; |
| speed = (9878400 / (speed * 16)) - 2; |
| } |
| return speed; |
| } |
| |
| static int gus_audio_set_channels(int channels) |
| { |
| if (!channels) |
| return gus_audio_channels; |
| if (channels > 2) |
| channels = 2; |
| if (channels < 1) |
| channels = 1; |
| gus_audio_channels = channels; |
| return channels; |
| } |
| |
| static int gus_audio_set_bits(int bits) |
| { |
| if (!bits) |
| return gus_audio_bits; |
| |
| if (bits != 8 && bits != 16) |
| bits = 8; |
| |
| if (only_8_bits) |
| bits = 8; |
| |
| gus_audio_bits = bits; |
| return bits; |
| } |
| |
| static int gus_audio_ioctl(int dev, unsigned int cmd, void __user *arg) |
| { |
| int val; |
| |
| switch (cmd) |
| { |
| case SOUND_PCM_WRITE_RATE: |
| if (get_user(val, (int __user*)arg)) |
| return -EFAULT; |
| val = gus_audio_set_speed(val); |
| break; |
| |
| case SOUND_PCM_READ_RATE: |
| val = gus_audio_speed; |
| break; |
| |
| case SNDCTL_DSP_STEREO: |
| if (get_user(val, (int __user *)arg)) |
| return -EFAULT; |
| val = gus_audio_set_channels(val + 1) - 1; |
| break; |
| |
| case SOUND_PCM_WRITE_CHANNELS: |
| if (get_user(val, (int __user *)arg)) |
| return -EFAULT; |
| val = gus_audio_set_channels(val); |
| break; |
| |
| case SOUND_PCM_READ_CHANNELS: |
| val = gus_audio_channels; |
| break; |
| |
| case SNDCTL_DSP_SETFMT: |
| if (get_user(val, (int __user *)arg)) |
| return -EFAULT; |
| val = gus_audio_set_bits(val); |
| break; |
| |
| case SOUND_PCM_READ_BITS: |
| val = gus_audio_bits; |
| break; |
| |
| case SOUND_PCM_WRITE_FILTER: /* NOT POSSIBLE */ |
| case SOUND_PCM_READ_FILTER: |
| val = -EINVAL; |
| break; |
| default: |
| return -EINVAL; |
| } |
| return put_user(val, (int __user *)arg); |
| } |
| |
| static void gus_audio_reset(int dev) |
| { |
| if (recording_active) |
| { |
| gus_write8(0x49, 0x00); /* Halt recording */ |
| set_input_volumes(); |
| } |
| } |
| |
| static int saved_iw_mode; /* A hack hack hack */ |
| |
| static int gus_audio_open(int dev, int mode) |
| { |
| if (gus_busy) |
| return -EBUSY; |
| |
| if (gus_pnp_flag && mode & OPEN_READ) |
| { |
| /* printk(KERN_ERR "GUS: Audio device #%d is playback only.\n", dev);*/ |
| return -EIO; |
| } |
| gus_initialize(); |
| |
| gus_busy = 1; |
| active_device = 0; |
| |
| saved_iw_mode = iw_mode; |
| if (iw_mode) |
| { |
| /* There are some problems with audio in enhanced mode so disable it */ |
| gus_write8(0x19, gus_read8(0x19) & ~0x01); /* Disable enhanced mode */ |
| iw_mode = 0; |
| } |
| |
| gus_reset(); |
| reset_sample_memory(); |
| gus_select_max_voices(14); |
| |
| pcm_active = 0; |
| dma_active = 0; |
| pcm_opened = 1; |
| if (mode & OPEN_READ) |
| { |
| recording_active = 1; |
| set_input_volumes(); |
| } |
| only_read_access = !(mode & OPEN_WRITE); |
| only_8_bits = mode & OPEN_READ; |
| if (only_8_bits) |
| audio_devs[dev]->format_mask = AFMT_U8; |
| else |
| audio_devs[dev]->format_mask = AFMT_U8 | AFMT_S16_LE; |
| |
| return 0; |
| } |
| |
| static void gus_audio_close(int dev) |
| { |
| iw_mode = saved_iw_mode; |
| gus_reset(); |
| gus_busy = 0; |
| pcm_opened = 0; |
| active_device = 0; |
| |
| if (recording_active) |
| { |
| gus_write8(0x49, 0x00); /* Halt recording */ |
| set_input_volumes(); |
| } |
| recording_active = 0; |
| } |
| |
| static void gus_audio_update_volume(void) |
| { |
| unsigned long flags; |
| int voice; |
| |
| if (pcm_active && pcm_opened) |
| for (voice = 0; voice < gus_audio_channels; voice++) |
| { |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| gus_rampoff(); |
| gus_voice_volume(1530 + (25 * gus_pcm_volume)); |
| gus_ramp_range(65, 1530 + (25 * gus_pcm_volume)); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| } |
| } |
| |
| static void play_next_pcm_block(void) |
| { |
| unsigned long flags; |
| int speed = gus_audio_speed; |
| int this_one, is16bits, chn; |
| unsigned long dram_loc; |
| unsigned char mode[2], ramp_mode[2]; |
| |
| if (!pcm_qlen) |
| return; |
| |
| this_one = pcm_head; |
| |
| for (chn = 0; chn < gus_audio_channels; chn++) |
| { |
| mode[chn] = 0x00; |
| ramp_mode[chn] = 0x03; /* Ramping and rollover off */ |
| |
| if (chn == 0) |
| { |
| mode[chn] |= 0x20; /* Loop IRQ */ |
| voices[chn].loop_irq_mode = LMODE_PCM; |
| } |
| if (gus_audio_bits != 8) |
| { |
| is16bits = 1; |
| mode[chn] |= 0x04; /* 16 bit data */ |
| } |
| else |
| is16bits = 0; |
| |
| dram_loc = this_one * pcm_bsize; |
| dram_loc += chn * pcm_banksize; |
| |
| if (this_one == (pcm_nblk - 1)) /* Last fragment of the DRAM buffer */ |
| { |
| mode[chn] |= 0x08; /* Enable loop */ |
| ramp_mode[chn] = 0x03; /* Disable rollover bit */ |
| } |
| else |
| { |
| if (chn == 0) |
| ramp_mode[chn] = 0x04; /* Enable rollover bit */ |
| } |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(chn); |
| gus_voice_freq(speed); |
| |
| if (gus_audio_channels == 1) |
| gus_voice_balance(7); /* mono */ |
| else if (chn == 0) |
| gus_voice_balance(0); /* left */ |
| else |
| gus_voice_balance(15); /* right */ |
| |
| if (!pcm_active) /* Playback not already active */ |
| { |
| /* |
| * The playback was not started yet (or there has been a pause). |
| * Start the voice (again) and ask for a rollover irq at the end of |
| * this_one block. If this_one one is last of the buffers, use just |
| * the normal loop with irq. |
| */ |
| |
| gus_voice_off(); |
| gus_rampoff(); |
| gus_voice_volume(1530 + (25 * gus_pcm_volume)); |
| gus_ramp_range(65, 1530 + (25 * gus_pcm_volume)); |
| |
| gus_write_addr(0x0a, chn * pcm_banksize, 0, is16bits); /* Starting position */ |
| gus_write_addr(0x02, chn * pcm_banksize, 0, is16bits); /* Loop start */ |
| |
| if (chn != 0) |
| gus_write_addr(0x04, pcm_banksize + (pcm_bsize * pcm_nblk) - 1, |
| 0, is16bits); /* Loop end location */ |
| } |
| if (chn == 0) |
| gus_write_addr(0x04, dram_loc + pcm_bsize - 1, |
| 0, is16bits); /* Loop end location */ |
| else |
| mode[chn] |= 0x08; /* Enable looping */ |
| spin_unlock_irqrestore(&gus_lock,flags); |
| } |
| for (chn = 0; chn < gus_audio_channels; chn++) |
| { |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(chn); |
| gus_write8(0x0d, ramp_mode[chn]); |
| if (iw_mode) |
| gus_write8(0x15, 0x00); /* Reset voice deactivate bit of SMSI */ |
| gus_voice_on(mode[chn]); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| } |
| pcm_active = 1; |
| } |
| |
| static void gus_transfer_output_block(int dev, unsigned long buf, |
| int total_count, int intrflag, int chn) |
| { |
| /* |
| * This routine transfers one block of audio data to the DRAM. In mono mode |
| * it's called just once. When in stereo mode, this_one routine is called |
| * once for both channels. |
| * |
| * The left/mono channel data is transferred to the beginning of dram and the |
| * right data to the area pointed by gus_page_size. |
| */ |
| |
| int this_one, count; |
| unsigned long flags; |
| unsigned char dma_command; |
| unsigned long address, hold_address; |
| |
| spin_lock_irqsave(&gus_lock,flags); |
| |
| count = total_count / gus_audio_channels; |
| |
| if (chn == 0) |
| { |
| if (pcm_qlen >= pcm_nblk) |
| printk(KERN_WARNING "GUS Warning: PCM buffers out of sync\n"); |
| |
| this_one = pcm_current_block = pcm_tail; |
| pcm_qlen++; |
| pcm_tail = (pcm_tail + 1) % pcm_nblk; |
| pcm_datasize[this_one] = count; |
| } |
| else |
| this_one = pcm_current_block; |
| |
| gus_write8(0x41, 0); /* Disable GF1 DMA */ |
| DMAbuf_start_dma(dev, buf + (chn * count), count, DMA_MODE_WRITE); |
| |
| address = this_one * pcm_bsize; |
| address += chn * pcm_banksize; |
| |
| if (audio_devs[dev]->dmap_out->dma > 3) |
| { |
| hold_address = address; |
| address = address >> 1; |
| address &= 0x0001ffffL; |
| address |= (hold_address & 0x000c0000L); |
| } |
| gus_write16(0x42, (address >> 4) & 0xffff); /* DRAM DMA address */ |
| |
| dma_command = 0x21; /* IRQ enable, DMA start */ |
| |
| if (gus_audio_bits != 8) |
| dma_command |= 0x40; /* 16 bit _DATA_ */ |
| else |
| dma_command |= 0x80; /* Invert MSB */ |
| |
| if (audio_devs[dev]->dmap_out->dma > 3) |
| dma_command |= 0x04; /* 16 bit DMA channel */ |
| |
| gus_write8(0x41, dma_command); /* Kick start */ |
| |
| if (chn == (gus_audio_channels - 1)) /* Last channel */ |
| { |
| /* |
| * Last (right or mono) channel data |
| */ |
| dma_active = 1; /* DMA started. There is a unacknowledged buffer */ |
| active_device = GUS_DEV_PCM_DONE; |
| if (!pcm_active && (pcm_qlen > 1 || count < pcm_bsize)) |
| { |
| play_next_pcm_block(); |
| } |
| } |
| else |
| { |
| /* |
| * Left channel data. The right channel |
| * is transferred after DMA interrupt |
| */ |
| active_device = GUS_DEV_PCM_CONTINUE; |
| } |
| |
| spin_unlock_irqrestore(&gus_lock,flags); |
| } |
| |
| static void gus_uninterleave8(char *buf, int l) |
| { |
| /* This routine uninterleaves 8 bit stereo output (LRLRLR->LLLRRR) */ |
| int i, p = 0, halfsize = l / 2; |
| char *buf2 = buf + halfsize, *src = bounce_buf; |
| |
| memcpy(bounce_buf, buf, l); |
| |
| for (i = 0; i < halfsize; i++) |
| { |
| buf[i] = src[p++]; /* Left channel */ |
| buf2[i] = src[p++]; /* Right channel */ |
| } |
| } |
| |
| static void gus_uninterleave16(short *buf, int l) |
| { |
| /* This routine uninterleaves 16 bit stereo output (LRLRLR->LLLRRR) */ |
| int i, p = 0, halfsize = l / 2; |
| short *buf2 = buf + halfsize, *src = (short *) bounce_buf; |
| |
| memcpy(bounce_buf, (char *) buf, l * 2); |
| |
| for (i = 0; i < halfsize; i++) |
| { |
| buf[i] = src[p++]; /* Left channel */ |
| buf2[i] = src[p++]; /* Right channel */ |
| } |
| } |
| |
| static void gus_audio_output_block(int dev, unsigned long buf, int total_count, |
| int intrflag) |
| { |
| struct dma_buffparms *dmap = audio_devs[dev]->dmap_out; |
| |
| dmap->flags |= DMA_NODMA | DMA_NOTIMEOUT; |
| |
| pcm_current_buf = buf; |
| pcm_current_count = total_count; |
| pcm_current_intrflag = intrflag; |
| pcm_current_dev = dev; |
| if (gus_audio_channels == 2) |
| { |
| char *b = dmap->raw_buf + (buf - dmap->raw_buf_phys); |
| |
| if (gus_audio_bits == 8) |
| gus_uninterleave8(b, total_count); |
| else |
| gus_uninterleave16((short *) b, total_count / 2); |
| } |
| gus_transfer_output_block(dev, buf, total_count, intrflag, 0); |
| } |
| |
| static void gus_audio_start_input(int dev, unsigned long buf, int count, |
| int intrflag) |
| { |
| unsigned long flags; |
| unsigned char mode; |
| |
| spin_lock_irqsave(&gus_lock,flags); |
| |
| DMAbuf_start_dma(dev, buf, count, DMA_MODE_READ); |
| mode = 0xa0; /* DMA IRQ enabled, invert MSB */ |
| |
| if (audio_devs[dev]->dmap_in->dma > 3) |
| mode |= 0x04; /* 16 bit DMA channel */ |
| if (gus_audio_channels > 1) |
| mode |= 0x02; /* Stereo */ |
| mode |= 0x01; /* DMA enable */ |
| |
| gus_write8(0x49, mode); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| } |
| |
| static int gus_audio_prepare_for_input(int dev, int bsize, int bcount) |
| { |
| unsigned int rate; |
| |
| gus_audio_bsize = bsize; |
| audio_devs[dev]->dmap_in->flags |= DMA_NODMA; |
| rate = (((9878400 + gus_audio_speed / 2) / (gus_audio_speed + 2)) + 8) / 16; |
| |
| gus_write8(0x48, rate & 0xff); /* Set sampling rate */ |
| |
| if (gus_audio_bits != 8) |
| { |
| /* printk("GUS Error: 16 bit recording not supported\n");*/ |
| return -EINVAL; |
| } |
| return 0; |
| } |
| |
| static int gus_audio_prepare_for_output(int dev, int bsize, int bcount) |
| { |
| int i; |
| |
| long mem_ptr, mem_size; |
| |
| audio_devs[dev]->dmap_out->flags |= DMA_NODMA | DMA_NOTIMEOUT; |
| mem_ptr = 0; |
| mem_size = gus_mem_size / gus_audio_channels; |
| |
| if (mem_size > (256 * 1024)) |
| mem_size = 256 * 1024; |
| |
| pcm_bsize = bsize / gus_audio_channels; |
| pcm_head = pcm_tail = pcm_qlen = 0; |
| |
| pcm_nblk = 2; /* MAX_PCM_BUFFERS; */ |
| if ((pcm_bsize * pcm_nblk) > mem_size) |
| pcm_nblk = mem_size / pcm_bsize; |
| |
| for (i = 0; i < pcm_nblk; i++) |
| pcm_datasize[i] = 0; |
| |
| pcm_banksize = pcm_nblk * pcm_bsize; |
| |
| if (gus_audio_bits != 8 && pcm_banksize == (256 * 1024)) |
| pcm_nblk--; |
| gus_write8(0x41, 0); /* Disable GF1 DMA */ |
| return 0; |
| } |
| |
| static int gus_local_qlen(int dev) |
| { |
| return pcm_qlen; |
| } |
| |
| |
| static struct audio_driver gus_audio_driver = |
| { |
| .owner = THIS_MODULE, |
| .open = gus_audio_open, |
| .close = gus_audio_close, |
| .output_block = gus_audio_output_block, |
| .start_input = gus_audio_start_input, |
| .ioctl = gus_audio_ioctl, |
| .prepare_for_input = gus_audio_prepare_for_input, |
| .prepare_for_output = gus_audio_prepare_for_output, |
| .halt_io = gus_audio_reset, |
| .local_qlen = gus_local_qlen, |
| }; |
| |
| static void guswave_setup_voice(int dev, int voice, int chn) |
| { |
| struct channel_info *info = &synth_devs[dev]->chn_info[chn]; |
| |
| guswave_set_instr(dev, voice, info->pgm_num); |
| voices[voice].expression_vol = info->controllers[CTL_EXPRESSION]; /* Just MSB */ |
| voices[voice].main_vol = (info->controllers[CTL_MAIN_VOLUME] * 100) / (unsigned) 128; |
| voices[voice].panning = (info->controllers[CTL_PAN] * 2) - 128; |
| voices[voice].bender = 0; |
| voices[voice].bender_range = info->bender_range; |
| |
| if (chn == 9) |
| voices[voice].fixed_pitch = 1; |
| } |
| |
| static void guswave_bender(int dev, int voice, int value) |
| { |
| int freq; |
| unsigned long flags; |
| |
| voices[voice].bender = value - 8192; |
| freq = compute_finetune(voices[voice].orig_freq, value - 8192, voices[voice].bender_range, 0); |
| voices[voice].current_freq = freq; |
| |
| spin_lock_irqsave(&gus_lock,flags); |
| gus_select_voice(voice); |
| gus_voice_freq(freq); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| } |
| |
| static int guswave_alloc(int dev, int chn, int note, struct voice_alloc_info *alloc) |
| { |
| int i, p, best = -1, best_time = 0x7fffffff; |
| |
| p = alloc->ptr; |
| /* |
| * First look for a completely stopped voice |
| */ |
| |
| for (i = 0; i < alloc->max_voice; i++) |
| { |
| if (alloc->map[p] == 0) |
| { |
| alloc->ptr = p; |
| return p; |
| } |
| if (alloc->alloc_times[p] < best_time) |
| { |
| best = p; |
| best_time = alloc->alloc_times[p]; |
| } |
| p = (p + 1) % alloc->max_voice; |
| } |
| |
| /* |
| * Then look for a releasing voice |
| */ |
| |
| for (i = 0; i < alloc->max_voice; i++) |
| { |
| if (alloc->map[p] == 0xffff) |
| { |
| alloc->ptr = p; |
| return p; |
| } |
| p = (p + 1) % alloc->max_voice; |
| } |
| if (best >= 0) |
| p = best; |
| |
| alloc->ptr = p; |
| return p; |
| } |
| |
| static struct synth_operations guswave_operations = |
| { |
| .owner = THIS_MODULE, |
| .id = "GUS", |
| .info = &gus_info, |
| .midi_dev = 0, |
| .synth_type = SYNTH_TYPE_SAMPLE, |
| .synth_subtype = SAMPLE_TYPE_GUS, |
| .open = guswave_open, |
| .close = guswave_close, |
| .ioctl = guswave_ioctl, |
| .kill_note = guswave_kill_note, |
| .start_note = guswave_start_note, |
| .set_instr = guswave_set_instr, |
| .reset = guswave_reset, |
| .hw_control = guswave_hw_control, |
| .load_patch = guswave_load_patch, |
| .aftertouch = guswave_aftertouch, |
| .controller = guswave_controller, |
| .panning = guswave_panning, |
| .volume_method = guswave_volume_method, |
| .bender = guswave_bender, |
| .alloc_voice = guswave_alloc, |
| .setup_voice = guswave_setup_voice |
| }; |
| |
| static void set_input_volumes(void) |
| { |
| unsigned long flags; |
| unsigned char mask = 0xff & ~0x06; /* Just line out enabled */ |
| |
| if (have_gus_max) /* Don't disturb GUS MAX */ |
| return; |
| |
| spin_lock_irqsave(&gus_lock,flags); |
| |
| /* |
| * Enable channels having vol > 10% |
| * Note! bit 0x01 means the line in DISABLED while 0x04 means |
| * the mic in ENABLED. |
| */ |
| if (gus_line_vol > 10) |
| mask &= ~0x01; |
| if (gus_mic_vol > 10) |
| mask |= 0x04; |
| |
| if (recording_active) |
| { |
| /* |
| * Disable channel, if not selected for recording |
| */ |
| if (!(gus_recmask & SOUND_MASK_LINE)) |
| mask |= 0x01; |
| if (!(gus_recmask & SOUND_MASK_MIC)) |
| mask &= ~0x04; |
| } |
| mix_image &= ~0x07; |
| mix_image |= mask & 0x07; |
| outb((mix_image), u_Mixer); |
| |
| spin_unlock_irqrestore(&gus_lock,flags); |
| } |
| |
| #define MIX_DEVS (SOUND_MASK_MIC|SOUND_MASK_LINE| \ |
| SOUND_MASK_SYNTH|SOUND_MASK_PCM) |
| |
| int gus_default_mixer_ioctl(int dev, unsigned int cmd, void __user *arg) |
| { |
| int vol, val; |
| |
| if (((cmd >> 8) & 0xff) != 'M') |
| return -EINVAL; |
| |
| if (!access_ok(VERIFY_WRITE, arg, sizeof(int))) |
| return -EFAULT; |
| |
| if (_SIOC_DIR(cmd) & _SIOC_WRITE) |
| { |
| if (__get_user(val, (int __user *) arg)) |
| return -EFAULT; |
| |
| switch (cmd & 0xff) |
| { |
| case SOUND_MIXER_RECSRC: |
| gus_recmask = val & MIX_DEVS; |
| if (!(gus_recmask & (SOUND_MASK_MIC | SOUND_MASK_LINE))) |
| gus_recmask = SOUND_MASK_MIC; |
| /* Note! Input volumes are updated during next open for recording */ |
| val = gus_recmask; |
| break; |
| |
| case SOUND_MIXER_MIC: |
| vol = val & 0xff; |
| if (vol < 0) |
| vol = 0; |
| if (vol > 100) |
| vol = 100; |
| gus_mic_vol = vol; |
| set_input_volumes(); |
| val = vol | (vol << 8); |
| break; |
| |
| case SOUND_MIXER_LINE: |
| vol = val & 0xff; |
| if (vol < 0) |
| vol = 0; |
| if (vol > 100) |
| vol = 100; |
| gus_line_vol = vol; |
| set_input_volumes(); |
| val = vol | (vol << 8); |
| break; |
| |
| case SOUND_MIXER_PCM: |
| gus_pcm_volume = val & 0xff; |
| if (gus_pcm_volume < 0) |
| gus_pcm_volume = 0; |
| if (gus_pcm_volume > 100) |
| gus_pcm_volume = 100; |
| gus_audio_update_volume(); |
| val = gus_pcm_volume | (gus_pcm_volume << 8); |
| break; |
| |
| case SOUND_MIXER_SYNTH: |
| gus_wave_volume = val & 0xff; |
| if (gus_wave_volume < 0) |
| gus_wave_volume = 0; |
| if (gus_wave_volume > 100) |
| gus_wave_volume = 100; |
| if (active_device == GUS_DEV_WAVE) |
| { |
| int voice; |
| for (voice = 0; voice < nr_voices; voice++) |
| dynamic_volume_change(voice); /* Apply the new vol */ |
| } |
| val = gus_wave_volume | (gus_wave_volume << 8); |
| break; |
| |
| default: |
| return -EINVAL; |
| } |
| } |
| else |
| { |
| switch (cmd & 0xff) |
| { |
| /* |
| * Return parameters |
| */ |
| case SOUND_MIXER_RECSRC: |
| val = gus_recmask; |
| break; |
| |
| case SOUND_MIXER_DEVMASK: |
| val = MIX_DEVS; |
| break; |
| |
| case SOUND_MIXER_STEREODEVS: |
| val = 0; |
| break; |
| |
| case SOUND_MIXER_RECMASK: |
| val = SOUND_MASK_MIC | SOUND_MASK_LINE; |
| break; |
| |
| case SOUND_MIXER_CAPS: |
| val = 0; |
| break; |
| |
| case SOUND_MIXER_MIC: |
| val = gus_mic_vol | (gus_mic_vol << 8); |
| break; |
| |
| case SOUND_MIXER_LINE: |
| val = gus_line_vol | (gus_line_vol << 8); |
| break; |
| |
| case SOUND_MIXER_PCM: |
| val = gus_pcm_volume | (gus_pcm_volume << 8); |
| break; |
| |
| case SOUND_MIXER_SYNTH: |
| val = gus_wave_volume | (gus_wave_volume << 8); |
| break; |
| |
| default: |
| return -EINVAL; |
| } |
| } |
| return __put_user(val, (int __user *)arg); |
| } |
| |
| static struct mixer_operations gus_mixer_operations = |
| { |
| .owner = THIS_MODULE, |
| .id = "GUS", |
| .name = "Gravis Ultrasound", |
| .ioctl = gus_default_mixer_ioctl |
| }; |
| |
| static int __init gus_default_mixer_init(void) |
| { |
| int n; |
| |
| if ((n = sound_alloc_mixerdev()) != -1) |
| { |
| /* |
| * Don't install if there is another |
| * mixer |
| */ |
| mixer_devs[n] = &gus_mixer_operations; |
| } |
| if (have_gus_max) |
| { |
| /* |
| * Enable all mixer channels on the GF1 side. Otherwise recording will |
| * not be possible using GUS MAX. |
| */ |
| mix_image &= ~0x07; |
| mix_image |= 0x04; /* All channels enabled */ |
| outb((mix_image), u_Mixer); |
| } |
| return n; |
| } |
| |
| void __init gus_wave_init(struct address_info *hw_config) |
| { |
| unsigned long flags; |
| unsigned char val; |
| char *model_num = "2.4"; |
| char tmp[64]; |
| int gus_type = 0x24; /* 2.4 */ |
| |
| int irq = hw_config->irq, dma = hw_config->dma, dma2 = hw_config->dma2; |
| int sdev; |
| |
| hw_config->slots[0] = -1; /* No wave */ |
| hw_config->slots[1] = -1; /* No ad1848 */ |
| hw_config->slots[4] = -1; /* No audio */ |
| hw_config->slots[5] = -1; /* No mixer */ |
| |
| if (!gus_pnp_flag) |
| { |
| if (irq < 0 || irq > 15) |
| { |
| printk(KERN_ERR "ERROR! Invalid IRQ#%d. GUS Disabled", irq); |
| return; |
| } |
| } |
| |
| if (dma < 0 || dma > 7 || dma == 4) |
| { |
| printk(KERN_ERR "ERROR! Invalid DMA#%d. GUS Disabled", dma); |
| return; |
| } |
| gus_irq = irq; |
| gus_dma = dma; |
| gus_dma2 = dma2; |
| gus_hw_config = hw_config; |
| |
| if (gus_dma2 == -1) |
| gus_dma2 = dma; |
| |
| /* |
| * Try to identify the GUS model. |
| * |
| * Versions < 3.6 don't have the digital ASIC. Try to probe it first. |
| */ |
| |
| spin_lock_irqsave(&gus_lock,flags); |
| outb((0x20), gus_base + 0x0f); |
| val = inb(gus_base + 0x0f); |
| spin_unlock_irqrestore(&gus_lock,flags); |
| |
| if (gus_pnp_flag || (val != 0xff && (val & 0x06))) /* Should be 0x02?? */ |
| { |
| int ad_flags = 0; |
| |
| if (gus_pnp_flag) |
| ad_flags = 0x12345678; /* Interwave "magic" */ |
| /* |
| * It has the digital ASIC so the card is at least v3.4. |
| * Next try to detect the true model. |
| */ |
| |
| if (gus_pnp_flag) /* Hack hack hack */ |
| val = 10; |
| else |
| val = inb(u_MixSelect); |
| |
| /* |
| * Value 255 means pre-3.7 which don't have mixer. |
| * Values 5 thru 9 mean v3.7 which has a ICS2101 mixer. |
| * 10 and above is GUS MAX which has the CS4231 codec/mixer. |
| * |
| */ |
| |
| if (val == 255 || val < 5) |
| { |
| model_num = "3.4"; |
| gus_type = 0x34; |
| } |
| else if (val < 10) |
| { |
| model_num = "3.7"; |
| gus_type = 0x37; |
| mixer_type = ICS2101; |
| request_region(u_MixSelect, 1, "GUS mixer"); |
| } |
| else |
| { |
| struct resource *ports; |
| ports = request_region(gus_base + 0x10c, 4, "ad1848"); |
| model_num = "MAX"; |
| gus_type = 0x40; |
| mixer_type = CS4231; |
| #ifdef CONFIG_SOUND_GUSMAX |
| { |
| unsigned char max_config = 0x40; /* Codec enable */ |
| |
| if (gus_dma2 == -1) |
| gus_dma2 = gus_dma; |
| |
| if (gus_dma > 3) |
| max_config |= 0x10; /* 16 bit capture DMA */ |
| |
| if (gus_dma2 > 3) |
| max_config |= 0x20; /* 16 bit playback DMA */ |
| |
| max_config |= (gus_base >> 4) & 0x0f; /* Extract the X from 2X0 */ |
| |
| outb((max_config), gus_base + 0x106); /* UltraMax control */ |
| } |
| |
| if (!ports) |
| goto no_cs4231; |
| |
| if (ad1848_detect(ports, &ad_flags, hw_config->osp)) |
| { |
| char *name = "GUS MAX"; |
| int old_num_mixers = num_mixers; |
| |
| if (gus_pnp_flag) |
| name = "GUS PnP"; |
| |
| gus_mic_vol = gus_line_vol = gus_pcm_volume = 100; |
| gus_wave_volume = 90; |
| have_gus_max = 1; |
| if (hw_config->name) |
| name = hw_config->name; |
| |
| hw_config->slots[1] = ad1848_init(name, ports, |
| -irq, gus_dma2, /* Playback DMA */ |
| gus_dma, /* Capture DMA */ |
| 1, /* Share DMA channels with GF1 */ |
| hw_config->osp, |
| THIS_MODULE); |
| |
| if (num_mixers > old_num_mixers) |
| { |
| /* GUS has it's own mixer map */ |
| AD1848_REROUTE(SOUND_MIXER_LINE1, SOUND_MIXER_SYNTH); |
| AD1848_REROUTE(SOUND_MIXER_LINE2, SOUND_MIXER_CD); |
| AD1848_REROUTE(SOUND_MIXER_LINE3, SOUND_MIXER_LINE); |
| } |
| } |
| else { |
| release_region(gus_base + 0x10c, 4); |
| no_cs4231: |
| printk(KERN_WARNING "GUS: No CS4231 ??"); |
| } |
| #else |
| printk(KERN_ERR "GUS MAX found, but not compiled in\n"); |
| #endif |
| } |
| } |
| else |
| { |
| /* |
| * ASIC not detected so the card must be 2.2 or 2.4. |
| * There could still be the 16-bit/mixer daughter card. |
| */ |
| } |
| |
| if (hw_config->name) |
| snprintf(tmp, sizeof(tmp), "%s (%dk)", hw_config->name, |
| (int) gus_mem_size / 1024); |
| else if (gus_pnp_flag) |
| snprintf(tmp, sizeof(tmp), "Gravis UltraSound PnP (%dk)", |
| (int) gus_mem_size / 1024); |
| else |
| snprintf(tmp, sizeof(tmp), "Gravis UltraSound %s (%dk)", model_num, |
| (int) gus_mem_size / 1024); |
| |
| |
| samples = (struct patch_info *)vmalloc((MAX_SAMPLE + 1) * sizeof(*samples)); |
| if (samples == NULL) |
| { |
| printk(KERN_WARNING "gus_init: Cant allocate memory for instrument tables\n"); |
| return; |
| } |
| conf_printf(tmp, hw_config); |
| strlcpy(gus_info.name, tmp, sizeof(gus_info.name)); |
| |
| if ((sdev = sound_alloc_synthdev()) == -1) |
| printk(KERN_WARNING "gus_init: Too many synthesizers\n"); |
| else |
| { |
| voice_alloc = &guswave_operations.alloc; |
| if (iw_mode) |
| guswave_operations.id = "IWAVE"; |
| hw_config->slots[0] = sdev; |
| synth_devs[sdev] = &guswave_operations; |
| sequencer_init(); |
| gus_tmr_install(gus_base + 8); |
| } |
| |
| reset_sample_memory(); |
| |
| gus_initialize(); |
| |
| if ((gus_mem_size > 0) && !gus_no_wave_dma) |
| { |
| hw_config->slots[4] = -1; |
| if ((gus_devnum = sound_install_audiodrv(AUDIO_DRIVER_VERSION, |
| "Ultrasound", |
| &gus_audio_driver, |
| sizeof(struct audio_driver), |
| NEEDS_RESTART | |
| ((!iw_mode && dma2 != dma && dma2 != -1) ? |
| DMA_DUPLEX : 0), |
| AFMT_U8 | AFMT_S16_LE, |
| NULL, dma, dma2)) < 0) |
| { |
| return; |
| } |
| |
| hw_config->slots[4] = gus_devnum; |
| audio_devs[gus_devnum]->min_fragment = 9; /* 512k */ |
| audio_devs[gus_devnum]-> |