sound/soc/stm/stm32_sai_sub.c

   1 /*
   2  * STM32 ALSA SoC Digital Audio Interface (SAI) driver.
   3  *
   4  * Copyright (C) 2016, STMicroelectronics - All Rights Reserved
   5  * Author(s): Olivier Moysan <olivier.moysan@st.com> for STMicroelectronics.
   6  *
   7  * License terms: GPL V2.0.
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License version 2 as published by
  11  * the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  16  * details.
  17  */
  18
  19 #include <linux/clk.h>
  20 #include <linux/clk-provider.h>
  21 #include <linux/kernel.h>
  22 #include <linux/module.h>
  23 #include <linux/of_irq.h>
  24 #include <linux/of_platform.h>
  25 #include <linux/regmap.h>
  26
  27 #include <sound/asoundef.h>
  28 #include <sound/core.h>
  29 #include <sound/dmaengine_pcm.h>
  30 #include <sound/pcm_params.h>
  31
  32 #include "stm32_sai.h"
  33
  34 #define SAI_FREE_PROTOCOL       0x0
  35 #define SAI_SPDIF_PROTOCOL      0x1
  36
  37 #define SAI_SLOT_SIZE_AUTO      0x0
  38 #define SAI_SLOT_SIZE_16        0x1
  39 #define SAI_SLOT_SIZE_32        0x2
  40
  41 #define SAI_DATASIZE_8          0x2
  42 #define SAI_DATASIZE_10         0x3
  43 #define SAI_DATASIZE_16         0x4
  44 #define SAI_DATASIZE_20         0x5
  45 #define SAI_DATASIZE_24         0x6
  46 #define SAI_DATASIZE_32         0x7
  47
  48 #define STM_SAI_FIFO_SIZE       8
  49 #define STM_SAI_DAI_NAME_SIZE   15
  50
  51 #define STM_SAI_IS_PLAYBACK(ip) ((ip)->dir == SNDRV_PCM_STREAM_PLAYBACK)
  52 #define STM_SAI_IS_CAPTURE(ip)  ((ip)->dir == SNDRV_PCM_STREAM_CAPTURE)
  53
  54 #define STM_SAI_A_ID            0x0
  55 #define STM_SAI_B_ID            0x1
  56
  57 #define STM_SAI_IS_SUB_A(x)     ((x)->id == STM_SAI_A_ID)
  58 #define STM_SAI_IS_SUB_B(x)     ((x)->id == STM_SAI_B_ID)
  59 #define STM_SAI_BLOCK_NAME(x)   (((x)->id == STM_SAI_A_ID) ? "A" : "B")
  60
  61 #define SAI_SYNC_NONE           0x0
  62 #define SAI_SYNC_INTERNAL       0x1
  63 #define SAI_SYNC_EXTERNAL       0x2
  64
  65 #define STM_SAI_PROTOCOL_IS_SPDIF(ip)   ((ip)->spdif)
  66 #define STM_SAI_HAS_SPDIF(x)    ((x)->pdata->conf->has_spdif)
  67 #define STM_SAI_HAS_EXT_SYNC(x) (!STM_SAI_IS_F4(sai->pdata))
  68
  69 #define SAI_IEC60958_BLOCK_FRAMES       192
  70 #define SAI_IEC60958_STATUS_BYTES       24
  71
  72 #define SAI_MCLK_NAME_LEN               32
  73
  74 /**
  75  * struct stm32_sai_sub_data - private data of SAI sub block (block A or B)
  76  * @pdev: device data pointer
  77  * @regmap: SAI register map pointer
  78  * @regmap_config: SAI sub block register map configuration pointer
  79  * @dma_params: dma configuration data for rx or tx channel
  80  * @cpu_dai_drv: DAI driver data pointer
  81  * @cpu_dai: DAI runtime data pointer
  82  * @substream: PCM substream data pointer
  83  * @pdata: SAI block parent data pointer
  84  * @np_sync_provider: synchronization provider node
  85  * @sai_ck: kernel clock feeding the SAI clock generator
  86  * @sai_mclk: master clock from SAI mclk provider
  87  * @phys_addr: SAI registers physical base address
  88  * @mclk_rate: SAI block master clock frequency (Hz). set at init
  89  * @id: SAI sub block id corresponding to sub-block A or B
  90  * @dir: SAI block direction (playback or capture). set at init
  91  * @master: SAI block mode flag. (true=master, false=slave) set at init
  92  * @spdif: SAI S/PDIF iec60958 mode flag. set at init
  93  * @fmt: SAI block format. relevant only for custom protocols. set at init
  94  * @sync: SAI block synchronization mode. (none, internal or external)
  95  * @synco: SAI block ext sync source (provider setting). (none, sub-block A/B)
  96  * @synci: SAI block ext sync source (client setting). (SAI sync provider index)
  97  * @fs_length: frame synchronization length. depends on protocol settings
  98  * @slots: rx or tx slot number
  99  * @slot_width: rx or tx slot width in bits
 100  * @slot_mask: rx or tx active slots mask. set at init or at runtime
 101  * @data_size: PCM data width. corresponds to PCM substream width.
 102  * @spdif_frm_cnt: S/PDIF playback frame counter
 103  * @iec958: iec958 data
 104  * @ctrl_lock: control lock
 105  */
 106 struct stm32_sai_sub_data {
 107         struct platform_device *pdev;
 108         struct regmap *regmap;
 109         const struct regmap_config *regmap_config;
 110         struct snd_dmaengine_dai_dma_data dma_params;
 111         struct snd_soc_dai_driver *cpu_dai_drv;
 112         struct snd_soc_dai *cpu_dai;
 113         struct snd_pcm_substream *substream;
 114         struct stm32_sai_data *pdata;
 115         struct device_node *np_sync_provider;
 116         struct clk *sai_ck;
 117         struct clk *sai_mclk;
 118         dma_addr_t phys_addr;
 119         unsigned int mclk_rate;
 120         unsigned int id;
 121         int dir;
 122         bool master;
 123         bool spdif;
 124         int fmt;
 125         int sync;
 126         int synco;
 127         int synci;
 128         int fs_length;
 129         int slots;
 130         int slot_width;
 131         int slot_mask;
 132         int data_size;
 133         unsigned int spdif_frm_cnt;
 134         struct snd_aes_iec958 iec958;
 135         struct mutex ctrl_lock; /* protect resources accessed by controls */
 136 };
 137
 138 enum stm32_sai_fifo_th {
 139         STM_SAI_FIFO_TH_EMPTY,
 140         STM_SAI_FIFO_TH_QUARTER,
 141         STM_SAI_FIFO_TH_HALF,
 142         STM_SAI_FIFO_TH_3_QUARTER,
 143         STM_SAI_FIFO_TH_FULL,
 144 };
 145
 146 static bool stm32_sai_sub_readable_reg(struct device *dev, unsigned int reg)
 147 {
 148         switch (reg) {
 149         case STM_SAI_CR1_REGX:
 150         case STM_SAI_CR2_REGX:
 151         case STM_SAI_FRCR_REGX:
 152         case STM_SAI_SLOTR_REGX:
 153         case STM_SAI_IMR_REGX:
 154         case STM_SAI_SR_REGX:
 155         case STM_SAI_CLRFR_REGX:
 156         case STM_SAI_DR_REGX:
 157         case STM_SAI_PDMCR_REGX:
 158         case STM_SAI_PDMLY_REGX:
 159                 return true;
 160         default:
 161                 return false;
 162         }
 163 }
 164
 165 static bool stm32_sai_sub_volatile_reg(struct device *dev, unsigned int reg)
 166 {
 167         switch (reg) {
 168         case STM_SAI_DR_REGX:
 169                 return true;
 170         default:
 171                 return false;
 172         }
 173 }
 174
 175 static bool stm32_sai_sub_writeable_reg(struct device *dev, unsigned int reg)
 176 {
 177         switch (reg) {
 178         case STM_SAI_CR1_REGX:
 179         case STM_SAI_CR2_REGX:
 180         case STM_SAI_FRCR_REGX:
 181         case STM_SAI_SLOTR_REGX:
 182         case STM_SAI_IMR_REGX:
 183         case STM_SAI_SR_REGX:
 184         case STM_SAI_CLRFR_REGX:
 185         case STM_SAI_DR_REGX:
 186         case STM_SAI_PDMCR_REGX:
 187         case STM_SAI_PDMLY_REGX:
 188                 return true;
 189         default:
 190                 return false;
 191         }
 192 }
 193
 194 static const struct regmap_config stm32_sai_sub_regmap_config_f4 = {
 195         .reg_bits = 32,
 196         .reg_stride = 4,
 197         .val_bits = 32,
 198         .max_register = STM_SAI_DR_REGX,
 199         .readable_reg = stm32_sai_sub_readable_reg,
 200         .volatile_reg = stm32_sai_sub_volatile_reg,
 201         .writeable_reg = stm32_sai_sub_writeable_reg,
 202         .fast_io = true,
 203 };
 204
 205 static const struct regmap_config stm32_sai_sub_regmap_config_h7 = {
 206         .reg_bits = 32,
 207         .reg_stride = 4,
 208         .val_bits = 32,
 209         .max_register = STM_SAI_PDMLY_REGX,
 210         .readable_reg = stm32_sai_sub_readable_reg,
 211         .volatile_reg = stm32_sai_sub_volatile_reg,
 212         .writeable_reg = stm32_sai_sub_writeable_reg,
 213         .fast_io = true,
 214 };
 215
 216 static int snd_pcm_iec958_info(struct snd_kcontrol *kcontrol,
 217                                struct snd_ctl_elem_info *uinfo)
 218 {
 219         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
 220         uinfo->count = 1;
 221
 222         return 0;
 223 }
 224
 225 static int snd_pcm_iec958_get(struct snd_kcontrol *kcontrol,
 226                               struct snd_ctl_elem_value *uctl)
 227 {
 228         struct stm32_sai_sub_data *sai = snd_kcontrol_chip(kcontrol);
 229
 230         mutex_lock(&sai->ctrl_lock);
 231         memcpy(uctl->value.iec958.status, sai->iec958.status, 4);
 232         mutex_unlock(&sai->ctrl_lock);
 233
 234         return 0;
 235 }
 236
 237 static int snd_pcm_iec958_put(struct snd_kcontrol *kcontrol,
 238                               struct snd_ctl_elem_value *uctl)
 239 {
 240         struct stm32_sai_sub_data *sai = snd_kcontrol_chip(kcontrol);
 241
 242         mutex_lock(&sai->ctrl_lock);
 243         memcpy(sai->iec958.status, uctl->value.iec958.status, 4);
 244         mutex_unlock(&sai->ctrl_lock);
 245
 246         return 0;
 247 }
 248
 249 static const struct snd_kcontrol_new iec958_ctls = {
 250         .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
 251                         SNDRV_CTL_ELEM_ACCESS_VOLATILE),
 252         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
 253         .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
 254         .info = snd_pcm_iec958_info,
 255         .get = snd_pcm_iec958_get,
 256         .put = snd_pcm_iec958_put,
 257 };
 258
 259 struct stm32_sai_mclk_data {
 260         struct clk_hw hw;
 261         unsigned long freq;
 262         struct stm32_sai_sub_data *sai_data;
 263 };
 264
 265 #define to_mclk_data(_hw) container_of(_hw, struct stm32_sai_mclk_data, hw)
 266 #define STM32_SAI_MAX_CLKS 1
 267
 268 static int stm32_sai_get_clk_div(struct stm32_sai_sub_data *sai,
 269                                  unsigned long input_rate,
 270                                  unsigned long output_rate)
 271 {
 272         int version = sai->pdata->conf->version;
 273         int div;
 274
 275         div = DIV_ROUND_CLOSEST(input_rate, output_rate);
 276         if (div > SAI_XCR1_MCKDIV_MAX(version)) {
 277                 dev_err(&sai->pdev->dev, "Divider %d out of range\n", div);
 278                 return -EINVAL;
 279         }
 280         dev_dbg(&sai->pdev->dev, "SAI divider %d\n", div);
 281
 282         if (input_rate % div)
 283                 dev_dbg(&sai->pdev->dev,
 284                         "Rate not accurate. requested (%ld), actual (%ld)\n",
 285                         output_rate, input_rate / div);
 286
 287         return div;
 288 }
 289
 290 static int stm32_sai_set_clk_div(struct stm32_sai_sub_data *sai,
 291                                  unsigned int div)
 292 {
 293         int version = sai->pdata->conf->version;
 294         int ret, cr1, mask;
 295
 296         if (div > SAI_XCR1_MCKDIV_MAX(version)) {
 297                 dev_err(&sai->pdev->dev, "Divider %d out of range\n", div);
 298                 return -EINVAL;
 299         }
 300
 301         mask = SAI_XCR1_MCKDIV_MASK(SAI_XCR1_MCKDIV_WIDTH(version));
 302         cr1 = SAI_XCR1_MCKDIV_SET(div);
 303         ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, mask, cr1);
 304         if (ret < 0)
 305                 dev_err(&sai->pdev->dev, "Failed to update CR1 register\n");
 306
 307         return ret;
 308 }
 309
 310 static long stm32_sai_mclk_round_rate(struct clk_hw *hw, unsigned long rate,
 311                                       unsigned long *prate)
 312 {
 313         struct stm32_sai_mclk_data *mclk = to_mclk_data(hw);
 314         struct stm32_sai_sub_data *sai = mclk->sai_data;
 315         int div;
 316
 317         div = stm32_sai_get_clk_div(sai, *prate, rate);
 318         if (div < 0)
 319                 return div;
 320
 321         mclk->freq = *prate / div;
 322
 323         return mclk->freq;
 324 }
 325
 326 static unsigned long stm32_sai_mclk_recalc_rate(struct clk_hw *hw,
 327                                                 unsigned long parent_rate)
 328 {
 329         struct stm32_sai_mclk_data *mclk = to_mclk_data(hw);
 330
 331         return mclk->freq;
 332 }
 333
 334 static int stm32_sai_mclk_set_rate(struct clk_hw *hw, unsigned long rate,
 335                                    unsigned long parent_rate)
 336 {
 337         struct stm32_sai_mclk_data *mclk = to_mclk_data(hw);
 338         struct stm32_sai_sub_data *sai = mclk->sai_data;
 339         int div, ret;
 340
 341         div = stm32_sai_get_clk_div(sai, parent_rate, rate);
 342         if (div < 0)
 343                 return div;
 344
 345         ret = stm32_sai_set_clk_div(sai, div);
 346         if (ret)
 347                 return ret;
 348
 349         mclk->freq = rate;
 350
 351         return 0;
 352 }
 353
 354 static int stm32_sai_mclk_enable(struct clk_hw *hw)
 355 {
 356         struct stm32_sai_mclk_data *mclk = to_mclk_data(hw);
 357         struct stm32_sai_sub_data *sai = mclk->sai_data;
 358
 359         dev_dbg(&sai->pdev->dev, "Enable master clock\n");
 360
 361         return regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
 362                                   SAI_XCR1_MCKEN, SAI_XCR1_MCKEN);
 363 }
 364
 365 static void stm32_sai_mclk_disable(struct clk_hw *hw)
 366 {
 367         struct stm32_sai_mclk_data *mclk = to_mclk_data(hw);
 368         struct stm32_sai_sub_data *sai = mclk->sai_data;
 369
 370         dev_dbg(&sai->pdev->dev, "Disable master clock\n");
 371
 372         regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, SAI_XCR1_MCKEN, 0);
 373 }
 374
 375 static const struct clk_ops mclk_ops = {
 376         .enable = stm32_sai_mclk_enable,
 377         .disable = stm32_sai_mclk_disable,
 378         .recalc_rate = stm32_sai_mclk_recalc_rate,
 379         .round_rate = stm32_sai_mclk_round_rate,
 380         .set_rate = stm32_sai_mclk_set_rate,
 381 };
 382
 383 static int stm32_sai_add_mclk_provider(struct stm32_sai_sub_data *sai)
 384 {
 385         struct clk_hw *hw;
 386         struct stm32_sai_mclk_data *mclk;
 387         struct device *dev = &sai->pdev->dev;
 388         const char *pname = __clk_get_name(sai->sai_ck);
 389         char *mclk_name, *p, *s = (char *)pname;
 390         int ret, i = 0;
 391
 392         mclk = devm_kzalloc(dev, sizeof(*mclk), GFP_KERNEL);
 393         if (!mclk)
 394                 return -ENOMEM;
 395
 396         mclk_name = devm_kcalloc(dev, sizeof(char),
 397                                  SAI_MCLK_NAME_LEN, GFP_KERNEL);
 398         if (!mclk_name)
 399                 return -ENOMEM;
 400
 401         /*
 402          * Forge mclk clock name from parent clock name and suffix.
 403          * String after "_" char is stripped in parent name.
 404          */
 405         p = mclk_name;
 406         while (*s && *s != '_' && (i < (SAI_MCLK_NAME_LEN - 7))) {
 407                 *p++ = *s++;
 408                 i++;
 409         }
 410         STM_SAI_IS_SUB_A(sai) ? strcat(p, "a_mclk") : strcat(p, "b_mclk");
 411
 412         mclk->hw.init = CLK_HW_INIT(mclk_name, pname, &mclk_ops, 0);
 413         mclk->sai_data = sai;
 414         hw = &mclk->hw;
 415
 416         dev_dbg(dev, "Register master clock %s\n", mclk_name);
 417         ret = devm_clk_hw_register(&sai->pdev->dev, hw);
 418         if (ret) {
 419                 dev_err(dev, "mclk register returned %d\n", ret);
 420                 return ret;
 421         }
 422         sai->sai_mclk = hw->clk;
 423
 424         /* register mclk provider */
 425         return devm_of_clk_add_hw_provider(dev, of_clk_hw_simple_get, hw);
 426 }
 427
 428 static irqreturn_t stm32_sai_isr(int irq, void *devid)
 429 {
 430         struct stm32_sai_sub_data *sai = (struct stm32_sai_sub_data *)devid;
 431         struct platform_device *pdev = sai->pdev;
 432         unsigned int sr, imr, flags;
 433         snd_pcm_state_t status = SNDRV_PCM_STATE_RUNNING;
 434
 435         regmap_read(sai->regmap, STM_SAI_IMR_REGX, &imr);
 436         regmap_read(sai->regmap, STM_SAI_SR_REGX, &sr);
 437
 438         flags = sr & imr;
 439         if (!flags)
 440                 return IRQ_NONE;
 441
 442         regmap_update_bits(sai->regmap, STM_SAI_CLRFR_REGX, SAI_XCLRFR_MASK,
 443                            SAI_XCLRFR_MASK);
 444
 445         if (!sai->substream) {
 446                 dev_err(&pdev->dev, "Device stopped. Spurious IRQ 0x%x\n", sr);
 447                 return IRQ_NONE;
 448         }
 449
 450         if (flags & SAI_XIMR_OVRUDRIE) {
 451                 dev_err(&pdev->dev, "IRQ %s\n",
 452                         STM_SAI_IS_PLAYBACK(sai) ? "underrun" : "overrun");
 453                 status = SNDRV_PCM_STATE_XRUN;
 454         }
 455
 456         if (flags & SAI_XIMR_MUTEDETIE)
 457                 dev_dbg(&pdev->dev, "IRQ mute detected\n");
 458
 459         if (flags & SAI_XIMR_WCKCFGIE) {
 460                 dev_err(&pdev->dev, "IRQ wrong clock configuration\n");
 461                 status = SNDRV_PCM_STATE_DISCONNECTED;
 462         }
 463
 464         if (flags & SAI_XIMR_CNRDYIE)
 465                 dev_err(&pdev->dev, "IRQ Codec not ready\n");
 466
 467         if (flags & SAI_XIMR_AFSDETIE) {
 468                 dev_err(&pdev->dev, "IRQ Anticipated frame synchro\n");
 469                 status = SNDRV_PCM_STATE_XRUN;
 470         }
 471
 472         if (flags & SAI_XIMR_LFSDETIE) {
 473                 dev_err(&pdev->dev, "IRQ Late frame synchro\n");
 474                 status = SNDRV_PCM_STATE_XRUN;
 475         }
 476
 477         if (status != SNDRV_PCM_STATE_RUNNING)
 478                 snd_pcm_stop_xrun(sai->substream);
 479
 480         return IRQ_HANDLED;
 481 }
 482
 483 static int stm32_sai_set_sysclk(struct snd_soc_dai *cpu_dai,
 484                                 int clk_id, unsigned int freq, int dir)
 485 {
 486         struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
 487         int ret;
 488
 489         if (dir == SND_SOC_CLOCK_OUT) {
 490                 ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
 491                                          SAI_XCR1_NODIV,
 492                                          (unsigned int)~SAI_XCR1_NODIV);
 493                 if (ret < 0)
 494                         return ret;
 495
 496                 dev_dbg(cpu_dai->dev, "SAI MCLK frequency is %uHz\n", freq);
 497                 sai->mclk_rate = freq;
 498
 499                 if (sai->sai_mclk) {
 500                         ret = clk_set_rate_exclusive(sai->sai_mclk,
 501                                                      sai->mclk_rate);
 502                         if (ret) {
 503                                 dev_err(cpu_dai->dev,
 504                                         "Could not set mclk rate\n");
 505                                 return ret;
 506                         }
 507                 }
 508         }
 509
 510         return 0;
 511 }
 512
 513 static int stm32_sai_set_dai_tdm_slot(struct snd_soc_dai *cpu_dai, u32 tx_mask,
 514                                       u32 rx_mask, int slots, int slot_width)
 515 {
 516         struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
 517         int slotr, slotr_mask, slot_size;
 518
 519         if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
 520                 dev_warn(cpu_dai->dev, "Slot setting relevant only for TDM\n");
 521                 return 0;
 522         }
 523
 524         dev_dbg(cpu_dai->dev, "Masks tx/rx:%#x/%#x, slots:%d, width:%d\n",
 525                 tx_mask, rx_mask, slots, slot_width);
 526
 527         switch (slot_width) {
 528         case 16:
 529                 slot_size = SAI_SLOT_SIZE_16;
 530                 break;
 531         case 32:
 532                 slot_size = SAI_SLOT_SIZE_32;
 533                 break;
 534         default:
 535                 slot_size = SAI_SLOT_SIZE_AUTO;
 536                 break;
 537         }
 538
 539         slotr = SAI_XSLOTR_SLOTSZ_SET(slot_size) |
 540                 SAI_XSLOTR_NBSLOT_SET(slots - 1);
 541         slotr_mask = SAI_XSLOTR_SLOTSZ_MASK | SAI_XSLOTR_NBSLOT_MASK;
 542
 543         /* tx/rx mask set in machine init, if slot number defined in DT */
 544         if (STM_SAI_IS_PLAYBACK(sai)) {
 545                 sai->slot_mask = tx_mask;
 546                 slotr |= SAI_XSLOTR_SLOTEN_SET(tx_mask);
 547         }
 548
 549         if (STM_SAI_IS_CAPTURE(sai)) {
 550                 sai->slot_mask = rx_mask;
 551                 slotr |= SAI_XSLOTR_SLOTEN_SET(rx_mask);
 552         }
 553
 554         slotr_mask |= SAI_XSLOTR_SLOTEN_MASK;
 555
 556         regmap_update_bits(sai->regmap, STM_SAI_SLOTR_REGX, slotr_mask, slotr);
 557
 558         sai->slot_width = slot_width;
 559         sai->slots = slots;
 560
 561         return 0;
 562 }
 563
 564 static int stm32_sai_set_dai_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt)
 565 {
 566         struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
 567         int cr1, frcr = 0;
 568         int cr1_mask, frcr_mask = 0;
 569         int ret;
 570
 571         dev_dbg(cpu_dai->dev, "fmt %x\n", fmt);
 572
 573         /* Do not generate master by default */
 574         cr1 = SAI_XCR1_NODIV;
 575         cr1_mask = SAI_XCR1_NODIV;
 576
 577         cr1_mask |= SAI_XCR1_PRTCFG_MASK;
 578         if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
 579                 cr1 |= SAI_XCR1_PRTCFG_SET(SAI_SPDIF_PROTOCOL);
 580                 goto conf_update;
 581         }
 582
 583         cr1 |= SAI_XCR1_PRTCFG_SET(SAI_FREE_PROTOCOL);
 584
 585         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 586         /* SCK active high for all protocols */
 587         case SND_SOC_DAIFMT_I2S:
 588                 cr1 |= SAI_XCR1_CKSTR;
 589                 frcr |= SAI_XFRCR_FSOFF | SAI_XFRCR_FSDEF;
 590                 break;
 591         /* Left justified */
 592         case SND_SOC_DAIFMT_MSB:
 593                 frcr |= SAI_XFRCR_FSPOL | SAI_XFRCR_FSDEF;
 594                 break;
 595         /* Right justified */
 596         case SND_SOC_DAIFMT_LSB:
 597                 frcr |= SAI_XFRCR_FSPOL | SAI_XFRCR_FSDEF;
 598                 break;
 599         case SND_SOC_DAIFMT_DSP_A:
 600                 frcr |= SAI_XFRCR_FSPOL | SAI_XFRCR_FSOFF;
 601                 break;
 602         case SND_SOC_DAIFMT_DSP_B:
 603                 frcr |= SAI_XFRCR_FSPOL;
 604                 break;
 605         default:
 606                 dev_err(cpu_dai->dev, "Unsupported protocol %#x\n",
 607                         fmt & SND_SOC_DAIFMT_FORMAT_MASK);
 608                 return -EINVAL;
 609         }
 610
 611         cr1_mask |= SAI_XCR1_CKSTR;
 612         frcr_mask |= SAI_XFRCR_FSPOL | SAI_XFRCR_FSOFF |
 613                      SAI_XFRCR_FSDEF;
 614
 615         /* DAI clock strobing. Invert setting previously set */
 616         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 617         case SND_SOC_DAIFMT_NB_NF:
 618                 break;
 619         case SND_SOC_DAIFMT_IB_NF:
 620                 cr1 ^= SAI_XCR1_CKSTR;
 621                 break;
 622         case SND_SOC_DAIFMT_NB_IF:
 623                 frcr ^= SAI_XFRCR_FSPOL;
 624                 break;
 625         case SND_SOC_DAIFMT_IB_IF:
 626                 /* Invert fs & sck */
 627                 cr1 ^= SAI_XCR1_CKSTR;
 628                 frcr ^= SAI_XFRCR_FSPOL;
 629                 break;
 630         default:
 631                 dev_err(cpu_dai->dev, "Unsupported strobing %#x\n",
 632                         fmt & SND_SOC_DAIFMT_INV_MASK);
 633                 return -EINVAL;
 634         }
 635         cr1_mask |= SAI_XCR1_CKSTR;
 636         frcr_mask |= SAI_XFRCR_FSPOL;
 637
 638         regmap_update_bits(sai->regmap, STM_SAI_FRCR_REGX, frcr_mask, frcr);
 639
 640         /* DAI clock master masks */
 641         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 642         case SND_SOC_DAIFMT_CBM_CFM:
 643                 /* codec is master */
 644                 cr1 |= SAI_XCR1_SLAVE;
 645                 sai->master = false;
 646                 break;
 647         case SND_SOC_DAIFMT_CBS_CFS:
 648                 sai->master = true;
 649                 break;
 650         default:
 651                 dev_err(cpu_dai->dev, "Unsupported mode %#x\n",
 652                         fmt & SND_SOC_DAIFMT_MASTER_MASK);
 653                 return -EINVAL;
 654         }
 655
 656         /* Set slave mode if sub-block is synchronized with another SAI */
 657         if (sai->sync) {
 658                 dev_dbg(cpu_dai->dev, "Synchronized SAI configured as slave\n");
 659                 cr1 |= SAI_XCR1_SLAVE;
 660                 sai->master = false;
 661         }
 662
 663         cr1_mask |= SAI_XCR1_SLAVE;
 664
 665 conf_update:
 666         ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, cr1_mask, cr1);
 667         if (ret < 0) {
 668                 dev_err(cpu_dai->dev, "Failed to update CR1 register\n");
 669                 return ret;
 670         }
 671
 672         sai->fmt = fmt;
 673
 674         return 0;
 675 }
 676
 677 static int stm32_sai_startup(struct snd_pcm_substream *substream,
 678                              struct snd_soc_dai *cpu_dai)
 679 {
 680         struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
 681         int imr, cr2, ret;
 682
 683         sai->substream = substream;
 684
 685         if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
 686                 snd_pcm_hw_constraint_mask64(substream->runtime,
 687                                              SNDRV_PCM_HW_PARAM_FORMAT,
 688                                              SNDRV_PCM_FMTBIT_S32_LE);
 689                 snd_pcm_hw_constraint_single(substream->runtime,
 690                                              SNDRV_PCM_HW_PARAM_CHANNELS, 2);
 691         }
 692
 693         ret = clk_prepare_enable(sai->sai_ck);
 694         if (ret < 0) {
 695                 dev_err(cpu_dai->dev, "Failed to enable clock: %d\n", ret);
 696                 return ret;
 697         }
 698
 699         /* Enable ITs */
 700
 701         regmap_update_bits(sai->regmap, STM_SAI_CLRFR_REGX,
 702                            SAI_XCLRFR_MASK, SAI_XCLRFR_MASK);
 703
 704         imr = SAI_XIMR_OVRUDRIE;
 705         if (STM_SAI_IS_CAPTURE(sai)) {
 706                 regmap_read(sai->regmap, STM_SAI_CR2_REGX, &cr2);
 707                 if (cr2 & SAI_XCR2_MUTECNT_MASK)
 708                         imr |= SAI_XIMR_MUTEDETIE;
 709         }
 710
 711         if (sai->master)
 712                 imr |= SAI_XIMR_WCKCFGIE;
 713         else
 714                 imr |= SAI_XIMR_AFSDETIE | SAI_XIMR_LFSDETIE;
 715
 716         regmap_update_bits(sai->regmap, STM_SAI_IMR_REGX,
 717                            SAI_XIMR_MASK, imr);
 718
 719         return 0;
 720 }
 721
 722 static int stm32_sai_set_config(struct snd_soc_dai *cpu_dai,
 723                                 struct snd_pcm_substream *substream,
 724                                 struct snd_pcm_hw_params *params)
 725 {
 726         struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
 727         int cr1, cr1_mask, ret;
 728
 729         /*
 730          * DMA bursts increment is set to 4 words.
 731          * SAI fifo threshold is set to half fifo, to keep enough space
 732          * for DMA incoming bursts.
 733          */
 734         regmap_update_bits(sai->regmap, STM_SAI_CR2_REGX,
 735                            SAI_XCR2_FFLUSH | SAI_XCR2_FTH_MASK,
 736                            SAI_XCR2_FFLUSH |
 737                            SAI_XCR2_FTH_SET(STM_SAI_FIFO_TH_HALF));
 738
 739         /* DS bits in CR1 not set for SPDIF (size forced to 24 bits).*/
 740         if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
 741                 sai->spdif_frm_cnt = 0;
 742                 return 0;
 743         }
 744
 745         /* Mode, data format and channel config */
 746         cr1_mask = SAI_XCR1_DS_MASK;
 747         switch (params_format(params)) {
 748         case SNDRV_PCM_FORMAT_S8:
 749                 cr1 = SAI_XCR1_DS_SET(SAI_DATASIZE_8);
 750                 break;
 751         case SNDRV_PCM_FORMAT_S16_LE:
 752                 cr1 = SAI_XCR1_DS_SET(SAI_DATASIZE_16);
 753                 break;
 754         case SNDRV_PCM_FORMAT_S32_LE:
 755                 cr1 = SAI_XCR1_DS_SET(SAI_DATASIZE_32);
 756                 break;
 757         default:
 758                 dev_err(cpu_dai->dev, "Data format not supported");
 759                 return -EINVAL;
 760         }
 761
 762         cr1_mask |= SAI_XCR1_MONO;
 763         if ((sai->slots == 2) && (params_channels(params) == 1))
 764                 cr1 |= SAI_XCR1_MONO;
 765
 766         ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, cr1_mask, cr1);
 767         if (ret < 0) {
 768                 dev_err(cpu_dai->dev, "Failed to update CR1 register\n");
 769                 return ret;
 770         }
 771
 772         return 0;
 773 }
 774
 775 static int stm32_sai_set_slots(struct snd_soc_dai *cpu_dai)
 776 {
 777         struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
 778         int slotr, slot_sz;
 779
 780         regmap_read(sai->regmap, STM_SAI_SLOTR_REGX, &slotr);
 781
 782         /*
 783          * If SLOTSZ is set to auto in SLOTR, align slot width on data size
 784          * By default slot width = data size, if not forced from DT
 785          */
 786         slot_sz = slotr & SAI_XSLOTR_SLOTSZ_MASK;
 787         if (slot_sz == SAI_XSLOTR_SLOTSZ_SET(SAI_SLOT_SIZE_AUTO))
 788                 sai->slot_width = sai->data_size;
 789
 790         if (sai->slot_width < sai->data_size) {
 791                 dev_err(cpu_dai->dev,
 792                         "Data size %d larger than slot width\n",
 793                         sai->data_size);
 794                 return -EINVAL;
 795         }
 796
 797         /* Slot number is set to 2, if not specified in DT */
 798         if (!sai->slots)
 799                 sai->slots = 2;
 800
 801         /* The number of slots in the audio frame is equal to NBSLOT[3:0] + 1*/
 802         regmap_update_bits(sai->regmap, STM_SAI_SLOTR_REGX,
 803                            SAI_XSLOTR_NBSLOT_MASK,
 804                            SAI_XSLOTR_NBSLOT_SET((sai->slots - 1)));
 805
 806         /* Set default slots mask if not already set from DT */
 807         if (!(slotr & SAI_XSLOTR_SLOTEN_MASK)) {
 808                 sai->slot_mask = (1 << sai->slots) - 1;
 809                 regmap_update_bits(sai->regmap,
 810                                    STM_SAI_SLOTR_REGX, SAI_XSLOTR_SLOTEN_MASK,
 811                                    SAI_XSLOTR_SLOTEN_SET(sai->slot_mask));
 812         }
 813
 814         dev_dbg(cpu_dai->dev, "Slots %d, slot width %d\n",
 815                 sai->slots, sai->slot_width);
 816
 817         return 0;
 818 }
 819
 820 static void stm32_sai_set_frame(struct snd_soc_dai *cpu_dai)
 821 {
 822         struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
 823         int fs_active, offset, format;
 824         int frcr, frcr_mask;
 825
 826         format = sai->fmt & SND_SOC_DAIFMT_FORMAT_MASK;
 827         sai->fs_length = sai->slot_width * sai->slots;
 828
 829         fs_active = sai->fs_length / 2;
 830         if ((format == SND_SOC_DAIFMT_DSP_A) ||
 831             (format == SND_SOC_DAIFMT_DSP_B))
 832                 fs_active = 1;
 833
 834         frcr = SAI_XFRCR_FRL_SET((sai->fs_length - 1));
 835         frcr |= SAI_XFRCR_FSALL_SET((fs_active - 1));
 836         frcr_mask = SAI_XFRCR_FRL_MASK | SAI_XFRCR_FSALL_MASK;
 837
 838         dev_dbg(cpu_dai->dev, "Frame length %d, frame active %d\n",
 839                 sai->fs_length, fs_active);
 840
 841         regmap_update_bits(sai->regmap, STM_SAI_FRCR_REGX, frcr_mask, frcr);
 842
 843         if ((sai->fmt & SND_SOC_DAIFMT_FORMAT_MASK) == SND_SOC_DAIFMT_LSB) {
 844                 offset = sai->slot_width - sai->data_size;
 845
 846                 regmap_update_bits(sai->regmap, STM_SAI_SLOTR_REGX,
 847                                    SAI_XSLOTR_FBOFF_MASK,
 848                                    SAI_XSLOTR_FBOFF_SET(offset));
 849         }
 850 }
 851
 852 static void stm32_sai_init_iec958_status(struct stm32_sai_sub_data *sai)
 853 {
 854         unsigned char *cs = sai->iec958.status;
 855
 856         cs[0] = IEC958_AES0_CON_NOT_COPYRIGHT | IEC958_AES0_CON_EMPHASIS_NONE;
 857         cs[1] = IEC958_AES1_CON_GENERAL;
 858         cs[2] = IEC958_AES2_CON_SOURCE_UNSPEC | IEC958_AES2_CON_CHANNEL_UNSPEC;
 859         cs[3] = IEC958_AES3_CON_CLOCK_1000PPM | IEC958_AES3_CON_FS_NOTID;
 860 }
 861
 862 static void stm32_sai_set_iec958_status(struct stm32_sai_sub_data *sai,
 863                                         struct snd_pcm_runtime *runtime)
 864 {
 865         if (!runtime)
 866                 return;
 867
 868         /* Force the sample rate according to runtime rate */
 869         mutex_lock(&sai->ctrl_lock);
 870         switch (runtime->rate) {
 871         case 22050:
 872                 sai->iec958.status[3] = IEC958_AES3_CON_FS_22050;
 873                 break;
 874         case 44100:
 875                 sai->iec958.status[3] = IEC958_AES3_CON_FS_44100;
 876                 break;
 877         case 88200:
 878                 sai->iec958.status[3] = IEC958_AES3_CON_FS_88200;
 879                 break;
 880         case 176400:
 881                 sai->iec958.status[3] = IEC958_AES3_CON_FS_176400;
 882                 break;
 883         case 24000:
 884                 sai->iec958.status[3] = IEC958_AES3_CON_FS_24000;
 885                 break;
 886         case 48000:
 887                 sai->iec958.status[3] = IEC958_AES3_CON_FS_48000;
 888                 break;
 889         case 96000:
 890                 sai->iec958.status[3] = IEC958_AES3_CON_FS_96000;
 891                 break;
 892         case 192000:
 893                 sai->iec958.status[3] = IEC958_AES3_CON_FS_192000;
 894                 break;
 895         case 32000:
 896                 sai->iec958.status[3] = IEC958_AES3_CON_FS_32000;
 897                 break;
 898         default:
 899                 sai->iec958.status[3] = IEC958_AES3_CON_FS_NOTID;
 900                 break;
 901         }
 902         mutex_unlock(&sai->ctrl_lock);
 903 }
 904
 905 static int stm32_sai_configure_clock(struct snd_soc_dai *cpu_dai,
 906                                      struct snd_pcm_hw_params *params)
 907 {
 908         struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
 909         int div = 0;
 910         int sai_clk_rate, mclk_ratio, den;
 911         unsigned int rate = params_rate(params);
 912
 913         if (!(rate % 11025))
 914                 clk_set_parent(sai->sai_ck, sai->pdata->clk_x11k);
 915         else
 916                 clk_set_parent(sai->sai_ck, sai->pdata->clk_x8k);
 917         sai_clk_rate = clk_get_rate(sai->sai_ck);
 918
 919         if (STM_SAI_IS_F4(sai->pdata)) {
 920                 /* mclk on (NODIV=0)
 921                  *   mclk_rate = 256 * fs
 922                  *   MCKDIV = 0 if sai_ck < 3/2 * mclk_rate
 923                  *   MCKDIV = sai_ck / (2 * mclk_rate) otherwise
 924                  * mclk off (NODIV=1)
 925                  *   MCKDIV ignored. sck = sai_ck
 926                  */
 927                 if (!sai->mclk_rate)
 928                         return 0;
 929
 930                 if (2 * sai_clk_rate >= 3 * sai->mclk_rate) {
 931                         div = stm32_sai_get_clk_div(sai, sai_clk_rate,
 932                                                     2 * sai->mclk_rate);
 933                         if (div < 0)
 934                                 return div;
 935                 }
 936         } else {
 937                 /*
 938                  * TDM mode :
 939                  *   mclk on
 940                  *      MCKDIV = sai_ck / (ws x 256)    (NOMCK=0. OSR=0)
 941                  *      MCKDIV = sai_ck / (ws x 512)    (NOMCK=0. OSR=1)
 942                  *   mclk off
 943                  *      MCKDIV = sai_ck / (frl x ws)    (NOMCK=1)
 944                  * Note: NOMCK/NODIV correspond to same bit.
 945                  */
 946                 if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
 947                         div = stm32_sai_get_clk_div(sai, sai_clk_rate,
 948                                                     rate * 128);
 949                         if (div < 0)
 950                                 return div;
 951                 } else {
 952                         if (sai->mclk_rate) {
 953                                 mclk_ratio = sai->mclk_rate / rate;
 954                                 if ((mclk_ratio != 512) &&
 955                                     (mclk_ratio != 256)) {
 956                                         dev_err(cpu_dai->dev,
 957                                                 "Wrong mclk ratio %d\n",
 958                                                 mclk_ratio);
 959                                         return -EINVAL;
 960                                 }
 961                                 div = stm32_sai_get_clk_div(sai, sai_clk_rate,
 962                                                             sai->mclk_rate);
 963                                 if (div < 0)
 964                                         return div;
 965                         } else {
 966                                 /* mclk-fs not set, master clock not active */
 967                                 den = sai->fs_length * params_rate(params);
 968                                 div = stm32_sai_get_clk_div(sai, sai_clk_rate,
 969                                                             den);
 970                                 if (div < 0)
 971                                         return div;
 972                         }
 973                 }
 974         }
 975
 976         return stm32_sai_set_clk_div(sai, div);
 977 }
 978
 979 static int stm32_sai_hw_params(struct snd_pcm_substream *substream,
 980                                struct snd_pcm_hw_params *params,
 981                                struct snd_soc_dai *cpu_dai)
 982 {
 983         struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
 984         int ret;
 985
 986         sai->data_size = params_width(params);
 987
 988         if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
 989                 /* Rate not already set in runtime structure */
 990                 substream->runtime->rate = params_rate(params);
 991                 stm32_sai_set_iec958_status(sai, substream->runtime);
 992         } else {
 993                 ret = stm32_sai_set_slots(cpu_dai);
 994                 if (ret < 0)
 995                         return ret;
 996                 stm32_sai_set_frame(cpu_dai);
 997         }
 998
 999         ret = stm32_sai_set_config(cpu_dai, substream, params);
