1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright (c) 2011-2012, The Linux Foundation. All rights reserved. |
4 | * |
5 | * Description: CoreSight Funnel driver |
6 | */ |
7 | |
8 | #include <linux/acpi.h> |
9 | #include <linux/kernel.h> |
10 | #include <linux/init.h> |
11 | #include <linux/types.h> |
12 | #include <linux/device.h> |
13 | #include <linux/err.h> |
14 | #include <linux/fs.h> |
15 | #include <linux/slab.h> |
16 | #include <linux/of.h> |
17 | #include <linux/platform_device.h> |
18 | #include <linux/pm_runtime.h> |
19 | #include <linux/coresight.h> |
20 | #include <linux/amba/bus.h> |
21 | #include <linux/clk.h> |
22 | |
23 | #include "coresight-priv.h" |
24 | |
25 | #define FUNNEL_FUNCTL 0x000 |
26 | #define FUNNEL_PRICTL 0x004 |
27 | |
28 | #define FUNNEL_HOLDTIME_MASK 0xf00 |
29 | #define FUNNEL_HOLDTIME_SHFT 0x8 |
30 | #define FUNNEL_HOLDTIME (0x7 << FUNNEL_HOLDTIME_SHFT) |
31 | #define FUNNEL_ENSx_MASK 0xff |
32 | |
33 | DEFINE_CORESIGHT_DEVLIST(funnel_devs, "funnel" ); |
34 | |
35 | /** |
36 | * struct funnel_drvdata - specifics associated to a funnel component |
37 | * @base: memory mapped base address for this component. |
38 | * @atclk: optional clock for the core parts of the funnel. |
39 | * @csdev: component vitals needed by the framework. |
40 | * @priority: port selection order. |
41 | * @spinlock: serialize enable/disable operations. |
42 | */ |
43 | struct funnel_drvdata { |
44 | void __iomem *base; |
45 | struct clk *atclk; |
46 | struct coresight_device *csdev; |
47 | unsigned long priority; |
48 | spinlock_t spinlock; |
49 | }; |
50 | |
51 | static int dynamic_funnel_enable_hw(struct funnel_drvdata *drvdata, int port) |
52 | { |
53 | u32 functl; |
54 | int rc = 0; |
55 | struct coresight_device *csdev = drvdata->csdev; |
56 | |
57 | CS_UNLOCK(addr: drvdata->base); |
58 | |
59 | functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL); |
60 | /* Claim the device only when we enable the first slave */ |
61 | if (!(functl & FUNNEL_ENSx_MASK)) { |
62 | rc = coresight_claim_device_unlocked(csdev); |
63 | if (rc) |
64 | goto done; |
65 | } |
66 | |
67 | functl &= ~FUNNEL_HOLDTIME_MASK; |
68 | functl |= FUNNEL_HOLDTIME; |
69 | functl |= (1 << port); |
70 | writel_relaxed(functl, drvdata->base + FUNNEL_FUNCTL); |
71 | writel_relaxed(drvdata->priority, drvdata->base + FUNNEL_PRICTL); |
72 | done: |
73 | CS_LOCK(addr: drvdata->base); |
74 | return rc; |
75 | } |
76 | |
77 | static int funnel_enable(struct coresight_device *csdev, |
78 | struct coresight_connection *in, |
79 | struct coresight_connection *out) |
80 | { |
81 | int rc = 0; |
82 | struct funnel_drvdata *drvdata = dev_get_drvdata(dev: csdev->dev.parent); |
83 | unsigned long flags; |
84 | bool first_enable = false; |
85 | |
86 | spin_lock_irqsave(&drvdata->spinlock, flags); |
87 | if (atomic_read(v: &in->dest_refcnt) == 0) { |
88 | if (drvdata->base) |
89 | rc = dynamic_funnel_enable_hw(drvdata, port: in->dest_port); |
90 | if (!rc) |
91 | first_enable = true; |
92 | } |
93 | if (!rc) |
94 | atomic_inc(v: &in->dest_refcnt); |
95 | spin_unlock_irqrestore(lock: &drvdata->spinlock, flags); |
96 | |
97 | if (first_enable) |
98 | dev_dbg(&csdev->dev, "FUNNEL inport %d enabled\n" , |
99 | in->dest_port); |
100 | return rc; |
101 | } |
102 | |
103 | static void dynamic_funnel_disable_hw(struct funnel_drvdata *drvdata, |
104 | int inport) |
105 | { |
106 | u32 functl; |
107 | struct coresight_device *csdev = drvdata->csdev; |
108 | |
109 | CS_UNLOCK(addr: drvdata->base); |
110 | |
111 | functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL); |
112 | functl &= ~(1 << inport); |
113 | writel_relaxed(functl, drvdata->base + FUNNEL_FUNCTL); |
114 | |
115 | /* Disclaim the device if none of the slaves are now active */ |
116 | if (!(functl & FUNNEL_ENSx_MASK)) |
117 | coresight_disclaim_device_unlocked(csdev); |
118 | |
119 | CS_LOCK(addr: drvdata->base); |
120 | } |
121 | |
122 | static void funnel_disable(struct coresight_device *csdev, |
123 | struct coresight_connection *in, |
124 | struct coresight_connection *out) |
125 | { |
126 | struct funnel_drvdata *drvdata = dev_get_drvdata(dev: csdev->dev.parent); |
127 | unsigned long flags; |
128 | bool last_disable = false; |
129 | |
130 | spin_lock_irqsave(&drvdata->spinlock, flags); |
131 | if (atomic_dec_return(v: &in->dest_refcnt) == 0) { |
132 | if (drvdata->base) |
133 | dynamic_funnel_disable_hw(drvdata, inport: in->dest_port); |
134 | last_disable = true; |
135 | } |
136 | spin_unlock_irqrestore(lock: &drvdata->spinlock, flags); |
137 | |
138 | if (last_disable) |
139 | dev_dbg(&csdev->dev, "FUNNEL inport %d disabled\n" , |
140 | in->dest_port); |
141 | } |
142 | |
143 | static const struct coresight_ops_link funnel_link_ops = { |
144 | .enable = funnel_enable, |
145 | .disable = funnel_disable, |
146 | }; |
147 | |
148 | static const struct coresight_ops funnel_cs_ops = { |
149 | .link_ops = &funnel_link_ops, |
150 | }; |
151 | |
152 | static ssize_t priority_show(struct device *dev, |
153 | struct device_attribute *attr, char *buf) |
154 | { |
155 | struct funnel_drvdata *drvdata = dev_get_drvdata(dev: dev->parent); |
156 | unsigned long val = drvdata->priority; |
157 | |
158 | return sprintf(buf, fmt: "%#lx\n" , val); |
159 | } |
160 | |
161 | static ssize_t priority_store(struct device *dev, |
162 | struct device_attribute *attr, |
163 | const char *buf, size_t size) |
164 | { |
165 | int ret; |
166 | unsigned long val; |
167 | struct funnel_drvdata *drvdata = dev_get_drvdata(dev: dev->parent); |
168 | |
169 | ret = kstrtoul(s: buf, base: 16, res: &val); |
170 | if (ret) |
171 | return ret; |
172 | |
173 | drvdata->priority = val; |
174 | return size; |
175 | } |
176 | static DEVICE_ATTR_RW(priority); |
177 | |
178 | static u32 get_funnel_ctrl_hw(struct funnel_drvdata *drvdata) |
179 | { |
180 | u32 functl; |
181 | |
182 | CS_UNLOCK(addr: drvdata->base); |
183 | functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL); |
184 | CS_LOCK(addr: drvdata->base); |
185 | |
186 | return functl; |
187 | } |
188 | |
189 | static ssize_t funnel_ctrl_show(struct device *dev, |
190 | struct device_attribute *attr, char *buf) |
191 | { |
192 | u32 val; |
193 | struct funnel_drvdata *drvdata = dev_get_drvdata(dev: dev->parent); |
194 | |
195 | pm_runtime_get_sync(dev: dev->parent); |
196 | |
197 | val = get_funnel_ctrl_hw(drvdata); |
198 | |
199 | pm_runtime_put(dev: dev->parent); |
200 | |
201 | return sprintf(buf, fmt: "%#x\n" , val); |
202 | } |
203 | static DEVICE_ATTR_RO(funnel_ctrl); |
204 | |
205 | static struct attribute *coresight_funnel_attrs[] = { |
206 | &dev_attr_funnel_ctrl.attr, |
207 | &dev_attr_priority.attr, |
208 | NULL, |
209 | }; |
210 | ATTRIBUTE_GROUPS(coresight_funnel); |
211 | |
212 | static int funnel_probe(struct device *dev, struct resource *res) |
213 | { |
214 | int ret; |
215 | void __iomem *base; |
216 | struct coresight_platform_data *pdata = NULL; |
217 | struct funnel_drvdata *drvdata; |
218 | struct coresight_desc desc = { 0 }; |
219 | |
220 | if (is_of_node(dev_fwnode(dev)) && |
221 | of_device_is_compatible(device: dev->of_node, "arm,coresight-funnel" )) |
222 | dev_warn_once(dev, "Uses OBSOLETE CoreSight funnel binding\n" ); |
223 | |
224 | desc.name = coresight_alloc_device_name(&funnel_devs, dev); |
225 | if (!desc.name) |
226 | return -ENOMEM; |
227 | |
228 | drvdata = devm_kzalloc(dev, size: sizeof(*drvdata), GFP_KERNEL); |
229 | if (!drvdata) |
230 | return -ENOMEM; |
231 | |
232 | drvdata->atclk = devm_clk_get(dev, id: "atclk" ); /* optional */ |
233 | if (!IS_ERR(ptr: drvdata->atclk)) { |
234 | ret = clk_prepare_enable(clk: drvdata->atclk); |
235 | if (ret) |
236 | return ret; |
237 | } |
238 | |
239 | /* |
240 | * Map the device base for dynamic-funnel, which has been |
241 | * validated by AMBA core. |
242 | */ |
243 | if (res) { |
244 | base = devm_ioremap_resource(dev, res); |
245 | if (IS_ERR(ptr: base)) { |
246 | ret = PTR_ERR(ptr: base); |
247 | goto out_disable_clk; |
248 | } |
249 | drvdata->base = base; |
250 | desc.groups = coresight_funnel_groups; |
251 | desc.access = CSDEV_ACCESS_IOMEM(base); |
252 | } |
253 | |
254 | dev_set_drvdata(dev, data: drvdata); |
255 | |
256 | pdata = coresight_get_platform_data(dev); |
257 | if (IS_ERR(ptr: pdata)) { |
258 | ret = PTR_ERR(ptr: pdata); |
259 | goto out_disable_clk; |
260 | } |
261 | dev->platform_data = pdata; |
262 | |
263 | spin_lock_init(&drvdata->spinlock); |
264 | desc.type = CORESIGHT_DEV_TYPE_LINK; |
265 | desc.subtype.link_subtype = CORESIGHT_DEV_SUBTYPE_LINK_MERG; |
266 | desc.ops = &funnel_cs_ops; |
267 | desc.pdata = pdata; |
268 | desc.dev = dev; |
269 | drvdata->csdev = coresight_register(desc: &desc); |
270 | if (IS_ERR(ptr: drvdata->csdev)) { |
271 | ret = PTR_ERR(ptr: drvdata->csdev); |
272 | goto out_disable_clk; |
273 | } |
274 | |
275 | pm_runtime_put(dev); |
276 | ret = 0; |
277 | |
278 | out_disable_clk: |
279 | if (ret && !IS_ERR_OR_NULL(ptr: drvdata->atclk)) |
280 | clk_disable_unprepare(clk: drvdata->atclk); |
281 | return ret; |
282 | } |
283 | |
284 | static int funnel_remove(struct device *dev) |
285 | { |
286 | struct funnel_drvdata *drvdata = dev_get_drvdata(dev); |
287 | |
288 | coresight_unregister(csdev: drvdata->csdev); |
289 | |
290 | return 0; |
291 | } |
292 | |
293 | #ifdef CONFIG_PM |
294 | static int funnel_runtime_suspend(struct device *dev) |
295 | { |
296 | struct funnel_drvdata *drvdata = dev_get_drvdata(dev); |
297 | |
298 | if (drvdata && !IS_ERR(ptr: drvdata->atclk)) |
299 | clk_disable_unprepare(clk: drvdata->atclk); |
300 | |
301 | return 0; |
302 | } |
303 | |
304 | static int funnel_runtime_resume(struct device *dev) |
305 | { |
306 | struct funnel_drvdata *drvdata = dev_get_drvdata(dev); |
307 | |
308 | if (drvdata && !IS_ERR(ptr: drvdata->atclk)) |
309 | clk_prepare_enable(clk: drvdata->atclk); |
310 | |
311 | return 0; |
312 | } |
313 | #endif |
314 | |
315 | static const struct dev_pm_ops funnel_dev_pm_ops = { |
316 | SET_RUNTIME_PM_OPS(funnel_runtime_suspend, funnel_runtime_resume, NULL) |
317 | }; |
318 | |
319 | static int static_funnel_probe(struct platform_device *pdev) |
320 | { |
321 | int ret; |
322 | |
323 | pm_runtime_get_noresume(dev: &pdev->dev); |
324 | pm_runtime_set_active(dev: &pdev->dev); |
325 | pm_runtime_enable(dev: &pdev->dev); |
326 | |
327 | /* Static funnel do not have programming base */ |
328 | ret = funnel_probe(dev: &pdev->dev, NULL); |
329 | |
330 | if (ret) { |
331 | pm_runtime_put_noidle(dev: &pdev->dev); |
332 | pm_runtime_disable(dev: &pdev->dev); |
333 | } |
334 | |
335 | return ret; |
336 | } |
337 | |
338 | static int static_funnel_remove(struct platform_device *pdev) |
339 | { |
340 | funnel_remove(dev: &pdev->dev); |
341 | pm_runtime_disable(dev: &pdev->dev); |
342 | return 0; |
343 | } |
344 | |
345 | static const struct of_device_id static_funnel_match[] = { |
346 | {.compatible = "arm,coresight-static-funnel" }, |
347 | {} |
348 | }; |
349 | |
350 | MODULE_DEVICE_TABLE(of, static_funnel_match); |
351 | |
352 | #ifdef CONFIG_ACPI |
353 | static const struct acpi_device_id static_funnel_ids[] = { |
354 | {"ARMHC9FE" , 0}, |
355 | {}, |
356 | }; |
357 | |
358 | MODULE_DEVICE_TABLE(acpi, static_funnel_ids); |
359 | #endif |
360 | |
361 | static struct platform_driver static_funnel_driver = { |
362 | .probe = static_funnel_probe, |
363 | .remove = static_funnel_remove, |
364 | .driver = { |
365 | .name = "coresight-static-funnel" , |
366 | /* THIS_MODULE is taken care of by platform_driver_register() */ |
367 | .of_match_table = static_funnel_match, |
368 | .acpi_match_table = ACPI_PTR(static_funnel_ids), |
369 | .pm = &funnel_dev_pm_ops, |
370 | .suppress_bind_attrs = true, |
371 | }, |
372 | }; |
373 | |
374 | static int dynamic_funnel_probe(struct amba_device *adev, |
375 | const struct amba_id *id) |
376 | { |
377 | return funnel_probe(dev: &adev->dev, res: &adev->res); |
378 | } |
379 | |
380 | static void dynamic_funnel_remove(struct amba_device *adev) |
381 | { |
382 | funnel_remove(dev: &adev->dev); |
383 | } |
384 | |
385 | static const struct amba_id dynamic_funnel_ids[] = { |
386 | { |
387 | .id = 0x000bb908, |
388 | .mask = 0x000fffff, |
389 | }, |
390 | { |
391 | /* Coresight SoC-600 */ |
392 | .id = 0x000bb9eb, |
393 | .mask = 0x000fffff, |
394 | }, |
395 | { 0, 0}, |
396 | }; |
397 | |
398 | MODULE_DEVICE_TABLE(amba, dynamic_funnel_ids); |
399 | |
400 | static struct amba_driver dynamic_funnel_driver = { |
401 | .drv = { |
402 | .name = "coresight-dynamic-funnel" , |
403 | .owner = THIS_MODULE, |
404 | .pm = &funnel_dev_pm_ops, |
405 | .suppress_bind_attrs = true, |
406 | }, |
407 | .probe = dynamic_funnel_probe, |
408 | .remove = dynamic_funnel_remove, |
409 | .id_table = dynamic_funnel_ids, |
410 | }; |
411 | |
412 | static int __init funnel_init(void) |
413 | { |
414 | int ret; |
415 | |
416 | ret = platform_driver_register(&static_funnel_driver); |
417 | if (ret) { |
418 | pr_info("Error registering platform driver\n" ); |
419 | return ret; |
420 | } |
421 | |
422 | ret = amba_driver_register(drv: &dynamic_funnel_driver); |
423 | if (ret) { |
424 | pr_info("Error registering amba driver\n" ); |
425 | platform_driver_unregister(&static_funnel_driver); |
426 | } |
427 | |
428 | return ret; |
429 | } |
430 | |
431 | static void __exit funnel_exit(void) |
432 | { |
433 | platform_driver_unregister(&static_funnel_driver); |
434 | amba_driver_unregister(drv: &dynamic_funnel_driver); |
435 | } |
436 | |
437 | module_init(funnel_init); |
438 | module_exit(funnel_exit); |
439 | |
440 | MODULE_AUTHOR("Pratik Patel <pratikp@codeaurora.org>" ); |
441 | MODULE_AUTHOR("Mathieu Poirier <mathieu.poirier@linaro.org>" ); |
442 | MODULE_DESCRIPTION("Arm CoreSight Funnel Driver" ); |
443 | MODULE_LICENSE("GPL v2" ); |
444 | |