korg1212.c

是关于linux2.5.1的完全源码

        snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);
        return 1;
}

static void snd_korg1212_EnableCardInterrupts(korg1212_t * korg1212)
{
	* korg1212->statusRegPtr = PCI_INT_ENABLE_BIT            |
                                   PCI_DOORBELL_INT_ENABLE_BIT   |
                                   LOCAL_INT_ENABLE_BIT          |
                                   LOCAL_DOORBELL_INT_ENABLE_BIT |
                                   LOCAL_DMA1_INT_ENABLE_BIT;
}

#if 0 /* not used */

static int snd_korg1212_SetMonitorMode(korg1212_t *korg1212, MonitorModeSelector mode)
{
#ifdef DEBUG
	PRINTK("DEBUG: SetMonitorMode [%s]\n", stateName[korg1212->cardState]);
#endif

        switch (mode) {
                case K1212_MONMODE_Off:
                        if (korg1212->cardState != K1212_STATE_MONITOR) {
                                return 0;
                        } else {
                                writel(0xffffffff, &korg1212->sharedBufferPtr->cardCommand);
                                snd_korg1212_WaitForCardStopAck(korg1212);
                                snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);
                        }
                        break;

                case K1212_MONMODE_On:
                        if (korg1212->cardState != K1212_STATE_OPEN) {
                                return 0;
                        } else {
                                snd_korg1212_setCardState(korg1212, K1212_STATE_MONITOR);
                                rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode,
                                                        K1212_MODE_MonitorOn, 0, 0, 0);
                                if (rc != K1212_CMDRET_Success) {
                                        return 0;
                                }
                        }
                        break;

                default:
                        return 0;
        }

        return 1;
}

#endif /* not used */

static int snd_korg1212_SetRate(korg1212_t *korg1212, int rate)
{
        static ClockSourceIndex s44[] = { K1212_CLKIDX_AdatAt44_1K,
                                          K1212_CLKIDX_WordAt44_1K,
                                          K1212_CLKIDX_LocalAt44_1K };
        static ClockSourceIndex s48[] = {
                                          K1212_CLKIDX_AdatAt48K,
                                          K1212_CLKIDX_WordAt48K,
                                          K1212_CLKIDX_LocalAt48K };
        int parm;

        switch(rate) {
                case 44100:
                parm = s44[korg1212->clkSource];
                break;

                case 48000:
                parm = s48[korg1212->clkSource];
                break;

                default:
                return -EINVAL;
        }

        korg1212->clkSrcRate = parm;
        korg1212->clkRate = rate;

	TickDelay(INTERCOMMAND_DELAY);
	rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SetClockSourceRate,
					  ClockSourceSelector[korg1212->clkSrcRate],
					  0, 0, 0);

#ifdef DEBUG
	if (rc) PRINTK("DEBUG: Set Clock Source Selector - RC = %d [%s]\n", rc, stateName[korg1212->cardState]);
#endif

        return 0;
}

static int snd_korg1212_SetClockSource(korg1212_t *korg1212, int source)
{

        if (source<0 || source >2)
           return -EINVAL;

        korg1212->clkSource = source;

        snd_korg1212_SetRate(korg1212, korg1212->clkRate);

        return 0;
}

static void snd_korg1212_DisableCardInterrupts(korg1212_t *korg1212)
{
	* korg1212->statusRegPtr = 0;
}

