sound/soc/codecs/max98504.c

   1 /*
   2  * MAX98504 ALSA SoC Audio driver
   3  *
   4  * Copyright 2013 - 2014 Maxim Integrated Products
   5  * Copyright 2016 Samsung Electronics Co., Ltd.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11
  12 #include <linux/delay.h>
  13 #include <linux/i2c.h>
  14 #include <linux/module.h>
  15 #include <linux/regulator/consumer.h>
  16 #include <linux/slab.h>
  17 #include <linux/types.h>
  18 #include <sound/soc.h>
  19
  20 #include "max98504.h"
  21
  22 static const char * const max98504_supply_names[] = {
  23         "DVDD",
  24         "DIOVDD",
  25         "PVDD",
  26 };
  27 #define MAX98504_NUM_SUPPLIES ARRAY_SIZE(max98504_supply_names)
  28
  29 struct max98504_priv {
  30         struct regmap *regmap;
  31         struct regulator_bulk_data supplies[MAX98504_NUM_SUPPLIES];
  32         unsigned int pcm_rx_channels;
  33         bool brownout_enable;
  34         unsigned int brownout_threshold;
  35         unsigned int brownout_attenuation;
  36         unsigned int brownout_attack_hold;
  37         unsigned int brownout_timed_hold;
  38         unsigned int brownout_release_rate;
  39 };
  40
  41 static struct reg_default max98504_reg_defaults[] = {
  42         { 0x01, 0},
  43         { 0x02, 0},
  44         { 0x03, 0},
  45         { 0x04, 0},
  46         { 0x10, 0},
  47         { 0x11, 0},
  48         { 0x12, 0},
  49         { 0x13, 0},
  50         { 0x14, 0},
  51         { 0x15, 0},
  52         { 0x16, 0},
  53         { 0x17, 0},
  54         { 0x18, 0},
  55         { 0x19, 0},
  56         { 0x1A, 0},
  57         { 0x20, 0},
  58         { 0x21, 0},
  59         { 0x22, 0},
  60         { 0x23, 0},
  61         { 0x24, 0},
  62         { 0x25, 0},
  63         { 0x26, 0},
  64         { 0x27, 0},
  65         { 0x28, 0},
  66         { 0x30, 0},
  67         { 0x31, 0},
  68         { 0x32, 0},
  69         { 0x33, 0},
  70         { 0x34, 0},
  71         { 0x35, 0},
  72         { 0x36, 0},
  73         { 0x37, 0},
  74         { 0x38, 0},
  75         { 0x39, 0},
  76         { 0x40, 0},
  77         { 0x41, 0},
  78 };
  79
  80 static bool max98504_volatile_register(struct device *dev, unsigned int reg)
  81 {
  82         switch (reg) {
  83         case MAX98504_INTERRUPT_STATUS:
  84         case MAX98504_INTERRUPT_FLAGS:
  85         case MAX98504_INTERRUPT_FLAG_CLEARS:
  86         case MAX98504_WATCHDOG_CLEAR:
  87         case MAX98504_GLOBAL_ENABLE:
  88         case MAX98504_SOFTWARE_RESET:
  89                 return true;
  90         default:
  91                 return false;
  92         }
  93 }
  94
  95 static bool max98504_readable_register(struct device *dev, unsigned int reg)
  96 {
  97         switch (reg) {
  98         case MAX98504_SOFTWARE_RESET:
  99         case MAX98504_WATCHDOG_CLEAR:
 100         case MAX98504_INTERRUPT_FLAG_CLEARS:
 101                 return false;
 102         default:
 103                 return true;
 104         }
 105 }
 106
 107 static int max98504_pcm_rx_ev(struct snd_soc_dapm_widget *w,
 108                               struct snd_kcontrol *kcontrol, int event)
 109 {
 110         struct snd_soc_component *c = snd_soc_dapm_to_component(w->dapm);
 111         struct max98504_priv *max98504 = snd_soc_component_get_drvdata(c);
 112
 113         switch (event) {
 114         case SND_SOC_DAPM_PRE_PMU:
 115                 regmap_write(max98504->regmap, MAX98504_PCM_RX_ENABLE,
 116                              max98504->pcm_rx_channels);
 117                 break;
 118         case SND_SOC_DAPM_POST_PMD:
 119                 regmap_write(max98504->regmap, MAX98504_PCM_RX_ENABLE, 0);
 120                 break;
 121         }
 122
 123         return 0;
 124 }
 125
 126 static int max98504_component_probe(struct snd_soc_component *c)
 127 {
 128         struct max98504_priv *max98504 = snd_soc_component_get_drvdata(c);
 129         struct regmap *map = max98504->regmap;
 130         int ret;
 131
 132         ret = regulator_bulk_enable(MAX98504_NUM_SUPPLIES, max98504->supplies);
 133         if (ret < 0)
 134                 return ret;
 135
 136         regmap_write(map, MAX98504_SOFTWARE_RESET, 0x1);
 137         msleep(20);
 138
 139         if (!max98504->brownout_enable)
 140                 return 0;
 141
 142         regmap_write(map, MAX98504_PVDD_BROWNOUT_ENABLE, 0x1);
 143
 144         regmap_write(map, MAX98504_PVDD_BROWNOUT_CONFIG_1,
 145                      (max98504->brownout_threshold & 0x1f) << 3 |
 146                      (max98504->brownout_attenuation & 0x3));
 147
 148         regmap_write(map, MAX98504_PVDD_BROWNOUT_CONFIG_2,
 149                      max98504->brownout_attack_hold & 0xff);
 150
 151         regmap_write(map, MAX98504_PVDD_BROWNOUT_CONFIG_3,
 152                      max98504->brownout_timed_hold & 0xff);
 153
 154         regmap_write(map, MAX98504_PVDD_BROWNOUT_CONFIG_4,
 155                      max98504->brownout_release_rate & 0xff);
 156
 157         return 0;
 158 }
 159
 160 static void max98504_component_remove(struct snd_soc_component *c)
 161 {
 162         struct max98504_priv *max98504 = snd_soc_component_get_drvdata(c);
 163
 164         regulator_bulk_disable(MAX98504_NUM_SUPPLIES, max98504->supplies);
 165 }
 166
 167 static const char *spk_source_mux_text[] = {
 168         "PCM Monomix", "Analog In", "PDM Left", "PDM Right"
 169 };
 170
 171 static const struct soc_enum spk_source_mux_enum =
 172         SOC_ENUM_SINGLE(MAX98504_SPEAKER_SOURCE_SELECT,
 173                         0, ARRAY_SIZE(spk_source_mux_text),
 174                         spk_source_mux_text);
 175
 176 static const struct snd_kcontrol_new spk_source_mux =
 177         SOC_DAPM_ENUM("SPK Source", spk_source_mux_enum);
 178
 179 static const struct snd_soc_dapm_route max98504_dapm_routes[] = {
 180         { "SPKOUT", NULL, "Global Enable" },
 181         { "SPK Source", "PCM Monomix", "DAC PCM" },
 182         { "SPK Source", "Analog In", "AIN" },
 183         { "SPK Source", "PDM Left", "DAC PDM" },
 184         { "SPK Source", "PDM Right", "DAC PDM" },
 185 };
 186
 187 static const struct snd_soc_dapm_widget max98504_dapm_widgets[] = {
 188         SND_SOC_DAPM_SUPPLY("Global Enable", MAX98504_GLOBAL_ENABLE,
 189                 0, 0, NULL, 0),
 190         SND_SOC_DAPM_INPUT("AIN"),
 191         SND_SOC_DAPM_AIF_OUT("AIF2OUTL", "AIF2 Capture", 0, SND_SOC_NOPM, 0, 0),
 192         SND_SOC_DAPM_AIF_OUT("AIF2OUTR", "AIF2 Capture", 1, SND_SOC_NOPM, 0, 0),
 193         SND_SOC_DAPM_DAC_E("DAC PCM", NULL, SND_SOC_NOPM, 0, 0,
 194                 max98504_pcm_rx_ev,
 195                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
 196         SND_SOC_DAPM_DAC("DAC PDM", NULL, MAX98504_PDM_RX_ENABLE, 0, 0),
 197         SND_SOC_DAPM_MUX("SPK Source", SND_SOC_NOPM, 0, 0, &spk_source_mux),
 198         SND_SOC_DAPM_REG(snd_soc_dapm_spk, "SPKOUT",
 199                 MAX98504_SPEAKER_ENABLE, 0, 1, 1, 0),
 200 };
 201
 202 static int max98504_set_tdm_slot(struct snd_soc_dai *dai,
 203                 unsigned int tx_mask, unsigned int rx_mask,
 204                 int slots, int slot_width)
 205 {
 206         struct max98504_priv *max98504 = snd_soc_dai_get_drvdata(dai);
 207         struct regmap *map = max98504->regmap;
 208
 209
 210         switch (dai->id) {
 211         case MAX98504_DAI_ID_PCM:
 212                 regmap_write(map, MAX98504_PCM_TX_ENABLE, tx_mask);
 213                 max98504->pcm_rx_channels = rx_mask;
 214                 break;
 215
 216         case MAX98504_DAI_ID_PDM:
 217                 regmap_write(map, MAX98504_PDM_TX_ENABLE, tx_mask);
 218                 break;
 219         default:
 220                 WARN_ON(1);
 221         }
 222
 223         return 0;
 224 }
 225 static int max98504_set_channel_map(struct snd_soc_dai *dai,
 226                 unsigned int tx_num, unsigned int *tx_slot,
 227                 unsigned int rx_num, unsigned int *rx_slot)
 228 {
 229         struct max98504_priv *max98504 = snd_soc_dai_get_drvdata(dai);
 230         struct regmap *map = max98504->regmap;
 231         unsigned int i, sources = 0;
 232
 233         for (i = 0; i < tx_num; i++)
 234                 if (tx_slot[i])
 235                         sources |= (1 << i);
 236
 237         switch (dai->id) {
 238         case MAX98504_DAI_ID_PCM:
 239                 regmap_write(map, MAX98504_PCM_TX_CHANNEL_SOURCES,
 240                              sources);
 241                 break;
 242
 243         case MAX98504_DAI_ID_PDM:
 244                 regmap_write(map, MAX98504_PDM_TX_CONTROL, sources);
 245                 break;
 246         default:
 247                 WARN_ON(1);
 248         }
 249
 250         regmap_write(map, MAX98504_MEASUREMENT_ENABLE, sources ? 0x3 : 0x01);
 251
 252         return 0;
 253 }
 254
 255 static const struct snd_soc_dai_ops max98504_dai_ops = {
 256         .set_tdm_slot           = max98504_set_tdm_slot,
 257         .set_channel_map        = max98504_set_channel_map,
 258 };
 259
 260 #define MAX98504_FORMATS        (SNDRV_PCM_FMTBIT_S8|SNDRV_PCM_FMTBIT_S16_LE|\
 261                                 SNDRV_PCM_FMTBIT_S24_LE|SNDRV_PCM_FMTBIT_S32_LE)
 262 #define MAX98504_PDM_RATES      (SNDRV_PCM_RATE_8000|SNDRV_PCM_RATE_16000|\
 263                                 SNDRV_PCM_RATE_32000|SNDRV_PCM_RATE_44100|\
 264                                 SNDRV_PCM_RATE_48000|SNDRV_PCM_RATE_88200|\
 265                                 SNDRV_PCM_RATE_96000)
 266
 267 static struct snd_soc_dai_driver max98504_dai[] = {
 268         /* TODO: Add the PCM interface definitions */
 269         {
 270                 .name = "max98504-aif2",
 271                 .id = MAX98504_DAI_ID_PDM,
 272                 .playback = {
 273                         .stream_name    = "AIF2 Playback",
 274                         .channels_min   = 1,
 275                         .channels_max   = 2,
 276                         .rates          = MAX98504_PDM_RATES,
 277                         .formats        = MAX98504_FORMATS,
 278                 },
 279                 .capture = {
 280                         .stream_name    = "AIF2 Capture",
 281                         .channels_min   = 1,
 282                         .channels_max   = 2,
 283                         .rates          = MAX98504_PDM_RATES,
 284                         .formats        = MAX98504_FORMATS,
 285                 },
 286                 .ops = &max98504_dai_ops,
 287         },
 288 };
 289
 290 static const struct snd_soc_component_driver max98504_component_driver = {
 291         .probe                  = max98504_component_probe,
 292         .remove                 = max98504_component_remove,
 293         .dapm_widgets           = max98504_dapm_widgets,
 294         .num_dapm_widgets       = ARRAY_SIZE(max98504_dapm_widgets),
 295         .dapm_routes            = max98504_dapm_routes,
 296         .num_dapm_routes        = ARRAY_SIZE(max98504_dapm_routes),
 297 };
 298
 299 static const struct regmap_config max98504_regmap = {
 300         .reg_bits               = 16,
 301         .val_bits               = 8,
 302         .max_register           = MAX98504_MAX_REGISTER,
 303         .reg_defaults           = max98504_reg_defaults,
 304         .num_reg_defaults       = ARRAY_SIZE(max98504_reg_defaults),
 305         .volatile_reg           = max98504_volatile_register,
 306         .readable_reg           = max98504_readable_register,
 307         .cache_type             = REGCACHE_RBTREE,
 308 };
 309
 310 static int max98504_i2c_probe(struct i2c_client *client,
 311                               const struct i2c_device_id *id)
 312 {
 313         struct device *dev = &client->dev;
 314         struct device_node *node = dev->of_node;
 315         struct max98504_priv *max98504;
 316         int i, ret;
 317
 318         max98504 = devm_kzalloc(dev, sizeof(*max98504), GFP_KERNEL);
 319         if (!max98504)
 320                 return -ENOMEM;
 321
 322         if (node) {
 323                 if (!of_property_read_u32(node, "maxim,brownout-threshold",
 324                                         &max98504->brownout_threshold))
 325                         max98504->brownout_enable = true;
 326
 327                 of_property_read_u32(node, "maxim,brownout-attenuation",
 328                                         &max98504->brownout_attenuation);
 329                 of_property_read_u32(node, "maxim,brownout-attack-hold-ms",
 330                                         &max98504->brownout_attack_hold);
 331                 of_property_read_u32(node, "maxim,brownout-timed-hold-ms",
 332                                         &max98504->brownout_timed_hold);
 333                 of_property_read_u32(node, "maxim,brownout-release-rate-ms",
 334                                         &max98504->brownout_release_rate);
 335         }
 336
 337         max98504->regmap = devm_regmap_init_i2c(client, &max98504_regmap);
 338         if (IS_ERR(max98504->regmap)) {
 339                 ret = PTR_ERR(max98504->regmap);
 340                 dev_err(&client->dev, "regmap initialization failed: %d\n", ret);
 341                 return ret;
 342         }
 343
 344         for (i = 0; i < MAX98504_NUM_SUPPLIES; i++)
 345                 max98504->supplies[i].supply = max98504_supply_names[i];
 346
 347         ret = devm_regulator_bulk_get(dev, MAX98504_NUM_SUPPLIES,
 348                                       max98504->supplies);
 349         if (ret < 0)
 350                 return ret;
 351
 352         i2c_set_clientdata(client, max98504);
 353
 354         return devm_snd_soc_register_component(dev, &max98504_component_driver,
 355                                 max98504_dai, ARRAY_SIZE(max98504_dai));
 356 }
 357
 358 #ifdef CONFIG_OF
 359 static const struct of_device_id max98504_of_match[] = {
 360         { .compatible = "maxim,max98504" },
 361         { },
 362 };
 363 MODULE_DEVICE_TABLE(of, max98504_of_match);
 364 #endif
 365
 366 static const struct i2c_device_id max98504_i2c_id[] = {
 367         { "max98504" },
 368         { }
 369 };
 370 MODULE_DEVICE_TABLE(i2c, max98504_i2c_id);
 371
 372 static struct i2c_driver max98504_i2c_driver = {
 373         .driver = {
 374                 .name = "max98504",
 375                 .of_match_table = of_match_ptr(max98504_of_match),
 376         },
 377         .probe = max98504_i2c_probe,
 378         .id_table = max98504_i2c_id,
 379 };
 380 module_i2c_driver(max98504_i2c_driver);
 381
 382 MODULE_DESCRIPTION("ASoC MAX98504 driver");
 383 MODULE_LICENSE("GPL");