korg1212.c

是关于linux2.5.1的完全源码

	korg1212->inIRQ++;


        switch (doorbellValue) {
                case K1212_DB_DSPDownloadDone:
#ifdef DEBUG
                        PRINTK("DEBUG: IRQ DNLD count - %ld, %x, [%s].\n", korg1212->irqcount, doorbellValue, stateName[korg1212->cardState]);
#endif
                        if (korg1212->cardState == K1212_STATE_DSP_IN_PROCESS) {
                                        snd_korg1212_setCardState(korg1212, K1212_STATE_DSP_COMPLETE);
                                        snd_korg1212_OnDSPDownloadComplete(korg1212);
                        }
                        break;

                // ------------------------------------------------------------------------
                // an error occurred - stop the card
                // ------------------------------------------------------------------------
                case K1212_ISRCODE_DMAERROR:
#ifdef DEBUG
                        PRINTK("DEBUG: IRQ DMAE count - %ld, %x, [%s].\n", korg1212->irqcount, doorbellValue, stateName[korg1212->cardState]);
#endif
                        writel(0, &korg1212->sharedBufferPtr->cardCommand);
                        break;

                // ------------------------------------------------------------------------
                // the card has stopped by our request.  Clear the command word and signal
                // the semaphore in case someone is waiting for this.
                // ------------------------------------------------------------------------
                case K1212_ISRCODE_CARDSTOPPED:
#ifdef DEBUG
                        PRINTK("DEBUG: IRQ CSTP count - %ld, %x, [%s].\n", korg1212->irqcount, doorbellValue, stateName[korg1212->cardState]);
#endif
                        writel(0, &korg1212->sharedBufferPtr->cardCommand);
                        break;

                default:
#ifdef XDEBUG
                        PRINTK("DEBUG: IRQ DFLT count - %ld, %x, cpos=%d [%s].\n", korg1212->irqcount, doorbellValue, 
				korg1212->currentBuffer, stateName[korg1212->cardState]);
#endif
                        if ((korg1212->cardState > K1212_STATE_SETUP) || korg1212->idleMonitorOn) {
                                korg1212->currentBuffer++;

                                if (korg1212->currentBuffer >= kNumBuffers)
                                        korg1212->currentBuffer = 0;

                                if (!korg1212->running)
                                        break;

                                if (korg1212->capture_substream) {
                                        snd_pcm_period_elapsed(korg1212->capture_substream);
                                }

                                if (korg1212->playback_substream) {
                                        snd_pcm_period_elapsed(korg1212->playback_substream);
                                }
                        }
                        break;
        }

	korg1212->inIRQ--;
}

static int snd_korg1212_downloadDSPCode(korg1212_t *korg1212)
{

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

        // ---------------------------------------------------------------
        // verify the state of the card before proceeding.
        // ---------------------------------------------------------------
        if (korg1212->cardState >= K1212_STATE_DSP_IN_PROCESS) {
                return 1;
        }

        snd_korg1212_setCardState(korg1212, K1212_STATE_DSP_IN_PROCESS);

        memcpy(korg1212->dspMemPtr, dspCode, korg1212->dspCodeSize);

        rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_StartDSPDownload,
                                     UpperWordSwap(korg1212->dspMemPhy),
                                     0, 0, 0);

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

        interruptible_sleep_on_timeout(&korg1212->wait, HZ * 4);

        return 0;
}

static snd_pcm_hardware_t snd_korg1212_playback_info =
{
        info:                (SNDRV_PCM_INFO_MMAP |
                              SNDRV_PCM_INFO_MMAP_VALID |
                              SNDRV_PCM_INFO_INTERLEAVED),
        formats:             SNDRV_PCM_FMTBIT_S16_LE,
        rates:               (SNDRV_PCM_RATE_44100 |
                              SNDRV_PCM_RATE_48000),
        rate_min:            44100,
        rate_max:            48000,
        channels_min:        K1212_CHANNELS,
        channels_max:        K1212_CHANNELS,
        buffer_bytes_max:    K1212_BUF_SIZE,
        period_bytes_min:    K1212_PERIOD_BYTES,
        period_bytes_max:    K1212_PERIOD_BYTES,
        periods_min:         K1212_PERIODS,
        periods_max:         K1212_PERIODS,
        fifo_size:           0,
};

static snd_pcm_hardware_t snd_korg1212_capture_info =
{
        info:                (SNDRV_PCM_INFO_MMAP |
                              SNDRV_PCM_INFO_MMAP_VALID |
                              SNDRV_PCM_INFO_INTERLEAVED),
        formats:             SNDRV_PCM_FMTBIT_S16_LE,
        rates:               (SNDRV_PCM_RATE_44100 |
                              SNDRV_PCM_RATE_48000),
        rate_min:            44100,
        rate_max:            48000,
        channels_min:        K1212_CHANNELS,
        channels_max:        K1212_CHANNELS,
        buffer_bytes_max:    K1212_BUF_SIZE,
        period_bytes_min:    K1212_PERIOD_BYTES,
        period_bytes_max:    K1212_PERIOD_BYTES,
        periods_min:         K1212_PERIODS,
        periods_max:         K1212_PERIODS,
        fifo_size:           0,
};

static void snd_korg1212_free_pcm(snd_pcm_t *pcm)
{
        korg1212_t *korg1212 = (korg1212_t *) pcm->private_data;

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

        korg1212->pcm16 = NULL;
}

static unsigned int period_bytes[] = { K1212_PERIOD_BYTES };

