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