]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/arch/arm/mach-pxa/ssp.c | |
3 | * | |
4 | * based on linux/arch/arm/mach-sa1100/ssp.c by Russell King | |
5 | * | |
6 | * Copyright (C) 2003 Russell King. | |
7 | * Copyright (C) 2003 Wolfson Microelectronics PLC | |
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 version 2 as | |
11 | * published by the Free Software Foundation. | |
12 | * | |
13 | * PXA2xx SSP driver. This provides the generic core for simple | |
14 | * IO-based SSP applications and allows easy port setup for DMA access. | |
15 | * | |
16 | * Author: Liam Girdwood <liam.girdwood@wolfsonmicro.com> | |
1da177e4 LT |
17 | */ |
18 | ||
19 | #include <linux/module.h> | |
20 | #include <linux/kernel.h> | |
21 | #include <linux/sched.h> | |
22 | #include <linux/slab.h> | |
23 | #include <linux/errno.h> | |
24 | #include <linux/interrupt.h> | |
25 | #include <linux/ioport.h> | |
26 | #include <linux/init.h> | |
00431707 | 27 | #include <linux/mutex.h> |
88286450 | 28 | #include <linux/clk.h> |
29 | #include <linux/err.h> | |
30 | #include <linux/platform_device.h> | |
8348c259 | 31 | #include <linux/spi/pxa2xx_spi.h> |
fced80c7 | 32 | #include <linux/io.h> |
a6e56c28 DM |
33 | #include <linux/of.h> |
34 | #include <linux/of_device.h> | |
88286450 | 35 | |
1da177e4 | 36 | #include <asm/irq.h> |
a09e64fb | 37 | #include <mach/hardware.h> |
1da177e4 | 38 | |
88286450 | 39 | static DEFINE_MUTEX(ssp_lock); |
40 | static LIST_HEAD(ssp_list); | |
41 | ||
baffe169 | 42 | struct ssp_device *pxa_ssp_request(int port, const char *label) |
88286450 | 43 | { |
44 | struct ssp_device *ssp = NULL; | |
45 | ||
46 | mutex_lock(&ssp_lock); | |
1da177e4 | 47 | |
88286450 | 48 | list_for_each_entry(ssp, &ssp_list, node) { |
49 | if (ssp->port_id == port && ssp->use_count == 0) { | |
50 | ssp->use_count++; | |
51 | ssp->label = label; | |
52 | break; | |
53 | } | |
1da177e4 LT |
54 | } |
55 | ||
88286450 | 56 | mutex_unlock(&ssp_lock); |
57 | ||
a4aff223 | 58 | if (&ssp->node == &ssp_list) |
88286450 | 59 | return NULL; |
60 | ||
61 | return ssp; | |
62 | } | |
baffe169 | 63 | EXPORT_SYMBOL(pxa_ssp_request); |
88286450 | 64 | |
6446221c DM |
65 | struct ssp_device *pxa_ssp_request_of(const struct device_node *of_node, |
66 | const char *label) | |
67 | { | |
68 | struct ssp_device *ssp = NULL; | |
69 | ||
70 | mutex_lock(&ssp_lock); | |
71 | ||
72 | list_for_each_entry(ssp, &ssp_list, node) { | |
73 | if (ssp->of_node == of_node && ssp->use_count == 0) { | |
74 | ssp->use_count++; | |
75 | ssp->label = label; | |
76 | break; | |
77 | } | |
78 | } | |
79 | ||
80 | mutex_unlock(&ssp_lock); | |
81 | ||
82 | if (&ssp->node == &ssp_list) | |
83 | return NULL; | |
84 | ||
85 | return ssp; | |
86 | } | |
87 | EXPORT_SYMBOL(pxa_ssp_request_of); | |
88 | ||
baffe169 | 89 | void pxa_ssp_free(struct ssp_device *ssp) |
88286450 | 90 | { |
91 | mutex_lock(&ssp_lock); | |
92 | if (ssp->use_count) { | |
93 | ssp->use_count--; | |
94 | ssp->label = NULL; | |
95 | } else | |
96 | dev_err(&ssp->pdev->dev, "device already free\n"); | |
97 | mutex_unlock(&ssp_lock); | |
1da177e4 | 98 | } |
baffe169 | 99 | EXPORT_SYMBOL(pxa_ssp_free); |
88286450 | 100 | |
a6e56c28 DM |
101 | #ifdef CONFIG_OF |
102 | static const struct of_device_id pxa_ssp_of_ids[] = { | |
103 | { .compatible = "mrvl,pxa25x-ssp", .data = (void *) PXA25x_SSP }, | |
104 | { .compatible = "mvrl,pxa25x-nssp", .data = (void *) PXA25x_NSSP }, | |
105 | { .compatible = "mrvl,pxa27x-ssp", .data = (void *) PXA27x_SSP }, | |
106 | { .compatible = "mrvl,pxa3xx-ssp", .data = (void *) PXA3xx_SSP }, | |
107 | { .compatible = "mvrl,pxa168-ssp", .data = (void *) PXA168_SSP }, | |
108 | { .compatible = "mrvl,pxa910-ssp", .data = (void *) PXA910_SSP }, | |
109 | { .compatible = "mrvl,ce4100-ssp", .data = (void *) CE4100_SSP }, | |
110 | { .compatible = "mrvl,lpss-ssp", .data = (void *) LPSS_SSP }, | |
111 | { }, | |
112 | }; | |
113 | MODULE_DEVICE_TABLE(of, pxa_ssp_of_ids); | |
114 | #endif | |
115 | ||
351a102d | 116 | static int pxa_ssp_probe(struct platform_device *pdev) |
88286450 | 117 | { |
118 | struct resource *res; | |
119 | struct ssp_device *ssp; | |
970d8a71 | 120 | struct device *dev = &pdev->dev; |
88286450 | 121 | |
1c459de1 | 122 | ssp = devm_kzalloc(dev, sizeof(struct ssp_device), GFP_KERNEL); |
64be2814 | 123 | if (ssp == NULL) |
88286450 | 124 | return -ENOMEM; |
64be2814 | 125 | |
919dcb21 | 126 | ssp->pdev = pdev; |
88286450 | 127 | |
1c459de1 DM |
128 | ssp->clk = devm_clk_get(dev, NULL); |
129 | if (IS_ERR(ssp->clk)) | |
130 | return PTR_ERR(ssp->clk); | |
88286450 | 131 | |
a6e56c28 DM |
132 | if (dev->of_node) { |
133 | struct of_phandle_args dma_spec; | |
134 | struct device_node *np = dev->of_node; | |
d5ece937 | 135 | int ret; |
a6e56c28 DM |
136 | |
137 | /* | |
138 | * FIXME: we should allocate the DMA channel from this | |
139 | * context and pass the channel down to the ssp users. | |
140 | * For now, we lookup the rx and tx indices manually | |
141 | */ | |
142 | ||
143 | /* rx */ | |
d5ece937 OJ |
144 | ret = of_parse_phandle_with_args(np, "dmas", "#dma-cells", |
145 | 0, &dma_spec); | |
146 | ||
147 | if (ret) { | |
148 | dev_err(dev, "Can't parse dmas property\n"); | |
149 | return -ENODEV; | |
150 | } | |
a6e56c28 DM |
151 | ssp->drcmr_rx = dma_spec.args[0]; |
152 | of_node_put(dma_spec.np); | |
153 | ||
154 | /* tx */ | |
d5ece937 OJ |
155 | ret = of_parse_phandle_with_args(np, "dmas", "#dma-cells", |
156 | 1, &dma_spec); | |
157 | if (ret) { | |
158 | dev_err(dev, "Can't parse dmas property\n"); | |
159 | return -ENODEV; | |
160 | } | |
a6e56c28 DM |
161 | ssp->drcmr_tx = dma_spec.args[0]; |
162 | of_node_put(dma_spec.np); | |
163 | } else { | |
164 | res = platform_get_resource(pdev, IORESOURCE_DMA, 0); | |
165 | if (res == NULL) { | |
166 | dev_err(dev, "no SSP RX DRCMR defined\n"); | |
167 | return -ENODEV; | |
168 | } | |
169 | ssp->drcmr_rx = res->start; | |
077de1ad | 170 | |
a6e56c28 DM |
171 | res = platform_get_resource(pdev, IORESOURCE_DMA, 1); |
172 | if (res == NULL) { | |
173 | dev_err(dev, "no SSP TX DRCMR defined\n"); | |
174 | return -ENODEV; | |
175 | } | |
176 | ssp->drcmr_tx = res->start; | |
077de1ad | 177 | } |
077de1ad | 178 | |
88286450 | 179 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
180 | if (res == NULL) { | |
970d8a71 | 181 | dev_err(dev, "no memory resource defined\n"); |
1c459de1 | 182 | return -ENODEV; |
88286450 | 183 | } |
184 | ||
1c459de1 DM |
185 | res = devm_request_mem_region(dev, res->start, resource_size(res), |
186 | pdev->name); | |
88286450 | 187 | if (res == NULL) { |
970d8a71 | 188 | dev_err(dev, "failed to request memory resource\n"); |
1c459de1 | 189 | return -EBUSY; |
88286450 | 190 | } |
191 | ||
192 | ssp->phys_base = res->start; | |
193 | ||
1c459de1 | 194 | ssp->mmio_base = devm_ioremap(dev, res->start, resource_size(res)); |
88286450 | 195 | if (ssp->mmio_base == NULL) { |
970d8a71 | 196 | dev_err(dev, "failed to ioremap() registers\n"); |
1c459de1 | 197 | return -ENODEV; |
88286450 | 198 | } |
199 | ||
200 | ssp->irq = platform_get_irq(pdev, 0); | |
201 | if (ssp->irq < 0) { | |
970d8a71 | 202 | dev_err(dev, "no IRQ resource defined\n"); |
1c459de1 | 203 | return -ENODEV; |
88286450 | 204 | } |
205 | ||
a6e56c28 DM |
206 | if (dev->of_node) { |
207 | const struct of_device_id *id = | |
208 | of_match_device(of_match_ptr(pxa_ssp_of_ids), dev); | |
209 | ssp->type = (int) id->data; | |
210 | } else { | |
211 | const struct platform_device_id *id = | |
212 | platform_get_device_id(pdev); | |
213 | ssp->type = (int) id->driver_data; | |
214 | ||
215 | /* PXA2xx/3xx SSP ports starts from 1 and the internal pdev->id | |
216 | * starts from 0, do a translation here | |
217 | */ | |
218 | ssp->port_id = pdev->id + 1; | |
219 | } | |
220 | ||
88286450 | 221 | ssp->use_count = 0; |
6446221c | 222 | ssp->of_node = dev->of_node; |
88286450 | 223 | |
224 | mutex_lock(&ssp_lock); | |
225 | list_add(&ssp->node, &ssp_list); | |
226 | mutex_unlock(&ssp_lock); | |
227 | ||
228 | platform_set_drvdata(pdev, ssp); | |
88286450 | 229 | |
1c459de1 | 230 | return 0; |
88286450 | 231 | } |
232 | ||
351a102d | 233 | static int pxa_ssp_remove(struct platform_device *pdev) |
88286450 | 234 | { |
235 | struct resource *res; | |
236 | struct ssp_device *ssp; | |
237 | ||
238 | ssp = platform_get_drvdata(pdev); | |
239 | if (ssp == NULL) | |
240 | return -ENODEV; | |
241 | ||
242 | iounmap(ssp->mmio_base); | |
243 | ||
244 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
c8ee5c69 | 245 | release_mem_region(res->start, resource_size(res)); |
88286450 | 246 | |
247 | clk_put(ssp->clk); | |
1da177e4 | 248 | |
88286450 | 249 | mutex_lock(&ssp_lock); |
250 | list_del(&ssp->node); | |
251 | mutex_unlock(&ssp_lock); | |
252 | ||
253 | kfree(ssp); | |
254 | return 0; | |
255 | } | |
256 | ||
6427d450 EM |
257 | static const struct platform_device_id ssp_id_table[] = { |
258 | { "pxa25x-ssp", PXA25x_SSP }, | |
259 | { "pxa25x-nssp", PXA25x_NSSP }, | |
260 | { "pxa27x-ssp", PXA27x_SSP }, | |
6f0243a1 | 261 | { "pxa3xx-ssp", PXA3xx_SSP }, |
7e499228 | 262 | { "pxa168-ssp", PXA168_SSP }, |
60172215 | 263 | { "pxa910-ssp", PXA910_SSP }, |
6427d450 | 264 | { }, |
88286450 | 265 | }; |
266 | ||
baffe169 HZ |
267 | static struct platform_driver pxa_ssp_driver = { |
268 | .probe = pxa_ssp_probe, | |
351a102d | 269 | .remove = pxa_ssp_remove, |
88286450 | 270 | .driver = { |
a6e56c28 DM |
271 | .name = "pxa2xx-ssp", |
272 | .of_match_table = of_match_ptr(pxa_ssp_of_ids), | |
88286450 | 273 | }, |
6427d450 | 274 | .id_table = ssp_id_table, |
88286450 | 275 | }; |
276 | ||
277 | static int __init pxa_ssp_init(void) | |
278 | { | |
baffe169 | 279 | return platform_driver_register(&pxa_ssp_driver); |
88286450 | 280 | } |
281 | ||
282 | static void __exit pxa_ssp_exit(void) | |
283 | { | |
baffe169 | 284 | platform_driver_unregister(&pxa_ssp_driver); |
1da177e4 LT |
285 | } |
286 | ||
cae05541 | 287 | arch_initcall(pxa_ssp_init); |
88286450 | 288 | module_exit(pxa_ssp_exit); |
1da177e4 | 289 | |
1da177e4 LT |
290 | MODULE_DESCRIPTION("PXA SSP driver"); |
291 | MODULE_AUTHOR("Liam Girdwood"); | |
292 | MODULE_LICENSE("GPL"); |