1000         if (ret)
1001                 return ret;
1002
1003         if (sai->master)
1004                 ret = stm32_sai_configure_clock(cpu_dai, params);
1005
1006         return ret;
1007 }
1008
1009 static int stm32_sai_trigger(struct snd_pcm_substream *substream, int cmd,
1010                              struct snd_soc_dai *cpu_dai)
1011 {
1012         struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
1013         int ret;
1014
1015         switch (cmd) {
1016         case SNDRV_PCM_TRIGGER_START:
1017         case SNDRV_PCM_TRIGGER_RESUME:
1018         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1019                 dev_dbg(cpu_dai->dev, "Enable DMA and SAI\n");
1020
1021                 regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
1022                                    SAI_XCR1_DMAEN, SAI_XCR1_DMAEN);
1023
1024                 /* Enable SAI */
1025                 ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
1026                                          SAI_XCR1_SAIEN, SAI_XCR1_SAIEN);
1027                 if (ret < 0)
1028                         dev_err(cpu_dai->dev, "Failed to update CR1 register\n");
1029                 break;
1030         case SNDRV_PCM_TRIGGER_SUSPEND:
1031         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1032         case SNDRV_PCM_TRIGGER_STOP:
1033                 dev_dbg(cpu_dai->dev, "Disable DMA and SAI\n");
1034
1035                 regmap_update_bits(sai->regmap, STM_SAI_IMR_REGX,
1036                                    SAI_XIMR_MASK, 0);
1037
1038                 regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
1039                                    SAI_XCR1_SAIEN,
1040                                    (unsigned int)~SAI_XCR1_SAIEN);
1041
1042                 ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
1043                                          SAI_XCR1_DMAEN,
1044                                          (unsigned int)~SAI_XCR1_DMAEN);
1045                 if (ret < 0)
1046                         dev_err(cpu_dai->dev, "Failed to update CR1 register\n");
1047
1048                 if (STM_SAI_PROTOCOL_IS_SPDIF(sai))
1049                         sai->spdif_frm_cnt = 0;
1050                 break;
1051         default:
1052                 return -EINVAL;
1053         }
1054
1055         return ret;
1056 }
1057
1058 static void stm32_sai_shutdown(struct snd_pcm_substream *substream,
1059                                struct snd_soc_dai *cpu_dai)
1060 {
1061         struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
1062
1063         regmap_update_bits(sai->regmap, STM_SAI_IMR_REGX, SAI_XIMR_MASK, 0);
1064
1065         regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, SAI_XCR1_NODIV,
1066                            SAI_XCR1_NODIV);
1067
1068         clk_disable_unprepare(sai->sai_ck);
1069
1070         clk_rate_exclusive_put(sai->sai_mclk);
1071
1072         sai->substream = NULL;
1073 }
1074
1075 static int stm32_sai_pcm_new(struct snd_soc_pcm_runtime *rtd,
1076                              struct snd_soc_dai *cpu_dai)
1077 {
1078         struct stm32_sai_sub_data *sai = dev_get_drvdata(cpu_dai->dev);
1079         struct snd_kcontrol_new knew = iec958_ctls;
1080
1081         if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
1082                 dev_dbg(&sai->pdev->dev, "%s: register iec controls", __func__);
1083                 knew.device = rtd->pcm->device;
1084                 return snd_ctl_add(rtd->pcm->card, snd_ctl_new1(&knew, sai));
1085         }
1086
1087         return 0;
1088 }
1089
1090 static int stm32_sai_dai_probe(struct snd_soc_dai *cpu_dai)
1091 {
1092         struct stm32_sai_sub_data *sai = dev_get_drvdata(cpu_dai->dev);
1093         int cr1 = 0, cr1_mask;
1094
1095         sai->cpu_dai = cpu_dai;
1096
1097         sai->dma_params.addr = (dma_addr_t)(sai->phys_addr + STM_SAI_DR_REGX);
1098         /*
1099          * DMA supports 4, 8 or 16 burst sizes. Burst size 4 is the best choice,
1100          * as it allows bytes, half-word and words transfers. (See DMA fifos
1101          * constraints).
1102          */
1103         sai->dma_params.maxburst = 4;
1104         /* Buswidth will be set by framework at runtime */
1105         sai->dma_params.addr_width = DMA_SLAVE_BUSWIDTH_UNDEFINED;
1106
1107         if (STM_SAI_IS_PLAYBACK(sai))
1108                 snd_soc_dai_init_dma_data(cpu_dai, &sai->dma_params, NULL);
1109         else
1110                 snd_soc_dai_init_dma_data(cpu_dai, NULL, &sai->dma_params);
1111
1112         /* Next settings are not relevant for spdif mode */
1113         if (STM_SAI_PROTOCOL_IS_SPDIF(sai))
1114                 return 0;
1115
1116         cr1_mask = SAI_XCR1_RX_TX;
1117         if (STM_SAI_IS_CAPTURE(sai))
1118                 cr1 |= SAI_XCR1_RX_TX;
1119
1120         /* Configure synchronization */
1121         if (sai->sync == SAI_SYNC_EXTERNAL) {
1122                 /* Configure synchro client and provider */
1123                 sai->pdata->set_sync(sai->pdata, sai->np_sync_provider,
1124                                      sai->synco, sai->synci);
1125         }
1126
1127         cr1_mask |= SAI_XCR1_SYNCEN_MASK;
1128         cr1 |= SAI_XCR1_SYNCEN_SET(sai->sync);
1129
1130         return regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, cr1_mask, cr1);
1131 }
1132
1133 static const struct snd_soc_dai_ops stm32_sai_pcm_dai_ops = {
1134         .set_sysclk     = stm32_sai_set_sysclk,
1135         .set_fmt        = stm32_sai_set_dai_fmt,
1136         .set_tdm_slot   = stm32_sai_set_dai_tdm_slot,
1137         .startup        = stm32_sai_startup,
1138         .hw_params      = stm32_sai_hw_params,
1139         .trigger        = stm32_sai_trigger,
1140         .shutdown       = stm32_sai_shutdown,
1141 };
1142
1143 static int stm32_sai_pcm_process_spdif(struct snd_pcm_substream *substream,
1144                                        int channel, unsigned long hwoff,
1145                                        void *buf, unsigned long bytes)
1146 {
1147         struct snd_pcm_runtime *runtime = substream->runtime;
1148         struct snd_soc_pcm_runtime *rtd = substream->private_data;
1149         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1150         struct stm32_sai_sub_data *sai = dev_get_drvdata(cpu_dai->dev);
1151         int *ptr = (int *)(runtime->dma_area + hwoff +
1152                            channel * (runtime->dma_bytes / runtime->channels));
1153         ssize_t cnt = bytes_to_samples(runtime, bytes);
1154         unsigned int frm_cnt = sai->spdif_frm_cnt;
1155         unsigned int byte;
1156         unsigned int mask;
1157
1158         do {
1159                 *ptr = ((*ptr >> 8) & 0x00ffffff);
1160
1161                 /* Set channel status bit */
1162                 byte = frm_cnt >> 3;
1163                 mask = 1 << (frm_cnt - (byte << 3));
1164                 if (sai->iec958.status[byte] & mask)
1165                         *ptr |= 0x04000000;
1166                 ptr++;
1167
1168                 if (!(cnt % 2))
1169                         frm_cnt++;
1170
1171                 if (frm_cnt == SAI_IEC60958_BLOCK_FRAMES)
1172                         frm_cnt = 0;
1173         } while (--cnt);
1174         sai->spdif_frm_cnt = frm_cnt;
1175
1176         return 0;
1177 }
1178
1179 static const struct snd_pcm_hardware stm32_sai_pcm_hw = {
1180         .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP,
1181         .buffer_bytes_max = 8 * PAGE_SIZE,
1182         .period_bytes_min = 1024, /* 5ms at 48kHz */
1183         .period_bytes_max = PAGE_SIZE,
1184         .periods_min = 2,
1185         .periods_max = 8,
1186 };
1187
1188 static struct snd_soc_dai_driver stm32_sai_playback_dai[] = {
1189 {
1190                 .probe = stm32_sai_dai_probe,
1191                 .pcm_new = stm32_sai_pcm_new,
1192                 .id = 1, /* avoid call to fmt_single_name() */
1193                 .playback = {
1194                         .channels_min = 1,
1195                         .channels_max = 2,
1196                         .rate_min = 8000,
1197                         .rate_max = 192000,
1198                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
1199                         /* DMA does not support 24 bits transfers */
1200                         .formats =
1201                                 SNDRV_PCM_FMTBIT_S8 |
1202                                 SNDRV_PCM_FMTBIT_S16_LE |
1203                                 SNDRV_PCM_FMTBIT_S32_LE,
1204                 },
1205                 .ops = &stm32_sai_pcm_dai_ops,
1206         }
1207 };
1208
1209 static struct snd_soc_dai_driver stm32_sai_capture_dai[] = {
1210 {
1211                 .probe = stm32_sai_dai_probe,
1212                 .id = 1, /* avoid call to fmt_single_name() */
1213                 .capture = {
1214                         .channels_min = 1,
1215                         .channels_max = 2,
1216                         .rate_min = 8000,
1217                         .rate_max = 192000,
1218                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
1219                         /* DMA does not support 24 bits transfers */
1220                         .formats =
1221                                 SNDRV_PCM_FMTBIT_S8 |
1222                                 SNDRV_PCM_FMTBIT_S16_LE |
1223                                 SNDRV_PCM_FMTBIT_S32_LE,
1224                 },
1225                 .ops = &stm32_sai_pcm_dai_ops,
1226         }
1227 };
1228
1229 static const struct snd_dmaengine_pcm_config stm32_sai_pcm_config = {
1230         .pcm_hardware = &stm32_sai_pcm_hw,
1231         .prepare_slave_config = snd_dmaengine_pcm_prepare_slave_config,
1232 };
1233
1234 static const struct snd_dmaengine_pcm_config stm32_sai_pcm_config_spdif = {
1235         .pcm_hardware = &stm32_sai_pcm_hw,
1236         .prepare_slave_config = snd_dmaengine_pcm_prepare_slave_config,
1237         .process = stm32_sai_pcm_process_spdif,
1238 };
1239
1240 static const struct snd_soc_component_driver stm32_component = {
1241         .name = "stm32-sai",
1242 };
1243
1244 static const struct of_device_id stm32_sai_sub_ids[] = {
1245         { .compatible = "st,stm32-sai-sub-a",
1246           .data = (void *)STM_SAI_A_ID},
1247         { .compatible = "st,stm32-sai-sub-b",
1248           .data = (void *)STM_SAI_B_ID},
1249         {}
1250 };
1251 MODULE_DEVICE_TABLE(of, stm32_sai_sub_ids);
1252
1253 static int stm32_sai_sub_parse_of(struct platform_device *pdev,
1254                                   struct stm32_sai_sub_data *sai)
1255 {
1256         struct device_node *np = pdev->dev.of_node;
1257         struct resource *res;
1258         void __iomem *base;
1259         struct of_phandle_args args;
1260         int ret;
1261
1262         if (!np)
1263                 return -ENODEV;
1264
1265         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1266         base = devm_ioremap_resource(&pdev->dev, res);
1267         if (IS_ERR(base))
1268                 return PTR_ERR(base);
1269
1270         sai->phys_addr = res->start;
1271
1272         sai->regmap_config = &stm32_sai_sub_regmap_config_f4;
1273         /* Note: PDM registers not available for H7 sub-block B */
1274         if (STM_SAI_IS_H7(sai->pdata) && STM_SAI_IS_SUB_A(sai))
1275                 sai->regmap_config = &stm32_sai_sub_regmap_config_h7;
1276
1277         sai->regmap = devm_regmap_init_mmio_clk(&pdev->dev, "sai_ck",
1278                                                 base, sai->regmap_config);
1279         if (IS_ERR(sai->regmap)) {
1280                 dev_err(&pdev->dev, "Failed to initialize MMIO\n");
1281                 return PTR_ERR(sai->regmap);
1282         }
1283
1284         /* Get direction property */
1285         if (of_property_match_string(np, "dma-names", "tx") >= 0) {
1286                 sai->dir = SNDRV_PCM_STREAM_PLAYBACK;
1287         } else if (of_property_match_string(np, "dma-names", "rx") >= 0) {
1288                 sai->dir = SNDRV_PCM_STREAM_CAPTURE;
1289         } else {
1290                 dev_err(&pdev->dev, "Unsupported direction\n");
1291                 return -EINVAL;
1292         }
1293
1294         /* Get spdif iec60958 property */
1295         sai->spdif = false;
1296         if (of_get_property(np, "st,iec60958", NULL)) {
1297                 if (!STM_SAI_HAS_SPDIF(sai) ||
1298                     sai->dir == SNDRV_PCM_STREAM_CAPTURE) {
1299                         dev_err(&pdev->dev, "S/PDIF IEC60958 not supported\n");
1300                         return -EINVAL;
1301                 }
1302                 stm32_sai_init_iec958_status(sai);
1303                 sai->spdif = true;
1304                 sai->master = true;
1305         }
1306
1307         /* Get synchronization property */
1308         args.np = NULL;
1309         ret = of_parse_phandle_with_fixed_args(np, "st,sync", 1, 0, &args);
1310         if (ret < 0  && ret != -ENOENT) {
1311                 dev_err(&pdev->dev, "Failed to get st,sync property\n");
1312                 return ret;
1313         }
1314
1315         sai->sync = SAI_SYNC_NONE;
1316         if (args.np) {
1317                 if (args.np == np) {
1318                         dev_err(&pdev->dev, "%pOFn sync own reference\n", np);
1319                         of_node_put(args.np);
1320                         return -EINVAL;
1321                 }
1322
1323                 sai->np_sync_provider  = of_get_parent(args.np);
1324                 if (!sai->np_sync_provider) {
1325                         dev_err(&pdev->dev, "%pOFn parent node not found\n",
1326                                 np);
1327                         of_node_put(args.np);
1328                         return -ENODEV;
1329                 }
1330
1331                 sai->sync = SAI_SYNC_INTERNAL;
1332                 if (sai->np_sync_provider != sai->pdata->pdev->dev.of_node) {
1333                         if (!STM_SAI_HAS_EXT_SYNC(sai)) {
1334                                 dev_err(&pdev->dev,
1335                                         "External synchro not supported\n");
1336                                 of_node_put(args.np);
1337                                 return -EINVAL;
1338                         }
1339                         sai->sync = SAI_SYNC_EXTERNAL;
1340
1341                         sai->synci = args.args[0];
1342                         if (sai->synci < 1 ||
1343                             (sai->synci > (SAI_GCR_SYNCIN_MAX + 1))) {
1344                                 dev_err(&pdev->dev, "Wrong SAI index\n");
1345                                 of_node_put(args.np);
1346                                 return -EINVAL;
1347                         }
1348
1349                         if (of_property_match_string(args.np, "compatible",
1350                                                      "st,stm32-sai-sub-a") >= 0)
1351                                 sai->synco = STM_SAI_SYNC_OUT_A;
1352
1353                         if (of_property_match_string(args.np, "compatible",
1354                                                      "st,stm32-sai-sub-b") >= 0)
1355                                 sai->synco = STM_SAI_SYNC_OUT_B;
1356
1357                         if (!sai->synco) {
1358                                 dev_err(&pdev->dev, "Unknown SAI sub-block\n");
1359                                 of_node_put(args.np);
1360                                 return -EINVAL;
1361                         }
1362                 }
1363
1364                 dev_dbg(&pdev->dev, "%s synchronized with %s\n",
1365                         pdev->name, args.np->full_name);
1366         }
1367
1368         of_node_put(args.np);
1369         sai->sai_ck = devm_clk_get(&pdev->dev, "sai_ck");
1370         if (IS_ERR(sai->sai_ck)) {
1371                 dev_err(&pdev->dev, "Missing kernel clock sai_ck\n");
1372                 return PTR_ERR(sai->sai_ck);
1373         }
1374
1375         if (STM_SAI_IS_F4(sai->pdata))
1376                 return 0;
1377
1378         /* Register mclk provider if requested */
1379         if (of_find_property(np, "#clock-cells", NULL)) {
1380                 ret = stm32_sai_add_mclk_provider(sai);
1381                 if (ret < 0)
1382                         return ret;
1383         } else {
1384                 sai->sai_mclk = devm_clk_get(&pdev->dev, "MCLK");
1385                 if (IS_ERR(sai->sai_mclk)) {
1386                         if (PTR_ERR(sai->sai_mclk) != -ENOENT)
1387                                 return PTR_ERR(sai->sai_mclk);
1388                         sai->sai_mclk = NULL;
1389                 }
1390         }
1391
1392         return 0;
1393 }
1394
1395 static int stm32_sai_sub_dais_init(struct platform_device *pdev,
1396                                    struct stm32_sai_sub_data *sai)
1397 {
1398         sai->cpu_dai_drv = devm_kzalloc(&pdev->dev,
1399                                         sizeof(struct snd_soc_dai_driver),
1400                                         GFP_KERNEL);
1401         if (!sai->cpu_dai_drv)
1402                 return -ENOMEM;
1403
1404         sai->cpu_dai_drv->name = dev_name(&pdev->dev);
1405         if (STM_SAI_IS_PLAYBACK(sai)) {
1406                 memcpy(sai->cpu_dai_drv, &stm32_sai_playback_dai,
1407                        sizeof(stm32_sai_playback_dai));
1408                 sai->cpu_dai_drv->playback.stream_name = sai->cpu_dai_drv->name;
1409         } else {
1410                 memcpy(sai->cpu_dai_drv, &stm32_sai_capture_dai,
1411                        sizeof(stm32_sai_capture_dai));
1412                 sai->cpu_dai_drv->capture.stream_name = sai->cpu_dai_drv->name;
1413         }
1414
1415         return 0;
1416 }
1417
1418 static int stm32_sai_sub_probe(struct platform_device *pdev)
1419 {
1420         struct stm32_sai_sub_data *sai;
1421         const struct of_device_id *of_id;
1422         const struct snd_dmaengine_pcm_config *conf = &stm32_sai_pcm_config;
1423         int ret;
1424
1425         sai = devm_kzalloc(&pdev->dev, sizeof(*sai), GFP_KERNEL);
1426         if (!sai)
1427                 return -ENOMEM;
1428
1429         of_id = of_match_device(stm32_sai_sub_ids, &pdev->dev);
1430         if (!of_id)
1431                 return -EINVAL;
1432         sai->id = (uintptr_t)of_id->data;
1433
1434         sai->pdev = pdev;
1435         mutex_init(&sai->ctrl_lock);
1436         platform_set_drvdata(pdev, sai);
1437
1438         sai->pdata = dev_get_drvdata(pdev->dev.parent);
1439         if (!sai->pdata) {
1440                 dev_err(&pdev->dev, "Parent device data not available\n");
1441                 return -EINVAL;
1442         }
1443
1444         ret = stm32_sai_sub_parse_of(pdev, sai);
1445         if (ret)
1446                 return ret;
1447
1448         ret = stm32_sai_sub_dais_init(pdev, sai);
1449         if (ret)
1450                 return ret;
1451
1452         ret = devm_request_irq(&pdev->dev, sai->pdata->irq, stm32_sai_isr,
1453                                IRQF_SHARED, dev_name(&pdev->dev), sai);
1454         if (ret) {
1455                 dev_err(&pdev->dev, "IRQ request returned %d\n", ret);
1456                 return ret;
1457         }
1458
1459         ret = devm_snd_soc_register_component(&pdev->dev, &stm32_component,
1460                                               sai->cpu_dai_drv, 1);
1461         if (ret)
1462                 return ret;
1463
1464         if (STM_SAI_PROTOCOL_IS_SPDIF(sai))
1465                 conf = &stm32_sai_pcm_config_spdif;
1466
1467         ret = devm_snd_dmaengine_pcm_register(&pdev->dev, conf, 0);
1468         if (ret) {
1469                 dev_err(&pdev->dev, "Could not register pcm dma\n");
1470                 return ret;
1471         }
1472
1473         return 0;
1474 }
1475
1476 static struct platform_driver stm32_sai_sub_driver = {
1477         .driver = {
1478                 .name = "st,stm32-sai-sub",
1479                 .of_match_table = stm32_sai_sub_ids,
1480         },
1481         .probe = stm32_sai_sub_probe,
1482 };
1483
1484 module_platform_driver(stm32_sai_sub_driver);
1485
1486 MODULE_DESCRIPTION("STM32 Soc SAI sub-block Interface");
1487 MODULE_AUTHOR("Olivier Moysan <olivier.moysan@st.com>");
1488 MODULE_ALIAS("platform:st,stm32-sai-sub");
1489 MODULE_LICENSE("GPL v2");