static int snd_korg1212_WriteADCSensitivity(korg1212_t *korg1212)
{
        SensBits  sensVals;
        int       bitPosition;
        int       channel;
        int       clkIs48K;
        int       monModeSet;
        u16       controlValue;    // this keeps the current value to be written to
                                   //  the card's eeprom control register.
        u16       count;

#ifdef DEBUG
	PRINTK("DEBUG: WriteADCSensivity [%s]\n", stateName[korg1212->cardState]);
#endif

        // ----------------------------------------------------------------------------
        // initialize things.  The local init bit is always set when writing to the
        // card's control register.
        // ----------------------------------------------------------------------------
        controlValue = 0;
        SetBitInWord(&controlValue, SET_SENS_LOCALINIT_BITPOS);    // init the control value

        // ----------------------------------------------------------------------------
        // make sure the card is not in monitor mode when we do this update.
        // ----------------------------------------------------------------------------
        if (korg1212->cardState == K1212_STATE_MONITOR || korg1212->idleMonitorOn) {
                writel(0xffffffff, &korg1212->sharedBufferPtr->cardCommand);
                monModeSet = 1;
                snd_korg1212_WaitForCardStopAck(korg1212);
        } else
                monModeSet = 0;

        // ----------------------------------------------------------------------------
        // we are about to send new values to the card, so clear the new values queued
        // flag.  Also, clear out mailbox 3, so we don't lockup.
        // ----------------------------------------------------------------------------
        writel(0, korg1212->mailbox3Ptr);
        TickDelay(LOADSHIFT_DELAY);

        // ----------------------------------------------------------------------------
        // determine whether we are running a 48K or 44.1K clock.  This info is used
        // later when setting the SPDIF FF after the volume has been shifted in.
        // ----------------------------------------------------------------------------
        switch (korg1212->clkSrcRate) {
                case K1212_CLKIDX_AdatAt44_1K:
                case K1212_CLKIDX_WordAt44_1K:
                case K1212_CLKIDX_LocalAt44_1K:
                        clkIs48K = 0;
                        break;

                case K1212_CLKIDX_WordAt48K:
                case K1212_CLKIDX_AdatAt48K:
                case K1212_CLKIDX_LocalAt48K:
                default:
                        clkIs48K = 1;
                        break;
        }

        // ----------------------------------------------------------------------------
        // start the update.  Setup the bit structure and then shift the bits.
        // ----------------------------------------------------------------------------
        sensVals.l.v.leftChanId   = SET_SENS_LEFTCHANID;
        sensVals.r.v.rightChanId  = SET_SENS_RIGHTCHANID;
        sensVals.l.v.leftChanVal  = korg1212->leftADCInSens;
        sensVals.r.v.rightChanVal = korg1212->rightADCInSens;

        // ----------------------------------------------------------------------------
        // now start shifting the bits in.  Start with the left channel then the right.
        // ----------------------------------------------------------------------------
        for (channel = 0; channel < 2; channel++) {

                // ----------------------------------------------------------------------------
                // Bring the load/shift line low, then wait - the spec says >150ns from load/
                // shift low to the first rising edge of the clock.
                // ----------------------------------------------------------------------------
                ClearBitInWord(&controlValue, SET_SENS_LOADSHIFT_BITPOS);
                ClearBitInWord(&controlValue, SET_SENS_DATA_BITPOS);
                writew(controlValue, korg1212->sensRegPtr);                          // load/shift goes low
                TickDelay(LOADSHIFT_DELAY);

                for (bitPosition = 15; bitPosition >= 0; bitPosition--) {       // for all the bits
                        if (channel == 0) {
                                if (sensVals.l.leftSensBits & (0x0001 << bitPosition)) {
                                        SetBitInWord(&controlValue, SET_SENS_DATA_BITPOS);     // data bit set high
                                } else {
                                        ClearBitInWord(&controlValue, SET_SENS_DATA_BITPOS);   // data bit set low
                                }
                        } else {
                                if (sensVals.r.rightSensBits & (0x0001 << bitPosition)) {
                                SetBitInWord(&controlValue, SET_SENS_DATA_BITPOS);     // data bit set high
                                } else {
                                ClearBitInWord(&controlValue, SET_SENS_DATA_BITPOS);   // data bit set low
                                }
                        }

                        ClearBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);
                        writew(controlValue, korg1212->sensRegPtr);                       // clock goes low
                        TickDelay(SENSCLKPULSE_WIDTH);
                        SetBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);
                        writew(controlValue, korg1212->sensRegPtr);                       // clock goes high
                        TickDelay(SENSCLKPULSE_WIDTH);
                }

                // ----------------------------------------------------------------------------
                // finish up SPDIF for left.  Bring the load/shift line high, then write a one
                // bit if the clock rate is 48K otherwise write 0.
                // ----------------------------------------------------------------------------
                ClearBitInWord(&controlValue, SET_SENS_DATA_BITPOS);
                ClearBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);
                SetBitInWord(&controlValue, SET_SENS_LOADSHIFT_BITPOS);
                writew(controlValue, korg1212->sensRegPtr);                   // load shift goes high - clk low
                TickDelay(SENSCLKPULSE_WIDTH);

                if (clkIs48K)
                        SetBitInWord(&controlValue, SET_SENS_DATA_BITPOS);

                writew(controlValue, korg1212->sensRegPtr);                   // set/clear data bit
                TickDelay(ONE_RTC_TICK);
                SetBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);
                writew(controlValue, korg1212->sensRegPtr);                   // clock goes high
                TickDelay(SENSCLKPULSE_WIDTH);
                ClearBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);
                writew(controlValue, korg1212->sensRegPtr);                   // clock goes low
                TickDelay(SENSCLKPULSE_WIDTH);
        }

        // ----------------------------------------------------------------------------
        // The update is complete.  Set a timeout.  This is the inter-update delay.
        // Also, if the card was in monitor mode, restore it.
        // ----------------------------------------------------------------------------
        for (count = 0; count < 10; count++)
                TickDelay(SENSCLKPULSE_WIDTH);

        if (monModeSet) {
                rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode,
                                K1212_MODE_MonitorOn, 0, 0, 0);
