Merge tag 'trace-v4.3' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux...
[deliverable/linux.git] / sound / soc / fsl / fsl_ssi.c
1 /*
2 * Freescale SSI ALSA SoC Digital Audio Interface (DAI) driver
3 *
4 * Author: Timur Tabi <timur@freescale.com>
5 *
6 * Copyright 2007-2010 Freescale Semiconductor, Inc.
7 *
8 * This file is licensed under the terms of the GNU General Public License
9 * version 2. This program is licensed "as is" without any warranty of any
10 * kind, whether express or implied.
11 *
12 *
13 * Some notes why imx-pcm-fiq is used instead of DMA on some boards:
14 *
15 * The i.MX SSI core has some nasty limitations in AC97 mode. While most
16 * sane processor vendors have a FIFO per AC97 slot, the i.MX has only
17 * one FIFO which combines all valid receive slots. We cannot even select
18 * which slots we want to receive. The WM9712 with which this driver
19 * was developed with always sends GPIO status data in slot 12 which
20 * we receive in our (PCM-) data stream. The only chance we have is to
21 * manually skip this data in the FIQ handler. With sampling rates different
22 * from 48000Hz not every frame has valid receive data, so the ratio
23 * between pcm data and GPIO status data changes. Our FIQ handler is not
24 * able to handle this, hence this driver only works with 48000Hz sampling
25 * rate.
26 * Reading and writing AC97 registers is another challenge. The core
27 * provides us status bits when the read register is updated with *another*
28 * value. When we read the same register two times (and the register still
29 * contains the same value) these status bits are not set. We work
30 * around this by not polling these bits but only wait a fixed delay.
31 */
32
33 #include <linux/init.h>
34 #include <linux/io.h>
35 #include <linux/module.h>
36 #include <linux/interrupt.h>
37 #include <linux/clk.h>
38 #include <linux/device.h>
39 #include <linux/delay.h>
40 #include <linux/slab.h>
41 #include <linux/spinlock.h>
42 #include <linux/of.h>
43 #include <linux/of_address.h>
44 #include <linux/of_irq.h>
45 #include <linux/of_platform.h>
46
47 #include <sound/core.h>
48 #include <sound/pcm.h>
49 #include <sound/pcm_params.h>
50 #include <sound/initval.h>
51 #include <sound/soc.h>
52 #include <sound/dmaengine_pcm.h>
53
54 #include "fsl_ssi.h"
55 #include "imx-pcm.h"
56
57 /**
58 * FSLSSI_I2S_RATES: sample rates supported by the I2S
59 *
60 * This driver currently only supports the SSI running in I2S slave mode,
61 * which means the codec determines the sample rate. Therefore, we tell
62 * ALSA that we support all rates and let the codec driver decide what rates
63 * are really supported.
64 */
65 #define FSLSSI_I2S_RATES SNDRV_PCM_RATE_CONTINUOUS
66
67 /**
68 * FSLSSI_I2S_FORMATS: audio formats supported by the SSI
69 *
70 * The SSI has a limitation in that the samples must be in the same byte
71 * order as the host CPU. This is because when multiple bytes are written
72 * to the STX register, the bytes and bits must be written in the same
73 * order. The STX is a shift register, so all the bits need to be aligned
74 * (bit-endianness must match byte-endianness). Processors typically write
75 * the bits within a byte in the same order that the bytes of a word are
76 * written in. So if the host CPU is big-endian, then only big-endian
77 * samples will be written to STX properly.
78 */
79 #ifdef __BIG_ENDIAN
80 #define FSLSSI_I2S_FORMATS (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_BE | \
81 SNDRV_PCM_FMTBIT_S18_3BE | SNDRV_PCM_FMTBIT_S20_3BE | \
82 SNDRV_PCM_FMTBIT_S24_3BE | SNDRV_PCM_FMTBIT_S24_BE)
83 #else
84 #define FSLSSI_I2S_FORMATS (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_LE | \
85 SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S20_3LE | \
86 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_LE)
87 #endif
88
89 #define FSLSSI_SIER_DBG_RX_FLAGS (CCSR_SSI_SIER_RFF0_EN | \
90 CCSR_SSI_SIER_RLS_EN | CCSR_SSI_SIER_RFS_EN | \
91 CCSR_SSI_SIER_ROE0_EN | CCSR_SSI_SIER_RFRC_EN)
92 #define FSLSSI_SIER_DBG_TX_FLAGS (CCSR_SSI_SIER_TFE0_EN | \
93 CCSR_SSI_SIER_TLS_EN | CCSR_SSI_SIER_TFS_EN | \
94 CCSR_SSI_SIER_TUE0_EN | CCSR_SSI_SIER_TFRC_EN)
95
96 enum fsl_ssi_type {
97 FSL_SSI_MCP8610,
98 FSL_SSI_MX21,
99 FSL_SSI_MX35,
100 FSL_SSI_MX51,
101 };
102
103 struct fsl_ssi_reg_val {
104 u32 sier;
105 u32 srcr;
106 u32 stcr;
107 u32 scr;
108 };
109
110 struct fsl_ssi_rxtx_reg_val {
111 struct fsl_ssi_reg_val rx;
112 struct fsl_ssi_reg_val tx;
113 };
114 static const struct regmap_config fsl_ssi_regconfig = {
115 .max_register = CCSR_SSI_SACCDIS,
116 .reg_bits = 32,
117 .val_bits = 32,
118 .reg_stride = 4,
119 .val_format_endian = REGMAP_ENDIAN_NATIVE,
120 };
121
122 struct fsl_ssi_soc_data {
123 bool imx;
124 bool offline_config;
125 u32 sisr_write_mask;
126 };
127
128 /**
129 * fsl_ssi_private: per-SSI private data
130 *
131 * @reg: Pointer to the regmap registers
132 * @irq: IRQ of this SSI
133 * @cpu_dai_drv: CPU DAI driver for this device
134 *
135 * @dai_fmt: DAI configuration this device is currently used with
136 * @i2s_mode: i2s and network mode configuration of the device. Is used to
137 * switch between normal and i2s/network mode
138 * mode depending on the number of channels
139 * @use_dma: DMA is used or FIQ with stream filter
140 * @use_dual_fifo: DMA with support for both FIFOs used
141 * @fifo_deph: Depth of the SSI FIFOs
142 * @rxtx_reg_val: Specific register settings for receive/transmit configuration
143 *
144 * @clk: SSI clock
145 * @baudclk: SSI baud clock for master mode
146 * @baudclk_streams: Active streams that are using baudclk
147 * @bitclk_freq: bitclock frequency set by .set_dai_sysclk
148 *
149 * @dma_params_tx: DMA transmit parameters
150 * @dma_params_rx: DMA receive parameters
151 * @ssi_phys: physical address of the SSI registers
152 *
153 * @fiq_params: FIQ stream filtering parameters
154 *
155 * @pdev: Pointer to pdev used for deprecated fsl-ssi sound card
156 *
157 * @dbg_stats: Debugging statistics
158 *
159 * @soc: SoC specific data
160 */
161 struct fsl_ssi_private {
162 struct regmap *regs;
163 int irq;
164 struct snd_soc_dai_driver cpu_dai_drv;
165
166 unsigned int dai_fmt;
167 u8 i2s_mode;
168 bool use_dma;
169 bool use_dual_fifo;
170 bool has_ipg_clk_name;
171 unsigned int fifo_depth;
172 struct fsl_ssi_rxtx_reg_val rxtx_reg_val;
173
174 struct clk *clk;
175 struct clk *baudclk;
176 unsigned int baudclk_streams;
177 unsigned int bitclk_freq;
178
179 /* DMA params */
180 struct snd_dmaengine_dai_dma_data dma_params_tx;
181 struct snd_dmaengine_dai_dma_data dma_params_rx;
182 dma_addr_t ssi_phys;
183
184 /* params for non-dma FIQ stream filtered mode */
185 struct imx_pcm_fiq_params fiq_params;
186
187 /* Used when using fsl-ssi as sound-card. This is only used by ppc and
188 * should be replaced with simple-sound-card. */
189 struct platform_device *pdev;
190
191 struct fsl_ssi_dbg dbg_stats;
192
193 const struct fsl_ssi_soc_data *soc;
194 };
195
196 /*
197 * imx51 and later SoCs have a slightly different IP that allows the
198 * SSI configuration while the SSI unit is running.
199 *
200 * More important, it is necessary on those SoCs to configure the
201 * sperate TX/RX DMA bits just before starting the stream
202 * (fsl_ssi_trigger). The SDMA unit has to be configured before fsl_ssi
203 * sends any DMA requests to the SDMA unit, otherwise it is not defined
204 * how the SDMA unit handles the DMA request.
205 *
206 * SDMA units are present on devices starting at imx35 but the imx35
207 * reference manual states that the DMA bits should not be changed
208 * while the SSI unit is running (SSIEN). So we support the necessary
209 * online configuration of fsl-ssi starting at imx51.
210 */
211
212 static struct fsl_ssi_soc_data fsl_ssi_mpc8610 = {
213 .imx = false,
214 .offline_config = true,
215 .sisr_write_mask = CCSR_SSI_SISR_RFRC | CCSR_SSI_SISR_TFRC |
216 CCSR_SSI_SISR_ROE0 | CCSR_SSI_SISR_ROE1 |
217 CCSR_SSI_SISR_TUE0 | CCSR_SSI_SISR_TUE1,
218 };
219
220 static struct fsl_ssi_soc_data fsl_ssi_imx21 = {
221 .imx = true,
222 .offline_config = true,
223 .sisr_write_mask = 0,
224 };
225
226 static struct fsl_ssi_soc_data fsl_ssi_imx35 = {
227 .imx = true,
228 .offline_config = true,
229 .sisr_write_mask = CCSR_SSI_SISR_RFRC | CCSR_SSI_SISR_TFRC |
230 CCSR_SSI_SISR_ROE0 | CCSR_SSI_SISR_ROE1 |
231 CCSR_SSI_SISR_TUE0 | CCSR_SSI_SISR_TUE1,
232 };
233
234 static struct fsl_ssi_soc_data fsl_ssi_imx51 = {
235 .imx = true,
236 .offline_config = false,
237 .sisr_write_mask = CCSR_SSI_SISR_ROE0 | CCSR_SSI_SISR_ROE1 |
238 CCSR_SSI_SISR_TUE0 | CCSR_SSI_SISR_TUE1,
239 };
240
241 static const struct of_device_id fsl_ssi_ids[] = {
242 { .compatible = "fsl,mpc8610-ssi", .data = &fsl_ssi_mpc8610 },
243 { .compatible = "fsl,imx51-ssi", .data = &fsl_ssi_imx51 },
244 { .compatible = "fsl,imx35-ssi", .data = &fsl_ssi_imx35 },
245 { .compatible = "fsl,imx21-ssi", .data = &fsl_ssi_imx21 },
246 {}
247 };
248 MODULE_DEVICE_TABLE(of, fsl_ssi_ids);
249
250 static bool fsl_ssi_is_ac97(struct fsl_ssi_private *ssi_private)
251 {
252 return !!(ssi_private->dai_fmt & SND_SOC_DAIFMT_AC97);
253 }
254
255 static bool fsl_ssi_is_i2s_master(struct fsl_ssi_private *ssi_private)
256 {
257 return (ssi_private->dai_fmt & SND_SOC_DAIFMT_MASTER_MASK) ==
258 SND_SOC_DAIFMT_CBS_CFS;
259 }
260
261 static bool fsl_ssi_is_i2s_cbm_cfs(struct fsl_ssi_private *ssi_private)
262 {
263 return (ssi_private->dai_fmt & SND_SOC_DAIFMT_MASTER_MASK) ==
264 SND_SOC_DAIFMT_CBM_CFS;
265 }
266 /**
267 * fsl_ssi_isr: SSI interrupt handler
268 *
269 * Although it's possible to use the interrupt handler to send and receive
270 * data to/from the SSI, we use the DMA instead. Programming is more
271 * complicated, but the performance is much better.
272 *
273 * This interrupt handler is used only to gather statistics.
274 *
275 * @irq: IRQ of the SSI device
276 * @dev_id: pointer to the ssi_private structure for this SSI device
277 */
278 static irqreturn_t fsl_ssi_isr(int irq, void *dev_id)
279 {
280 struct fsl_ssi_private *ssi_private = dev_id;
281 struct regmap *regs = ssi_private->regs;
282 __be32 sisr;
283 __be32 sisr2;
284
285 /* We got an interrupt, so read the status register to see what we
286 were interrupted for. We mask it with the Interrupt Enable register
287 so that we only check for events that we're interested in.
288 */
289 regmap_read(regs, CCSR_SSI_SISR, &sisr);
290
291 sisr2 = sisr & ssi_private->soc->sisr_write_mask;
292 /* Clear the bits that we set */
293 if (sisr2)
294 regmap_write(regs, CCSR_SSI_SISR, sisr2);
295
296 fsl_ssi_dbg_isr(&ssi_private->dbg_stats, sisr);
297
298 return IRQ_HANDLED;
299 }
300
301 /*
302 * Enable/Disable all rx/tx config flags at once.
303 */
304 static void fsl_ssi_rxtx_config(struct fsl_ssi_private *ssi_private,
305 bool enable)
306 {
307 struct regmap *regs = ssi_private->regs;
308 struct fsl_ssi_rxtx_reg_val *vals = &ssi_private->rxtx_reg_val;
309
310 if (enable) {
311 regmap_update_bits(regs, CCSR_SSI_SIER,
312 vals->rx.sier | vals->tx.sier,
313 vals->rx.sier | vals->tx.sier);
314 regmap_update_bits(regs, CCSR_SSI_SRCR,
315 vals->rx.srcr | vals->tx.srcr,
316 vals->rx.srcr | vals->tx.srcr);
317 regmap_update_bits(regs, CCSR_SSI_STCR,
318 vals->rx.stcr | vals->tx.stcr,
319 vals->rx.stcr | vals->tx.stcr);
320 } else {
321 regmap_update_bits(regs, CCSR_SSI_SRCR,
322 vals->rx.srcr | vals->tx.srcr, 0);
323 regmap_update_bits(regs, CCSR_SSI_STCR,
324 vals->rx.stcr | vals->tx.stcr, 0);
325 regmap_update_bits(regs, CCSR_SSI_SIER,
326 vals->rx.sier | vals->tx.sier, 0);
327 }
328 }
329
330 /*
331 * Calculate the bits that have to be disabled for the current stream that is
332 * getting disabled. This keeps the bits enabled that are necessary for the
333 * second stream to work if 'stream_active' is true.
334 *
335 * Detailed calculation:
336 * These are the values that need to be active after disabling. For non-active
337 * second stream, this is 0:
338 * vals_stream * !!stream_active
339 *
340 * The following computes the overall differences between the setup for the
341 * to-disable stream and the active stream, a simple XOR:
342 * vals_disable ^ (vals_stream * !!(stream_active))
343 *
344 * The full expression adds a mask on all values we care about
345 */
346 #define fsl_ssi_disable_val(vals_disable, vals_stream, stream_active) \
347 ((vals_disable) & \
348 ((vals_disable) ^ ((vals_stream) * (u32)!!(stream_active))))
349
350 /*
351 * Enable/Disable a ssi configuration. You have to pass either
352 * ssi_private->rxtx_reg_val.rx or tx as vals parameter.
353 */
354 static void fsl_ssi_config(struct fsl_ssi_private *ssi_private, bool enable,
355 struct fsl_ssi_reg_val *vals)
356 {
357 struct regmap *regs = ssi_private->regs;
358 struct fsl_ssi_reg_val *avals;
359 int nr_active_streams;
360 u32 scr_val;
361 int keep_active;
362
363 regmap_read(regs, CCSR_SSI_SCR, &scr_val);
364
365 nr_active_streams = !!(scr_val & CCSR_SSI_SCR_TE) +
366 !!(scr_val & CCSR_SSI_SCR_RE);
367
368 if (nr_active_streams - 1 > 0)
369 keep_active = 1;
370 else
371 keep_active = 0;
372
373 /* Find the other direction values rx or tx which we do not want to
374 * modify */
375 if (&ssi_private->rxtx_reg_val.rx == vals)
376 avals = &ssi_private->rxtx_reg_val.tx;
377 else
378 avals = &ssi_private->rxtx_reg_val.rx;
379
380 /* If vals should be disabled, start with disabling the unit */
381 if (!enable) {
382 u32 scr = fsl_ssi_disable_val(vals->scr, avals->scr,
383 keep_active);
384 regmap_update_bits(regs, CCSR_SSI_SCR, scr, 0);
385 }
386
387 /*
388 * We are running on a SoC which does not support online SSI
389 * reconfiguration, so we have to enable all necessary flags at once
390 * even if we do not use them later (capture and playback configuration)
391 */
392 if (ssi_private->soc->offline_config) {
393 if ((enable && !nr_active_streams) ||
394 (!enable && !keep_active))
395 fsl_ssi_rxtx_config(ssi_private, enable);
396
397 goto config_done;
398 }
399
400 /*
401 * Configure single direction units while the SSI unit is running
402 * (online configuration)
403 */
404 if (enable) {
405 regmap_update_bits(regs, CCSR_SSI_SIER, vals->sier, vals->sier);
406 regmap_update_bits(regs, CCSR_SSI_SRCR, vals->srcr, vals->srcr);
407 regmap_update_bits(regs, CCSR_SSI_STCR, vals->stcr, vals->stcr);
408 } else {
409 u32 sier;
410 u32 srcr;
411 u32 stcr;
412
413 /*
414 * Disabling the necessary flags for one of rx/tx while the
415 * other stream is active is a little bit more difficult. We
416 * have to disable only those flags that differ between both
417 * streams (rx XOR tx) and that are set in the stream that is
418 * disabled now. Otherwise we could alter flags of the other
419 * stream
420 */
421
422 /* These assignments are simply vals without bits set in avals*/
423 sier = fsl_ssi_disable_val(vals->sier, avals->sier,
424 keep_active);
425 srcr = fsl_ssi_disable_val(vals->srcr, avals->srcr,
426 keep_active);
427 stcr = fsl_ssi_disable_val(vals->stcr, avals->stcr,
428 keep_active);
429
430 regmap_update_bits(regs, CCSR_SSI_SRCR, srcr, 0);
431 regmap_update_bits(regs, CCSR_SSI_STCR, stcr, 0);
432 regmap_update_bits(regs, CCSR_SSI_SIER, sier, 0);
433 }
434
435 config_done:
436 /* Enabling of subunits is done after configuration */
437 if (enable)
438 regmap_update_bits(regs, CCSR_SSI_SCR, vals->scr, vals->scr);
439 }
440
441
442 static void fsl_ssi_rx_config(struct fsl_ssi_private *ssi_private, bool enable)
443 {
444 fsl_ssi_config(ssi_private, enable, &ssi_private->rxtx_reg_val.rx);
445 }
446
447 static void fsl_ssi_tx_config(struct fsl_ssi_private *ssi_private, bool enable)
448 {
449 fsl_ssi_config(ssi_private, enable, &ssi_private->rxtx_reg_val.tx);
450 }
451
452 /*
453 * Setup rx/tx register values used to enable/disable the streams. These will
454 * be used later in fsl_ssi_config to setup the streams without the need to
455 * check for all different SSI modes.
456 */
457 static void fsl_ssi_setup_reg_vals(struct fsl_ssi_private *ssi_private)
458 {
459 struct fsl_ssi_rxtx_reg_val *reg = &ssi_private->rxtx_reg_val;
460
461 reg->rx.sier = CCSR_SSI_SIER_RFF0_EN;
462 reg->rx.srcr = CCSR_SSI_SRCR_RFEN0;
463 reg->rx.scr = 0;
464 reg->tx.sier = CCSR_SSI_SIER_TFE0_EN;
465 reg->tx.stcr = CCSR_SSI_STCR_TFEN0;
466 reg->tx.scr = 0;
467
468 if (!fsl_ssi_is_ac97(ssi_private)) {
469 reg->rx.scr = CCSR_SSI_SCR_SSIEN | CCSR_SSI_SCR_RE;
470 reg->rx.sier |= CCSR_SSI_SIER_RFF0_EN;
471 reg->tx.scr = CCSR_SSI_SCR_SSIEN | CCSR_SSI_SCR_TE;
472 reg->tx.sier |= CCSR_SSI_SIER_TFE0_EN;
473 }
474
475 if (ssi_private->use_dma) {
476 reg->rx.sier |= CCSR_SSI_SIER_RDMAE;
477 reg->tx.sier |= CCSR_SSI_SIER_TDMAE;
478 } else {
479 reg->rx.sier |= CCSR_SSI_SIER_RIE;
480 reg->tx.sier |= CCSR_SSI_SIER_TIE;
481 }
482
483 reg->rx.sier |= FSLSSI_SIER_DBG_RX_FLAGS;
484 reg->tx.sier |= FSLSSI_SIER_DBG_TX_FLAGS;
485 }
486
487 static void fsl_ssi_setup_ac97(struct fsl_ssi_private *ssi_private)
488 {
489 struct regmap *regs = ssi_private->regs;
490
491 /*
492 * Setup the clock control register
493 */
494 regmap_write(regs, CCSR_SSI_STCCR,
495 CCSR_SSI_SxCCR_WL(17) | CCSR_SSI_SxCCR_DC(13));
496 regmap_write(regs, CCSR_SSI_SRCCR,
497 CCSR_SSI_SxCCR_WL(17) | CCSR_SSI_SxCCR_DC(13));
498
499 /*
500 * Enable AC97 mode and startup the SSI
501 */
502 regmap_write(regs, CCSR_SSI_SACNT,
503 CCSR_SSI_SACNT_AC97EN | CCSR_SSI_SACNT_FV);
504 regmap_write(regs, CCSR_SSI_SACCDIS, 0xff);
505 regmap_write(regs, CCSR_SSI_SACCEN, 0x300);
506
507 /*
508 * Enable SSI, Transmit and Receive. AC97 has to communicate with the
509 * codec before a stream is started.
510 */
511 regmap_update_bits(regs, CCSR_SSI_SCR,
512 CCSR_SSI_SCR_SSIEN | CCSR_SSI_SCR_TE | CCSR_SSI_SCR_RE,
513 CCSR_SSI_SCR_SSIEN | CCSR_SSI_SCR_TE | CCSR_SSI_SCR_RE);
514
515 regmap_write(regs, CCSR_SSI_SOR, CCSR_SSI_SOR_WAIT(3));
516 }
517
518 /**
519 * fsl_ssi_startup: create a new substream
520 *
521 * This is the first function called when a stream is opened.
522 *
523 * If this is the first stream open, then grab the IRQ and program most of
524 * the SSI registers.
525 */
526 static int fsl_ssi_startup(struct snd_pcm_substream *substream,
527 struct snd_soc_dai *dai)
528 {
529 struct snd_soc_pcm_runtime *rtd = substream->private_data;
530 struct fsl_ssi_private *ssi_private =
531 snd_soc_dai_get_drvdata(rtd->cpu_dai);
532 int ret;
533
534 ret = clk_prepare_enable(ssi_private->clk);
535 if (ret)
536 return ret;
537
538 /* When using dual fifo mode, it is safer to ensure an even period
539 * size. If appearing to an odd number while DMA always starts its
540 * task from fifo0, fifo1 would be neglected at the end of each
541 * period. But SSI would still access fifo1 with an invalid data.
542 */
543 if (ssi_private->use_dual_fifo)
544 snd_pcm_hw_constraint_step(substream->runtime, 0,
545 SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 2);
546
547 return 0;
548 }
549
550 /**
551 * fsl_ssi_shutdown: shutdown the SSI
552 *
553 */
554 static void fsl_ssi_shutdown(struct snd_pcm_substream *substream,
555 struct snd_soc_dai *dai)
556 {
557 struct snd_soc_pcm_runtime *rtd = substream->private_data;
558 struct fsl_ssi_private *ssi_private =
559 snd_soc_dai_get_drvdata(rtd->cpu_dai);
560
561 clk_disable_unprepare(ssi_private->clk);
562
563 }
564
565 /**
566 * fsl_ssi_set_bclk - configure Digital Audio Interface bit clock
567 *
568 * Note: This function can be only called when using SSI as DAI master
569 *
570 * Quick instruction for parameters:
571 * freq: Output BCLK frequency = samplerate * 32 (fixed) * channels
572 * dir: SND_SOC_CLOCK_OUT -> TxBCLK, SND_SOC_CLOCK_IN -> RxBCLK.
573 */
574 static int fsl_ssi_set_bclk(struct snd_pcm_substream *substream,
575 struct snd_soc_dai *cpu_dai,
576 struct snd_pcm_hw_params *hw_params)
577 {
578 struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
579 struct regmap *regs = ssi_private->regs;
580 int synchronous = ssi_private->cpu_dai_drv.symmetric_rates, ret;
581 u32 pm = 999, div2, psr, stccr, mask, afreq, factor, i;
582 unsigned long clkrate, baudrate, tmprate;
583 u64 sub, savesub = 100000;
584 unsigned int freq;
585 bool baudclk_is_used;
586
587 /* Prefer the explicitly set bitclock frequency */
588 if (ssi_private->bitclk_freq)
589 freq = ssi_private->bitclk_freq;
590 else
591 freq = params_channels(hw_params) * 32 * params_rate(hw_params);
592
593 /* Don't apply it to any non-baudclk circumstance */
594 if (IS_ERR(ssi_private->baudclk))
595 return -EINVAL;
596
597 baudclk_is_used = ssi_private->baudclk_streams & ~(BIT(substream->stream));
598
599 /* It should be already enough to divide clock by setting pm alone */
600 psr = 0;
601 div2 = 0;
602
603 factor = (div2 + 1) * (7 * psr + 1) * 2;
604
605 for (i = 0; i < 255; i++) {
606 tmprate = freq * factor * (i + 1);
607
608 if (baudclk_is_used)
609 clkrate = clk_get_rate(ssi_private->baudclk);
610 else
611 clkrate = clk_round_rate(ssi_private->baudclk, tmprate);
612
613 /*
614 * Hardware limitation: The bclk rate must be
615 * never greater than 1/5 IPG clock rate
616 */
617 if (clkrate * 5 > clk_get_rate(ssi_private->clk))
618 continue;
619
620 clkrate /= factor;
621 afreq = clkrate / (i + 1);
622
623 if (freq == afreq)
624 sub = 0;
625 else if (freq / afreq == 1)
626 sub = freq - afreq;
627 else if (afreq / freq == 1)
628 sub = afreq - freq;
629 else
630 continue;
631
632 /* Calculate the fraction */
633 sub *= 100000;
634 do_div(sub, freq);
635
636 if (sub < savesub && !(i == 0 && psr == 0 && div2 == 0)) {
637 baudrate = tmprate;
638 savesub = sub;
639 pm = i;
640 }
641
642 /* We are lucky */
643 if (savesub == 0)
644 break;
645 }
646
647 /* No proper pm found if it is still remaining the initial value */
648 if (pm == 999) {
649 dev_err(cpu_dai->dev, "failed to handle the required sysclk\n");
650 return -EINVAL;
651 }
652
653 stccr = CCSR_SSI_SxCCR_PM(pm + 1) | (div2 ? CCSR_SSI_SxCCR_DIV2 : 0) |
654 (psr ? CCSR_SSI_SxCCR_PSR : 0);
655 mask = CCSR_SSI_SxCCR_PM_MASK | CCSR_SSI_SxCCR_DIV2 |
656 CCSR_SSI_SxCCR_PSR;
657
658 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK || synchronous)
659 regmap_update_bits(regs, CCSR_SSI_STCCR, mask, stccr);
660 else
661 regmap_update_bits(regs, CCSR_SSI_SRCCR, mask, stccr);
662
663 if (!baudclk_is_used) {
664 ret = clk_set_rate(ssi_private->baudclk, baudrate);
665 if (ret) {
666 dev_err(cpu_dai->dev, "failed to set baudclk rate\n");
667 return -EINVAL;
668 }
669 }
670
671 return 0;
672 }
673
674 static int fsl_ssi_set_dai_sysclk(struct snd_soc_dai *cpu_dai,
675 int clk_id, unsigned int freq, int dir)
676 {
677 struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
678
679 ssi_private->bitclk_freq = freq;
680
681 return 0;
682 }
683
684 /**
685 * fsl_ssi_hw_params - program the sample size
686 *
687 * Most of the SSI registers have been programmed in the startup function,
688 * but the word length must be programmed here. Unfortunately, programming
689 * the SxCCR.WL bits requires the SSI to be temporarily disabled. This can
690 * cause a problem with supporting simultaneous playback and capture. If
691 * the SSI is already playing a stream, then that stream may be temporarily
692 * stopped when you start capture.
693 *
694 * Note: The SxCCR.DC and SxCCR.PM bits are only used if the SSI is the
695 * clock master.
696 */
697 static int fsl_ssi_hw_params(struct snd_pcm_substream *substream,
698 struct snd_pcm_hw_params *hw_params, struct snd_soc_dai *cpu_dai)
699 {
700 struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
701 struct regmap *regs = ssi_private->regs;
702 unsigned int channels = params_channels(hw_params);
703 unsigned int sample_size =
704 snd_pcm_format_width(params_format(hw_params));
705 u32 wl = CCSR_SSI_SxCCR_WL(sample_size);
706 int ret;
707 u32 scr_val;
708 int enabled;
709
710 regmap_read(regs, CCSR_SSI_SCR, &scr_val);
711 enabled = scr_val & CCSR_SSI_SCR_SSIEN;
712
713 /*
714 * If we're in synchronous mode, and the SSI is already enabled,
715 * then STCCR is already set properly.
716 */
717 if (enabled && ssi_private->cpu_dai_drv.symmetric_rates)
718 return 0;
719
720 if (fsl_ssi_is_i2s_master(ssi_private)) {
721 ret = fsl_ssi_set_bclk(substream, cpu_dai, hw_params);
722 if (ret)
723 return ret;
724
725 /* Do not enable the clock if it is already enabled */
726 if (!(ssi_private->baudclk_streams & BIT(substream->stream))) {
727 ret = clk_prepare_enable(ssi_private->baudclk);
728 if (ret)
729 return ret;
730
731 ssi_private->baudclk_streams |= BIT(substream->stream);
732 }
733 }
734
735 if (!fsl_ssi_is_ac97(ssi_private)) {
736 u8 i2smode;
737 /*
738 * Switch to normal net mode in order to have a frame sync
739 * signal every 32 bits instead of 16 bits
740 */
741 if (fsl_ssi_is_i2s_cbm_cfs(ssi_private) && sample_size == 16)
742 i2smode = CCSR_SSI_SCR_I2S_MODE_NORMAL |
743 CCSR_SSI_SCR_NET;
744 else
745 i2smode = ssi_private->i2s_mode;
746
747 regmap_update_bits(regs, CCSR_SSI_SCR,
748 CCSR_SSI_SCR_NET | CCSR_SSI_SCR_I2S_MODE_MASK,
749 channels == 1 ? 0 : i2smode);
750 }
751
752 /*
753 * FIXME: The documentation says that SxCCR[WL] should not be
754 * modified while the SSI is enabled. The only time this can
755 * happen is if we're trying to do simultaneous playback and
756 * capture in asynchronous mode. Unfortunately, I have been enable
757 * to get that to work at all on the P1022DS. Therefore, we don't
758 * bother to disable/enable the SSI when setting SxCCR[WL], because
759 * the SSI will stop anyway. Maybe one day, this will get fixed.
760 */
761
762 /* In synchronous mode, the SSI uses STCCR for capture */
763 if ((substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ||
764 ssi_private->cpu_dai_drv.symmetric_rates)
765 regmap_update_bits(regs, CCSR_SSI_STCCR, CCSR_SSI_SxCCR_WL_MASK,
766 wl);
767 else
768 regmap_update_bits(regs, CCSR_SSI_SRCCR, CCSR_SSI_SxCCR_WL_MASK,
769 wl);
770
771 return 0;
772 }
773
774 static int fsl_ssi_hw_free(struct snd_pcm_substream *substream,
775 struct snd_soc_dai *cpu_dai)
776 {
777 struct snd_soc_pcm_runtime *rtd = substream->private_data;
778 struct fsl_ssi_private *ssi_private =
779 snd_soc_dai_get_drvdata(rtd->cpu_dai);
780
781 if (fsl_ssi_is_i2s_master(ssi_private) &&
782 ssi_private->baudclk_streams & BIT(substream->stream)) {
783 clk_disable_unprepare(ssi_private->baudclk);
784 ssi_private->baudclk_streams &= ~BIT(substream->stream);
785 }
786
787 return 0;
788 }
789
790 static int _fsl_ssi_set_dai_fmt(struct device *dev,
791 struct fsl_ssi_private *ssi_private,
792 unsigned int fmt)
793 {
794 struct regmap *regs = ssi_private->regs;
795 u32 strcr = 0, stcr, srcr, scr, mask;
796 u8 wm;
797
798 ssi_private->dai_fmt = fmt;
799
800 if (fsl_ssi_is_i2s_master(ssi_private) && IS_ERR(ssi_private->baudclk)) {
801 dev_err(dev, "baudclk is missing which is necessary for master mode\n");
802 return -EINVAL;
803 }
804
805 fsl_ssi_setup_reg_vals(ssi_private);
806
807 regmap_read(regs, CCSR_SSI_SCR, &scr);
808 scr &= ~(CCSR_SSI_SCR_SYN | CCSR_SSI_SCR_I2S_MODE_MASK);
809 scr |= CCSR_SSI_SCR_SYNC_TX_FS;
810
811 mask = CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TFDIR | CCSR_SSI_STCR_TXDIR |
812 CCSR_SSI_STCR_TSCKP | CCSR_SSI_STCR_TFSI | CCSR_SSI_STCR_TFSL |
813 CCSR_SSI_STCR_TEFS;
814 regmap_read(regs, CCSR_SSI_STCR, &stcr);
815 regmap_read(regs, CCSR_SSI_SRCR, &srcr);
816 stcr &= ~mask;
817 srcr &= ~mask;
818
819 ssi_private->i2s_mode = CCSR_SSI_SCR_NET;
820 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
821 case SND_SOC_DAIFMT_I2S:
822 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
823 case SND_SOC_DAIFMT_CBM_CFS:
824 case SND_SOC_DAIFMT_CBS_CFS:
825 ssi_private->i2s_mode |= CCSR_SSI_SCR_I2S_MODE_MASTER;
826 regmap_update_bits(regs, CCSR_SSI_STCCR,
827 CCSR_SSI_SxCCR_DC_MASK,
828 CCSR_SSI_SxCCR_DC(2));
829 regmap_update_bits(regs, CCSR_SSI_SRCCR,
830 CCSR_SSI_SxCCR_DC_MASK,
831 CCSR_SSI_SxCCR_DC(2));
832 break;
833 case SND_SOC_DAIFMT_CBM_CFM:
834 ssi_private->i2s_mode |= CCSR_SSI_SCR_I2S_MODE_SLAVE;
835 break;
836 default:
837 return -EINVAL;
838 }
839
840 /* Data on rising edge of bclk, frame low, 1clk before data */
841 strcr |= CCSR_SSI_STCR_TFSI | CCSR_SSI_STCR_TSCKP |
842 CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TEFS;
843 break;
844 case SND_SOC_DAIFMT_LEFT_J:
845 /* Data on rising edge of bclk, frame high */
846 strcr |= CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TSCKP;
847 break;
848 case SND_SOC_DAIFMT_DSP_A:
849 /* Data on rising edge of bclk, frame high, 1clk before data */
850 strcr |= CCSR_SSI_STCR_TFSL | CCSR_SSI_STCR_TSCKP |
851 CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TEFS;
852 break;
853 case SND_SOC_DAIFMT_DSP_B:
854 /* Data on rising edge of bclk, frame high */
855 strcr |= CCSR_SSI_STCR_TFSL | CCSR_SSI_STCR_TSCKP |
856 CCSR_SSI_STCR_TXBIT0;
857 break;
858 case SND_SOC_DAIFMT_AC97:
859 ssi_private->i2s_mode |= CCSR_SSI_SCR_I2S_MODE_NORMAL;
860 break;
861 default:
862 return -EINVAL;
863 }
864 scr |= ssi_private->i2s_mode;
865
866 /* DAI clock inversion */
867 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
868 case SND_SOC_DAIFMT_NB_NF:
869 /* Nothing to do for both normal cases */
870 break;
871 case SND_SOC_DAIFMT_IB_NF:
872 /* Invert bit clock */
873 strcr ^= CCSR_SSI_STCR_TSCKP;
874 break;
875 case SND_SOC_DAIFMT_NB_IF:
876 /* Invert frame clock */
877 strcr ^= CCSR_SSI_STCR_TFSI;
878 break;
879 case SND_SOC_DAIFMT_IB_IF:
880 /* Invert both clocks */
881 strcr ^= CCSR_SSI_STCR_TSCKP;
882 strcr ^= CCSR_SSI_STCR_TFSI;
883 break;
884 default:
885 return -EINVAL;
886 }
887
888 /* DAI clock master masks */
889 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
890 case SND_SOC_DAIFMT_CBS_CFS:
891 strcr |= CCSR_SSI_STCR_TFDIR | CCSR_SSI_STCR_TXDIR;
892 scr |= CCSR_SSI_SCR_SYS_CLK_EN;
893 break;
894 case SND_SOC_DAIFMT_CBM_CFM:
895 scr &= ~CCSR_SSI_SCR_SYS_CLK_EN;
896 break;
897 case SND_SOC_DAIFMT_CBM_CFS:
898 strcr &= ~CCSR_SSI_STCR_TXDIR;
899 strcr |= CCSR_SSI_STCR_TFDIR;
900 scr &= ~CCSR_SSI_SCR_SYS_CLK_EN;
901 break;
902 default:
903 if (!fsl_ssi_is_ac97(ssi_private))
904 return -EINVAL;
905 }
906
907 stcr |= strcr;
908 srcr |= strcr;
909
910 if (ssi_private->cpu_dai_drv.symmetric_rates
911 || fsl_ssi_is_ac97(ssi_private)) {
912 /* Need to clear RXDIR when using SYNC or AC97 mode */
913 srcr &= ~CCSR_SSI_SRCR_RXDIR;
914 scr |= CCSR_SSI_SCR_SYN;
915 }
916
917 regmap_write(regs, CCSR_SSI_STCR, stcr);
918 regmap_write(regs, CCSR_SSI_SRCR, srcr);
919 regmap_write(regs, CCSR_SSI_SCR, scr);
920
921 /*
922 * Set the watermark for transmit FIFI 0 and receive FIFO 0. We don't
923 * use FIFO 1. We program the transmit water to signal a DMA transfer
924 * if there are only two (or fewer) elements left in the FIFO. Two
925 * elements equals one frame (left channel, right channel). This value,
926 * however, depends on the depth of the transmit buffer.
927 *
928 * We set the watermark on the same level as the DMA burstsize. For
929 * fiq it is probably better to use the biggest possible watermark
930 * size.
931 */
932 if (ssi_private->use_dma)
933 wm = ssi_private->fifo_depth - 2;
934 else
935 wm = ssi_private->fifo_depth;
936
937 regmap_write(regs, CCSR_SSI_SFCSR,
938 CCSR_SSI_SFCSR_TFWM0(wm) | CCSR_SSI_SFCSR_RFWM0(wm) |
939 CCSR_SSI_SFCSR_TFWM1(wm) | CCSR_SSI_SFCSR_RFWM1(wm));
940
941 if (ssi_private->use_dual_fifo) {
942 regmap_update_bits(regs, CCSR_SSI_SRCR, CCSR_SSI_SRCR_RFEN1,
943 CCSR_SSI_SRCR_RFEN1);
944 regmap_update_bits(regs, CCSR_SSI_STCR, CCSR_SSI_STCR_TFEN1,
945 CCSR_SSI_STCR_TFEN1);
946 regmap_update_bits(regs, CCSR_SSI_SCR, CCSR_SSI_SCR_TCH_EN,
947 CCSR_SSI_SCR_TCH_EN);
948 }
949
950 if (fmt & SND_SOC_DAIFMT_AC97)
951 fsl_ssi_setup_ac97(ssi_private);
952
953 return 0;
954
955 }
956
957 /**
958 * fsl_ssi_set_dai_fmt - configure Digital Audio Interface Format.
959 */
960 static int fsl_ssi_set_dai_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt)
961 {
962 struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
963
964 return _fsl_ssi_set_dai_fmt(cpu_dai->dev, ssi_private, fmt);
965 }
966
967 /**
968 * fsl_ssi_set_dai_tdm_slot - set TDM slot number
969 *
970 * Note: This function can be only called when using SSI as DAI master
971 */
972 static int fsl_ssi_set_dai_tdm_slot(struct snd_soc_dai *cpu_dai, u32 tx_mask,
973 u32 rx_mask, int slots, int slot_width)
974 {
975 struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
976 struct regmap *regs = ssi_private->regs;
977 u32 val;
978
979 /* The slot number should be >= 2 if using Network mode or I2S mode */
980 regmap_read(regs, CCSR_SSI_SCR, &val);
981 val &= CCSR_SSI_SCR_I2S_MODE_MASK | CCSR_SSI_SCR_NET;
982 if (val && slots < 2) {
983 dev_err(cpu_dai->dev, "slot number should be >= 2 in I2S or NET\n");
984 return -EINVAL;
985 }
986
987 regmap_update_bits(regs, CCSR_SSI_STCCR, CCSR_SSI_SxCCR_DC_MASK,
988 CCSR_SSI_SxCCR_DC(slots));
989 regmap_update_bits(regs, CCSR_SSI_SRCCR, CCSR_SSI_SxCCR_DC_MASK,
990 CCSR_SSI_SxCCR_DC(slots));
991
992 /* The register SxMSKs needs SSI to provide essential clock due to
993 * hardware design. So we here temporarily enable SSI to set them.
994 */
995 regmap_read(regs, CCSR_SSI_SCR, &val);
996 val &= CCSR_SSI_SCR_SSIEN;
997 regmap_update_bits(regs, CCSR_SSI_SCR, CCSR_SSI_SCR_SSIEN,
998 CCSR_SSI_SCR_SSIEN);
999
1000 regmap_write(regs, CCSR_SSI_STMSK, ~tx_mask);
1001 regmap_write(regs, CCSR_SSI_SRMSK, ~rx_mask);
1002
1003 regmap_update_bits(regs, CCSR_SSI_SCR, CCSR_SSI_SCR_SSIEN, val);
1004
1005 return 0;
1006 }
1007
1008 /**
1009 * fsl_ssi_trigger: start and stop the DMA transfer.
1010 *
1011 * This function is called by ALSA to start, stop, pause, and resume the DMA
1012 * transfer of data.
1013 *
1014 * The DMA channel is in external master start and pause mode, which
1015 * means the SSI completely controls the flow of data.
1016 */
1017 static int fsl_ssi_trigger(struct snd_pcm_substream *substream, int cmd,
1018 struct snd_soc_dai *dai)
1019 {
1020 struct snd_soc_pcm_runtime *rtd = substream->private_data;
1021 struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(rtd->cpu_dai);
1022 struct regmap *regs = ssi_private->regs;
1023
1024 switch (cmd) {
1025 case SNDRV_PCM_TRIGGER_START:
1026 case SNDRV_PCM_TRIGGER_RESUME:
1027 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1028 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1029 fsl_ssi_tx_config(ssi_private, true);
1030 else
1031 fsl_ssi_rx_config(ssi_private, true);
1032 break;
1033
1034 case SNDRV_PCM_TRIGGER_STOP:
1035 case SNDRV_PCM_TRIGGER_SUSPEND:
1036 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1037 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1038 fsl_ssi_tx_config(ssi_private, false);
1039 else
1040 fsl_ssi_rx_config(ssi_private, false);
1041 break;
1042
1043 default:
1044 return -EINVAL;
1045 }
1046
1047 if (fsl_ssi_is_ac97(ssi_private)) {
1048 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1049 regmap_write(regs, CCSR_SSI_SOR, CCSR_SSI_SOR_TX_CLR);
1050 else
1051 regmap_write(regs, CCSR_SSI_SOR, CCSR_SSI_SOR_RX_CLR);
1052 }
1053
1054 return 0;
1055 }
1056
1057 static int fsl_ssi_dai_probe(struct snd_soc_dai *dai)
1058 {
1059 struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(dai);
1060
1061 if (ssi_private->soc->imx && ssi_private->use_dma) {
1062 dai->playback_dma_data = &ssi_private->dma_params_tx;
1063 dai->capture_dma_data = &ssi_private->dma_params_rx;
1064 }
1065
1066 return 0;
1067 }
1068
1069 static const struct snd_soc_dai_ops fsl_ssi_dai_ops = {
1070 .startup = fsl_ssi_startup,
1071 .shutdown = fsl_ssi_shutdown,
1072 .hw_params = fsl_ssi_hw_params,
1073 .hw_free = fsl_ssi_hw_free,
1074 .set_fmt = fsl_ssi_set_dai_fmt,
1075 .set_sysclk = fsl_ssi_set_dai_sysclk,
1076 .set_tdm_slot = fsl_ssi_set_dai_tdm_slot,
1077 .trigger = fsl_ssi_trigger,
1078 };
1079
1080 /* Template for the CPU dai driver structure */
1081 static struct snd_soc_dai_driver fsl_ssi_dai_template = {
1082 .probe = fsl_ssi_dai_probe,
1083 .playback = {
1084 .stream_name = "CPU-Playback",
1085 .channels_min = 1,
1086 .channels_max = 2,
1087 .rates = FSLSSI_I2S_RATES,
1088 .formats = FSLSSI_I2S_FORMATS,
1089 },
1090 .capture = {
1091 .stream_name = "CPU-Capture",
1092 .channels_min = 1,
1093 .channels_max = 2,
1094 .rates = FSLSSI_I2S_RATES,
1095 .formats = FSLSSI_I2S_FORMATS,
1096 },
1097 .ops = &fsl_ssi_dai_ops,
1098 };
1099
1100 static const struct snd_soc_component_driver fsl_ssi_component = {
1101 .name = "fsl-ssi",
1102 };
1103
1104 static struct snd_soc_dai_driver fsl_ssi_ac97_dai = {
1105 .bus_control = true,
1106 .probe = fsl_ssi_dai_probe,
1107 .playback = {
1108 .stream_name = "AC97 Playback",
1109 .channels_min = 2,
1110 .channels_max = 2,
1111 .rates = SNDRV_PCM_RATE_8000_48000,
1112 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1113 },
1114 .capture = {
1115 .stream_name = "AC97 Capture",
1116 .channels_min = 2,
1117 .channels_max = 2,
1118 .rates = SNDRV_PCM_RATE_48000,
1119 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1120 },
1121 .ops = &fsl_ssi_dai_ops,
1122 };
1123
1124
1125 static struct fsl_ssi_private *fsl_ac97_data;
1126
1127 static void fsl_ssi_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
1128 unsigned short val)
1129 {
1130 struct regmap *regs = fsl_ac97_data->regs;
1131 unsigned int lreg;
1132 unsigned int lval;
1133 int ret;
1134
1135 if (reg > 0x7f)
1136 return;
1137
1138 ret = clk_prepare_enable(fsl_ac97_data->clk);
1139 if (ret) {
1140 pr_err("ac97 write clk_prepare_enable failed: %d\n",
1141 ret);
1142 return;
1143 }
1144
1145 lreg = reg << 12;
1146 regmap_write(regs, CCSR_SSI_SACADD, lreg);
1147
1148 lval = val << 4;
1149 regmap_write(regs, CCSR_SSI_SACDAT, lval);
1150
1151 regmap_update_bits(regs, CCSR_SSI_SACNT, CCSR_SSI_SACNT_RDWR_MASK,
1152 CCSR_SSI_SACNT_WR);
1153 udelay(100);
1154
1155 clk_disable_unprepare(fsl_ac97_data->clk);
1156 }
1157
1158 static unsigned short fsl_ssi_ac97_read(struct snd_ac97 *ac97,
1159 unsigned short reg)
1160 {
1161 struct regmap *regs = fsl_ac97_data->regs;
1162
1163 unsigned short val = -1;
1164 u32 reg_val;
1165 unsigned int lreg;
1166 int ret;
1167
1168 ret = clk_prepare_enable(fsl_ac97_data->clk);
1169 if (ret) {
1170 pr_err("ac97 read clk_prepare_enable failed: %d\n",
1171 ret);
1172 return -1;
1173 }
1174
1175 lreg = (reg & 0x7f) << 12;
1176 regmap_write(regs, CCSR_SSI_SACADD, lreg);
1177 regmap_update_bits(regs, CCSR_SSI_SACNT, CCSR_SSI_SACNT_RDWR_MASK,
1178 CCSR_SSI_SACNT_RD);
1179
1180 udelay(100);
1181
1182 regmap_read(regs, CCSR_SSI_SACDAT, &reg_val);
1183 val = (reg_val >> 4) & 0xffff;
1184
1185 clk_disable_unprepare(fsl_ac97_data->clk);
1186
1187 return val;
1188 }
1189
1190 static struct snd_ac97_bus_ops fsl_ssi_ac97_ops = {
1191 .read = fsl_ssi_ac97_read,
1192 .write = fsl_ssi_ac97_write,
1193 };
1194
1195 /**
1196 * Make every character in a string lower-case
1197 */
1198 static void make_lowercase(char *s)
1199 {
1200 char *p = s;
1201 char c;
1202
1203 while ((c = *p)) {
1204 if ((c >= 'A') && (c <= 'Z'))
1205 *p = c + ('a' - 'A');
1206 p++;
1207 }
1208 }
1209
1210 static int fsl_ssi_imx_probe(struct platform_device *pdev,
1211 struct fsl_ssi_private *ssi_private, void __iomem *iomem)
1212 {
1213 struct device_node *np = pdev->dev.of_node;
1214 u32 dmas[4];
1215 int ret;
1216
1217 if (ssi_private->has_ipg_clk_name)
1218 ssi_private->clk = devm_clk_get(&pdev->dev, "ipg");
1219 else
1220 ssi_private->clk = devm_clk_get(&pdev->dev, NULL);
1221 if (IS_ERR(ssi_private->clk)) {
1222 ret = PTR_ERR(ssi_private->clk);
1223 dev_err(&pdev->dev, "could not get clock: %d\n", ret);
1224 return ret;
1225 }
1226
1227 if (!ssi_private->has_ipg_clk_name) {
1228 ret = clk_prepare_enable(ssi_private->clk);
1229 if (ret) {
1230 dev_err(&pdev->dev, "clk_prepare_enable failed: %d\n", ret);
1231 return ret;
1232 }
1233 }
1234
1235 /* For those SLAVE implementations, we ignore non-baudclk cases
1236 * and, instead, abandon MASTER mode that needs baud clock.
1237 */
1238 ssi_private->baudclk = devm_clk_get(&pdev->dev, "baud");
1239 if (IS_ERR(ssi_private->baudclk))
1240 dev_dbg(&pdev->dev, "could not get baud clock: %ld\n",
1241 PTR_ERR(ssi_private->baudclk));
1242
1243 /*
1244 * We have burstsize be "fifo_depth - 2" to match the SSI
1245 * watermark setting in fsl_ssi_startup().
1246 */
1247 ssi_private->dma_params_tx.maxburst = ssi_private->fifo_depth - 2;
1248 ssi_private->dma_params_rx.maxburst = ssi_private->fifo_depth - 2;
1249 ssi_private->dma_params_tx.addr = ssi_private->ssi_phys + CCSR_SSI_STX0;
1250 ssi_private->dma_params_rx.addr = ssi_private->ssi_phys + CCSR_SSI_SRX0;
1251
1252 ret = of_property_read_u32_array(np, "dmas", dmas, 4);
1253 if (ssi_private->use_dma && !ret && dmas[2] == IMX_DMATYPE_SSI_DUAL) {
1254 ssi_private->use_dual_fifo = true;
1255 /* When using dual fifo mode, we need to keep watermark
1256 * as even numbers due to dma script limitation.
1257 */
1258 ssi_private->dma_params_tx.maxburst &= ~0x1;
1259 ssi_private->dma_params_rx.maxburst &= ~0x1;
1260 }
1261
1262 if (!ssi_private->use_dma) {
1263
1264 /*
1265 * Some boards use an incompatible codec. To get it
1266 * working, we are using imx-fiq-pcm-audio, that
1267 * can handle those codecs. DMA is not possible in this
1268 * situation.
1269 */
1270
1271 ssi_private->fiq_params.irq = ssi_private->irq;
1272 ssi_private->fiq_params.base = iomem;
1273 ssi_private->fiq_params.dma_params_rx =
1274 &ssi_private->dma_params_rx;
1275 ssi_private->fiq_params.dma_params_tx =
1276 &ssi_private->dma_params_tx;
1277
1278 ret = imx_pcm_fiq_init(pdev, &ssi_private->fiq_params);
1279 if (ret)
1280 goto error_pcm;
1281 } else {
1282 ret = imx_pcm_dma_init(pdev, IMX_SSI_DMABUF_SIZE);
1283 if (ret)
1284 goto error_pcm;
1285 }
1286
1287 return 0;
1288
1289 error_pcm:
1290
1291 if (!ssi_private->has_ipg_clk_name)
1292 clk_disable_unprepare(ssi_private->clk);
1293 return ret;
1294 }
1295
1296 static void fsl_ssi_imx_clean(struct platform_device *pdev,
1297 struct fsl_ssi_private *ssi_private)
1298 {
1299 if (!ssi_private->use_dma)
1300 imx_pcm_fiq_exit(pdev);
1301 if (!ssi_private->has_ipg_clk_name)
1302 clk_disable_unprepare(ssi_private->clk);
1303 }
1304
1305 static int fsl_ssi_probe(struct platform_device *pdev)
1306 {
1307 struct fsl_ssi_private *ssi_private;
1308 int ret = 0;
1309 struct device_node *np = pdev->dev.of_node;
1310 const struct of_device_id *of_id;
1311 const char *p, *sprop;
1312 const uint32_t *iprop;
1313 struct resource *res;
1314 void __iomem *iomem;
1315 char name[64];
1316
1317 of_id = of_match_device(fsl_ssi_ids, &pdev->dev);
1318 if (!of_id || !of_id->data)
1319 return -EINVAL;
1320
1321 ssi_private = devm_kzalloc(&pdev->dev, sizeof(*ssi_private),
1322 GFP_KERNEL);
1323 if (!ssi_private) {
1324 dev_err(&pdev->dev, "could not allocate DAI object\n");
1325 return -ENOMEM;
1326 }
1327
1328 ssi_private->soc = of_id->data;
1329
1330 sprop = of_get_property(np, "fsl,mode", NULL);
1331 if (sprop) {
1332 if (!strcmp(sprop, "ac97-slave"))
1333 ssi_private->dai_fmt = SND_SOC_DAIFMT_AC97;
1334 }
1335
1336 ssi_private->use_dma = !of_property_read_bool(np,
1337 "fsl,fiq-stream-filter");
1338
1339 if (fsl_ssi_is_ac97(ssi_private)) {
1340 memcpy(&ssi_private->cpu_dai_drv, &fsl_ssi_ac97_dai,
1341 sizeof(fsl_ssi_ac97_dai));
1342
1343 fsl_ac97_data = ssi_private;
1344
1345 ret = snd_soc_set_ac97_ops_of_reset(&fsl_ssi_ac97_ops, pdev);
1346 if (ret) {
1347 dev_err(&pdev->dev, "could not set AC'97 ops\n");
1348 return ret;
1349 }
1350 } else {
1351 /* Initialize this copy of the CPU DAI driver structure */
1352 memcpy(&ssi_private->cpu_dai_drv, &fsl_ssi_dai_template,
1353 sizeof(fsl_ssi_dai_template));
1354 }
1355 ssi_private->cpu_dai_drv.name = dev_name(&pdev->dev);
1356
1357 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1358 iomem = devm_ioremap_resource(&pdev->dev, res);
1359 if (IS_ERR(iomem))
1360 return PTR_ERR(iomem);
1361 ssi_private->ssi_phys = res->start;
1362
1363 ret = of_property_match_string(np, "clock-names", "ipg");
1364 if (ret < 0) {
1365 ssi_private->has_ipg_clk_name = false;
1366 ssi_private->regs = devm_regmap_init_mmio(&pdev->dev, iomem,
1367 &fsl_ssi_regconfig);
1368 } else {
1369 ssi_private->has_ipg_clk_name = true;
1370 ssi_private->regs = devm_regmap_init_mmio_clk(&pdev->dev,
1371 "ipg", iomem, &fsl_ssi_regconfig);
1372 }
1373 if (IS_ERR(ssi_private->regs)) {
1374 dev_err(&pdev->dev, "Failed to init register map\n");
1375 return PTR_ERR(ssi_private->regs);
1376 }
1377
1378 ssi_private->irq = platform_get_irq(pdev, 0);
1379 if (ssi_private->irq < 0) {
1380 dev_err(&pdev->dev, "no irq for node %s\n", pdev->name);
1381 return ssi_private->irq;
1382 }
1383
1384 /* Are the RX and the TX clocks locked? */
1385 if (!of_find_property(np, "fsl,ssi-asynchronous", NULL)) {
1386 if (!fsl_ssi_is_ac97(ssi_private))
1387 ssi_private->cpu_dai_drv.symmetric_rates = 1;
1388
1389 ssi_private->cpu_dai_drv.symmetric_channels = 1;
1390 ssi_private->cpu_dai_drv.symmetric_samplebits = 1;
1391 }
1392
1393 /* Determine the FIFO depth. */
1394 iprop = of_get_property(np, "fsl,fifo-depth", NULL);
1395 if (iprop)
1396 ssi_private->fifo_depth = be32_to_cpup(iprop);
1397 else
1398 /* Older 8610 DTs didn't have the fifo-depth property */
1399 ssi_private->fifo_depth = 8;
1400
1401 dev_set_drvdata(&pdev->dev, ssi_private);
1402
1403 if (ssi_private->soc->imx) {
1404 ret = fsl_ssi_imx_probe(pdev, ssi_private, iomem);
1405 if (ret)
1406 return ret;
1407 }
1408
1409 ret = devm_snd_soc_register_component(&pdev->dev, &fsl_ssi_component,
1410 &ssi_private->cpu_dai_drv, 1);
1411 if (ret) {
1412 dev_err(&pdev->dev, "failed to register DAI: %d\n", ret);
1413 goto error_asoc_register;
1414 }
1415
1416 if (ssi_private->use_dma) {
1417 ret = devm_request_irq(&pdev->dev, ssi_private->irq,
1418 fsl_ssi_isr, 0, dev_name(&pdev->dev),
1419 ssi_private);
1420 if (ret < 0) {
1421 dev_err(&pdev->dev, "could not claim irq %u\n",
1422 ssi_private->irq);
1423 goto error_asoc_register;
1424 }
1425 }
1426
1427 ret = fsl_ssi_debugfs_create(&ssi_private->dbg_stats, &pdev->dev);
1428 if (ret)
1429 goto error_asoc_register;
1430
1431 /*
1432 * If codec-handle property is missing from SSI node, we assume
1433 * that the machine driver uses new binding which does not require
1434 * SSI driver to trigger machine driver's probe.
1435 */
1436 if (!of_get_property(np, "codec-handle", NULL))
1437 goto done;
1438
1439 /* Trigger the machine driver's probe function. The platform driver
1440 * name of the machine driver is taken from /compatible property of the
1441 * device tree. We also pass the address of the CPU DAI driver
1442 * structure.
1443 */
1444 sprop = of_get_property(of_find_node_by_path("/"), "compatible", NULL);
1445 /* Sometimes the compatible name has a "fsl," prefix, so we strip it. */
1446 p = strrchr(sprop, ',');
1447 if (p)
1448 sprop = p + 1;
1449 snprintf(name, sizeof(name), "snd-soc-%s", sprop);
1450 make_lowercase(name);
1451
1452 ssi_private->pdev =
1453 platform_device_register_data(&pdev->dev, name, 0, NULL, 0);
1454 if (IS_ERR(ssi_private->pdev)) {
1455 ret = PTR_ERR(ssi_private->pdev);
1456 dev_err(&pdev->dev, "failed to register platform: %d\n", ret);
1457 goto error_sound_card;
1458 }
1459
1460 done:
1461 if (ssi_private->dai_fmt)
1462 _fsl_ssi_set_dai_fmt(&pdev->dev, ssi_private,
1463 ssi_private->dai_fmt);
1464
1465 if (fsl_ssi_is_ac97(ssi_private)) {
1466 u32 ssi_idx;
1467
1468 ret = of_property_read_u32(np, "cell-index", &ssi_idx);
1469 if (ret) {
1470 dev_err(&pdev->dev, "cannot get SSI index property\n");
1471 goto error_sound_card;
1472 }
1473
1474 ssi_private->pdev =
1475 platform_device_register_data(NULL,
1476 "ac97-codec", ssi_idx, NULL, 0);
1477 if (IS_ERR(ssi_private->pdev)) {
1478 ret = PTR_ERR(ssi_private->pdev);
1479 dev_err(&pdev->dev,
1480 "failed to register AC97 codec platform: %d\n",
1481 ret);
1482 goto error_sound_card;
1483 }
1484 }
1485
1486 return 0;
1487
1488 error_sound_card:
1489 fsl_ssi_debugfs_remove(&ssi_private->dbg_stats);
1490
1491 error_asoc_register:
1492 if (ssi_private->soc->imx)
1493 fsl_ssi_imx_clean(pdev, ssi_private);
1494
1495 return ret;
1496 }
1497
1498 static int fsl_ssi_remove(struct platform_device *pdev)
1499 {
1500 struct fsl_ssi_private *ssi_private = dev_get_drvdata(&pdev->dev);
1501
1502 fsl_ssi_debugfs_remove(&ssi_private->dbg_stats);
1503
1504 if (ssi_private->pdev)
1505 platform_device_unregister(ssi_private->pdev);
1506
1507 if (ssi_private->soc->imx)
1508 fsl_ssi_imx_clean(pdev, ssi_private);
1509
1510 if (fsl_ssi_is_ac97(ssi_private))
1511 snd_soc_set_ac97_ops(NULL);
1512
1513 return 0;
1514 }
1515
1516 static struct platform_driver fsl_ssi_driver = {
1517 .driver = {
1518 .name = "fsl-ssi-dai",
1519 .of_match_table = fsl_ssi_ids,
1520 },
1521 .probe = fsl_ssi_probe,
1522 .remove = fsl_ssi_remove,
1523 };
1524
1525 module_platform_driver(fsl_ssi_driver);
1526
1527 MODULE_ALIAS("platform:fsl-ssi-dai");
1528 MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
1529 MODULE_DESCRIPTION("Freescale Synchronous Serial Interface (SSI) ASoC Driver");
1530 MODULE_LICENSE("GPL v2");
This page took 0.087556 seconds and 5 git commands to generate.