1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//前为kcontrol辅助定义宏
#define SOC_SINGLE(xname, reg, shift, max, invert) 
 {   .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, 
     .info = snd_soc_info_volsw, 
     .get = snd_soc_get_volsw,
     .put = snd_soc_put_volsw, 
     .private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
     
/* dapm kcontrol types */
 #define SOC_DAPM_SINGLE(xname, reg, shift, max, invert) 
{   .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, 
    .info = snd_soc_info_volsw, 
    .get = snd_soc_dapm_get_volsw, 
    .put = snd_soc_dapm_put_volsw, 
    .private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
/**
 * snd_soc_dapm_get_volsw - dapm mixer get callback
 * @kcontrol: mixer control
 * @ucontrol: control element information
 *
 * Callback to get the value of a dapm mixer control.
 *
 * Returns 0 for success.
 */
int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
	struct snd_soc_card *card = dapm->card;
	struct soc_mixer_control *mc =
		(struct soc_mixer_control *)kcontrol->private_value;
	int reg = mc->reg;
	unsigned int shift = mc->shift;
	int max = mc->max;
	unsigned int mask = (1 << fls(max)) - 1;
	unsigned int invert = mc->invert;
	unsigned int val;
	int ret = 0;

	if (snd_soc_volsw_is_stereo(mc))
		dev_warn(dapm->dev,
			 "ASoC: Control '%s' is stereo, which is not supportedn",
			 kcontrol->id.name);

	mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
	if (dapm_kcontrol_is_powered(kcontrol) && reg != SND_SOC_NOPM) {
		ret = soc_dapm_read(dapm, reg, &val);
		val = (val >> shift) & mask;
	} else {
		val = dapm_kcontrol_get_value(kcontrol);
	}
	mutex_unlock(&card->dapm_mutex);

	if (ret)
		return ret;

	if (invert)
		ucontrol->value.integer.value[0] = max - val;
	else
		ucontrol->value.integer.value[0] = val;

	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/**
 * snd_soc_add_codec_controls - add an array of controls to a codec.
 * Convenience function to add a list of controls. Many codecs were
 * duplicating this code.
 *
 * @codec: codec to add controls to
 * @controls: array of controls to add
 * @num_controls: number of elements in the array
 *
 * Return 0 for success, else error.
 */
int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
	const struct snd_kcontrol_new *controls, unsigned int num_controls)
{
	return snd_soc_add_component_controls(&codec->component, controls,
		num_controls);
}

/**
 * snd_soc_add_component_controls - Add an array of controls to a component.
 *
 * @component: Component to add controls to
 * @controls: Array of controls to add
 * @num_controls: Number of elements in the array
 *
 * Return: 0 for success, else error.
 */
int snd_soc_add_component_controls(struct snd_soc_component *component,
	const struct snd_kcontrol_new *controls, unsigned int num_controls)
{
	struct snd_card *card = component->card->snd_card;

	return snd_soc_add_controls(card, component->dev, controls,
			num_controls, component->name_prefix, component);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
static int snd_soc_add_controls(struct snd_card *card, struct device *dev,
	const struct snd_kcontrol_new *controls, int num_controls,
	const char *prefix, void *data)
{
	int err, i;

	for (i = 0; i < num_controls; i++) {
		const struct snd_kcontrol_new *control = &controls[i];
		err = snd_ctl_add(card, snd_soc_cnew(control, data,
						     control->name, prefix));
		if (err < 0) {
			dev_err(dev, "ASoC: Failed to add %s: %dn",
				control->name, err);
			return err;
		}
	}

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/**
 * snd_soc_cnew - create new control
 * @_template: control template
 * @data: control private data
 * @long_name: control long name
 * @prefix: control name prefix
 *
 * Create a new mixer control from a template control.
 *
 * Returns 0 for success, else error.
 */
struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
				  void *data, const char *long_name,
				  const char *prefix)
{
	struct snd_kcontrol_new template;
	struct snd_kcontrol *kcontrol;
	char *name = NULL;

	memcpy(&template, _template, sizeof(template));
	template.index = 0;

	if (!long_name)
		long_name = template.name;

	if (prefix) {
		name = kasprintf(GFP_KERNEL, "%s %s", prefix, long_name);
		if (!name)
			return NULL;

		template.name = name;
	} else {
		template.name = long_name;
	}

	kcontrol = snd_ctl_new1(&template, data);

	kfree(name);

	return kcontrol;
}
EXPORT_SYMBOL_GPL(snd_soc_cnew);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 /**
 221  * snd_ctl_new1 - create a control instance from the template
 222  * @ncontrol: the initialization record
 223  * @private_data: the private data to set
 224  *
 225  * Allocates a new struct snd_kcontrol instance and initialize from the given
 226  * template.  When the access field of ncontrol is 0, it's assumed as
 227  * READWRITE access. When the count field is 0, it's assumes as one.
 228  *
 229  * Return: The pointer of the newly generated instance, or %NULL on failure.
 230  */
 231 struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol,
 232                   void *private_data)
 233 {
 234     struct snd_kcontrol kctl;
 235     unsigned int access;
 236
 237     if (snd_BUG_ON(!ncontrol || !ncontrol->info))
 238         return NULL;
 239     memset(&kctl, 0, sizeof(kctl));
 240     kctl.id.iface = ncontrol->iface;
 241     kctl.id.device = ncontrol->device;
 242     kctl.id.subdevice = ncontrol->subdevice;
 243     if (ncontrol->name) {
 244         strlcpy(kctl.id.name, ncontrol->name, sizeof(kctl.id.name));
 245         if (strcmp(ncontrol->name, kctl.id.name) != 0)
 246             snd_printk(KERN_WARNING
 247                    "Control name '%s' truncated to '%s'n",
 248                    ncontrol->name, kctl.id.name);
 249     }
 250     kctl.id.index = ncontrol->index;
 251     kctl.count = ncontrol->count ? ncontrol->count : 1;
 252     access = ncontrol->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
 253          (ncontrol->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|
 254                       SNDRV_CTL_ELEM_ACCESS_VOLATILE|
 255                       SNDRV_CTL_ELEM_ACCESS_INACTIVE|
 256                       SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE|
 257                       SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND|
 258                       SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK));
 259     kctl.info = ncontrol->info;
 260     kctl.get = ncontrol->get;
 261     kctl.put = ncontrol->put;
 262     kctl.tlv.p = ncontrol->tlv.p;
 263     kctl.private_value = ncontrol->private_value;
 264     kctl.private_data = private_data;
 265     return snd_ctl_new(&kctl, access);
 266 }