[deliverable/linux.git] / sound / drivers / pcsp / pcsp_mixer.c

/*
 * PC-Speaker driver for Linux
 *
 * Mixer implementation.
 * Copyright (C) 2001-2008  Stas Sergeev
 */

#include <sound/core.h>
#include <sound/control.h>
#include "pcsp.h"


static int pcsp_enable_info(struct snd_kcontrol *kcontrol,
			    struct snd_ctl_elem_info *uinfo)
{
	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
	uinfo->count = 1;
	uinfo->value.integer.min = 0;
	uinfo->value.integer.max = 1;
	return 0;
}

static int pcsp_enable_get(struct snd_kcontrol *kcontrol,
			   struct snd_ctl_elem_value *ucontrol)
{
	struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
	ucontrol->value.integer.value[0] = chip->enable;
	return 0;
}

static int pcsp_enable_put(struct snd_kcontrol *kcontrol,
			   struct snd_ctl_elem_value *ucontrol)
{
	struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
	int changed = 0;
	int enab = ucontrol->value.integer.value[0];
	if (enab != chip->enable) {
		chip->enable = enab;
		changed = 1;
	}
	return changed;
}

static int pcsp_treble_info(struct snd_kcontrol *kcontrol,
			    struct snd_ctl_elem_info *uinfo)
{
	struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	uinfo->count = 1;
	uinfo->value.enumerated.items = chip->max_treble + 1;
	if (uinfo->value.enumerated.item > chip->max_treble)
		uinfo->value.enumerated.item = chip->max_treble;
	sprintf(uinfo->value.enumerated.name, "%lu",
		(unsigned long)PCSP_CALC_RATE(uinfo->value.enumerated.item));
	return 0;
}

static int pcsp_treble_get(struct snd_kcontrol *kcontrol,
			   struct snd_ctl_elem_value *ucontrol)
{
	struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
	ucontrol->value.enumerated.item[0] = chip->treble;
	return 0;
}

static int pcsp_treble_put(struct snd_kcontrol *kcontrol,
			   struct snd_ctl_elem_value *ucontrol)
{
	struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
	int changed = 0;
	int treble = ucontrol->value.enumerated.item[0];
	if (treble != chip->treble) {
		chip->treble = treble;
#if PCSP_DEBUG
		printk(KERN_INFO "PCSP: rate set to %i\n", PCSP_RATE());
#endif
		changed = 1;
	}
	return changed;
}

static int pcsp_pcspkr_info(struct snd_kcontrol *kcontrol,
			    struct snd_ctl_elem_info *uinfo)
{
	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
	uinfo->count = 1;
	uinfo->value.integer.min = 0;
	uinfo->value.integer.max = 1;
	return 0;
}

static int pcsp_pcspkr_get(struct snd_kcontrol *kcontrol,
			   struct snd_ctl_elem_value *ucontrol)
{
	struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
	ucontrol->value.integer.value[0] = chip->pcspkr;
	return 0;
}

static int pcsp_pcspkr_put(struct snd_kcontrol *kcontrol,
			   struct snd_ctl_elem_value *ucontrol)
{
	struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
	int changed = 0;
	int spkr = ucontrol->value.integer.value[0];
	if (spkr != chip->pcspkr) {
		chip->pcspkr = spkr;
		changed = 1;
	}
	return changed;
}

#define PCSP_MIXER_CONTROL(ctl_type, ctl_name) \
{ \
	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER, \
	.name =		ctl_name, \
	.info =		pcsp_##ctl_type##_info, \
	.get =		pcsp_##ctl_type##_get, \
	.put =		pcsp_##ctl_type##_put, \
}

static struct snd_kcontrol_new __devinitdata snd_pcsp_controls[] = {
	PCSP_MIXER_CONTROL(enable, "Master Playback Switch"),
	PCSP_MIXER_CONTROL(treble, "BaseFRQ Playback Volume"),
	PCSP_MIXER_CONTROL(pcspkr, "PC Speaker Playback Switch"),
};

