simple_open: automatically convert to simple_open()
[linux-2.6.git] / sound / soc / imx / imx-audmux.c
1 /*
2  * Copyright 2012 Freescale Semiconductor, Inc.
3  * Copyright 2012 Linaro Ltd.
4  * Copyright 2009 Pengutronix, Sascha Hauer <s.hauer@pengutronix.de>
5  *
6  * Initial development of this code was funded by
7  * Phytec Messtechnik GmbH, http://www.phytec.de
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  */
19
20 #include <linux/clk.h>
21 #include <linux/debugfs.h>
22 #include <linux/err.h>
23 #include <linux/io.h>
24 #include <linux/module.h>
25 #include <linux/of.h>
26 #include <linux/of_device.h>
27 #include <linux/platform_device.h>
28 #include <linux/slab.h>
29
30 #include "imx-audmux.h"
31
32 #define DRIVER_NAME "imx-audmux"
33
34 static struct clk *audmux_clk;
35 static void __iomem *audmux_base;
36
37 #define IMX_AUDMUX_V2_PTCR(x)           ((x) * 8)
38 #define IMX_AUDMUX_V2_PDCR(x)           ((x) * 8 + 4)
39
40 #ifdef CONFIG_DEBUG_FS
41 static struct dentry *audmux_debugfs_root;
42
43 /* There is an annoying discontinuity in the SSI numbering with regard
44  * to the Linux number of the devices */
45 static const char *audmux_port_string(int port)
46 {
47         switch (port) {
48         case MX31_AUDMUX_PORT1_SSI0:
49                 return "imx-ssi.0";
50         case MX31_AUDMUX_PORT2_SSI1:
51                 return "imx-ssi.1";
52         case MX31_AUDMUX_PORT3_SSI_PINS_3:
53                 return "SSI3";
54         case MX31_AUDMUX_PORT4_SSI_PINS_4:
55                 return "SSI4";
56         case MX31_AUDMUX_PORT5_SSI_PINS_5:
57                 return "SSI5";
58         case MX31_AUDMUX_PORT6_SSI_PINS_6:
59                 return "SSI6";
60         default:
61                 return "UNKNOWN";
62         }
63 }
64
65 static ssize_t audmux_read_file(struct file *file, char __user *user_buf,
66                                 size_t count, loff_t *ppos)
67 {
68         ssize_t ret;
69         char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
70         int port = (int)file->private_data;
71         u32 pdcr, ptcr;
72
73         if (!buf)
74                 return -ENOMEM;
75
76         if (audmux_clk)
77                 clk_prepare_enable(audmux_clk);
78
79         ptcr = readl(audmux_base + IMX_AUDMUX_V2_PTCR(port));
80         pdcr = readl(audmux_base + IMX_AUDMUX_V2_PDCR(port));
81
82         if (audmux_clk)
83                 clk_disable_unprepare(audmux_clk);
84
85         ret = snprintf(buf, PAGE_SIZE, "PDCR: %08x\nPTCR: %08x\n",
86                        pdcr, ptcr);
87
88         if (ptcr & IMX_AUDMUX_V2_PTCR_TFSDIR)
89                 ret += snprintf(buf + ret, PAGE_SIZE - ret,
90                                 "TxFS output from %s, ",
91                                 audmux_port_string((ptcr >> 27) & 0x7));
92         else
93                 ret += snprintf(buf + ret, PAGE_SIZE - ret,
94                                 "TxFS input, ");
95
96         if (ptcr & IMX_AUDMUX_V2_PTCR_TCLKDIR)
97                 ret += snprintf(buf + ret, PAGE_SIZE - ret,
98                                 "TxClk output from %s",
99                                 audmux_port_string((ptcr >> 22) & 0x7));
100         else
101                 ret += snprintf(buf + ret, PAGE_SIZE - ret,
102                                 "TxClk input");
103
104         ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
105
106         if (ptcr & IMX_AUDMUX_V2_PTCR_SYN) {
107                 ret += snprintf(buf + ret, PAGE_SIZE - ret,
108                                 "Port is symmetric");
109         } else {
110                 if (ptcr & IMX_AUDMUX_V2_PTCR_RFSDIR)
111                         ret += snprintf(buf + ret, PAGE_SIZE - ret,
112                                         "RxFS output from %s, ",
113                                         audmux_port_string((ptcr >> 17) & 0x7));
114                 else
115                         ret += snprintf(buf + ret, PAGE_SIZE - ret,
116                                         "RxFS input, ");
117
118                 if (ptcr & IMX_AUDMUX_V2_PTCR_RCLKDIR)
119                         ret += snprintf(buf + ret, PAGE_SIZE - ret,
120                                         "RxClk output from %s",
121                                         audmux_port_string((ptcr >> 12) & 0x7));
122                 else
123                         ret += snprintf(buf + ret, PAGE_SIZE - ret,
124                                         "RxClk input");
125         }
126
127         ret += snprintf(buf + ret, PAGE_SIZE - ret,
128                         "\nData received from %s\n",
129                         audmux_port_string((pdcr >> 13) & 0x7));
130
131         ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
132
133         kfree(buf);
134
135         return ret;
136 }
137
138 static const struct file_operations audmux_debugfs_fops = {
139         .open = simple_open,
140         .read = audmux_read_file,
141         .llseek = default_llseek,
142 };
143
144 static void __init audmux_debugfs_init(void)
145 {
146         int i;
147         char buf[20];
148
149         audmux_debugfs_root = debugfs_create_dir("audmux", NULL);
150         if (!audmux_debugfs_root) {
151                 pr_warning("Failed to create AUDMUX debugfs root\n");
152                 return;
153         }
154
155         for (i = 1; i < 8; i++) {
156                 snprintf(buf, sizeof(buf), "ssi%d", i);
157                 if (!debugfs_create_file(buf, 0444, audmux_debugfs_root,
158                                          (void *)i, &audmux_debugfs_fops))
159                         pr_warning("Failed to create AUDMUX port %d debugfs file\n",
160                                    i);
161         }
162 }
163
164 static void __devexit audmux_debugfs_remove(void)
165 {
166         debugfs_remove_recursive(audmux_debugfs_root);
167 }
168 #else
169 static inline void audmux_debugfs_init(void)
170 {
171 }
172
173 static inline void audmux_debugfs_remove(void)
174 {
175 }
176 #endif
177
178 enum imx_audmux_type {
179         IMX21_AUDMUX,
180         IMX31_AUDMUX,
181 } audmux_type;
182
183 static struct platform_device_id imx_audmux_ids[] = {
184         {
185                 .name = "imx21-audmux",
186                 .driver_data = IMX21_AUDMUX,
187         }, {
188                 .name = "imx31-audmux",
189                 .driver_data = IMX31_AUDMUX,
190         }, {
191                 /* sentinel */
192         }
193 };
194 MODULE_DEVICE_TABLE(platform, imx_audmux_ids);
195
196 static const struct of_device_id imx_audmux_dt_ids[] = {
197         { .compatible = "fsl,imx21-audmux", .data = &imx_audmux_ids[0], },
198         { .compatible = "fsl,imx31-audmux", .data = &imx_audmux_ids[1], },
199         { /* sentinel */ }
200 };
201 MODULE_DEVICE_TABLE(of, imx_audmux_dt_ids);
202
203 static const uint8_t port_mapping[] = {
204         0x0, 0x4, 0x8, 0x10, 0x14, 0x1c,
205 };
206
207 int imx_audmux_v1_configure_port(unsigned int port, unsigned int pcr)
208 {
209         if (audmux_type != IMX21_AUDMUX)
210                 return -EINVAL;
211
212         if (!audmux_base)
213                 return -ENOSYS;
214
215         if (port >= ARRAY_SIZE(port_mapping))
216                 return -EINVAL;
217
218         writel(pcr, audmux_base + port_mapping[port]);
219
220         return 0;
221 }
222 EXPORT_SYMBOL_GPL(imx_audmux_v1_configure_port);
223
224 int imx_audmux_v2_configure_port(unsigned int port, unsigned int ptcr,
225                 unsigned int pdcr)
226 {
227         if (audmux_type != IMX31_AUDMUX)
228                 return -EINVAL;
229
230         if (!audmux_base)
231                 return -ENOSYS;
232
233         if (audmux_clk)
234                 clk_prepare_enable(audmux_clk);
235
236         writel(ptcr, audmux_base + IMX_AUDMUX_V2_PTCR(port));
237         writel(pdcr, audmux_base + IMX_AUDMUX_V2_PDCR(port));
238
239         if (audmux_clk)
240                 clk_disable_unprepare(audmux_clk);
241
242         return 0;
243 }
244 EXPORT_SYMBOL_GPL(imx_audmux_v2_configure_port);
245
246 static int __devinit imx_audmux_probe(struct platform_device *pdev)
247 {
248         struct resource *res;
249         const struct of_device_id *of_id =
250                         of_match_device(imx_audmux_dt_ids, &pdev->dev);
251
252         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
253         audmux_base = devm_request_and_ioremap(&pdev->dev, res);
254         if (!audmux_base)
255                 return -EADDRNOTAVAIL;
256
257         audmux_clk = clk_get(&pdev->dev, "audmux");
258         if (IS_ERR(audmux_clk)) {
259                 dev_dbg(&pdev->dev, "cannot get clock: %ld\n",
260                                 PTR_ERR(audmux_clk));
261                 audmux_clk = NULL;
262         }
263
264         if (of_id)
265                 pdev->id_entry = of_id->data;
266         audmux_type = pdev->id_entry->driver_data;
267         if (audmux_type == IMX31_AUDMUX)
268                 audmux_debugfs_init();
269
270         return 0;
271 }
272
273 static int __devexit imx_audmux_remove(struct platform_device *pdev)
274 {
275         if (audmux_type == IMX31_AUDMUX)
276                 audmux_debugfs_remove();
277         clk_put(audmux_clk);
278
279         return 0;
280 }
281
282 static struct platform_driver imx_audmux_driver = {
283         .probe          = imx_audmux_probe,
284         .remove         = __devexit_p(imx_audmux_remove),
285         .id_table       = imx_audmux_ids,
286         .driver = {
287                 .name   = DRIVER_NAME,
288                 .owner  = THIS_MODULE,
289                 .of_match_table = imx_audmux_dt_ids,
290         }
291 };
292
293 static int __init imx_audmux_init(void)
294 {
295         return platform_driver_register(&imx_audmux_driver);
296 }
297 subsys_initcall(imx_audmux_init);
298
299 static void __exit imx_audmux_exit(void)
300 {
301         platform_driver_unregister(&imx_audmux_driver);
302 }
303 module_exit(imx_audmux_exit);
304
305 MODULE_DESCRIPTION("Freescale i.MX AUDMUX driver");
306 MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
307 MODULE_LICENSE("GPL v2");
308 MODULE_ALIAS("platform:" DRIVER_NAME);