korg1212.c

优龙2410linux2.6.8内核源代码

		snd_korg1212_TurnOffIdleMonitor(korg1212);
		snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);
	}

	up(&korg1212->open_mutex);
        return 1;
}

static int snd_korg1212_CloseCard(korg1212_t * korg1212)
{
#if K1212_DEBUG_LEVEL > 0
	K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard [%s] %d\n", stateName[korg1212->cardState], korg1212->opencnt);
#endif

	down(&korg1212->open_mutex);
	if (--(korg1212->opencnt)) {
		up(&korg1212->open_mutex);
		return 0;
	}

        if (korg1212->cardState == K1212_STATE_SETUP) {
                rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode,
                                K1212_MODE_StopPlay, 0, 0, 0);
#if K1212_DEBUG_LEVEL > 0
	if (rc) K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard - RC = %d [%s]\n", rc, stateName[korg1212->cardState]);
#endif

		if (rc != K1212_CMDRET_Success) {
			up(&korg1212->open_mutex);
                        return 0;
		}
        } else if (korg1212->cardState > K1212_STATE_SETUP) {
		snd_korg1212_SendStopAndWait(korg1212);
        }

        if (korg1212->cardState > K1212_STATE_READY) {
		snd_korg1212_TurnOnIdleMonitor(korg1212);
                snd_korg1212_setCardState(korg1212, K1212_STATE_READY);
	}

	up(&korg1212->open_mutex);
        return 0;
}

/* spinlock already held */
static int snd_korg1212_SetupForPlay(korg1212_t * korg1212)
{
#if K1212_DEBUG_LEVEL > 0
	K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay [%s] %d\n", stateName[korg1212->cardState], korg1212->setcnt);
#endif

        if (korg1212->setcnt++)
		return 0;

        snd_korg1212_setCardState(korg1212, K1212_STATE_SETUP);
        rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode,
                                        K1212_MODE_SetupPlay, 0, 0, 0);

#if K1212_DEBUG_LEVEL > 0
	if (rc) K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay - RC = %d [%s]\n", rc, stateName[korg1212->cardState]);
#endif
        if (rc != K1212_CMDRET_Success) {
                return 1;
        }
        return 0;
}

/* spinlock already held */
static int snd_korg1212_TriggerPlay(korg1212_t * korg1212)
{
#if K1212_DEBUG_LEVEL > 0
	K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay [%s] %d\n", stateName[korg1212->cardState], korg1212->playcnt);
#endif

        if (korg1212->playcnt++)
		return 0;

        snd_korg1212_setCardState(korg1212, K1212_STATE_PLAYING);
        rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_TriggerPlay, 0, 0, 0, 0);

#if K1212_DEBUG_LEVEL > 0
	if (rc) K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay - RC = %d [%s]\n", rc, stateName[korg1212->cardState]);
#endif

        if (rc != K1212_CMDRET_Success) {
                return 1;
        }
        return 0;
}

/* spinlock already held */
static int snd_korg1212_StopPlay(korg1212_t * korg1212)
{
#if K1212_DEBUG_LEVEL > 0
	K1212_DEBUG_PRINTK("K1212_DEBUG: StopPlay [%s] %d\n", stateName[korg1212->cardState], korg1212->playcnt);
#endif

        if (--(korg1212->playcnt)) 
		return 0;

	korg1212->setcnt = 0;

        if (korg1212->cardState != K1212_STATE_ERRORSTOP)
		snd_korg1212_SendStop(korg1212);

	snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);
        return 0;
}

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)
{
#if K1212_DEBUG_LEVEL > 0
	K1212_DEBUG_PRINTK("K1212_DEBUG: SetMonitorMode [%s]\n", stateName[korg1212->cardState]);
#endif

        switch (mode) {
                case K1212_MONMODE_Off:
                        if (korg1212->cardState != K1212_STATE_MONITOR) {
                                return 0;
                        } else {
				snd_korg1212_SendStopAndWait(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;

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

#if K1212_DEBUG_LEVEL > 0
	if (rc) K1212_DEBUG_PRINTK("K1212_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;
	unsigned long flags;

#if K1212_DEBUG_LEVEL > 0
	K1212_DEBUG_PRINTK("K1212_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) {
                monModeSet = 1;
		snd_korg1212_SendStopAndWait(korg1212);
        } else
                monModeSet = 0;

	spin_lock_irqsave(&korg1212->lock, flags);

        // ----------------------------------------------------------------------------
        // 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);
        udelay(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
                udelay(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
                        udelay(SENSCLKPULSE_WIDTH);
                        SetBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);
                        writew(controlValue, korg1212->sensRegPtr);                       // clock goes high
                        udelay(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
                udelay(SENSCLKPULSE_WIDTH);

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

                writew(controlValue, korg1212->sensRegPtr);                   // set/clear data bit
                udelay(ONE_RTC_TICK);
                SetBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);
                writew(controlValue, korg1212->sensRegPtr);                   // clock goes high
                udelay(SENSCLKPULSE_WIDTH);
                ClearBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);
                writew(controlValue, korg1212->sensRegPtr);                   // clock goes low
                udelay(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++)
                udelay(SENSCLKPULSE_WIDTH);