1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2018 Linaro Limited, All rights reserved.
4  * Author: Mike Leach <mike.leach@linaro.org>
5  */
6 
7 #include <linux/amba/bus.h>
8 #include <linux/atomic.h>
9 #include <linux/bits.h>
10 #include <linux/coresight.h>
11 #include <linux/cpu_pm.h>
12 #include <linux/cpuhotplug.h>
13 #include <linux/device.h>
14 #include <linux/io.h>
15 #include <linux/kernel.h>
16 #include <linux/list.h>
17 #include <linux/mutex.h>
18 #include <linux/pm_runtime.h>
19 #include <linux/property.h>
20 #include <linux/spinlock.h>
21 
22 #include "coresight-priv.h"
23 #include "coresight-cti.h"
24 
25 /**
26  * CTI devices can be associated with a PE, or be connected to CoreSight
27  * hardware. We have a list of all CTIs irrespective of CPU bound or
28  * otherwise.
29  *
30  * We assume that the non-CPU CTIs are always powered as we do with sinks etc.
31  *
32  * We leave the client to figure out if all the CTIs are interconnected with
33  * the same CTM, in general this is the case but does not always have to be.
34  */
35 
36 /* net of CTI devices connected via CTM */
37 static LIST_HEAD(ect_net);
38 
39 /* protect the list */
40 static DEFINE_MUTEX(ect_mutex);
41 
42 #define csdev_to_cti_drvdata(csdev)	\
43 	dev_get_drvdata(csdev->dev.parent)
44 
45 /* power management handling */
46 static int nr_cti_cpu;
47 
48 /* quick lookup list for CPU bound CTIs when power handling */
49 static struct cti_drvdata *cti_cpu_drvdata[NR_CPUS];
50 
51 /*
52  * CTI naming. CTI bound to cores will have the name cti_cpu<N> where
53  * N is the CPU ID. System CTIs will have the name cti_sys<I> where I
54  * is an index allocated by order of discovery.
55  *
56  * CTI device name list - for CTI not bound to cores.
57  */
58 DEFINE_CORESIGHT_DEVLIST(cti_sys_devs, "cti_sys");
59 
60 /* write set of regs to hardware - call with spinlock claimed */
61 void cti_write_all_hw_regs(struct cti_drvdata *drvdata)
62 {
63 	struct cti_config *config = &drvdata->config;
64 	int i;
65 
66 	CS_UNLOCK(drvdata->base);
67 
68 	/* disable CTI before writing registers */
69 	writel_relaxed(0, drvdata->base + CTICONTROL);
70 
71 	/* write the CTI trigger registers */
72 	for (i = 0; i < config->nr_trig_max; i++) {
73 		writel_relaxed(config->ctiinen[i], drvdata->base + CTIINEN(i));
74 		writel_relaxed(config->ctiouten[i],
75 			       drvdata->base + CTIOUTEN(i));
76 	}
77 
78 	/* other regs */
79 	writel_relaxed(config->ctigate, drvdata->base + CTIGATE);
80 	writel_relaxed(config->asicctl, drvdata->base + ASICCTL);
81 	writel_relaxed(config->ctiappset, drvdata->base + CTIAPPSET);
82 
83 	/* re-enable CTI */
84 	writel_relaxed(1, drvdata->base + CTICONTROL);
85 
86 	CS_LOCK(drvdata->base);
87 }
88 
89 /* write regs to hardware and enable */
90 static int cti_enable_hw(struct cti_drvdata *drvdata)
91 {
92 	struct cti_config *config = &drvdata->config;
93 	unsigned long flags;
94 	int rc = 0;
95 
96 	spin_lock_irqsave(&drvdata->spinlock, flags);
97 
98 	/* no need to do anything if enabled or unpowered*/
99 	if (config->hw_enabled || !config->hw_powered)
100 		goto cti_state_unchanged;
101 
102 	/* claim the device */
103 	rc = coresight_claim_device(drvdata->csdev);
104 	if (rc)
105 		goto cti_err_not_enabled;
106 
107 	cti_write_all_hw_regs(drvdata);
108 
109 	config->hw_enabled = true;
110 	atomic_inc(&drvdata->config.enable_req_count);
111 	spin_unlock_irqrestore(&drvdata->spinlock, flags);
112 	return rc;
113 
114 cti_state_unchanged:
115 	atomic_inc(&drvdata->config.enable_req_count);
116 
117 	/* cannot enable due to error */
118 cti_err_not_enabled:
119 	spin_unlock_irqrestore(&drvdata->spinlock, flags);
120 	return rc;
121 }
122 
123 /* re-enable CTI on CPU when using CPU hotplug */
124 static void cti_cpuhp_enable_hw(struct cti_drvdata *drvdata)
125 {
126 	struct cti_config *config = &drvdata->config;
127 
128 	spin_lock(&drvdata->spinlock);
129 	config->hw_powered = true;
130 
131 	/* no need to do anything if no enable request */
132 	if (!atomic_read(&drvdata->config.enable_req_count))
133 		goto cti_hp_not_enabled;
134 
135 	/* try to claim the device */
136 	if (coresight_claim_device(drvdata->csdev))
137 		goto cti_hp_not_enabled;
138 
139 	cti_write_all_hw_regs(drvdata);
140 	config->hw_enabled = true;
141 	spin_unlock(&drvdata->spinlock);
142 	return;
143 
144 	/* did not re-enable due to no claim / no request */
145 cti_hp_not_enabled:
146 	spin_unlock(&drvdata->spinlock);
147 }
148 
149 /* disable hardware */
150 static int cti_disable_hw(struct cti_drvdata *drvdata)
151 {
152 	struct cti_config *config = &drvdata->config;
153 	struct coresight_device *csdev = drvdata->csdev;
154 
155 	spin_lock(&drvdata->spinlock);
156 
157 	/* check refcount - disable on 0 */
158 	if (atomic_dec_return(&drvdata->config.enable_req_count) > 0)
159 		goto cti_not_disabled;
160 
161 	/* no need to do anything if disabled or cpu unpowered */
162 	if (!config->hw_enabled || !config->hw_powered)
163 		goto cti_not_disabled;
164 
165 	CS_UNLOCK(drvdata->base);
166 
167 	/* disable CTI */
168 	writel_relaxed(0, drvdata->base + CTICONTROL);
169 	config->hw_enabled = false;
170 
171 	coresight_disclaim_device_unlocked(csdev);
172 	CS_LOCK(drvdata->base);
173 	spin_unlock(&drvdata->spinlock);
174 	return 0;
175 
176 	/* not disabled this call */
177 cti_not_disabled:
178 	spin_unlock(&drvdata->spinlock);
179 	return 0;
180 }
181 
182 void cti_write_single_reg(struct cti_drvdata *drvdata, int offset, u32 value)
183 {
184 	CS_UNLOCK(drvdata->base);
185 	writel_relaxed(value, drvdata->base + offset);
186 	CS_LOCK(drvdata->base);
187 }
188 
189 void cti_write_intack(struct device *dev, u32 ackval)
190 {
191 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
192 	struct cti_config *config = &drvdata->config;
193 
194 	spin_lock(&drvdata->spinlock);
195 	/* write if enabled */
196 	if (cti_active(config))
197 		cti_write_single_reg(drvdata, CTIINTACK, ackval);
198 	spin_unlock(&drvdata->spinlock);
199 }
200 
201 /*
202  * Look at the HW DEVID register for some of the HW settings.
203  * DEVID[15:8] - max number of in / out triggers.
204  */
205 #define CTI_DEVID_MAXTRIGS(devid_val) ((int) BMVAL(devid_val, 8, 15))
206 
207 /* DEVID[19:16] - number of CTM channels */
208 #define CTI_DEVID_CTMCHANNELS(devid_val) ((int) BMVAL(devid_val, 16, 19))
209 
210 static void cti_set_default_config(struct device *dev,
211 				   struct cti_drvdata *drvdata)
212 {
213 	struct cti_config *config = &drvdata->config;
214 	u32 devid;
215 
216 	devid = readl_relaxed(drvdata->base + CORESIGHT_DEVID);
217 	config->nr_trig_max = CTI_DEVID_MAXTRIGS(devid);
218 
219 	/*
220 	 * no current hardware should exceed this, but protect the driver
221 	 * in case of fault / out of spec hw
222 	 */
223 	if (config->nr_trig_max > CTIINOUTEN_MAX) {
224 		dev_warn_once(dev,
225 			"Limiting HW MaxTrig value(%d) to driver max(%d)\n",
226 			config->nr_trig_max, CTIINOUTEN_MAX);
227 		config->nr_trig_max = CTIINOUTEN_MAX;
228 	}
229 
230 	config->nr_ctm_channels = CTI_DEVID_CTMCHANNELS(devid);
231 
232 	/* Most regs default to 0 as zalloc'ed except...*/
233 	config->trig_filter_enable = true;
234 	config->ctigate = GENMASK(config->nr_ctm_channels - 1, 0);
235 	atomic_set(&config->enable_req_count, 0);
236 }
237 
238 /*
239  * Add a connection entry to the list of connections for this
240  * CTI device.
241  */
242 int cti_add_connection_entry(struct device *dev, struct cti_drvdata *drvdata,
243 			     struct cti_trig_con *tc,
244 			     struct coresight_device *csdev,
245 			     const char *assoc_dev_name)
246 {
247 	struct cti_device *cti_dev = &drvdata->ctidev;
248 
249 	tc->con_dev = csdev;
250 	/*
251 	 * Prefer actual associated CS device dev name to supplied value -
252 	 * which is likely to be node name / other conn name.
253 	 */
254 	if (csdev)
255 		tc->con_dev_name = dev_name(&csdev->dev);
256 	else if (assoc_dev_name != NULL) {
257 		tc->con_dev_name = devm_kstrdup(dev,
258 						assoc_dev_name, GFP_KERNEL);
259 		if (!tc->con_dev_name)
260 			return -ENOMEM;
261 	}
262 	list_add_tail(&tc->node, &cti_dev->trig_cons);
263 	cti_dev->nr_trig_con++;
264 
265 	/* add connection usage bit info to overall info */
266 	drvdata->config.trig_in_use |= tc->con_in->used_mask;
267 	drvdata->config.trig_out_use |= tc->con_out->used_mask;
268 
269 	return 0;
270 }
271 
272 /* create a trigger connection with appropriately sized signal groups */
273 struct cti_trig_con *cti_allocate_trig_con(struct device *dev, int in_sigs,
274 					   int out_sigs)
275 {
276 	struct cti_trig_con *tc = NULL;
277 	struct cti_trig_grp *in = NULL, *out = NULL;
278 
279 	tc = devm_kzalloc(dev, sizeof(struct cti_trig_con), GFP_KERNEL);
280 	if (!tc)
281 		return tc;
282 
283 	in = devm_kzalloc(dev,
284 			  offsetof(struct cti_trig_grp, sig_types[in_sigs]),
285 			  GFP_KERNEL);
286 	if (!in)
287 		return NULL;
288 
289 	out = devm_kzalloc(dev,
290 			   offsetof(struct cti_trig_grp, sig_types[out_sigs]),
291 			   GFP_KERNEL);
292 	if (!out)
293 		return NULL;
294 
295 	tc->con_in = in;
296 	tc->con_out = out;
297 	tc->con_in->nr_sigs = in_sigs;
298 	tc->con_out->nr_sigs = out_sigs;
299 	return tc;
300 }
301 
302 /*
303  * Add a default connection if nothing else is specified.
304  * single connection based on max in/out info, no assoc device
305  */
306 int cti_add_default_connection(struct device *dev, struct cti_drvdata *drvdata)
307 {
308 	int ret = 0;
309 	int n_trigs = drvdata->config.nr_trig_max;
310 	u32 n_trig_mask = GENMASK(n_trigs - 1, 0);
311 	struct cti_trig_con *tc = NULL;
312 
313 	/*
314 	 * Assume max trigs for in and out,
315 	 * all used, default sig types allocated
316 	 */
317 	tc = cti_allocate_trig_con(dev, n_trigs, n_trigs);
318 	if (!tc)
319 		return -ENOMEM;
320 
321 	tc->con_in->used_mask = n_trig_mask;
322 	tc->con_out->used_mask = n_trig_mask;
323 	ret = cti_add_connection_entry(dev, drvdata, tc, NULL, "default");
324 	return ret;
325 }
326 
327 /** cti channel api **/
328 /* attach/detach channel from trigger - write through if enabled. */
329 int cti_channel_trig_op(struct device *dev, enum cti_chan_op op,
330 			enum cti_trig_dir direction, u32 channel_idx,
331 			u32 trigger_idx)
332 {
333 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
334 	struct cti_config *config = &drvdata->config;
335 	u32 trig_bitmask;
336 	u32 chan_bitmask;
337 	u32 reg_value;
338 	int reg_offset;
339 
340 	/* ensure indexes in range */
341 	if ((channel_idx >= config->nr_ctm_channels) ||
342 	   (trigger_idx >= config->nr_trig_max))
343 		return -EINVAL;
344 
345 	trig_bitmask = BIT(trigger_idx);
346 
347 	/* ensure registered triggers and not out filtered */
348 	if (direction == CTI_TRIG_IN)	{
349 		if (!(trig_bitmask & config->trig_in_use))
350 			return -EINVAL;
351 	} else {
352 		if (!(trig_bitmask & config->trig_out_use))
353 			return -EINVAL;
354 
355 		if ((config->trig_filter_enable) &&
356 		    (config->trig_out_filter & trig_bitmask))
357 			return -EINVAL;
358 	}
359 
360 	/* update the local register values */
361 	chan_bitmask = BIT(channel_idx);
362 	reg_offset = (direction == CTI_TRIG_IN ? CTIINEN(trigger_idx) :
363 		      CTIOUTEN(trigger_idx));
364 
365 	spin_lock(&drvdata->spinlock);
366 
367 	/* read - modify write - the trigger / channel enable value */
368 	reg_value = direction == CTI_TRIG_IN ? config->ctiinen[trigger_idx] :
369 		     config->ctiouten[trigger_idx];
370 	if (op == CTI_CHAN_ATTACH)
371 		reg_value |= chan_bitmask;
372 	else
373 		reg_value &= ~chan_bitmask;
374 
375 	/* write local copy */
376 	if (direction == CTI_TRIG_IN)
377 		config->ctiinen[trigger_idx] = reg_value;
378 	else
379 		config->ctiouten[trigger_idx] = reg_value;
380 
381 	/* write through if enabled */
382 	if (cti_active(config))
383 		cti_write_single_reg(drvdata, reg_offset, reg_value);
384 	spin_unlock(&drvdata->spinlock);
385 	return 0;
386 }
387 
388 int cti_channel_gate_op(struct device *dev, enum cti_chan_gate_op op,
389 			u32 channel_idx)
390 {
391 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
392 	struct cti_config *config = &drvdata->config;
393 	u32 chan_bitmask;
394 	u32 reg_value;
395 	int err = 0;
396 
397 	if (channel_idx >= config->nr_ctm_channels)
398 		return -EINVAL;
399 
400 	chan_bitmask = BIT(channel_idx);
401 
402 	spin_lock(&drvdata->spinlock);
403 	reg_value = config->ctigate;
404 	switch (op) {
405 	case CTI_GATE_CHAN_ENABLE:
406 		reg_value |= chan_bitmask;
407 		break;
408 
409 	case CTI_GATE_CHAN_DISABLE:
410 		reg_value &= ~chan_bitmask;
411 		break;
412 
413 	default:
414 		err = -EINVAL;
415 		break;
416 	}
417 	if (err == 0) {
418 		config->ctigate = reg_value;
419 		if (cti_active(config))
420 			cti_write_single_reg(drvdata, CTIGATE, reg_value);
421 	}
422 	spin_unlock(&drvdata->spinlock);
423 	return err;
424 }
425 
426 int cti_channel_setop(struct device *dev, enum cti_chan_set_op op,
427 		      u32 channel_idx)
428 {
429 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
430 	struct cti_config *config = &drvdata->config;
431 	u32 chan_bitmask;
432 	u32 reg_value;
433 	u32 reg_offset;
434 	int err = 0;
435 
436 	if (channel_idx >= config->nr_ctm_channels)
437 		return -EINVAL;
438 
439 	chan_bitmask = BIT(channel_idx);
440 
441 	spin_lock(&drvdata->spinlock);
442 	reg_value = config->ctiappset;
443 	switch (op) {
444 	case CTI_CHAN_SET:
445 		config->ctiappset |= chan_bitmask;
446 		reg_value  = config->ctiappset;
447 		reg_offset = CTIAPPSET;
448 		break;
449 
450 	case CTI_CHAN_CLR:
451 		config->ctiappset &= ~chan_bitmask;
452 		reg_value = chan_bitmask;
453 		reg_offset = CTIAPPCLEAR;
454 		break;
455 
456 	case CTI_CHAN_PULSE:
457 		config->ctiappset &= ~chan_bitmask;
458 		reg_value = chan_bitmask;
459 		reg_offset = CTIAPPPULSE;
460 		break;
461 
462 	default:
463 		err = -EINVAL;
464 		break;
465 	}
466 
467 	if ((err == 0) && cti_active(config))
468 		cti_write_single_reg(drvdata, reg_offset, reg_value);
469 	spin_unlock(&drvdata->spinlock);
470 
471 	return err;
472 }
473 
474 static bool cti_add_sysfs_link(struct cti_drvdata *drvdata,
475 			       struct cti_trig_con *tc)
476 {
477 	struct coresight_sysfs_link link_info;
478 	int link_err = 0;
479 
480 	link_info.orig = drvdata->csdev;
481 	link_info.orig_name = tc->con_dev_name;
482 	link_info.target = tc->con_dev;
483 	link_info.target_name = dev_name(&drvdata->csdev->dev);
484 
485 	link_err = coresight_add_sysfs_link(&link_info);
486 	if (link_err)
487 		dev_warn(&drvdata->csdev->dev,
488 			 "Failed to set CTI sysfs link %s<=>%s\n",
489 			 link_info.orig_name, link_info.target_name);
490 	return !link_err;
491 }
492 
493 static void cti_remove_sysfs_link(struct cti_drvdata *drvdata,
494 				  struct cti_trig_con *tc)
495 {
496 	struct coresight_sysfs_link link_info;
497 
498 	link_info.orig = drvdata->csdev;
499 	link_info.orig_name = tc->con_dev_name;
500 	link_info.target = tc->con_dev;
501 	link_info.target_name = dev_name(&drvdata->csdev->dev);
502 	coresight_remove_sysfs_link(&link_info);
503 }
504 
505 /*
506  * Look for a matching connection device name in the list of connections.
507  * If found then swap in the csdev name, set trig con association pointer
508  * and return found.
509  */
510 static bool
511 cti_match_fixup_csdev(struct cti_device *ctidev, const char *node_name,
512 		      struct coresight_device *csdev)
513 {
514 	struct cti_trig_con *tc;
515 	struct cti_drvdata *drvdata = container_of(ctidev, struct cti_drvdata,
516 						   ctidev);
517 
518 	list_for_each_entry(tc, &ctidev->trig_cons, node) {
519 		if (tc->con_dev_name) {
520 			if (!strcmp(node_name, tc->con_dev_name)) {
521 				/* match: so swap in csdev name & dev */
522 				tc->con_dev_name = dev_name(&csdev->dev);
523 				tc->con_dev = csdev;
524 				/* try to set sysfs link */
525 				if (cti_add_sysfs_link(drvdata, tc))
526 					return true;
527 				/* link failed - remove CTI reference */
528 				tc->con_dev = NULL;
529 				break;
530 			}
531 		}
532 	}
533 	return false;
534 }
535 
536 /*
537  * Search the cti list to add an associated CTI into the supplied CS device
538  * This will set the association if CTI declared before the CS device.
539  * (called from coresight_register() without coresight_mutex locked).
540  */
541 static void cti_add_assoc_to_csdev(struct coresight_device *csdev)
542 {
543 	struct cti_drvdata *ect_item;
544 	struct cti_device *ctidev;
545 	const char *node_name = NULL;
546 
547 	/* protect the list */
548 	mutex_lock(&ect_mutex);
549 
550 	/* exit if current is an ECT device.*/
551 	if ((csdev->type == CORESIGHT_DEV_TYPE_ECT) || list_empty(&ect_net))
552 		goto cti_add_done;
553 
554 	/* if we didn't find the csdev previously we used the fwnode name */
555 	node_name = cti_plat_get_node_name(dev_fwnode(csdev->dev.parent));
556 	if (!node_name)
557 		goto cti_add_done;
558 
559 	/* for each CTI in list... */
560 	list_for_each_entry(ect_item, &ect_net, node) {
561 		ctidev = &ect_item->ctidev;
562 		if (cti_match_fixup_csdev(ctidev, node_name, csdev)) {
563 			/*
564 			 * if we found a matching csdev then update the ECT
565 			 * association pointer for the device with this CTI.
566 			 */
567 			coresight_set_assoc_ectdev_mutex(csdev,
568 							 ect_item->csdev);
569 			break;
570 		}
571 	}
572 cti_add_done:
573 	mutex_unlock(&ect_mutex);
574 }
575 
576 /*
577  * Removing the associated devices is easier.
578  * A CTI will not have a value for csdev->ect_dev.
579  */
580 static void cti_remove_assoc_from_csdev(struct coresight_device *csdev)
581 {
582 	struct cti_drvdata *ctidrv;
583 	struct cti_trig_con *tc;
584 	struct cti_device *ctidev;
585 
586 	mutex_lock(&ect_mutex);
587 	if (csdev->ect_dev) {
588 		ctidrv = csdev_to_cti_drvdata(csdev->ect_dev);
589 		ctidev = &ctidrv->ctidev;
590 		list_for_each_entry(tc, &ctidev->trig_cons, node) {
591 			if (tc->con_dev == csdev) {
592 				cti_remove_sysfs_link(ctidrv, tc);
593 				tc->con_dev = NULL;
594 				break;
595 			}
596 		}
597 		csdev->ect_dev = NULL;
598 	}
599 	mutex_unlock(&ect_mutex);
600 }
601 
602 /*
603  * Operations to add and remove associated CTI.
604  * Register to coresight core driver as call back function.
605  */
606 static struct cti_assoc_op cti_assoc_ops = {
607 	.add = cti_add_assoc_to_csdev,
608 	.remove = cti_remove_assoc_from_csdev
609 };
610 
611 /*
612  * Update the cross references where the associated device was found
613  * while we were building the connection info. This will occur if the
614  * assoc device was registered before the CTI.
615  */
616 static void cti_update_conn_xrefs(struct cti_drvdata *drvdata)
617 {
618 	struct cti_trig_con *tc;
619 	struct cti_device *ctidev = &drvdata->ctidev;
620 
621 	list_for_each_entry(tc, &ctidev->trig_cons, node) {
622 		if (tc->con_dev) {
623 			/* if we can set the sysfs link */
624 			if (cti_add_sysfs_link(drvdata, tc))
625 				/* set the CTI/csdev association */
626 				coresight_set_assoc_ectdev_mutex(tc->con_dev,
627 							 drvdata->csdev);
628 			else
629 				/* otherwise remove reference from CTI */
630 				tc->con_dev = NULL;
631 		}
632 	}
633 }
634 
635 static void cti_remove_conn_xrefs(struct cti_drvdata *drvdata)
636 {
637 	struct cti_trig_con *tc;
638 	struct cti_device *ctidev = &drvdata->ctidev;
639 
640 	list_for_each_entry(tc, &ctidev->trig_cons, node) {
641 		if (tc->con_dev) {
642 			coresight_set_assoc_ectdev_mutex(tc->con_dev,
643 							 NULL);
644 			cti_remove_sysfs_link(drvdata, tc);
645 			tc->con_dev = NULL;
646 		}
647 	}
648 }
649 
650 /** cti PM callbacks **/
651 static int cti_cpu_pm_notify(struct notifier_block *nb, unsigned long cmd,
652 			     void *v)
653 {
654 	struct cti_drvdata *drvdata;
655 	struct coresight_device *csdev;
656 	unsigned int cpu = smp_processor_id();
657 	int notify_res = NOTIFY_OK;
658 
659 	if (!cti_cpu_drvdata[cpu])
660 		return NOTIFY_OK;
661 
662 	drvdata = cti_cpu_drvdata[cpu];
663 	csdev = drvdata->csdev;
664 
665 	if (WARN_ON_ONCE(drvdata->ctidev.cpu != cpu))
666 		return NOTIFY_BAD;
667 
668 	spin_lock(&drvdata->spinlock);
669 
670 	switch (cmd) {
671 	case CPU_PM_ENTER:
672 		/* CTI regs all static - we have a copy & nothing to save */
673 		drvdata->config.hw_powered = false;
674 		if (drvdata->config.hw_enabled)
675 			coresight_disclaim_device(csdev);
676 		break;
677 
678 	case CPU_PM_ENTER_FAILED:
679 		drvdata->config.hw_powered = true;
680 		if (drvdata->config.hw_enabled) {
681 			if (coresight_claim_device(csdev))
682 				drvdata->config.hw_enabled = false;
683 		}
684 		break;
685 
686 	case CPU_PM_EXIT:
687 		/* write hardware registers to re-enable. */
688 		drvdata->config.hw_powered = true;
689 		drvdata->config.hw_enabled = false;
690 
691 		/* check enable reference count to enable HW */
692 		if (atomic_read(&drvdata->config.enable_req_count)) {
693 			/* check we can claim the device as we re-power */
694 			if (coresight_claim_device(csdev))
695 				goto cti_notify_exit;
696 
697 			drvdata->config.hw_enabled = true;
698 			cti_write_all_hw_regs(drvdata);
699 		}
700 		break;
701 
702 	default:
703 		notify_res = NOTIFY_DONE;
704 		break;
705 	}
706 
707 cti_notify_exit:
708 	spin_unlock(&drvdata->spinlock);
709 	return notify_res;
710 }
711 
712 static struct notifier_block cti_cpu_pm_nb = {
713 	.notifier_call = cti_cpu_pm_notify,
714 };
715 
716 /* CPU HP handlers */
717 static int cti_starting_cpu(unsigned int cpu)
718 {
719 	struct cti_drvdata *drvdata = cti_cpu_drvdata[cpu];
720 
721 	if (!drvdata)
722 		return 0;
723 
724 	cti_cpuhp_enable_hw(drvdata);
725 	return 0;
726 }
727 
728 static int cti_dying_cpu(unsigned int cpu)
729 {
730 	struct cti_drvdata *drvdata = cti_cpu_drvdata[cpu];
731 
732 	if (!drvdata)
733 		return 0;
734 
735 	spin_lock(&drvdata->spinlock);
736 	drvdata->config.hw_powered = false;
737 	if (drvdata->config.hw_enabled)
738 		coresight_disclaim_device(drvdata->csdev);
739 	spin_unlock(&drvdata->spinlock);
740 	return 0;
741 }
742 
743 static int cti_pm_setup(struct cti_drvdata *drvdata)
744 {
745 	int ret;
746 
747 	if (drvdata->ctidev.cpu == -1)
748 		return 0;
749 
750 	if (nr_cti_cpu)
751 		goto done;
752 
753 	cpus_read_lock();
754 	ret = cpuhp_setup_state_nocalls_cpuslocked(
755 			CPUHP_AP_ARM_CORESIGHT_CTI_STARTING,
756 			"arm/coresight_cti:starting",
757 			cti_starting_cpu, cti_dying_cpu);
758 	if (ret) {
759 		cpus_read_unlock();
760 		return ret;
761 	}
762 
763 	ret = cpu_pm_register_notifier(&cti_cpu_pm_nb);
764 	cpus_read_unlock();
765 	if (ret) {
766 		cpuhp_remove_state_nocalls(CPUHP_AP_ARM_CORESIGHT_CTI_STARTING);
767 		return ret;
768 	}
769 
770 done:
771 	nr_cti_cpu++;
772 	cti_cpu_drvdata[drvdata->ctidev.cpu] = drvdata;
773 
774 	return 0;
775 }
776 
777 /* release PM registrations */
778 static void cti_pm_release(struct cti_drvdata *drvdata)
779 {
780 	if (drvdata->ctidev.cpu == -1)
781 		return;
782 
783 	cti_cpu_drvdata[drvdata->ctidev.cpu] = NULL;
784 	if (--nr_cti_cpu == 0) {
785 		cpu_pm_unregister_notifier(&cti_cpu_pm_nb);
786 		cpuhp_remove_state_nocalls(CPUHP_AP_ARM_CORESIGHT_CTI_STARTING);
787 	}
788 }
789 
790 /** cti ect operations **/
791 int cti_enable(struct coresight_device *csdev)
792 {
793 	struct cti_drvdata *drvdata = csdev_to_cti_drvdata(csdev);
794 
795 	return cti_enable_hw(drvdata);
796 }
797 
798 int cti_disable(struct coresight_device *csdev)
799 {
800 	struct cti_drvdata *drvdata = csdev_to_cti_drvdata(csdev);
801 
802 	return cti_disable_hw(drvdata);
803 }
804 
805 static const struct coresight_ops_ect cti_ops_ect = {
806 	.enable = cti_enable,
807 	.disable = cti_disable,
808 };
809 
810 static const struct coresight_ops cti_ops = {
811 	.ect_ops = &cti_ops_ect,
812 };
813 
814 /*
815  * Free up CTI specific resources
816  * called by dev->release, need to call down to underlying csdev release.
817  */
818 static void cti_device_release(struct device *dev)
819 {
820 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
821 	struct cti_drvdata *ect_item, *ect_tmp;
822 
823 	mutex_lock(&ect_mutex);
824 	cti_pm_release(drvdata);
825 
826 	/* remove from the list */
827 	list_for_each_entry_safe(ect_item, ect_tmp, &ect_net, node) {
828 		if (ect_item == drvdata) {
829 			list_del(&ect_item->node);
830 			break;
831 		}
832 	}
833 	mutex_unlock(&ect_mutex);
834 
835 	if (drvdata->csdev_release)
836 		drvdata->csdev_release(dev);
837 }
838 static void cti_remove(struct amba_device *adev)
839 {
840 	struct cti_drvdata *drvdata = dev_get_drvdata(&adev->dev);
841 
842 	mutex_lock(&ect_mutex);
843 	cti_remove_conn_xrefs(drvdata);
844 	mutex_unlock(&ect_mutex);
845 
846 	coresight_unregister(drvdata->csdev);
847 }
848 
849 static int cti_probe(struct amba_device *adev, const struct amba_id *id)
850 {
851 	int ret = 0;
852 	void __iomem *base;
853 	struct device *dev = &adev->dev;
854 	struct cti_drvdata *drvdata = NULL;
855 	struct coresight_desc cti_desc;
856 	struct coresight_platform_data *pdata = NULL;
857 	struct resource *res = &adev->res;
858 
859 	/* driver data*/
860 	drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL);
861 	if (!drvdata)
862 		return -ENOMEM;
863 
864 	/* Validity for the resource is already checked by the AMBA core */
865 	base = devm_ioremap_resource(dev, res);
866 	if (IS_ERR(base))
867 		return PTR_ERR(base);
868 
869 	drvdata->base = base;
870 	cti_desc.access = CSDEV_ACCESS_IOMEM(base);
871 
872 	dev_set_drvdata(dev, drvdata);
873 
874 	/* default CTI device info  */
875 	drvdata->ctidev.cpu = -1;
876 	drvdata->ctidev.nr_trig_con = 0;
877 	drvdata->ctidev.ctm_id = 0;
878 	INIT_LIST_HEAD(&drvdata->ctidev.trig_cons);
879 
880 	spin_lock_init(&drvdata->spinlock);
881 
882 	/* initialise CTI driver config values */
883 	cti_set_default_config(dev, drvdata);
884 
885 	pdata = coresight_cti_get_platform_data(dev);
886 	if (IS_ERR(pdata)) {
887 		dev_err(dev, "coresight_cti_get_platform_data err\n");
888 		return  PTR_ERR(pdata);
889 	}
890 
891 	/* default to powered - could change on PM notifications */
892 	drvdata->config.hw_powered = true;
893 
894 	/* set up device name - will depend if cpu bound or otherwise */
895 	if (drvdata->ctidev.cpu >= 0)
896 		cti_desc.name = devm_kasprintf(dev, GFP_KERNEL, "cti_cpu%d",
897 					       drvdata->ctidev.cpu);
898 	else
899 		cti_desc.name = coresight_alloc_device_name(&cti_sys_devs, dev);
900 	if (!cti_desc.name)
901 		return -ENOMEM;
902 
903 	/* setup CPU power management handling for CPU bound CTI devices. */
904 	ret = cti_pm_setup(drvdata);
905 	if (ret)
906 		return ret;
907 
908 	/* create dynamic attributes for connections */
909 	ret = cti_create_cons_sysfs(dev, drvdata);
910 	if (ret) {
911 		dev_err(dev, "%s: create dynamic sysfs entries failed\n",
912 			cti_desc.name);
913 		goto pm_release;
914 	}
915 
916 	/* set up coresight component description */
917 	cti_desc.pdata = pdata;
918 	cti_desc.type = CORESIGHT_DEV_TYPE_ECT;
919 	cti_desc.subtype.ect_subtype = CORESIGHT_DEV_SUBTYPE_ECT_CTI;
920 	cti_desc.ops = &cti_ops;
921 	cti_desc.groups = drvdata->ctidev.con_groups;
922 	cti_desc.dev = dev;
923 	drvdata->csdev = coresight_register(&cti_desc);
924 	if (IS_ERR(drvdata->csdev)) {
925 		ret = PTR_ERR(drvdata->csdev);
926 		goto pm_release;
927 	}
928 
929 	/* add to list of CTI devices */
930 	mutex_lock(&ect_mutex);
931 	list_add(&drvdata->node, &ect_net);
932 	/* set any cross references */
933 	cti_update_conn_xrefs(drvdata);
934 	mutex_unlock(&ect_mutex);
935 
936 	/* set up release chain */
937 	drvdata->csdev_release = drvdata->csdev->dev.release;
938 	drvdata->csdev->dev.release = cti_device_release;
939 
940 	/* all done - dec pm refcount */
941 	pm_runtime_put(&adev->dev);
942 	dev_info(&drvdata->csdev->dev, "CTI initialized\n");
943 	return 0;
944 
945 pm_release:
946 	cti_pm_release(drvdata);
947 	return ret;
948 }
949 
950 static struct amba_cs_uci_id uci_id_cti[] = {
951 	{
952 		/*  CTI UCI data */
953 		.devarch	= 0x47701a14, /* CTI v2 */
954 		.devarch_mask	= 0xfff0ffff,
955 		.devtype	= 0x00000014, /* maj(0x4-debug) min(0x1-ECT) */
956 	}
957 };
958 
959 static const struct amba_id cti_ids[] = {
960 	CS_AMBA_ID(0x000bb906), /* Coresight CTI (SoC 400), C-A72, C-A57 */
961 	CS_AMBA_ID(0x000bb922), /* CTI - C-A8 */
962 	CS_AMBA_ID(0x000bb9a8), /* CTI - C-A53 */
963 	CS_AMBA_ID(0x000bb9aa), /* CTI - C-A73 */
964 	CS_AMBA_UCI_ID(0x000bb9da, uci_id_cti), /* CTI - C-A35 */
965 	CS_AMBA_UCI_ID(0x000bb9ed, uci_id_cti), /* Coresight CTI (SoC 600) */
966 	{ 0, 0},
967 };
968 
969 MODULE_DEVICE_TABLE(amba, cti_ids);
970 
971 static struct amba_driver cti_driver = {
972 	.drv = {
973 		.name	= "coresight-cti",
974 		.owner = THIS_MODULE,
975 		.suppress_bind_attrs = true,
976 	},
977 	.probe		= cti_probe,
978 	.remove		= cti_remove,
979 	.id_table	= cti_ids,
980 };
981 
982 static int __init cti_init(void)
983 {
984 	int ret;
985 
986 	ret = amba_driver_register(&cti_driver);
987 	if (ret)
988 		pr_info("Error registering cti driver\n");
989 	coresight_set_cti_ops(&cti_assoc_ops);
990 	return ret;
991 }
992 
993 static void __exit cti_exit(void)
994 {
995 	coresight_remove_cti_ops();
996 	amba_driver_unregister(&cti_driver);
997 }
998 
999 module_init(cti_init);
1000 module_exit(cti_exit);
1001 
1002 MODULE_AUTHOR("Mike Leach <mike.leach@linaro.org>");
1003 MODULE_DESCRIPTION("Arm CoreSight CTI Driver");
1004 MODULE_LICENSE("GPL v2");
1005