#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){	writel(PCI_INT_ENABLE_BIT            |	       PCI_DOORBELL_INT_ENABLE_BIT   |	       LOCAL_INT_ENABLE_BIT          |	       LOCAL_DOORBELL_INT_ENABLE_BIT |	       LOCAL_DMA1_INT_ENABLE_BIT,	       korg1212->statusRegPtr);}#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 inline int snd_korg1212_use_is_exclusive(korg1212_t *korg1212){	int ret = 1;	if ((korg1212->playback_pid != korg1212->capture_pid) &&	    (korg1212->playback_pid >= 0) && (korg1212->capture_pid >= 0)) {		ret = 0;	}	return ret;}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;        if (!snd_korg1212_use_is_exclusive (korg1212)) {                return -EBUSY;        }        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){	writel(0, korg1212->statusRegPtr);}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);