1 /* 2 * Freescale ALSA SoC Digital Audio Interface (SAI) driver. 3 * 4 * Copyright 2012-2013 Freescale Semiconductor, Inc. 5 * 6 * This program is free software, you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License as published by the 8 * Free Software Foundation, either version 2 of the License, or(at your 9 * option) any later version. 10 * 11 */ 12 13 #include <linux/clk.h> 14 #include <linux/delay.h> 15 #include <linux/dmaengine.h> 16 #include <linux/module.h> 17 #include <linux/of_address.h> 18 #include <linux/regmap.h> 19 #include <linux/slab.h> 20 #include <sound/core.h> 21 #include <sound/dmaengine_pcm.h> 22 #include <sound/pcm_params.h> 23 24 #include "fsl_sai.h" 25 #include "imx-pcm.h" 26 27 #define FSL_SAI_FLAGS (FSL_SAI_CSR_SEIE |\ 28 FSL_SAI_CSR_FEIE) 29 30 static irqreturn_t fsl_sai_isr(int irq, void *devid) 31 { 32 struct fsl_sai *sai = (struct fsl_sai *)devid; 33 struct device *dev = &sai->pdev->dev; 34 u32 flags, xcsr, mask; 35 bool irq_none = true; 36 37 /* 38 * Both IRQ status bits and IRQ mask bits are in the xCSR but 39 * different shifts. And we here create a mask only for those 40 * IRQs that we activated. 41 */ 42 mask = (FSL_SAI_FLAGS >> FSL_SAI_CSR_xIE_SHIFT) << FSL_SAI_CSR_xF_SHIFT; 43 44 /* Tx IRQ */ 45 regmap_read(sai->regmap, FSL_SAI_TCSR, &xcsr); 46 flags = xcsr & mask; 47 48 if (flags) 49 irq_none = false; 50 else 51 goto irq_rx; 52 53 if (flags & FSL_SAI_CSR_WSF) 54 dev_dbg(dev, "isr: Start of Tx word detected\n"); 55 56 if (flags & FSL_SAI_CSR_SEF) 57 dev_warn(dev, "isr: Tx Frame sync error detected\n"); 58 59 if (flags & FSL_SAI_CSR_FEF) { 60 dev_warn(dev, "isr: Transmit underrun detected\n"); 61 /* FIFO reset for safety */ 62 xcsr |= FSL_SAI_CSR_FR; 63 } 64 65 if (flags & FSL_SAI_CSR_FWF) 66 dev_dbg(dev, "isr: Enabled transmit FIFO is empty\n"); 67 68 if (flags & FSL_SAI_CSR_FRF) 69 dev_dbg(dev, "isr: Transmit FIFO watermark has been reached\n"); 70 71 flags &= FSL_SAI_CSR_xF_W_MASK; 72 xcsr &= ~FSL_SAI_CSR_xF_MASK; 73 74 if (flags) 75 regmap_write(sai->regmap, FSL_SAI_TCSR, flags | xcsr); 76 77 irq_rx: 78 /* Rx IRQ */ 79 regmap_read(sai->regmap, FSL_SAI_RCSR, &xcsr); 80 flags = xcsr & mask; 81 82 if (flags) 83 irq_none = false; 84 else 85 goto out; 86 87 if (flags & FSL_SAI_CSR_WSF) 88 dev_dbg(dev, "isr: Start of Rx word detected\n"); 89 90 if (flags & FSL_SAI_CSR_SEF) 91 dev_warn(dev, "isr: Rx Frame sync error detected\n"); 92 93 if (flags & FSL_SAI_CSR_FEF) { 94 dev_warn(dev, "isr: Receive overflow detected\n"); 95 /* FIFO reset for safety */ 96 xcsr |= FSL_SAI_CSR_FR; 97 } 98 99 if (flags & FSL_SAI_CSR_FWF) 100 dev_dbg(dev, "isr: Enabled receive FIFO is full\n"); 101 102 if (flags & FSL_SAI_CSR_FRF) 103 dev_dbg(dev, "isr: Receive FIFO watermark has been reached\n"); 104 105 flags &= FSL_SAI_CSR_xF_W_MASK; 106 xcsr &= ~FSL_SAI_CSR_xF_MASK; 107 108 if (flags) 109 regmap_write(sai->regmap, FSL_SAI_RCSR, flags | xcsr); 110 111 out: 112 if (irq_none) 113 return IRQ_NONE; 114 else 115 return IRQ_HANDLED; 116 } 117 118 static int fsl_sai_set_dai_sysclk_tr(struct snd_soc_dai *cpu_dai, 119 int clk_id, unsigned int freq, int fsl_dir) 120 { 121 struct fsl_sai *sai = snd_soc_dai_get_drvdata(cpu_dai); 122 bool tx = fsl_dir == FSL_FMT_TRANSMITTER; 123 u32 val_cr2 = 0; 124 125 switch (clk_id) { 126 case FSL_SAI_CLK_BUS: 127 val_cr2 |= FSL_SAI_CR2_MSEL_BUS; 128 break; 129 case FSL_SAI_CLK_MAST1: 130 val_cr2 |= FSL_SAI_CR2_MSEL_MCLK1; 131 break; 132 case FSL_SAI_CLK_MAST2: 133 val_cr2 |= FSL_SAI_CR2_MSEL_MCLK2; 134 break; 135 case FSL_SAI_CLK_MAST3: 136 val_cr2 |= FSL_SAI_CR2_MSEL_MCLK3; 137 break; 138 default: 139 return -EINVAL; 140 } 141 142 regmap_update_bits(sai->regmap, FSL_SAI_xCR2(tx), 143 FSL_SAI_CR2_MSEL_MASK, val_cr2); 144 145 return 0; 146 } 147 148 static int fsl_sai_set_dai_sysclk(struct snd_soc_dai *cpu_dai, 149 int clk_id, unsigned int freq, int dir) 150 { 151 int ret; 152 153 if (dir == SND_SOC_CLOCK_IN) 154 return 0; 155 156 ret = fsl_sai_set_dai_sysclk_tr(cpu_dai, clk_id, freq, 157 FSL_FMT_TRANSMITTER); 158 if (ret) { 159 dev_err(cpu_dai->dev, "Cannot set tx sysclk: %d\n", ret); 160 return ret; 161 } 162 163 ret = fsl_sai_set_dai_sysclk_tr(cpu_dai, clk_id, freq, 164 FSL_FMT_RECEIVER); 165 if (ret) 166 dev_err(cpu_dai->dev, "Cannot set rx sysclk: %d\n", ret); 167 168 return ret; 169 } 170 171 static int fsl_sai_set_dai_fmt_tr(struct snd_soc_dai *cpu_dai, 172 unsigned int fmt, int fsl_dir) 173 { 174 struct fsl_sai *sai = snd_soc_dai_get_drvdata(cpu_dai); 175 bool tx = fsl_dir == FSL_FMT_TRANSMITTER; 176 u32 val_cr2 = 0, val_cr4 = 0; 177 178 if (!sai->big_endian_data) 179 val_cr4 |= FSL_SAI_CR4_MF; 180 181 /* DAI mode */ 182 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 183 case SND_SOC_DAIFMT_I2S: 184 /* 185 * Frame low, 1clk before data, one word length for frame sync, 186 * frame sync starts one serial clock cycle earlier, 187 * that is, together with the last bit of the previous 188 * data word. 189 */ 190 val_cr2 |= FSL_SAI_CR2_BCP; 191 val_cr4 |= FSL_SAI_CR4_FSE | FSL_SAI_CR4_FSP; 192 break; 193 case SND_SOC_DAIFMT_LEFT_J: 194 /* 195 * Frame high, one word length for frame sync, 196 * frame sync asserts with the first bit of the frame. 197 */ 198 val_cr2 |= FSL_SAI_CR2_BCP; 199 break; 200 case SND_SOC_DAIFMT_DSP_A: 201 /* 202 * Frame high, 1clk before data, one bit for frame sync, 203 * frame sync starts one serial clock cycle earlier, 204 * that is, together with the last bit of the previous 205 * data word. 206 */ 207 val_cr2 |= FSL_SAI_CR2_BCP; 208 val_cr4 |= FSL_SAI_CR4_FSE; 209 sai->is_dsp_mode = true; 210 break; 211 case SND_SOC_DAIFMT_DSP_B: 212 /* 213 * Frame high, one bit for frame sync, 214 * frame sync asserts with the first bit of the frame. 215 */ 216 val_cr2 |= FSL_SAI_CR2_BCP; 217 sai->is_dsp_mode = true; 218 break; 219 case SND_SOC_DAIFMT_RIGHT_J: 220 /* To be done */ 221 default: 222 return -EINVAL; 223 } 224 225 /* DAI clock inversion */ 226 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 227 case SND_SOC_DAIFMT_IB_IF: 228 /* Invert both clocks */ 229 val_cr2 ^= FSL_SAI_CR2_BCP; 230 val_cr4 ^= FSL_SAI_CR4_FSP; 231 break; 232 case SND_SOC_DAIFMT_IB_NF: 233 /* Invert bit clock */ 234 val_cr2 ^= FSL_SAI_CR2_BCP; 235 break; 236 case SND_SOC_DAIFMT_NB_IF: 237 /* Invert frame clock */ 238 val_cr4 ^= FSL_SAI_CR4_FSP; 239 break; 240 case SND_SOC_DAIFMT_NB_NF: 241 /* Nothing to do for both normal cases */ 242 break; 243 default: 244 return -EINVAL; 245 } 246 247 /* DAI clock master masks */ 248 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { 249 case SND_SOC_DAIFMT_CBS_CFS: 250 val_cr2 |= FSL_SAI_CR2_BCD_MSTR; 251 val_cr4 |= FSL_SAI_CR4_FSD_MSTR; 252 break; 253 case SND_SOC_DAIFMT_CBM_CFM: 254 break; 255 case SND_SOC_DAIFMT_CBS_CFM: 256 val_cr2 |= FSL_SAI_CR2_BCD_MSTR; 257 break; 258 case SND_SOC_DAIFMT_CBM_CFS: 259 val_cr4 |= FSL_SAI_CR4_FSD_MSTR; 260 break; 261 default: 262 return -EINVAL; 263 } 264 265 regmap_update_bits(sai->regmap, FSL_SAI_xCR2(tx), 266 FSL_SAI_CR2_BCP | FSL_SAI_CR2_BCD_MSTR, val_cr2); 267 regmap_update_bits(sai->regmap, FSL_SAI_xCR4(tx), 268 FSL_SAI_CR4_MF | FSL_SAI_CR4_FSE | 269 FSL_SAI_CR4_FSP | FSL_SAI_CR4_FSD_MSTR, val_cr4); 270 271 return 0; 272 } 273 274 static int fsl_sai_set_dai_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt) 275 { 276 int ret; 277 278 ret = fsl_sai_set_dai_fmt_tr(cpu_dai, fmt, FSL_FMT_TRANSMITTER); 279 if (ret) { 280 dev_err(cpu_dai->dev, "Cannot set tx format: %d\n", ret); 281 return ret; 282 } 283 284 ret = fsl_sai_set_dai_fmt_tr(cpu_dai, fmt, FSL_FMT_RECEIVER); 285 if (ret) 286 dev_err(cpu_dai->dev, "Cannot set rx format: %d\n", ret); 287 288 return ret; 289 } 290 291 static int fsl_sai_hw_params(struct snd_pcm_substream *substream, 292 struct snd_pcm_hw_params *params, 293 struct snd_soc_dai *cpu_dai) 294 { 295 struct fsl_sai *sai = snd_soc_dai_get_drvdata(cpu_dai); 296 bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; 297 unsigned int channels = params_channels(params); 298 u32 word_width = snd_pcm_format_width(params_format(params)); 299 u32 val_cr4 = 0, val_cr5 = 0; 300 301 if (!sai->is_dsp_mode) 302 val_cr4 |= FSL_SAI_CR4_SYWD(word_width); 303 304 val_cr5 |= FSL_SAI_CR5_WNW(word_width); 305 val_cr5 |= FSL_SAI_CR5_W0W(word_width); 306 307 if (sai->big_endian_data) 308 val_cr5 |= FSL_SAI_CR5_FBT(0); 309 else 310 val_cr5 |= FSL_SAI_CR5_FBT(word_width - 1); 311 312 val_cr4 |= FSL_SAI_CR4_FRSZ(channels); 313 314 regmap_update_bits(sai->regmap, FSL_SAI_xCR4(tx), 315 FSL_SAI_CR4_SYWD_MASK | FSL_SAI_CR4_FRSZ_MASK, 316 val_cr4); 317 regmap_update_bits(sai->regmap, FSL_SAI_xCR5(tx), 318 FSL_SAI_CR5_WNW_MASK | FSL_SAI_CR5_W0W_MASK | 319 FSL_SAI_CR5_FBT_MASK, val_cr5); 320 regmap_write(sai->regmap, FSL_SAI_xMR(tx), ~0UL - ((1 << channels) - 1)); 321 322 return 0; 323 } 324 325 static int fsl_sai_trigger(struct snd_pcm_substream *substream, int cmd, 326 struct snd_soc_dai *cpu_dai) 327 { 328 struct fsl_sai *sai = snd_soc_dai_get_drvdata(cpu_dai); 329 bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; 330 u32 xcsr, count = 100; 331 332 /* 333 * The transmitter bit clock and frame sync are to be 334 * used by both the transmitter and receiver. 335 */ 336 regmap_update_bits(sai->regmap, FSL_SAI_TCR2, FSL_SAI_CR2_SYNC, 337 ~FSL_SAI_CR2_SYNC); 338 regmap_update_bits(sai->regmap, FSL_SAI_RCR2, FSL_SAI_CR2_SYNC, 339 FSL_SAI_CR2_SYNC); 340 341 /* 342 * It is recommended that the transmitter is the last enabled 343 * and the first disabled. 344 */ 345 switch (cmd) { 346 case SNDRV_PCM_TRIGGER_START: 347 case SNDRV_PCM_TRIGGER_RESUME: 348 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 349 regmap_update_bits(sai->regmap, FSL_SAI_xCSR(tx), 350 FSL_SAI_CSR_FRDE, FSL_SAI_CSR_FRDE); 351 352 regmap_update_bits(sai->regmap, FSL_SAI_RCSR, 353 FSL_SAI_CSR_TERE, FSL_SAI_CSR_TERE); 354 regmap_update_bits(sai->regmap, FSL_SAI_TCSR, 355 FSL_SAI_CSR_TERE, FSL_SAI_CSR_TERE); 356 357 regmap_update_bits(sai->regmap, FSL_SAI_xCSR(tx), 358 FSL_SAI_CSR_xIE_MASK, FSL_SAI_FLAGS); 359 break; 360 case SNDRV_PCM_TRIGGER_STOP: 361 case SNDRV_PCM_TRIGGER_SUSPEND: 362 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 363 regmap_update_bits(sai->regmap, FSL_SAI_xCSR(tx), 364 FSL_SAI_CSR_FRDE, 0); 365 regmap_update_bits(sai->regmap, FSL_SAI_xCSR(tx), 366 FSL_SAI_CSR_xIE_MASK, 0); 367 368 /* Check if the opposite FRDE is also disabled */ 369 regmap_read(sai->regmap, FSL_SAI_xCSR(!tx), &xcsr); 370 if (!(xcsr & FSL_SAI_CSR_FRDE)) { 371 /* Disable both directions and reset their FIFOs */ 372 regmap_update_bits(sai->regmap, FSL_SAI_TCSR, 373 FSL_SAI_CSR_TERE, 0); 374 regmap_update_bits(sai->regmap, FSL_SAI_RCSR, 375 FSL_SAI_CSR_TERE, 0); 376 377 /* TERE will remain set till the end of current frame */ 378 do { 379 udelay(10); 380 regmap_read(sai->regmap, FSL_SAI_xCSR(tx), &xcsr); 381 } while (--count && xcsr & FSL_SAI_CSR_TERE); 382 383 regmap_update_bits(sai->regmap, FSL_SAI_TCSR, 384 FSL_SAI_CSR_FR, FSL_SAI_CSR_FR); 385 regmap_update_bits(sai->regmap, FSL_SAI_RCSR, 386 FSL_SAI_CSR_FR, FSL_SAI_CSR_FR); 387 } 388 break; 389 default: 390 return -EINVAL; 391 } 392 393 return 0; 394 } 395 396 static int fsl_sai_startup(struct snd_pcm_substream *substream, 397 struct snd_soc_dai *cpu_dai) 398 { 399 struct fsl_sai *sai = snd_soc_dai_get_drvdata(cpu_dai); 400 bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; 401 struct device *dev = &sai->pdev->dev; 402 int ret; 403 404 ret = clk_prepare_enable(sai->bus_clk); 405 if (ret) { 406 dev_err(dev, "failed to enable bus clock: %d\n", ret); 407 return ret; 408 } 409 410 regmap_update_bits(sai->regmap, FSL_SAI_xCR3(tx), FSL_SAI_CR3_TRCE, 411 FSL_SAI_CR3_TRCE); 412 413 return 0; 414 } 415 416 static void fsl_sai_shutdown(struct snd_pcm_substream *substream, 417 struct snd_soc_dai *cpu_dai) 418 { 419 struct fsl_sai *sai = snd_soc_dai_get_drvdata(cpu_dai); 420 bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; 421 422 regmap_update_bits(sai->regmap, FSL_SAI_xCR3(tx), FSL_SAI_CR3_TRCE, 0); 423 424 clk_disable_unprepare(sai->bus_clk); 425 } 426 427 static const struct snd_soc_dai_ops fsl_sai_pcm_dai_ops = { 428 .set_sysclk = fsl_sai_set_dai_sysclk, 429 .set_fmt = fsl_sai_set_dai_fmt, 430 .hw_params = fsl_sai_hw_params, 431 .trigger = fsl_sai_trigger, 432 .startup = fsl_sai_startup, 433 .shutdown = fsl_sai_shutdown, 434 }; 435 436 static int fsl_sai_dai_probe(struct snd_soc_dai *cpu_dai) 437 { 438 struct fsl_sai *sai = dev_get_drvdata(cpu_dai->dev); 439 440 regmap_update_bits(sai->regmap, FSL_SAI_TCSR, 0xffffffff, 0x0); 441 regmap_update_bits(sai->regmap, FSL_SAI_RCSR, 0xffffffff, 0x0); 442 regmap_update_bits(sai->regmap, FSL_SAI_TCR1, FSL_SAI_CR1_RFW_MASK, 443 FSL_SAI_MAXBURST_TX * 2); 444 regmap_update_bits(sai->regmap, FSL_SAI_RCR1, FSL_SAI_CR1_RFW_MASK, 445 FSL_SAI_MAXBURST_RX - 1); 446 447 snd_soc_dai_init_dma_data(cpu_dai, &sai->dma_params_tx, 448 &sai->dma_params_rx); 449 450 snd_soc_dai_set_drvdata(cpu_dai, sai); 451 452 return 0; 453 } 454 455 static struct snd_soc_dai_driver fsl_sai_dai = { 456 .probe = fsl_sai_dai_probe, 457 .playback = { 458 .stream_name = "CPU-Playback", 459 .channels_min = 1, 460 .channels_max = 2, 461 .rates = SNDRV_PCM_RATE_8000_96000, 462 .formats = FSL_SAI_FORMATS, 463 }, 464 .capture = { 465 .stream_name = "CPU-Capture", 466 .channels_min = 1, 467 .channels_max = 2, 468 .rates = SNDRV_PCM_RATE_8000_96000, 469 .formats = FSL_SAI_FORMATS, 470 }, 471 .ops = &fsl_sai_pcm_dai_ops, 472 }; 473 474 static const struct snd_soc_component_driver fsl_component = { 475 .name = "fsl-sai", 476 }; 477 478 static bool fsl_sai_readable_reg(struct device *dev, unsigned int reg) 479 { 480 switch (reg) { 481 case FSL_SAI_TCSR: 482 case FSL_SAI_TCR1: 483 case FSL_SAI_TCR2: 484 case FSL_SAI_TCR3: 485 case FSL_SAI_TCR4: 486 case FSL_SAI_TCR5: 487 case FSL_SAI_TFR: 488 case FSL_SAI_TMR: 489 case FSL_SAI_RCSR: 490 case FSL_SAI_RCR1: 491 case FSL_SAI_RCR2: 492 case FSL_SAI_RCR3: 493 case FSL_SAI_RCR4: 494 case FSL_SAI_RCR5: 495 case FSL_SAI_RDR: 496 case FSL_SAI_RFR: 497 case FSL_SAI_RMR: 498 return true; 499 default: 500 return false; 501 } 502 } 503 504 static bool fsl_sai_volatile_reg(struct device *dev, unsigned int reg) 505 { 506 switch (reg) { 507 case FSL_SAI_TFR: 508 case FSL_SAI_RFR: 509 case FSL_SAI_TDR: 510 case FSL_SAI_RDR: 511 return true; 512 default: 513 return false; 514 } 515 516 } 517 518 static bool fsl_sai_writeable_reg(struct device *dev, unsigned int reg) 519 { 520 switch (reg) { 521 case FSL_SAI_TCSR: 522 case FSL_SAI_TCR1: 523 case FSL_SAI_TCR2: 524 case FSL_SAI_TCR3: 525 case FSL_SAI_TCR4: 526 case FSL_SAI_TCR5: 527 case FSL_SAI_TDR: 528 case FSL_SAI_TMR: 529 case FSL_SAI_RCSR: 530 case FSL_SAI_RCR1: 531 case FSL_SAI_RCR2: 532 case FSL_SAI_RCR3: 533 case FSL_SAI_RCR4: 534 case FSL_SAI_RCR5: 535 case FSL_SAI_RMR: 536 return true; 537 default: 538 return false; 539 } 540 } 541 542 static struct regmap_config fsl_sai_regmap_config = { 543 .reg_bits = 32, 544 .reg_stride = 4, 545 .val_bits = 32, 546 547 .max_register = FSL_SAI_RMR, 548 .readable_reg = fsl_sai_readable_reg, 549 .volatile_reg = fsl_sai_volatile_reg, 550 .writeable_reg = fsl_sai_writeable_reg, 551 }; 552 553 static int fsl_sai_probe(struct platform_device *pdev) 554 { 555 struct device_node *np = pdev->dev.of_node; 556 struct fsl_sai *sai; 557 struct resource *res; 558 void __iomem *base; 559 char tmp[8]; 560 int irq, ret, i; 561 562 sai = devm_kzalloc(&pdev->dev, sizeof(*sai), GFP_KERNEL); 563 if (!sai) 564 return -ENOMEM; 565 566 sai->pdev = pdev; 567 568 if (of_device_is_compatible(pdev->dev.of_node, "fsl,imx6sx-sai")) 569 sai->sai_on_imx = true; 570 571 sai->big_endian_regs = of_property_read_bool(np, "big-endian-regs"); 572 if (sai->big_endian_regs) 573 fsl_sai_regmap_config.val_format_endian = REGMAP_ENDIAN_BIG; 574 575 sai->big_endian_data = of_property_read_bool(np, "big-endian-data"); 576 577 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 578 base = devm_ioremap_resource(&pdev->dev, res); 579 if (IS_ERR(base)) 580 return PTR_ERR(base); 581 582 sai->regmap = devm_regmap_init_mmio_clk(&pdev->dev, 583 "bus", base, &fsl_sai_regmap_config); 584 585 /* Compatible with old DTB cases */ 586 if (IS_ERR(sai->regmap)) 587 sai->regmap = devm_regmap_init_mmio_clk(&pdev->dev, 588 "sai", base, &fsl_sai_regmap_config); 589 if (IS_ERR(sai->regmap)) { 590 dev_err(&pdev->dev, "regmap init failed\n"); 591 return PTR_ERR(sai->regmap); 592 } 593 594 /* No error out for old DTB cases but only mark the clock NULL */ 595 sai->bus_clk = devm_clk_get(&pdev->dev, "bus"); 596 if (IS_ERR(sai->bus_clk)) { 597 dev_err(&pdev->dev, "failed to get bus clock: %ld\n", 598 PTR_ERR(sai->bus_clk)); 599 sai->bus_clk = NULL; 600 } 601 602 for (i = 0; i < FSL_SAI_MCLK_MAX; i++) { 603 sprintf(tmp, "mclk%d", i + 1); 604 sai->mclk_clk[i] = devm_clk_get(&pdev->dev, tmp); 605 if (IS_ERR(sai->mclk_clk[i])) { 606 dev_err(&pdev->dev, "failed to get mclk%d clock: %ld\n", 607 i + 1, PTR_ERR(sai->mclk_clk[i])); 608 sai->mclk_clk[i] = NULL; 609 } 610 } 611 612 irq = platform_get_irq(pdev, 0); 613 if (irq < 0) { 614 dev_err(&pdev->dev, "no irq for node %s\n", np->full_name); 615 return irq; 616 } 617 618 ret = devm_request_irq(&pdev->dev, irq, fsl_sai_isr, 0, np->name, sai); 619 if (ret) { 620 dev_err(&pdev->dev, "failed to claim irq %u\n", irq); 621 return ret; 622 } 623 624 sai->dma_params_rx.addr = res->start + FSL_SAI_RDR; 625 sai->dma_params_tx.addr = res->start + FSL_SAI_TDR; 626 sai->dma_params_rx.maxburst = FSL_SAI_MAXBURST_RX; 627 sai->dma_params_tx.maxburst = FSL_SAI_MAXBURST_TX; 628 629 platform_set_drvdata(pdev, sai); 630 631 ret = devm_snd_soc_register_component(&pdev->dev, &fsl_component, 632 &fsl_sai_dai, 1); 633 if (ret) 634 return ret; 635 636 if (sai->sai_on_imx) 637 return imx_pcm_dma_init(pdev); 638 else 639 return devm_snd_dmaengine_pcm_register(&pdev->dev, NULL, 640 SND_DMAENGINE_PCM_FLAG_NO_RESIDUE); 641 } 642 643 static const struct of_device_id fsl_sai_ids[] = { 644 { .compatible = "fsl,vf610-sai", }, 645 { .compatible = "fsl,imx6sx-sai", }, 646 { /* sentinel */ } 647 }; 648 649 static struct platform_driver fsl_sai_driver = { 650 .probe = fsl_sai_probe, 651 .driver = { 652 .name = "fsl-sai", 653 .owner = THIS_MODULE, 654 .of_match_table = fsl_sai_ids, 655 }, 656 }; 657 module_platform_driver(fsl_sai_driver); 658 659 MODULE_DESCRIPTION("Freescale Soc SAI Interface"); 660 MODULE_AUTHOR("Xiubo Li, <Li.Xiubo@freescale.com>"); 661 MODULE_ALIAS("platform:fsl-sai"); 662 MODULE_LICENSE("GPL"); 663