int __devinit snd_pcsp_new_mixer(struct snd_pcsp *chip)
{
	struct snd_card *card = chip->card;
	int i, err;

	for (i = 0; i < ARRAY_SIZE(snd_pcsp_controls); i++) {
		err = snd_ctl_add(card,
				 snd_ctl_new1(snd_pcsp_controls + i,
					      chip));
		if (err < 0)
			return err;
	}

	strcpy(card->mixername, "PC-Speaker");

	return 0;
}
Commit	Line	Data
9ab4d072 SS	1	/*
	2	* PC-Speaker driver for Linux
	3	*
	4	* Mixer implementation.
	5	* Copyright (C) 2001-2008 Stas Sergeev
	6	*/
	7
	8	#include <sound/core.h>
	9	#include <sound/control.h>
	10	#include "pcsp.h"
	11
	12
	13	static int pcsp_enable_info(struct snd_kcontrol *kcontrol,
	14	struct snd_ctl_elem_info *uinfo)
	15	{
	16	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
	17	uinfo->count = 1;
	18	uinfo->value.integer.min = 0;
	19	uinfo->value.integer.max = 1;
	20	return 0;
	21	}
	22
	23	static int pcsp_enable_get(struct snd_kcontrol *kcontrol,
	24	struct snd_ctl_elem_value *ucontrol)
	25	{
	26	struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
	27	ucontrol->value.integer.value[0] = chip->enable;
	28	return 0;
	29	}
	30
	31	static int pcsp_enable_put(struct snd_kcontrol *kcontrol,
	32	struct snd_ctl_elem_value *ucontrol)
	33	{
	34	struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
	35	int changed = 0;
	36	int enab = ucontrol->value.integer.value[0];
	37	if (enab != chip->enable) {
	38	chip->enable = enab;
	39	changed = 1;
	40	}
	41	return changed;
	42	}
	43
	44	static int pcsp_treble_info(struct snd_kcontrol *kcontrol,
	45	struct snd_ctl_elem_info *uinfo)
	46	{
	47	struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
	48	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	49	uinfo->count = 1;
	50	uinfo->value.enumerated.items = chip->max_treble + 1;
	51	if (uinfo->value.enumerated.item > chip->max_treble)
	52	uinfo->value.enumerated.item = chip->max_treble;
5a641bcd	53	sprintf(uinfo->value.enumerated.name, "%lu",
b3b778b3	54	(unsigned long)PCSP_CALC_RATE(uinfo->value.enumerated.item));
9ab4d072 SS	55	return 0;
	56	}
	57
	58	static int pcsp_treble_get(struct snd_kcontrol *kcontrol,
	59	struct snd_ctl_elem_value *ucontrol)
	60	{
	61	struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
	62	ucontrol->value.enumerated.item[0] = chip->treble;
	63	return 0;
	64	}
	65
	66	static int pcsp_treble_put(struct snd_kcontrol *kcontrol,
	67	struct snd_ctl_elem_value *ucontrol)
	68	{
	69	struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
	70	int changed = 0;
	71	int treble = ucontrol->value.enumerated.item[0];
	72	if (treble != chip->treble) {
	73	chip->treble = treble;
	74	#if PCSP_DEBUG
	75	printk(KERN_INFO "PCSP: rate set to %i\n", PCSP_RATE());
	76	#endif
	77	changed = 1;
	78	}
	79	return changed;
	80	}
	81
	82	static int pcsp_pcspkr_info(struct snd_kcontrol *kcontrol,
	83	struct snd_ctl_elem_info *uinfo)
	84	{
	85	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
	86	uinfo->count = 1;
	87	uinfo->value.integer.min = 0;
	88	uinfo->value.integer.max = 1;
	89	return 0;
	90	}
	91
	92	static int pcsp_pcspkr_get(struct snd_kcontrol *kcontrol,
	93	struct snd_ctl_elem_value *ucontrol)
	94	{
	95	struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
	96	ucontrol->value.integer.value[0] = chip->pcspkr;
	97	return 0;
	98	}
	99
	100	static int pcsp_pcspkr_put(struct snd_kcontrol *kcontrol,
	101	struct snd_ctl_elem_value *ucontrol)
	102	{
	103	struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
	104	int changed = 0;
	105	int spkr = ucontrol->value.integer.value[0];
	106	if (spkr != chip->pcspkr) {
	107	chip->pcspkr = spkr;
	108	changed = 1;
	109	}
	110	return changed;
	111	}
	112
	113	#define PCSP_MIXER_CONTROL(ctl_type, ctl_name) \
	114	{ \
	115	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
	116	.name = ctl_name, \
	117	.info = pcsp_##ctl_type##_info, \
	118	.get = pcsp_##ctl_type##_get, \
119	.put = pcsp_##ctl_type##_put, \
120	}
121
122	static struct snd_kcontrol_new __devinitdata snd_pcsp_controls[] = {
123	PCSP_MIXER_CONTROL(enable, "Master Playback Switch"),
124	PCSP_MIXER_CONTROL(treble, "BaseFRQ Playback Volume"),
125	PCSP_MIXER_CONTROL(pcspkr, "PC Speaker Playback Switch"),
126	};
127
128	int __devinit snd_pcsp_new_mixer(struct snd_pcsp *chip)
129	{
130	struct snd_card *card = chip->card;
131	int i, err;
132
133	for (i = 0; i < ARRAY_SIZE(snd_pcsp_controls); i++) {
134	err = snd_ctl_add(card,
135	snd_ctl_new1(snd_pcsp_controls + i,
136	chip));
137	if (err < 0)
138	return err;
139	}
140
141	strcpy(card->mixername, "PC-Speaker");
142
143	return 0;
144	}