korg1212.c

是关于linux2.5.1的完全源码

                case SNDRV_PCM_TRIGGER_STOP:
                        korg1212->running = 0;
                        snd_korg1212_StopPlay(korg1212);
                        break;

                default:
                        return -EINVAL;
        }
        return 0;
}

static snd_pcm_uframes_t snd_korg1212_pointer(snd_pcm_substream_t *substream)
{
        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
        snd_pcm_uframes_t pos;

	if (korg1212->currentBuffer < 0)
		return 0;

	pos = korg1212->currentBuffer * kPlayBufferFrames;

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

        return pos;
}

static int snd_korg1212_playback_copy(snd_pcm_substream_t *substream,
                        int channel, /* not used (interleaved data) */
                        snd_pcm_uframes_t pos,
                        void *src,
                        snd_pcm_uframes_t count)
{
        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
	KorgAudioFrame * dst = korg1212->playDataBufsPtr[0].bufferData + pos;

#ifdef DEBUG
		PRINTK("DEBUG: snd_korg1212_playback_copy [%s] %ld %ld\n", stateName[korg1212->cardState], pos, count);
#endif
 
	snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL);

        copy_from_user(dst, src, count * K1212_FRAME_SIZE);

        return 0;
}

static int snd_korg1212_capture_copy(snd_pcm_substream_t *substream,
                        int channel, /* not used (interleaved data) */
                        snd_pcm_uframes_t pos,
                        void *dst,
                        snd_pcm_uframes_t count)
{
        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
	KorgAudioFrame * src = korg1212->recordDataBufsPtr[0].bufferData + pos;

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

	snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL);

        copy_to_user(dst, src, count * K1212_FRAME_SIZE);

        return 0;
}

static int snd_korg1212_playback_silence(snd_pcm_substream_t *substream,
                           int channel, /* not used (interleaved data) */
                           snd_pcm_uframes_t pos,
                           snd_pcm_uframes_t count)
{
        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
	KorgAudioFrame * dst = korg1212->playDataBufsPtr[0].bufferData + pos;

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

	snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL);

        memset(dst, 0, count * K1212_FRAME_SIZE);

        return 0;
}

static snd_pcm_ops_t snd_korg1212_playback_ops = {
        open:           snd_korg1212_playback_open,
        close:          snd_korg1212_playback_close,
        ioctl:          snd_korg1212_ioctl,
        hw_params:      snd_korg1212_hw_params,
        prepare:        snd_korg1212_prepare,
        trigger:        snd_korg1212_trigger,
        pointer:        snd_korg1212_pointer,
        copy:           snd_korg1212_playback_copy,
        silence:        snd_korg1212_playback_silence,
};

static snd_pcm_ops_t snd_korg1212_capture_ops = {
	open:		snd_korg1212_capture_open,
	close:		snd_korg1212_capture_close,
	ioctl:		snd_korg1212_ioctl,
	hw_params:	snd_korg1212_hw_params,
	prepare:	snd_korg1212_prepare,
	trigger:	snd_korg1212_trigger,
	pointer:	snd_korg1212_pointer,
	copy:		snd_korg1212_capture_copy,
};

/*
 * Control Interface
 */

static int snd_korg1212_control_phase_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
{
	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
	uinfo->count = (kcontrol->private_value >= 8) ? 2 : 1;
	return 0;
}

static int snd_korg1212_control_phase_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u)
{
	korg1212_t *korg1212 = _snd_kcontrol_chip(kcontrol);
	unsigned long flags;
	int i = kcontrol->private_value;

	spin_lock_irqsave(&korg1212->lock, flags);

        u->value.integer.value[0] = korg1212->volumePhase[i];

	if (i >= 8) 
        	u->value.integer.value[1] = korg1212->volumePhase[i+1];

        spin_unlock_irqrestore(&korg1212->lock, flags);

        return 0;
}

static int snd_korg1212_control_phase_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u)
{
	korg1212_t *korg1212 = _snd_kcontrol_chip(kcontrol);
	unsigned long flags;
        int change = 0;
        int i, val;

	spin_lock_irqsave(&korg1212->lock, flags);

	i = kcontrol->private_value;

	korg1212->volumePhase[i] = u->value.integer.value[0];

	val = korg1212->sharedBufferPtr->volumeData[kcontrol->private_value];

	if ((u->value.integer.value[0] > 0) != (val < 0)) {
		val = abs(val) * (korg1212->volumePhase[i] > 0 ? -1 : 1);
		korg1212->sharedBufferPtr->volumeData[i] = val;
		change = 1;
	}

	if (i >= 8) {
		korg1212->volumePhase[i+1] = u->value.integer.value[1];

		val = korg1212->sharedBufferPtr->volumeData[kcontrol->private_value+1];

		if ((u->value.integer.value[1] > 0) != (val < 0)) {
			val = abs(val) * (korg1212->volumePhase[i+1] > 0 ? -1 : 1);
			korg1212->sharedBufferPtr->volumeData[i+1] = val;
			change = 1;
		}
	}

	spin_unlock_irqrestore(&korg1212->lock, flags);

        return change;
}

