sound/soc/codecs/sta529.c

   1 /*
   2  * ASoC codec driver for spear platform
   3  *
   4  * sound/soc/codecs/sta529.c -- spear ALSA Soc codec driver
   5  *
   6  * Copyright (C) 2012 ST Microelectronics
   7  * Rajeev Kumar <[email protected]>
   8  *
   9  * This file is licensed under the terms of the GNU General Public
  10  * License version 2. This program is licensed "as is" without any
  11  * warranty of any kind, whether express or implied.
  12  */
  13
  14 #include <linux/clk.h>
  15 #include <linux/init.h>
  16 #include <linux/i2c.h>
  17 #include <linux/io.h>
  18 #include <linux/module.h>
  19 #include <linux/moduleparam.h>
  20 #include <linux/pm.h>
  21 #include <linux/regmap.h>
  22 #include <linux/slab.h>
  23
  24 #include <sound/core.h>
  25 #include <sound/initval.h>
  26 #include <sound/pcm.h>
  27 #include <sound/pcm_params.h>
  28 #include <sound/soc.h>
  29 #include <sound/soc-dapm.h>
  30 #include <sound/tlv.h>
  31
  32 /* STA529 Register offsets */
  33 #define  STA529_FFXCFG0         0x00
  34 #define  STA529_FFXCFG1         0x01
  35 #define  STA529_MVOL            0x02
  36 #define  STA529_LVOL            0x03
  37 #define  STA529_RVOL            0x04
  38 #define  STA529_TTF0            0x05
  39 #define  STA529_TTF1            0x06
  40 #define  STA529_TTP0            0x07
  41 #define  STA529_TTP1            0x08
  42 #define  STA529_S2PCFG0         0x0A
  43 #define  STA529_S2PCFG1         0x0B
  44 #define  STA529_P2SCFG0         0x0C
  45 #define  STA529_P2SCFG1         0x0D
  46 #define  STA529_PLLCFG0         0x14
  47 #define  STA529_PLLCFG1         0x15
  48 #define  STA529_PLLCFG2         0x16
  49 #define  STA529_PLLCFG3         0x17
  50 #define  STA529_PLLPFE          0x18
  51 #define  STA529_PLLST           0x19
  52 #define  STA529_ADCCFG          0x1E /*mic_select*/
  53 #define  STA529_CKOCFG          0x1F
  54 #define  STA529_MISC            0x20
  55 #define  STA529_PADST0          0x21
  56 #define  STA529_PADST1          0x22
  57 #define  STA529_FFXST           0x23
  58 #define  STA529_PWMIN1          0x2D
  59 #define  STA529_PWMIN2          0x2E
  60 #define  STA529_POWST           0x32
  61
  62 #define STA529_MAX_REGISTER     0x32
  63
  64 #define STA529_RATES            (SNDRV_PCM_RATE_8000 | \
  65                                 SNDRV_PCM_RATE_11025 | \
  66                                 SNDRV_PCM_RATE_16000 | \
  67                                 SNDRV_PCM_RATE_22050 | \
  68                                 SNDRV_PCM_RATE_32000 | \
  69                                 SNDRV_PCM_RATE_44100 | \
  70                                 SNDRV_PCM_RATE_48000)
  71
  72 #define STA529_FORMAT           (SNDRV_PCM_FMTBIT_S16_LE | \
  73                                 SNDRV_PCM_FMTBIT_S24_LE | \
  74                                 SNDRV_PCM_FMTBIT_S32_LE)
  75 #define S2PC_VALUE              0x98
  76 #define CLOCK_OUT               0x60
  77 #define DATA_FORMAT_MSK         0x0E
  78 #define LEFT_J_DATA_FORMAT      0x00
  79 #define I2S_DATA_FORMAT         0x02
  80 #define RIGHT_J_DATA_FORMAT     0x04
  81 #define CODEC_MUTE_VAL          0x80
  82
  83 #define POWER_CNTLMSAK          0x40
  84 #define POWER_STDBY             0x40
  85 #define FFX_MASK                0x80
  86 #define FFX_OFF                 0x80
  87 #define POWER_UP                0x00
  88 #define FFX_CLK_ENB             0x01
  89 #define FFX_CLK_DIS             0x00
  90 #define FFX_CLK_MSK             0x01
  91 #define PLAY_FREQ_RANGE_MSK     0x70
  92 #define CAP_FREQ_RANGE_MSK      0x0C
  93 #define PDATA_LEN_MSK           0xC0
  94 #define BCLK_TO_FS_MSK          0x30
  95 #define AUDIO_MUTE_MSK          0x80
  96
  97 static const struct reg_default sta529_reg_defaults[] = {
  98         { 0,  0x35 },     /* R0   - FFX Configuration reg 0 */
  99         { 1,  0xc8 },     /* R1   - FFX Configuration reg 1 */
 100         { 2,  0x50 },     /* R2   - Master Volume */
 101         { 3,  0x00 },     /* R3   - Left Volume */
 102         { 4,  0x00 },     /* R4  -  Right Volume */
 103         { 10, 0xb2 },     /* R10  - S2P Config Reg 0 */
 104         { 11, 0x41 },     /* R11  - S2P Config Reg 1 */
 105         { 12, 0x92 },     /* R12  - P2S Config Reg 0 */
 106         { 13, 0x41 },     /* R13  - P2S Config Reg 1 */
 107         { 30, 0xd2 },     /* R30  - ADC Config Reg */
 108         { 31, 0x40 },     /* R31  - clock Out Reg */
 109         { 32, 0x21 },     /* R32  - Misc Register */
 110 };
 111
 112 struct sta529 {
 113         struct regmap *regmap;
 114 };
 115
 116 static bool sta529_readable(struct device *dev, unsigned int reg)
 117 {
 118         switch (reg) {
 119
 120         case STA529_FFXCFG0:
 121         case STA529_FFXCFG1:
 122         case STA529_MVOL:
 123         case STA529_LVOL:
 124         case STA529_RVOL:
 125         case STA529_S2PCFG0:
 126         case STA529_S2PCFG1:
 127         case STA529_P2SCFG0:
 128         case STA529_P2SCFG1:
 129         case STA529_ADCCFG:
 130         case STA529_CKOCFG:
 131         case STA529_MISC:
 132                 return true;
 133         default:
 134                 return false;
 135         }
 136 }
 137
 138
 139 static const char *pwm_mode_text[] = { "Binary", "Headphone", "Ternary",
 140         "Phase-shift"};
 141
 142 static const DECLARE_TLV_DB_SCALE(out_gain_tlv, -9150, 50, 0);
 143 static const DECLARE_TLV_DB_SCALE(master_vol_tlv, -12750, 50, 0);
 144 static SOC_ENUM_SINGLE_DECL(pwm_src, STA529_FFXCFG1, 4, pwm_mode_text);
 145
 146 static const struct snd_kcontrol_new sta529_snd_controls[] = {
 147         SOC_DOUBLE_R_TLV("Digital Playback Volume", STA529_LVOL, STA529_RVOL, 0,
 148                         127, 0, out_gain_tlv),
 149         SOC_SINGLE_TLV("Master Playback Volume", STA529_MVOL, 0, 127, 1,
 150                         master_vol_tlv),
 151         SOC_ENUM("PWM Select", pwm_src),
 152 };
 153
 154 static int sta529_set_bias_level(struct snd_soc_codec *codec, enum
 155                 snd_soc_bias_level level)
 156 {
 157         struct sta529 *sta529 = snd_soc_codec_get_drvdata(codec);
 158
 159         switch (level) {
 160         case SND_SOC_BIAS_ON:
 161         case SND_SOC_BIAS_PREPARE:
 162                 snd_soc_update_bits(codec, STA529_FFXCFG0, POWER_CNTLMSAK,
 163                                 POWER_UP);
 164                 snd_soc_update_bits(codec, STA529_MISC, FFX_CLK_MSK,
 165                                 FFX_CLK_ENB);
 166                 break;
 167         case SND_SOC_BIAS_STANDBY:
 168                 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF)
 169                         regcache_sync(sta529->regmap);
 170                 snd_soc_update_bits(codec, STA529_FFXCFG0,
 171                                         POWER_CNTLMSAK, POWER_STDBY);
 172                 /* Making FFX output to zero */
 173                 snd_soc_update_bits(codec, STA529_FFXCFG0, FFX_MASK,
 174                                 FFX_OFF);
 175                 snd_soc_update_bits(codec, STA529_MISC, FFX_CLK_MSK,
 176                                 FFX_CLK_DIS);
 177                 break;
 178         case SND_SOC_BIAS_OFF:
 179                 break;
 180         }
 181
 182         /*
 183          * store the label for powers down audio subsystem for suspend.This is
 184          * used by soc core layer
 185          */
 186         codec->dapm.bias_level = level;
 187
 188         return 0;
 189
 190 }
 191
 192 static int sta529_hw_params(struct snd_pcm_substream *substream,
 193                 struct snd_pcm_hw_params *params,
 194                 struct snd_soc_dai *dai)
 195 {
 196         struct snd_soc_codec *codec = dai->codec;
 197         int pdata, play_freq_val, record_freq_val;
 198         int bclk_to_fs_ratio;
 199
 200         switch (params_width(params)) {
 201         case 16:
 202                 pdata = 1;
 203                 bclk_to_fs_ratio = 0;
 204                 break;
 205         case 24:
 206                 pdata = 2;
 207                 bclk_to_fs_ratio = 1;
 208                 break;
 209         case 32:
 210                 pdata = 3;
 211                 bclk_to_fs_ratio = 2;
 212                 break;
 213         default:
 214                 dev_err(codec->dev, "Unsupported format\n");
 215                 return -EINVAL;
 216         }
 217
 218         switch (params_rate(params)) {
 219         case 8000:
 220         case 11025:
 221                 play_freq_val = 0;
 222                 record_freq_val = 2;
 223                 break;
 224         case 16000:
 225         case 22050:
 226                 play_freq_val = 1;
 227                 record_freq_val = 0;
 228                 break;
 229
 230         case 32000:
 231         case 44100:
 232         case 48000:
 233                 play_freq_val = 2;
 234                 record_freq_val = 0;
 235                 break;
 236         default:
 237                 dev_err(codec->dev, "Unsupported rate\n");
 238                 return -EINVAL;
 239         }
 240
 241         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 242                 snd_soc_update_bits(codec, STA529_S2PCFG1, PDATA_LEN_MSK,
 243                                 pdata << 6);
 244                 snd_soc_update_bits(codec, STA529_S2PCFG1, BCLK_TO_FS_MSK,
 245                                 bclk_to_fs_ratio << 4);
 246                 snd_soc_update_bits(codec, STA529_MISC, PLAY_FREQ_RANGE_MSK,
 247                                 play_freq_val << 4);
 248         } else {
 249                 snd_soc_update_bits(codec, STA529_P2SCFG1, PDATA_LEN_MSK,
 250                                 pdata << 6);
 251                 snd_soc_update_bits(codec, STA529_P2SCFG1, BCLK_TO_FS_MSK,
 252                                 bclk_to_fs_ratio << 4);
 253                 snd_soc_update_bits(codec, STA529_MISC, CAP_FREQ_RANGE_MSK,
 254                                 record_freq_val << 2);
 255         }
 256
 257         return 0;
 258 }
 259
 260 static int sta529_mute(struct snd_soc_dai *dai, int mute)
 261 {
 262         u8 val = 0;
 263
 264         if (mute)
 265                 val |= CODEC_MUTE_VAL;
 266
 267         snd_soc_update_bits(dai->codec, STA529_FFXCFG0, AUDIO_MUTE_MSK, val);
 268
 269         return 0;
 270 }
 271
 272 static int sta529_set_dai_fmt(struct snd_soc_dai *codec_dai, u32 fmt)
 273 {
 274         struct snd_soc_codec *codec = codec_dai->codec;
 275         u8 mode = 0;
 276
 277         /* interface format */
 278         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 279         case SND_SOC_DAIFMT_LEFT_J:
 280                 mode = LEFT_J_DATA_FORMAT;
 281                 break;
 282         case SND_SOC_DAIFMT_I2S:
 283                 mode = I2S_DATA_FORMAT;
 284                 break;
 285         case SND_SOC_DAIFMT_RIGHT_J:
 286                 mode = RIGHT_J_DATA_FORMAT;
 287                 break;
 288         default:
 289                 return -EINVAL;
 290         }
 291
 292         snd_soc_update_bits(codec, STA529_S2PCFG0, DATA_FORMAT_MSK, mode);
 293
 294         return 0;
 295 }
 296
 297 static const struct snd_soc_dai_ops sta529_dai_ops = {
 298         .hw_params      =       sta529_hw_params,
 299         .set_fmt        =       sta529_set_dai_fmt,
 300         .digital_mute   =       sta529_mute,
 301 };
 302
 303 static struct snd_soc_dai_driver sta529_dai = {
 304         .name = "sta529-audio",
 305         .playback = {
 306                 .stream_name = "Playback",
 307                 .channels_min = 2,
 308                 .channels_max = 2,
 309                 .rates = STA529_RATES,
 310                 .formats = STA529_FORMAT,
 311         },
 312         .capture = {
 313                 .stream_name = "Capture",
 314                 .channels_min = 2,
 315                 .channels_max = 2,
 316                 .rates = STA529_RATES,
 317                 .formats = STA529_FORMAT,
 318         },
 319         .ops    = &sta529_dai_ops,
 320 };
 321
 322 static const struct snd_soc_codec_driver sta529_codec_driver = {
 323         .set_bias_level = sta529_set_bias_level,
 324         .suspend_bias_off = true,
 325
 326         .controls = sta529_snd_controls,
 327         .num_controls = ARRAY_SIZE(sta529_snd_controls),
 328 };
 329
 330 static const struct regmap_config sta529_regmap = {
 331         .reg_bits = 8,
 332         .val_bits = 8,
 333
 334         .max_register = STA529_MAX_REGISTER,
 335         .readable_reg = sta529_readable,
 336
 337         .cache_type = REGCACHE_RBTREE,
 338         .reg_defaults = sta529_reg_defaults,
 339         .num_reg_defaults = ARRAY_SIZE(sta529_reg_defaults),
 340 };
 341
 342 static int sta529_i2c_probe(struct i2c_client *i2c,
 343                             const struct i2c_device_id *id)
 344 {
 345         struct sta529 *sta529;
 346         int ret;
 347
 348         if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 349                 return -EINVAL;
 350
 351         sta529 = devm_kzalloc(&i2c->dev, sizeof(struct sta529), GFP_KERNEL);
 352         if (!sta529)
 353                 return -ENOMEM;
 354
 355         sta529->regmap = devm_regmap_init_i2c(i2c, &sta529_regmap);
 356         if (IS_ERR(sta529->regmap)) {
 357                 ret = PTR_ERR(sta529->regmap);
 358                 dev_err(&i2c->dev, "Failed to allocate regmap: %d\n", ret);
 359                 return ret;
 360         }
 361
 362         i2c_set_clientdata(i2c, sta529);
 363
 364         ret = snd_soc_register_codec(&i2c->dev,
 365                         &sta529_codec_driver, &sta529_dai, 1);
 366         if (ret != 0)
 367                 dev_err(&i2c->dev, "Failed to register CODEC: %d\n", ret);
 368
 369         return ret;
 370 }
 371
 372 static int sta529_i2c_remove(struct i2c_client *client)
 373 {
 374         snd_soc_unregister_codec(&client->dev);
 375
 376         return 0;
 377 }
 378
 379 static const struct i2c_device_id sta529_i2c_id[] = {
 380         { "sta529", 0 },
 381         { }
 382 };
 383 MODULE_DEVICE_TABLE(i2c, sta529_i2c_id);
 384
 385 static struct i2c_driver sta529_i2c_driver = {
 386         .driver = {
 387                 .name = "sta529",
 388                 .owner = THIS_MODULE,
 389         },
 390         .probe          = sta529_i2c_probe,
 391         .remove         = sta529_i2c_remove,
 392         .id_table       = sta529_i2c_id,
 393 };
 394
 395 module_i2c_driver(sta529_i2c_driver);
 396
 397 MODULE_DESCRIPTION("ASoC STA529 codec driver");
 398 MODULE_AUTHOR("Rajeev Kumar <[email protected]>");
 399 MODULE_LICENSE("GPL");