Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 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

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

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