ALSA: ASoC: Blackfin: update SPORT0 port selector (v2)
[linux-2.6.git] / sound / soc / fsl / soc-of-simple.c
1 /*
2  * OF helpers for ALSA SoC Layer
3  *
4  * Copyright (C) 2008, Secret Lab Technologies Ltd.
5  */
6
7 #include <linux/module.h>
8 #include <linux/moduleparam.h>
9 #include <linux/init.h>
10 #include <linux/delay.h>
11 #include <linux/pm.h>
12 #include <linux/bitops.h>
13 #include <linux/platform_device.h>
14 #include <linux/of.h>
15 #include <sound/core.h>
16 #include <sound/pcm.h>
17 #include <sound/pcm_params.h>
18 #include <sound/soc.h>
19 #include <sound/soc-of-simple.h>
20 #include <sound/initval.h>
21
22 MODULE_AUTHOR("Grant Likely <grant.likely@secretlab.ca>");
23 MODULE_LICENSE("GPL");
24 MODULE_DESCRIPTION("ALSA SoC OpenFirmware bindings");
25
26 static DEFINE_MUTEX(of_snd_soc_mutex);
27 static LIST_HEAD(of_snd_soc_device_list);
28 static int of_snd_soc_next_index;
29
30 struct of_snd_soc_device {
31         int id;
32         struct list_head list;
33         struct snd_soc_device device;
34         struct snd_soc_machine machine;
35         struct snd_soc_dai_link dai_link;
36         struct platform_device *pdev;
37         struct device_node *platform_node;
38         struct device_node *codec_node;
39 };
40
41 static struct snd_soc_ops of_snd_soc_ops = {
42 };
43
44 static struct of_snd_soc_device *
45 of_snd_soc_get_device(struct device_node *codec_node)
46 {
47         struct of_snd_soc_device *of_soc;
48
49         list_for_each_entry(of_soc, &of_snd_soc_device_list, list) {
50                 if (of_soc->codec_node == codec_node)
51                         return of_soc;
52         }
53
54         of_soc = kzalloc(sizeof(struct of_snd_soc_device), GFP_KERNEL);
55         if (!of_soc)
56                 return NULL;
57
58         /* Initialize the structure and add it to the global list */
59         of_soc->codec_node = codec_node;
60         of_soc->id = of_snd_soc_next_index++;
61         of_soc->machine.dai_link = &of_soc->dai_link;
62         of_soc->machine.num_links = 1;
63         of_soc->device.machine = &of_soc->machine;
64         of_soc->dai_link.ops = &of_snd_soc_ops;
65         list_add(&of_soc->list, &of_snd_soc_device_list);
66
67         return of_soc;
68 }
69
70 static void of_snd_soc_register_device(struct of_snd_soc_device *of_soc)
71 {
72         struct platform_device *pdev;
73         int rc;
74
75         /* Only register the device if both the codec and platform have
76          * been registered */
77         if ((!of_soc->device.codec_data) || (!of_soc->platform_node))
78                 return;
79
80         pr_info("platform<-->codec match achieved; registering machine\n");
81
82         pdev = platform_device_alloc("soc-audio", of_soc->id);
83         if (!pdev) {
84                 pr_err("of_soc: platform_device_alloc() failed\n");
85                 return;
86         }
87
88         pdev->dev.platform_data = of_soc;
89         platform_set_drvdata(pdev, &of_soc->device);
90         of_soc->device.dev = &pdev->dev;
91
92         /* The ASoC device is complete; register it */
93         rc = platform_device_add(pdev);
94         if (rc) {
95                 pr_err("of_soc: platform_device_add() failed\n");
96                 return;
97         }
98
99 }
100
101 int of_snd_soc_register_codec(struct snd_soc_codec_device *codec_dev,
102                               void *codec_data, struct snd_soc_dai *dai,
103                               struct device_node *node)
104 {
105         struct of_snd_soc_device *of_soc;
106         int rc = 0;
107
108         pr_info("registering ASoC codec driver: %s\n", node->full_name);
109
110         mutex_lock(&of_snd_soc_mutex);
111         of_soc = of_snd_soc_get_device(node);
112         if (!of_soc) {
113                 rc = -ENOMEM;
114                 goto out;
115         }
116
117         /* Store the codec data */
118         of_soc->device.codec_data = codec_data;
119         of_soc->device.codec_dev = codec_dev;
120         of_soc->dai_link.name = (char *)node->name;
121         of_soc->dai_link.stream_name = (char *)node->name;
122         of_soc->dai_link.codec_dai = dai;
123
124         /* Now try to register the SoC device */
125         of_snd_soc_register_device(of_soc);
126
127  out:
128         mutex_unlock(&of_snd_soc_mutex);
129         return rc;
130 }
131 EXPORT_SYMBOL_GPL(of_snd_soc_register_codec);
132
133 int of_snd_soc_register_platform(struct snd_soc_platform *platform,
134                                  struct device_node *node,
135                                  struct snd_soc_dai *cpu_dai)
136 {
137         struct of_snd_soc_device *of_soc;
138         struct device_node *codec_node;
139         const phandle *handle;
140         int len, rc = 0;
141
142         pr_info("registering ASoC platform driver: %s\n", node->full_name);
143
144         handle = of_get_property(node, "codec-handle", &len);
145         if (!handle || len < sizeof(handle))
146                 return -ENODEV;
147         codec_node = of_find_node_by_phandle(*handle);
148         if (!codec_node)
149                 return -ENODEV;
150         pr_info("looking for codec: %s\n", codec_node->full_name);
151
152         mutex_lock(&of_snd_soc_mutex);
153         of_soc = of_snd_soc_get_device(codec_node);
154         if (!of_soc) {
155                 rc = -ENOMEM;
156                 goto out;
157         }
158
159         of_soc->platform_node = node;
160         of_soc->dai_link.cpu_dai = cpu_dai;
161         of_soc->device.platform = platform;
162         of_soc->machine.name = of_soc->dai_link.cpu_dai->name;
163
164         /* Now try to register the SoC device */
165         of_snd_soc_register_device(of_soc);
166
167  out:
168         mutex_unlock(&of_snd_soc_mutex);
169         return rc;
170 }
171 EXPORT_SYMBOL_GPL(of_snd_soc_register_platform);