emufx.c

来自「Linux Kernel 2.6.9 for OMAP1710」· C语言 代码 · 共 1,713 行 · 第 1/5 页

	unsigned long flags;
	unsigned int nval, val;
	unsigned int i, j;
	int change = 0;
	
	spin_lock_irqsave(&emu->reg_lock, flags);
	for (i = 0; i < ctl->vcount; i++) {
		nval = ucontrol->value.integer.value[i];
		if (nval < ctl->min)
			nval = ctl->min;
		if (nval > ctl->max)
			nval = ctl->max;
		if (nval != ctl->value[i])
			change = 1;
		val = ctl->value[i] = nval;
		switch (ctl->translation) {
		case EMU10K1_GPR_TRANSLATION_NONE:
			snd_emu10k1_ptr_write(emu, emu->gpr_base + ctl->gpr[i], 0, val);
			break;
		case EMU10K1_GPR_TRANSLATION_TABLE100:
			snd_emu10k1_ptr_write(emu, emu->gpr_base + ctl->gpr[i], 0, db_table[val]);
			break;
		case EMU10K1_GPR_TRANSLATION_BASS:
			snd_runtime_check((ctl->count % 5) == 0 && (ctl->count / 5) == ctl->vcount, change = -EIO; goto __error);
			for (j = 0; j < 5; j++)
				snd_emu10k1_ptr_write(emu, emu->gpr_base + ctl->gpr[j * ctl->vcount + i], 0, bass_table[val][j]);
			break;
		case EMU10K1_GPR_TRANSLATION_TREBLE:
			snd_runtime_check((ctl->count % 5) == 0 && (ctl->count / 5) == ctl->vcount, change = -EIO; goto __error);
			for (j = 0; j < 5; j++)
				snd_emu10k1_ptr_write(emu, emu->gpr_base + ctl->gpr[j * ctl->vcount + i], 0, treble_table[val][j]);
			break;
		case EMU10K1_GPR_TRANSLATION_ONOFF:
			snd_emu10k1_ptr_write(emu, emu->gpr_base + ctl->gpr[i], 0, onoff_table[val]);
			break;
		}
	}
      __error:
	spin_unlock_irqrestore(&emu->reg_lock, flags);
	return change;
}

/*
 *   Interrupt handler
 */

static void snd_emu10k1_fx8010_interrupt(emu10k1_t *emu)
{
	snd_emu10k1_fx8010_irq_t *irq, *nirq;

	irq = emu->fx8010.irq_handlers;
	while (irq) {
		nirq = irq->next;	/* irq ptr can be removed from list */
		if (snd_emu10k1_ptr_read(emu, emu->gpr_base + irq->gpr_running, 0) & 0xffff0000) {
			if (irq->handler)
				irq->handler(emu, irq->private_data);
			snd_emu10k1_ptr_write(emu, emu->gpr_base + irq->gpr_running, 0, 1);
		}
		irq = nirq;
	}
}

int snd_emu10k1_fx8010_register_irq_handler(emu10k1_t *emu,
						   snd_fx8010_irq_handler_t *handler,
						   unsigned char gpr_running,
						   void *private_data,
						   snd_emu10k1_fx8010_irq_t **r_irq)
{
	snd_emu10k1_fx8010_irq_t *irq;
	unsigned long flags;
	
	snd_runtime_check(emu, return -EINVAL);
	snd_runtime_check(handler, return -EINVAL);
	irq = kmalloc(sizeof(*irq), GFP_ATOMIC);
	if (irq == NULL)
		return -ENOMEM;
	irq->handler = handler;
	irq->gpr_running = gpr_running;
	irq->private_data = private_data;
	irq->next = NULL;
	spin_lock_irqsave(&emu->fx8010.irq_lock, flags);
	if (emu->fx8010.irq_handlers == NULL) {
		emu->fx8010.irq_handlers = irq;
		emu->dsp_interrupt = snd_emu10k1_fx8010_interrupt;
		snd_emu10k1_intr_enable(emu, INTE_FXDSPENABLE);
	} else {
		irq->next = emu->fx8010.irq_handlers;
		emu->fx8010.irq_handlers = irq;
	}
	spin_unlock_irqrestore(&emu->fx8010.irq_lock, flags);
	if (r_irq)
		*r_irq = irq;
	return 0;
}

