Sascha Hauer | 9eedbdf | 2009-10-29 17:12:39 +0100 | [diff] [blame] | 1 | /* |
Richard Zhao | 3bc34a6 | 2012-03-05 22:30:52 +0800 | [diff] [blame] | 2 | * Copyright 2012 Freescale Semiconductor, Inc. |
| 3 | * Copyright 2012 Linaro Ltd. |
Sascha Hauer | 9eedbdf | 2009-10-29 17:12:39 +0100 | [diff] [blame] | 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. |
Sascha Hauer | 9eedbdf | 2009-10-29 17:12:39 +0100 | [diff] [blame] | 18 | */ |
| 19 | |
Sascha Hauer | 9eedbdf | 2009-10-29 17:12:39 +0100 | [diff] [blame] | 20 | #include <linux/clk.h> |
Mark Brown | 7b4e08a | 2010-01-11 16:33:18 +0000 | [diff] [blame] | 21 | #include <linux/debugfs.h> |
Richard Zhao | 3bc34a6 | 2012-03-05 22:30:52 +0800 | [diff] [blame] | 22 | #include <linux/err.h> |
| 23 | #include <linux/io.h> |
| 24 | #include <linux/module.h> |
Richard Zhao | 9d5ef26 | 2012-03-05 22:31:04 +0800 | [diff] [blame] | 25 | #include <linux/of.h> |
| 26 | #include <linux/of_device.h> |
Richard Zhao | 3bc34a6 | 2012-03-05 22:30:52 +0800 | [diff] [blame] | 27 | #include <linux/platform_device.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 28 | #include <linux/slab.h> |
Shawn Guo | 3c77c29 | 2012-03-05 22:30:53 +0800 | [diff] [blame] | 29 | |
| 30 | #include "imx-audmux.h" |
Richard Zhao | 3bc34a6 | 2012-03-05 22:30:52 +0800 | [diff] [blame] | 31 | |
| 32 | #define DRIVER_NAME "imx-audmux" |
Sascha Hauer | 9eedbdf | 2009-10-29 17:12:39 +0100 | [diff] [blame] | 33 | |
| 34 | static struct clk *audmux_clk; |
| 35 | static void __iomem *audmux_base; |
| 36 | |
Shawn Guo | af4872f | 2012-03-05 22:30:54 +0800 | [diff] [blame] | 37 | #define IMX_AUDMUX_V2_PTCR(x) ((x) * 8) |
| 38 | #define IMX_AUDMUX_V2_PDCR(x) ((x) * 8 + 4) |
Sascha Hauer | 9eedbdf | 2009-10-29 17:12:39 +0100 | [diff] [blame] | 39 | |
Mark Brown | 7b4e08a | 2010-01-11 16:33:18 +0000 | [diff] [blame] | 40 | #ifdef CONFIG_DEBUG_FS |
| 41 | static struct dentry *audmux_debugfs_root; |
| 42 | |
Mark Brown | 7b4e08a | 2010-01-11 16:33:18 +0000 | [diff] [blame] | 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) |
Linus Torvalds | 3480059 | 2012-03-27 16:41:24 -0700 | [diff] [blame] | 77 | clk_prepare_enable(audmux_clk); |
Mark Brown | 7b4e08a | 2010-01-11 16:33:18 +0000 | [diff] [blame] | 78 | |
Shawn Guo | af4872f | 2012-03-05 22:30:54 +0800 | [diff] [blame] | 79 | ptcr = readl(audmux_base + IMX_AUDMUX_V2_PTCR(port)); |
| 80 | pdcr = readl(audmux_base + IMX_AUDMUX_V2_PDCR(port)); |
Mark Brown | 7b4e08a | 2010-01-11 16:33:18 +0000 | [diff] [blame] | 81 | |
| 82 | if (audmux_clk) |
Linus Torvalds | 3480059 | 2012-03-27 16:41:24 -0700 | [diff] [blame] | 83 | clk_disable_unprepare(audmux_clk); |
Mark Brown | 7b4e08a | 2010-01-11 16:33:18 +0000 | [diff] [blame] | 84 | |
| 85 | ret = snprintf(buf, PAGE_SIZE, "PDCR: %08x\nPTCR: %08x\n", |
| 86 | pdcr, ptcr); |
| 87 | |
Shawn Guo | af4872f | 2012-03-05 22:30:54 +0800 | [diff] [blame] | 88 | if (ptcr & IMX_AUDMUX_V2_PTCR_TFSDIR) |
Mark Brown | 7b4e08a | 2010-01-11 16:33:18 +0000 | [diff] [blame] | 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 | |
Shawn Guo | af4872f | 2012-03-05 22:30:54 +0800 | [diff] [blame] | 96 | if (ptcr & IMX_AUDMUX_V2_PTCR_TCLKDIR) |
Mark Brown | 7b4e08a | 2010-01-11 16:33:18 +0000 | [diff] [blame] | 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 | |
Shawn Guo | af4872f | 2012-03-05 22:30:54 +0800 | [diff] [blame] | 106 | if (ptcr & IMX_AUDMUX_V2_PTCR_SYN) { |
Mark Brown | 7b4e08a | 2010-01-11 16:33:18 +0000 | [diff] [blame] | 107 | ret += snprintf(buf + ret, PAGE_SIZE - ret, |
| 108 | "Port is symmetric"); |
| 109 | } else { |
Shawn Guo | af4872f | 2012-03-05 22:30:54 +0800 | [diff] [blame] | 110 | if (ptcr & IMX_AUDMUX_V2_PTCR_RFSDIR) |
Mark Brown | 7b4e08a | 2010-01-11 16:33:18 +0000 | [diff] [blame] | 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 | |
Shawn Guo | af4872f | 2012-03-05 22:30:54 +0800 | [diff] [blame] | 118 | if (ptcr & IMX_AUDMUX_V2_PTCR_RCLKDIR) |
Mark Brown | 7b4e08a | 2010-01-11 16:33:18 +0000 | [diff] [blame] | 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 = { |
Stephen Boyd | 234e340 | 2012-04-05 14:25:11 -0700 | [diff] [blame] | 139 | .open = simple_open, |
Mark Brown | 7b4e08a | 2010-01-11 16:33:18 +0000 | [diff] [blame] | 140 | .read = audmux_read_file, |
Arnd Bergmann | 6038f37 | 2010-08-15 18:52:59 +0200 | [diff] [blame] | 141 | .llseek = default_llseek, |
Mark Brown | 7b4e08a | 2010-01-11 16:33:18 +0000 | [diff] [blame] | 142 | }; |
| 143 | |
Richard Zhao | 3bc34a6 | 2012-03-05 22:30:52 +0800 | [diff] [blame] | 144 | static void __init audmux_debugfs_init(void) |
Mark Brown | 7b4e08a | 2010-01-11 16:33:18 +0000 | [diff] [blame] | 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 | } |
Richard Zhao | 3bc34a6 | 2012-03-05 22:30:52 +0800 | [diff] [blame] | 163 | |
Fabio Estevam | fb97624a | 2012-03-07 15:19:57 -0300 | [diff] [blame] | 164 | static void __devexit audmux_debugfs_remove(void) |
Richard Zhao | 3bc34a6 | 2012-03-05 22:30:52 +0800 | [diff] [blame] | 165 | { |
| 166 | debugfs_remove_recursive(audmux_debugfs_root); |
| 167 | } |
Mark Brown | 7b4e08a | 2010-01-11 16:33:18 +0000 | [diff] [blame] | 168 | #else |
| 169 | static inline void audmux_debugfs_init(void) |
| 170 | { |
| 171 | } |
Richard Zhao | 3bc34a6 | 2012-03-05 22:30:52 +0800 | [diff] [blame] | 172 | |
| 173 | static inline void audmux_debugfs_remove(void) |
| 174 | { |
| 175 | } |
Mark Brown | 7b4e08a | 2010-01-11 16:33:18 +0000 | [diff] [blame] | 176 | #endif |
| 177 | |
Richard Zhao | 3bc34a6 | 2012-03-05 22:30:52 +0800 | [diff] [blame] | 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 | |
Richard Zhao | 9d5ef26 | 2012-03-05 22:31:04 +0800 | [diff] [blame] | 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 | |
Shawn Guo | 2405fc9 | 2012-03-05 22:30:51 +0800 | [diff] [blame] | 203 | static const uint8_t port_mapping[] = { |
| 204 | 0x0, 0x4, 0x8, 0x10, 0x14, 0x1c, |
| 205 | }; |
| 206 | |
Shawn Guo | af4872f | 2012-03-05 22:30:54 +0800 | [diff] [blame] | 207 | int imx_audmux_v1_configure_port(unsigned int port, unsigned int pcr) |
Shawn Guo | 2405fc9 | 2012-03-05 22:30:51 +0800 | [diff] [blame] | 208 | { |
Richard Zhao | 3bc34a6 | 2012-03-05 22:30:52 +0800 | [diff] [blame] | 209 | if (audmux_type != IMX21_AUDMUX) |
| 210 | return -EINVAL; |
| 211 | |
Shawn Guo | 2405fc9 | 2012-03-05 22:30:51 +0800 | [diff] [blame] | 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 | } |
Shawn Guo | af4872f | 2012-03-05 22:30:54 +0800 | [diff] [blame] | 222 | EXPORT_SYMBOL_GPL(imx_audmux_v1_configure_port); |
Shawn Guo | 2405fc9 | 2012-03-05 22:30:51 +0800 | [diff] [blame] | 223 | |
Shawn Guo | af4872f | 2012-03-05 22:30:54 +0800 | [diff] [blame] | 224 | int imx_audmux_v2_configure_port(unsigned int port, unsigned int ptcr, |
Sascha Hauer | 9eedbdf | 2009-10-29 17:12:39 +0100 | [diff] [blame] | 225 | unsigned int pdcr) |
| 226 | { |
Richard Zhao | 3bc34a6 | 2012-03-05 22:30:52 +0800 | [diff] [blame] | 227 | if (audmux_type != IMX31_AUDMUX) |
| 228 | return -EINVAL; |
| 229 | |
Sascha Hauer | 9eedbdf | 2009-10-29 17:12:39 +0100 | [diff] [blame] | 230 | if (!audmux_base) |
| 231 | return -ENOSYS; |
| 232 | |
| 233 | if (audmux_clk) |
Linus Torvalds | 3480059 | 2012-03-27 16:41:24 -0700 | [diff] [blame] | 234 | clk_prepare_enable(audmux_clk); |
Sascha Hauer | 9eedbdf | 2009-10-29 17:12:39 +0100 | [diff] [blame] | 235 | |
Shawn Guo | af4872f | 2012-03-05 22:30:54 +0800 | [diff] [blame] | 236 | writel(ptcr, audmux_base + IMX_AUDMUX_V2_PTCR(port)); |
| 237 | writel(pdcr, audmux_base + IMX_AUDMUX_V2_PDCR(port)); |
Sascha Hauer | 9eedbdf | 2009-10-29 17:12:39 +0100 | [diff] [blame] | 238 | |
| 239 | if (audmux_clk) |
Linus Torvalds | 3480059 | 2012-03-27 16:41:24 -0700 | [diff] [blame] | 240 | clk_disable_unprepare(audmux_clk); |
Sascha Hauer | 9eedbdf | 2009-10-29 17:12:39 +0100 | [diff] [blame] | 241 | |
| 242 | return 0; |
| 243 | } |
Shawn Guo | af4872f | 2012-03-05 22:30:54 +0800 | [diff] [blame] | 244 | EXPORT_SYMBOL_GPL(imx_audmux_v2_configure_port); |
Sascha Hauer | 9eedbdf | 2009-10-29 17:12:39 +0100 | [diff] [blame] | 245 | |
Fabio Estevam | fb97624a | 2012-03-07 15:19:57 -0300 | [diff] [blame] | 246 | static int __devinit imx_audmux_probe(struct platform_device *pdev) |
Sascha Hauer | 9eedbdf | 2009-10-29 17:12:39 +0100 | [diff] [blame] | 247 | { |
Richard Zhao | 3bc34a6 | 2012-03-05 22:30:52 +0800 | [diff] [blame] | 248 | struct resource *res; |
Richard Zhao | 9d5ef26 | 2012-03-05 22:31:04 +0800 | [diff] [blame] | 249 | const struct of_device_id *of_id = |
| 250 | of_match_device(imx_audmux_dt_ids, &pdev->dev); |
Richard Zhao | 3bc34a6 | 2012-03-05 22:30:52 +0800 | [diff] [blame] | 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; |
Eric BĂ©nard | 8402ed3 | 2010-06-08 11:03:00 +0200 | [diff] [blame] | 262 | } |
Sascha Hauer | 56c6b87 | 2011-08-23 21:24:57 +0200 | [diff] [blame] | 263 | |
Richard Zhao | 9d5ef26 | 2012-03-05 22:31:04 +0800 | [diff] [blame] | 264 | if (of_id) |
| 265 | pdev->id_entry = of_id->data; |
Richard Zhao | 3bc34a6 | 2012-03-05 22:30:52 +0800 | [diff] [blame] | 266 | audmux_type = pdev->id_entry->driver_data; |
| 267 | if (audmux_type == IMX31_AUDMUX) |
Shawn Guo | 2405fc9 | 2012-03-05 22:30:51 +0800 | [diff] [blame] | 268 | audmux_debugfs_init(); |
Mark Brown | 7b4e08a | 2010-01-11 16:33:18 +0000 | [diff] [blame] | 269 | |
Sascha Hauer | 9eedbdf | 2009-10-29 17:12:39 +0100 | [diff] [blame] | 270 | return 0; |
| 271 | } |
| 272 | |
Fabio Estevam | fb97624a | 2012-03-07 15:19:57 -0300 | [diff] [blame] | 273 | static int __devexit imx_audmux_remove(struct platform_device *pdev) |
Richard Zhao | 3bc34a6 | 2012-03-05 22:30:52 +0800 | [diff] [blame] | 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, |
Fabio Estevam | fb97624a | 2012-03-07 15:19:57 -0300 | [diff] [blame] | 284 | .remove = __devexit_p(imx_audmux_remove), |
Richard Zhao | 3bc34a6 | 2012-03-05 22:30:52 +0800 | [diff] [blame] | 285 | .id_table = imx_audmux_ids, |
| 286 | .driver = { |
| 287 | .name = DRIVER_NAME, |
| 288 | .owner = THIS_MODULE, |
Richard Zhao | 9d5ef26 | 2012-03-05 22:31:04 +0800 | [diff] [blame] | 289 | .of_match_table = imx_audmux_dt_ids, |
Richard Zhao | 3bc34a6 | 2012-03-05 22:30:52 +0800 | [diff] [blame] | 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); |