1
2
3
4
5
6
7
8
9
10
11
12#include <linux/module.h>
13#include <linux/slab.h>
14#include <sound/core.h>
15#include <sound/soc.h>
16#include <sound/initval.h>
17#include <linux/spi/spi.h>
18#include <sound/asoundef.h>
19
20
21#define AK4104_REG_CONTROL1 0x00
22#define AK4104_REG_RESERVED 0x01
23#define AK4104_REG_CONTROL2 0x02
24#define AK4104_REG_TX 0x03
25#define AK4104_REG_CHN_STATUS(x) ((x) + 0x04)
26#define AK4104_NUM_REGS 10
27
28#define AK4104_REG_MASK 0x1f
29#define AK4104_READ 0xc0
30#define AK4104_WRITE 0xe0
31#define AK4104_RESERVED_VAL 0x5b
32
33
34#define AK4104_CONTROL1_RSTN (1 << 0)
35#define AK4104_CONTROL1_PW (1 << 1)
36#define AK4104_CONTROL1_DIF0 (1 << 2)
37#define AK4104_CONTROL1_DIF1 (1 << 3)
38
39#define AK4104_CONTROL2_SEL0 (1 << 0)
40#define AK4104_CONTROL2_SEL1 (1 << 1)
41#define AK4104_CONTROL2_MODE (1 << 2)
42
43#define AK4104_TX_TXE (1 << 0)
44#define AK4104_TX_V (1 << 1)
45
46#define DRV_NAME "ak4104-codec"
47
48struct ak4104_private {
49 struct regmap *regmap;
50};
51
52static int ak4104_set_dai_fmt(struct snd_soc_dai *codec_dai,
53 unsigned int format)
54{
55 struct snd_soc_codec *codec = codec_dai->codec;
56 int val = 0;
57 int ret;
58
59
60 switch (format & SND_SOC_DAIFMT_FORMAT_MASK) {
61 case SND_SOC_DAIFMT_RIGHT_J:
62 break;
63 case SND_SOC_DAIFMT_LEFT_J:
64 val |= AK4104_CONTROL1_DIF0;
65 break;
66 case SND_SOC_DAIFMT_I2S:
67 val |= AK4104_CONTROL1_DIF0 | AK4104_CONTROL1_DIF1;
68 break;
69 default:
70 dev_err(codec->dev, "invalid dai format\n");
71 return -EINVAL;
72 }
73
74
75 if ((format & SND_SOC_DAIFMT_MASTER_MASK) != SND_SOC_DAIFMT_CBS_CFS)
76 return -EINVAL;
77
78 ret = snd_soc_update_bits(codec, AK4104_REG_CONTROL1,
79 AK4104_CONTROL1_DIF0 | AK4104_CONTROL1_DIF1,
80 val);
81 if (ret < 0)
82 return ret;
83
84 return 0;
85}
86
87static int ak4104_hw_params(struct snd_pcm_substream *substream,
88 struct snd_pcm_hw_params *params,
89 struct snd_soc_dai *dai)
90{
91 struct snd_soc_pcm_runtime *rtd = substream->private_data;
92 struct snd_soc_codec *codec = rtd->codec;
93 int val = 0;
94
95
96 val |= IEC958_AES0_CON_NOT_COPYRIGHT;
97 snd_soc_write(codec, AK4104_REG_CHN_STATUS(0), val);
98
99 val = 0;
100
101 switch (params_rate(params)) {
102 case 44100:
103 val |= IEC958_AES3_CON_FS_44100;
104 break;
105 case 48000:
106 val |= IEC958_AES3_CON_FS_48000;
107 break;
108 case 32000:
109 val |= IEC958_AES3_CON_FS_32000;
110 break;
111 default:
112 dev_err(codec->dev, "unsupported sampling rate\n");
113 return -EINVAL;
114 }
115
116 return snd_soc_write(codec, AK4104_REG_CHN_STATUS(3), val);
117}
118
119static const struct snd_soc_dai_ops ak4101_dai_ops = {
120 .hw_params = ak4104_hw_params,
121 .set_fmt = ak4104_set_dai_fmt,
122};
123
124static struct snd_soc_dai_driver ak4104_dai = {
125 .name = "ak4104-hifi",
126 .playback = {
127 .stream_name = "Playback",
128 .channels_min = 2,
129 .channels_max = 2,
130 .rates = SNDRV_PCM_RATE_8000_192000,
131 .formats = SNDRV_PCM_FMTBIT_S16_LE |
132 SNDRV_PCM_FMTBIT_S24_3LE |
133 SNDRV_PCM_FMTBIT_S24_LE
134 },
135 .ops = &ak4101_dai_ops,
136};
137
138static int ak4104_probe(struct snd_soc_codec *codec)
139{
140 struct ak4104_private *ak4104 = snd_soc_codec_get_drvdata(codec);
141 int ret;
142
143 codec->control_data = ak4104->regmap;
144 ret = snd_soc_codec_set_cache_io(codec, 8, 8, SND_SOC_REGMAP);
145 if (ret != 0)
146 return ret;
147
148
149 ret = snd_soc_update_bits(codec, AK4104_REG_CONTROL1,
150 AK4104_CONTROL1_PW | AK4104_CONTROL1_RSTN,
151 AK4104_CONTROL1_PW | AK4104_CONTROL1_RSTN);
152 if (ret < 0)
153 return ret;
154
155
156 ret = snd_soc_update_bits(codec, AK4104_REG_TX,
157 AK4104_TX_TXE, AK4104_TX_TXE);
158 if (ret < 0)
159 return ret;
160
161 return 0;
162}
163
164static int ak4104_remove(struct snd_soc_codec *codec)
165{
166 snd_soc_update_bits(codec, AK4104_REG_CONTROL1,
167 AK4104_CONTROL1_PW | AK4104_CONTROL1_RSTN, 0);
168
169 return 0;
170}
171
172static struct snd_soc_codec_driver soc_codec_device_ak4104 = {
173 .probe = ak4104_probe,
174 .remove = ak4104_remove,
175};
176
177static const struct regmap_config ak4104_regmap = {
178 .reg_bits = 8,
179 .val_bits = 8,
180
181 .max_register = AK4104_NUM_REGS - 1,
182 .read_flag_mask = AK4104_READ,
183 .write_flag_mask = AK4104_WRITE,
184
185 .cache_type = REGCACHE_RBTREE,
186};
187
188static int ak4104_spi_probe(struct spi_device *spi)
189{
190 struct ak4104_private *ak4104;
191 unsigned int val;
192 int ret;
193
194 spi->bits_per_word = 8;
195 spi->mode = SPI_MODE_0;
196 ret = spi_setup(spi);
197 if (ret < 0)
198 return ret;
199
200 ak4104 = devm_kzalloc(&spi->dev, sizeof(struct ak4104_private),
201 GFP_KERNEL);
202 if (ak4104 == NULL)
203 return -ENOMEM;
204
205 ak4104->regmap = regmap_init_spi(spi, &ak4104_regmap);
206 if (IS_ERR(ak4104->regmap)) {
207 ret = PTR_ERR(ak4104->regmap);
208 return ret;
209 }
210
211
212
213
214 ret = regmap_read(ak4104->regmap, AK4104_REG_RESERVED, &val);
215 if (ret != 0)
216 goto err;
217 if (val != AK4104_RESERVED_VAL) {
218 ret = -ENODEV;
219 goto err;
220 }
221
222 spi_set_drvdata(spi, ak4104);
223
224 ret = snd_soc_register_codec(&spi->dev,
225 &soc_codec_device_ak4104, &ak4104_dai, 1);
226 if (ret != 0)
227 goto err;
228
229 return 0;
230
231err:
232 regmap_exit(ak4104->regmap);
233 return ret;
234}
235
236static int __devexit ak4104_spi_remove(struct spi_device *spi)
237{
238 struct ak4104_private *ak4101 = spi_get_drvdata(spi);
239 regmap_exit(ak4101->regmap);
240 snd_soc_unregister_codec(&spi->dev);
241 return 0;
242}
243
244static struct spi_driver ak4104_spi_driver = {
245 .driver = {
246 .name = DRV_NAME,
247 .owner = THIS_MODULE,
248 },
249 .probe = ak4104_spi_probe,
250 .remove = __devexit_p(ak4104_spi_remove),
251};
252
253module_spi_driver(ak4104_spi_driver);
254
255MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>");
256MODULE_DESCRIPTION("Asahi Kasei AK4104 ALSA SoC driver");
257MODULE_LICENSE("GPL");
258
259
