Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 398 insertions, 0 deletions

diff --git a/sound/oss/emu10k1/voicemgr.c b/sound/oss/emu10k1/voicemgr.c
new file mode 100644
index 000000000000..d88b602c07c2
--- /dev/null
+++ b/sound/oss/emu10k1/voicemgr.c
@@ -0,0 +1,398 @@
+/*
+ **********************************************************************
+ *     voicemgr.c - Voice manager for emu10k1 driver
+ *     Copyright 1999, 2000 Creative Labs, Inc.
+ *
+ **********************************************************************
+ *
+ *     Date                 Author          Summary of changes
+ *     ----                 ------          ------------------
+ *     October 20, 1999     Bertrand Lee    base code release
+ *
+ **********************************************************************
+ *
+ *     This program is free software; you can redistribute it and/or
+ *     modify it under the terms of the GNU General Public License as
+ *     published by the Free Software Foundation; either version 2 of
+ *     the License, or (at your option) any later version.
+ *
+ *     This program is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public
+ *     License along with this program; if not, write to the Free
+ *     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
+ *     USA.
+ *
+ **********************************************************************
+ */
+
+#include "voicemgr.h"
+#include "8010.h"
+
+#define PITCH_48000 0x00004000
+#define PITCH_96000 0x00008000
+#define PITCH_85000 0x00007155
+#define PITCH_80726 0x00006ba2
+#define PITCH_67882 0x00005a82
+#define PITCH_57081 0x00004c1c
+
+static u32 emu10k1_select_interprom(struct emu10k1_card *card,
+                                    struct emu_voice *voice)
+{
+        if(voice->pitch_target==PITCH_48000)
+                return CCCA_INTERPROM_0;
+        else if(voice->pitch_target<PITCH_48000)
+                return CCCA_INTERPROM_1;
+        else  if(voice->pitch_target>=PITCH_96000)
+                return CCCA_INTERPROM_0;
+        else  if(voice->pitch_target>=PITCH_85000)
+                return CCCA_INTERPROM_6;
+        else  if(voice->pitch_target>=PITCH_80726)
+                return CCCA_INTERPROM_5;
+        else  if(voice->pitch_target>=PITCH_67882)
+                return CCCA_INTERPROM_4;
+        else  if(voice->pitch_target>=PITCH_57081)
+                return CCCA_INTERPROM_3;
+        else  
+                return CCCA_INTERPROM_2;
+}
+
+
+/**
+ * emu10k1_voice_alloc_buffer -
+ *
+ * allocates the memory buffer for a voice. Two page tables are kept for each buffer.
+ * One (dma_handle) keeps track of the host memory pages used and the other (virtualpagetable)
+ * is passed to the device so that it can do DMA to host memory.
+ *
+ */
+int emu10k1_voice_alloc_buffer(struct emu10k1_card *card, struct voice_mem *mem, u32 pages)
+{
+        u32 pageindex, pagecount;
+        u32 busaddx;
+        int i;
+
+        DPD(2, "requested pages is: %d\n", pages);
+
+        if ((mem->emupageindex = emu10k1_addxmgr_alloc(pages * PAGE_SIZE, card)) < 0)
+        {
+                DPF(1, "couldn't allocate emu10k1 address space\n");
+                return -1;
+        }
+
+        /* Fill in virtual memory table */
+        for (pagecount = 0; pagecount < pages; pagecount++) {
+                if ((mem->addr[pagecount] = pci_alloc_consistent(card->pci_dev, PAGE_SIZE, &mem->dma_handle[pagecount]))
+                        == NULL) {
+                        mem->pages = pagecount;
+                        DPF(1, "couldn't allocate dma memory\n");
+                        return -1;
+                }
+
+                DPD(2, "Virtual Addx: %p\n", mem->addr[pagecount]);
+
+                for (i = 0; i < PAGE_SIZE / EMUPAGESIZE; i++) {
+                        busaddx = (u32) mem->dma_handle[pagecount] + i * EMUPAGESIZE;
+
+                        DPD(3, "Bus Addx: %#x\n", busaddx);
+
+                        pageindex = mem->emupageindex + pagecount * PAGE_SIZE / EMUPAGESIZE + i;
+
+                        ((u32 *) card->virtualpagetable.addr)[pageindex] = cpu_to_le32((busaddx * 2) | pageindex);
+                }
+        }
+
+        mem->pages = pagecount;
+
+        return 0;
+}
+
+/**
+ * emu10k1_voice_free_buffer -
+ *
+ * frees the memory buffer for a voice.
+ */
+void emu10k1_voice_free_buffer(struct emu10k1_card *card, struct voice_mem *mem)
+{
+        u32 pagecount, pageindex;
+        int i;
+
+        if (mem->emupageindex < 0)
+                return;
+
+        for (pagecount = 0; pagecount < mem->pages; pagecount++) {
+                pci_free_consistent(card->pci_dev, PAGE_SIZE,
+                                        mem->addr[pagecount],
+                                        mem->dma_handle[pagecount]);
+
+                for (i = 0; i < PAGE_SIZE / EMUPAGESIZE; i++) {
+                        pageindex = mem->emupageindex + pagecount * PAGE_SIZE / EMUPAGESIZE + i;
+                        ((u32 *) card->virtualpagetable.addr)[pageindex] =
+                                cpu_to_le32(((u32) card->silentpage.dma_handle * 2) | pageindex);
+                }
+        }
+
+        emu10k1_addxmgr_free(card, mem->emupageindex);
+        mem->emupageindex = -1;
+}
+
+int emu10k1_voice_alloc(struct emu10k1_card *card, struct emu_voice *voice)
+{
+        u8 *voicetable = card->voicetable;
+        int i;
+        unsigned long flags;
+
+        DPF(2, "emu10k1_voice_alloc()\n");
+
+        spin_lock_irqsave(&card->lock, flags);
+
+        if (voice->flags & VOICE_FLAGS_STEREO) {
+                for (i = 0; i < NUM_G; i += 2)
+                        if ((voicetable[i] == VOICE_USAGE_FREE) && (voicetable[i + 1] == VOICE_USAGE_FREE)) {
+                                voicetable[i] = voice->usage;
+                                voicetable[i + 1] = voice->usage;
+                                break;
+                        }
+        } else {
+                for (i = 0; i < NUM_G; i++)
+                        if (voicetable[i] == VOICE_USAGE_FREE) {
+                                voicetable[i] = voice->usage;
+                                break;
+                        }
+        }
+
+        spin_unlock_irqrestore(&card->lock, flags);
+
+        if (i >= NUM_G)
+                return -1;
+
+        voice->card = card;
+        voice->num = i;
+
+        for (i = 0; i < (voice->flags & VOICE_FLAGS_STEREO ? 2 : 1); i++) {
+                DPD(2, " voice allocated -> %d\n", voice->num + i);
+
+                sblive_writeptr_tag(card, voice->num + i, IFATN, 0xffff,
+                                                        DCYSUSV, 0,
+                                                        VTFT, 0x0000ffff,
+                                                        PTRX, 0,
+                                                        TAGLIST_END);
+        }
+
+        return 0;
+}
+
+void emu10k1_voice_free(struct emu_voice *voice)
+{
+        struct emu10k1_card *card = voice->card;
+        int i;
+        unsigned long flags;
+
+        DPF(2, "emu10k1_voice_free()\n");
+
+        if (voice->usage == VOICE_USAGE_FREE)
+                return;
+
+        for (i = 0; i < (voice->flags & VOICE_FLAGS_STEREO ? 2 : 1); i++) {
+                DPD(2, " voice released -> %d\n", voice->num + i);
+
+                sblive_writeptr_tag(card, voice->num + i, DCYSUSV, 0, 
+                                                        VTFT, 0x0000ffff,
+                                                        PTRX_PITCHTARGET, 0,
+                                                        CVCF, 0x0000ffff,
+                                                        //CPF, 0,
+                                                        TAGLIST_END);
+                
+                sblive_writeptr(card, CPF, voice->num + i, 0);
+        }
+
+        voice->usage = VOICE_USAGE_FREE;
+
+        spin_lock_irqsave(&card->lock, flags);
+
+        card->voicetable[voice->num] = VOICE_USAGE_FREE;
+
+        if (voice->flags & VOICE_FLAGS_STEREO)
+                card->voicetable[voice->num + 1] = VOICE_USAGE_FREE;
+
+        spin_unlock_irqrestore(&card->lock, flags);
+}
+
+void emu10k1_voice_playback_setup(struct emu_voice *voice)
+{
+        struct emu10k1_card *card = voice->card;
+        u32 start;
+        int i;
+
+        DPF(2, "emu10k1_voice_playback_setup()\n");
+
+        if (voice->flags & VOICE_FLAGS_STEREO) {
+                /* Set stereo bit */
+                start = 28;
+                sblive_writeptr(card, CPF, voice->num, CPF_STEREO_MASK);
+                sblive_writeptr(card, CPF, voice->num + 1, CPF_STEREO_MASK);
+        } else {
+                start = 30;
+                sblive_writeptr(card, CPF, voice->num, 0);
+        }
+
+        if(!(voice->flags & VOICE_FLAGS_16BIT))
+                start *= 2;
+
+        voice->start += start;
+
+        for (i = 0; i < (voice->flags & VOICE_FLAGS_STEREO ? 2 : 1); i++) {
+                if (card->is_audigy) {
+                        sblive_writeptr(card, A_FXRT1, voice->num + i, voice->params[i].send_routing);
+                        sblive_writeptr(card, A_FXRT2, voice->num + i, voice->params[i].send_routing2);
+                        sblive_writeptr(card,  A_SENDAMOUNTS, voice->num + i, voice->params[i].send_hgfe);
+                } else {
+                        sblive_writeptr(card, FXRT, voice->num + i, voice->params[i].send_routing << 16);
+                }
+
+                /* Stop CA */
+                /* Assumption that PT is already 0 so no harm overwriting */
+                sblive_writeptr(card, PTRX, voice->num + i, ((voice->params[i].send_dcba & 0xff) << 8)
+                                | ((voice->params[i].send_dcba & 0xff00) >> 8));
+
+                sblive_writeptr_tag(card, voice->num + i,
+                                /* CSL, ST, CA */
+                                    DSL, voice->endloop | (voice->params[i].send_dcba & 0xff000000),
+                                    PSST, voice->startloop | ((voice->params[i].send_dcba & 0x00ff0000) << 8),
+                                    CCCA, (voice->start) |  emu10k1_select_interprom(card,voice) |
+                                        ((voice->flags & VOICE_FLAGS_16BIT) ? 0 : CCCA_8BITSELECT),
+                                    /* Clear filter delay memory */
+                                    Z1, 0,
+                                    Z2, 0,
+                                    /* Invalidate maps */
+                                    MAPA, MAP_PTI_MASK | ((u32) card->silentpage.dma_handle * 2),
+                                    MAPB, MAP_PTI_MASK | ((u32) card->silentpage.dma_handle * 2),
+                                /* modulation envelope */
+                                    CVCF, 0x0000ffff,
+                                    VTFT, 0x0000ffff,
+                                    ATKHLDM, 0,
+                                    DCYSUSM, 0x007f,
+                                    LFOVAL1, 0x8000,
+                                    LFOVAL2, 0x8000,
+                                    FMMOD, 0,
+                                    TREMFRQ, 0,
+                                    FM2FRQ2, 0,
+                                    ENVVAL, 0x8000,
+                                /* volume envelope */
+                                    ATKHLDV, 0x7f7f,
+                                    ENVVOL, 0x8000,
+                                /* filter envelope */
+                                    PEFE_FILTERAMOUNT, 0x7f,
+                                /* pitch envelope */
+                                    PEFE_PITCHAMOUNT, 0, TAGLIST_END);
+
+                voice->params[i].fc_target = 0xffff;
+        }
+}
+
+void emu10k1_voices_start(struct emu_voice *first_voice, unsigned int num_voices, int set)
+{
+        struct emu10k1_card *card = first_voice->card;
+        struct emu_voice *voice;
+        unsigned int voicenum;
+        int j;
+
+        DPF(2, "emu10k1_voices_start()\n");
+
+        for (voicenum = 0; voicenum < num_voices; voicenum++)
+        {
+                voice = first_voice + voicenum;
+
+                if (!set) {
+                        u32 cra, ccis, cs, sample;
+                        if (voice->flags & VOICE_FLAGS_STEREO) {
+                                cra = 64;
+                                ccis = 28;
+                                cs = 4;
+                        } else {
+                                cra = 64;
+                                ccis = 30;
+                                cs = 2;
+                        }
+
+                        if(voice->flags & VOICE_FLAGS_16BIT) {
+                                sample = 0x00000000;
+                        } else {
+                                sample = 0x80808080;            
+                                ccis *= 2;
+                        }
+
+                        for(j = 0; j < cs; j++)
+                                sblive_writeptr(card, CD0 + j, voice->num, sample);
+
+                        /* Reset cache */
+                        sblive_writeptr(card, CCR_CACHEINVALIDSIZE, voice->num, 0);
+                        if (voice->flags & VOICE_FLAGS_STEREO)
+                                sblive_writeptr(card, CCR_CACHEINVALIDSIZE, voice->num + 1, 0);
+
+                        sblive_writeptr(card, CCR_READADDRESS, voice->num, cra);
+
+                        if (voice->flags & VOICE_FLAGS_STEREO)
+                                sblive_writeptr(card, CCR_READADDRESS, voice->num + 1, cra);
+
+                        /* Fill cache */
+                        sblive_writeptr(card, CCR_CACHEINVALIDSIZE, voice->num, ccis);
+                }
+
+                for (j = 0; j < (voice->flags & VOICE_FLAGS_STEREO ? 2 : 1); j++) {
+                        sblive_writeptr_tag(card, voice->num + j,
+                                    IFATN, (voice->params[j].initial_fc << 8) | voice->params[j].initial_attn,
+                                    VTFT, (voice->params[j].volume_target << 16) | voice->params[j].fc_target,
+                                    CVCF, (voice->params[j].volume_target << 16) | voice->params[j].fc_target,
+                                    DCYSUSV, (voice->params[j].byampl_env_sustain << 8) | voice->params[j].byampl_env_decay,
+                                    TAGLIST_END);
+        
+                        emu10k1_clear_stop_on_loop(card, voice->num + j);
+                }
+        }
+
+
+        for (voicenum = 0; voicenum < num_voices; voicenum++)
+        {
+                voice = first_voice + voicenum;
+
+                for (j = 0; j < (voice->flags & VOICE_FLAGS_STEREO ? 2 : 1); j++) {
+                        sblive_writeptr(card, PTRX_PITCHTARGET, voice->num + j, voice->pitch_target);
+
+                        if (j == 0)
+                                sblive_writeptr(card, CPF_CURRENTPITCH, voice->num, voice->pitch_target);
+
+                        sblive_writeptr(card, IP, voice->num + j, voice->initial_pitch);
+                }
+        }
+}
+
+void emu10k1_voices_stop(struct emu_voice *first_voice, int num_voices)
+{
+        struct emu10k1_card *card = first_voice->card;
+        struct emu_voice *voice;
+        unsigned int voice_num;
+        int j;
+
+        DPF(2, "emu10k1_voice_stop()\n");
+
+        for (voice_num = 0; voice_num < num_voices; voice_num++)
+        {
+                voice = first_voice + voice_num;
+
+                for (j = 0; j < (voice->flags & VOICE_FLAGS_STEREO ? 2 : 1); j++) {
+                        sblive_writeptr_tag(card, voice->num + j,
+                                                PTRX_PITCHTARGET, 0,
+                                                CPF_CURRENTPITCH, 0,
+                                                IFATN, 0xffff,
+                                                VTFT, 0x0000ffff,
+                                                CVCF, 0x0000ffff,
+                                                IP, 0,
+                                                TAGLIST_END);
+                }
+        }
+}
+