Marek Belisko | 95169d0 | 2013-08-01 11:14:58 +0200 | [diff] [blame] | 1 | /* |
| 2 | * PCM1681 ASoC codec driver |
| 3 | * |
| 4 | * Copyright (c) StreamUnlimited GmbH 2013 |
| 5 | * Marek Belisko <marek.belisko@streamunlimited.com> |
| 6 | * |
| 7 | * This program is free software; you can redistribute it and/or |
| 8 | * modify it under the terms of the GNU General Public License |
| 9 | * as published by the Free Software Foundation; either version 2 |
| 10 | * of the License, or (at your option) any later version. |
| 11 | * |
| 12 | * This program is distributed in the hope that it will be useful, |
| 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 15 | * GNU General Public License for more details. |
| 16 | */ |
| 17 | |
| 18 | #include <linux/module.h> |
| 19 | #include <linux/slab.h> |
| 20 | #include <linux/delay.h> |
| 21 | #include <linux/gpio.h> |
| 22 | #include <linux/i2c.h> |
| 23 | #include <linux/regmap.h> |
Sachin Kamat | 193a471 | 2013-10-11 17:23:57 +0530 | [diff] [blame] | 24 | #include <linux/of.h> |
Marek Belisko | 95169d0 | 2013-08-01 11:14:58 +0200 | [diff] [blame] | 25 | #include <linux/of_device.h> |
| 26 | #include <linux/of_gpio.h> |
| 27 | #include <sound/pcm.h> |
| 28 | #include <sound/pcm_params.h> |
| 29 | #include <sound/soc.h> |
| 30 | #include <sound/tlv.h> |
| 31 | |
| 32 | #define PCM1681_PCM_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | \ |
| 33 | SNDRV_PCM_FMTBIT_S24_LE) |
| 34 | |
| 35 | #define PCM1681_PCM_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 | \ |
| 36 | SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | \ |
| 37 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 | \ |
| 38 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000) |
| 39 | |
| 40 | #define PCM1681_SOFT_MUTE_ALL 0xff |
| 41 | #define PCM1681_DEEMPH_RATE_MASK 0x18 |
| 42 | #define PCM1681_DEEMPH_MASK 0x01 |
| 43 | |
| 44 | #define PCM1681_ATT_CONTROL(X) (X <= 6 ? X : X + 9) /* Attenuation level */ |
| 45 | #define PCM1681_SOFT_MUTE 0x07 /* Soft mute control register */ |
| 46 | #define PCM1681_DAC_CONTROL 0x08 /* DAC operation control */ |
| 47 | #define PCM1681_FMT_CONTROL 0x09 /* Audio interface data format */ |
| 48 | #define PCM1681_DEEMPH_CONTROL 0x0a /* De-emphasis control */ |
| 49 | #define PCM1681_ZERO_DETECT_STATUS 0x0e /* Zero detect status reg */ |
| 50 | |
| 51 | static const struct reg_default pcm1681_reg_defaults[] = { |
| 52 | { 0x01, 0xff }, |
| 53 | { 0x02, 0xff }, |
| 54 | { 0x03, 0xff }, |
| 55 | { 0x04, 0xff }, |
| 56 | { 0x05, 0xff }, |
| 57 | { 0x06, 0xff }, |
| 58 | { 0x07, 0x00 }, |
| 59 | { 0x08, 0x00 }, |
| 60 | { 0x09, 0x06 }, |
| 61 | { 0x0A, 0x00 }, |
| 62 | { 0x0B, 0xff }, |
| 63 | { 0x0C, 0x0f }, |
| 64 | { 0x0D, 0x00 }, |
| 65 | { 0x10, 0xff }, |
| 66 | { 0x11, 0xff }, |
| 67 | { 0x12, 0x00 }, |
| 68 | { 0x13, 0x00 }, |
| 69 | }; |
| 70 | |
| 71 | static bool pcm1681_accessible_reg(struct device *dev, unsigned int reg) |
| 72 | { |
| 73 | return !((reg == 0x00) || (reg == 0x0f)); |
| 74 | } |
| 75 | |
| 76 | static bool pcm1681_writeable_reg(struct device *dev, unsigned register reg) |
| 77 | { |
| 78 | return pcm1681_accessible_reg(dev, reg) && |
| 79 | (reg != PCM1681_ZERO_DETECT_STATUS); |
| 80 | } |
| 81 | |
| 82 | struct pcm1681_private { |
| 83 | struct regmap *regmap; |
| 84 | unsigned int format; |
| 85 | /* Current deemphasis status */ |
| 86 | unsigned int deemph; |
| 87 | /* Current rate for deemphasis control */ |
| 88 | unsigned int rate; |
| 89 | }; |
| 90 | |
| 91 | static const int pcm1681_deemph[] = { 44100, 48000, 32000 }; |
| 92 | |
| 93 | static int pcm1681_set_deemph(struct snd_soc_codec *codec) |
| 94 | { |
| 95 | struct pcm1681_private *priv = snd_soc_codec_get_drvdata(codec); |
| 96 | int i = 0, val = -1, enable = 0; |
| 97 | |
| 98 | if (priv->deemph) |
| 99 | for (i = 0; i < ARRAY_SIZE(pcm1681_deemph); i++) |
| 100 | if (pcm1681_deemph[i] == priv->rate) |
| 101 | val = i; |
| 102 | |
| 103 | if (val != -1) { |
| 104 | regmap_update_bits(priv->regmap, PCM1681_DEEMPH_CONTROL, |
| 105 | PCM1681_DEEMPH_RATE_MASK, val); |
| 106 | enable = 1; |
| 107 | } else |
| 108 | enable = 0; |
| 109 | |
| 110 | /* enable/disable deemphasis functionality */ |
| 111 | return regmap_update_bits(priv->regmap, PCM1681_DEEMPH_CONTROL, |
| 112 | PCM1681_DEEMPH_MASK, enable); |
| 113 | } |
| 114 | |
| 115 | static int pcm1681_get_deemph(struct snd_kcontrol *kcontrol, |
| 116 | struct snd_ctl_elem_value *ucontrol) |
| 117 | { |
Lars-Peter Clausen | ea53bf7 | 2014-03-18 09:02:04 +0100 | [diff] [blame] | 118 | struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); |
Marek Belisko | 95169d0 | 2013-08-01 11:14:58 +0200 | [diff] [blame] | 119 | struct pcm1681_private *priv = snd_soc_codec_get_drvdata(codec); |
| 120 | |
| 121 | ucontrol->value.enumerated.item[0] = priv->deemph; |
| 122 | |
| 123 | return 0; |
| 124 | } |
| 125 | |
| 126 | static int pcm1681_put_deemph(struct snd_kcontrol *kcontrol, |
| 127 | struct snd_ctl_elem_value *ucontrol) |
| 128 | { |
Lars-Peter Clausen | ea53bf7 | 2014-03-18 09:02:04 +0100 | [diff] [blame] | 129 | struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); |
Marek Belisko | 95169d0 | 2013-08-01 11:14:58 +0200 | [diff] [blame] | 130 | struct pcm1681_private *priv = snd_soc_codec_get_drvdata(codec); |
| 131 | |
| 132 | priv->deemph = ucontrol->value.enumerated.item[0]; |
| 133 | |
| 134 | return pcm1681_set_deemph(codec); |
| 135 | } |
| 136 | |
| 137 | static int pcm1681_set_dai_fmt(struct snd_soc_dai *codec_dai, |
| 138 | unsigned int format) |
| 139 | { |
| 140 | struct snd_soc_codec *codec = codec_dai->codec; |
| 141 | struct pcm1681_private *priv = snd_soc_codec_get_drvdata(codec); |
| 142 | |
| 143 | /* The PCM1681 can only be slave to all clocks */ |
| 144 | if ((format & SND_SOC_DAIFMT_MASTER_MASK) != SND_SOC_DAIFMT_CBS_CFS) { |
| 145 | dev_err(codec->dev, "Invalid clocking mode\n"); |
| 146 | return -EINVAL; |
| 147 | } |
| 148 | |
| 149 | priv->format = format; |
| 150 | |
| 151 | return 0; |
| 152 | } |
| 153 | |
| 154 | static int pcm1681_digital_mute(struct snd_soc_dai *dai, int mute) |
| 155 | { |
| 156 | struct snd_soc_codec *codec = dai->codec; |
| 157 | struct pcm1681_private *priv = snd_soc_codec_get_drvdata(codec); |
| 158 | int val; |
| 159 | |
| 160 | if (mute) |
| 161 | val = PCM1681_SOFT_MUTE_ALL; |
| 162 | else |
| 163 | val = 0; |
| 164 | |
| 165 | return regmap_write(priv->regmap, PCM1681_SOFT_MUTE, val); |
| 166 | } |
| 167 | |
| 168 | static int pcm1681_hw_params(struct snd_pcm_substream *substream, |
| 169 | struct snd_pcm_hw_params *params, |
| 170 | struct snd_soc_dai *dai) |
| 171 | { |
| 172 | struct snd_soc_codec *codec = dai->codec; |
| 173 | struct pcm1681_private *priv = snd_soc_codec_get_drvdata(codec); |
| 174 | int val = 0, ret; |
Marek Belisko | 95169d0 | 2013-08-01 11:14:58 +0200 | [diff] [blame] | 175 | |
| 176 | priv->rate = params_rate(params); |
| 177 | |
| 178 | switch (priv->format & SND_SOC_DAIFMT_FORMAT_MASK) { |
| 179 | case SND_SOC_DAIFMT_RIGHT_J: |
Mark Brown | 50a68fb | 2014-01-24 16:07:05 +0000 | [diff] [blame] | 180 | switch (params_width(params)) { |
| 181 | case 24: |
| 182 | val = 0; |
| 183 | break; |
| 184 | case 16: |
| 185 | val = 3; |
| 186 | break; |
| 187 | default: |
| 188 | return -EINVAL; |
| 189 | } |
Marek Belisko | 95169d0 | 2013-08-01 11:14:58 +0200 | [diff] [blame] | 190 | break; |
| 191 | case SND_SOC_DAIFMT_I2S: |
| 192 | val = 0x04; |
| 193 | break; |
| 194 | case SND_SOC_DAIFMT_LEFT_J: |
| 195 | val = 0x05; |
| 196 | break; |
| 197 | default: |
| 198 | dev_err(codec->dev, "Invalid DAI format\n"); |
| 199 | return -EINVAL; |
| 200 | } |
| 201 | |
| 202 | ret = regmap_update_bits(priv->regmap, PCM1681_FMT_CONTROL, 0x0f, val); |
| 203 | if (ret < 0) |
| 204 | return ret; |
| 205 | |
| 206 | return pcm1681_set_deemph(codec); |
| 207 | } |
| 208 | |
| 209 | static const struct snd_soc_dai_ops pcm1681_dai_ops = { |
| 210 | .set_fmt = pcm1681_set_dai_fmt, |
| 211 | .hw_params = pcm1681_hw_params, |
| 212 | .digital_mute = pcm1681_digital_mute, |
| 213 | }; |
| 214 | |
Mark Brown | b9281f9 | 2013-08-13 18:25:41 +0100 | [diff] [blame] | 215 | static const struct snd_soc_dapm_widget pcm1681_dapm_widgets[] = { |
| 216 | SND_SOC_DAPM_OUTPUT("VOUT1"), |
| 217 | SND_SOC_DAPM_OUTPUT("VOUT2"), |
| 218 | SND_SOC_DAPM_OUTPUT("VOUT3"), |
| 219 | SND_SOC_DAPM_OUTPUT("VOUT4"), |
| 220 | SND_SOC_DAPM_OUTPUT("VOUT5"), |
| 221 | SND_SOC_DAPM_OUTPUT("VOUT6"), |
| 222 | SND_SOC_DAPM_OUTPUT("VOUT7"), |
| 223 | SND_SOC_DAPM_OUTPUT("VOUT8"), |
| 224 | }; |
| 225 | |
| 226 | static const struct snd_soc_dapm_route pcm1681_dapm_routes[] = { |
| 227 | { "VOUT1", NULL, "Playback" }, |
| 228 | { "VOUT2", NULL, "Playback" }, |
| 229 | { "VOUT3", NULL, "Playback" }, |
| 230 | { "VOUT4", NULL, "Playback" }, |
| 231 | { "VOUT5", NULL, "Playback" }, |
| 232 | { "VOUT6", NULL, "Playback" }, |
| 233 | { "VOUT7", NULL, "Playback" }, |
| 234 | { "VOUT8", NULL, "Playback" }, |
| 235 | }; |
| 236 | |
Marek Belisko | 95169d0 | 2013-08-01 11:14:58 +0200 | [diff] [blame] | 237 | static const DECLARE_TLV_DB_SCALE(pcm1681_dac_tlv, -6350, 50, 1); |
| 238 | |
| 239 | static const struct snd_kcontrol_new pcm1681_controls[] = { |
| 240 | SOC_DOUBLE_R_TLV("Channel 1/2 Playback Volume", |
| 241 | PCM1681_ATT_CONTROL(1), PCM1681_ATT_CONTROL(2), 0, |
| 242 | 0x7f, 0, pcm1681_dac_tlv), |
| 243 | SOC_DOUBLE_R_TLV("Channel 3/4 Playback Volume", |
| 244 | PCM1681_ATT_CONTROL(3), PCM1681_ATT_CONTROL(4), 0, |
| 245 | 0x7f, 0, pcm1681_dac_tlv), |
| 246 | SOC_DOUBLE_R_TLV("Channel 5/6 Playback Volume", |
| 247 | PCM1681_ATT_CONTROL(5), PCM1681_ATT_CONTROL(6), 0, |
| 248 | 0x7f, 0, pcm1681_dac_tlv), |
| 249 | SOC_DOUBLE_R_TLV("Channel 7/8 Playback Volume", |
| 250 | PCM1681_ATT_CONTROL(7), PCM1681_ATT_CONTROL(8), 0, |
| 251 | 0x7f, 0, pcm1681_dac_tlv), |
| 252 | SOC_SINGLE_BOOL_EXT("De-emphasis Switch", 0, |
| 253 | pcm1681_get_deemph, pcm1681_put_deemph), |
| 254 | }; |
| 255 | |
Mark Brown | 1669597 | 2013-08-08 12:25:57 +0100 | [diff] [blame] | 256 | static struct snd_soc_dai_driver pcm1681_dai = { |
Marek Belisko | 95169d0 | 2013-08-01 11:14:58 +0200 | [diff] [blame] | 257 | .name = "pcm1681-hifi", |
| 258 | .playback = { |
| 259 | .stream_name = "Playback", |
| 260 | .channels_min = 2, |
| 261 | .channels_max = 8, |
| 262 | .rates = PCM1681_PCM_RATES, |
| 263 | .formats = PCM1681_PCM_FORMATS, |
| 264 | }, |
| 265 | .ops = &pcm1681_dai_ops, |
| 266 | }; |
| 267 | |
| 268 | #ifdef CONFIG_OF |
| 269 | static const struct of_device_id pcm1681_dt_ids[] = { |
| 270 | { .compatible = "ti,pcm1681", }, |
| 271 | { } |
| 272 | }; |
| 273 | MODULE_DEVICE_TABLE(of, pcm1681_dt_ids); |
| 274 | #endif |
| 275 | |
| 276 | static const struct regmap_config pcm1681_regmap = { |
| 277 | .reg_bits = 8, |
| 278 | .val_bits = 8, |
Axel Lin | 64256ac | 2013-10-12 17:24:25 +0800 | [diff] [blame] | 279 | .max_register = 0x13, |
Marek Belisko | 95169d0 | 2013-08-01 11:14:58 +0200 | [diff] [blame] | 280 | .reg_defaults = pcm1681_reg_defaults, |
| 281 | .num_reg_defaults = ARRAY_SIZE(pcm1681_reg_defaults), |
| 282 | .writeable_reg = pcm1681_writeable_reg, |
| 283 | .readable_reg = pcm1681_accessible_reg, |
| 284 | }; |
| 285 | |
| 286 | static struct snd_soc_codec_driver soc_codec_dev_pcm1681 = { |
| 287 | .controls = pcm1681_controls, |
| 288 | .num_controls = ARRAY_SIZE(pcm1681_controls), |
Mark Brown | b9281f9 | 2013-08-13 18:25:41 +0100 | [diff] [blame] | 289 | .dapm_widgets = pcm1681_dapm_widgets, |
| 290 | .num_dapm_widgets = ARRAY_SIZE(pcm1681_dapm_widgets), |
| 291 | .dapm_routes = pcm1681_dapm_routes, |
| 292 | .num_dapm_routes = ARRAY_SIZE(pcm1681_dapm_routes), |
Marek Belisko | 95169d0 | 2013-08-01 11:14:58 +0200 | [diff] [blame] | 293 | }; |
| 294 | |
| 295 | static const struct i2c_device_id pcm1681_i2c_id[] = { |
| 296 | {"pcm1681", 0}, |
| 297 | {} |
| 298 | }; |
| 299 | MODULE_DEVICE_TABLE(i2c, pcm1681_i2c_id); |
| 300 | |
| 301 | static int pcm1681_i2c_probe(struct i2c_client *client, |
| 302 | const struct i2c_device_id *id) |
| 303 | { |
| 304 | int ret; |
| 305 | struct pcm1681_private *priv; |
| 306 | |
| 307 | priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL); |
| 308 | if (!priv) |
| 309 | return -ENOMEM; |
| 310 | |
| 311 | priv->regmap = devm_regmap_init_i2c(client, &pcm1681_regmap); |
| 312 | if (IS_ERR(priv->regmap)) { |
| 313 | ret = PTR_ERR(priv->regmap); |
| 314 | dev_err(&client->dev, "Failed to create regmap: %d\n", ret); |
| 315 | return ret; |
| 316 | } |
| 317 | |
| 318 | i2c_set_clientdata(client, priv); |
| 319 | |
| 320 | return snd_soc_register_codec(&client->dev, &soc_codec_dev_pcm1681, |
| 321 | &pcm1681_dai, 1); |
| 322 | } |
| 323 | |
| 324 | static int pcm1681_i2c_remove(struct i2c_client *client) |
| 325 | { |
| 326 | snd_soc_unregister_codec(&client->dev); |
| 327 | return 0; |
| 328 | } |
| 329 | |
| 330 | static struct i2c_driver pcm1681_i2c_driver = { |
| 331 | .driver = { |
| 332 | .name = "pcm1681", |
| 333 | .owner = THIS_MODULE, |
| 334 | .of_match_table = of_match_ptr(pcm1681_dt_ids), |
| 335 | }, |
| 336 | .id_table = pcm1681_i2c_id, |
| 337 | .probe = pcm1681_i2c_probe, |
| 338 | .remove = pcm1681_i2c_remove, |
| 339 | }; |
| 340 | |
| 341 | module_i2c_driver(pcm1681_i2c_driver); |
| 342 | |
| 343 | MODULE_DESCRIPTION("Texas Instruments PCM1681 ALSA SoC Codec Driver"); |
| 344 | MODULE_AUTHOR("Marek Belisko <marek.belisko@streamunlimited.com>"); |
| 345 | MODULE_LICENSE("GPL"); |