#define PERIOD_BYTES sizeof(period_bytes) / sizeof(period_bytes[0])

static snd_pcm_hw_constraint_list_t hw_constraints_period_bytes = {
        count: PERIOD_BYTES,
        list: period_bytes,
        mask: 0
};

static int snd_korg1212_playback_open(snd_pcm_substream_t *substream)
{
        unsigned long flags;
        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
        snd_pcm_runtime_t *runtime = substream->runtime;

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

        spin_lock_irqsave(&korg1212->lock, flags);

        snd_korg1212_OpenCard(korg1212);

        snd_pcm_set_sync(substream);    // ???

        runtime->hw = snd_korg1212_playback_info;
	runtime->dma_area = (char *) korg1212->playDataBufsPtr;
	runtime->dma_bytes = K1212_BUF_SIZE;

        korg1212->playback_substream = substream;
        korg1212->periodsize = K1212_PERIODS;

        spin_unlock_irqrestore(&korg1212->lock, flags);

        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, K1212_BUF_SIZE, K1212_BUF_SIZE);
        snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
        return 0;
}

static int snd_korg1212_capture_open(snd_pcm_substream_t *substream)
{
        unsigned long flags;
        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
        snd_pcm_runtime_t *runtime = substream->runtime;

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

        spin_lock_irqsave(&korg1212->lock, flags);

        snd_korg1212_OpenCard(korg1212);

        snd_pcm_set_sync(substream);    // ???

        runtime->hw = snd_korg1212_capture_info;
	runtime->dma_area = (char *) korg1212->recordDataBufsPtr;
	runtime->dma_bytes = K1212_BUF_SIZE;

        korg1212->capture_substream = substream;
        korg1212->periodsize = K1212_PERIODS;

        spin_unlock_irqrestore(&korg1212->lock, flags);

        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, K1212_BUF_SIZE, K1212_BUF_SIZE);
        snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
        return 0;
}

static int snd_korg1212_playback_close(snd_pcm_substream_t *substream)
{
        unsigned long flags;
        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);

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

        spin_lock_irqsave(&korg1212->lock, flags);

        korg1212->playback_substream = NULL;
        korg1212->periodsize = 0;

        snd_korg1212_CloseCard(korg1212);

        spin_unlock_irqrestore(&korg1212->lock, flags);
        return 0;
}

static int snd_korg1212_capture_close(snd_pcm_substream_t *substream)
{
        unsigned long flags;
        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);

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

        spin_lock_irqsave(&korg1212->lock, flags);

        korg1212->capture_substream = NULL;
        korg1212->periodsize = 0;

        snd_korg1212_CloseCard(korg1212);

        spin_unlock_irqrestore(&korg1212->lock, flags);
        return 0;
}

static int snd_korg1212_channel_info(snd_pcm_substream_t *substream,
				    snd_pcm_channel_info_t *info)
{
	int chn = info->channel;

	// snd_assert(info->channel < kAudioChannels + 1, return -EINVAL);

        info->offset = 0;
        // if (chn < k16BitChannels) {
                info->first = chn * 16;
        // } else {
        //         info->first = k16BitChannels * 16 + (chn - k16BitChannels - 1) * 32;
        // }
        info->step = sizeof(KorgAudioFrame) * 8;

#ifdef DEBUG
		PRINTK("DEBUG: snd_korg1212_channel_info %d:, offset=%ld, first=%d, step=%d\n", chn, info->offset, info->first, info->step);
#endif

	return 0;
}

static int snd_korg1212_ioctl(snd_pcm_substream_t *substream,
			     unsigned int cmd, void *arg)
{
#ifdef DEBUG
		PRINTK("DEBUG: snd_korg1212_ioctl: cmd=%d\n", cmd);
#endif
	if (cmd == SNDRV_PCM_IOCTL1_CHANNEL_INFO ) {
		snd_pcm_channel_info_t *info = arg;
		return snd_korg1212_channel_info(substream, info);
	}

        return snd_pcm_lib_ioctl(substream, cmd, arg);
}

static int snd_korg1212_hw_params(snd_pcm_substream_t *substream,
                             snd_pcm_hw_params_t *params)
{
        unsigned long flags;
        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
        int err;

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

        spin_lock_irqsave(&korg1212->lock, flags);
        if ((err = snd_korg1212_SetRate(korg1212, params_rate(params))) < 0) {
                spin_unlock_irqrestore(&korg1212->lock, flags);
                return err;
        }

        if (params_format(params) != SNDRV_PCM_FORMAT_S16_LE) {
                spin_unlock_irqrestore(&korg1212->lock, flags);
                return -EINVAL;
        }

        korg1212->periodsize = K1212_BLOCK_SIZE;

        spin_unlock_irqrestore(&korg1212->lock, flags);

        return 0;
}

static int snd_korg1212_prepare(snd_pcm_substream_t *substream)
{
        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
        unsigned long flags;

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

        spin_lock_irqsave(&korg1212->lock, flags);

        snd_korg1212_SetupForPlay(korg1212);

        korg1212->currentBuffer = -1;

        spin_unlock_irqrestore(&korg1212->lock, flags);
        return 0;
}

static int snd_korg1212_trigger(snd_pcm_substream_t *substream,
                           int cmd)
{
        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);

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

        switch (cmd) {
                case SNDRV_PCM_TRIGGER_START:
                        korg1212->running = 1;
                        snd_korg1212_TriggerPlay(korg1212);
                        break;