2 * Freescale MPC8610HPCD ALSA SoC Fabric driver
4 * Author: Timur Tabi <timur@freescale.com>
6 * Copyright 2007-2008 Freescale Semiconductor, Inc. This file is licensed
7 * under the terms of the GNU General Public License version 2. This
8 * program is licensed "as is" without any warranty of any kind, whether
12 #include <linux/module.h>
13 #include <linux/interrupt.h>
14 #include <linux/of_device.h>
15 #include <linux/of_platform.h>
16 #include <sound/soc.h>
17 #include <asm/immap_86xx.h>
19 #include "../codecs/cs4270.h"
24 * mpc8610_hpcd_data: fabric-specific ASoC device data
26 * This structure contains data for a single sound platform device on an
27 * MPC8610 HPCD. Some of the data is taken from the device tree.
29 struct mpc8610_hpcd_data
{
30 struct snd_soc_device sound_devdata
;
31 struct snd_soc_dai_link dai
;
32 struct snd_soc_card machine
;
33 unsigned int dai_format
;
34 unsigned int codec_clk_direction
;
35 unsigned int cpu_clk_direction
;
36 unsigned int clk_frequency
;
37 struct ccsr_guts __iomem
*guts
;
38 struct ccsr_ssi __iomem
*ssi
;
39 unsigned int ssi_id
; /* 0 = SSI1, 1 = SSI2, etc */
41 unsigned int dma_id
; /* 0 = DMA1, 1 = DMA2, etc */
42 unsigned int dma_irq
[2];
43 struct ccsr_dma_channel __iomem
*dma
[2];
44 unsigned int dma_channel_id
[2]; /* 0 = ch 0, 1 = ch 1, etc*/
48 * mpc8610_hpcd_machine_probe: initalize the board
50 * This function is called when platform_device_add() is called. It is used
51 * to initialize the board-specific hardware.
53 * Here we program the DMACR and PMUXCR registers.
55 static int mpc8610_hpcd_machine_probe(struct platform_device
*sound_device
)
57 struct mpc8610_hpcd_data
*machine_data
=
58 sound_device
->dev
.platform_data
;
60 /* Program the signal routing between the SSI and the DMA */
61 guts_set_dmacr(machine_data
->guts
, machine_data
->dma_id
,
62 machine_data
->dma_channel_id
[0], CCSR_GUTS_DMACR_DEV_SSI
);
63 guts_set_dmacr(machine_data
->guts
, machine_data
->dma_id
,
64 machine_data
->dma_channel_id
[1], CCSR_GUTS_DMACR_DEV_SSI
);
66 guts_set_pmuxcr_dma(machine_data
->guts
, machine_data
->dma_id
,
67 machine_data
->dma_channel_id
[0], 0);
68 guts_set_pmuxcr_dma(machine_data
->guts
, machine_data
->dma_id
,
69 machine_data
->dma_channel_id
[1], 0);
71 switch (machine_data
->ssi_id
) {
73 clrsetbits_be32(&machine_data
->guts
->pmuxcr
,
74 CCSR_GUTS_PMUXCR_SSI1_MASK
, CCSR_GUTS_PMUXCR_SSI1_SSI
);
77 clrsetbits_be32(&machine_data
->guts
->pmuxcr
,
78 CCSR_GUTS_PMUXCR_SSI2_MASK
, CCSR_GUTS_PMUXCR_SSI2_SSI
);
86 * mpc8610_hpcd_startup: program the board with various hardware parameters
88 * This function takes board-specific information, like clock frequencies
89 * and serial data formats, and passes that information to the codec and
92 static int mpc8610_hpcd_startup(struct snd_pcm_substream
*substream
)
94 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
95 struct snd_soc_dai
*codec_dai
= rtd
->dai
->codec_dai
;
96 struct snd_soc_dai
*cpu_dai
= rtd
->dai
->cpu_dai
;
97 struct mpc8610_hpcd_data
*machine_data
=
98 rtd
->socdev
->dev
->platform_data
;
101 /* Tell the CPU driver what the serial protocol is. */
102 ret
= snd_soc_dai_set_fmt(cpu_dai
, machine_data
->dai_format
);
104 dev_err(substream
->pcm
->card
->dev
,
105 "could not set CPU driver audio format\n");
109 /* Tell the codec driver what the serial protocol is. */
110 ret
= snd_soc_dai_set_fmt(codec_dai
, machine_data
->dai_format
);
112 dev_err(substream
->pcm
->card
->dev
,
113 "could not set codec driver audio format\n");
118 * Tell the CPU driver what the clock frequency is, and whether it's a
121 ret
= snd_soc_dai_set_sysclk(cpu_dai
, 0,
122 machine_data
->clk_frequency
,
123 machine_data
->cpu_clk_direction
);
125 dev_err(substream
->pcm
->card
->dev
,
126 "could not set CPU driver clock parameters\n");
131 * Tell the codec driver what the MCLK frequency is, and whether it's
134 ret
= snd_soc_dai_set_sysclk(codec_dai
, 0,
135 machine_data
->clk_frequency
,
136 machine_data
->codec_clk_direction
);
138 dev_err(substream
->pcm
->card
->dev
,
139 "could not set codec driver clock params\n");
147 * mpc8610_hpcd_machine_remove: Remove the sound device
149 * This function is called to remove the sound device for one SSI. We
150 * de-program the DMACR and PMUXCR register.
152 int mpc8610_hpcd_machine_remove(struct platform_device
*sound_device
)
154 struct mpc8610_hpcd_data
*machine_data
=
155 sound_device
->dev
.platform_data
;
157 /* Restore the signal routing */
159 guts_set_dmacr(machine_data
->guts
, machine_data
->dma_id
,
160 machine_data
->dma_channel_id
[0], 0);
161 guts_set_dmacr(machine_data
->guts
, machine_data
->dma_id
,
162 machine_data
->dma_channel_id
[1], 0);
164 switch (machine_data
->ssi_id
) {
166 clrsetbits_be32(&machine_data
->guts
->pmuxcr
,
167 CCSR_GUTS_PMUXCR_SSI1_MASK
, CCSR_GUTS_PMUXCR_SSI1_LA
);
170 clrsetbits_be32(&machine_data
->guts
->pmuxcr
,
171 CCSR_GUTS_PMUXCR_SSI2_MASK
, CCSR_GUTS_PMUXCR_SSI2_LA
);
179 * mpc8610_hpcd_ops: ASoC fabric driver operations
181 static struct snd_soc_ops mpc8610_hpcd_ops
= {
182 .startup
= mpc8610_hpcd_startup
,
186 * mpc8610_hpcd_machine: ASoC machine data
188 static struct snd_soc_card mpc8610_hpcd_machine
= {
189 .probe
= mpc8610_hpcd_machine_probe
,
190 .remove
= mpc8610_hpcd_machine_remove
,
191 .name
= "MPC8610 HPCD",
196 * mpc8610_hpcd_probe: OF probe function for the fabric driver
198 * This function gets called when an SSI node is found in the device tree.
200 * Although this is a fabric driver, the SSI node is the "master" node with
201 * respect to audio hardware connections. Therefore, we create a new ASoC
202 * device for each new SSI node that has a codec attached.
204 * FIXME: Currently, we only support one DMA controller, so if there are
205 * multiple SSI nodes with codecs, only the first will be supported.
207 * FIXME: Even if we did support multiple DMA controllers, we have no
208 * mechanism for assigning DMA controllers and channels to the individual
209 * SSI devices. We also probably aren't compatible with the generic Elo DMA
212 static int mpc8610_hpcd_probe(struct of_device
*ofdev
,
213 const struct of_device_id
*match
)
215 struct device_node
*np
= ofdev
->node
;
216 struct device_node
*codec_np
= NULL
;
217 struct device_node
*guts_np
= NULL
;
218 struct device_node
*dma_np
= NULL
;
219 struct device_node
*dma_channel_np
= NULL
;
220 const phandle
*codec_ph
;
224 struct platform_device
*sound_device
= NULL
;
225 struct mpc8610_hpcd_data
*machine_data
;
226 struct fsl_ssi_info ssi_info
;
227 struct fsl_dma_info dma_info
;
229 unsigned int playback_dma_channel
;
230 unsigned int capture_dma_channel
;
232 machine_data
= kzalloc(sizeof(struct mpc8610_hpcd_data
), GFP_KERNEL
);
236 memset(&ssi_info
, 0, sizeof(ssi_info
));
237 memset(&dma_info
, 0, sizeof(dma_info
));
239 ssi_info
.dev
= &ofdev
->dev
;
242 * We are only interested in SSIs with a codec phandle in them, so let's
243 * make sure this SSI has one.
245 codec_ph
= of_get_property(np
, "codec-handle", NULL
);
249 codec_np
= of_find_node_by_phandle(*codec_ph
);
253 /* The MPC8610 HPCD only knows about the CS4270 codec, so reject
255 if (!of_device_is_compatible(codec_np
, "cirrus,cs4270"))
258 /* Get the device ID */
259 iprop
= of_get_property(np
, "cell-index", NULL
);
261 dev_err(&ofdev
->dev
, "cell-index property not found\n");
265 machine_data
->ssi_id
= *iprop
;
266 ssi_info
.id
= *iprop
;
268 /* Get the serial format and clock direction. */
269 sprop
= of_get_property(np
, "fsl,mode", NULL
);
271 dev_err(&ofdev
->dev
, "fsl,mode property not found\n");
276 if (strcasecmp(sprop
, "i2s-slave") == 0) {
277 machine_data
->dai_format
= SND_SOC_DAIFMT_I2S
;
278 machine_data
->codec_clk_direction
= SND_SOC_CLOCK_OUT
;
279 machine_data
->cpu_clk_direction
= SND_SOC_CLOCK_IN
;
282 * In i2s-slave mode, the codec has its own clock source, so we
283 * need to get the frequency from the device tree and pass it to
286 iprop
= of_get_property(codec_np
, "clock-frequency", NULL
);
287 if (!iprop
|| !*iprop
) {
288 dev_err(&ofdev
->dev
, "codec bus-frequency property "
289 "is missing or invalid\n");
293 machine_data
->clk_frequency
= *iprop
;
294 } else if (strcasecmp(sprop
, "i2s-master") == 0) {
295 machine_data
->dai_format
= SND_SOC_DAIFMT_I2S
;
296 machine_data
->codec_clk_direction
= SND_SOC_CLOCK_IN
;
297 machine_data
->cpu_clk_direction
= SND_SOC_CLOCK_OUT
;
298 } else if (strcasecmp(sprop
, "lj-slave") == 0) {
299 machine_data
->dai_format
= SND_SOC_DAIFMT_LEFT_J
;
300 machine_data
->codec_clk_direction
= SND_SOC_CLOCK_OUT
;
301 machine_data
->cpu_clk_direction
= SND_SOC_CLOCK_IN
;
302 } else if (strcasecmp(sprop
, "lj-master") == 0) {
303 machine_data
->dai_format
= SND_SOC_DAIFMT_LEFT_J
;
304 machine_data
->codec_clk_direction
= SND_SOC_CLOCK_IN
;
305 machine_data
->cpu_clk_direction
= SND_SOC_CLOCK_OUT
;
306 } else if (strcasecmp(sprop
, "rj-slave") == 0) {
307 machine_data
->dai_format
= SND_SOC_DAIFMT_RIGHT_J
;
308 machine_data
->codec_clk_direction
= SND_SOC_CLOCK_OUT
;
309 machine_data
->cpu_clk_direction
= SND_SOC_CLOCK_IN
;
310 } else if (strcasecmp(sprop
, "rj-master") == 0) {
311 machine_data
->dai_format
= SND_SOC_DAIFMT_RIGHT_J
;
312 machine_data
->codec_clk_direction
= SND_SOC_CLOCK_IN
;
313 machine_data
->cpu_clk_direction
= SND_SOC_CLOCK_OUT
;
314 } else if (strcasecmp(sprop
, "ac97-slave") == 0) {
315 machine_data
->dai_format
= SND_SOC_DAIFMT_AC97
;
316 machine_data
->codec_clk_direction
= SND_SOC_CLOCK_OUT
;
317 machine_data
->cpu_clk_direction
= SND_SOC_CLOCK_IN
;
318 } else if (strcasecmp(sprop
, "ac97-master") == 0) {
319 machine_data
->dai_format
= SND_SOC_DAIFMT_AC97
;
320 machine_data
->codec_clk_direction
= SND_SOC_CLOCK_IN
;
321 machine_data
->cpu_clk_direction
= SND_SOC_CLOCK_OUT
;
324 "unrecognized fsl,mode property \"%s\"\n", sprop
);
329 if (!machine_data
->clk_frequency
) {
330 dev_err(&ofdev
->dev
, "unknown clock frequency\n");
335 /* Read the SSI information from the device tree */
336 ret
= of_address_to_resource(np
, 0, &res
);
338 dev_err(&ofdev
->dev
, "could not obtain SSI address\n");
342 dev_err(&ofdev
->dev
, "invalid SSI address\n");
345 ssi_info
.ssi_phys
= res
.start
;
347 machine_data
->ssi
= ioremap(ssi_info
.ssi_phys
, sizeof(struct ccsr_ssi
));
348 if (!machine_data
->ssi
) {
349 dev_err(&ofdev
->dev
, "could not map SSI address %x\n",
354 ssi_info
.ssi
= machine_data
->ssi
;
357 /* Get the IRQ of the SSI */
358 machine_data
->ssi_irq
= irq_of_parse_and_map(np
, 0);
359 if (!machine_data
->ssi_irq
) {
360 dev_err(&ofdev
->dev
, "could not get SSI IRQ\n");
364 ssi_info
.irq
= machine_data
->ssi_irq
;
367 /* Map the global utilities registers. */
368 guts_np
= of_find_compatible_node(NULL
, NULL
, "fsl,mpc8610-guts");
370 dev_err(&ofdev
->dev
, "could not obtain address of GUTS\n");
374 machine_data
->guts
= of_iomap(guts_np
, 0);
375 of_node_put(guts_np
);
376 if (!machine_data
->guts
) {
377 dev_err(&ofdev
->dev
, "could not map GUTS\n");
382 /* Find the DMA channels to use. Both SSIs need to use the same DMA
383 * controller, so let's use DMA#1.
385 for_each_compatible_node(dma_np
, NULL
, "fsl,mpc8610-dma") {
386 iprop
= of_get_property(dma_np
, "cell-index", NULL
);
387 if (iprop
&& (*iprop
== 0)) {
393 dev_err(&ofdev
->dev
, "could not find DMA node\n");
397 machine_data
->dma_id
= *iprop
;
399 /* SSI1 needs to use DMA Channels 0 and 1, and SSI2 needs to use DMA
400 * channels 2 and 3. This is just how the MPC8610 is wired
403 playback_dma_channel
= (machine_data
->ssi_id
== 0) ? 0 : 2;
404 capture_dma_channel
= (machine_data
->ssi_id
== 0) ? 1 : 3;
407 * Find the DMA channels to use.
409 while ((dma_channel_np
= of_get_next_child(dma_np
, dma_channel_np
))) {
410 iprop
= of_get_property(dma_channel_np
, "cell-index", NULL
);
411 if (iprop
&& (*iprop
== playback_dma_channel
)) {
412 /* dma_channel[0] and dma_irq[0] are for playback */
413 dma_info
.dma_channel
[0] = of_iomap(dma_channel_np
, 0);
414 dma_info
.dma_irq
[0] =
415 irq_of_parse_and_map(dma_channel_np
, 0);
416 machine_data
->dma_channel_id
[0] = *iprop
;
419 if (iprop
&& (*iprop
== capture_dma_channel
)) {
420 /* dma_channel[1] and dma_irq[1] are for capture */
421 dma_info
.dma_channel
[1] = of_iomap(dma_channel_np
, 0);
422 dma_info
.dma_irq
[1] =
423 irq_of_parse_and_map(dma_channel_np
, 0);
424 machine_data
->dma_channel_id
[1] = *iprop
;
428 if (!dma_info
.dma_channel
[0] || !dma_info
.dma_channel
[1] ||
429 !dma_info
.dma_irq
[0] || !dma_info
.dma_irq
[1]) {
430 dev_err(&ofdev
->dev
, "could not find DMA channels\n");
435 dma_info
.ssi_stx_phys
= ssi_info
.ssi_phys
+
436 offsetof(struct ccsr_ssi
, stx0
);
437 dma_info
.ssi_srx_phys
= ssi_info
.ssi_phys
+
438 offsetof(struct ccsr_ssi
, srx0
);
440 /* We have the DMA information, so tell the DMA driver what it is */
441 if (!fsl_dma_configure(&dma_info
)) {
442 dev_err(&ofdev
->dev
, "could not instantiate DMA device\n");
448 * Initialize our DAI data structure. We should probably get this
449 * information from the device tree.
451 machine_data
->dai
.name
= "CS4270";
452 machine_data
->dai
.stream_name
= "CS4270";
454 machine_data
->dai
.cpu_dai
= fsl_ssi_create_dai(&ssi_info
);
455 machine_data
->dai
.codec_dai
= &cs4270_dai
; /* The codec_dai we want */
456 machine_data
->dai
.ops
= &mpc8610_hpcd_ops
;
458 mpc8610_hpcd_machine
.dai_link
= &machine_data
->dai
;
460 /* Allocate a new audio platform device structure */
461 sound_device
= platform_device_alloc("soc-audio", -1);
463 dev_err(&ofdev
->dev
, "platform device allocation failed\n");
468 machine_data
->sound_devdata
.card
= &mpc8610_hpcd_machine
;
469 machine_data
->sound_devdata
.codec_dev
= &soc_codec_device_cs4270
;
470 machine_data
->machine
.platform
= &fsl_soc_platform
;
472 sound_device
->dev
.platform_data
= machine_data
;
475 /* Set the platform device and ASoC device to point to each other */
476 platform_set_drvdata(sound_device
, &machine_data
->sound_devdata
);
478 machine_data
->sound_devdata
.dev
= &sound_device
->dev
;
481 /* Tell ASoC to probe us. This will call mpc8610_hpcd_machine.probe(),
483 ret
= platform_device_add(sound_device
);
486 dev_err(&ofdev
->dev
, "platform device add failed\n");
490 dev_set_drvdata(&ofdev
->dev
, sound_device
);
495 of_node_put(codec_np
);
496 of_node_put(guts_np
);
498 of_node_put(dma_channel_np
);
501 platform_device_unregister(sound_device
);
503 if (machine_data
->dai
.cpu_dai
)
504 fsl_ssi_destroy_dai(machine_data
->dai
.cpu_dai
);
507 iounmap(ssi_info
.ssi
);
510 irq_dispose_mapping(ssi_info
.irq
);
512 if (dma_info
.dma_channel
[0])
513 iounmap(dma_info
.dma_channel
[0]);
515 if (dma_info
.dma_channel
[1])
516 iounmap(dma_info
.dma_channel
[1]);
518 if (dma_info
.dma_irq
[0])
519 irq_dispose_mapping(dma_info
.dma_irq
[0]);
521 if (dma_info
.dma_irq
[1])
522 irq_dispose_mapping(dma_info
.dma_irq
[1]);
524 if (machine_data
->guts
)
525 iounmap(machine_data
->guts
);
533 * mpc8610_hpcd_remove: remove the OF device
535 * This function is called when the OF device is removed.
537 static int mpc8610_hpcd_remove(struct of_device
*ofdev
)
539 struct platform_device
*sound_device
= dev_get_drvdata(&ofdev
->dev
);
540 struct mpc8610_hpcd_data
*machine_data
=
541 sound_device
->dev
.platform_data
;
543 platform_device_unregister(sound_device
);
545 if (machine_data
->dai
.cpu_dai
)
546 fsl_ssi_destroy_dai(machine_data
->dai
.cpu_dai
);
548 if (machine_data
->ssi
)
549 iounmap(machine_data
->ssi
);
551 if (machine_data
->dma
[0])
552 iounmap(machine_data
->dma
[0]);
554 if (machine_data
->dma
[1])
555 iounmap(machine_data
->dma
[1]);
557 if (machine_data
->dma_irq
[0])
558 irq_dispose_mapping(machine_data
->dma_irq
[0]);
560 if (machine_data
->dma_irq
[1])
561 irq_dispose_mapping(machine_data
->dma_irq
[1]);
563 if (machine_data
->guts
)
564 iounmap(machine_data
->guts
);
567 sound_device
->dev
.platform_data
= NULL
;
569 dev_set_drvdata(&ofdev
->dev
, NULL
);
574 static struct of_device_id mpc8610_hpcd_match
[] = {
576 .compatible
= "fsl,mpc8610-ssi",
580 MODULE_DEVICE_TABLE(of
, mpc8610_hpcd_match
);
582 static struct of_platform_driver mpc8610_hpcd_of_driver
= {
583 .owner
= THIS_MODULE
,
584 .name
= "mpc8610_hpcd",
585 .match_table
= mpc8610_hpcd_match
,
586 .probe
= mpc8610_hpcd_probe
,
587 .remove
= mpc8610_hpcd_remove
,
591 * mpc8610_hpcd_init: fabric driver initialization.
593 * This function is called when this module is loaded.
595 static int __init
mpc8610_hpcd_init(void)
599 printk(KERN_INFO
"Freescale MPC8610 HPCD ALSA SoC fabric driver\n");
601 ret
= of_register_platform_driver(&mpc8610_hpcd_of_driver
);
605 "mpc8610-hpcd: failed to register platform driver\n");
611 * mpc8610_hpcd_exit: fabric driver exit
613 * This function is called when this driver is unloaded.
615 static void __exit
mpc8610_hpcd_exit(void)
617 of_unregister_platform_driver(&mpc8610_hpcd_of_driver
);
620 module_init(mpc8610_hpcd_init
);
621 module_exit(mpc8610_hpcd_exit
);
623 MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
624 MODULE_DESCRIPTION("Freescale MPC8610 HPCD ALSA SoC fabric driver");
625 MODULE_LICENSE("GPL");