sound/soc/qcom/sc8280xp.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (c) 2022, Linaro Limited
   3
   4 #include <dt-bindings/sound/qcom,q6afe.h>
   5 #include <linux/module.h>
   6 #include <linux/platform_device.h>
   7 #include <sound/soc.h>
   8 #include <sound/soc-dapm.h>
   9 #include <sound/pcm.h>
  10 #include <linux/soundwire/sdw.h>
  11 #include <sound/jack.h>
  12 #include <linux/input-event-codes.h>
  13 #include "qdsp6/q6afe.h"
  14 #include "common.h"
  15 #include "sdw.h"
  16
  17 struct sc8280xp_snd_data {
  18         bool stream_prepared[AFE_PORT_MAX];
  19         struct snd_soc_card *card;
  20         struct sdw_stream_runtime *sruntime[AFE_PORT_MAX];
  21         struct snd_soc_jack jack;
  22         struct snd_soc_jack dp_jack[8];
  23         bool jack_setup;
  24 };
  25
  26 static int sc8280xp_snd_init(struct snd_soc_pcm_runtime *rtd)
  27 {
  28         struct sc8280xp_snd_data *data = snd_soc_card_get_drvdata(rtd->card);
  29         struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
  30         struct snd_soc_card *card = rtd->card;
  31         struct snd_soc_jack *dp_jack  = NULL;
  32         int dp_pcm_id = 0;
  33
  34         switch (cpu_dai->id) {
  35         case WSA_CODEC_DMA_RX_0:
  36         case WSA_CODEC_DMA_RX_1:
  37                 /*
  38                  * Set limit of -3 dB on Digital Volume and 0 dB on PA Volume
  39                  * to reduce the risk of speaker damage until we have active
  40                  * speaker protection in place.
  41                  */
  42                 snd_soc_limit_volume(card, "WSA_RX0 Digital Volume", 81);
  43                 snd_soc_limit_volume(card, "WSA_RX1 Digital Volume", 81);
  44                 snd_soc_limit_volume(card, "SpkrLeft PA Volume", 17);
  45                 snd_soc_limit_volume(card, "SpkrRight PA Volume", 17);
  46                 break;
  47         case DISPLAY_PORT_RX_0:
  48                 /* DISPLAY_PORT dai ids are not contiguous */
  49                 dp_pcm_id = 0;
  50                 dp_jack = &data->dp_jack[dp_pcm_id];
  51                 break;
  52         case DISPLAY_PORT_RX_1 ... DISPLAY_PORT_RX_7:
  53                 dp_pcm_id = cpu_dai->id - DISPLAY_PORT_RX_1 + 1;
  54                 dp_jack = &data->dp_jack[dp_pcm_id];
  55                 break;
  56         default:
  57                 break;
  58         }
  59
  60         if (dp_jack)
  61                 return qcom_snd_dp_jack_setup(rtd, dp_jack, dp_pcm_id);
  62
  63         return qcom_snd_wcd_jack_setup(rtd, &data->jack, &data->jack_setup);
  64 }
  65
  66 static void sc8280xp_snd_shutdown(struct snd_pcm_substream *substream)
  67 {
  68         struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
  69         struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
  70         struct sc8280xp_snd_data *pdata = snd_soc_card_get_drvdata(rtd->card);
  71         struct sdw_stream_runtime *sruntime = pdata->sruntime[cpu_dai->id];
  72
  73         pdata->sruntime[cpu_dai->id] = NULL;
  74         sdw_release_stream(sruntime);
  75 }
  76
  77 static int sc8280xp_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
  78                                      struct snd_pcm_hw_params *params)
  79 {
  80         struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
  81         struct snd_interval *rate = hw_param_interval(params,
  82                                         SNDRV_PCM_HW_PARAM_RATE);
  83         struct snd_interval *channels = hw_param_interval(params,
  84                                         SNDRV_PCM_HW_PARAM_CHANNELS);
  85
  86         rate->min = rate->max = 48000;
  87         channels->min = 2;
  88         channels->max = 2;
  89         switch (cpu_dai->id) {
  90         case TX_CODEC_DMA_TX_0:
  91         case TX_CODEC_DMA_TX_1:
  92         case TX_CODEC_DMA_TX_2:
  93         case TX_CODEC_DMA_TX_3:
  94                 channels->min = 1;
  95                 break;
  96         default:
  97                 break;
  98         }
  99
 100
 101         return 0;
 102 }
 103
 104 static int sc8280xp_snd_hw_params(struct snd_pcm_substream *substream,
 105                                 struct snd_pcm_hw_params *params)
 106 {
 107         struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
 108         struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
 109         struct sc8280xp_snd_data *pdata = snd_soc_card_get_drvdata(rtd->card);
 110
 111         return qcom_snd_sdw_hw_params(substream, params, &pdata->sruntime[cpu_dai->id]);
 112 }
 113
 114 static int sc8280xp_snd_prepare(struct snd_pcm_substream *substream)
 115 {
 116         struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
 117         struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
 118         struct sc8280xp_snd_data *data = snd_soc_card_get_drvdata(rtd->card);
 119         struct sdw_stream_runtime *sruntime = data->sruntime[cpu_dai->id];
 120
 121         return qcom_snd_sdw_prepare(substream, sruntime,
 122                                     &data->stream_prepared[cpu_dai->id]);
 123 }
 124
 125 static int sc8280xp_snd_hw_free(struct snd_pcm_substream *substream)
 126 {
 127         struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
 128         struct sc8280xp_snd_data *data = snd_soc_card_get_drvdata(rtd->card);
 129         struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
 130         struct sdw_stream_runtime *sruntime = data->sruntime[cpu_dai->id];
 131
 132         return qcom_snd_sdw_hw_free(substream, sruntime,
 133                                     &data->stream_prepared[cpu_dai->id]);
 134 }
 135
 136 static const struct snd_soc_ops sc8280xp_be_ops = {
 137         .startup = qcom_snd_sdw_startup,
 138         .shutdown = sc8280xp_snd_shutdown,
 139         .hw_params = sc8280xp_snd_hw_params,
 140         .hw_free = sc8280xp_snd_hw_free,
 141         .prepare = sc8280xp_snd_prepare,
 142 };
 143
 144 static void sc8280xp_add_be_ops(struct snd_soc_card *card)
 145 {
 146         struct snd_soc_dai_link *link;
 147         int i;
 148
 149         for_each_card_prelinks(card, i, link) {
 150                 if (link->no_pcm == 1) {
 151                         link->init = sc8280xp_snd_init;
 152                         link->be_hw_params_fixup = sc8280xp_be_hw_params_fixup;
 153                         link->ops = &sc8280xp_be_ops;
 154                 }
 155         }
 156 }
 157
 158 static int sc8280xp_platform_probe(struct platform_device *pdev)
 159 {
 160         struct snd_soc_card *card;
 161         struct sc8280xp_snd_data *data;
 162         struct device *dev = &pdev->dev;
 163         int ret;
 164
 165         card = devm_kzalloc(dev, sizeof(*card), GFP_KERNEL);
 166         if (!card)
 167                 return -ENOMEM;
 168         card->owner = THIS_MODULE;
 169         /* Allocate the private data */
 170         data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
 171         if (!data)
 172                 return -ENOMEM;
 173
 174         card->dev = dev;
 175         dev_set_drvdata(dev, card);
 176         snd_soc_card_set_drvdata(card, data);
 177         ret = qcom_snd_parse_of(card);
 178         if (ret)
 179                 return ret;
 180
 181         card->driver_name = of_device_get_match_data(dev);
 182         sc8280xp_add_be_ops(card);
 183         return devm_snd_soc_register_card(dev, card);
 184 }
 185
 186 static const struct of_device_id snd_sc8280xp_dt_match[] = {
 187         {.compatible = "qcom,qcm6490-idp-sndcard", "qcm6490"},
 188         {.compatible = "qcom,qcs6490-rb3gen2-sndcard", "qcs6490"},
 189         {.compatible = "qcom,sc8280xp-sndcard", "sc8280xp"},
 190         {.compatible = "qcom,sm8450-sndcard", "sm8450"},
 191         {.compatible = "qcom,sm8550-sndcard", "sm8550"},
 192         {.compatible = "qcom,sm8650-sndcard", "sm8650"},
 193         {.compatible = "qcom,sm8750-sndcard", "sm8750"},
 194         {}
 195 };
 196
 197 MODULE_DEVICE_TABLE(of, snd_sc8280xp_dt_match);
 198
 199 static struct platform_driver snd_sc8280xp_driver = {
 200         .probe  = sc8280xp_platform_probe,
 201         .driver = {
 202                 .name = "snd-sc8280xp",
 203                 .of_match_table = snd_sc8280xp_dt_match,
 204         },
 205 };
 206 module_platform_driver(snd_sc8280xp_driver);
 207 MODULE_AUTHOR("Srinivas Kandagatla <srinivas.kandagatla@linaro.org");
 208 MODULE_DESCRIPTION("SC8280XP ASoC Machine Driver");
 209 MODULE_LICENSE("GPL");