static int snd_korg1212_control_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
{
        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	uinfo->count = (kcontrol->private_value >= 8) ? 2 : 1;
        uinfo->value.integer.min = k1212MinVolume;
	uinfo->value.integer.max = k1212MaxVolume;
        return 0;
}

static int snd_korg1212_control_volume_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u)
{
	korg1212_t *korg1212 = _snd_kcontrol_chip(kcontrol);
	unsigned long flags;
        int i;

	spin_lock_irqsave(&korg1212->lock, flags);

	i = kcontrol->private_value;
        u->value.integer.value[0] = abs(korg1212->sharedBufferPtr->volumeData[i]);

	if (i >= 8) 
                u->value.integer.value[1] = abs(korg1212->sharedBufferPtr->volumeData[i+1]);

        spin_unlock_irqrestore(&korg1212->lock, flags);

        return 0;
}

static int snd_korg1212_control_volume_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u)
{
	korg1212_t *korg1212 = _snd_kcontrol_chip(kcontrol);
	unsigned long flags;
        int change = 0;
        int i;
	int val;

	spin_lock_irqsave(&korg1212->lock, flags);

	i = kcontrol->private_value;

	if (u->value.integer.value[0] != abs(korg1212->sharedBufferPtr->volumeData[i])) {
		val = korg1212->volumePhase[i] > 0 ? -1 : 1;
		val *= u->value.integer.value[0];
		korg1212->sharedBufferPtr->volumeData[i] = val;
		change = 1;
	}

	if (i >= 8) {
		if (u->value.integer.value[1] != abs(korg1212->sharedBufferPtr->volumeData[i+1])) {
			val = korg1212->volumePhase[i+1] > 0 ? -1 : 1;
			val *= u->value.integer.value[1];
			korg1212->sharedBufferPtr->volumeData[i+1] = val;
			change = 1;
		}
	}

	spin_unlock_irqrestore(&korg1212->lock, flags);

        return change;
}

static int snd_korg1212_control_route_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
{
	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	uinfo->count = (kcontrol->private_value >= 8) ? 2 : 1;
	uinfo->value.enumerated.items = kAudioChannels;
	if (uinfo->value.enumerated.item > kAudioChannels-1) {
		uinfo->value.enumerated.item = kAudioChannels-1;
	}
	strcpy(uinfo->value.enumerated.name, channelName[uinfo->value.enumerated.item]);
	return 0;
}

static int snd_korg1212_control_route_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u)
{
	korg1212_t *korg1212 = _snd_kcontrol_chip(kcontrol);
	unsigned long flags;
        int i;

	spin_lock_irqsave(&korg1212->lock, flags);

	i = kcontrol->private_value;
	u->value.enumerated.item[0] = korg1212->sharedBufferPtr->routeData[i];

	if (i >= 8) 
		u->value.enumerated.item[1] = korg1212->sharedBufferPtr->routeData[i+1];

        spin_unlock_irqrestore(&korg1212->lock, flags);

        return 0;
}

static int snd_korg1212_control_route_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u)
{
	korg1212_t *korg1212 = _snd_kcontrol_chip(kcontrol);
	unsigned long flags;
        int change = 0, i;

	spin_lock_irqsave(&korg1212->lock, flags);

	i = kcontrol->private_value;

	if (u->value.enumerated.item[0] != korg1212->sharedBufferPtr->volumeData[i]) {
		korg1212->sharedBufferPtr->routeData[i] = u->value.enumerated.item[0];
		change = 1;
	}

	if (i >= 8) {
		if (u->value.enumerated.item[1] != korg1212->sharedBufferPtr->volumeData[i+1]) {
			korg1212->sharedBufferPtr->routeData[i+1] = u->value.enumerated.item[1];
			change = 1;
		}
	}

	spin_unlock_irqrestore(&korg1212->lock, flags);

        return change;
}

static int snd_korg1212_control_analog_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
{
        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
        uinfo->count = 2;
        uinfo->value.integer.min = k1212MaxADCSens;
	uinfo->value.integer.max = k1212MinADCSens;
        return 0;
}

static int snd_korg1212_control_analog_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u)
{
	korg1212_t *korg1212 = _snd_kcontrol_chip(kcontrol);
	unsigned long flags;

	spin_lock_irqsave(&korg1212->lock, flags);

        u->value.integer.value[0] = korg1212->leftADCInSens;
        u->value.integer.value[1] = korg1212->rightADCInSens;

        spin_unlock_irqrestore(&korg1212->lock, flags);

        return 0;
}

static int snd_korg1212_control_analog_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u)
{
	korg1212_t *korg1212 = _snd_kcontrol_chip(kcontrol);
	unsigned long flags;
        int change = 0;

	spin_lock_irqsave(&korg1212->lock, flags);

        if (u->value.integer.value[0] != korg1212->leftADCInSens) {
                korg1212->leftADCInSens = u->value.integer.value[0];
                change = 1;
        }
        if (u->value.integer.value[1] != korg1212->rightADCInSens) {
                korg1212->rightADCInSens = u->value.integer.value[1];
                change = 1;
        }

        if (change)
                snd_korg1212_WriteADCSensitivity(korg1212);

	spin_unlock_irqrestore(&korg1212->lock, flags);

        return change;
}

static int snd_korg1212_control_sync_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
{
	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	uinfo->count = 1;
	uinfo->value.enumerated.items =