int snd_emu10k1_fx8010_unregister_irq_handler(emu10k1_t *emu,
						     snd_emu10k1_fx8010_irq_t *irq)
{
	snd_emu10k1_fx8010_irq_t *tmp;
	unsigned long flags;
	
	snd_runtime_check(irq, return -EINVAL);
	spin_lock_irqsave(&emu->fx8010.irq_lock, flags);
	if ((tmp = emu->fx8010.irq_handlers) == irq) {
		emu->fx8010.irq_handlers = tmp->next;
		if (emu->fx8010.irq_handlers == NULL) {
			snd_emu10k1_intr_disable(emu, INTE_FXDSPENABLE);
			emu->dsp_interrupt = NULL;
		}
	} else {
		while (tmp && tmp->next != irq)
			tmp = tmp->next;
		if (tmp)
			tmp->next = tmp->next->next;
	}
	spin_unlock_irqrestore(&emu->fx8010.irq_lock, flags);
	kfree(irq);
	return 0;
}

/*************************************************************************
 * EMU10K1 effect manager
 *************************************************************************/

static void snd_emu10k1_write_op(emu10k1_fx8010_code_t *icode, unsigned int *ptr,
				 u32 op, u32 r, u32 a, u32 x, u32 y)
{
	snd_assert(*ptr < 512, return);
	set_bit(*ptr, icode->code_valid);
	icode->code[*ptr    ][0] = ((x & 0x3ff) << 10) | (y & 0x3ff);
	icode->code[(*ptr)++][1] = ((op & 0x0f) << 20) | ((r & 0x3ff) << 10) | (a & 0x3ff);
}

#define OP(icode, ptr, op, r, a, x, y) \
	snd_emu10k1_write_op(icode, ptr, op, r, a, x, y)

static void snd_emu10k1_audigy_write_op(emu10k1_fx8010_code_t *icode, unsigned int *ptr,
					u32 op, u32 r, u32 a, u32 x, u32 y)
{
	snd_assert(*ptr < 512, return);
	set_bit(*ptr, icode->code_valid);
	icode->code[*ptr    ][0] = ((x & 0x7ff) << 12) | (y & 0x7ff);
	icode->code[(*ptr)++][1] = ((op & 0x0f) << 24) | ((r & 0x7ff) << 12) | (a & 0x7ff);
}

#define A_OP(icode, ptr, op, r, a, x, y) \
	snd_emu10k1_audigy_write_op(icode, ptr, op, r, a, x, y)

void snd_emu10k1_efx_write(emu10k1_t *emu, unsigned int pc, unsigned int data)
{
	pc += emu->audigy ? A_MICROCODEBASE : MICROCODEBASE;
	snd_emu10k1_ptr_write(emu, pc, 0, data);
}

unsigned int snd_emu10k1_efx_read(emu10k1_t *emu, unsigned int pc)
{
	pc += emu->audigy ? A_MICROCODEBASE : MICROCODEBASE;
	return snd_emu10k1_ptr_read(emu, pc, 0);
}

static void snd_emu10k1_gpr_poke(emu10k1_t *emu, emu10k1_fx8010_code_t *icode)
{
	int gpr;

	for (gpr = 0; gpr < 0x100; gpr++) {
		if (!test_bit(gpr, icode->gpr_valid))
			continue;
		snd_emu10k1_ptr_write(emu, emu->gpr_base + gpr, 0, icode->gpr_map[gpr]);
	}
}

