target/linux/bcm27xx/patches-5.4/950-0077-Driver-and-overlay-for-Allo-Katana-DAC.patch

   1 From 32e71104fac52cd0dfe3614ac0d74e4eb50c509b Mon Sep 17 00:00:00 2001
   2 From: allocom <sparky-dev@allo.com>
   3 Date: Thu, 19 Apr 2018 12:12:26 +0530
   4 Subject: [PATCH] Driver and overlay for Allo Katana DAC
   5
   6 Allo Katana DAC: Updated default values
   7
   8 Signed-off-by: Jaikumar <jaikumar@cem-solutions.com>
   9
  10 Added mute stream func
  11
  12 Signed-off-by: Jaikumar <jaikumar@cem-solutions.net>
  13
  14 codecs: Correct Katana minimum volume
  15
  16 Update Katana minimum volume to get the exact 0.5 dB value in each step.
  17
  18 Signed-off-by: Sudeep Kumar <sudeepkumar@cem-solutions.net>
  19 ---
  20  sound/soc/bcm/allo-katana-codec.c | 388 ++++++++++++++++++++++++++++++
  21  1 file changed, 388 insertions(+)
  22  create mode 100644 sound/soc/bcm/allo-katana-codec.c
  23
  24 --- /dev/null
  25 +++ b/sound/soc/bcm/allo-katana-codec.c
  26 @@ -0,0 +1,388 @@
  27 +/*
  28 + * Driver for the ALLO KATANA CODEC
  29 + *
  30 + * Author: Jaikumar <jaikumar@cem-solutions.net>
  31 + *             Copyright 2018
  32 + *
  33 + * This program is free software; you can redistribute it and/or
  34 + * modify it under the terms of the GNU General Public License
  35 + * version 2 as published by the Free Software Foundation.
  36 + *
  37 + * This program is distributed in the hope that it will be useful, but
  38 + * WITHOUT ANY WARRANTY; without even the implied warranty of
  39 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  40 + * General Public License for more details.
  41 + */
  42 +
  43 +
  44 +#include <linux/init.h>
  45 +#include <linux/module.h>
  46 +#include <linux/clk.h>
  47 +#include <linux/kernel.h>
  48 +#include <linux/regmap.h>
  49 +#include <linux/regulator/consumer.h>
  50 +#include <linux/gcd.h>
  51 +#include <sound/soc.h>
  52 +#include <sound/soc-dapm.h>
  53 +#include <sound/pcm_params.h>
  54 +#include <sound/tlv.h>
  55 +#include <linux/i2c.h>
  56 +
  57 +
  58 +#define KATANA_CODEC_CHIP_ID           0x30
  59 +#define KATANA_CODEC_VIRT_BASE         0x100
  60 +#define KATANA_CODEC_PAGE              0
  61 +
  62 +#define KATANA_CODEC_CHIP_ID_REG       (KATANA_CODEC_VIRT_BASE + 0)
  63 +#define KATANA_CODEC_RESET             (KATANA_CODEC_VIRT_BASE + 1)
  64 +#define KATANA_CODEC_VOLUME_1          (KATANA_CODEC_VIRT_BASE + 2)
  65 +#define KATANA_CODEC_VOLUME_2          (KATANA_CODEC_VIRT_BASE + 3)
  66 +#define KATANA_CODEC_MUTE              (KATANA_CODEC_VIRT_BASE + 4)
  67 +#define KATANA_CODEC_DSP_PROGRAM       (KATANA_CODEC_VIRT_BASE + 5)
  68 +#define KATANA_CODEC_DEEMPHASIS                (KATANA_CODEC_VIRT_BASE + 6)
  69 +#define KATANA_CODEC_DOP               (KATANA_CODEC_VIRT_BASE + 7)
  70 +#define KATANA_CODEC_FORMAT            (KATANA_CODEC_VIRT_BASE + 8)
  71 +#define KATANA_CODEC_COMMAND           (KATANA_CODEC_VIRT_BASE + 9)
  72 +#define KATANA_CODEC_MUTE_STREAM       (KATANA_CODEC_VIRT_BASE + 10)
  73 +
  74 +#define KATANA_CODEC_MAX_REGISTER      (KATANA_CODEC_VIRT_BASE + 10)
  75 +
  76 +#define KATANA_CODEC_FMT               0xff
  77 +#define KATANA_CODEC_CHAN_MONO         0x00
  78 +#define KATANA_CODEC_CHAN_STEREO       0x80
  79 +#define KATANA_CODEC_ALEN_16           0x10
  80 +#define KATANA_CODEC_ALEN_24           0x20
  81 +#define KATANA_CODEC_ALEN_32           0x30
  82 +#define KATANA_CODEC_RATE_11025                0x01
  83 +#define KATANA_CODEC_RATE_22050                0x02
  84 +#define KATANA_CODEC_RATE_32000                0x03
  85 +#define KATANA_CODEC_RATE_44100                0x04
  86 +#define KATANA_CODEC_RATE_48000                0x05
  87 +#define KATANA_CODEC_RATE_88200                0x06
  88 +#define KATANA_CODEC_RATE_96000                0x07
  89 +#define KATANA_CODEC_RATE_176400       0x08
  90 +#define KATANA_CODEC_RATE_192000       0x09
  91 +#define KATANA_CODEC_RATE_352800       0x0a
  92 +#define KATANA_CODEC_RATE_384000       0x0b
  93 +
  94 +
  95 +struct katana_codec_priv {
  96 +       struct regmap *regmap;
  97 +       int fmt;
  98 +};
  99 +
 100 +static const struct reg_default katana_codec_reg_defaults[] = {
 101 +       { KATANA_CODEC_RESET,           0x00 },
 102 +       { KATANA_CODEC_VOLUME_1,        0xF0 },
 103 +       { KATANA_CODEC_VOLUME_2,        0xF0 },
 104 +       { KATANA_CODEC_MUTE,            0x00 },
 105 +       { KATANA_CODEC_DSP_PROGRAM,     0x04 },
 106 +       { KATANA_CODEC_DEEMPHASIS,      0x00 },
 107 +       { KATANA_CODEC_DOP,             0x00 },
 108 +       { KATANA_CODEC_FORMAT,          0xb4 },
 109 +};
 110 +
 111 +static const char * const katana_codec_dsp_program_texts[] = {
 112 +       "Linear Phase Fast Roll-off Filter",
 113 +       "Linear Phase Slow Roll-off Filter",
 114 +       "Minimum Phase Fast Roll-off Filter",
 115 +       "Minimum Phase Slow Roll-off Filter",
 116 +       "Apodizing Fast Roll-off Filter",
 117 +       "Corrected Minimum Phase Fast Roll-off Filter",
 118 +       "Brick Wall Filter",
 119 +};
 120 +
 121 +static const unsigned int katana_codec_dsp_program_values[] = {
 122 +       0,
 123 +       1,
 124 +       2,
 125 +       3,
 126 +       4,
 127 +       6,
 128 +       7,
 129 +};
 130 +
 131 +static SOC_VALUE_ENUM_SINGLE_DECL(katana_codec_dsp_program,
 132 +                                 KATANA_CODEC_DSP_PROGRAM, 0, 0x07,
 133 +                                 katana_codec_dsp_program_texts,
 134 +                                 katana_codec_dsp_program_values);
 135 +
 136 +static const char * const katana_codec_deemphasis_texts[] = {
 137 +       "Bypass",
 138 +       "32kHz",
 139 +       "44.1kHz",
 140 +       "48kHz",
 141 +};
 142 +
 143 +static const unsigned int katana_codec_deemphasis_values[] = {
 144 +       0,
 145 +       1,
 146 +       2,
 147 +       3,
 148 +};
 149 +
 150 +static SOC_VALUE_ENUM_SINGLE_DECL(katana_codec_deemphasis,
 151 +                                 KATANA_CODEC_DEEMPHASIS, 0, 0x03,
 152 +                                 katana_codec_deemphasis_texts,
 153 +                                 katana_codec_deemphasis_values);
 154 +
 155 +static const SNDRV_CTL_TLVD_DECLARE_DB_MINMAX(master_tlv, -12750, 0);
 156 +
 157 +static const struct snd_kcontrol_new katana_codec_controls[] = {
 158 +       SOC_DOUBLE_R_TLV("Master Playback Volume", KATANA_CODEC_VOLUME_1,
 159 +                       KATANA_CODEC_VOLUME_2, 0, 255, 1, master_tlv),
 160 +       SOC_DOUBLE("Master Playback Switch", KATANA_CODEC_MUTE, 0, 0, 1, 1),
 161 +       SOC_ENUM("DSP Program Route", katana_codec_dsp_program),
 162 +       SOC_ENUM("Deemphasis Route", katana_codec_deemphasis),
 163 +       SOC_SINGLE("DoP Playback Switch", KATANA_CODEC_DOP, 0, 1, 1)
 164 +};
 165 +
 166 +static bool katana_codec_readable_register(struct device *dev,
 167 +                               unsigned int reg)
 168 +{
 169 +       switch (reg) {
 170 +       case KATANA_CODEC_CHIP_ID_REG:
 171 +               return true;
 172 +       default:
 173 +               return reg < 0xff;
 174 +       }
 175 +}
 176 +
 177 +static int katana_codec_hw_params(struct snd_pcm_substream *substream,
 178 +                            struct snd_pcm_hw_params *params,
 179 +                            struct snd_soc_dai *dai)
 180 +{
 181 +       struct snd_soc_component *component = dai->component;
 182 +       struct katana_codec_priv *katana_codec =
 183 +               snd_soc_component_get_drvdata(component);
 184 +       int fmt = 0;
 185 +       int ret;
 186 +
 187 +       dev_dbg(component->card->dev, "hw_params %u Hz, %u channels, %u bits\n",
 188 +                       params_rate(params),
 189 +                       params_channels(params),
 190 +                       params_width(params));
 191 +
 192 +       switch (katana_codec->fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 193 +       case SND_SOC_DAIFMT_CBM_CFM: // master
 194 +               if (params_channels(params) == 2)
 195 +                       fmt = KATANA_CODEC_CHAN_STEREO;
 196 +               else
 197 +                       fmt = KATANA_CODEC_CHAN_MONO;
 198 +
 199 +               switch (params_width(params)) {
 200 +               case 16:
 201 +                       fmt |= KATANA_CODEC_ALEN_16;
 202 +                       break;
 203 +               case 24:
 204 +                       fmt |= KATANA_CODEC_ALEN_24;
 205 +                       break;
 206 +               case 32:
 207 +                       fmt |= KATANA_CODEC_ALEN_32;
 208 +                       break;
 209 +               default:
 210 +                       dev_err(component->card->dev, "Bad frame size: %d\n",
 211 +                                       params_width(params));
 212 +                       return -EINVAL;
 213 +               }
 214 +
 215 +               switch (params_rate(params)) {
 216 +               case 44100:
 217 +                       fmt |= KATANA_CODEC_RATE_44100;
 218 +                       break;
 219 +               case 48000:
 220 +                       fmt |= KATANA_CODEC_RATE_48000;
 221 +                       break;
 222 +               case 88200:
 223 +                       fmt |= KATANA_CODEC_RATE_88200;
 224 +                       break;
 225 +               case 96000:
 226 +                       fmt |= KATANA_CODEC_RATE_96000;
 227 +                       break;
 228 +               case 176400:
 229 +                       fmt |= KATANA_CODEC_RATE_176400;
 230 +                       break;
 231 +               case 192000:
 232 +                       fmt |= KATANA_CODEC_RATE_192000;
 233 +                       break;
 234 +               case 352800:
 235 +                       fmt |= KATANA_CODEC_RATE_352800;
 236 +                       break;
 237 +               case 384000:
 238 +                       fmt |= KATANA_CODEC_RATE_384000;
 239 +                       break;
 240 +               default:
 241 +                       dev_err(component->card->dev, "Bad sample rate: %d\n",
 242 +                                       params_rate(params));
 243 +                       return -EINVAL;
 244 +               }
 245 +
 246 +               ret = regmap_write(katana_codec->regmap, KATANA_CODEC_FORMAT,
 247 +                                       fmt);
 248 +               if (ret != 0) {
 249 +                       dev_err(component->card->dev, "Failed to set format: %d\n", ret);
 250 +                       return ret;
 251 +               }
 252 +               break;
 253 +
 254 +       case SND_SOC_DAIFMT_CBS_CFS:
 255 +               break;
 256 +
 257 +       default:
 258 +               return -EINVAL;
 259 +       }
 260 +
 261 +       return 0;
 262 +}
 263 +
 264 +static int katana_codec_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
 265 +{
 266 +       struct snd_soc_component *component = dai->component;
 267 +       struct katana_codec_priv *katana_codec =
 268 +               snd_soc_component_get_drvdata(component);
 269 +
 270 +       katana_codec->fmt = fmt;
 271 +
 272 +       return 0;
 273 +}
 274 +
 275 +int katana_codec_dai_mute_stream(struct snd_soc_dai *dai, int mute,
 276 +                                               int stream)
 277 +{
 278 +       struct snd_soc_component *component = dai->component;
 279 +       struct katana_codec_priv *katana_codec =
 280 +               snd_soc_component_get_drvdata(component);
 281 +       int ret = 0;
 282 +
 283 +       ret = regmap_write(katana_codec->regmap, KATANA_CODEC_MUTE_STREAM,
 284 +                               mute);
 285 +       if (ret != 0) {
 286 +               dev_err(component->card->dev, "Failed to set mute: %d\n", ret);
 287 +               return ret;
 288 +       }
 289 +       return ret;
 290 +}
 291 +
 292 +static const struct snd_soc_dai_ops katana_codec_dai_ops = {
 293 +       .mute_stream = katana_codec_dai_mute_stream,
 294 +       .hw_params = katana_codec_hw_params,
 295 +       .set_fmt = katana_codec_set_fmt,
 296 +};
 297 +
 298 +static struct snd_soc_dai_driver katana_codec_dai = {
 299 +       .name = "allo-katana-codec",
 300 +       .playback = {
 301 +               .stream_name = "Playback",
 302 +               .channels_min = 2,
 303 +               .channels_max = 2,
 304 +               .rates = SNDRV_PCM_RATE_CONTINUOUS,
 305 +               .rate_min = 44100,
 306 +               .rate_max = 384000,
 307 +               .formats = SNDRV_PCM_FMTBIT_S16_LE |
 308 +                       SNDRV_PCM_FMTBIT_S32_LE
 309 +       },
 310 +       .ops = &katana_codec_dai_ops,
 311 +};
 312 +
 313 +static struct snd_soc_component_driver katana_codec_component_driver = {
 314 +       .idle_bias_on = true,
 315 +
 316 +       .controls               = katana_codec_controls,
 317 +       .num_controls   = ARRAY_SIZE(katana_codec_controls),
 318 +};
 319 +
 320 +static const struct regmap_range_cfg katana_codec_range = {
 321 +       .name = "Pages", .range_min = KATANA_CODEC_VIRT_BASE,
 322 +       .range_max = KATANA_CODEC_MAX_REGISTER,
 323 +       .selector_reg = KATANA_CODEC_PAGE,
 324 +       .selector_mask = 0xff,
 325 +       .window_start = 0, .window_len = 0x100,
 326 +};
 327 +
 328 +const struct regmap_config katana_codec_regmap = {
 329 +       .reg_bits = 8,
 330 +       .val_bits = 8,
 331 +
 332 +       .ranges = &katana_codec_range,
 333 +       .num_ranges = 1,
 334 +
 335 +       .max_register = KATANA_CODEC_MAX_REGISTER,
 336 +       .readable_reg = katana_codec_readable_register,
 337 +       .reg_defaults = katana_codec_reg_defaults,
 338 +       .num_reg_defaults = ARRAY_SIZE(katana_codec_reg_defaults),
 339 +       .cache_type = REGCACHE_RBTREE,
 340 +};
 341 +
 342 +static int allo_katana_component_probe(struct i2c_client *i2c,
 343 +                            const struct i2c_device_id *id)
 344 +{
 345 +       struct regmap *regmap;
 346 +       struct regmap_config config = katana_codec_regmap;
 347 +       struct device *dev = &i2c->dev;
 348 +       struct katana_codec_priv *katana_codec;
 349 +       unsigned int chip_id = 0;
 350 +       int ret;
 351 +
 352 +       regmap = devm_regmap_init_i2c(i2c, &config);
 353 +       if (IS_ERR(regmap))
 354 +               return PTR_ERR(regmap);
 355 +
 356 +       katana_codec = devm_kzalloc(dev, sizeof(struct katana_codec_priv),
 357 +                                       GFP_KERNEL);
 358 +       if (!katana_codec)
 359 +               return -ENOMEM;
 360 +
 361 +       dev_set_drvdata(dev, katana_codec);
 362 +       katana_codec->regmap = regmap;
 363 +
 364 +       ret = regmap_read(regmap, KATANA_CODEC_CHIP_ID_REG, &chip_id);
 365 +       if ((ret != 0) || (chip_id != KATANA_CODEC_CHIP_ID)) {
 366 +               dev_err(dev, "Failed to read Chip or wrong Chip id: %d\n", ret);
 367 +               return ret;
 368 +       }
 369 +       regmap_update_bits(regmap, KATANA_CODEC_RESET, 0x01, 0x01);
 370 +       msleep(10);
 371 +
 372 +       ret = snd_soc_register_component(dev, &katana_codec_component_driver,
 373 +                                   &katana_codec_dai, 1);
 374 +       if (ret != 0) {
 375 +               dev_err(dev, "failed to register codec: %d\n", ret);
 376 +               return ret;
 377 +       }
 378 +
 379 +       return 0;
 380 +}
 381 +
 382 +static int allo_katana_component_remove(struct i2c_client *i2c)
 383 +{
 384 +       snd_soc_unregister_component(&i2c->dev);
 385 +       return 0;
 386 +}
 387 +
 388 +static const struct i2c_device_id allo_katana_component_id[] = {
 389 +       { "allo-katana-codec", },
 390 +       { }
 391 +};
 392 +MODULE_DEVICE_TABLE(i2c, allo_katana_component_id);
 393 +
 394 +static const struct of_device_id allo_katana_codec_of_match[] = {
 395 +       { .compatible = "allo,allo-katana-codec", },
 396 +       { }
 397 +};
 398 +MODULE_DEVICE_TABLE(of, allo_katana_codec_of_match);
 399 +
 400 +static struct i2c_driver allo_katana_component_driver = {
 401 +       .probe          = allo_katana_component_probe,
 402 +       .remove         = allo_katana_component_remove,
 403 +       .id_table       = allo_katana_component_id,
 404 +       .driver         = {
 405 +       .name           = "allo-katana-codec",
 406 +       .of_match_table = allo_katana_codec_of_match,
 407 +       },
 408 +};
 409 +
 410 +module_i2c_driver(allo_katana_component_driver);
 411 +
 412 +MODULE_DESCRIPTION("ASoC Allo Katana Codec Driver");
 413 +MODULE_AUTHOR("Jaikumar <jaikumar@cem-solutions.net>");
 414 +MODULE_LICENSE("GPL v2");