1/*
2 * AK4104 ALSA SoC (ASoC) driver
3 *
4 * Copyright (c) 2009 Daniel Mack <daniel@caiaq.de>
5 *
6 *  This program is free software; you can redistribute  it and/or modify it
7 *  under the terms of  the GNU General  Public License as published by the
8 *  Free Software Foundation;  either version 2 of the  License, or (at your
9 *  option) any later version.
10 */
11
12#include <linux/module.h>
13#include <linux/slab.h>
14#include <linux/spi/spi.h>
15#include <linux/of_device.h>
16#include <linux/of_gpio.h>
17#include <linux/regulator/consumer.h>
18#include <sound/asoundef.h>
19#include <sound/core.h>
20#include <sound/soc.h>
21#include <sound/initval.h>
22
23/* AK4104 registers addresses */
24#define AK4104_REG_CONTROL1		0x00
25#define AK4104_REG_RESERVED		0x01
26#define AK4104_REG_CONTROL2		0x02
27#define AK4104_REG_TX			0x03
28#define AK4104_REG_CHN_STATUS(x)	((x) + 0x04)
29#define AK4104_NUM_REGS			10
30
31#define AK4104_REG_MASK			0x1f
32#define AK4104_READ			0xc0
33#define AK4104_WRITE			0xe0
34#define AK4104_RESERVED_VAL		0x5b
35
36/* Bit masks for AK4104 registers */
37#define AK4104_CONTROL1_RSTN		(1 << 0)
38#define AK4104_CONTROL1_PW		(1 << 1)
39#define AK4104_CONTROL1_DIF0		(1 << 2)
40#define AK4104_CONTROL1_DIF1		(1 << 3)
41
42#define AK4104_CONTROL2_SEL0		(1 << 0)
43#define AK4104_CONTROL2_SEL1		(1 << 1)
44#define AK4104_CONTROL2_MODE		(1 << 2)
45
46#define AK4104_TX_TXE			(1 << 0)
47#define AK4104_TX_V			(1 << 1)
48
49struct ak4104_private {
50	struct regmap *regmap;
51	struct regulator *regulator;
52};
53
54static const struct snd_soc_dapm_widget ak4104_dapm_widgets[] = {
55SND_SOC_DAPM_PGA("TXE", AK4104_REG_TX, AK4104_TX_TXE, 0, NULL, 0),
56
57SND_SOC_DAPM_OUTPUT("TX"),
58};
59
60static const struct snd_soc_dapm_route ak4104_dapm_routes[] = {
61	{ "TXE", NULL, "Playback" },
62	{ "TX", NULL, "TXE" },
63};
64
65static int ak4104_set_dai_fmt(struct snd_soc_dai *codec_dai,
66			      unsigned int format)
67{
68	struct snd_soc_codec *codec = codec_dai->codec;
69	struct ak4104_private *ak4104 = snd_soc_codec_get_drvdata(codec);
70	int val = 0;
71	int ret;
72
73	/* set DAI format */
74	switch (format & SND_SOC_DAIFMT_FORMAT_MASK) {
75	case SND_SOC_DAIFMT_RIGHT_J:
76		break;
77	case SND_SOC_DAIFMT_LEFT_J:
78		val |= AK4104_CONTROL1_DIF0;
79		break;
80	case SND_SOC_DAIFMT_I2S:
81		val |= AK4104_CONTROL1_DIF0 | AK4104_CONTROL1_DIF1;
82		break;
83	default:
84		dev_err(codec->dev, "invalid dai format\n");
85		return -EINVAL;
86	}
87
88	/* This device can only be slave */
89	if ((format & SND_SOC_DAIFMT_MASTER_MASK) != SND_SOC_DAIFMT_CBS_CFS)
90		return -EINVAL;
91
92	ret = regmap_update_bits(ak4104->regmap, AK4104_REG_CONTROL1,
93				 AK4104_CONTROL1_DIF0 | AK4104_CONTROL1_DIF1,
94				 val);
95	if (ret < 0)
96		return ret;
97
98	return 0;
99}
100
101static int ak4104_hw_params(struct snd_pcm_substream *substream,
102			    struct snd_pcm_hw_params *params,
103			    struct snd_soc_dai *dai)
104{
105	struct snd_soc_codec *codec = dai->codec;
106	struct ak4104_private *ak4104 = snd_soc_codec_get_drvdata(codec);
107	int ret, val = 0;
108
109	/* set the IEC958 bits: consumer mode, no copyright bit */
110	val |= IEC958_AES0_CON_NOT_COPYRIGHT;
111	regmap_write(ak4104->regmap, AK4104_REG_CHN_STATUS(0), val);
112
113	val = 0;
114
115	switch (params_rate(params)) {
116	case 22050:
117		val |= IEC958_AES3_CON_FS_22050;
118		break;
119	case 24000:
120		val |= IEC958_AES3_CON_FS_24000;
121		break;
122	case 32000:
123		val |= IEC958_AES3_CON_FS_32000;
124		break;
125	case 44100:
126		val |= IEC958_AES3_CON_FS_44100;
127		break;
128	case 48000:
129		val |= IEC958_AES3_CON_FS_48000;
130		break;
131	case 88200:
132		val |= IEC958_AES3_CON_FS_88200;
133		break;
134	case 96000:
135		val |= IEC958_AES3_CON_FS_96000;
136		break;
137	case 176400:
138		val |= IEC958_AES3_CON_FS_176400;
139		break;
140	case 192000:
141		val |= IEC958_AES3_CON_FS_192000;
142		break;
143	default:
144		dev_err(codec->dev, "unsupported sampling rate\n");
145		return -EINVAL;
146	}
147
148	ret = regmap_write(ak4104->regmap, AK4104_REG_CHN_STATUS(3), val);
149	if (ret < 0)
150		return ret;
151
152	return 0;
153}
154
155static const struct snd_soc_dai_ops ak4101_dai_ops = {
156	.hw_params = ak4104_hw_params,
157	.set_fmt = ak4104_set_dai_fmt,
158};
159
160static struct snd_soc_dai_driver ak4104_dai = {
161	.name = "ak4104-hifi",
162	.playback = {
163		.stream_name = "Playback",
164		.channels_min = 2,
165		.channels_max = 2,
166		.rates = SNDRV_PCM_RATE_8000_192000,
167		.formats = SNDRV_PCM_FMTBIT_S16_LE  |
168			   SNDRV_PCM_FMTBIT_S24_3LE |
169			   SNDRV_PCM_FMTBIT_S24_LE
170	},
171	.ops = &ak4101_dai_ops,
172};
173
174static int ak4104_probe(struct snd_soc_codec *codec)
175{
176	struct ak4104_private *ak4104 = snd_soc_codec_get_drvdata(codec);
177	int ret;
178
179	ret = regulator_enable(ak4104->regulator);
180	if (ret < 0) {
181		dev_err(codec->dev, "Unable to enable regulator: %d\n", ret);
182		return ret;
183	}
184
185	/* set power-up and non-reset bits */
186	ret = regmap_update_bits(ak4104->regmap, AK4104_REG_CONTROL1,
187				 AK4104_CONTROL1_PW | AK4104_CONTROL1_RSTN,
188				 AK4104_CONTROL1_PW | AK4104_CONTROL1_RSTN);
189	if (ret < 0)
190		goto exit_disable_regulator;
191
192	/* enable transmitter */
193	ret = regmap_update_bits(ak4104->regmap, AK4104_REG_TX,
194				 AK4104_TX_TXE, AK4104_TX_TXE);
195	if (ret < 0)
196		goto exit_disable_regulator;
197
198	return 0;
199
200exit_disable_regulator:
201	regulator_disable(ak4104->regulator);
202	return ret;
203}
204
205static int ak4104_remove(struct snd_soc_codec *codec)
206{
207	struct ak4104_private *ak4104 = snd_soc_codec_get_drvdata(codec);
208
209	regmap_update_bits(ak4104->regmap, AK4104_REG_CONTROL1,
210			   AK4104_CONTROL1_PW | AK4104_CONTROL1_RSTN, 0);
211	regulator_disable(ak4104->regulator);
212
213	return 0;
214}
215
216#ifdef CONFIG_PM
217static int ak4104_soc_suspend(struct snd_soc_codec *codec)
218{
219	struct ak4104_private *priv = snd_soc_codec_get_drvdata(codec);
220
221	regulator_disable(priv->regulator);
222
223	return 0;
224}
225
226static int ak4104_soc_resume(struct snd_soc_codec *codec)
227{
228	struct ak4104_private *priv = snd_soc_codec_get_drvdata(codec);
229	int ret;
230
231	ret = regulator_enable(priv->regulator);
232	if (ret < 0)
233		return ret;
234
235	return 0;
236}
237#else
238#define ak4104_soc_suspend	NULL
239#define ak4104_soc_resume	NULL
240#endif /* CONFIG_PM */
241
242static struct snd_soc_codec_driver soc_codec_device_ak4104 = {
243	.probe = ak4104_probe,
244	.remove = ak4104_remove,
245	.suspend = ak4104_soc_suspend,
246	.resume = ak4104_soc_resume,
247
248	.dapm_widgets = ak4104_dapm_widgets,
249	.num_dapm_widgets = ARRAY_SIZE(ak4104_dapm_widgets),
250	.dapm_routes = ak4104_dapm_routes,
251	.num_dapm_routes = ARRAY_SIZE(ak4104_dapm_routes),
252};
253
254static const struct regmap_config ak4104_regmap = {
255	.reg_bits = 8,
256	.val_bits = 8,
257
258	.max_register = AK4104_NUM_REGS - 1,
259	.read_flag_mask = AK4104_READ,
260	.write_flag_mask = AK4104_WRITE,
261
262	.cache_type = REGCACHE_RBTREE,
263};
264
265static int ak4104_spi_probe(struct spi_device *spi)
266{
267	struct device_node *np = spi->dev.of_node;
268	struct ak4104_private *ak4104;
269	unsigned int val;
270	int ret;
271
272	spi->bits_per_word = 8;
273	spi->mode = SPI_MODE_0;
274	ret = spi_setup(spi);
275	if (ret < 0)
276		return ret;
277
278	ak4104 = devm_kzalloc(&spi->dev, sizeof(struct ak4104_private),
279			      GFP_KERNEL);
280	if (ak4104 == NULL)
281		return -ENOMEM;
282
283	ak4104->regulator = devm_regulator_get(&spi->dev, "vdd");
284	if (IS_ERR(ak4104->regulator)) {
285		ret = PTR_ERR(ak4104->regulator);
286		dev_err(&spi->dev, "Unable to get Vdd regulator: %d\n", ret);
287		return ret;
288	}
289
290	ak4104->regmap = devm_regmap_init_spi(spi, &ak4104_regmap);
291	if (IS_ERR(ak4104->regmap)) {
292		ret = PTR_ERR(ak4104->regmap);
293		return ret;
294	}
295
296	if (np) {
297		enum of_gpio_flags flags;
298		int gpio = of_get_named_gpio_flags(np, "reset-gpio", 0, &flags);
299
300		if (gpio_is_valid(gpio)) {
301			ret = devm_gpio_request_one(&spi->dev, gpio,
302				     flags & OF_GPIO_ACTIVE_LOW ?
303					GPIOF_OUT_INIT_LOW : GPIOF_OUT_INIT_HIGH,
304				     "ak4104 reset");
305			if (ret < 0)
306				return ret;
307		}
308	}
309
310	/* read the 'reserved' register - according to the datasheet, it
311	 * should contain 0x5b. Not a good way to verify the presence of
312	 * the device, but there is no hardware ID register. */
313	ret = regmap_read(ak4104->regmap, AK4104_REG_RESERVED, &val);
314	if (ret != 0)
315		return ret;
316	if (val != AK4104_RESERVED_VAL)
317		return -ENODEV;
318
319	spi_set_drvdata(spi, ak4104);
320
321	ret = snd_soc_register_codec(&spi->dev,
322			&soc_codec_device_ak4104, &ak4104_dai, 1);
323	return ret;
324}
325
326static int ak4104_spi_remove(struct spi_device *spi)
327{
328	snd_soc_unregister_codec(&spi->dev);
329	return 0;
330}
331
332static const struct of_device_id ak4104_of_match[] = {
333	{ .compatible = "asahi-kasei,ak4104", },
334	{ }
335};
336MODULE_DEVICE_TABLE(of, ak4104_of_match);
337
338static const struct spi_device_id ak4104_id_table[] = {
339	{ "ak4104", 0 },
340	{ }
341};
342MODULE_DEVICE_TABLE(spi, ak4104_id_table);
343
344static struct spi_driver ak4104_spi_driver = {
345	.driver  = {
346		.name   = "ak4104",
347		.of_match_table = ak4104_of_match,
348	},
349	.id_table = ak4104_id_table,
350	.probe  = ak4104_spi_probe,
351	.remove = ak4104_spi_remove,
352};
353
354module_spi_driver(ak4104_spi_driver);
355
356MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>");
357MODULE_DESCRIPTION("Asahi Kasei AK4104 ALSA SoC driver");
358MODULE_LICENSE("GPL");
359
360