static void snd_emu10k1_gpr_peek(emu10k1_t *emu, emu10k1_fx8010_code_t *icode)
{
	int gpr;

	for (gpr = 0; gpr < 0x100; gpr++) {
		set_bit(gpr, icode->gpr_valid);
		icode->gpr_map[gpr] = snd_emu10k1_ptr_read(emu, emu->gpr_base + gpr, 0);
	}
}

static void snd_emu10k1_tram_poke(emu10k1_t *emu, emu10k1_fx8010_code_t *icode)
{
	int tram;

	for (tram = 0; tram < 0xa0; tram++) {
		if (!test_bit(tram, icode->tram_valid))
			continue;
		snd_emu10k1_ptr_write(emu, TANKMEMDATAREGBASE + tram, 0, icode->tram_data_map[tram]);
		snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + tram, 0, icode->tram_addr_map[tram]);
	}
}

static void snd_emu10k1_tram_peek(emu10k1_t *emu, emu10k1_fx8010_code_t *icode)
{
	int tram;

	memset(icode->tram_valid, 0, sizeof(icode->tram_valid));
	for (tram = 0; tram < 0xa0; tram++) {
		set_bit(tram, icode->tram_valid);
		icode->tram_data_map[tram] = snd_emu10k1_ptr_read(emu, TANKMEMDATAREGBASE + tram, 0);
		icode->tram_addr_map[tram] = snd_emu10k1_ptr_read(emu, TANKMEMADDRREGBASE + tram, 0);
	}
}

static void snd_emu10k1_code_poke(emu10k1_t *emu, emu10k1_fx8010_code_t *icode)
{
	u32 pc;

	for (pc = 0; pc < 512; pc++) {
		if (!test_bit(pc, icode->code_valid))
			continue;
		snd_emu10k1_efx_write(emu, pc * 2, icode->code[pc][0]);
		snd_emu10k1_efx_write(emu, pc * 2 + 1, icode->code[pc][1]);
	}
}

static void snd_emu10k1_code_peek(emu10k1_t *emu, emu10k1_fx8010_code_t *icode)
{
	u32 pc;

	memset(icode->code_valid, 0, sizeof(icode->code_valid));
	for (pc = 0; pc < 512; pc++) {
		set_bit(pc, icode->code_valid);
		icode->code[pc][0] = snd_emu10k1_efx_read(emu, pc * 2);
		icode->code[pc][1] = snd_emu10k1_efx_read(emu, pc * 2 + 1);
	}
}

static snd_emu10k1_fx8010_ctl_t *snd_emu10k1_look_for_ctl(emu10k1_t *emu, snd_ctl_elem_id_t *id)
{
	snd_emu10k1_fx8010_ctl_t *ctl;
	snd_kcontrol_t *kcontrol;
	struct list_head *list;
	
	list_for_each(list, &emu->fx8010.gpr_ctl) {
		ctl = emu10k1_gpr_ctl(list);
		kcontrol = ctl->kcontrol;
		if (kcontrol->id.iface == id->iface &&
		    !strcmp(kcontrol->id.name, id->name) &&
		    kcontrol->id.index == id->index)
			return ctl;
	}
	return NULL;
}

