1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2019 Linaro Limited, All rights reserved.
4  * Author: Mike Leach <mike.leach@linaro.org>
5  */
6 
7 #include <linux/atomic.h>
8 #include <linux/coresight.h>
9 #include <linux/device.h>
10 #include <linux/io.h>
11 #include <linux/kernel.h>
12 #include <linux/spinlock.h>
13 #include <linux/sysfs.h>
14 
15 #include "coresight-cti.h"
16 
17 /*
18  * Declare the number of static declared attribute groups
19  * Value includes groups + NULL value at end of table.
20  */
21 #define CORESIGHT_CTI_STATIC_GROUPS_MAX 5
22 
23 /*
24  * List of trigger signal type names. Match the constants declared in
25  * include\dt-bindings\arm\coresight-cti-dt.h
26  */
27 static const char * const sig_type_names[] = {
28 	"genio",	/* GEN_IO */
29 	"intreq",	/* GEN_INTREQ */
30 	"intack",	/* GEN_INTACK */
31 	"haltreq",	/* GEN_HALTREQ */
32 	"restartreq",	/* GEN_RESTARTREQ */
33 	"pe_edbgreq",	/* PE_EDBGREQ */
34 	"pe_dbgrestart",/* PE_DBGRESTART */
35 	"pe_ctiirq",	/* PE_CTIIRQ */
36 	"pe_pmuirq",	/* PE_PMUIRQ */
37 	"pe_dbgtrigger",/* PE_DBGTRIGGER */
38 	"etm_extout",	/* ETM_EXTOUT */
39 	"etm_extin",	/* ETM_EXTIN */
40 	"snk_full",	/* SNK_FULL */
41 	"snk_acqcomp",	/* SNK_ACQCOMP */
42 	"snk_flushcomp",/* SNK_FLUSHCOMP */
43 	"snk_flushin",	/* SNK_FLUSHIN */
44 	"snk_trigin",	/* SNK_TRIGIN */
45 	"stm_asyncout",	/* STM_ASYNCOUT */
46 	"stm_tout_spte",/* STM_TOUT_SPTE */
47 	"stm_tout_sw",	/* STM_TOUT_SW */
48 	"stm_tout_hete",/* STM_TOUT_HETE */
49 	"stm_hwevent",	/* STM_HWEVENT */
50 	"ela_tstart",	/* ELA_TSTART */
51 	"ela_tstop",	/* ELA_TSTOP */
52 	"ela_dbgreq",	/* ELA_DBGREQ */
53 };
54 
55 /* Show function pointer used in the connections dynamic declared attributes*/
56 typedef ssize_t (*p_show_fn)(struct device *dev, struct device_attribute *attr,
57 			     char *buf);
58 
59 /* Connection attribute types */
60 enum cti_conn_attr_type {
61 	CTI_CON_ATTR_NAME,
62 	CTI_CON_ATTR_TRIGIN_SIG,
63 	CTI_CON_ATTR_TRIGOUT_SIG,
64 	CTI_CON_ATTR_TRIGIN_TYPES,
65 	CTI_CON_ATTR_TRIGOUT_TYPES,
66 	CTI_CON_ATTR_MAX,
67 };
68 
69 /* Names for the connection attributes */
70 static const char * const con_attr_names[CTI_CON_ATTR_MAX] = {
71 	"name",
72 	"in_signals",
73 	"out_signals",
74 	"in_types",
75 	"out_types",
76 };
77 
78 /* basic attributes */
79 static ssize_t enable_show(struct device *dev,
80 			   struct device_attribute *attr,
81 			   char *buf)
82 {
83 	int enable_req;
84 	bool enabled, powered;
85 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
86 
87 	enable_req = atomic_read(&drvdata->config.enable_req_count);
88 	spin_lock(&drvdata->spinlock);
89 	powered = drvdata->config.hw_powered;
90 	enabled = drvdata->config.hw_enabled;
91 	spin_unlock(&drvdata->spinlock);
92 
93 	if (powered)
94 		return sprintf(buf, "%d\n", enabled);
95 	else
96 		return sprintf(buf, "%d\n", !!enable_req);
97 }
98 
99 static ssize_t enable_store(struct device *dev,
100 			    struct device_attribute *attr,
101 			    const char *buf, size_t size)
102 {
103 	int ret = 0;
104 	unsigned long val;
105 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
106 
107 	ret = kstrtoul(buf, 0, &val);
108 	if (ret)
109 		return ret;
110 
111 	if (val)
112 		ret = cti_enable(drvdata->csdev);
113 	else
114 		ret = cti_disable(drvdata->csdev);
115 	if (ret)
116 		return ret;
117 	return size;
118 }
119 static DEVICE_ATTR_RW(enable);
120 
121 static ssize_t powered_show(struct device *dev,
122 			    struct device_attribute *attr,
123 			    char *buf)
124 {
125 	bool powered;
126 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
127 
128 	spin_lock(&drvdata->spinlock);
129 	powered = drvdata->config.hw_powered;
130 	spin_unlock(&drvdata->spinlock);
131 
132 	return sprintf(buf, "%d\n", powered);
133 }
134 static DEVICE_ATTR_RO(powered);
135 
136 static ssize_t ctmid_show(struct device *dev,
137 			  struct device_attribute *attr, char *buf)
138 {
139 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
140 
141 	return sprintf(buf, "%d\n", drvdata->ctidev.ctm_id);
142 }
143 static DEVICE_ATTR_RO(ctmid);
144 
145 static ssize_t nr_trigger_cons_show(struct device *dev,
146 				    struct device_attribute *attr,
147 				    char *buf)
148 {
149 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
150 
151 	return sprintf(buf, "%d\n", drvdata->ctidev.nr_trig_con);
152 }
153 static DEVICE_ATTR_RO(nr_trigger_cons);
154 
155 /* attribute and group sysfs tables. */
156 static struct attribute *coresight_cti_attrs[] = {
157 	&dev_attr_enable.attr,
158 	&dev_attr_powered.attr,
159 	&dev_attr_ctmid.attr,
160 	&dev_attr_nr_trigger_cons.attr,
161 	NULL,
162 };
163 
164 /* register based attributes */
165 
166 /* macro to access RO registers with power check only (no enable check). */
167 #define coresight_cti_reg(name, offset)			\
168 static ssize_t name##_show(struct device *dev,				\
169 			   struct device_attribute *attr, char *buf)	\
170 {									\
171 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);	\
172 	u32 val = 0;							\
173 	pm_runtime_get_sync(dev->parent);				\
174 	spin_lock(&drvdata->spinlock);					\
175 	if (drvdata->config.hw_powered)					\
176 		val = readl_relaxed(drvdata->base + offset);		\
177 	spin_unlock(&drvdata->spinlock);				\
178 	pm_runtime_put_sync(dev->parent);				\
179 	return sprintf(buf, "0x%x\n", val);				\
180 }									\
181 static DEVICE_ATTR_RO(name)
182 
183 /* coresight management registers */
184 coresight_cti_reg(devaff0, CTIDEVAFF0);
185 coresight_cti_reg(devaff1, CTIDEVAFF1);
186 coresight_cti_reg(authstatus, CORESIGHT_AUTHSTATUS);
187 coresight_cti_reg(devarch, CORESIGHT_DEVARCH);
188 coresight_cti_reg(devid, CORESIGHT_DEVID);
189 coresight_cti_reg(devtype, CORESIGHT_DEVTYPE);
190 coresight_cti_reg(pidr0, CORESIGHT_PERIPHIDR0);
191 coresight_cti_reg(pidr1, CORESIGHT_PERIPHIDR1);
192 coresight_cti_reg(pidr2, CORESIGHT_PERIPHIDR2);
193 coresight_cti_reg(pidr3, CORESIGHT_PERIPHIDR3);
194 coresight_cti_reg(pidr4, CORESIGHT_PERIPHIDR4);
195 
196 static struct attribute *coresight_cti_mgmt_attrs[] = {
197 	&dev_attr_devaff0.attr,
198 	&dev_attr_devaff1.attr,
199 	&dev_attr_authstatus.attr,
200 	&dev_attr_devarch.attr,
201 	&dev_attr_devid.attr,
202 	&dev_attr_devtype.attr,
203 	&dev_attr_pidr0.attr,
204 	&dev_attr_pidr1.attr,
205 	&dev_attr_pidr2.attr,
206 	&dev_attr_pidr3.attr,
207 	&dev_attr_pidr4.attr,
208 	NULL,
209 };
210 
211 /* CTI low level programming registers */
212 
213 /*
214  * Show a simple 32 bit value if enabled and powered.
215  * If inaccessible & pcached_val not NULL then show cached value.
216  */
217 static ssize_t cti_reg32_show(struct device *dev, char *buf,
218 			      u32 *pcached_val, int reg_offset)
219 {
220 	u32 val = 0;
221 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
222 	struct cti_config *config = &drvdata->config;
223 
224 	spin_lock(&drvdata->spinlock);
225 	if ((reg_offset >= 0) && cti_active(config)) {
226 		CS_UNLOCK(drvdata->base);
227 		val = readl_relaxed(drvdata->base + reg_offset);
228 		if (pcached_val)
229 			*pcached_val = val;
230 		CS_LOCK(drvdata->base);
231 	} else if (pcached_val) {
232 		val = *pcached_val;
233 	}
234 	spin_unlock(&drvdata->spinlock);
235 	return sprintf(buf, "%#x\n", val);
236 }
237 
238 /*
239  * Store a simple 32 bit value.
240  * If pcached_val not NULL, then copy to here too,
241  * if reg_offset >= 0 then write through if enabled.
242  */
243 static ssize_t cti_reg32_store(struct device *dev, const char *buf,
244 			       size_t size, u32 *pcached_val, int reg_offset)
245 {
246 	unsigned long val;
247 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
248 	struct cti_config *config = &drvdata->config;
249 
250 	if (kstrtoul(buf, 0, &val))
251 		return -EINVAL;
252 
253 	spin_lock(&drvdata->spinlock);
254 	/* local store */
255 	if (pcached_val)
256 		*pcached_val = (u32)val;
257 
258 	/* write through if offset and enabled */
259 	if ((reg_offset >= 0) && cti_active(config))
260 		cti_write_single_reg(drvdata, reg_offset, val);
261 	spin_unlock(&drvdata->spinlock);
262 	return size;
263 }
264 
265 /* Standard macro for simple rw cti config registers */
266 #define cti_config_reg32_rw(name, cfgname, offset)			\
267 static ssize_t name##_show(struct device *dev,				\
268 			   struct device_attribute *attr,		\
269 			   char *buf)					\
270 {									\
271 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);	\
272 	return cti_reg32_show(dev, buf,					\
273 			      &drvdata->config.cfgname, offset);	\
274 }									\
275 									\
276 static ssize_t name##_store(struct device *dev,				\
277 			    struct device_attribute *attr,		\
278 			    const char *buf, size_t size)		\
279 {									\
280 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);	\
281 	return cti_reg32_store(dev, buf, size,				\
282 			       &drvdata->config.cfgname, offset);	\
283 }									\
284 static DEVICE_ATTR_RW(name)
285 
286 static ssize_t inout_sel_show(struct device *dev,
287 			      struct device_attribute *attr,
288 			      char *buf)
289 {
290 	u32 val;
291 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
292 
293 	val = (u32)drvdata->config.ctiinout_sel;
294 	return sprintf(buf, "%d\n", val);
295 }
296 
297 static ssize_t inout_sel_store(struct device *dev,
298 			       struct device_attribute *attr,
299 			       const char *buf, size_t size)
300 {
301 	unsigned long val;
302 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
303 
304 	if (kstrtoul(buf, 0, &val))
305 		return -EINVAL;
306 	if (val > (CTIINOUTEN_MAX - 1))
307 		return -EINVAL;
308 
309 	spin_lock(&drvdata->spinlock);
310 	drvdata->config.ctiinout_sel = val;
311 	spin_unlock(&drvdata->spinlock);
312 	return size;
313 }
314 static DEVICE_ATTR_RW(inout_sel);
315 
316 static ssize_t inen_show(struct device *dev,
317 			 struct device_attribute *attr,
318 			 char *buf)
319 {
320 	unsigned long val;
321 	int index;
322 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
323 
324 	spin_lock(&drvdata->spinlock);
325 	index = drvdata->config.ctiinout_sel;
326 	val = drvdata->config.ctiinen[index];
327 	spin_unlock(&drvdata->spinlock);
328 	return sprintf(buf, "%#lx\n", val);
329 }
330 
331 static ssize_t inen_store(struct device *dev,
332 			  struct device_attribute *attr,
333 			  const char *buf, size_t size)
334 {
335 	unsigned long val;
336 	int index;
337 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
338 	struct cti_config *config = &drvdata->config;
339 
340 	if (kstrtoul(buf, 0, &val))
341 		return -EINVAL;
342 
343 	spin_lock(&drvdata->spinlock);
344 	index = config->ctiinout_sel;
345 	config->ctiinen[index] = val;
346 
347 	/* write through if enabled */
348 	if (cti_active(config))
349 		cti_write_single_reg(drvdata, CTIINEN(index), val);
350 	spin_unlock(&drvdata->spinlock);
351 	return size;
352 }
353 static DEVICE_ATTR_RW(inen);
354 
355 static ssize_t outen_show(struct device *dev,
356 			  struct device_attribute *attr,
357 			  char *buf)
358 {
359 	unsigned long val;
360 	int index;
361 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
362 
363 	spin_lock(&drvdata->spinlock);
364 	index = drvdata->config.ctiinout_sel;
365 	val = drvdata->config.ctiouten[index];
366 	spin_unlock(&drvdata->spinlock);
367 	return sprintf(buf, "%#lx\n", val);
368 }
369 
370 static ssize_t outen_store(struct device *dev,
371 			   struct device_attribute *attr,
372 			   const char *buf, size_t size)
373 {
374 	unsigned long val;
375 	int index;
376 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
377 	struct cti_config *config = &drvdata->config;
378 
379 	if (kstrtoul(buf, 0, &val))
380 		return -EINVAL;
381 
382 	spin_lock(&drvdata->spinlock);
383 	index = config->ctiinout_sel;
384 	config->ctiouten[index] = val;
385 
386 	/* write through if enabled */
387 	if (cti_active(config))
388 		cti_write_single_reg(drvdata, CTIOUTEN(index), val);
389 	spin_unlock(&drvdata->spinlock);
390 	return size;
391 }
392 static DEVICE_ATTR_RW(outen);
393 
394 static ssize_t intack_store(struct device *dev,
395 			    struct device_attribute *attr,
396 			    const char *buf, size_t size)
397 {
398 	unsigned long val;
399 
400 	if (kstrtoul(buf, 0, &val))
401 		return -EINVAL;
402 
403 	cti_write_intack(dev, val);
404 	return size;
405 }
406 static DEVICE_ATTR_WO(intack);
407 
408 cti_config_reg32_rw(gate, ctigate, CTIGATE);
409 cti_config_reg32_rw(asicctl, asicctl, ASICCTL);
410 cti_config_reg32_rw(appset, ctiappset, CTIAPPSET);
411 
412 static ssize_t appclear_store(struct device *dev,
413 			      struct device_attribute *attr,
414 			      const char *buf, size_t size)
415 {
416 	unsigned long val;
417 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
418 	struct cti_config *config = &drvdata->config;
419 
420 	if (kstrtoul(buf, 0, &val))
421 		return -EINVAL;
422 
423 	spin_lock(&drvdata->spinlock);
424 
425 	/* a 1'b1 in appclr clears down the same bit in appset*/
426 	config->ctiappset &= ~val;
427 
428 	/* write through if enabled */
429 	if (cti_active(config))
430 		cti_write_single_reg(drvdata, CTIAPPCLEAR, val);
431 	spin_unlock(&drvdata->spinlock);
432 	return size;
433 }
434 static DEVICE_ATTR_WO(appclear);
435 
436 static ssize_t apppulse_store(struct device *dev,
437 			      struct device_attribute *attr,
438 			      const char *buf, size_t size)
439 {
440 	unsigned long val;
441 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
442 	struct cti_config *config = &drvdata->config;
443 
444 	if (kstrtoul(buf, 0, &val))
445 		return -EINVAL;
446 
447 	spin_lock(&drvdata->spinlock);
448 
449 	/* write through if enabled */
450 	if (cti_active(config))
451 		cti_write_single_reg(drvdata, CTIAPPPULSE, val);
452 	spin_unlock(&drvdata->spinlock);
453 	return size;
454 }
455 static DEVICE_ATTR_WO(apppulse);
456 
457 coresight_cti_reg(triginstatus, CTITRIGINSTATUS);
458 coresight_cti_reg(trigoutstatus, CTITRIGOUTSTATUS);
459 coresight_cti_reg(chinstatus, CTICHINSTATUS);
460 coresight_cti_reg(choutstatus, CTICHOUTSTATUS);
461 
462 /*
463  * Define CONFIG_CORESIGHT_CTI_INTEGRATION_REGS to enable the access to the
464  * integration control registers. Normally only used to investigate connection
465  * data.
466  */
467 #ifdef CONFIG_CORESIGHT_CTI_INTEGRATION_REGS
468 
469 /* macro to access RW registers with power check only (no enable check). */
470 #define coresight_cti_reg_rw(name, offset)				\
471 static ssize_t name##_show(struct device *dev,				\
472 			   struct device_attribute *attr, char *buf)	\
473 {									\
474 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);	\
475 	u32 val = 0;							\
476 	pm_runtime_get_sync(dev->parent);				\
477 	spin_lock(&drvdata->spinlock);					\
478 	if (drvdata->config.hw_powered)					\
479 		val = readl_relaxed(drvdata->base + offset);		\
480 	spin_unlock(&drvdata->spinlock);				\
481 	pm_runtime_put_sync(dev->parent);				\
482 	return sprintf(buf, "0x%x\n", val);				\
483 }									\
484 									\
485 static ssize_t name##_store(struct device *dev,				\
486 			    struct device_attribute *attr,		\
487 			    const char *buf, size_t size)		\
488 {									\
489 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);	\
490 	unsigned long val = 0;						\
491 	if (kstrtoul(buf, 0, &val))					\
492 		return -EINVAL;						\
493 									\
494 	pm_runtime_get_sync(dev->parent);				\
495 	spin_lock(&drvdata->spinlock);					\
496 	if (drvdata->config.hw_powered)					\
497 		cti_write_single_reg(drvdata, offset, val);		\
498 	spin_unlock(&drvdata->spinlock);				\
499 	pm_runtime_put_sync(dev->parent);				\
500 	return size;							\
501 }									\
502 static DEVICE_ATTR_RW(name)
503 
504 /* macro to access WO registers with power check only (no enable check). */
505 #define coresight_cti_reg_wo(name, offset)				\
506 static ssize_t name##_store(struct device *dev,				\
507 			    struct device_attribute *attr,		\
508 			    const char *buf, size_t size)		\
509 {									\
510 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);	\
511 	unsigned long val = 0;						\
512 	if (kstrtoul(buf, 0, &val))					\
513 		return -EINVAL;						\
514 									\
515 	pm_runtime_get_sync(dev->parent);				\
516 	spin_lock(&drvdata->spinlock);					\
517 	if (drvdata->config.hw_powered)					\
518 		cti_write_single_reg(drvdata, offset, val);		\
519 	spin_unlock(&drvdata->spinlock);				\
520 	pm_runtime_put_sync(dev->parent);				\
521 	return size;							\
522 }									\
523 static DEVICE_ATTR_WO(name)
524 
525 coresight_cti_reg_rw(itchout, ITCHOUT);
526 coresight_cti_reg_rw(ittrigout, ITTRIGOUT);
527 coresight_cti_reg_rw(itctrl, CORESIGHT_ITCTRL);
528 coresight_cti_reg_wo(itchinack, ITCHINACK);
529 coresight_cti_reg_wo(ittriginack, ITTRIGINACK);
530 coresight_cti_reg(ittrigin, ITTRIGIN);
531 coresight_cti_reg(itchin, ITCHIN);
532 coresight_cti_reg(itchoutack, ITCHOUTACK);
533 coresight_cti_reg(ittrigoutack, ITTRIGOUTACK);
534 
535 #endif /* CORESIGHT_CTI_INTEGRATION_REGS */
536 
537 static struct attribute *coresight_cti_regs_attrs[] = {
538 	&dev_attr_inout_sel.attr,
539 	&dev_attr_inen.attr,
540 	&dev_attr_outen.attr,
541 	&dev_attr_gate.attr,
542 	&dev_attr_asicctl.attr,
543 	&dev_attr_intack.attr,
544 	&dev_attr_appset.attr,
545 	&dev_attr_appclear.attr,
546 	&dev_attr_apppulse.attr,
547 	&dev_attr_triginstatus.attr,
548 	&dev_attr_trigoutstatus.attr,
549 	&dev_attr_chinstatus.attr,
550 	&dev_attr_choutstatus.attr,
551 #ifdef CONFIG_CORESIGHT_CTI_INTEGRATION_REGS
552 	&dev_attr_itctrl.attr,
553 	&dev_attr_ittrigin.attr,
554 	&dev_attr_itchin.attr,
555 	&dev_attr_ittrigout.attr,
556 	&dev_attr_itchout.attr,
557 	&dev_attr_itchoutack.attr,
558 	&dev_attr_ittrigoutack.attr,
559 	&dev_attr_ittriginack.attr,
560 	&dev_attr_itchinack.attr,
561 #endif
562 	NULL,
563 };
564 
565 /* CTI channel x-trigger programming */
566 static int
567 cti_trig_op_parse(struct device *dev, enum cti_chan_op op,
568 		  enum cti_trig_dir dir, const char *buf, size_t size)
569 {
570 	u32 chan_idx;
571 	u32 trig_idx;
572 	int items, err = -EINVAL;
573 
574 	/* extract chan idx and trigger idx */
575 	items = sscanf(buf, "%d %d", &chan_idx, &trig_idx);
576 	if (items == 2) {
577 		err = cti_channel_trig_op(dev, op, dir, chan_idx, trig_idx);
578 		if (!err)
579 			err = size;
580 	}
581 	return err;
582 }
583 
584 static ssize_t trigin_attach_store(struct device *dev,
585 				   struct device_attribute *attr,
586 				   const char *buf, size_t size)
587 {
588 	return cti_trig_op_parse(dev, CTI_CHAN_ATTACH, CTI_TRIG_IN,
589 				 buf, size);
590 }
591 static DEVICE_ATTR_WO(trigin_attach);
592 
593 static ssize_t trigin_detach_store(struct device *dev,
594 				   struct device_attribute *attr,
595 				   const char *buf, size_t size)
596 {
597 	return cti_trig_op_parse(dev, CTI_CHAN_DETACH, CTI_TRIG_IN,
598 				 buf, size);
599 }
600 static DEVICE_ATTR_WO(trigin_detach);
601 
602 static ssize_t trigout_attach_store(struct device *dev,
603 				    struct device_attribute *attr,
604 				    const char *buf, size_t size)
605 {
606 	return cti_trig_op_parse(dev, CTI_CHAN_ATTACH, CTI_TRIG_OUT,
607 				 buf, size);
608 }
609 static DEVICE_ATTR_WO(trigout_attach);
610 
611 static ssize_t trigout_detach_store(struct device *dev,
612 				    struct device_attribute *attr,
613 				    const char *buf, size_t size)
614 {
615 	return cti_trig_op_parse(dev, CTI_CHAN_DETACH, CTI_TRIG_OUT,
616 				 buf, size);
617 }
618 static DEVICE_ATTR_WO(trigout_detach);
619 
620 
621 static ssize_t chan_gate_enable_store(struct device *dev,
622 				      struct device_attribute *attr,
623 				      const char *buf, size_t size)
624 {
625 	int err = 0, channel = 0;
626 
627 	if (kstrtoint(buf, 0, &channel))
628 		return -EINVAL;
629 
630 	err = cti_channel_gate_op(dev, CTI_GATE_CHAN_ENABLE, channel);
631 	return err ? err : size;
632 }
633 
634 static ssize_t chan_gate_enable_show(struct device *dev,
635 				     struct device_attribute *attr,
636 				     char *buf)
637 {
638 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
639 	struct cti_config *cfg = &drvdata->config;
640 	unsigned long ctigate_bitmask = cfg->ctigate;
641 	int size = 0;
642 
643 	if (cfg->ctigate == 0)
644 		size = sprintf(buf, "\n");
645 	else
646 		size = bitmap_print_to_pagebuf(true, buf, &ctigate_bitmask,
647 					       cfg->nr_ctm_channels);
648 	return size;
649 }
650 static DEVICE_ATTR_RW(chan_gate_enable);
651 
652 static ssize_t chan_gate_disable_store(struct device *dev,
653 				       struct device_attribute *attr,
654 				       const char *buf, size_t size)
655 {
656 	int err = 0, channel = 0;
657 
658 	if (kstrtoint(buf, 0, &channel))
659 		return -EINVAL;
660 
661 	err = cti_channel_gate_op(dev, CTI_GATE_CHAN_DISABLE, channel);
662 	return err ? err : size;
663 }
664 static DEVICE_ATTR_WO(chan_gate_disable);
665 
666 static int
667 chan_op_parse(struct device *dev, enum cti_chan_set_op op, const char *buf)
668 {
669 	int err = 0, channel = 0;
670 
671 	if (kstrtoint(buf, 0, &channel))
672 		return -EINVAL;
673 
674 	err = cti_channel_setop(dev, op, channel);
675 	return err;
676 
677 }
678 
679 static ssize_t chan_set_store(struct device *dev,
680 			      struct device_attribute *attr,
681 			      const char *buf, size_t size)
682 {
683 	int err = chan_op_parse(dev, CTI_CHAN_SET, buf);
684 
685 	return err ? err : size;
686 }
687 static DEVICE_ATTR_WO(chan_set);
688 
689 static ssize_t chan_clear_store(struct device *dev,
690 				struct device_attribute *attr,
691 				const char *buf, size_t size)
692 {
693 	int err = chan_op_parse(dev, CTI_CHAN_CLR, buf);
694 
695 	return err ? err : size;
696 }
697 static DEVICE_ATTR_WO(chan_clear);
698 
699 static ssize_t chan_pulse_store(struct device *dev,
700 				struct device_attribute *attr,
701 				const char *buf, size_t size)
702 {
703 	int err = chan_op_parse(dev, CTI_CHAN_PULSE, buf);
704 
705 	return err ? err : size;
706 }
707 static DEVICE_ATTR_WO(chan_pulse);
708 
709 static ssize_t trig_filter_enable_show(struct device *dev,
710 				       struct device_attribute *attr,
711 				       char *buf)
712 {
713 	u32 val;
714 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
715 
716 	spin_lock(&drvdata->spinlock);
717 	val = drvdata->config.trig_filter_enable;
718 	spin_unlock(&drvdata->spinlock);
719 	return sprintf(buf, "%d\n", val);
720 }
721 
722 static ssize_t trig_filter_enable_store(struct device *dev,
723 					struct device_attribute *attr,
724 					const char *buf, size_t size)
725 {
726 	unsigned long val;
727 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
728 
729 	if (kstrtoul(buf, 0, &val))
730 		return -EINVAL;
731 
732 	spin_lock(&drvdata->spinlock);
733 	drvdata->config.trig_filter_enable = !!val;
734 	spin_unlock(&drvdata->spinlock);
735 	return size;
736 }
737 static DEVICE_ATTR_RW(trig_filter_enable);
738 
739 static ssize_t trigout_filtered_show(struct device *dev,
740 				     struct device_attribute *attr,
741 				     char *buf)
742 {
743 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
744 	struct cti_config *cfg = &drvdata->config;
745 	int size = 0, nr_trig_max = cfg->nr_trig_max;
746 	unsigned long mask = cfg->trig_out_filter;
747 
748 	if (mask)
749 		size = bitmap_print_to_pagebuf(true, buf, &mask, nr_trig_max);
750 	return size;
751 }
752 static DEVICE_ATTR_RO(trigout_filtered);
753 
754 /* clear all xtrigger / channel programming */
755 static ssize_t chan_xtrigs_reset_store(struct device *dev,
756 				       struct device_attribute *attr,
757 				       const char *buf, size_t size)
758 {
759 	int i;
760 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
761 	struct cti_config *config = &drvdata->config;
762 
763 	spin_lock(&drvdata->spinlock);
764 
765 	/* clear the CTI trigger / channel programming registers */
766 	for (i = 0; i < config->nr_trig_max; i++) {
767 		config->ctiinen[i] = 0;
768 		config->ctiouten[i] = 0;
769 	}
770 
771 	/* clear the other regs */
772 	config->ctigate = GENMASK(config->nr_ctm_channels - 1, 0);
773 	config->asicctl = 0;
774 	config->ctiappset = 0;
775 	config->ctiinout_sel = 0;
776 	config->xtrig_rchan_sel = 0;
777 
778 	/* if enabled then write through */
779 	if (cti_active(config))
780 		cti_write_all_hw_regs(drvdata);
781 
782 	spin_unlock(&drvdata->spinlock);
783 	return size;
784 }
785 static DEVICE_ATTR_WO(chan_xtrigs_reset);
786 
787 /*
788  * Write to select a channel to view, read to display the
789  * cross triggers for the selected channel.
790  */
791 static ssize_t chan_xtrigs_sel_store(struct device *dev,
792 				     struct device_attribute *attr,
793 				     const char *buf, size_t size)
794 {
795 	unsigned long val;
796 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
797 
798 	if (kstrtoul(buf, 0, &val))
799 		return -EINVAL;
800 	if (val > (drvdata->config.nr_ctm_channels - 1))
801 		return -EINVAL;
802 
803 	spin_lock(&drvdata->spinlock);
804 	drvdata->config.xtrig_rchan_sel = val;
805 	spin_unlock(&drvdata->spinlock);
806 	return size;
807 }
808 
809 static ssize_t chan_xtrigs_sel_show(struct device *dev,
810 				    struct device_attribute *attr,
811 				    char *buf)
812 {
813 	unsigned long val;
814 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
815 
816 	spin_lock(&drvdata->spinlock);
817 	val = drvdata->config.xtrig_rchan_sel;
818 	spin_unlock(&drvdata->spinlock);
819 
820 	return sprintf(buf, "%ld\n", val);
821 }
822 static DEVICE_ATTR_RW(chan_xtrigs_sel);
823 
824 static ssize_t chan_xtrigs_in_show(struct device *dev,
825 				   struct device_attribute *attr,
826 				   char *buf)
827 {
828 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
829 	struct cti_config *cfg = &drvdata->config;
830 	int used = 0, reg_idx;
831 	int nr_trig_max = drvdata->config.nr_trig_max;
832 	u32 chan_mask = BIT(cfg->xtrig_rchan_sel);
833 
834 	for (reg_idx = 0; reg_idx < nr_trig_max; reg_idx++) {
835 		if (chan_mask & cfg->ctiinen[reg_idx])
836 			used += sprintf(buf + used, "%d ", reg_idx);
837 	}
838 
839 	used += sprintf(buf + used, "\n");
840 	return used;
841 }
842 static DEVICE_ATTR_RO(chan_xtrigs_in);
843 
844 static ssize_t chan_xtrigs_out_show(struct device *dev,
845 				    struct device_attribute *attr,
846 				    char *buf)
847 {
848 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
849 	struct cti_config *cfg = &drvdata->config;
850 	int used = 0, reg_idx;
851 	int nr_trig_max = drvdata->config.nr_trig_max;
852 	u32 chan_mask = BIT(cfg->xtrig_rchan_sel);
853 
854 	for (reg_idx = 0; reg_idx < nr_trig_max; reg_idx++) {
855 		if (chan_mask & cfg->ctiouten[reg_idx])
856 			used += sprintf(buf + used, "%d ", reg_idx);
857 	}
858 
859 	used += sprintf(buf + used, "\n");
860 	return used;
861 }
862 static DEVICE_ATTR_RO(chan_xtrigs_out);
863 
864 static ssize_t print_chan_list(struct device *dev,
865 			       char *buf, bool inuse)
866 {
867 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
868 	struct cti_config *config = &drvdata->config;
869 	int size, i;
870 	unsigned long inuse_bits = 0, chan_mask;
871 
872 	/* scan regs to get bitmap of channels in use. */
873 	spin_lock(&drvdata->spinlock);
874 	for (i = 0; i < config->nr_trig_max; i++) {
875 		inuse_bits |= config->ctiinen[i];
876 		inuse_bits |= config->ctiouten[i];
877 	}
878 	spin_unlock(&drvdata->spinlock);
879 
880 	/* inverse bits if printing free channels */
881 	if (!inuse)
882 		inuse_bits = ~inuse_bits;
883 
884 	/* list of channels, or 'none' */
885 	chan_mask = GENMASK(config->nr_ctm_channels - 1, 0);
886 	if (inuse_bits & chan_mask)
887 		size = bitmap_print_to_pagebuf(true, buf, &inuse_bits,
888 					       config->nr_ctm_channels);
889 	else
890 		size = sprintf(buf, "\n");
891 	return size;
892 }
893 
894 static ssize_t chan_inuse_show(struct device *dev,
895 			       struct device_attribute *attr,
896 			       char *buf)
897 {
898 	return print_chan_list(dev, buf, true);
899 }
900 static DEVICE_ATTR_RO(chan_inuse);
901 
902 static ssize_t chan_free_show(struct device *dev,
903 			      struct device_attribute *attr,
904 			      char *buf)
905 {
906 	return print_chan_list(dev, buf, false);
907 }
908 static DEVICE_ATTR_RO(chan_free);
909 
910 static struct attribute *coresight_cti_channel_attrs[] = {
911 	&dev_attr_trigin_attach.attr,
912 	&dev_attr_trigin_detach.attr,
913 	&dev_attr_trigout_attach.attr,
914 	&dev_attr_trigout_detach.attr,
915 	&dev_attr_trig_filter_enable.attr,
916 	&dev_attr_trigout_filtered.attr,
917 	&dev_attr_chan_gate_enable.attr,
918 	&dev_attr_chan_gate_disable.attr,
919 	&dev_attr_chan_set.attr,
920 	&dev_attr_chan_clear.attr,
921 	&dev_attr_chan_pulse.attr,
922 	&dev_attr_chan_inuse.attr,
923 	&dev_attr_chan_free.attr,
924 	&dev_attr_chan_xtrigs_sel.attr,
925 	&dev_attr_chan_xtrigs_in.attr,
926 	&dev_attr_chan_xtrigs_out.attr,
927 	&dev_attr_chan_xtrigs_reset.attr,
928 	NULL,
929 };
930 
931 /* Create the connections trigger groups and attrs dynamically */
932 /*
933  * Each connection has dynamic group triggers<N> + name, trigin/out sigs/types
934  * attributes, + each device has static nr_trigger_cons giving the number
935  * of groups. e.g. in sysfs:-
936  * /cti_<name>/triggers0
937  * /cti_<name>/triggers1
938  * /cti_<name>/nr_trigger_cons
939  * where nr_trigger_cons = 2
940  */
941 static ssize_t con_name_show(struct device *dev,
942 			     struct device_attribute *attr,
943 			     char *buf)
944 {
945 	struct dev_ext_attribute *ext_attr =
946 		container_of(attr, struct dev_ext_attribute, attr);
947 	struct cti_trig_con *con = (struct cti_trig_con *)ext_attr->var;
948 
949 	return sprintf(buf, "%s\n", con->con_dev_name);
950 }
951 
952 static ssize_t trigin_sig_show(struct device *dev,
953 			       struct device_attribute *attr,
954 			       char *buf)
955 {
956 	struct dev_ext_attribute *ext_attr =
957 		container_of(attr, struct dev_ext_attribute, attr);
958 	struct cti_trig_con *con = (struct cti_trig_con *)ext_attr->var;
959 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
960 	struct cti_config *cfg = &drvdata->config;
961 	unsigned long mask = con->con_in->used_mask;
962 
963 	return bitmap_print_to_pagebuf(true, buf, &mask, cfg->nr_trig_max);
964 }
965 
966 static ssize_t trigout_sig_show(struct device *dev,
967 				struct device_attribute *attr,
968 				char *buf)
969 {
970 	struct dev_ext_attribute *ext_attr =
971 		container_of(attr, struct dev_ext_attribute, attr);
972 	struct cti_trig_con *con = (struct cti_trig_con *)ext_attr->var;
973 	struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
974 	struct cti_config *cfg = &drvdata->config;
975 	unsigned long mask = con->con_out->used_mask;
976 
977 	return bitmap_print_to_pagebuf(true, buf, &mask, cfg->nr_trig_max);
978 }
979 
980 /* convert a sig type id to a name */
981 static const char *
982 cti_sig_type_name(struct cti_trig_con *con, int used_count, bool in)
983 {
984 	int idx = 0;
985 	struct cti_trig_grp *grp = in ? con->con_in : con->con_out;
986 
987 	if (used_count < grp->nr_sigs)
988 		idx = grp->sig_types[used_count];
989 	return sig_type_names[idx];
990 }
991 
992 static ssize_t trigin_type_show(struct device *dev,
993 				struct device_attribute *attr,
994 				char *buf)
995 {
996 	struct dev_ext_attribute *ext_attr =
997 		container_of(attr, struct dev_ext_attribute, attr);
998 	struct cti_trig_con *con = (struct cti_trig_con *)ext_attr->var;
999 	int sig_idx, used = 0;
1000 	const char *name;
1001 
1002 	for (sig_idx = 0; sig_idx < con->con_in->nr_sigs; sig_idx++) {
1003 		name = cti_sig_type_name(con, sig_idx, true);
1004 		used += sprintf(buf + used, "%s ", name);
1005 	}
1006 	used += sprintf(buf + used, "\n");
1007 	return used;
1008 }
1009 
1010 static ssize_t trigout_type_show(struct device *dev,
1011 				 struct device_attribute *attr,
1012 				 char *buf)
1013 {
1014 	struct dev_ext_attribute *ext_attr =
1015 		container_of(attr, struct dev_ext_attribute, attr);
1016 	struct cti_trig_con *con = (struct cti_trig_con *)ext_attr->var;
1017 	int sig_idx, used = 0;
1018 	const char *name;
1019 
1020 	for (sig_idx = 0; sig_idx < con->con_out->nr_sigs; sig_idx++) {
1021 		name = cti_sig_type_name(con, sig_idx, false);
1022 		used += sprintf(buf + used, "%s ", name);
1023 	}
1024 	used += sprintf(buf + used, "\n");
1025 	return used;
1026 }
1027 
1028 /*
1029  * Array of show function names declared above to allow selection
1030  * for the connection attributes
1031  */
1032 static p_show_fn show_fns[CTI_CON_ATTR_MAX] = {
1033 	con_name_show,
1034 	trigin_sig_show,
1035 	trigout_sig_show,
1036 	trigin_type_show,
1037 	trigout_type_show,
1038 };
1039 
1040 static int cti_create_con_sysfs_attr(struct device *dev,
1041 				     struct cti_trig_con *con,
1042 				     enum cti_conn_attr_type attr_type,
1043 				     int attr_idx)
1044 {
1045 	struct dev_ext_attribute *eattr;
1046 	char *name;
1047 
1048 	eattr = devm_kzalloc(dev, sizeof(struct dev_ext_attribute),
1049 				    GFP_KERNEL);
1050 	if (eattr) {
1051 		name = devm_kstrdup(dev, con_attr_names[attr_type],
1052 				    GFP_KERNEL);
1053 		if (name) {
1054 			/* fill out the underlying attribute struct */
1055 			eattr->attr.attr.name = name;
1056 			eattr->attr.attr.mode = 0444;
1057 
1058 			/* now the device_attribute struct */
1059 			eattr->attr.show = show_fns[attr_type];
1060 		} else {
1061 			return -ENOMEM;
1062 		}
1063 	} else {
1064 		return -ENOMEM;
1065 	}
1066 	eattr->var = con;
1067 	con->con_attrs[attr_idx] = &eattr->attr.attr;
1068 	return 0;
1069 }
1070 
1071 static struct attribute_group *
1072 cti_create_con_sysfs_group(struct device *dev, struct cti_device *ctidev,
1073 			   int con_idx, struct cti_trig_con *tc)
1074 {
1075 	struct attribute_group *group = NULL;
1076 	int grp_idx;
1077 
1078 	group = devm_kzalloc(dev, sizeof(struct attribute_group), GFP_KERNEL);
1079 	if (!group)
1080 		return NULL;
1081 
1082 	group->name = devm_kasprintf(dev, GFP_KERNEL, "triggers%d", con_idx);
1083 	if (!group->name)
1084 		return NULL;
1085 
1086 	grp_idx = con_idx + CORESIGHT_CTI_STATIC_GROUPS_MAX - 1;
1087 	ctidev->con_groups[grp_idx] = group;
1088 	tc->attr_group = group;
1089 	return group;
1090 }
1091 
1092 /* create a triggers connection group and the attributes for that group */
1093 static int cti_create_con_attr_set(struct device *dev, int con_idx,
1094 				   struct cti_device *ctidev,
1095 				   struct cti_trig_con *tc)
1096 {
1097 	struct attribute_group *attr_group = NULL;
1098 	int attr_idx = 0;
1099 	int err = -ENOMEM;
1100 
1101 	attr_group = cti_create_con_sysfs_group(dev, ctidev, con_idx, tc);
1102 	if (!attr_group)
1103 		return -ENOMEM;
1104 
1105 	/* allocate NULL terminated array of attributes */
1106 	tc->con_attrs = devm_kcalloc(dev, CTI_CON_ATTR_MAX + 1,
1107 				     sizeof(struct attribute *), GFP_KERNEL);
1108 	if (!tc->con_attrs)
1109 		return -ENOMEM;
1110 
1111 	err = cti_create_con_sysfs_attr(dev, tc, CTI_CON_ATTR_NAME,
1112 					attr_idx++);
1113 	if (err)
1114 		return err;
1115 
1116 	if (tc->con_in->nr_sigs > 0) {
1117 		err = cti_create_con_sysfs_attr(dev, tc,
1118 						CTI_CON_ATTR_TRIGIN_SIG,
1119 						attr_idx++);
1120 		if (err)
1121 			return err;
1122 
1123 		err = cti_create_con_sysfs_attr(dev, tc,
1124 						CTI_CON_ATTR_TRIGIN_TYPES,
1125 						attr_idx++);
1126 		if (err)
1127 			return err;
1128 	}
1129 
1130 	if (tc->con_out->nr_sigs > 0) {
1131 		err = cti_create_con_sysfs_attr(dev, tc,
1132 						CTI_CON_ATTR_TRIGOUT_SIG,
1133 						attr_idx++);
1134 		if (err)
1135 			return err;
1136 
1137 		err = cti_create_con_sysfs_attr(dev, tc,
1138 						CTI_CON_ATTR_TRIGOUT_TYPES,
1139 						attr_idx++);
1140 		if (err)
1141 			return err;
1142 	}
1143 	attr_group->attrs = tc->con_attrs;
1144 	return 0;
1145 }
1146 
1147 /* create the array of group pointers for the CTI sysfs groups */
1148 static int cti_create_cons_groups(struct device *dev, struct cti_device *ctidev)
1149 {
1150 	int nr_groups;
1151 
1152 	/* nr groups = dynamic + static + NULL terminator */
1153 	nr_groups = ctidev->nr_trig_con + CORESIGHT_CTI_STATIC_GROUPS_MAX;
1154 	ctidev->con_groups = devm_kcalloc(dev, nr_groups,
1155 					  sizeof(struct attribute_group *),
1156 					  GFP_KERNEL);
1157 	if (!ctidev->con_groups)
1158 		return -ENOMEM;
1159 	return 0;
1160 }
1161 
1162 int cti_create_cons_sysfs(struct device *dev, struct cti_drvdata *drvdata)
1163 {
1164 	struct cti_device *ctidev = &drvdata->ctidev;
1165 	int err, con_idx = 0, i;
1166 	struct cti_trig_con *tc;
1167 
1168 	err = cti_create_cons_groups(dev, ctidev);
1169 	if (err)
1170 		return err;
1171 
1172 	/* populate first locations with the static set of groups */
1173 	for (i = 0; i < (CORESIGHT_CTI_STATIC_GROUPS_MAX - 1); i++)
1174 		ctidev->con_groups[i] = coresight_cti_groups[i];
1175 
1176 	/* add dynamic set for each connection */
1177 	list_for_each_entry(tc, &ctidev->trig_cons, node) {
1178 		err = cti_create_con_attr_set(dev, con_idx++, ctidev, tc);
1179 		if (err)
1180 			break;
1181 	}
1182 	return err;
1183 }
1184 
1185 /* attribute and group sysfs tables. */
1186 static const struct attribute_group coresight_cti_group = {
1187 	.attrs = coresight_cti_attrs,
1188 };
1189 
1190 static const struct attribute_group coresight_cti_mgmt_group = {
1191 	.attrs = coresight_cti_mgmt_attrs,
1192 	.name = "mgmt",
1193 };
1194 
1195 static const struct attribute_group coresight_cti_regs_group = {
1196 	.attrs = coresight_cti_regs_attrs,
1197 	.name = "regs",
1198 };
1199 
1200 static const struct attribute_group coresight_cti_channels_group = {
1201 	.attrs = coresight_cti_channel_attrs,
1202 	.name = "channels",
1203 };
1204 
1205 const struct attribute_group *
1206 coresight_cti_groups[CORESIGHT_CTI_STATIC_GROUPS_MAX] = {
1207 	&coresight_cti_group,
1208 	&coresight_cti_mgmt_group,
1209 	&coresight_cti_regs_group,
1210 	&coresight_cti_channels_group,
1211 	NULL,
1212 };
1213