#ifdef DEBUG
	        if (rc) PRINTK("DEBUG: WriteADCSensivity - RC = %d [%s]\n", rc, stateName[korg1212->cardState]);
#endif

        }

        return 1;
}

static void snd_korg1212_OnDSPDownloadComplete(korg1212_t *korg1212)
{
        int channel;

#ifdef DEBUG
        PRINTK("DEBUG: DSP download is complete. [%s]\n", stateName[korg1212->cardState]);
#endif

        // ----------------------------------------------------
        // tell the card to boot
        // ----------------------------------------------------
        rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_BootFromDSPPage4, 0, 0, 0, 0);

#ifdef DEBUG
	if (rc) PRINTK("DEBUG: Boot from Page 4 - RC = %d [%s]\n", rc, stateName[korg1212->cardState]);
#endif
	mdelay(DSP_BOOT_DELAY_IN_MS);

        // --------------------------------------------------------------------------------
        // Let the card know where all the buffers are.
        // --------------------------------------------------------------------------------
        rc = snd_korg1212_Send1212Command(korg1212,
                        K1212_DB_ConfigureBufferMemory,
                        LowerWordSwap(korg1212->PlayDataPhy),
                        LowerWordSwap(korg1212->RecDataPhy),
                        ((kNumBuffers * kPlayBufferFrames) / 2),   // size given to the card
                                                                   // is based on 2 buffers
                        0
        );

#ifdef DEBUG
	if (rc) PRINTK("DEBUG: Configure Buffer Memory - RC = %d [%s]\n", rc, stateName[korg1212->cardState]);
#endif

        TickDelay(INTERCOMMAND_DELAY);

        rc = snd_korg1212_Send1212Command(korg1212,
                        K1212_DB_ConfigureMiscMemory,
                        LowerWordSwap(korg1212->VolumeTablePhy),
                        LowerWordSwap(korg1212->RoutingTablePhy),
                        LowerWordSwap(korg1212->AdatTimeCodePhy),
                        0
        );

#ifdef DEBUG
	if (rc) PRINTK("DEBUG: Configure Misc Memory - RC = %d [%s]\n", rc, stateName[korg1212->cardState]);
#endif


        // --------------------------------------------------------------------------------
        // Initialize the routing and volume tables, then update the card's state.
        // --------------------------------------------------------------------------------
        TickDelay(INTERCOMMAND_DELAY);

        for (channel = 0; channel < kAudioChannels; channel++) {
                korg1212->sharedBufferPtr->volumeData[channel] = k1212MaxVolume;
                //korg1212->sharedBufferPtr->routeData[channel] = channel;
                korg1212->sharedBufferPtr->routeData[channel] = 8 + (channel & 1);
        }

        snd_korg1212_WriteADCSensitivity(korg1212);

	TickDelay(INTERCOMMAND_DELAY);
	rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SetClockSourceRate,
					  ClockSourceSelector[korg1212->clkSrcRate],
					  0, 0, 0);
#ifdef DEBUG
	if (rc) PRINTK("DEBUG: Set Clock Source Selector - RC = %d [%s]\n", rc, stateName[korg1212->cardState]);
#endif

	snd_korg1212_setCardState(korg1212, K1212_STATE_READY);

#ifdef DEBUG
	if (rc) PRINTK("DEBUG: Set Monitor On - RC = %d [%s]\n", rc, stateName[korg1212->cardState]);
#endif

        wake_up_interruptible(&korg1212->wait);
}


static void snd_korg1212_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
        u32 doorbellValue;
        korg1212_t *korg1212 = snd_magic_cast(korg1212_t, dev_id, return);

	if(irq != korg1212->irq)
		return;

        doorbellValue = readl(korg1212->inDoorbellPtr);

        if (!doorbellValue)
		return;

	writel(doorbellValue, korg1212->inDoorbellPtr);

        korg1212->irqcount++;