static int snd_emu10k1_verify_controls(emu10k1_t *emu, emu10k1_fx8010_code_t *icode)
{
	unsigned int i;
	snd_ctl_elem_id_t __user *_id;
	snd_ctl_elem_id_t id;
	emu10k1_fx8010_control_gpr_t __user *_gctl;
	emu10k1_fx8010_control_gpr_t gctl;
	
	for (i = 0, _id = icode->gpr_del_controls;
	     i < icode->gpr_del_control_count; i++, _id++) {
	     	if (copy_from_user(&id, _id, sizeof(id)))
	     		return -EFAULT;
		if (snd_emu10k1_look_for_ctl(emu, &id) == NULL)
			return -ENOENT;
	}
	for (i = 0, _gctl = icode->gpr_add_controls;
	     i < icode->gpr_add_control_count; i++, _gctl++) {
		if (copy_from_user(&gctl, _gctl, sizeof(gctl)))
			return -EFAULT;
		if (snd_emu10k1_look_for_ctl(emu, &gctl.id))
			continue;
		down_read(&emu->card->controls_rwsem);
		if (snd_ctl_find_id(emu->card, &gctl.id) != NULL) {
			up_read(&emu->card->controls_rwsem);
			return -EEXIST;
		}
		up_read(&emu->card->controls_rwsem);
		if (gctl.id.iface != SNDRV_CTL_ELEM_IFACE_MIXER &&
		    gctl.id.iface != SNDRV_CTL_ELEM_IFACE_PCM)
			return -EINVAL;
	}
	for (i = 0, _gctl = icode->gpr_list_controls;
	     i < icode->gpr_list_control_count; i++, _gctl++) {
	     	/* FIXME: we need to check the WRITE access */
		if (copy_from_user(&gctl, _gctl, sizeof(gctl)))
			return -EFAULT;
	}
	return 0;
}

static void snd_emu10k1_ctl_private_free(snd_kcontrol_t *kctl)
{
	snd_emu10k1_fx8010_ctl_t *ctl;
	
	ctl = (snd_emu10k1_fx8010_ctl_t *)kctl->private_value;
	kctl->private_value = 0;
	list_del(&ctl->list);
	kfree(ctl);
}

static void snd_emu10k1_add_controls(emu10k1_t *emu, emu10k1_fx8010_code_t *icode)
{
	unsigned int i, j;
	emu10k1_fx8010_control_gpr_t __user *_gctl;
	emu10k1_fx8010_control_gpr_t gctl;
	snd_emu10k1_fx8010_ctl_t *ctl, nctl;
	snd_kcontrol_new_t knew;
	snd_kcontrol_t *kctl;
	snd_ctl_elem_value_t *val;

	val = (snd_ctl_elem_value_t *)kmalloc(sizeof(*val), GFP_KERNEL);
	if (!val)
		return;
	for (i = 0, _gctl = icode->gpr_add_controls;
	     i < icode->gpr_add_control_count; i++, _gctl++) {
		if (copy_from_user(&gctl, _gctl, sizeof(gctl)))
			break;
		snd_runtime_check(gctl.id.iface == SNDRV_CTL_ELEM_IFACE_MIXER ||
		                  gctl.id.iface == SNDRV_CTL_ELEM_IFACE_PCM, continue);
		snd_runtime_check(gctl.id.name[0] != '\0', continue);
		ctl = snd_emu10k1_look_for_ctl(emu, &gctl.id);
		memset(&knew, 0, sizeof(knew));
		knew.iface = gctl.id.iface;
		knew.name = gctl.id.name;
		knew.index = gctl.id.index;
		knew.device = gctl.id.device;
		knew.subdevice = gctl.id.subdevice;
		knew.info = snd_emu10k1_gpr_ctl_info;
		knew.get = snd_emu10k1_gpr_ctl_get;
		knew.put = snd_emu10k1_gpr_ctl_put;
		memset(&nctl, 0, sizeof(nctl));
		nctl.vcount = gctl.vcount;
		nctl.count = gctl.count;
		for (j = 0; j < 32; j++) {
			nctl.gpr[j] = gctl.gpr[j];
			nctl.value[j] = ~gctl.value[j];	/* inverted, we want to write new value in gpr_ctl_put() */
			val->value.integer.value[j] = gctl.value[j];
		}
		nctl.min = gctl.min;
		nctl.max = gctl.max;
		nctl.translation = gctl.translation;
		if (ctl == NULL) {
			ctl = (snd_emu10k1_fx8010_ctl_t *)kmalloc(sizeof(*ctl), GFP_KERNEL);
			if (ctl == NULL)
				continue;
			knew.private_value = (unsigned long)ctl;
			memcpy(ctl, &nctl, sizeof(nctl));