summaryrefslogtreecommitdiff
path: root/sound/soc/codecs/cros_ec_codec.c
blob: 85beef265cc8255b6274374a53dbcdd0ac648263 (plain)
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
// SPDX-License-Identifier: GPL-2.0
/*
 * Driver for ChromeOS Embedded Controller codec.
 *
 * This driver uses the cros-ec interface to communicate with the ChromeOS
 * EC for audio function.
 */

#include <linux/delay.h>
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/mfd/cros_ec.h>
#include <linux/mfd/cros_ec_commands.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <sound/tlv.h>

#define DRV_NAME "cros-ec-codec"

/**
 * struct cros_ec_codec_data - ChromeOS EC codec driver data.
 * @dev:		Device structure used in sysfs.
 * @ec_device:		cros_ec_device structure to talk to the physical device.
 * @component:		Pointer to the component.
 * @max_dmic_gain:	Maximum gain in dB supported by EC codec.
 */
struct cros_ec_codec_data {
	struct device *dev;
	struct cros_ec_device *ec_device;
	struct snd_soc_component *component;
	unsigned int max_dmic_gain;
};

static const DECLARE_TLV_DB_SCALE(ec_mic_gain_tlv, 0, 100, 0);

static int ec_command_get_gain(struct snd_soc_component *component,
			       struct ec_param_codec_i2s *param,
			       struct ec_codec_i2s_gain *resp)
{
	struct cros_ec_codec_data *codec_data =
		snd_soc_component_get_drvdata(component);
	struct cros_ec_device *ec_device = codec_data->ec_device;
	u8 buffer[sizeof(struct cros_ec_command) +
		  max(sizeof(struct ec_param_codec_i2s),
		      sizeof(struct ec_codec_i2s_gain))];
	struct cros_ec_command *msg = (struct cros_ec_command *)&buffer;
	int ret;

	msg->version = 0;
	msg->command = EC_CMD_CODEC_I2S;
	msg->outsize = sizeof(struct ec_param_codec_i2s);
	msg->insize = sizeof(struct ec_codec_i2s_gain);

	memcpy(msg->data, param, msg->outsize);

	ret = cros_ec_cmd_xfer_status(ec_device, msg);
	if (ret > 0)
		memcpy(resp, msg->data, msg->insize);

	return ret;
}

/*
 * Wrapper for EC command without response.
 */
static int ec_command_no_resp(struct snd_soc_component *component,
			      struct ec_param_codec_i2s *param)
{
	struct cros_ec_codec_data *codec_data =
		snd_soc_component_get_drvdata(component);
	struct cros_ec_device *ec_device = codec_data->ec_device;
	u8 buffer[sizeof(struct cros_ec_command) +
		  sizeof(struct ec_param_codec_i2s)];
	struct cros_ec_command *msg = (struct cros_ec_command *)&buffer;

	msg->version = 0;
	msg->command = EC_CMD_CODEC_I2S;
	msg->outsize = sizeof(struct ec_param_codec_i2s);
	msg->insize = 0;

	memcpy(msg->data, param, msg->outsize);

	return cros_ec_cmd_xfer_status(ec_device, msg);
}

static int set_i2s_config(struct snd_soc_component *component,
			  enum ec_i2s_config i2s_config)
{
	struct ec_param_codec_i2s param;

	dev_dbg(component->dev, "%s set I2S format to %u\n", __func__,
		i2s_config);

	param.cmd = EC_CODEC_I2S_SET_CONFIG;
	param.i2s_config = i2s_config;

	return ec_command_no_resp(component, &param);
}

static int cros_ec_i2s_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
{
	struct snd_soc_component *component = dai->component;
	enum ec_i2s_config i2s_config;

	switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
	case SND_SOC_DAIFMT_CBS_CFS:
		break;
	default:
		return -EINVAL;
	}

	switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
	case SND_SOC_DAIFMT_NB_NF:
		break;
	default:
		return -EINVAL;
	}

	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
	case SND_SOC_DAIFMT_I2S:
		i2s_config = EC_DAI_FMT_I2S;
		break;

	case SND_SOC_DAIFMT_RIGHT_J:
		i2s_config = EC_DAI_FMT_RIGHT_J;
		break;

	case SND_SOC_DAIFMT_LEFT_J:
		i2s_config = EC_DAI_FMT_LEFT_J;
		break;

	case SND_SOC_DAIFMT_DSP_A:
		i2s_config = EC_DAI_FMT_PCM_A;
		break;

	case SND_SOC_DAIFMT_DSP_B:
		i2s_config = EC_DAI_FMT_PCM_B;
		break;

	default:
		return -EINVAL;
	}

	return set_i2s_config(component, i2s_config);
}

static int set_i2s_sample_depth(struct snd_soc_component *component,
				enum ec_sample_depth_value depth)
{
	struct ec_param_codec_i2s param;

