1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2012, The Linux Foundation. All rights reserved.
4 */
5
6 #include <linux/build_bug.h>
7 #include <linux/kernel.h>
8 #include <linux/init.h>
9 #include <linux/types.h>
10 #include <linux/device.h>
11 #include <linux/io.h>
12 #include <linux/err.h>
13 #include <linux/export.h>
14 #include <linux/slab.h>
15 #include <linux/stringhash.h>
16 #include <linux/mutex.h>
17 #include <linux/clk.h>
18 #include <linux/coresight.h>
19 #include <linux/property.h>
20 #include <linux/delay.h>
21 #include <linux/pm_runtime.h>
22 #include <linux/panic_notifier.h>
23
24 #include "coresight-etm-perf.h"
25 #include "coresight-priv.h"
26 #include "coresight-syscfg.h"
27 #include "coresight-trace-id.h"
28
29 /*
30 * Mutex used to lock all sysfs enable and disable actions and loading and
31 * unloading devices by the Coresight core.
32 */
33 DEFINE_MUTEX(coresight_mutex);
34 static DEFINE_PER_CPU(struct coresight_device *, csdev_sink);
35
36 /**
37 * struct coresight_node - elements of a path, from source to sink
38 * @csdev: Address of an element.
39 * @link: hook to the list.
40 */
41 struct coresight_node {
42 struct coresight_device *csdev;
43 struct list_head link;
44 };
45
46 /*
47 * When losing synchronisation a new barrier packet needs to be inserted at the
48 * beginning of the data collected in a buffer. That way the decoder knows that
49 * it needs to look for another sync sequence.
50 */
51 const u32 coresight_barrier_pkt[4] = {0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff};
52 EXPORT_SYMBOL_GPL(coresight_barrier_pkt);
53
54 static const struct cti_assoc_op *cti_assoc_ops;
55
coresight_set_cti_ops(const struct cti_assoc_op * cti_op)56 void coresight_set_cti_ops(const struct cti_assoc_op *cti_op)
57 {
58 cti_assoc_ops = cti_op;
59 }
60 EXPORT_SYMBOL_GPL(coresight_set_cti_ops);
61
coresight_remove_cti_ops(void)62 void coresight_remove_cti_ops(void)
63 {
64 cti_assoc_ops = NULL;
65 }
66 EXPORT_SYMBOL_GPL(coresight_remove_cti_ops);
67
coresight_set_percpu_sink(int cpu,struct coresight_device * csdev)68 void coresight_set_percpu_sink(int cpu, struct coresight_device *csdev)
69 {
70 per_cpu(csdev_sink, cpu) = csdev;
71 }
72 EXPORT_SYMBOL_GPL(coresight_set_percpu_sink);
73
coresight_get_percpu_sink(int cpu)74 struct coresight_device *coresight_get_percpu_sink(int cpu)
75 {
76 return per_cpu(csdev_sink, cpu);
77 }
78 EXPORT_SYMBOL_GPL(coresight_get_percpu_sink);
79
coresight_get_source(struct coresight_path * path)80 static struct coresight_device *coresight_get_source(struct coresight_path *path)
81 {
82 struct coresight_device *csdev;
83
84 if (!path)
85 return NULL;
86
87 csdev = list_first_entry(&path->path_list, struct coresight_node, link)->csdev;
88 if (!coresight_is_device_source(csdev))
89 return NULL;
90
91 return csdev;
92 }
93
94 /**
95 * coresight_blocks_source - checks whether the connection matches the source
96 * of path if connection is bound to specific source.
97 * @src: The source device of the trace path
98 * @conn: The connection of one outport
99 *
100 * Return false if the connection doesn't have a source binded or source of the
101 * path matches the source binds to connection.
102 */
coresight_blocks_source(struct coresight_device * src,struct coresight_connection * conn)103 static bool coresight_blocks_source(struct coresight_device *src,
104 struct coresight_connection *conn)
105 {
106 return conn->filter_src_fwnode && (conn->filter_src_dev != src);
107 }
108
109 static struct coresight_connection *
coresight_find_out_connection(struct coresight_device * csdev,struct coresight_device * out_dev,struct coresight_device * trace_src)110 coresight_find_out_connection(struct coresight_device *csdev,
111 struct coresight_device *out_dev,
112 struct coresight_device *trace_src)
113 {
114 int i;
115 struct coresight_connection *conn;
116
117 for (i = 0; i < csdev->pdata->nr_outconns; i++) {
118 conn = csdev->pdata->out_conns[i];
119 if (coresight_blocks_source(trace_src, conn))
120 continue;
121 if (conn->dest_dev == out_dev)
122 return conn;
123 }
124
125 dev_err(&csdev->dev,
126 "couldn't find output connection, csdev: %s, out_dev: %s\n",
127 dev_name(&csdev->dev), dev_name(&out_dev->dev));
128
129 return ERR_PTR(-ENODEV);
130 }
131
coresight_read_claim_tags(struct coresight_device * csdev)132 static inline u32 coresight_read_claim_tags(struct coresight_device *csdev)
133 {
134 return csdev_access_relaxed_read32(&csdev->access, CORESIGHT_CLAIMCLR);
135 }
136
coresight_is_claimed_self_hosted(struct coresight_device * csdev)137 static inline bool coresight_is_claimed_self_hosted(struct coresight_device *csdev)
138 {
139 return coresight_read_claim_tags(csdev) == CORESIGHT_CLAIM_SELF_HOSTED;
140 }
141
coresight_is_claimed_any(struct coresight_device * csdev)142 static inline bool coresight_is_claimed_any(struct coresight_device *csdev)
143 {
144 return coresight_read_claim_tags(csdev) != 0;
145 }
146
coresight_set_claim_tags(struct coresight_device * csdev)147 static inline void coresight_set_claim_tags(struct coresight_device *csdev)
148 {
149 csdev_access_relaxed_write32(&csdev->access, CORESIGHT_CLAIM_SELF_HOSTED,
150 CORESIGHT_CLAIMSET);
151 isb();
152 }
153
coresight_clear_claim_tags(struct coresight_device * csdev)154 static inline void coresight_clear_claim_tags(struct coresight_device *csdev)
155 {
156 csdev_access_relaxed_write32(&csdev->access, CORESIGHT_CLAIM_SELF_HOSTED,
157 CORESIGHT_CLAIMCLR);
158 isb();
159 }
160
161 /*
162 * coresight_claim_device_unlocked : Claim the device for self-hosted usage
163 * to prevent an external tool from touching this device. As per PSCI
164 * standards, section "Preserving the execution context" => "Debug and Trace
165 * save and Restore", DBGCLAIM[1] is reserved for Self-hosted debug/trace and
166 * DBGCLAIM[0] is reserved for external tools.
167 *
168 * Called with CS_UNLOCKed for the component.
169 * Returns : 0 on success
170 */
coresight_claim_device_unlocked(struct coresight_device * csdev)171 int coresight_claim_device_unlocked(struct coresight_device *csdev)
172 {
173 if (WARN_ON(!csdev))
174 return -EINVAL;
175
176 if (coresight_is_claimed_any(csdev))
177 return -EBUSY;
178
179 coresight_set_claim_tags(csdev);
180 if (coresight_is_claimed_self_hosted(csdev))
181 return 0;
182 /* There was a race setting the tags, clean up and fail */
183 coresight_clear_claim_tags(csdev);
184 return -EBUSY;
185 }
186 EXPORT_SYMBOL_GPL(coresight_claim_device_unlocked);
187
coresight_claim_device(struct coresight_device * csdev)188 int coresight_claim_device(struct coresight_device *csdev)
189 {
190 int rc;
191
192 if (WARN_ON(!csdev))
193 return -EINVAL;
194
195 CS_UNLOCK(csdev->access.base);
196 rc = coresight_claim_device_unlocked(csdev);
197 CS_LOCK(csdev->access.base);
198
199 return rc;
200 }
201 EXPORT_SYMBOL_GPL(coresight_claim_device);
202
203 /*
204 * coresight_disclaim_device_unlocked : Clear the claim tags for the device.
205 * Called with CS_UNLOCKed for the component.
206 */
coresight_disclaim_device_unlocked(struct coresight_device * csdev)207 void coresight_disclaim_device_unlocked(struct coresight_device *csdev)
208 {
209
210 if (WARN_ON(!csdev))
211 return;
212
213 if (coresight_is_claimed_self_hosted(csdev))
214 coresight_clear_claim_tags(csdev);
215 else
216 /*
217 * The external agent may have not honoured our claim
218 * and has manipulated it. Or something else has seriously
219 * gone wrong in our driver.
220 */
221 WARN_ON_ONCE(1);
222 }
223 EXPORT_SYMBOL_GPL(coresight_disclaim_device_unlocked);
224
coresight_disclaim_device(struct coresight_device * csdev)225 void coresight_disclaim_device(struct coresight_device *csdev)
226 {
227 if (WARN_ON(!csdev))
228 return;
229
230 CS_UNLOCK(csdev->access.base);
231 coresight_disclaim_device_unlocked(csdev);
232 CS_LOCK(csdev->access.base);
233 }
234 EXPORT_SYMBOL_GPL(coresight_disclaim_device);
235
236 /*
237 * Add a helper as an output device. This function takes the @coresight_mutex
238 * because it's assumed that it's called from the helper device, outside of the
239 * core code where the mutex would already be held. Don't add new calls to this
240 * from inside the core code, instead try to add the new helper to the DT and
241 * ACPI where it will be picked up and linked automatically.
242 */
coresight_add_helper(struct coresight_device * csdev,struct coresight_device * helper)243 void coresight_add_helper(struct coresight_device *csdev,
244 struct coresight_device *helper)
245 {
246 int i;
247 struct coresight_connection conn = {};
248 struct coresight_connection *new_conn;
249
250 mutex_lock(&coresight_mutex);
251 conn.dest_fwnode = fwnode_handle_get(dev_fwnode(&helper->dev));
252 conn.dest_dev = helper;
253 conn.dest_port = conn.src_port = -1;
254 conn.src_dev = csdev;
255
256 /*
257 * Check for duplicates because this is called every time a helper
258 * device is re-loaded. Existing connections will get re-linked
259 * automatically.
260 */
261 for (i = 0; i < csdev->pdata->nr_outconns; ++i)
262 if (csdev->pdata->out_conns[i]->dest_fwnode == conn.dest_fwnode)
263 goto unlock;
264
265 new_conn = coresight_add_out_conn(csdev->dev.parent, csdev->pdata,
266 &conn);
267 if (!IS_ERR(new_conn))
268 coresight_add_in_conn(new_conn);
269
270 unlock:
271 mutex_unlock(&coresight_mutex);
272 }
273 EXPORT_SYMBOL_GPL(coresight_add_helper);
274
coresight_enable_sink(struct coresight_device * csdev,enum cs_mode mode,void * data)275 static int coresight_enable_sink(struct coresight_device *csdev,
276 enum cs_mode mode, void *data)
277 {
278 return sink_ops(csdev)->enable(csdev, mode, data);
279 }
280
coresight_disable_sink(struct coresight_device * csdev)281 static void coresight_disable_sink(struct coresight_device *csdev)
282 {
283 sink_ops(csdev)->disable(csdev);
284 }
285
coresight_enable_link(struct coresight_device * csdev,struct coresight_device * parent,struct coresight_device * child,struct coresight_device * source)286 static int coresight_enable_link(struct coresight_device *csdev,
287 struct coresight_device *parent,
288 struct coresight_device *child,
289 struct coresight_device *source)
290 {
291 int link_subtype;
292 struct coresight_connection *inconn, *outconn;
293
294 if (!parent || !child)
295 return -EINVAL;
296
297 inconn = coresight_find_out_connection(parent, csdev, source);
298 outconn = coresight_find_out_connection(csdev, child, source);
299 link_subtype = csdev->subtype.link_subtype;
300
301 if (link_subtype == CORESIGHT_DEV_SUBTYPE_LINK_MERG && IS_ERR(inconn))
302 return PTR_ERR(inconn);
303 if (link_subtype == CORESIGHT_DEV_SUBTYPE_LINK_SPLIT && IS_ERR(outconn))
304 return PTR_ERR(outconn);
305
306 return link_ops(csdev)->enable(csdev, inconn, outconn);
307 }
308
coresight_disable_link(struct coresight_device * csdev,struct coresight_device * parent,struct coresight_device * child,struct coresight_device * source)309 static void coresight_disable_link(struct coresight_device *csdev,
310 struct coresight_device *parent,
311 struct coresight_device *child,
312 struct coresight_device *source)
313 {
314 struct coresight_connection *inconn, *outconn;
315
316 if (!parent || !child)
317 return;
318
319 inconn = coresight_find_out_connection(parent, csdev, source);
320 outconn = coresight_find_out_connection(csdev, child, source);
321
322 link_ops(csdev)->disable(csdev, inconn, outconn);
323 }
324
coresight_is_helper(struct coresight_device * csdev)325 static bool coresight_is_helper(struct coresight_device *csdev)
326 {
327 return csdev->type == CORESIGHT_DEV_TYPE_HELPER;
328 }
329
coresight_enable_helper(struct coresight_device * csdev,enum cs_mode mode,void * data)330 static int coresight_enable_helper(struct coresight_device *csdev,
331 enum cs_mode mode, void *data)
332 {
333 return helper_ops(csdev)->enable(csdev, mode, data);
334 }
335
coresight_disable_helper(struct coresight_device * csdev,void * data)336 static void coresight_disable_helper(struct coresight_device *csdev, void *data)
337 {
338 helper_ops(csdev)->disable(csdev, data);
339 }
340
coresight_disable_helpers(struct coresight_device * csdev,void * data)341 static void coresight_disable_helpers(struct coresight_device *csdev, void *data)
342 {
343 int i;
344 struct coresight_device *helper;
345
346 for (i = 0; i < csdev->pdata->nr_outconns; ++i) {
347 helper = csdev->pdata->out_conns[i]->dest_dev;
348 if (helper && coresight_is_helper(helper))
349 coresight_disable_helper(helper, data);
350 }
351 }
352
353 /*
354 * Helper function to call source_ops(csdev)->disable and also disable the
355 * helpers.
356 *
357 * There is an imbalance between coresight_enable_path() and
358 * coresight_disable_path(). Enabling also enables the source's helpers as part
359 * of the path, but disabling always skips the first item in the path (which is
360 * the source), so sources and their helpers don't get disabled as part of that
361 * function and we need the extra step here.
362 */
coresight_disable_source(struct coresight_device * csdev,void * data)363 void coresight_disable_source(struct coresight_device *csdev, void *data)
364 {
365 source_ops(csdev)->disable(csdev, data);
366 coresight_disable_helpers(csdev, NULL);
367 }
368 EXPORT_SYMBOL_GPL(coresight_disable_source);
369
370 /*
371 * coresight_disable_path_from : Disable components in the given path beyond
372 * @nd in the list. If @nd is NULL, all the components, except the SOURCE are
373 * disabled.
374 */
coresight_disable_path_from(struct coresight_path * path,struct coresight_node * nd)375 static void coresight_disable_path_from(struct coresight_path *path,
376 struct coresight_node *nd)
377 {
378 u32 type;
379 struct coresight_device *csdev, *parent, *child;
380
381 if (!nd)
382 nd = list_first_entry(&path->path_list, struct coresight_node, link);
383
384 list_for_each_entry_continue(nd, &path->path_list, link) {
385 csdev = nd->csdev;
386 type = csdev->type;
387
388 /*
389 * ETF devices are tricky... They can be a link or a sink,
390 * depending on how they are configured. If an ETF has been
391 * selected as a sink it will be configured as a sink, otherwise
392 * go ahead with the link configuration.
393 */
394 if (type == CORESIGHT_DEV_TYPE_LINKSINK)
395 type = (csdev == coresight_get_sink(path)) ?
396 CORESIGHT_DEV_TYPE_SINK :
397 CORESIGHT_DEV_TYPE_LINK;
398
399 switch (type) {
400 case CORESIGHT_DEV_TYPE_SINK:
401 coresight_disable_sink(csdev);
402 break;
403 case CORESIGHT_DEV_TYPE_SOURCE:
404 /*
405 * We skip the first node in the path assuming that it
406 * is the source. So we don't expect a source device in
407 * the middle of a path.
408 */
409 WARN_ON(1);
410 break;
411 case CORESIGHT_DEV_TYPE_LINK:
412 parent = list_prev_entry(nd, link)->csdev;
413 child = list_next_entry(nd, link)->csdev;
414 coresight_disable_link(csdev, parent, child,
415 coresight_get_source(path));
416 break;
417 default:
418 break;
419 }
420
421 /* Disable all helpers adjacent along the path last */
422 coresight_disable_helpers(csdev, path);
423 }
424 }
425
coresight_disable_path(struct coresight_path * path)426 void coresight_disable_path(struct coresight_path *path)
427 {
428 coresight_disable_path_from(path, NULL);
429 }
430 EXPORT_SYMBOL_GPL(coresight_disable_path);
431
coresight_enable_helpers(struct coresight_device * csdev,enum cs_mode mode,void * data)432 static int coresight_enable_helpers(struct coresight_device *csdev,
433 enum cs_mode mode, void *data)
434 {
435 int i, ret = 0;
436 struct coresight_device *helper;
437
438 for (i = 0; i < csdev->pdata->nr_outconns; ++i) {
439 helper = csdev->pdata->out_conns[i]->dest_dev;
440 if (!helper || !coresight_is_helper(helper))
441 continue;
442
443 ret = coresight_enable_helper(helper, mode, data);
444 if (ret)
445 return ret;
446 }
447
448 return 0;
449 }
450
coresight_enable_path(struct coresight_path * path,enum cs_mode mode,void * sink_data)451 int coresight_enable_path(struct coresight_path *path, enum cs_mode mode,
452 void *sink_data)
453 {
454 int ret = 0;
455 u32 type;
456 struct coresight_node *nd;
457 struct coresight_device *csdev, *parent, *child;
458 struct coresight_device *source;
459
460 source = coresight_get_source(path);
461 list_for_each_entry_reverse(nd, &path->path_list, link) {
462 csdev = nd->csdev;
463 type = csdev->type;
464
465 /* Enable all helpers adjacent to the path first */
466 ret = coresight_enable_helpers(csdev, mode, path);
467 if (ret)
468 goto err;
469 /*
470 * ETF devices are tricky... They can be a link or a sink,
471 * depending on how they are configured. If an ETF has been
472 * selected as a sink it will be configured as a sink, otherwise
473 * go ahead with the link configuration.
474 */
475 if (type == CORESIGHT_DEV_TYPE_LINKSINK)
476 type = (csdev == coresight_get_sink(path)) ?
477 CORESIGHT_DEV_TYPE_SINK :
478 CORESIGHT_DEV_TYPE_LINK;
479
480 switch (type) {
481 case CORESIGHT_DEV_TYPE_SINK:
482 ret = coresight_enable_sink(csdev, mode, sink_data);
483 /*
484 * Sink is the first component turned on. If we
485 * failed to enable the sink, there are no components
486 * that need disabling. Disabling the path here
487 * would mean we could disrupt an existing session.
488 */
489 if (ret)
490 goto out;
491 break;
492 case CORESIGHT_DEV_TYPE_SOURCE:
493 /* sources are enabled from either sysFS or Perf */
494 break;
495 case CORESIGHT_DEV_TYPE_LINK:
496 parent = list_prev_entry(nd, link)->csdev;
497 child = list_next_entry(nd, link)->csdev;
498 ret = coresight_enable_link(csdev, parent, child, source);
499 if (ret)
500 goto err;
501 break;
502 default:
503 goto err;
504 }
505 }
506
507 out:
508 return ret;
509 err:
510 coresight_disable_path_from(path, nd);
511 goto out;
512 }
513
coresight_get_sink(struct coresight_path * path)514 struct coresight_device *coresight_get_sink(struct coresight_path *path)
515 {
516 struct coresight_device *csdev;
517
518 if (!path)
519 return NULL;
520
521 csdev = list_last_entry(&path->path_list, struct coresight_node, link)->csdev;
522 if (csdev->type != CORESIGHT_DEV_TYPE_SINK &&
523 csdev->type != CORESIGHT_DEV_TYPE_LINKSINK)
524 return NULL;
525
526 return csdev;
527 }
528 EXPORT_SYMBOL_GPL(coresight_get_sink);
529
coresight_get_sink_id(struct coresight_device * csdev)530 u32 coresight_get_sink_id(struct coresight_device *csdev)
531 {
532 if (!csdev->ea)
533 return 0;
534
535 /*
536 * See function etm_perf_add_symlink_sink() to know where
537 * this comes from.
538 */
539 return (u32) (unsigned long) csdev->ea->var;
540 }
541
coresight_sink_by_id(struct device * dev,const void * data)542 static int coresight_sink_by_id(struct device *dev, const void *data)
543 {
544 struct coresight_device *csdev = to_coresight_device(dev);
545
546 if (csdev->type == CORESIGHT_DEV_TYPE_SINK ||
547 csdev->type == CORESIGHT_DEV_TYPE_LINKSINK) {
548 if (coresight_get_sink_id(csdev) == *(u32 *)data)
549 return 1;
550 }
551
552 return 0;
553 }
554
555 /**
556 * coresight_get_sink_by_id - returns the sink that matches the id
557 * @id: Id of the sink to match
558 *
559 * The name of a sink is unique, whether it is found on the AMBA bus or
560 * otherwise. As such the hash of that name can easily be used to identify
561 * a sink.
562 */
coresight_get_sink_by_id(u32 id)563 struct coresight_device *coresight_get_sink_by_id(u32 id)
564 {
565 struct device *dev = NULL;
566
567 dev = bus_find_device(&coresight_bustype, NULL, &id,
568 coresight_sink_by_id);
569
570 return dev ? to_coresight_device(dev) : NULL;
571 }
572
573 /**
574 * coresight_get_ref- Helper function to increase reference count to module
575 * and device.
576 *
577 * @csdev: The coresight device to get a reference on.
578 *
579 * Return true in successful case and power up the device.
580 * Return false when failed to get reference of module.
581 */
coresight_get_ref(struct coresight_device * csdev)582 static inline bool coresight_get_ref(struct coresight_device *csdev)
583 {
584 struct device *dev = csdev->dev.parent;
585
586 /* Make sure the driver can't be removed */
587 if (!try_module_get(dev->driver->owner))
588 return false;
589 /* Make sure the device can't go away */
590 get_device(dev);
591 pm_runtime_get_sync(dev);
592 return true;
593 }
594
595 /**
596 * coresight_put_ref- Helper function to decrease reference count to module
597 * and device. Power off the device.
598 *
599 * @csdev: The coresight device to decrement a reference from.
600 */
coresight_put_ref(struct coresight_device * csdev)601 static inline void coresight_put_ref(struct coresight_device *csdev)
602 {
603 struct device *dev = csdev->dev.parent;
604
605 pm_runtime_put(dev);
606 put_device(dev);
607 module_put(dev->driver->owner);
608 }
609
610 /*
611 * coresight_grab_device - Power up this device and any of the helper
612 * devices connected to it for trace operation. Since the helper devices
613 * don't appear on the trace path, they should be handled along with the
614 * master device.
615 */
coresight_grab_device(struct coresight_device * csdev)616 static int coresight_grab_device(struct coresight_device *csdev)
617 {
618 int i;
619
620 for (i = 0; i < csdev->pdata->nr_outconns; i++) {
621 struct coresight_device *child;
622
623 child = csdev->pdata->out_conns[i]->dest_dev;
624 if (child && coresight_is_helper(child))
625 if (!coresight_get_ref(child))
626 goto err;
627 }
628 if (coresight_get_ref(csdev))
629 return 0;
630 err:
631 for (i--; i >= 0; i--) {
632 struct coresight_device *child;
633
634 child = csdev->pdata->out_conns[i]->dest_dev;
635 if (child && coresight_is_helper(child))
636 coresight_put_ref(child);
637 }
638 return -ENODEV;
639 }
640
641 /*
642 * coresight_drop_device - Release this device and any of the helper
643 * devices connected to it.
644 */
coresight_drop_device(struct coresight_device * csdev)645 static void coresight_drop_device(struct coresight_device *csdev)
646 {
647 int i;
648
649 coresight_put_ref(csdev);
650 for (i = 0; i < csdev->pdata->nr_outconns; i++) {
651 struct coresight_device *child;
652
653 child = csdev->pdata->out_conns[i]->dest_dev;
654 if (child && coresight_is_helper(child))
655 coresight_put_ref(child);
656 }
657 }
658
659 /*
660 * coresight device will read their existing or alloc a trace ID, if their trace_id
661 * callback is set.
662 *
663 * Return 0 if the trace_id callback is not set.
664 * Return the result of the trace_id callback if it is set. The return value
665 * will be the trace_id if successful, and an error number if it fails.
666 */
coresight_get_trace_id(struct coresight_device * csdev,enum cs_mode mode,struct coresight_device * sink)667 static int coresight_get_trace_id(struct coresight_device *csdev,
668 enum cs_mode mode,
669 struct coresight_device *sink)
670 {
671 if (coresight_ops(csdev)->trace_id)
672 return coresight_ops(csdev)->trace_id(csdev, mode, sink);
673
674 return 0;
675 }
676
677 /*
678 * Call this after creating the path and before enabling it. This leaves
679 * the trace ID set on the path, or it remains 0 if it couldn't be assigned.
680 */
coresight_path_assign_trace_id(struct coresight_path * path,enum cs_mode mode)681 void coresight_path_assign_trace_id(struct coresight_path *path,
682 enum cs_mode mode)
683 {
684 struct coresight_device *sink = coresight_get_sink(path);
685 struct coresight_node *nd;
686 int trace_id;
687
688 list_for_each_entry(nd, &path->path_list, link) {
689 /* Assign a trace ID to the path for the first device that wants to do it */
690 trace_id = coresight_get_trace_id(nd->csdev, mode, sink);
691
692 /*
693 * 0 in this context is that it didn't want to assign so keep searching.
694 * Non 0 is either success or fail.
695 */
696 if (trace_id != 0) {
697 path->trace_id = trace_id;
698 return;
699 }
700 }
701 }
702
703 /**
704 * _coresight_build_path - recursively build a path from a @csdev to a sink.
705 * @csdev: The device to start from.
706 * @source: The trace source device of the path.
707 * @sink: The final sink we want in this path.
708 * @path: The list to add devices to.
709 *
710 * The tree of Coresight device is traversed until @sink is found.
711 * From there the sink is added to the list along with all the devices that led
712 * to that point - the end result is a list from source to sink. In that list
713 * the source is the first device and the sink the last one.
714 */
_coresight_build_path(struct coresight_device * csdev,struct coresight_device * source,struct coresight_device * sink,struct coresight_path * path)715 static int _coresight_build_path(struct coresight_device *csdev,
716 struct coresight_device *source,
717 struct coresight_device *sink,
718 struct coresight_path *path)
719 {
720 int i, ret;
721 bool found = false;
722 struct coresight_node *node;
723
724 /* The sink has been found. Enqueue the element */
725 if (csdev == sink)
726 goto out;
727
728 if (coresight_is_percpu_source(csdev) && coresight_is_percpu_sink(sink) &&
729 sink == per_cpu(csdev_sink, source_ops(csdev)->cpu_id(csdev))) {
730 if (_coresight_build_path(sink, source, sink, path) == 0) {
731 found = true;
732 goto out;
733 }
734 }
735
736 /* Not a sink - recursively explore each port found on this element */
737 for (i = 0; i < csdev->pdata->nr_outconns; i++) {
738 struct coresight_device *child_dev;
739
740 child_dev = csdev->pdata->out_conns[i]->dest_dev;
741
742 if (coresight_blocks_source(source, csdev->pdata->out_conns[i]))
743 continue;
744
745 if (child_dev &&
746 _coresight_build_path(child_dev, source, sink, path) == 0) {
747 found = true;
748 break;
749 }
750 }
751
752 if (!found)
753 return -ENODEV;
754
755 out:
756 /*
757 * A path from this element to a sink has been found. The elements
758 * leading to the sink are already enqueued, all that is left to do
759 * is tell the PM runtime core we need this element and add a node
760 * for it.
761 */
762 ret = coresight_grab_device(csdev);
763 if (ret)
764 return ret;
765
766 node = kzalloc(sizeof(struct coresight_node), GFP_KERNEL);
767 if (!node)
768 return -ENOMEM;
769
770 node->csdev = csdev;
771 list_add(&node->link, &path->path_list);
772
773 return 0;
774 }
775
coresight_build_path(struct coresight_device * source,struct coresight_device * sink)776 struct coresight_path *coresight_build_path(struct coresight_device *source,
777 struct coresight_device *sink)
778 {
779 struct coresight_path *path;
780 int rc;
781
782 if (!sink)
783 return ERR_PTR(-EINVAL);
784
785 path = kzalloc(sizeof(struct coresight_path), GFP_KERNEL);
786 if (!path)
787 return ERR_PTR(-ENOMEM);
788
789 INIT_LIST_HEAD(&path->path_list);
790
791 rc = _coresight_build_path(source, source, sink, path);
792 if (rc) {
793 kfree(path);
794 return ERR_PTR(rc);
795 }
796
797 return path;
798 }
799
800 /**
801 * coresight_release_path - release a previously built path.
802 * @path: the path to release.
803 *
804 * Go through all the elements of a path and 1) removed it from the list and
805 * 2) free the memory allocated for each node.
806 */
coresight_release_path(struct coresight_path * path)807 void coresight_release_path(struct coresight_path *path)
808 {
809 struct coresight_device *csdev;
810 struct coresight_node *nd, *next;
811
812 list_for_each_entry_safe(nd, next, &path->path_list, link) {
813 csdev = nd->csdev;
814
815 coresight_drop_device(csdev);
816 list_del(&nd->link);
817 kfree(nd);
818 }
819
820 kfree(path);
821 }
822
823 /* return true if the device is a suitable type for a default sink */
coresight_is_def_sink_type(struct coresight_device * csdev)824 static inline bool coresight_is_def_sink_type(struct coresight_device *csdev)
825 {
826 /* sink & correct subtype */
827 if (((csdev->type == CORESIGHT_DEV_TYPE_SINK) ||
828 (csdev->type == CORESIGHT_DEV_TYPE_LINKSINK)) &&
829 (csdev->subtype.sink_subtype >= CORESIGHT_DEV_SUBTYPE_SINK_BUFFER))
830 return true;
831 return false;
832 }
833
834 /**
835 * coresight_select_best_sink - return the best sink for use as default from
836 * the two provided.
837 *
838 * @sink: current best sink.
839 * @depth: search depth where current sink was found.
840 * @new_sink: new sink for comparison with current sink.
841 * @new_depth: search depth where new sink was found.
842 *
843 * Sinks prioritised according to coresight_dev_subtype_sink, with only
844 * subtypes CORESIGHT_DEV_SUBTYPE_SINK_BUFFER or higher being used.
845 *
846 * Where two sinks of equal priority are found, the sink closest to the
847 * source is used (smallest search depth).
848 *
849 * return @new_sink & update @depth if better than @sink, else return @sink.
850 */
851 static struct coresight_device *
coresight_select_best_sink(struct coresight_device * sink,int * depth,struct coresight_device * new_sink,int new_depth)852 coresight_select_best_sink(struct coresight_device *sink, int *depth,
853 struct coresight_device *new_sink, int new_depth)
854 {
855 bool update = false;
856
857 if (!sink) {
858 /* first found at this level */
859 update = true;
860 } else if (new_sink->subtype.sink_subtype >
861 sink->subtype.sink_subtype) {
862 /* found better sink */
863 update = true;
864 } else if ((new_sink->subtype.sink_subtype ==
865 sink->subtype.sink_subtype) &&
866 (*depth > new_depth)) {
867 /* found same but closer sink */
868 update = true;
869 }
870
871 if (update)
872 *depth = new_depth;
873 return update ? new_sink : sink;
874 }
875
876 /**
877 * coresight_find_sink - recursive function to walk trace connections from
878 * source to find a suitable default sink.
879 *
880 * @csdev: source / current device to check.
881 * @depth: [in] search depth of calling dev, [out] depth of found sink.
882 *
883 * This will walk the connection path from a source (ETM) till a suitable
884 * sink is encountered and return that sink to the original caller.
885 *
886 * If current device is a plain sink return that & depth, otherwise recursively
887 * call child connections looking for a sink. Select best possible using
888 * coresight_select_best_sink.
889 *
890 * return best sink found, or NULL if not found at this node or child nodes.
891 */
892 static struct coresight_device *
coresight_find_sink(struct coresight_device * csdev,int * depth)893 coresight_find_sink(struct coresight_device *csdev, int *depth)
894 {
895 int i, curr_depth = *depth + 1, found_depth = 0;
896 struct coresight_device *found_sink = NULL;
897
898 if (coresight_is_def_sink_type(csdev)) {
899 found_depth = curr_depth;
900 found_sink = csdev;
901 if (csdev->type == CORESIGHT_DEV_TYPE_SINK)
902 goto return_def_sink;
903 /* look past LINKSINK for something better */
904 }
905
906 /*
907 * Not a sink we want - or possible child sink may be better.
908 * recursively explore each port found on this element.
909 */
910 for (i = 0; i < csdev->pdata->nr_outconns; i++) {
911 struct coresight_device *child_dev, *sink = NULL;
912 int child_depth = curr_depth;
913
914 child_dev = csdev->pdata->out_conns[i]->dest_dev;
915 if (child_dev)
916 sink = coresight_find_sink(child_dev, &child_depth);
917
918 if (sink)
919 found_sink = coresight_select_best_sink(found_sink,
920 &found_depth,
921 sink,
922 child_depth);
923 }
924
925 return_def_sink:
926 /* return found sink and depth */
927 if (found_sink)
928 *depth = found_depth;
929 return found_sink;
930 }
931
932 /**
933 * coresight_find_default_sink: Find a sink suitable for use as a
934 * default sink.
935 *
936 * @csdev: starting source to find a connected sink.
937 *
938 * Walks connections graph looking for a suitable sink to enable for the
939 * supplied source. Uses CoreSight device subtypes and distance from source
940 * to select the best sink.
941 *
942 * If a sink is found, then the default sink for this device is set and
943 * will be automatically used in future.
944 *
945 * Used in cases where the CoreSight user (perf / sysfs) has not selected a
946 * sink.
947 */
948 struct coresight_device *
coresight_find_default_sink(struct coresight_device * csdev)949 coresight_find_default_sink(struct coresight_device *csdev)
950 {
951 int depth = 0;
952
953 /* look for a default sink if we have not found for this device */
954 if (!csdev->def_sink) {
955 if (coresight_is_percpu_source(csdev))
956 csdev->def_sink = per_cpu(csdev_sink, source_ops(csdev)->cpu_id(csdev));
957 if (!csdev->def_sink)
958 csdev->def_sink = coresight_find_sink(csdev, &depth);
959 }
960 return csdev->def_sink;
961 }
962
coresight_remove_sink_ref(struct device * dev,void * data)963 static int coresight_remove_sink_ref(struct device *dev, void *data)
964 {
965 struct coresight_device *sink = data;
966 struct coresight_device *source = to_coresight_device(dev);
967
968 if (source->def_sink == sink)
969 source->def_sink = NULL;
970 return 0;
971 }
972
973 /**
974 * coresight_clear_default_sink: Remove all default sink references to the
975 * supplied sink.
976 *
977 * If supplied device is a sink, then check all the bus devices and clear
978 * out all the references to this sink from the coresight_device def_sink
979 * parameter.
980 *
981 * @csdev: coresight sink - remove references to this from all sources.
982 */
coresight_clear_default_sink(struct coresight_device * csdev)983 static void coresight_clear_default_sink(struct coresight_device *csdev)
984 {
985 if ((csdev->type == CORESIGHT_DEV_TYPE_SINK) ||
986 (csdev->type == CORESIGHT_DEV_TYPE_LINKSINK)) {
987 bus_for_each_dev(&coresight_bustype, NULL, csdev,
988 coresight_remove_sink_ref);
989 }
990 }
991
coresight_device_release(struct device * dev)992 static void coresight_device_release(struct device *dev)
993 {
994 struct coresight_device *csdev = to_coresight_device(dev);
995
996 fwnode_handle_put(csdev->dev.fwnode);
997 free_percpu(csdev->perf_sink_id_map.cpu_map);
998 kfree(csdev);
999 }
1000
coresight_orphan_match(struct device * dev,void * data)1001 static int coresight_orphan_match(struct device *dev, void *data)
1002 {
1003 int i, ret = 0;
1004 bool still_orphan = false;
1005 struct coresight_device *dst_csdev = data;
1006 struct coresight_device *src_csdev = to_coresight_device(dev);
1007 struct coresight_connection *conn;
1008 bool fixup_self = (src_csdev == dst_csdev);
1009
1010 /* Move on to another component if no connection is orphan */
1011 if (!src_csdev->orphan)
1012 return 0;
1013 /*
1014 * Circle through all the connections of that component. If we find
1015 * an orphan connection whose name matches @dst_csdev, link it.
1016 */
1017 for (i = 0; i < src_csdev->pdata->nr_outconns; i++) {
1018 conn = src_csdev->pdata->out_conns[i];
1019
1020 /* Fix filter source device before skip the port */
1021 if (conn->filter_src_fwnode && !conn->filter_src_dev) {
1022 if (dst_csdev &&
1023 (conn->filter_src_fwnode == dst_csdev->dev.fwnode) &&
1024 !WARN_ON_ONCE(!coresight_is_device_source(dst_csdev)))
1025 conn->filter_src_dev = dst_csdev;
1026 else
1027 still_orphan = true;
1028 }
1029
1030 /* Skip the port if it's already connected. */
1031 if (conn->dest_dev)
1032 continue;
1033
1034 /*
1035 * If we are at the "new" device, which triggered this search,
1036 * we must find the remote device from the fwnode in the
1037 * connection.
1038 */
1039 if (fixup_self)
1040 dst_csdev = coresight_find_csdev_by_fwnode(
1041 conn->dest_fwnode);
1042
1043 /* Does it match this newly added device? */
1044 if (dst_csdev && conn->dest_fwnode == dst_csdev->dev.fwnode) {
1045 ret = coresight_make_links(src_csdev, conn, dst_csdev);
1046 if (ret)
1047 return ret;
1048
1049 /*
1050 * Install the device connection. This also indicates that
1051 * the links are operational on both ends.
1052 */
1053 conn->dest_dev = dst_csdev;
1054 conn->src_dev = src_csdev;
1055
1056 ret = coresight_add_in_conn(conn);
1057 if (ret)
1058 return ret;
1059 } else {
1060 /* This component still has an orphan */
1061 still_orphan = true;
1062 }
1063 }
1064
1065 src_csdev->orphan = still_orphan;
1066
1067 /*
1068 * Returning '0' in case we didn't encounter any error,
1069 * ensures that all known component on the bus will be checked.
1070 */
1071 return 0;
1072 }
1073
coresight_fixup_orphan_conns(struct coresight_device * csdev)1074 static int coresight_fixup_orphan_conns(struct coresight_device *csdev)
1075 {
1076 return bus_for_each_dev(&coresight_bustype, NULL,
1077 csdev, coresight_orphan_match);
1078 }
1079
coresight_clear_filter_source(struct device * dev,void * data)1080 static int coresight_clear_filter_source(struct device *dev, void *data)
1081 {
1082 int i;
1083 struct coresight_device *source = data;
1084 struct coresight_device *csdev = to_coresight_device(dev);
1085
1086 for (i = 0; i < csdev->pdata->nr_outconns; ++i) {
1087 if (csdev->pdata->out_conns[i]->filter_src_dev == source)
1088 csdev->pdata->out_conns[i]->filter_src_dev = NULL;
1089 }
1090 return 0;
1091 }
1092
1093 /* coresight_remove_conns - Remove other device's references to this device */
coresight_remove_conns(struct coresight_device * csdev)1094 static void coresight_remove_conns(struct coresight_device *csdev)
1095 {
1096 int i, j;
1097 struct coresight_connection *conn;
1098
1099 if (coresight_is_device_source(csdev))
1100 bus_for_each_dev(&coresight_bustype, NULL, csdev,
1101 coresight_clear_filter_source);
1102
1103 /*
1104 * Remove the input connection references from the destination device
1105 * for each output connection.
1106 */
1107 for (i = 0; i < csdev->pdata->nr_outconns; i++) {
1108 conn = csdev->pdata->out_conns[i];
1109 if (conn->filter_src_fwnode) {
1110 conn->filter_src_dev = NULL;
1111 fwnode_handle_put(conn->filter_src_fwnode);
1112 }
1113
1114 if (!conn->dest_dev)
1115 continue;
1116
1117 for (j = 0; j < conn->dest_dev->pdata->nr_inconns; ++j)
1118 if (conn->dest_dev->pdata->in_conns[j] == conn) {
1119 conn->dest_dev->pdata->in_conns[j] = NULL;
1120 break;
1121 }
1122 }
1123
1124 /*
1125 * For all input connections, remove references to this device.
1126 * Connection objects are shared so modifying this device's input
1127 * connections affects the other device's output connection.
1128 */
1129 for (i = 0; i < csdev->pdata->nr_inconns; ++i) {
1130 conn = csdev->pdata->in_conns[i];
1131 /* Input conns array is sparse */
1132 if (!conn)
1133 continue;
1134
1135 conn->src_dev->orphan = true;
1136 coresight_remove_links(conn->src_dev, conn);
1137 conn->dest_dev = NULL;
1138 }
1139 }
1140
1141 /**
1142 * coresight_timeout_action - loop until a bit has changed to a specific register
1143 * state, with a callback after every trial.
1144 * @csa: coresight device access for the device
1145 * @offset: Offset of the register from the base of the device.
1146 * @position: the position of the bit of interest.
1147 * @value: the value the bit should have.
1148 * @cb: Call back after each trial.
1149 *
1150 * Return: 0 as soon as the bit has taken the desired state or -EAGAIN if
1151 * TIMEOUT_US has elapsed, which ever happens first.
1152 */
coresight_timeout_action(struct csdev_access * csa,u32 offset,int position,int value,coresight_timeout_cb_t cb)1153 int coresight_timeout_action(struct csdev_access *csa, u32 offset,
1154 int position, int value,
1155 coresight_timeout_cb_t cb)
1156 {
1157 int i;
1158 u32 val;
1159
1160 for (i = TIMEOUT_US; i > 0; i--) {
1161 val = csdev_access_read32(csa, offset);
1162 /* waiting on the bit to go from 0 to 1 */
1163 if (value) {
1164 if (val & BIT(position))
1165 return 0;
1166 /* waiting on the bit to go from 1 to 0 */
1167 } else {
1168 if (!(val & BIT(position)))
1169 return 0;
1170 }
1171 if (cb)
1172 cb(csa, offset, position, value);
1173 /*
1174 * Delay is arbitrary - the specification doesn't say how long
1175 * we are expected to wait. Extra check required to make sure
1176 * we don't wait needlessly on the last iteration.
1177 */
1178 if (i - 1)
1179 udelay(1);
1180 }
1181
1182 return -EAGAIN;
1183 }
1184 EXPORT_SYMBOL_GPL(coresight_timeout_action);
1185
coresight_timeout(struct csdev_access * csa,u32 offset,int position,int value)1186 int coresight_timeout(struct csdev_access *csa, u32 offset,
1187 int position, int value)
1188 {
1189 return coresight_timeout_action(csa, offset, position, value, NULL);
1190 }
1191 EXPORT_SYMBOL_GPL(coresight_timeout);
1192
coresight_relaxed_read32(struct coresight_device * csdev,u32 offset)1193 u32 coresight_relaxed_read32(struct coresight_device *csdev, u32 offset)
1194 {
1195 return csdev_access_relaxed_read32(&csdev->access, offset);
1196 }
1197
coresight_read32(struct coresight_device * csdev,u32 offset)1198 u32 coresight_read32(struct coresight_device *csdev, u32 offset)
1199 {
1200 return csdev_access_read32(&csdev->access, offset);
1201 }
1202
coresight_relaxed_write32(struct coresight_device * csdev,u32 val,u32 offset)1203 void coresight_relaxed_write32(struct coresight_device *csdev,
1204 u32 val, u32 offset)
1205 {
1206 csdev_access_relaxed_write32(&csdev->access, val, offset);
1207 }
1208
coresight_write32(struct coresight_device * csdev,u32 val,u32 offset)1209 void coresight_write32(struct coresight_device *csdev, u32 val, u32 offset)
1210 {
1211 csdev_access_write32(&csdev->access, val, offset);
1212 }
1213
coresight_relaxed_read64(struct coresight_device * csdev,u32 offset)1214 u64 coresight_relaxed_read64(struct coresight_device *csdev, u32 offset)
1215 {
1216 return csdev_access_relaxed_read64(&csdev->access, offset);
1217 }
1218
coresight_read64(struct coresight_device * csdev,u32 offset)1219 u64 coresight_read64(struct coresight_device *csdev, u32 offset)
1220 {
1221 return csdev_access_read64(&csdev->access, offset);
1222 }
1223
coresight_relaxed_write64(struct coresight_device * csdev,u64 val,u32 offset)1224 void coresight_relaxed_write64(struct coresight_device *csdev,
1225 u64 val, u32 offset)
1226 {
1227 csdev_access_relaxed_write64(&csdev->access, val, offset);
1228 }
1229
coresight_write64(struct coresight_device * csdev,u64 val,u32 offset)1230 void coresight_write64(struct coresight_device *csdev, u64 val, u32 offset)
1231 {
1232 csdev_access_write64(&csdev->access, val, offset);
1233 }
1234
1235 /*
1236 * coresight_release_platform_data: Release references to the devices connected
1237 * to the output port of this device.
1238 */
coresight_release_platform_data(struct coresight_device * csdev,struct device * dev,struct coresight_platform_data * pdata)1239 void coresight_release_platform_data(struct coresight_device *csdev,
1240 struct device *dev,
1241 struct coresight_platform_data *pdata)
1242 {
1243 int i;
1244 struct coresight_connection **conns = pdata->out_conns;
1245
1246 for (i = 0; i < pdata->nr_outconns; i++) {
1247 /* If we have made the links, remove them now */
1248 if (csdev && conns[i]->dest_dev)
1249 coresight_remove_links(csdev, conns[i]);
1250 /*
1251 * Drop the refcount and clear the handle as this device
1252 * is going away
1253 */
1254 fwnode_handle_put(conns[i]->dest_fwnode);
1255 conns[i]->dest_fwnode = NULL;
1256 devm_kfree(dev, conns[i]);
1257 }
1258 devm_kfree(dev, pdata->out_conns);
1259 devm_kfree(dev, pdata->in_conns);
1260 devm_kfree(dev, pdata);
1261 if (csdev)
1262 coresight_remove_conns_sysfs_group(csdev);
1263 }
1264
coresight_register(struct coresight_desc * desc)1265 struct coresight_device *coresight_register(struct coresight_desc *desc)
1266 {
1267 int ret;
1268 struct coresight_device *csdev;
1269 bool registered = false;
1270
1271 csdev = kzalloc(sizeof(*csdev), GFP_KERNEL);
1272 if (!csdev) {
1273 ret = -ENOMEM;
1274 goto err_out;
1275 }
1276
1277 csdev->pdata = desc->pdata;
1278
1279 csdev->type = desc->type;
1280 csdev->subtype = desc->subtype;
1281 csdev->ops = desc->ops;
1282 csdev->access = desc->access;
1283 csdev->orphan = true;
1284
1285 csdev->dev.type = &coresight_dev_type[desc->type];
1286 csdev->dev.groups = desc->groups;
1287 csdev->dev.parent = desc->dev;
1288 csdev->dev.release = coresight_device_release;
1289 csdev->dev.bus = &coresight_bustype;
1290 /*
1291 * Hold the reference to our parent device. This will be
1292 * dropped only in coresight_device_release().
1293 */
1294 csdev->dev.fwnode = fwnode_handle_get(dev_fwnode(desc->dev));
1295 dev_set_name(&csdev->dev, "%s", desc->name);
1296
1297 if (csdev->type == CORESIGHT_DEV_TYPE_SINK ||
1298 csdev->type == CORESIGHT_DEV_TYPE_LINKSINK) {
1299 raw_spin_lock_init(&csdev->perf_sink_id_map.lock);
1300 csdev->perf_sink_id_map.cpu_map = alloc_percpu(atomic_t);
1301 if (!csdev->perf_sink_id_map.cpu_map) {
1302 kfree(csdev);
1303 ret = -ENOMEM;
1304 goto err_out;
1305 }
1306 }
1307 /*
1308 * Make sure the device registration and the connection fixup
1309 * are synchronised, so that we don't see uninitialised devices
1310 * on the coresight bus while trying to resolve the connections.
1311 */
1312 mutex_lock(&coresight_mutex);
1313
1314 ret = device_register(&csdev->dev);
1315 if (ret) {
1316 put_device(&csdev->dev);
1317 /*
1318 * All resources are free'd explicitly via
1319 * coresight_device_release(), triggered from put_device().
1320 */
1321 goto out_unlock;
1322 }
1323
1324 if (csdev->type == CORESIGHT_DEV_TYPE_SINK ||
1325 csdev->type == CORESIGHT_DEV_TYPE_LINKSINK) {
1326 ret = etm_perf_add_symlink_sink(csdev);
1327
1328 if (ret) {
1329 device_unregister(&csdev->dev);
1330 /*
1331 * As with the above, all resources are free'd
1332 * explicitly via coresight_device_release() triggered
1333 * from put_device(), which is in turn called from
1334 * function device_unregister().
1335 */
1336 goto out_unlock;
1337 }
1338 }
1339 /* Device is now registered */
1340 registered = true;
1341
1342 ret = coresight_create_conns_sysfs_group(csdev);
1343 if (!ret)
1344 ret = coresight_fixup_orphan_conns(csdev);
1345
1346 out_unlock:
1347 mutex_unlock(&coresight_mutex);
1348 /* Success */
1349 if (!ret) {
1350 if (cti_assoc_ops && cti_assoc_ops->add)
1351 cti_assoc_ops->add(csdev);
1352 return csdev;
1353 }
1354
1355 /* Unregister the device if needed */
1356 if (registered) {
1357 coresight_unregister(csdev);
1358 return ERR_PTR(ret);
1359 }
1360
1361 err_out:
1362 /* Cleanup the connection information */
1363 coresight_release_platform_data(NULL, desc->dev, desc->pdata);
1364 return ERR_PTR(ret);
1365 }
1366 EXPORT_SYMBOL_GPL(coresight_register);
1367
coresight_unregister(struct coresight_device * csdev)1368 void coresight_unregister(struct coresight_device *csdev)
1369 {
1370 etm_perf_del_symlink_sink(csdev);
1371 /* Remove references of that device in the topology */
1372 if (cti_assoc_ops && cti_assoc_ops->remove)
1373 cti_assoc_ops->remove(csdev);
1374 coresight_remove_conns(csdev);
1375 coresight_clear_default_sink(csdev);
1376 coresight_release_platform_data(csdev, csdev->dev.parent, csdev->pdata);
1377 device_unregister(&csdev->dev);
1378 }
1379 EXPORT_SYMBOL_GPL(coresight_unregister);
1380
1381
1382 /*
1383 * coresight_search_device_idx - Search the fwnode handle of a device
1384 * in the given dev_idx list. Must be called with the coresight_mutex held.
1385 *
1386 * Returns the index of the entry, when found. Otherwise, -ENOENT.
1387 */
coresight_search_device_idx(struct coresight_dev_list * dict,struct fwnode_handle * fwnode)1388 static inline int coresight_search_device_idx(struct coresight_dev_list *dict,
1389 struct fwnode_handle *fwnode)
1390 {
1391 int i;
1392
1393 for (i = 0; i < dict->nr_idx; i++)
1394 if (dict->fwnode_list[i] == fwnode)
1395 return i;
1396 return -ENOENT;
1397 }
1398
coresight_compare_type(enum coresight_dev_type type_a,union coresight_dev_subtype subtype_a,enum coresight_dev_type type_b,union coresight_dev_subtype subtype_b)1399 static bool coresight_compare_type(enum coresight_dev_type type_a,
1400 union coresight_dev_subtype subtype_a,
1401 enum coresight_dev_type type_b,
1402 union coresight_dev_subtype subtype_b)
1403 {
1404 if (type_a != type_b)
1405 return false;
1406
1407 switch (type_a) {
1408 case CORESIGHT_DEV_TYPE_SINK:
1409 return subtype_a.sink_subtype == subtype_b.sink_subtype;
1410 case CORESIGHT_DEV_TYPE_LINK:
1411 return subtype_a.link_subtype == subtype_b.link_subtype;
1412 case CORESIGHT_DEV_TYPE_LINKSINK:
1413 return subtype_a.link_subtype == subtype_b.link_subtype &&
1414 subtype_a.sink_subtype == subtype_b.sink_subtype;
1415 case CORESIGHT_DEV_TYPE_SOURCE:
1416 return subtype_a.source_subtype == subtype_b.source_subtype;
1417 case CORESIGHT_DEV_TYPE_HELPER:
1418 return subtype_a.helper_subtype == subtype_b.helper_subtype;
1419 default:
1420 return false;
1421 }
1422 }
1423
1424 struct coresight_device *
coresight_find_input_type(struct coresight_platform_data * pdata,enum coresight_dev_type type,union coresight_dev_subtype subtype)1425 coresight_find_input_type(struct coresight_platform_data *pdata,
1426 enum coresight_dev_type type,
1427 union coresight_dev_subtype subtype)
1428 {
1429 int i;
1430 struct coresight_connection *conn;
1431
1432 for (i = 0; i < pdata->nr_inconns; ++i) {
1433 conn = pdata->in_conns[i];
1434 if (conn &&
1435 coresight_compare_type(type, subtype, conn->src_dev->type,
1436 conn->src_dev->subtype))
1437 return conn->src_dev;
1438 }
1439 return NULL;
1440 }
1441 EXPORT_SYMBOL_GPL(coresight_find_input_type);
1442
1443 struct coresight_device *
coresight_find_output_type(struct coresight_platform_data * pdata,enum coresight_dev_type type,union coresight_dev_subtype subtype)1444 coresight_find_output_type(struct coresight_platform_data *pdata,
1445 enum coresight_dev_type type,
1446 union coresight_dev_subtype subtype)
1447 {
1448 int i;
1449 struct coresight_connection *conn;
1450
1451 for (i = 0; i < pdata->nr_outconns; ++i) {
1452 conn = pdata->out_conns[i];
1453 if (conn->dest_dev &&
1454 coresight_compare_type(type, subtype, conn->dest_dev->type,
1455 conn->dest_dev->subtype))
1456 return conn->dest_dev;
1457 }
1458 return NULL;
1459 }
1460 EXPORT_SYMBOL_GPL(coresight_find_output_type);
1461
coresight_loses_context_with_cpu(struct device * dev)1462 bool coresight_loses_context_with_cpu(struct device *dev)
1463 {
1464 return fwnode_property_present(dev_fwnode(dev),
1465 "arm,coresight-loses-context-with-cpu");
1466 }
1467 EXPORT_SYMBOL_GPL(coresight_loses_context_with_cpu);
1468
1469 /*
1470 * coresight_alloc_device_name - Get an index for a given device in the
1471 * device index list specific to a driver. An index is allocated for a
1472 * device and is tracked with the fwnode_handle to prevent allocating
1473 * duplicate indices for the same device (e.g, if we defer probing of
1474 * a device due to dependencies), in case the index is requested again.
1475 */
coresight_alloc_device_name(struct coresight_dev_list * dict,struct device * dev)1476 char *coresight_alloc_device_name(struct coresight_dev_list *dict,
1477 struct device *dev)
1478 {
1479 int idx;
1480 char *name = NULL;
1481 struct fwnode_handle **list;
1482
1483 mutex_lock(&coresight_mutex);
1484
1485 idx = coresight_search_device_idx(dict, dev_fwnode(dev));
1486 if (idx < 0) {
1487 /* Make space for the new entry */
1488 idx = dict->nr_idx;
1489 list = krealloc_array(dict->fwnode_list,
1490 idx + 1, sizeof(*dict->fwnode_list),
1491 GFP_KERNEL);
1492 if (ZERO_OR_NULL_PTR(list)) {
1493 idx = -ENOMEM;
1494 goto done;
1495 }
1496
1497 list[idx] = dev_fwnode(dev);
1498 dict->fwnode_list = list;
1499 dict->nr_idx = idx + 1;
1500 }
1501
1502 name = devm_kasprintf(dev, GFP_KERNEL, "%s%d", dict->pfx, idx);
1503 done:
1504 mutex_unlock(&coresight_mutex);
1505 return name;
1506 }
1507 EXPORT_SYMBOL_GPL(coresight_alloc_device_name);
1508
1509 const struct bus_type coresight_bustype = {
1510 .name = "coresight",
1511 };
1512
coresight_panic_sync(struct device * dev,void * data)1513 static int coresight_panic_sync(struct device *dev, void *data)
1514 {
1515 int mode;
1516 struct coresight_device *csdev;
1517
1518 /* Run through panic sync handlers for all enabled devices */
1519 csdev = container_of(dev, struct coresight_device, dev);
1520 mode = coresight_get_mode(csdev);
1521
1522 if ((mode == CS_MODE_SYSFS) || (mode == CS_MODE_PERF)) {
1523 if (panic_ops(csdev))
1524 panic_ops(csdev)->sync(csdev);
1525 }
1526
1527 return 0;
1528 }
1529
coresight_panic_cb(struct notifier_block * self,unsigned long v,void * p)1530 static int coresight_panic_cb(struct notifier_block *self,
1531 unsigned long v, void *p)
1532 {
1533 bus_for_each_dev(&coresight_bustype, NULL, NULL,
1534 coresight_panic_sync);
1535
1536 return 0;
1537 }
1538
1539 static struct notifier_block coresight_notifier = {
1540 .notifier_call = coresight_panic_cb,
1541 };
1542
coresight_init(void)1543 static int __init coresight_init(void)
1544 {
1545 int ret;
1546
1547 ret = bus_register(&coresight_bustype);
1548 if (ret)
1549 return ret;
1550
1551 ret = etm_perf_init();
1552 if (ret)
1553 goto exit_bus_unregister;
1554
1555 /* Register function to be called for panic */
1556 ret = atomic_notifier_chain_register(&panic_notifier_list,
1557 &coresight_notifier);
1558 if (ret)
1559 goto exit_perf;
1560
1561 /* initialise the coresight syscfg API */
1562 ret = cscfg_init();
1563 if (!ret)
1564 return 0;
1565
1566 atomic_notifier_chain_unregister(&panic_notifier_list,
1567 &coresight_notifier);
1568 exit_perf:
1569 etm_perf_exit();
1570 exit_bus_unregister:
1571 bus_unregister(&coresight_bustype);
1572 return ret;
1573 }
1574
coresight_exit(void)1575 static void __exit coresight_exit(void)
1576 {
1577 cscfg_exit();
1578 atomic_notifier_chain_unregister(&panic_notifier_list,
1579 &coresight_notifier);
1580 etm_perf_exit();
1581 bus_unregister(&coresight_bustype);
1582 }
1583
1584 module_init(coresight_init);
1585 module_exit(coresight_exit);
1586
coresight_init_driver(const char * drv,struct amba_driver * amba_drv,struct platform_driver * pdev_drv)1587 int coresight_init_driver(const char *drv, struct amba_driver *amba_drv,
1588 struct platform_driver *pdev_drv)
1589 {
1590 int ret;
1591
1592 ret = amba_driver_register(amba_drv);
1593 if (ret) {
1594 pr_err("%s: error registering AMBA driver\n", drv);
1595 return ret;
1596 }
1597
1598 ret = platform_driver_register(pdev_drv);
1599 if (!ret)
1600 return 0;
1601
1602 pr_err("%s: error registering platform driver\n", drv);
1603 amba_driver_unregister(amba_drv);
1604 return ret;
1605 }
1606 EXPORT_SYMBOL_GPL(coresight_init_driver);
1607
coresight_remove_driver(struct amba_driver * amba_drv,struct platform_driver * pdev_drv)1608 void coresight_remove_driver(struct amba_driver *amba_drv,
1609 struct platform_driver *pdev_drv)
1610 {
1611 amba_driver_unregister(amba_drv);
1612 platform_driver_unregister(pdev_drv);
1613 }
1614 EXPORT_SYMBOL_GPL(coresight_remove_driver);
1615
coresight_etm_get_trace_id(struct coresight_device * csdev,enum cs_mode mode,struct coresight_device * sink)1616 int coresight_etm_get_trace_id(struct coresight_device *csdev, enum cs_mode mode,
1617 struct coresight_device *sink)
1618 {
1619 int cpu, trace_id;
1620
1621 if (csdev->type != CORESIGHT_DEV_TYPE_SOURCE || !source_ops(csdev)->cpu_id)
1622 return -EINVAL;
1623
1624 cpu = source_ops(csdev)->cpu_id(csdev);
1625 switch (mode) {
1626 case CS_MODE_SYSFS:
1627 trace_id = coresight_trace_id_get_cpu_id(cpu);
1628 break;
1629 case CS_MODE_PERF:
1630 if (WARN_ON(!sink))
1631 return -EINVAL;
1632
1633 trace_id = coresight_trace_id_get_cpu_id_map(cpu, &sink->perf_sink_id_map);
1634 break;
1635 default:
1636 trace_id = -EINVAL;
1637 break;
1638 }
1639
1640 if (!IS_VALID_CS_TRACE_ID(trace_id))
1641 dev_err(&csdev->dev,
1642 "Failed to allocate trace ID on CPU%d\n", cpu);
1643
1644 return trace_id;
1645 }
1646 EXPORT_SYMBOL_GPL(coresight_etm_get_trace_id);
1647
1648 MODULE_LICENSE("GPL v2");
1649 MODULE_AUTHOR("Pratik Patel <pratikp@codeaurora.org>");
1650 MODULE_AUTHOR("Mathieu Poirier <mathieu.poirier@linaro.org>");
1651 MODULE_DESCRIPTION("Arm CoreSight tracer driver");
1652