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 <sound/asoundef.h> 19 20 /* AK4104 registers addresses */ 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 /* Bit masks for AK4104 registers */ 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 48 struct ak4104_private { 49 struct regmap *regmap; 50 }; 51 52 static 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 /* set DAI format */ 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 /* This device can only be slave */ 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 87 static 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 /* set the IEC958 bits: consumer mode, no copyright bit */ 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 119 static const struct snd_soc_dai_ops ak4101_dai_ops = { 120 .hw_params = ak4104_hw_params, 121 .set_fmt = ak4104_set_dai_fmt, 122 }; 123 124 static 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 138 static 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 /* set power-up and non-reset bits */ 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 /* enable transmitter */ 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 164 static 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 172 static struct snd_soc_codec_driver soc_codec_device_ak4104 = { 173 .probe = ak4104_probe, 174 .remove = ak4104_remove, 175 }; 176 177 static 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 188 static 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 /* read the 'reserved' register - according to the datasheet, it 212 * should contain 0x5b. Not a good way to verify the presence of 213 * the device, but there is no hardware ID register. */ 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 231 err: 232 regmap_exit(ak4104->regmap); 233 return ret; 234 } 235 236 static 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 244 static 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 253 module_spi_driver(ak4104_spi_driver); 254 255 MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>"); 256 MODULE_DESCRIPTION("Asahi Kasei AK4104 ALSA SoC driver"); 257 MODULE_LICENSE("GPL"); 258 259