	dev_dbg(component->dev, "%s set depth to %u\n", __func__, depth);

	param.cmd = EC_CODEC_SET_SAMPLE_DEPTH;
	param.depth = depth;

	return ec_command_no_resp(component, &param);
}

static int set_i2s_bclk(struct snd_soc_component *component, uint32_t bclk)
{
	struct ec_param_codec_i2s param;

	dev_dbg(component->dev, "%s set i2s bclk to %u\n", __func__, bclk);

	param.cmd = EC_CODEC_I2S_SET_BCLK;
	param.bclk = bclk;

	return ec_command_no_resp(component, &param);
}

static int cros_ec_i2s_hw_params(struct snd_pcm_substream *substream,
				 struct snd_pcm_hw_params *params,
				 struct snd_soc_dai *dai)
{
	struct snd_soc_component *component = dai->component;
	unsigned int rate, bclk;
	int ret;

	rate = params_rate(params);
	if (rate != 48000)
		return -EINVAL;

	switch (params_format(params)) {
	case SNDRV_PCM_FORMAT_S16_LE:
		ret = set_i2s_sample_depth(component, EC_CODEC_SAMPLE_DEPTH_16);
		break;
	case SNDRV_PCM_FORMAT_S24_LE:
		ret = set_i2s_sample_depth(component, EC_CODEC_SAMPLE_DEPTH_24);
		break;
	default:
		return -EINVAL;
	}
	if (ret < 0)
		return ret;

	bclk = snd_soc_params_to_bclk(params);
	return set_i2s_bclk(component, bclk);
}

static const struct snd_soc_dai_ops cros_ec_i2s_dai_ops = {
	.hw_params = cros_ec_i2s_hw_params,
	.set_fmt = cros_ec_i2s_set_dai_fmt,
};

static struct snd_soc_dai_driver cros_ec_dai[] = {
	{
		.name = "cros_ec_codec I2S",
		.id = 0,
		.capture = {
			.stream_name = "I2S Capture",
			.channels_min = 2,
			.channels_max = 2,
			.rates = SNDRV_PCM_RATE_48000,
			.formats = SNDRV_PCM_FMTBIT_S16_LE |
				   SNDRV_PCM_FMTBIT_S24_LE,
		},
		.ops = &cros_ec_i2s_dai_ops,
	}
};

static int get_ec_mic_gain(struct snd_soc_component *component,
			   u8 *left, u8 *right)
{
	struct ec_param_codec_i2s param;
	struct ec_codec_i2s_gain resp;
	int ret;

	param.cmd = EC_CODEC_GET_GAIN;

	ret = ec_command_get_gain(component, &param, &resp);
	if (ret < 0)
		return ret;

	*left = resp.left;
	*right = resp.right;

	return 0;
}

static int mic_gain_get(struct snd_kcontrol *kcontrol,
			struct snd_ctl_elem_value *ucontrol)
{
	struct snd_soc_component *component =
		snd_soc_kcontrol_component(kcontrol);
	u8 left, right;
	int ret;

	ret = get_ec_mic_gain(component, &left, &right);
	if (ret)
		return ret;

	ucontrol->value.integer.value[0] = left;
	ucontrol->value.integer.value[1] = right;

	return 0;
}

static int set_ec_mic_gain(struct snd_soc_component *component,
			   u8 left, u8 right)
{
	struct ec_param_codec_i2s param;

	dev_dbg(component->dev, "%s set mic gain to %u, %u\n",
		__func__, left, right);

	param.cmd = EC_CODEC_SET_GAIN;
	param.gain.left = left;
	param.gain.right = right;

	return ec_command_no_resp(component, &param);
}

static int mic_gain_put(struct snd_kcontrol *kcontrol,
			struct snd_ctl_elem_value *ucontrol)
{
	struct snd_soc_component *component =
		snd_soc_kcontrol_component(kcontrol);
	struct cros_ec_codec_data *codec_data =
		snd_soc_component_get_drvdata(component);
	int left = ucontrol->value.integer.value[0];
	int right = ucontrol->value.integer.value[1];
	unsigned int max_dmic_gain = codec_data->max_dmic_gain;

	if (left > max_dmic_gain || right > max_dmic_gain)
		return -EINVAL;

	return set_ec_mic_gain(component, (u8)left, (u8)right);
}

static struct snd_kcontrol_new mic_gain_control =
	SOC_DOUBLE_EXT_TLV("EC Mic Gain", SND_SOC_NOPM, SND_SOC_NOPM, 0, 0, 0,
			   mic_gain_get, mic_gain_put, ec_mic_gain_tlv);

