ASoC: Replace pdev with card in machine driver probe and remove
[linux-2.6.git] / sound / soc / fsl / mpc8610_hpcd.c
1 /**
2  * Freescale MPC8610HPCD ALSA SoC Machine 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 #include <linux/module.h>
14 #include <linux/interrupt.h>
15 #include <linux/of_device.h>
16 #include <linux/slab.h>
17 #include <sound/soc.h>
18 #include <asm/fsl_guts.h>
19
20 #include "fsl_dma.h"
21 #include "fsl_ssi.h"
22
23 /* There's only one global utilities register */
24 static phys_addr_t guts_phys;
25
26 #define DAI_NAME_SIZE   32
27
28 /**
29  * mpc8610_hpcd_data: machine-specific ASoC device data
30  *
31  * This structure contains data for a single sound platform device on an
32  * MPC8610 HPCD.  Some of the data is taken from the device tree.
33  */
34 struct mpc8610_hpcd_data {
35         struct snd_soc_dai_link dai[2];
36         struct snd_soc_card card;
37         unsigned int dai_format;
38         unsigned int codec_clk_direction;
39         unsigned int cpu_clk_direction;
40         unsigned int clk_frequency;
41         unsigned int ssi_id;            /* 0 = SSI1, 1 = SSI2, etc */
42         unsigned int dma_id[2];         /* 0 = DMA1, 1 = DMA2, etc */
43         unsigned int dma_channel_id[2]; /* 0 = ch 0, 1 = ch 1, etc*/
44         char codec_dai_name[DAI_NAME_SIZE];
45         char codec_name[DAI_NAME_SIZE];
46         char platform_name[2][DAI_NAME_SIZE]; /* One for each DMA channel */
47 };
48
49 /**
50  * mpc8610_hpcd_machine_probe: initialize the board
51  *
52  * This function is used to initialize the board-specific hardware.
53  *
54  * Here we program the DMACR and PMUXCR registers.
55  */
56 static int mpc8610_hpcd_machine_probe(struct snd_soc_card *card)
57 {
58         struct mpc8610_hpcd_data *machine_data =
59                 container_of(card, struct mpc8610_hpcd_data, card);
60         struct ccsr_guts_86xx __iomem *guts;
61
62         guts = ioremap(guts_phys, sizeof(struct ccsr_guts_86xx));
63         if (!guts) {
64                 dev_err(card->dev, "could not map global utilities\n");
65                 return -ENOMEM;
66         }
67
68         /* Program the signal routing between the SSI and the DMA */
69         guts_set_dmacr(guts, machine_data->dma_id[0],
70                        machine_data->dma_channel_id[0],
71                        CCSR_GUTS_DMACR_DEV_SSI);
72         guts_set_dmacr(guts, machine_data->dma_id[1],
73                        machine_data->dma_channel_id[1],
74                        CCSR_GUTS_DMACR_DEV_SSI);
75
76         guts_set_pmuxcr_dma(guts, machine_data->dma_id[0],
77                             machine_data->dma_channel_id[0], 0);
78         guts_set_pmuxcr_dma(guts, machine_data->dma_id[1],
79                             machine_data->dma_channel_id[1], 0);
80
81         switch (machine_data->ssi_id) {
82         case 0:
83                 clrsetbits_be32(&guts->pmuxcr,
84                         CCSR_GUTS_PMUXCR_SSI1_MASK, CCSR_GUTS_PMUXCR_SSI1_SSI);
85                 break;
86         case 1:
87                 clrsetbits_be32(&guts->pmuxcr,
88                         CCSR_GUTS_PMUXCR_SSI2_MASK, CCSR_GUTS_PMUXCR_SSI2_SSI);
89                 break;
90         }
91
92         iounmap(guts);
93
94         return 0;
95 }
96
97 /**
98  * mpc8610_hpcd_startup: program the board with various hardware parameters
99  *
100  * This function takes board-specific information, like clock frequencies
101  * and serial data formats, and passes that information to the codec and
102  * transport drivers.
103  */
104 static int mpc8610_hpcd_startup(struct snd_pcm_substream *substream)
105 {
106         struct snd_soc_pcm_runtime *rtd = substream->private_data;
107         struct mpc8610_hpcd_data *machine_data =
108                 container_of(rtd->card, struct mpc8610_hpcd_data, card);
109         struct device *dev = rtd->card->dev;
110         int ret = 0;
111
112         /* Tell the codec driver what the serial protocol is. */
113         ret = snd_soc_dai_set_fmt(rtd->codec_dai, machine_data->dai_format);
114         if (ret < 0) {
115                 dev_err(dev, "could not set codec driver audio format\n");
116                 return ret;
117         }
118
119         /*
120          * Tell the codec driver what the MCLK frequency is, and whether it's
121          * a slave or master.
122          */
123         ret = snd_soc_dai_set_sysclk(rtd->codec_dai, 0,
124                                      machine_data->clk_frequency,
125                                      machine_data->codec_clk_direction);
126         if (ret < 0) {
127                 dev_err(dev, "could not set codec driver clock params\n");
128                 return ret;
129         }
130
131         return 0;
132 }
133
134 /**
135  * mpc8610_hpcd_machine_remove: Remove the sound device
136  *
137  * This function is called to remove the sound device for one SSI.  We
138  * de-program the DMACR and PMUXCR register.
139  */
140 static int mpc8610_hpcd_machine_remove(struct snd_soc_card *card)
141 {
142         struct mpc8610_hpcd_data *machine_data =
143                 container_of(card, struct mpc8610_hpcd_data, card);
144         struct ccsr_guts_86xx __iomem *guts;
145
146         guts = ioremap(guts_phys, sizeof(struct ccsr_guts_86xx));
147         if (!guts) {
148                 dev_err(card->dev, "could not map global utilities\n");
149                 return -ENOMEM;
150         }
151
152         /* Restore the signal routing */
153
154         guts_set_dmacr(guts, machine_data->dma_id[0],
155                        machine_data->dma_channel_id[0], 0);
156         guts_set_dmacr(guts, machine_data->dma_id[1],
157                        machine_data->dma_channel_id[1], 0);
158
159         switch (machine_data->ssi_id) {
160         case 0:
161                 clrsetbits_be32(&guts->pmuxcr,
162                         CCSR_GUTS_PMUXCR_SSI1_MASK, CCSR_GUTS_PMUXCR_SSI1_LA);
163                 break;
164         case 1:
165                 clrsetbits_be32(&guts->pmuxcr,
166                         CCSR_GUTS_PMUXCR_SSI2_MASK, CCSR_GUTS_PMUXCR_SSI2_LA);
167                 break;
168         }
169
170         iounmap(guts);
171
172         return 0;
173 }
174
175 /**
176  * mpc8610_hpcd_ops: ASoC machine driver operations
177  */
178 static struct snd_soc_ops mpc8610_hpcd_ops = {
179         .startup = mpc8610_hpcd_startup,
180 };
181
182 /**
183  * get_node_by_phandle_name - get a node by its phandle name
184  *
185  * This function takes a node, the name of a property in that node, and a
186  * compatible string.  Assuming the property is a phandle to another node,
187  * it returns that node, (optionally) if that node is compatible.
188  *
189  * If the property is not a phandle, or the node it points to is not compatible
190  * with the specific string, then NULL is returned.
191  */
192 static struct device_node *get_node_by_phandle_name(struct device_node *np,
193                                                const char *name,
194                                                const char *compatible)
195 {
196         const phandle *ph;
197         int len;
198
199         ph = of_get_property(np, name, &len);
200         if (!ph || (len != sizeof(phandle)))
201                 return NULL;
202
203         np = of_find_node_by_phandle(*ph);
204         if (!np)
205                 return NULL;
206
207         if (compatible && !of_device_is_compatible(np, compatible)) {
208                 of_node_put(np);
209                 return NULL;
210         }
211
212         return np;
213 }
214
215 /**
216  * get_parent_cell_index -- return the cell-index of the parent of a node
217  *
218  * Return the value of the cell-index property of the parent of the given
219  * node.  This is used for DMA channel nodes that need to know the DMA ID
220  * of the controller they are on.
221  */
222 static int get_parent_cell_index(struct device_node *np)
223 {
224         struct device_node *parent = of_get_parent(np);
225         const u32 *iprop;
226
227         if (!parent)
228                 return -1;
229
230         iprop = of_get_property(parent, "cell-index", NULL);
231         of_node_put(parent);
232
233         if (!iprop)
234                 return -1;
235
236         return *iprop;
237 }
238
239 /**
240  * codec_node_dev_name - determine the dev_name for a codec node
241  *
242  * This function determines the dev_name for an I2C node.  This is the name
243  * that would be returned by dev_name() if this device_node were part of a
244  * 'struct device'  It's ugly and hackish, but it works.
245  *
246  * The dev_name for such devices include the bus number and I2C address. For
247  * example, "cs4270-codec.0-004f".
248  */
249 static int codec_node_dev_name(struct device_node *np, char *buf, size_t len)
250 {
251         const u32 *iprop;
252         int bus, addr;
253         char temp[DAI_NAME_SIZE];
254
255         of_modalias_node(np, temp, DAI_NAME_SIZE);
256
257         iprop = of_get_property(np, "reg", NULL);
258         if (!iprop)
259                 return -EINVAL;
260
261         addr = *iprop;
262
263         bus = get_parent_cell_index(np);
264         if (bus < 0)
265                 return bus;
266
267         snprintf(buf, len, "%s-codec.%u-%04x", temp, bus, addr);
268
269         return 0;
270 }
271
272 static int get_dma_channel(struct device_node *ssi_np,
273                            const char *compatible,
274                            struct snd_soc_dai_link *dai,
275                            unsigned int *dma_channel_id,
276                            unsigned int *dma_id)
277 {
278         struct resource res;
279         struct device_node *dma_channel_np;
280         const u32 *iprop;
281         int ret;
282
283         dma_channel_np = get_node_by_phandle_name(ssi_np, compatible,
284                                                   "fsl,ssi-dma-channel");
285         if (!dma_channel_np)
286                 return -EINVAL;
287
288         /* Determine the dev_name for the device_node.  This code mimics the
289          * behavior of of_device_make_bus_id(). We need this because ASoC uses
290          * the dev_name() of the device to match the platform (DMA) device with
291          * the CPU (SSI) device.  It's all ugly and hackish, but it works (for
292          * now).
293          *
294          * dai->platform name should already point to an allocated buffer.
295          */
296         ret = of_address_to_resource(dma_channel_np, 0, &res);
297         if (ret)
298                 return ret;
299         snprintf((char *)dai->platform_name, DAI_NAME_SIZE, "%llx.%s",
300                  (unsigned long long) res.start, dma_channel_np->name);
301
302         iprop = of_get_property(dma_channel_np, "cell-index", NULL);
303         if (!iprop) {
304                 of_node_put(dma_channel_np);
305                 return -EINVAL;
306         }
307
308         *dma_channel_id = *iprop;
309         *dma_id = get_parent_cell_index(dma_channel_np);
310         of_node_put(dma_channel_np);
311
312         return 0;
313 }
314
315 /**
316  * mpc8610_hpcd_probe: platform probe function for the machine driver
317  *
318  * Although this is a machine driver, the SSI node is the "master" node with
319  * respect to audio hardware connections.  Therefore, we create a new ASoC
320  * device for each new SSI node that has a codec attached.
321  */
322 static int mpc8610_hpcd_probe(struct platform_device *pdev)
323 {
324         struct device *dev = pdev->dev.parent;
325         /* ssi_pdev is the platform device for the SSI node that probed us */
326         struct platform_device *ssi_pdev =
327                 container_of(dev, struct platform_device, dev);
328         struct device_node *np = ssi_pdev->dev.of_node;
329         struct device_node *codec_np = NULL;
330         struct platform_device *sound_device = NULL;
331         struct mpc8610_hpcd_data *machine_data;
332         int ret = -ENODEV;
333         const char *sprop;
334         const u32 *iprop;
335
336         /* We are only interested in SSIs with a codec phandle in them,
337          * so let's make sure this SSI has one. The MPC8610 HPCD only
338          * knows about the CS4270 codec, so reject anything else.
339          */
340         codec_np = get_node_by_phandle_name(np, "codec-handle",
341                                             "cirrus,cs4270");
342         if (!codec_np) {
343                 dev_err(dev, "invalid codec node\n");
344                 return -EINVAL;
345         }
346
347         machine_data = kzalloc(sizeof(struct mpc8610_hpcd_data), GFP_KERNEL);
348         if (!machine_data)
349                 return -ENOMEM;
350
351         machine_data->dai[0].cpu_dai_name = dev_name(&ssi_pdev->dev);
352         machine_data->dai[0].ops = &mpc8610_hpcd_ops;
353
354         /* Determine the codec name, it will be used as the codec DAI name */
355         ret = codec_node_dev_name(codec_np, machine_data->codec_name,
356                                   DAI_NAME_SIZE);
357         if (ret) {
358                 dev_err(&pdev->dev, "invalid codec node %s\n",
359                         codec_np->full_name);
360                 ret = -EINVAL;
361                 goto error;
362         }
363         machine_data->dai[0].codec_name = machine_data->codec_name;
364
365         /* The DAI name from the codec (snd_soc_dai_driver.name) */
366         machine_data->dai[0].codec_dai_name = "cs4270-hifi";
367
368         /* We register two DAIs per SSI, one for playback and the other for
369          * capture.  Currently, we only support codecs that have one DAI for
370          * both playback and capture.
371          */
372         memcpy(&machine_data->dai[1], &machine_data->dai[0],
373                sizeof(struct snd_soc_dai_link));
374
375         /* Get the device ID */
376         iprop = of_get_property(np, "cell-index", NULL);
377         if (!iprop) {
378                 dev_err(&pdev->dev, "cell-index property not found\n");
379                 ret = -EINVAL;
380                 goto error;
381         }
382         machine_data->ssi_id = *iprop;
383
384         /* Get the serial format and clock direction. */
385         sprop = of_get_property(np, "fsl,mode", NULL);
386         if (!sprop) {
387                 dev_err(&pdev->dev, "fsl,mode property not found\n");
388                 ret = -EINVAL;
389                 goto error;
390         }
391
392         if (strcasecmp(sprop, "i2s-slave") == 0) {
393                 machine_data->dai_format = SND_SOC_DAIFMT_I2S;
394                 machine_data->codec_clk_direction = SND_SOC_CLOCK_OUT;
395                 machine_data->cpu_clk_direction = SND_SOC_CLOCK_IN;
396
397                 /* In i2s-slave mode, the codec has its own clock source, so we
398                  * need to get the frequency from the device tree and pass it to
399                  * the codec driver.
400                  */
401                 iprop = of_get_property(codec_np, "clock-frequency", NULL);
402                 if (!iprop || !*iprop) {
403                         dev_err(&pdev->dev, "codec bus-frequency "
404                                 "property is missing or invalid\n");
405                         ret = -EINVAL;
406                         goto error;
407                 }
408                 machine_data->clk_frequency = *iprop;
409         } else if (strcasecmp(sprop, "i2s-master") == 0) {
410                 machine_data->dai_format = SND_SOC_DAIFMT_I2S;
411                 machine_data->codec_clk_direction = SND_SOC_CLOCK_IN;
412                 machine_data->cpu_clk_direction = SND_SOC_CLOCK_OUT;
413         } else if (strcasecmp(sprop, "lj-slave") == 0) {
414                 machine_data->dai_format = SND_SOC_DAIFMT_LEFT_J;
415                 machine_data->codec_clk_direction = SND_SOC_CLOCK_OUT;
416                 machine_data->cpu_clk_direction = SND_SOC_CLOCK_IN;
417         } else if (strcasecmp(sprop, "lj-master") == 0) {
418                 machine_data->dai_format = SND_SOC_DAIFMT_LEFT_J;
419                 machine_data->codec_clk_direction = SND_SOC_CLOCK_IN;
420                 machine_data->cpu_clk_direction = SND_SOC_CLOCK_OUT;
421         } else if (strcasecmp(sprop, "rj-slave") == 0) {
422                 machine_data->dai_format = SND_SOC_DAIFMT_RIGHT_J;
423                 machine_data->codec_clk_direction = SND_SOC_CLOCK_OUT;
424                 machine_data->cpu_clk_direction = SND_SOC_CLOCK_IN;
425         } else if (strcasecmp(sprop, "rj-master") == 0) {
426                 machine_data->dai_format = SND_SOC_DAIFMT_RIGHT_J;
427                 machine_data->codec_clk_direction = SND_SOC_CLOCK_IN;
428                 machine_data->cpu_clk_direction = SND_SOC_CLOCK_OUT;
429         } else if (strcasecmp(sprop, "ac97-slave") == 0) {
430                 machine_data->dai_format = SND_SOC_DAIFMT_AC97;
431                 machine_data->codec_clk_direction = SND_SOC_CLOCK_OUT;
432                 machine_data->cpu_clk_direction = SND_SOC_CLOCK_IN;
433         } else if (strcasecmp(sprop, "ac97-master") == 0) {
434                 machine_data->dai_format = SND_SOC_DAIFMT_AC97;
435                 machine_data->codec_clk_direction = SND_SOC_CLOCK_IN;
436                 machine_data->cpu_clk_direction = SND_SOC_CLOCK_OUT;
437         } else {
438                 dev_err(&pdev->dev,
439                         "unrecognized fsl,mode property '%s'\n", sprop);
440                 ret = -EINVAL;
441                 goto error;
442         }
443
444         if (!machine_data->clk_frequency) {
445                 dev_err(&pdev->dev, "unknown clock frequency\n");
446                 ret = -EINVAL;
447                 goto error;
448         }
449
450         /* Find the playback DMA channel to use. */
451         machine_data->dai[0].platform_name = machine_data->platform_name[0];
452         ret = get_dma_channel(np, "fsl,playback-dma", &machine_data->dai[0],
453                               &machine_data->dma_channel_id[0],
454                               &machine_data->dma_id[0]);
455         if (ret) {
456                 dev_err(&pdev->dev, "missing/invalid playback DMA phandle\n");
457                 goto error;
458         }
459
460         /* Find the capture DMA channel to use. */
461         machine_data->dai[1].platform_name = machine_data->platform_name[1];
462         ret = get_dma_channel(np, "fsl,capture-dma", &machine_data->dai[1],
463                               &machine_data->dma_channel_id[1],
464                               &machine_data->dma_id[1]);
465         if (ret) {
466                 dev_err(&pdev->dev, "missing/invalid capture DMA phandle\n");
467                 goto error;
468         }
469
470         /* Initialize our DAI data structure.  */
471         machine_data->dai[0].stream_name = "playback";
472         machine_data->dai[1].stream_name = "capture";
473         machine_data->dai[0].name = machine_data->dai[0].stream_name;
474         machine_data->dai[1].name = machine_data->dai[1].stream_name;
475
476         machine_data->card.probe = mpc8610_hpcd_machine_probe;
477         machine_data->card.remove = mpc8610_hpcd_machine_remove;
478         machine_data->card.name = pdev->name; /* The platform driver name */
479         machine_data->card.num_links = 2;
480         machine_data->card.dai_link = machine_data->dai;
481
482         /* Allocate a new audio platform device structure */
483         sound_device = platform_device_alloc("soc-audio", -1);
484         if (!sound_device) {
485                 dev_err(&pdev->dev, "platform device alloc failed\n");
486                 ret = -ENOMEM;
487                 goto error;
488         }
489
490         /* Associate the card data with the sound device */
491         platform_set_drvdata(sound_device, &machine_data->card);
492
493         /* Register with ASoC */
494         ret = platform_device_add(sound_device);
495         if (ret) {
496                 dev_err(&pdev->dev, "platform device add failed\n");
497                 goto error;
498         }
499         dev_set_drvdata(&pdev->dev, sound_device);
500
501         of_node_put(codec_np);
502
503         return 0;
504
505 error:
506         of_node_put(codec_np);
507
508         if (sound_device)
509                 platform_device_unregister(sound_device);
510
511         kfree(machine_data);
512
513         return ret;
514 }
515
516 /**
517  * mpc8610_hpcd_remove: remove the platform device
518  *
519  * This function is called when the platform device is removed.
520  */
521 static int __devexit mpc8610_hpcd_remove(struct platform_device *pdev)
522 {
523         struct platform_device *sound_device = dev_get_drvdata(&pdev->dev);
524         struct snd_soc_card *card = platform_get_drvdata(sound_device);
525         struct mpc8610_hpcd_data *machine_data =
526                 container_of(card, struct mpc8610_hpcd_data, card);
527
528         platform_device_unregister(sound_device);
529
530         kfree(machine_data);
531         sound_device->dev.platform_data = NULL;
532
533         dev_set_drvdata(&pdev->dev, NULL);
534
535         return 0;
536 }
537
538 static struct platform_driver mpc8610_hpcd_driver = {
539         .probe = mpc8610_hpcd_probe,
540         .remove = __devexit_p(mpc8610_hpcd_remove),
541         .driver = {
542                 /* The name must match the 'model' property in the device tree,
543                  * in lowercase letters.
544                  */
545                 .name = "snd-soc-mpc8610hpcd",
546                 .owner = THIS_MODULE,
547         },
548 };
549
550 /**
551  * mpc8610_hpcd_init: machine driver initialization.
552  *
553  * This function is called when this module is loaded.
554  */
555 static int __init mpc8610_hpcd_init(void)
556 {
557         struct device_node *guts_np;
558         struct resource res;
559
560         pr_info("Freescale MPC8610 HPCD ALSA SoC machine driver\n");
561
562         /* Get the physical address of the global utilities registers */
563         guts_np = of_find_compatible_node(NULL, NULL, "fsl,mpc8610-guts");
564         if (of_address_to_resource(guts_np, 0, &res)) {
565                 pr_err("mpc8610-hpcd: missing/invalid global utilities node\n");
566                 return -EINVAL;
567         }
568         guts_phys = res.start;
569
570         return platform_driver_register(&mpc8610_hpcd_driver);
571 }
572
573 /**
574  * mpc8610_hpcd_exit: machine driver exit
575  *
576  * This function is called when this driver is unloaded.
577  */
578 static void __exit mpc8610_hpcd_exit(void)
579 {
580         platform_driver_unregister(&mpc8610_hpcd_driver);
581 }
582
583 module_init(mpc8610_hpcd_init);
584 module_exit(mpc8610_hpcd_exit);
585
586 MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
587 MODULE_DESCRIPTION("Freescale MPC8610 HPCD ALSA SoC machine driver");
588 MODULE_LICENSE("GPL v2");