/**
* 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;
unsigned long 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 */
if ((mem->addr = pci_alloc_consistent(card->pci_dev, pages * PAGE_SIZE, &mem->dma_handle))
== NULL) {
mem->pages = 0;
DPF(1, "couldn't allocate dma memory\n");
return -1;
}
for (pagecount = 0; pagecount < pages; pagecount++) {
DPD(2, "Virtual Addx: %p\n", mem->addr + pagecount * PAGE_SIZE);
for (i = 0; i < PAGE_SIZE / EMUPAGESIZE; i++) {
busaddx = (u32) pci_logic_to_physic_addr(
mem->addr + pagecount * PAGE_SIZE, card->pci_dev )
+ i * EMUPAGESIZE;
DPD(3, "Bus Addx: %#lx\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;
}
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);
}
int emu10k1_mpuin_start(struct emu10k1_card *card)
{
struct emu10k1_mpuin *card_mpuin = card->mpuin;
u8 dummy;
DPF(2, "emu10k1_mpuin_start()\n");
/* Set timestamp if not set */
if (card_mpuin->status & FLAGS_MIDM_STARTED) {
DPF(2, "Time Stamp not changed\n");
} else {
while (!emu10k1_mpu_read_data(card, &dummy));
card_mpuin->status |= FLAGS_MIDM_STARTED; /* set */
/* Set new time stamp */
card_mpuin->timestart = (jiffies * 1000) / HZ;
DPD(2, "New Time Stamp = %d\n", card_mpuin->timestart);
card_mpuin->qhead = 0;
card_mpuin->qtail = 0;
emu10k1_irq_enable(card, card->is_audigy ? A_INTE_MIDIRXENABLE : INTE_MIDIRXENABLE);
}
return 0;
}
int emu10k1_init(struct emu10k1_card *card)
{
/* Init Card */
if (hw_init(card) < 0)
return -1;
voice_init(card);
addxmgr_init(card);
DPD(2, " hw control register -> %#x\n", emu10k1_readfn0(card, HCFG));
return 0;
}
static int __devinit emu10k1_init(struct emu10k1_card *card)
{
/* Init Card */
if (hw_init(card) != CTSTATUS_SUCCESS)
return CTSTATUS_ERROR;
voice_init(card);
timer_init(card);
addxmgr_init(card);
DPD(2, " hw control register -> %x\n", sblive_readfn0(card, HCFG));
return CTSTATUS_SUCCESS;
}
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;
}
int emu10k1_pt_setup(struct emu10k1_wavedevice *wave_dev)
{
u32 bits;
struct emu10k1_card *card = wave_dev->card;
struct pt_data *pt = &card->pt;
int i;
for (i = 0; i < 3; i++) {
pt->old_spcs[i] = sblive_readptr(card, SPCS0 + i, 0);
if (pt->spcs_to_use & (1 << i)) {
DPD(2, "using S/PDIF port %d\n", i);
bits = SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | SPCS_GENERATIONSTATUS |
0x00001200 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT;
if (pt->ac3data)
bits |= SPCS_NOTAUDIODATA;
sblive_writeptr(card, SPCS0 + i, 0, bits);
}
}
return 0;
}
/* via IRQ & DPC callbacks to Ring 3 */
static int emu10k1_mpuin_callback(struct emu10k1_mpuin *card_mpuin, u32 msg, unsigned long data, u32 bytesvalid)
{
unsigned long timein;
struct midi_queue *midiq;
unsigned long callback_msg[3];
struct midi_hdr *midihdr;
/* Called during ISR. The data & code touched are:
* 1. card_mpuin
* 2. The function to be called
*/
timein = card_mpuin->timein;
if (card_mpuin->timestart <= timein)
callback_msg[0] = timein - card_mpuin->timestart;
else
callback_msg[0] = (~0x0L - card_mpuin->timestart) + timein;
if (msg == ICARDMIDI_INDATA || msg == ICARDMIDI_INDATAERROR) {
callback_msg[1] = data;
callback_msg[2] = bytesvalid;
DPD(2, "emu10k1_mpuin_callback: midimsg = %#lx\n", data);
} else {
midiq = (struct midi_queue *) data;
midihdr = (struct midi_hdr *) midiq->refdata;
callback_msg[1] = midiq->length - midiq->sizeLeft;
callback_msg[2] = midiq->refdata;
midihdr->flags &= ~MIDIBUF_INQUEUE;
midihdr->flags |= MIDIBUF_DONE;
midihdr->bytesrecorded = midiq->length - midiq->sizeLeft;
}
/* Notify client that Sysex buffer has been sent */
emu10k1_midi_callback(msg, card_mpuin->openinfo.refdata, callback_msg);
return 0;
}
ssize_t emu10k1_pt_write(struct file *file, const char __user *buffer, size_t count)
{
struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
struct emu10k1_card *card = wave_dev->card;
struct pt_data *pt = &card->pt;
int nonblock, i, r, blocks, blocks_copied, bytes_copied = 0;
DPD(3, "emu10k1_pt_write(): %d bytes\n", count);
nonblock = file->f_flags & O_NONBLOCK;
if (card->tankmem.size < PT_SAMPLES*2)
return -EFAULT;
if (pt->state == PT_STATE_INACTIVE) {
DPF(2, "bufptr init\n");
pt->playptr = PT_SAMPLES-1;
pt->copyptr = PT_INITPTR;
pt->blocks_played = pt->blocks_copied = 0;
memset(card->tankmem.addr, 0, card->tankmem.size);
pt->state = PT_STATE_ACTIVATED;
pt->buf = kmalloc(PT_BLOCKSIZE, GFP_KERNEL);
pt->prepend_size = 0;
if (pt->buf == NULL)
return -ENOMEM;
emu10k1_pt_setup(wave_dev);
}
if (pt->prepend_size) {
int needed = PT_BLOCKSIZE - pt->prepend_size;
DPD(3, "prepend size %d, prepending %d bytes\n", pt->prepend_size, needed);
if (count < needed) {
if (copy_from_user(pt->buf + pt->prepend_size,
buffer, count))
return -EFAULT;
pt->prepend_size += count;
DPD(3, "prepend size now %d\n", pt->prepend_size);
return count;
}
if (copy_from_user(pt->buf + pt->prepend_size, buffer, needed))
return -EFAULT;
r = pt_putblock(wave_dev, (u16 *) pt->buf, nonblock);
if (r)
return r;
bytes_copied += needed;
pt->prepend_size = 0;
}
blocks = (count-bytes_copied)/PT_BLOCKSIZE;
blocks_copied = 0;
while (blocks > 0) {
u16 __user *bufptr = (u16 __user *) buffer + (bytes_copied/2);
if (copy_from_user(pt->buf, bufptr, PT_BLOCKSIZE))
return -EFAULT;
r = pt_putblock(wave_dev, (u16 *)pt->buf, nonblock);
if (r) {
if (bytes_copied)
return bytes_copied;
else
return r;
}
bytes_copied += PT_BLOCKSIZE;
blocks--;
blocks_copied++;
}
i = count - bytes_copied;
if (i) {
pt->prepend_size = i;
if (copy_from_user(pt->buf, buffer + bytes_copied, i))
return -EFAULT;
bytes_copied += i;
DPD(3, "filling prepend buffer with %d bytes", i);
}
return bytes_copied;
}
void emu10k1_set_record_src(struct emu10k1_card *card, struct wiinst *wiinst)
{
struct wavein_buffer *buffer = &wiinst->buffer;
DPF(2, "emu10k1_set_record_src()\n");
switch (wiinst->recsrc) {
case WAVERECORD_AC97:
DPF(2, "recording source: AC97\n");
buffer->sizereg = ADCBS;
buffer->addrreg = ADCBA;
buffer->idxreg = ADCIDX_IDX;
switch (wiinst->format.samplingrate) {
case 0xBB80:
buffer->adcctl = ADCCR_SAMPLERATE_48;
break;
case 0xAC44:
buffer->adcctl = ADCCR_SAMPLERATE_44;
break;
case 0x7D00:
buffer->adcctl = ADCCR_SAMPLERATE_32;
break;
case 0x5DC0:
buffer->adcctl = ADCCR_SAMPLERATE_24;
break;
case 0x5622:
buffer->adcctl = ADCCR_SAMPLERATE_22;
break;
case 0x3E80:
buffer->adcctl = ADCCR_SAMPLERATE_16;
break;
case 0x2B11:
buffer->adcctl = ADCCR_SAMPLERATE_11;
break;
case 0x1F40:
buffer->adcctl = ADCCR_SAMPLERATE_8;
break;
default:
BUG();
break;
}
buffer->adcctl |= ADCCR_LCHANENABLE;
if (wiinst->format.channels == 2)
buffer->adcctl |= ADCCR_RCHANENABLE;
break;
case WAVERECORD_MIC:
DPF(2, "recording source: MIC\n");
buffer->sizereg = MICBS;
buffer->addrreg = MICBA;
buffer->idxreg = MICIDX_IDX;
buffer->adcctl = 0;
break;
case WAVERECORD_FX:
DPF(2, "recording source: FX\n");
buffer->sizereg = FXBS;
buffer->addrreg = FXBA;
buffer->idxreg = FXIDX_IDX;
buffer->adcctl = 0;
sblive_writeptr(card, FXWC, 0, wiinst->fxwc);
break;
default:
BUG();
break;
}
DPD(2, "bus addx: %#x\n", buffer->dma_handle);
sblive_writeptr(card, buffer->addrreg, 0, buffer->dma_handle);
return;
}
SCORE TraceBack(const ProfPos *PA, unsigned uLengthA, const ProfPos *PB,
unsigned uLengthB, const SCORE *DPM_, const SCORE *DPD_, const SCORE *DPI_,
PWPath &Path)
{
#if TRACE
Log("\n");
Log("TraceBack LengthA=%u LengthB=%u\n", uLengthA, uLengthB);
#endif
assert(uLengthB > 0 && uLengthA > 0);
const unsigned uPrefixCountA = uLengthA + 1;
const unsigned uPrefixCountB = uLengthB + 1;
Path.Clear();
unsigned uPrefixLengthA = uLengthA;
unsigned uPrefixLengthB = uLengthB;
const SCORE scoreM = DPM(uPrefixLengthA, uPrefixLengthB);
SCORE scoreD = DPD(uPrefixLengthA, uPrefixLengthB);
SCORE scoreI = DPI(uPrefixLengthA, uPrefixLengthB);
const ProfPos &LastPPA = PA[uLengthA - 1];
const ProfPos &LastPPB = PB[uLengthB - 1];
scoreD += LastPPA.m_scoreGapClose;
scoreI += LastPPB.m_scoreGapClose;
char cEdgeType = cInsane;
SCORE scoreMax;
if (scoreM >= scoreD && scoreM >= scoreI)
{
scoreMax = scoreM;
cEdgeType = 'M';
}
else if (scoreD >= scoreM && scoreD >= scoreI)
{
scoreMax = scoreD;
cEdgeType = 'D';
}
else
{
assert(scoreI >= scoreM && scoreI >= scoreD);
scoreMax = scoreI;
cEdgeType = 'I';
}
for (;;)
{
if ('S' == cEdgeType)
break;
PWEdge Edge;
Edge.cType = cEdgeType;
Edge.uPrefixLengthA = uPrefixLengthA;
Edge.uPrefixLengthB = uPrefixLengthB;
Path.PrependEdge(Edge);
char cPrevEdgeType;
unsigned uPrevPrefixLengthA = uPrefixLengthA;
unsigned uPrevPrefixLengthB = uPrefixLengthB;
switch (cEdgeType)
{
case 'M':
{
assert(uPrefixLengthA > 0);
assert(uPrefixLengthB > 0);
const ProfPos &PPA = PA[uPrefixLengthA - 1];
const ProfPos &PPB = PB[uPrefixLengthB - 1];
const SCORE Score = DPM(uPrefixLengthA, uPrefixLengthB);
const SCORE scoreMatch = ScoreProfPos2(PPA, PPB);
SCORE scoreSM;
if (1 == uPrefixLengthA && 1 == uPrefixLengthB)
scoreSM = scoreMatch;
else
scoreSM = MINUS_INFINITY;
SCORE scoreMM = MINUS_INFINITY;
SCORE scoreDM = MINUS_INFINITY;
SCORE scoreIM = MINUS_INFINITY;
if (uPrefixLengthA > 1 && uPrefixLengthB > 1)
scoreMM = DPM(uPrefixLengthA-1, uPrefixLengthB-1) + scoreMatch;
if (uPrefixLengthA > 1)
{
SCORE scoreTransDM = PA[uPrefixLengthA-2].m_scoreGapClose;
scoreDM = DPD(uPrefixLengthA-1, uPrefixLengthB-1) + scoreTransDM + scoreMatch;
}
if (uPrefixLengthB > 1)
{
SCORE scoreTransIM = PB[uPrefixLengthB-2].m_scoreGapClose;
scoreIM = DPI(uPrefixLengthA-1, uPrefixLengthB-1) + scoreTransIM + scoreMatch;
}
if (EQ(scoreMM, Score))
cPrevEdgeType = 'M';
else if (EQ(scoreDM, Score))
cPrevEdgeType = 'D';
else if (EQ(scoreIM, Score))
cPrevEdgeType = 'I';
else if (EQ(scoreSM, Score))
cPrevEdgeType = 'S';
else
Quit("TraceBack: failed to match M score=%g M=%g D=%g I=%g S=%g",
Score, scoreMM, scoreDM, scoreIM, scoreSM);
--uPrevPrefixLengthA;
--uPrevPrefixLengthB;
break;
}
case 'D':
{
assert(uPrefixLengthA > 0);
const SCORE Score = DPD(uPrefixLengthA, uPrefixLengthB);
SCORE scoreMD = MINUS_INFINITY;
SCORE scoreDD = MINUS_INFINITY;
SCORE scoreSD = MINUS_INFINITY;
if (uPrefixLengthB == 0)
{
if (uPrefixLengthA == 1)
scoreSD = PA[0].m_scoreGapOpen;
else
scoreSD = DPD(uPrefixLengthA - 1, 0);
}
if (uPrefixLengthA > 1)
{
const ProfPos &PPA = PA[uPrefixLengthA - 1];
SCORE scoreTransMD = PPA.m_scoreGapOpen;
scoreMD = DPM(uPrefixLengthA-1, uPrefixLengthB) + scoreTransMD;
scoreDD = DPD(uPrefixLengthA-1, uPrefixLengthB);
}
if (EQ(Score, scoreMD))
cPrevEdgeType = 'M';
else if (EQ(Score, scoreDD))
cPrevEdgeType = 'D';
else if (EQ(Score, scoreSD))
cPrevEdgeType = 'S';
else
Quit("TraceBack: failed to match D");
--uPrevPrefixLengthA;
break;
}
case 'I':
{
assert(uPrefixLengthB > 0);
const SCORE Score = DPI(uPrefixLengthA, uPrefixLengthB);
SCORE scoreMI = MINUS_INFINITY;
SCORE scoreII = MINUS_INFINITY;
SCORE scoreSI = MINUS_INFINITY;
if (uPrefixLengthA == 0)
{
if (uPrefixLengthB == 1)
scoreSI = PB[0].m_scoreGapOpen;
else
scoreSI = DPI(0, uPrefixLengthB - 1);
}
if (uPrefixLengthB > 1)
{
const ProfPos &PPB = PB[uPrefixLengthB - 1];
SCORE scoreTransMI = PPB.m_scoreGapOpen;
scoreMI = DPM(uPrefixLengthA, uPrefixLengthB-1) + scoreTransMI;
scoreII = DPI(uPrefixLengthA, uPrefixLengthB-1);
}
if (EQ(Score, scoreMI))
cPrevEdgeType = 'M';
else if (EQ(Score, scoreII))
cPrevEdgeType = 'I';
else if (EQ(Score, scoreSI))
cPrevEdgeType = 'S';
else
Quit("TraceBack: failed to match I");
--uPrevPrefixLengthB;
break;
}
default:
assert(false);
}
#if TRACE
Log("Edge %c%c%u.%u", cPrevEdgeType, cEdgeType, uPrefixLengthA, uPrefixLengthB);
Log("\n");
#endif
cEdgeType = cPrevEdgeType;
uPrefixLengthA = uPrevPrefixLengthA;
uPrefixLengthB = uPrevPrefixLengthB;
}
return scoreMax;
}
SCORE NWDASimple(const ProfPos *PA, unsigned uLengthA, const ProfPos *PB,
unsigned uLengthB, PWPath &Path)
{
assert(uLengthB > 0 && uLengthA > 0);
const unsigned uPrefixCountA = uLengthA + 1;
const unsigned uPrefixCountB = uLengthB + 1;
// Allocate DP matrices
const size_t LM = uPrefixCountA*uPrefixCountB;
SCORE *DPL_ = new SCORE[LM];
SCORE *DPM_ = new SCORE[LM];
SCORE *DPD_ = new SCORE[LM];
SCORE *DPE_ = new SCORE[LM];
SCORE *DPI_ = new SCORE[LM];
SCORE *DPJ_ = new SCORE[LM];
char *TBM_ = new char[LM];
char *TBD_ = new char[LM];
char *TBE_ = new char[LM];
char *TBI_ = new char[LM];
char *TBJ_ = new char[LM];
memset(TBM_, '?', LM);
memset(TBD_, '?', LM);
memset(TBE_, '?', LM);
memset(TBI_, '?', LM);
memset(TBJ_, '?', LM);
DPM(0, 0) = 0;
DPD(0, 0) = MINUS_INFINITY;
DPE(0, 0) = MINUS_INFINITY;
DPI(0, 0) = MINUS_INFINITY;
DPJ(0, 0) = MINUS_INFINITY;
DPM(1, 0) = MINUS_INFINITY;
DPD(1, 0) = PA[0].m_scoreGapOpen;
DPE(1, 0) = PA[0].m_scoreGapOpen2;
TBD(1, 0) = 'D';
TBE(1, 0) = 'E';
DPI(1, 0) = MINUS_INFINITY;
DPJ(1, 0) = MINUS_INFINITY;
DPM(0, 1) = MINUS_INFINITY;
DPD(0, 1) = MINUS_INFINITY;
DPE(0, 1) = MINUS_INFINITY;
DPI(0, 1) = PB[0].m_scoreGapOpen;
DPJ(0, 1) = PB[0].m_scoreGapOpen2;
TBI(0, 1) = 'I';
TBJ(0, 1) = 'J';
// Empty prefix of B is special case
for (unsigned uPrefixLengthA = 2; uPrefixLengthA < uPrefixCountA; ++uPrefixLengthA)
{
DPM(uPrefixLengthA, 0) = MINUS_INFINITY;
DPD(uPrefixLengthA, 0) = DPD(uPrefixLengthA - 1, 0) + g_scoreGapExtend.get();
DPE(uPrefixLengthA, 0) = DPE(uPrefixLengthA - 1, 0) + g_scoreGapExtend2.get();
TBD(uPrefixLengthA, 0) = 'D';
TBE(uPrefixLengthA, 0) = 'E';
DPI(uPrefixLengthA, 0) = MINUS_INFINITY;
DPJ(uPrefixLengthA, 0) = MINUS_INFINITY;
}
// Empty prefix of A is special case
for (unsigned uPrefixLengthB = 2; uPrefixLengthB < uPrefixCountB; ++uPrefixLengthB)
{
DPM(0, uPrefixLengthB) = MINUS_INFINITY;
DPD(0, uPrefixLengthB) = MINUS_INFINITY;
DPE(0, uPrefixLengthB) = MINUS_INFINITY;
DPI(0, uPrefixLengthB) = DPI(0, uPrefixLengthB - 1) + g_scoreGapExtend.get();
DPJ(0, uPrefixLengthB) = DPJ(0, uPrefixLengthB - 1) + g_scoreGapExtend2.get();
TBI(0, uPrefixLengthB) = 'I';
TBJ(0, uPrefixLengthB) = 'J';
}
// Special case to agree with NWFast, no D-I transitions so...
DPD(uLengthA, 0) = MINUS_INFINITY;
DPE(uLengthA, 0) = MINUS_INFINITY;
// DPI(0, uLengthB) = MINUS_INFINITY;
// DPJ(0, uLengthB) = MINUS_INFINITY;
// ============
// Main DP loop
// ============
SCORE scoreGapCloseB = MINUS_INFINITY;
SCORE scoreGapClose2B = MINUS_INFINITY;
for (unsigned uPrefixLengthB = 1; uPrefixLengthB < uPrefixCountB; ++uPrefixLengthB)
{
const ProfPos &PPB = PB[uPrefixLengthB - 1];
SCORE scoreGapCloseA = MINUS_INFINITY;
SCORE scoreGapClose2A = MINUS_INFINITY;
for (unsigned uPrefixLengthA = 1; uPrefixLengthA < uPrefixCountA; ++uPrefixLengthA)
{
const ProfPos &PPA = PA[uPrefixLengthA - 1];
{
// Match M=LetterA+LetterB
SCORE scoreLL = ScoreProfPos2(PPA, PPB);
DPL(uPrefixLengthA, uPrefixLengthB) = scoreLL;
SCORE scoreMM = DPM(uPrefixLengthA-1, uPrefixLengthB-1);
SCORE scoreDM = DPD(uPrefixLengthA-1, uPrefixLengthB-1) + scoreGapCloseA;
SCORE scoreEM = DPE(uPrefixLengthA-1, uPrefixLengthB-1) + scoreGapClose2A;
SCORE scoreIM = DPI(uPrefixLengthA-1, uPrefixLengthB-1) + scoreGapCloseB;
SCORE scoreJM = DPJ(uPrefixLengthA-1, uPrefixLengthB-1) + scoreGapClose2B;
SCORE scoreBest;
if (scoreMM >= scoreDM && scoreMM >= scoreEM && scoreMM >= scoreIM && scoreMM >= scoreJM)
{
scoreBest = scoreMM;
TBM(uPrefixLengthA, uPrefixLengthB) = 'M';
}
else if (scoreDM >= scoreMM && scoreDM >= scoreEM && scoreDM >= scoreIM && scoreDM >= scoreJM)
{
scoreBest = scoreDM;
TBM(uPrefixLengthA, uPrefixLengthB) = 'D';
}
else if (scoreEM >= scoreMM && scoreEM >= scoreDM && scoreEM >= scoreIM && scoreEM >= scoreJM)
{
scoreBest = scoreEM;
TBM(uPrefixLengthA, uPrefixLengthB) = 'E';
}
else if (scoreIM >= scoreMM && scoreIM >= scoreDM && scoreIM >= scoreEM && scoreIM >= scoreJM)
{
scoreBest = scoreIM;
TBM(uPrefixLengthA, uPrefixLengthB) = 'I';
}
else
{
assert(scoreJM >= scoreMM && scoreJM >= scoreDM && scoreJM >= scoreEM && scoreJM >= scoreIM);
scoreBest = scoreJM;
TBM(uPrefixLengthA, uPrefixLengthB) = 'J';
}
DPM(uPrefixLengthA, uPrefixLengthB) = scoreBest + scoreLL;
}
{
// Delete D=LetterA+GapB
SCORE scoreMD = DPM(uPrefixLengthA-1, uPrefixLengthB) +
PA[uPrefixLengthA-1].m_scoreGapOpen;
SCORE scoreDD = DPD(uPrefixLengthA-1, uPrefixLengthB) + g_scoreGapExtend.get();
SCORE scoreBest;
if (scoreMD >= scoreDD)
{
scoreBest = scoreMD;
TBD(uPrefixLengthA, uPrefixLengthB) = 'M';
}
else
{
assert(scoreDD >= scoreMD);
scoreBest = scoreDD;
TBD(uPrefixLengthA, uPrefixLengthB) = 'D';
}
DPD(uPrefixLengthA, uPrefixLengthB) = scoreBest;
}
{
// Delete E=LetterA+GapB
SCORE scoreME = DPM(uPrefixLengthA-1, uPrefixLengthB) +
PA[uPrefixLengthA-1].m_scoreGapOpen2;
SCORE scoreEE = DPE(uPrefixLengthA-1, uPrefixLengthB) + g_scoreGapExtend2.get();
SCORE scoreBest;
if (scoreME >= scoreEE)
{
scoreBest = scoreME;
TBE(uPrefixLengthA, uPrefixLengthB) = 'M';
}
else
{
assert(scoreEE >= scoreME);
scoreBest = scoreEE;
TBE(uPrefixLengthA, uPrefixLengthB) = 'E';
}
DPE(uPrefixLengthA, uPrefixLengthB) = scoreBest;
}
// Insert I=GapA+LetterB
{
SCORE scoreMI = DPM(uPrefixLengthA, uPrefixLengthB-1) +
PB[uPrefixLengthB - 1].m_scoreGapOpen;
SCORE scoreII = DPI(uPrefixLengthA, uPrefixLengthB-1) + g_scoreGapExtend.get();
SCORE scoreBest;
if (scoreMI >= scoreII)
{
scoreBest = scoreMI;
TBI(uPrefixLengthA, uPrefixLengthB) = 'M';
}
else
{
assert(scoreII > scoreMI);
scoreBest = scoreII;
TBI(uPrefixLengthA, uPrefixLengthB) = 'I';
}
DPI(uPrefixLengthA, uPrefixLengthB) = scoreBest;
}
// Insert J=GapA+LetterB
{
SCORE scoreMJ = DPM(uPrefixLengthA, uPrefixLengthB-1) +
PB[uPrefixLengthB - 1].m_scoreGapOpen2;
SCORE scoreJJ = DPJ(uPrefixLengthA, uPrefixLengthB-1) + g_scoreGapExtend2.get();
SCORE scoreBest;
if (scoreMJ >= scoreJJ)
{
scoreBest = scoreMJ;
TBJ(uPrefixLengthA, uPrefixLengthB) = 'M';
}
else
{
assert(scoreJJ > scoreMJ);
scoreBest = scoreJJ;
TBJ(uPrefixLengthA, uPrefixLengthB) = 'J';
}
DPJ(uPrefixLengthA, uPrefixLengthB) = scoreBest;
}
scoreGapCloseA = PPA.m_scoreGapClose;
scoreGapClose2A = PPA.m_scoreGapClose2;
}
scoreGapCloseB = PPB.m_scoreGapClose;
scoreGapClose2B = PPB.m_scoreGapClose2;
}
#if TRACE
Log("\n");
Log("DA Simple DPL:\n");
ListDP(DPL_, PA, PB, uPrefixCountA, uPrefixCountB);
Log("\n");
Log("DA Simple DPM:\n");
ListDP(DPM_, PA, PB, uPrefixCountA, uPrefixCountB);
Log("\n");
Log("DA Simple DPD:\n");
ListDP(DPD_, PA, PB, uPrefixCountA, uPrefixCountB);
Log("\n");
Log("DA Simple DPE:\n");
ListDP(DPE_, PA, PB, uPrefixCountA, uPrefixCountB);
Log("\n");
Log("DA Simple DPI:\n");
ListDP(DPI_, PA, PB, uPrefixCountA, uPrefixCountB);
Log("\n");
Log("DA Simple DPJ:\n");
ListDP(DPJ_, PA, PB, uPrefixCountA, uPrefixCountB);
Log("\n");
Log("DA Simple TBM:\n");
ListTB(TBM_, PA, PB, uPrefixCountA, uPrefixCountB);
Log("\n");
Log("DA Simple TBD:\n");
ListTB(TBD_, PA, PB, uPrefixCountA, uPrefixCountB);
Log("\n");
Log("DA Simple TBE:\n");
ListTB(TBE_, PA, PB, uPrefixCountA, uPrefixCountB);
Log("\n");
Log("DA Simple TBI:\n");
ListTB(TBI_, PA, PB, uPrefixCountA, uPrefixCountB);
Log("\n");
Log("DA Simple TBJ:\n");
ListTB(TBJ_, PA, PB, uPrefixCountA, uPrefixCountB);
#endif
// Trace-back
// ==========
Path.Clear();
// Find last edge
SCORE M = DPM(uLengthA, uLengthB);
SCORE D = DPD(uLengthA, uLengthB) + PA[uLengthA-1].m_scoreGapClose;
SCORE E = DPE(uLengthA, uLengthB) + PA[uLengthA-1].m_scoreGapClose2;
SCORE I = DPI(uLengthA, uLengthB) + PB[uLengthB-1].m_scoreGapClose;
SCORE J = DPJ(uLengthA, uLengthB) + PB[uLengthB-1].m_scoreGapClose2;
char cEdgeType = '?';
SCORE BestScore = M;
cEdgeType = 'M';
if (D > BestScore)
{
cEdgeType = 'D';
BestScore = D;
}
if (E > BestScore)
{
cEdgeType = 'E';
BestScore = E;
}
if (I > BestScore)
{
cEdgeType = 'I';
BestScore = I;
}
if (J > BestScore)
{
cEdgeType = 'J';
BestScore = J;
}
#if TRACE
Log("DA Simple: MAB=%.4g DAB=%.4g EAB=%.4g IAB=%.4g JAB=%.4g best=%c\n",
M, D, E, I, J, cEdgeType);
#endif
unsigned PLA = uLengthA;
unsigned PLB = uLengthB;
for (;;)
{
PWEdge Edge;
Edge.cType = XlatEdgeType(cEdgeType);
Edge.uPrefixLengthA = PLA;
Edge.uPrefixLengthB = PLB;
#if TRACE
Log("Prepend %c%d.%d\n", Edge.cType, PLA, PLB);
#endif
Path.PrependEdge(Edge);
switch (cEdgeType)
{
case 'M':
assert(PLA > 0);
assert(PLB > 0);
cEdgeType = TBM(PLA, PLB);
--PLA;
--PLB;
break;
case 'D':
assert(PLA > 0);
cEdgeType = TBD(PLA, PLB);
--PLA;
break;
case 'E':
assert(PLA > 0);
cEdgeType = TBE(PLA, PLB);
--PLA;
break;
case 'I':
assert(PLB > 0);
cEdgeType = TBI(PLA, PLB);
--PLB;
break;
case 'J':
assert(PLB > 0);
cEdgeType = TBJ(PLA, PLB);
--PLB;
break;
default:
Quit("Invalid edge %c", cEdgeType);
}
if (0 == PLA && 0 == PLB)
break;
}
Path.Validate();
// SCORE Score = TraceBack(PA, uLengthA, PB, uLengthB, DPM_, DPD_, DPI_, Path);
#if TRACE
SCORE scorePath = FastScorePath2(PA, uLengthA, PB, uLengthB, Path);
Path.LogMe();
Log("Score = %s Path = %s\n", LocalScoreToStr(BestScore), LocalScoreToStr(scorePath));
#endif
if (g_bKeepSimpleDP.get())
{
g_DPM.get() = DPM_;
g_DPD.get() = DPD_;
g_DPE.get() = DPE_;
g_DPI.get() = DPI_;
g_DPJ.get() = DPJ_;
g_TBM.get() = TBM_;
g_TBD.get() = TBD_;
g_TBE.get() = TBE_;
g_TBI.get() = TBI_;
g_TBJ.get() = TBJ_;
}
else
{
delete[] DPM_;
delete[] DPD_;
delete[] DPE_;
delete[] DPI_;
delete[] DPJ_;
delete[] TBM_;
delete[] TBD_;
delete[] TBE_;
delete[] TBI_;
delete[] TBJ_;
}
return BestScore;
}
static void __devinit mixer_init(struct emu10k1_card *card)
{
int count;
struct initvol {
int mixch;
int vol;
} initvol[] = {
{
SOUND_MIXER_VOLUME, 0x5050}, {
SOUND_MIXER_OGAIN, 0x3232}, {
SOUND_MIXER_SPEAKER, 0x3232}, {
SOUND_MIXER_PHONEIN, 0x3232}, {
SOUND_MIXER_MIC, 0x0000}, {
SOUND_MIXER_LINE, 0x0000}, {
SOUND_MIXER_CD, 0x3232}, {
SOUND_MIXER_LINE1, 0x3232}, {
SOUND_MIXER_LINE3, 0x3232}, {
SOUND_MIXER_DIGITAL1, 0x6464}, {
SOUND_MIXER_DIGITAL2, 0x6464}, {
SOUND_MIXER_PCM, 0x6464}, {
SOUND_MIXER_RECLEV, 0x3232}, {
SOUND_MIXER_TREBLE, 0x3232}, {
SOUND_MIXER_BASS, 0x3232}, {
SOUND_MIXER_LINE2, 0x4b4b}};
int initdig[] = { 0, 1, 2, 3, 6, 7, 18, 19, 20, 21, 24, 25, 72, 73, 74, 75, 78, 79,
94, 95
};
/* Reset */
sblive_writeac97(card, AC97_RESET, 0);
#if 0
/* Check status word */
{
u16 reg;
sblive_readac97(card, AC97_RESET, ®);
DPD(2, "RESET 0x%x\n", reg);
sblive_readac97(card, AC97_MASTERTONE, ®);
DPD(2, "MASTER_TONE 0x%x\n", reg);
}
#endif
/* Set default recording source to mic in */
sblive_writeac97(card, AC97_RECORDSELECT, 0);
/* Set default AC97 "PCM" volume to acceptable max */
//sblive_writeac97(card, AC97_PCMOUTVOLUME, 0);
//sblive_writeac97(card, AC97_LINE2, 0);
/* Set default volumes for all mixer channels */
for (count = 0; count < sizeof(card->digmix) / sizeof(card->digmix[0]); count++) {
card->digmix[count] = 0x80000000;
sblive_writeptr(card, FXGPREGBASE + 0x10 + count, 0, 0);
}
for (count = 0; count < sizeof(initdig) / sizeof(initdig[0]); count++) {
card->digmix[initdig[count]] = 0x7fffffff;
sblive_writeptr(card, FXGPREGBASE + 0x10 + initdig[count], 0, 0x7fffffff);
}
for (count = 0; count < sizeof(initvol) / sizeof(initvol[0]); count++) {
emu10k1_mixer_wrch(card, initvol[count].mixch, initvol[count].vol);
}
card->modcnt = 0; // Should this be here or in open() ?
return;
}
irqreturn_t emu10k1_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct emu10k1_card *card = (struct emu10k1_card *) dev_id;
u32 irqstatus, irqstatus_tmp;
int handled = 0;
DPD(4, "emu10k1_interrupt called, irq = %u\n", irq);
/*
** NOTE :
** We do a 'while loop' here cos on certain machines, with both
** playback and recording going on at the same time, IRQs will
** stop coming in after a while. Checking IPND indeed shows that
** there are interrupts pending but the PIC says no IRQs pending.
** I suspect that some boards need edge-triggered IRQs but are not
** getting that condition if we don't completely clear the IPND
** (make sure no more interrupts are pending).
** - Eric
*/
while ((irqstatus = inl(card->iobase + IPR))) {
DPD(4, "irq status %#x\n", irqstatus);
irqstatus_tmp = irqstatus;
if (irqstatus & IRQTYPE_TIMER) {
emu10k1_timer_irqhandler(card);
irqstatus &= ~IRQTYPE_TIMER;
}
if (irqstatus & IRQTYPE_DSP) {
emu10k1_dsp_irqhandler(card);
irqstatus &= ~IRQTYPE_DSP;
}
if (irqstatus & IRQTYPE_MPUIN) {
emu10k1_mpuin_irqhandler(card);
irqstatus &= ~IRQTYPE_MPUIN;
}
if (irqstatus & IRQTYPE_MPUOUT) {
emu10k1_mpuout_irqhandler(card);
irqstatus &= ~IRQTYPE_MPUOUT;
}
if (irqstatus & IPR_MUTE) {
emu10k1_mute_irqhandler(card);
irqstatus &=~IPR_MUTE;
}
if (irqstatus & IPR_VOLINCR) {
emu10k1_volincr_irqhandler(card);
irqstatus &=~IPR_VOLINCR;
}
if (irqstatus & IPR_VOLDECR) {
emu10k1_voldecr_irqhandler(card);
irqstatus &=~IPR_VOLDECR;
}
if (irqstatus){
printk(KERN_ERR "emu10k1: Warning, unhandled interrupt: %#08x\n", irqstatus);
//make sure any interrupts we don't handle are disabled:
emu10k1_irq_disable(card, ~(INTE_MIDIRXENABLE | INTE_MIDITXENABLE | INTE_INTERVALTIMERENB |
INTE_VOLDECRENABLE | INTE_VOLINCRENABLE | INTE_MUTEENABLE |
INTE_FXDSPENABLE));
}
/* acknowledge interrupt */
outl(irqstatus_tmp, card->iobase + IPR);
handled = 1;
}
return IRQ_RETVAL(handled);
}
SCORE SW(const ProfPos *PA, unsigned uLengthA, const ProfPos *PB,
unsigned uLengthB, PWPath &Path)
{
assert(uLengthB > 0 && uLengthA > 0);
const unsigned uPrefixCountA = uLengthA + 1;
const unsigned uPrefixCountB = uLengthB + 1;
// Allocate DP matrices
const size_t LM = uPrefixCountA*uPrefixCountB;
SCORE *DPM_ = new SCORE[LM];
SCORE *DPD_ = new SCORE[LM];
SCORE *DPI_ = new SCORE[LM];
DPM(0, 0) = 0;
DPD(0, 0) = MINUS_INFINITY;
DPI(0, 0) = MINUS_INFINITY;
DPM(1, 0) = MINUS_INFINITY;
DPD(1, 0) = MINUS_INFINITY;
DPI(1, 0) = MINUS_INFINITY;
DPM(0, 1) = MINUS_INFINITY;
DPD(0, 1) = MINUS_INFINITY;
DPI(0, 1) = MINUS_INFINITY;
// Empty prefix of B is special case
for (unsigned uPrefixLengthA = 2; uPrefixLengthA < uPrefixCountA; ++uPrefixLengthA)
{
// M=LetterA+LetterB, impossible with empty prefix
DPM(uPrefixLengthA, 0) = MINUS_INFINITY;
// D=LetterA+GapB, never optimal in local alignment with gap penalties
DPD(uPrefixLengthA, 0) = MINUS_INFINITY;
// I=GapA+LetterB, impossible with empty prefix
DPI(uPrefixLengthA, 0) = MINUS_INFINITY;
}
// Empty prefix of A is special case
for (unsigned uPrefixLengthB = 2; uPrefixLengthB < uPrefixCountB; ++uPrefixLengthB)
{
// M=LetterA+LetterB, impossible with empty prefix
DPM(0, uPrefixLengthB) = MINUS_INFINITY;
// D=LetterA+GapB, impossible with empty prefix
DPD(0, uPrefixLengthB) = MINUS_INFINITY;
// I=GapA+LetterB, never optimal in local alignment with gap penalties
DPI(0, uPrefixLengthB) = MINUS_INFINITY;
}
SCORE scoreMax = MINUS_INFINITY;
unsigned uPrefixLengthAMax = uInsane;
unsigned uPrefixLengthBMax = uInsane;
// ============
// Main DP loop
// ============
SCORE scoreGapCloseB = MINUS_INFINITY;
for (unsigned uPrefixLengthB = 1; uPrefixLengthB < uPrefixCountB; ++uPrefixLengthB)
{
const ProfPos &PPB = PB[uPrefixLengthB - 1];
SCORE scoreGapCloseA = MINUS_INFINITY;
for (unsigned uPrefixLengthA = 1; uPrefixLengthA < uPrefixCountA; ++uPrefixLengthA)
{
const ProfPos &PPA = PA[uPrefixLengthA - 1];
{
// Match M=LetterA+LetterB
SCORE scoreLL = ScoreProfPos2(PPA, PPB);
SCORE scoreMM = DPM(uPrefixLengthA-1, uPrefixLengthB-1);
SCORE scoreDM = DPD(uPrefixLengthA-1, uPrefixLengthB-1) + scoreGapCloseA;
SCORE scoreIM = DPI(uPrefixLengthA-1, uPrefixLengthB-1) + scoreGapCloseB;
SCORE scoreBest;
if (scoreMM >= scoreDM && scoreMM >= scoreIM)
scoreBest = scoreMM;
else if (scoreDM >= scoreMM && scoreDM >= scoreIM)
scoreBest = scoreDM;
else
{
assert(scoreIM >= scoreMM && scoreIM >= scoreDM);
scoreBest = scoreIM;
}
if (scoreBest < 0)
scoreBest = 0;
scoreBest += scoreLL;
if (scoreBest > scoreMax)
{
scoreMax = scoreBest;
uPrefixLengthAMax = uPrefixLengthA;
uPrefixLengthBMax = uPrefixLengthB;
}
DPM(uPrefixLengthA, uPrefixLengthB) = scoreBest;
}
{
// Delete D=LetterA+GapB
SCORE scoreMD = DPM(uPrefixLengthA-1, uPrefixLengthB) +
PA[uPrefixLengthA-1].m_scoreGapOpen;
SCORE scoreDD = DPD(uPrefixLengthA-1, uPrefixLengthB);
SCORE scoreBest;
if (scoreMD >= scoreDD)
scoreBest = scoreMD;
else
{
assert(scoreDD >= scoreMD);
scoreBest = scoreDD;
}
DPD(uPrefixLengthA, uPrefixLengthB) = scoreBest;
}
// Insert I=GapA+LetterB
{
SCORE scoreMI = DPM(uPrefixLengthA, uPrefixLengthB-1) +
PB[uPrefixLengthB - 1].m_scoreGapOpen;
SCORE scoreII = DPI(uPrefixLengthA, uPrefixLengthB-1);
SCORE scoreBest;
if (scoreMI >= scoreII)
scoreBest = scoreMI;
else
{
assert(scoreII > scoreMI);
scoreBest = scoreII;
}
DPI(uPrefixLengthA, uPrefixLengthB) = scoreBest;
}
scoreGapCloseA = PPA.m_scoreGapClose;
}
scoreGapCloseB = PPB.m_scoreGapClose;
}
#if TRACE
Log("DPM:\n");
ListDP(DPM_, PA, PB, uPrefixLengthA, uPrefixLengthB);
Log("DPD:\n");
ListDP(DPD_, PA, PB, uPrefixLengthA, uPrefixLengthB);
Log("DPI:\n");
ListDP(DPI_, PA, PB, uPrefixLengthA, uPrefixLengthB);
#endif
assert(scoreMax == DPM(uPrefixLengthAMax, uPrefixLengthBMax));
TraceBackSW(PA, uLengthA, PB, uLengthB, DPM_, DPD_, DPI_,
uPrefixLengthAMax, uPrefixLengthBMax, Path);
#if TRACE
SCORE scorePath = FastScorePath2(PA, uLengthA, PB, uLengthB, Path);
Path.LogMe();
Log("Score = %s Path = %s\n", LocalScoreToStr(scoreMax), LocalScoreToStr(scorePath));
#endif
delete[] DPM_;
delete[] DPD_;
delete[] DPI_;
return scoreMax;
}
static SCORE TraceBackDimer( const SCORE *DPM_, const SCORE *DPD_, const SCORE *DPI_,
const char *TBM_, const char *TBD_, const char *TBI_,
unsigned uLengthA, unsigned uLengthB, PWPath &Path)
{
const unsigned uPrefixCountA = uLengthA + 1;
unsigned uPrefixLengthA = uLengthA;
unsigned uPrefixLengthB = uLengthB;
char cEdge = 'M';
SCORE scoreMax = DPM(uLengthA, uLengthB);
if (DPD(uLengthA, uLengthB) > scoreMax)
{
scoreMax = DPD(uLengthA, uLengthB);
cEdge = 'D';
}
if (DPI(uLengthA, uLengthB) > scoreMax)
{
scoreMax = DPI(uLengthA, uLengthB);
cEdge = 'I';
}
for (;;)
{
if (0 == uPrefixLengthA && 0 == uPrefixLengthB)
break;
PWEdge Edge;
Edge.cType = cEdge;
Edge.uPrefixLengthA = uPrefixLengthA;
Edge.uPrefixLengthB = uPrefixLengthB;
Path.PrependEdge(Edge);
#if TRACE
Log("PLA=%u PLB=%u Edge=%c\n", uPrefixLengthA, uPrefixLengthB, cEdge);
#endif
switch (cEdge)
{
case 'M':
assert(uPrefixLengthA > 0 && uPrefixLengthB > 0);
cEdge = TBM(uPrefixLengthA, uPrefixLengthB);
--uPrefixLengthA;
--uPrefixLengthB;
break;
case 'D':
assert(uPrefixLengthA > 0);
cEdge = TBD(uPrefixLengthA, uPrefixLengthB);
--uPrefixLengthA;
break;
case 'I':
assert(uPrefixLengthB > 0);
cEdge = TBI(uPrefixLengthA, uPrefixLengthB);
--uPrefixLengthB;
break;
default:
Quit("Invalid edge PLA=%u PLB=%u %c", uPrefixLengthA, uPrefixLengthB, cEdge);
}
}
#if TRACE
Path.LogMe();
#endif
return scoreMax;
}
// Global alignment dynamic programming
// This variant optimizes the profile-profile SP score under the
// dimer approximation.
SCORE GlobalAlignDimer(const ProfPos *PA, unsigned uLengthA, const ProfPos *PB,
unsigned uLengthB, PWPath &Path)
{
assert(uLengthB > 0 && uLengthA > 0);
const unsigned uPrefixCountA = uLengthA + 1;
const unsigned uPrefixCountB = uLengthB + 1;
// Allocate DP matrices
const size_t LM = uPrefixCountA*uPrefixCountB;
SCORE *DPM_ = new SCORE[LM];
SCORE *DPD_ = new SCORE[LM];
SCORE *DPI_ = new SCORE[LM];
char *TBM_ = new char[LM];
char *TBD_ = new char[LM];
char *TBI_ = new char[LM];
DPM(0, 0) = 0;
DPD(0, 0) = MINUS_INFINITY;
DPI(0, 0) = MINUS_INFINITY;
TBM(0, 0) = 'S';
TBD(0, 0) = '?';
TBI(0, 0) = '?';
DPM(1, 0) = MINUS_INFINITY;
DPD(1, 0) = GapScoreMD(PA[0], PPTerm);
DPI(1, 0) = MINUS_INFINITY;
TBM(1, 0) = '?';
TBD(1, 0) = 'S';
TBI(1, 0) = '?';
DPM(0, 1) = MINUS_INFINITY;
DPD(0, 1) = MINUS_INFINITY;
DPI(0, 1) = GapScoreMI(PPTerm, PB[0]);
TBM(0, 1) = '?';
TBD(0, 1) = '?';
TBI(0, 1) = 'S';
// Empty prefix of B is special case
for (unsigned uPrefixLengthA = 2; uPrefixLengthA < uPrefixCountA; ++uPrefixLengthA)
{
// M=LetterA+LetterB, impossible with empty prefix
DPM(uPrefixLengthA, 0) = MINUS_INFINITY;
TBM(uPrefixLengthA, 0) = '?';
// D=LetterA+GapB
DPD(uPrefixLengthA, 0) = DPD(uPrefixLengthA - 1, 0) +
GapScoreDD(PA[uPrefixLengthA - 1], PPTerm);
TBD(uPrefixLengthA, 0) = 'D';
// I=GapA+LetterB, impossible with empty prefix
DPI(uPrefixLengthA, 0) = MINUS_INFINITY;
TBI(uPrefixLengthA, 0) = '?';
}
// Empty prefix of A is special case
for (unsigned uPrefixLengthB = 2; uPrefixLengthB < uPrefixCountB; ++uPrefixLengthB)
{
// M=LetterA+LetterB, impossible with empty prefix
DPM(0, uPrefixLengthB) = MINUS_INFINITY;
TBM(0, uPrefixLengthB) = '?';
// D=LetterA+GapB, impossible with empty prefix
DPD(0, uPrefixLengthB) = MINUS_INFINITY;
TBD(0, uPrefixLengthB) = '?';
// I=GapA+LetterB
DPI(0, uPrefixLengthB) = DPI(0, uPrefixLengthB - 1) +
GapScoreII(PPTerm, PB[uPrefixLengthB - 1]);
TBI(0, uPrefixLengthB) = 'I';
}
// ============
// Main DP loop
// ============
for (unsigned uPrefixLengthB = 1; uPrefixLengthB < uPrefixCountB; ++uPrefixLengthB)
{
const ProfPos &PPB = PB[uPrefixLengthB - 1];
for (unsigned uPrefixLengthA = 1; uPrefixLengthA < uPrefixCountA; ++uPrefixLengthA)
{
const ProfPos &PPA = PA[uPrefixLengthA - 1];
{
// Match M=LetterA+LetterB
SCORE scoreLL = ScoreProfPosDimer(PPA, PPB);
SCORE scoreMM = DPM(uPrefixLengthA-1, uPrefixLengthB-1) + GapScoreMM(PPA, PPB);
SCORE scoreDM = DPD(uPrefixLengthA-1, uPrefixLengthB-1) + GapScoreDM(PPA, PPB);
SCORE scoreIM = DPI(uPrefixLengthA-1, uPrefixLengthB-1) + GapScoreIM(PPA, PPB);
SCORE scoreBest = scoreMM;
char c = 'M';
if (scoreDM > scoreBest)
{
scoreBest = scoreDM;
c = 'D';
}
if (scoreIM > scoreBest)
{
scoreBest = scoreIM;
c = 'I';
}
DPM(uPrefixLengthA, uPrefixLengthB) = scoreBest + scoreLL;
TBM(uPrefixLengthA, uPrefixLengthB) = c;
}
{
// Delete D=LetterA+GapB
SCORE scoreMD = DPM(uPrefixLengthA-1, uPrefixLengthB) + GapScoreMD(PPA, PPB);
SCORE scoreDD = DPD(uPrefixLengthA-1, uPrefixLengthB) + GapScoreDD(PPA, PPB);
SCORE scoreID = DPI(uPrefixLengthA-1, uPrefixLengthB) + GapScoreID(PPA, PPB);
SCORE scoreBest = scoreMD;
char c = 'M';
if (scoreDD > scoreBest)
{
scoreBest = scoreDD;
c = 'D';
}
if (scoreID > scoreBest)
{
scoreBest = scoreID;
c = 'I';
}
DPD(uPrefixLengthA, uPrefixLengthB) = scoreBest;
TBD(uPrefixLengthA, uPrefixLengthB) = c;
}
{
// Insert I=GapA+LetterB
SCORE scoreMI = DPM(uPrefixLengthA, uPrefixLengthB-1) + GapScoreMI(PPA, PPB);
SCORE scoreDI = DPD(uPrefixLengthA, uPrefixLengthB-1) + GapScoreDI(PPA, PPB);
SCORE scoreII = DPI(uPrefixLengthA, uPrefixLengthB-1) + GapScoreII(PPA, PPB);
SCORE scoreBest = scoreMI;
char c = 'M';
if (scoreDI > scoreBest)
{
scoreBest = scoreDI;
c = 'D';
}
if (scoreII > scoreBest)
{
scoreBest = scoreII;
c = 'I';
}
DPI(uPrefixLengthA, uPrefixLengthB) = scoreBest;
TBI(uPrefixLengthA, uPrefixLengthB) = c;
}
}
}
#if TRACE
Log("DPM:\n");
ListDP(DPM_, PA, PB, uPrefixCountA, uPrefixCountB);
Log("DPD:\n");
ListDP(DPD_, PA, PB, uPrefixCountA, uPrefixCountB);
Log("DPI:\n");
ListDP(DPI_, PA, PB, uPrefixCountA, uPrefixCountB);
Log("TBM:\n");
ListTB(TBM_, PA, PB, uPrefixCountA, uPrefixCountB);
Log("TBD:\n");
ListTB(TBD_, PA, PB, uPrefixCountA, uPrefixCountB);
Log("TBI:\n");
ListTB(TBI_, PA, PB, uPrefixCountA, uPrefixCountB);
#endif
SCORE Score = TraceBackDimer(DPM_, DPD_, DPI_, TBM_, TBD_, TBI_,
uLengthA, uLengthB, Path);
#if TRACE
Log("GlobalAlignDimer score = %.3g\n", Score);
#endif
delete[] DPM_;
delete[] DPD_;
delete[] DPI_;
delete[] TBM_;
delete[] TBD_;
delete[] TBI_;
return Score;
}
/* Driver initialization routine */
static int __devinit emu10k1_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
{
struct emu10k1_card *card;
if ((card = kmalloc(sizeof(struct emu10k1_card), GFP_KERNEL)) == NULL) {
printk(KERN_ERR "emu10k1: out of memory\n");
return -ENOMEM;
}
memset(card, 0, sizeof(struct emu10k1_card));
#if LINUX_VERSION_CODE > 0x020320
if (!pci_dma_supported(pci_dev, EMU10K1_DMA_MASK)) {
printk(KERN_ERR "emu10k1: architecture does not support 32bit PCI busmaster DMA\n");
kfree(card);
return -ENODEV;
}
if (pci_enable_device(pci_dev)) {
printk(KERN_ERR "emu10k1: couldn't enable device\n");
kfree(card);
return -ENODEV;
}
pci_set_master(pci_dev);
card->iobase = pci_dev->resource[0].start;
if (request_region(card->iobase, EMU10K1_EXTENT, card_names[pci_id->driver_data]) == NULL) {
printk(KERN_ERR "emu10k1: IO space in use\n");
kfree(card);
return -ENODEV;
}
pci_dev->driver_data = card;
pci_dev->dma_mask = EMU10K1_DMA_MASK;
#else
pci_set_master(pci_dev);
card->iobase = pci_dev->base_address[0] & PCI_BASE_ADDRESS_IO_MASK;
if (check_region(card->iobase, EMU10K1_EXTENT)) {
printk(KERN_ERR "emu10k1: IO space in use\n");
kfree(card);
return -ENODEV;
}
request_region(card->iobase, EMU10K1_EXTENT, card_names[pci_id->driver_data]);
#endif
card->irq = pci_dev->irq;
card->pci_dev = pci_dev;
/* Reserve IRQ Line */
if (request_irq(card->irq, emu10k1_interrupt, SA_SHIRQ, card_names[pci_id->driver_data], card)) {
printk(KERN_ERR "emu10k1: IRQ in use\n");
goto err_irq;
}
pci_read_config_byte(pci_dev, PCI_REVISION_ID, &card->chiprev);
printk(KERN_INFO "emu10k1: %s rev %d found at IO 0x%04lx, IRQ %d\n", card_names[pci_id->driver_data], card->chiprev, card->iobase, card->irq);
spin_lock_init(&card->lock);
card->mixeraddx = card->iobase + AC97DATA;
init_MUTEX(&card->open_sem);
card->open_mode = 0;
init_waitqueue_head(&card->open_wait);
/* Register devices */
if ((card->audio1_num = register_sound_dsp(&emu10k1_audio_fops, -1)) < 0) {
printk(KERN_ERR "emu10k1: cannot register first audio device!\n");
goto err_dev0;
}
if ((card->audio2_num = register_sound_dsp(&emu10k1_audio_fops, -1)) < 0) {
printk(KERN_ERR "emu10k1: cannot register second audio device!\n");
goto err_dev1;
}
if ((card->mixer_num = register_sound_mixer(&emu10k1_mixer_fops, -1)) < 0) {
printk(KERN_ERR "emu10k1: cannot register mixer device!\n");
goto err_dev2;
}
if ((card->midi_num = register_sound_midi(&emu10k1_midi_fops, -1)) < 0) {
printk(KERN_ERR "emu10k1: cannot register midi device!\n");
goto err_dev3;
}
if (emu10k1_init(card) != CTSTATUS_SUCCESS) {
printk(KERN_ERR "emu10k1: cannot initialize device!\n");
goto err_emu10k1_init;
}
if (audio_init(card) != CTSTATUS_SUCCESS) {
printk(KERN_ERR "emu10k1: cannot initialize audio!\n");
goto err_audio_init;
}
if (midi_init(card) != CTSTATUS_SUCCESS) {
printk(KERN_ERR "emu10k1: cannot initialize midi!\n");
goto err_midi_init;
}
mixer_init(card);
DPD(2, "Hardware initialized. TRAM allocated: %u bytes\n", (unsigned int) card->tmemsize);
list_add(&card->list, &emu10k1_devs);
return 0;
err_midi_init:
audio_exit(card);
err_audio_init:
emu10k1_exit(card);
err_emu10k1_init:
unregister_sound_midi(card->midi_num);
err_dev3:
unregister_sound_mixer(card->mixer_num);
err_dev2:
unregister_sound_dsp(card->audio2_num);
err_dev1:
unregister_sound_dsp(card->audio1_num);
err_dev0:
free_irq(card->irq, card);
err_irq:
release_region(card->iobase, EMU10K1_EXTENT);
kfree(card);
return -ENODEV;
}