static int enable_i2s(struct snd_soc_component *component, int enable)
{
	struct ec_param_codec_i2s param;

	dev_dbg(component->dev, "%s set i2s to %u\n", __func__, enable);

	param.cmd = EC_CODEC_I2S_ENABLE;
	param.i2s_enable = enable;

	return ec_command_no_resp(component, &param);
}

static int cros_ec_i2s_enable_event(struct snd_soc_dapm_widget *w,
				    struct snd_kcontrol *kcontrol, int event)
{
	struct snd_soc_component *component =
		snd_soc_dapm_to_component(w->dapm);

	switch (event) {
	case SND_SOC_DAPM_PRE_PMU:
		dev_dbg(component->dev,
			"%s got SND_SOC_DAPM_PRE_PMU event\n", __func__);
		return enable_i2s(component, 1);

	case SND_SOC_DAPM_PRE_PMD:
		dev_dbg(component->dev,
			"%s got SND_SOC_DAPM_PRE_PMD event\n", __func__);
		return enable_i2s(component, 0);
	}

	return 0;
}

/*
 * The goal of this DAPM route is to turn on/off I2S using EC
 * host command when capture stream is started/stopped.
 */
static const struct snd_soc_dapm_widget cros_ec_codec_dapm_widgets[] = {
	SND_SOC_DAPM_INPUT("DMIC"),

	/*
	 * Control EC to enable/disable I2S.
	 */
	SND_SOC_DAPM_SUPPLY("I2S Enable", SND_SOC_NOPM,
			    0, 0, cros_ec_i2s_enable_event,
			    SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_PRE_PMD),

	SND_SOC_DAPM_AIF_OUT("I2STX", "I2S Capture", 0, SND_SOC_NOPM, 0, 0),
};

static const struct snd_soc_dapm_route cros_ec_codec_dapm_routes[] = {
	{ "I2STX", NULL, "DMIC" },
	{ "I2STX", NULL, "I2S Enable" },
};

/*
 * Read maximum gain from device property and set it to mixer control.
 */
static int cros_ec_set_gain_range(struct device *dev)
{
	struct soc_mixer_control *control;
	struct cros_ec_codec_data *codec_data = dev_get_drvdata(dev);
	int rc;

	rc = device_property_read_u32(dev, "max-dmic-gain",
				      &codec_data->max_dmic_gain);
	if (rc)
		return rc;

	control = (struct soc_mixer_control *)
				mic_gain_control.private_value;
	control->max = codec_data->max_dmic_gain;
	control->platform_max = codec_data->max_dmic_gain;

	return 0;
}

static int cros_ec_codec_probe(struct snd_soc_component *component)
{
	int rc;

	struct cros_ec_codec_data *codec_data =
		snd_soc_component_get_drvdata(component);

	rc = cros_ec_set_gain_range(codec_data->dev);
	if (rc)
		return rc;

	return snd_soc_add_component_controls(component, &mic_gain_control, 1);
}

static const struct snd_soc_component_driver cros_ec_component_driver = {
	.probe			= cros_ec_codec_probe,
	.dapm_widgets		= cros_ec_codec_dapm_widgets,
	.num_dapm_widgets	= ARRAY_SIZE(cros_ec_codec_dapm_widgets),
	.dapm_routes		= cros_ec_codec_dapm_routes,
	.num_dapm_routes	= ARRAY_SIZE(cros_ec_codec_dapm_routes),
};

/*
 * Platform device and platform driver fro cros-ec-codec.
 */
static int cros_ec_codec_platform_probe(struct platform_device *pd)
{
	struct device *dev = &pd->dev;
	struct cros_ec_device *ec_device = dev_get_drvdata(pd->dev.parent);
	struct cros_ec_codec_data *codec_data;

	codec_data = devm_kzalloc(dev, sizeof(struct cros_ec_codec_data),
				  GFP_KERNEL);
	if (!codec_data)
		return -ENOMEM;

	codec_data->dev = dev;
	codec_data->ec_device = ec_device;

	platform_set_drvdata(pd, codec_data);

	return devm_snd_soc_register_component(dev, &cros_ec_component_driver,
					  cros_ec_dai, ARRAY_SIZE(cros_ec_dai));
}

#ifdef CONFIG_OF
static const struct of_device_id cros_ec_codec_of_match[] = {
	{ .compatible = "google,cros-ec-codec" },
	{},
};
MODULE_DEVICE_TABLE(of, cros_ec_codec_of_match);
#endif

static struct platform_driver cros_ec_codec_platform_driver = {
	.driver = {
		.name = DRV_NAME,
		.of_match_table = of_match_ptr(cros_ec_codec_of_match),
	},
	.probe = cros_ec_codec_platform_probe,
};

module_platform_driver(cros_ec_codec_platform_driver);

MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("ChromeOS EC codec driver");
MODULE_AUTHOR("Cheng-Yi Chiang <cychiang@chromium.org>");
MODULE_ALIAS("platform:" DRV_NAME);