Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/sound/soc/codecs/ak4104.c

  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 
 49 struct ak4104_private {
 50         struct regmap *regmap;
 51         struct regulator *regulator;
 52 };
 53 
 54 static const struct snd_soc_dapm_widget ak4104_dapm_widgets[] = {
 55 SND_SOC_DAPM_PGA("TXE", AK4104_REG_TX, AK4104_TX_TXE, 0, NULL, 0),
 56 
 57 SND_SOC_DAPM_OUTPUT("TX"),
 58 };
 59 
 60 static const struct snd_soc_dapm_route ak4104_dapm_routes[] = {
 61         { "TXE", NULL, "Playback" },
 62         { "TX", NULL, "TXE" },
 63 };
 64 
 65 static 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 
101 static 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 
155 static const struct snd_soc_dai_ops ak4101_dai_ops = {
156         .hw_params = ak4104_hw_params,
157         .set_fmt = ak4104_set_dai_fmt,
158 };
159 
160 static 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 
174 static 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 
200 exit_disable_regulator:
201         regulator_disable(ak4104->regulator);
202         return ret;
203 }
204 
205 static 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
217 static 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 
226 static 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 
242 static 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 
254 static 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 
265 static 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 
326 static int ak4104_spi_remove(struct spi_device *spi)
327 {
328         snd_soc_unregister_codec(&spi->dev);
329         return 0;
330 }
331 
332 static const struct of_device_id ak4104_of_match[] = {
333         { .compatible = "asahi-kasei,ak4104", },
334         { }
335 };
336 MODULE_DEVICE_TABLE(of, ak4104_of_match);
337 
338 static const struct spi_device_id ak4104_id_table[] = {
339         { "ak4104", 0 },
340         { }
341 };
342 MODULE_DEVICE_TABLE(spi, ak4104_id_table);
343 
344 static struct spi_driver ak4104_spi_driver = {
345         .driver  = {
346                 .name   = "ak4104",
347                 .owner  = THIS_MODULE,
348                 .of_match_table = ak4104_of_match,
349         },
350         .id_table = ak4104_id_table,
351         .probe  = ak4104_spi_probe,
352         .remove = ak4104_spi_remove,
353 };
354 
355 module_spi_driver(ak4104_spi_driver);
356 
357 MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>");
358 MODULE_DESCRIPTION("Asahi Kasei AK4104 ALSA SoC driver");
359 MODULE_LICENSE("GPL");
360 
361 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us