1/*
2 * ALSA SoC Texas Instruments TPA6130A2 headset stereo amplifier driver
3 *
4 * Copyright (C) Nokia Corporation
5 *
6 * Author: Peter Ujfalusi <peter.ujfalusi@ti.com>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20 * 02110-1301 USA
21 */
22
23#include <linux/module.h>
24#include <linux/errno.h>
25#include <linux/device.h>
26#include <linux/i2c.h>
27#include <linux/gpio.h>
28#include <linux/regulator/consumer.h>
29#include <linux/slab.h>
30#include <sound/tpa6130a2-plat.h>
31#include <sound/soc.h>
32#include <sound/tlv.h>
33#include <linux/of.h>
34#include <linux/of_gpio.h>
35
36#include "tpa6130a2.h"
37
38enum tpa_model {
39	TPA6130A2,
40	TPA6140A2,
41};
42
43static struct i2c_client *tpa6130a2_client;
44
45/* This struct is used to save the context */
46struct tpa6130a2_data {
47	struct mutex mutex;
48	unsigned char regs[TPA6130A2_CACHEREGNUM];
49	struct regulator *supply;
50	int power_gpio;
51	u8 power_state:1;
52	enum tpa_model id;
53};
54
55static int tpa6130a2_i2c_read(int reg)
56{
57	struct tpa6130a2_data *data;
58	int val;
59
60	if (WARN_ON(!tpa6130a2_client))
61		return -EINVAL;
62	data = i2c_get_clientdata(tpa6130a2_client);
63
64	/* If powered off, return the cached value */
65	if (data->power_state) {
66		val = i2c_smbus_read_byte_data(tpa6130a2_client, reg);
67		if (val < 0)
68			dev_err(&tpa6130a2_client->dev, "Read failed\n");
69		else
70			data->regs[reg] = val;
71	} else {
72		val = data->regs[reg];
73	}
74
75	return val;
76}
77
78static int tpa6130a2_i2c_write(int reg, u8 value)
79{
80	struct tpa6130a2_data *data;
81	int val = 0;
82
83	if (WARN_ON(!tpa6130a2_client))
84		return -EINVAL;
85	data = i2c_get_clientdata(tpa6130a2_client);
86
87	if (data->power_state) {
88		val = i2c_smbus_write_byte_data(tpa6130a2_client, reg, value);
89		if (val < 0) {
90			dev_err(&tpa6130a2_client->dev, "Write failed\n");
91			return val;
92		}
93	}
94
95	/* Either powered on or off, we save the context */
96	data->regs[reg] = value;
97
98	return val;
99}
100
101static u8 tpa6130a2_read(int reg)
102{
103	struct tpa6130a2_data *data;
104
105	if (WARN_ON(!tpa6130a2_client))
106		return 0;
107	data = i2c_get_clientdata(tpa6130a2_client);
108
109	return data->regs[reg];
110}
111
112static int tpa6130a2_initialize(void)
113{
114	struct tpa6130a2_data *data;
115	int i, ret = 0;
116
117	if (WARN_ON(!tpa6130a2_client))
118		return -EINVAL;
119	data = i2c_get_clientdata(tpa6130a2_client);
120
121	for (i = 1; i < TPA6130A2_REG_VERSION; i++) {
122		ret = tpa6130a2_i2c_write(i, data->regs[i]);
123		if (ret < 0)
124			break;
125	}
126
127	return ret;
128}
129
130static int tpa6130a2_power(u8 power)
131{
132	struct	tpa6130a2_data *data;
133	u8	val;
134	int	ret = 0;
135
136	if (WARN_ON(!tpa6130a2_client))
137		return -EINVAL;
138	data = i2c_get_clientdata(tpa6130a2_client);
139
140	mutex_lock(&data->mutex);
141	if (power == data->power_state)
142		goto exit;
143
144	if (power) {
145		ret = regulator_enable(data->supply);
146		if (ret != 0) {
147			dev_err(&tpa6130a2_client->dev,
148				"Failed to enable supply: %d\n", ret);
149			goto exit;
150		}
151		/* Power on */
152		if (data->power_gpio >= 0)
153			gpio_set_value(data->power_gpio, 1);
154
155		data->power_state = 1;
156		ret = tpa6130a2_initialize();
157		if (ret < 0) {
158			dev_err(&tpa6130a2_client->dev,
159				"Failed to initialize chip\n");
160			if (data->power_gpio >= 0)
161				gpio_set_value(data->power_gpio, 0);
162			regulator_disable(data->supply);
163			data->power_state = 0;
164			goto exit;
165		}
166	} else {
167		/* set SWS */
168		val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
169		val |= TPA6130A2_SWS;
170		tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
171
172		/* Power off */
173		if (data->power_gpio >= 0)
174			gpio_set_value(data->power_gpio, 0);
175
176		ret = regulator_disable(data->supply);
177		if (ret != 0) {
178			dev_err(&tpa6130a2_client->dev,
179				"Failed to disable supply: %d\n", ret);
180			goto exit;
181		}
182
183		data->power_state = 0;
184	}
185
186exit:
187	mutex_unlock(&data->mutex);
188	return ret;
189}
190
191static int tpa6130a2_get_volsw(struct snd_kcontrol *kcontrol,
192		struct snd_ctl_elem_value *ucontrol)
193{
194	struct soc_mixer_control *mc =
195		(struct soc_mixer_control *)kcontrol->private_value;
196	struct tpa6130a2_data *data;
197	unsigned int reg = mc->reg;
198	unsigned int shift = mc->shift;
199	int max = mc->max;
200	unsigned int mask = (1 << fls(max)) - 1;
201	unsigned int invert = mc->invert;
202
203	if (WARN_ON(!tpa6130a2_client))
204		return -EINVAL;
205	data = i2c_get_clientdata(tpa6130a2_client);
206
207	mutex_lock(&data->mutex);
208
209	ucontrol->value.integer.value[0] =
210		(tpa6130a2_read(reg) >> shift) & mask;
211
212	if (invert)
213		ucontrol->value.integer.value[0] =
214			max - ucontrol->value.integer.value[0];
215
216	mutex_unlock(&data->mutex);
217	return 0;
218}
219
220static int tpa6130a2_put_volsw(struct snd_kcontrol *kcontrol,
221		struct snd_ctl_elem_value *ucontrol)
222{
223	struct soc_mixer_control *mc =
224		(struct soc_mixer_control *)kcontrol->private_value;
225	struct tpa6130a2_data *data;
226	unsigned int reg = mc->reg;
227	unsigned int shift = mc->shift;
228	int max = mc->max;
229	unsigned int mask = (1 << fls(max)) - 1;
230	unsigned int invert = mc->invert;
231	unsigned int val = (ucontrol->value.integer.value[0] & mask);
232	unsigned int val_reg;
233
234	if (WARN_ON(!tpa6130a2_client))
235		return -EINVAL;
236	data = i2c_get_clientdata(tpa6130a2_client);
237
238	if (invert)
239		val = max - val;
240
241	mutex_lock(&data->mutex);
242
243	val_reg = tpa6130a2_read(reg);
244	if (((val_reg >> shift) & mask) == val) {
245		mutex_unlock(&data->mutex);
246		return 0;
247	}
248
249	val_reg &= ~(mask << shift);
250	val_reg |= val << shift;
251	tpa6130a2_i2c_write(reg, val_reg);
252
253	mutex_unlock(&data->mutex);
254
255	return 1;
256}
257
258/*
259 * TPA6130 volume. From -59.5 to 4 dB with increasing step size when going
260 * down in gain.
261 */
262static const unsigned int tpa6130_tlv[] = {
263	TLV_DB_RANGE_HEAD(10),
264	0, 1, TLV_DB_SCALE_ITEM(-5950, 600, 0),
265	2, 3, TLV_DB_SCALE_ITEM(-5000, 250, 0),
266	4, 5, TLV_DB_SCALE_ITEM(-4550, 160, 0),
267	6, 7, TLV_DB_SCALE_ITEM(-4140, 190, 0),
268	8, 9, TLV_DB_SCALE_ITEM(-3650, 120, 0),
269	10, 11, TLV_DB_SCALE_ITEM(-3330, 160, 0),
270	12, 13, TLV_DB_SCALE_ITEM(-3040, 180, 0),
271	14, 20, TLV_DB_SCALE_ITEM(-2710, 110, 0),
272	21, 37, TLV_DB_SCALE_ITEM(-1960, 74, 0),
273	38, 63, TLV_DB_SCALE_ITEM(-720, 45, 0),
274};
275
276static const struct snd_kcontrol_new tpa6130a2_controls[] = {
277	SOC_SINGLE_EXT_TLV("TPA6130A2 Headphone Playback Volume",
278		       TPA6130A2_REG_VOL_MUTE, 0, 0x3f, 0,
279		       tpa6130a2_get_volsw, tpa6130a2_put_volsw,
280		       tpa6130_tlv),
281};
282
283static const unsigned int tpa6140_tlv[] = {
284	TLV_DB_RANGE_HEAD(3),
285	0, 8, TLV_DB_SCALE_ITEM(-5900, 400, 0),
286	9, 16, TLV_DB_SCALE_ITEM(-2500, 200, 0),
287	17, 31, TLV_DB_SCALE_ITEM(-1000, 100, 0),
288};
289
290static const struct snd_kcontrol_new tpa6140a2_controls[] = {
291	SOC_SINGLE_EXT_TLV("TPA6140A2 Headphone Playback Volume",
292		       TPA6130A2_REG_VOL_MUTE, 1, 0x1f, 0,
293		       tpa6130a2_get_volsw, tpa6130a2_put_volsw,
294		       tpa6140_tlv),
295};
296
297/*
298 * Enable or disable channel (left or right)
299 * The bit number for mute and amplifier are the same per channel:
300 * bit 6: Right channel
301 * bit 7: Left channel
302 * in both registers.
303 */
304static void tpa6130a2_channel_enable(u8 channel, int enable)
305{
306	u8	val;
307
308	if (enable) {
309		/* Enable channel */
310		/* Enable amplifier */
311		val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
312		val |= channel;
313		val &= ~TPA6130A2_SWS;
314		tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
315
316		/* Unmute channel */
317		val = tpa6130a2_read(TPA6130A2_REG_VOL_MUTE);
318		val &= ~channel;
319		tpa6130a2_i2c_write(TPA6130A2_REG_VOL_MUTE, val);
320	} else {
321		/* Disable channel */
322		/* Mute channel */
323		val = tpa6130a2_read(TPA6130A2_REG_VOL_MUTE);
324		val |= channel;
325		tpa6130a2_i2c_write(TPA6130A2_REG_VOL_MUTE, val);
326
327		/* Disable amplifier */
328		val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
329		val &= ~channel;
330		tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
331	}
332}
333
334int tpa6130a2_stereo_enable(struct snd_soc_codec *codec, int enable)
335{
336	int ret = 0;
337	if (enable) {
338		ret = tpa6130a2_power(1);
339		if (ret < 0)
340			return ret;
341		tpa6130a2_channel_enable(TPA6130A2_HP_EN_R | TPA6130A2_HP_EN_L,
342					 1);
343	} else {
344		tpa6130a2_channel_enable(TPA6130A2_HP_EN_R | TPA6130A2_HP_EN_L,
345					 0);
346		ret = tpa6130a2_power(0);
347	}
348
349	return ret;
350}
351EXPORT_SYMBOL_GPL(tpa6130a2_stereo_enable);
352
353int tpa6130a2_add_controls(struct snd_soc_codec *codec)
354{
355	struct	tpa6130a2_data *data;
356
357	if (tpa6130a2_client == NULL)
358		return -ENODEV;
359
360	data = i2c_get_clientdata(tpa6130a2_client);
361
362	if (data->id == TPA6140A2)
363		return snd_soc_add_codec_controls(codec, tpa6140a2_controls,
364						ARRAY_SIZE(tpa6140a2_controls));
365	else
366		return snd_soc_add_codec_controls(codec, tpa6130a2_controls,
367						ARRAY_SIZE(tpa6130a2_controls));
368}
369EXPORT_SYMBOL_GPL(tpa6130a2_add_controls);
370
371static int tpa6130a2_probe(struct i2c_client *client,
372			   const struct i2c_device_id *id)
373{
374	struct device *dev;
375	struct tpa6130a2_data *data;
376	struct tpa6130a2_platform_data *pdata = client->dev.platform_data;
377	struct device_node *np = client->dev.of_node;
378	const char *regulator;
379	int ret;
380
381	dev = &client->dev;
382
383	data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
384	if (!data)
385		return -ENOMEM;
386
387	if (pdata) {
388		data->power_gpio = pdata->power_gpio;
389	} else if (np) {
390		data->power_gpio = of_get_named_gpio(np, "power-gpio", 0);
391	} else {
392		dev_err(dev, "Platform data not set\n");
393		dump_stack();
394		return -ENODEV;
395	}
396
397	tpa6130a2_client = client;
398
399	i2c_set_clientdata(tpa6130a2_client, data);
400
401	data->id = id->driver_data;
402
403	mutex_init(&data->mutex);
404
405	/* Set default register values */
406	data->regs[TPA6130A2_REG_CONTROL] =	TPA6130A2_SWS;
407	data->regs[TPA6130A2_REG_VOL_MUTE] =	TPA6130A2_MUTE_R |
408						TPA6130A2_MUTE_L;
409
410	if (data->power_gpio >= 0) {
411		ret = devm_gpio_request(dev, data->power_gpio,
412					"tpa6130a2 enable");
413		if (ret < 0) {
414			dev_err(dev, "Failed to request power GPIO (%d)\n",
415				data->power_gpio);
416			goto err_gpio;
417		}
418		gpio_direction_output(data->power_gpio, 0);
419	}
420
421	switch (data->id) {
422	default:
423		dev_warn(dev, "Unknown TPA model (%d). Assuming 6130A2\n",
424			 data->id);
425	case TPA6130A2:
426		regulator = "Vdd";
427		break;
428	case TPA6140A2:
429		regulator = "AVdd";
430		break;
431	}
432
433	data->supply = devm_regulator_get(dev, regulator);
434	if (IS_ERR(data->supply)) {
435		ret = PTR_ERR(data->supply);
436		dev_err(dev, "Failed to request supply: %d\n", ret);
437		goto err_gpio;
438	}
439
440	ret = tpa6130a2_power(1);
441	if (ret != 0)
442		goto err_gpio;
443
444
445	/* Read version */
446	ret = tpa6130a2_i2c_read(TPA6130A2_REG_VERSION) &
447				 TPA6130A2_VERSION_MASK;
448	if ((ret != 1) && (ret != 2))
449		dev_warn(dev, "UNTESTED version detected (%d)\n", ret);
450
451	/* Disable the chip */
452	ret = tpa6130a2_power(0);
453	if (ret != 0)
454		goto err_gpio;
455
456	return 0;
457
458err_gpio:
459	tpa6130a2_client = NULL;
460
461	return ret;
462}
463
464static int tpa6130a2_remove(struct i2c_client *client)
465{
466	tpa6130a2_power(0);
467	tpa6130a2_client = NULL;
468
469	return 0;
470}
471
472static const struct i2c_device_id tpa6130a2_id[] = {
473	{ "tpa6130a2", TPA6130A2 },
474	{ "tpa6140a2", TPA6140A2 },
475	{ }
476};
477MODULE_DEVICE_TABLE(i2c, tpa6130a2_id);
478
479#if IS_ENABLED(CONFIG_OF)
480static const struct of_device_id tpa6130a2_of_match[] = {
481	{ .compatible = "ti,tpa6130a2", },
482	{ .compatible = "ti,tpa6140a2" },
483	{},
484};
485MODULE_DEVICE_TABLE(of, tpa6130a2_of_match);
486#endif
487
488static struct i2c_driver tpa6130a2_i2c_driver = {
489	.driver = {
490		.name = "tpa6130a2",
491		.owner = THIS_MODULE,
492		.of_match_table = of_match_ptr(tpa6130a2_of_match),
493	},
494	.probe = tpa6130a2_probe,
495	.remove = tpa6130a2_remove,
496	.id_table = tpa6130a2_id,
497};
498
499module_i2c_driver(tpa6130a2_i2c_driver);
500
501MODULE_AUTHOR("Peter Ujfalusi <peter.ujfalusi@ti.com>");
502MODULE_DESCRIPTION("TPA6130A2 Headphone amplifier driver");
503MODULE_LICENSE("GPL");
504