aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/hwtracing
diff options
context:
space:
mode:
authorMathieu Poirier <mathieu.poirier@linaro.org>2016-02-17 19:51:49 -0500
committerGreg Kroah-Hartman <gregkh@linuxfoundation.org>2016-02-20 17:11:01 -0500
commitc04148e708c0d8d7eabc447946b712a66b468b47 (patch)
tree7175b4649f13de6acb394b11727974e6eaf72fa0 /drivers/hwtracing
parentc1f8e57c9e6692f6e8c6c1f9eab7a46264ac4245 (diff)
coresight: etm3x: moving sysFS entries to dedicated file
SysFS entries are big enough to justify their own file. As such moving all sysFS related declarations to a dedicated location. Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Diffstat (limited to 'drivers/hwtracing')
-rw-r--r--drivers/hwtracing/coresight/Makefile3
-rw-r--r--drivers/hwtracing/coresight/coresight-etm.h4
-rw-r--r--drivers/hwtracing/coresight/coresight-etm3x-sysfs.c1218
-rw-r--r--drivers/hwtracing/coresight/coresight-etm3x.c1234
4 files changed, 1241 insertions, 1218 deletions
diff --git a/drivers/hwtracing/coresight/Makefile b/drivers/hwtracing/coresight/Makefile
index 99f8e5f6256e..233d66cf22d3 100644
--- a/drivers/hwtracing/coresight/Makefile
+++ b/drivers/hwtracing/coresight/Makefile
@@ -8,6 +8,7 @@ obj-$(CONFIG_CORESIGHT_SINK_TPIU) += coresight-tpiu.o
8obj-$(CONFIG_CORESIGHT_SINK_ETBV10) += coresight-etb10.o 8obj-$(CONFIG_CORESIGHT_SINK_ETBV10) += coresight-etb10.o
9obj-$(CONFIG_CORESIGHT_LINKS_AND_SINKS) += coresight-funnel.o \ 9obj-$(CONFIG_CORESIGHT_LINKS_AND_SINKS) += coresight-funnel.o \
10 coresight-replicator.o 10 coresight-replicator.o
11obj-$(CONFIG_CORESIGHT_SOURCE_ETM3X) += coresight-etm3x.o coresight-etm-cp14.o 11obj-$(CONFIG_CORESIGHT_SOURCE_ETM3X) += coresight-etm3x.o coresight-etm-cp14.o \
12 coresight-etm3x-sysfs.o
12obj-$(CONFIG_CORESIGHT_SOURCE_ETM4X) += coresight-etm4x.o 13obj-$(CONFIG_CORESIGHT_SOURCE_ETM4X) += coresight-etm4x.o
13obj-$(CONFIG_CORESIGHT_QCOM_REPLICATOR) += coresight-replicator-qcom.o 14obj-$(CONFIG_CORESIGHT_QCOM_REPLICATOR) += coresight-replicator-qcom.o
diff --git a/drivers/hwtracing/coresight/coresight-etm.h b/drivers/hwtracing/coresight/coresight-etm.h
index 34f7db881fa7..9a30aa392ed9 100644
--- a/drivers/hwtracing/coresight/coresight-etm.h
+++ b/drivers/hwtracing/coresight/coresight-etm.h
@@ -280,4 +280,8 @@ static inline unsigned int etm_readl(struct etm_drvdata *drvdata, u32 off)
280 280
281 return val; 281 return val;
282} 282}
283
284extern const struct attribute_group *coresight_etm_groups[];
285int etm_get_trace_id(struct etm_drvdata *drvdata);
286void etm_set_default(struct etm_drvdata *drvdata);
283#endif 287#endif
diff --git a/drivers/hwtracing/coresight/coresight-etm3x-sysfs.c b/drivers/hwtracing/coresight/coresight-etm3x-sysfs.c
new file mode 100644
index 000000000000..f409f5a88e95
--- /dev/null
+++ b/drivers/hwtracing/coresight/coresight-etm3x-sysfs.c
@@ -0,0 +1,1218 @@
1/*
2 * Copyright(C) 2015 Linaro Limited. All rights reserved.
3 * Author: Mathieu Poirier <mathieu.poirier@linaro.org>
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program. If not, see <http://www.gnu.org/licenses/>.
16 */
17
18#include <linux/pm_runtime.h>
19#include <linux/sysfs.h>
20#include "coresight-etm.h"
21
22static ssize_t nr_addr_cmp_show(struct device *dev,
23 struct device_attribute *attr, char *buf)
24{
25 unsigned long val;
26 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
27
28 val = drvdata->nr_addr_cmp;
29 return sprintf(buf, "%#lx\n", val);
30}
31static DEVICE_ATTR_RO(nr_addr_cmp);
32
33static ssize_t nr_cntr_show(struct device *dev,
34 struct device_attribute *attr, char *buf)
35{ unsigned long val;
36 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
37
38 val = drvdata->nr_cntr;
39 return sprintf(buf, "%#lx\n", val);
40}
41static DEVICE_ATTR_RO(nr_cntr);
42
43static ssize_t nr_ctxid_cmp_show(struct device *dev,
44 struct device_attribute *attr, char *buf)
45{
46 unsigned long val;
47 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
48
49 val = drvdata->nr_ctxid_cmp;
50 return sprintf(buf, "%#lx\n", val);
51}
52static DEVICE_ATTR_RO(nr_ctxid_cmp);
53
54static ssize_t etmsr_show(struct device *dev,
55 struct device_attribute *attr, char *buf)
56{
57 unsigned long flags, val;
58 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
59
60 pm_runtime_get_sync(drvdata->dev);
61 spin_lock_irqsave(&drvdata->spinlock, flags);
62 CS_UNLOCK(drvdata->base);
63
64 val = etm_readl(drvdata, ETMSR);
65
66 CS_LOCK(drvdata->base);
67 spin_unlock_irqrestore(&drvdata->spinlock, flags);
68 pm_runtime_put(drvdata->dev);
69
70 return sprintf(buf, "%#lx\n", val);
71}
72static DEVICE_ATTR_RO(etmsr);
73
74static ssize_t reset_store(struct device *dev,
75 struct device_attribute *attr,
76 const char *buf, size_t size)
77{
78 int i, ret;
79 unsigned long val;
80 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
81
82 ret = kstrtoul(buf, 16, &val);
83 if (ret)
84 return ret;
85
86 if (val) {
87 spin_lock(&drvdata->spinlock);
88 drvdata->mode = ETM_MODE_EXCLUDE;
89 drvdata->ctrl = 0x0;
90 drvdata->trigger_event = ETM_DEFAULT_EVENT_VAL;
91 drvdata->startstop_ctrl = 0x0;
92 drvdata->addr_idx = 0x0;
93 for (i = 0; i < drvdata->nr_addr_cmp; i++) {
94 drvdata->addr_val[i] = 0x0;
95 drvdata->addr_acctype[i] = 0x0;
96 drvdata->addr_type[i] = ETM_ADDR_TYPE_NONE;
97 }
98 drvdata->cntr_idx = 0x0;
99
100 etm_set_default(drvdata);
101 spin_unlock(&drvdata->spinlock);
102 }
103
104 return size;
105}
106static DEVICE_ATTR_WO(reset);
107
108static ssize_t mode_show(struct device *dev,
109 struct device_attribute *attr, char *buf)
110{
111 unsigned long val;
112 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
113
114 val = drvdata->mode;
115 return sprintf(buf, "%#lx\n", val);
116}
117
118static ssize_t mode_store(struct device *dev,
119 struct device_attribute *attr,
120 const char *buf, size_t size)
121{
122 int ret;
123 unsigned long val;
124 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
125
126 ret = kstrtoul(buf, 16, &val);
127 if (ret)
128 return ret;
129
130 spin_lock(&drvdata->spinlock);
131 drvdata->mode = val & ETM_MODE_ALL;
132
133 if (drvdata->mode & ETM_MODE_EXCLUDE)
134 drvdata->enable_ctrl1 |= ETMTECR1_INC_EXC;
135 else
136 drvdata->enable_ctrl1 &= ~ETMTECR1_INC_EXC;
137
138 if (drvdata->mode & ETM_MODE_CYCACC)
139 drvdata->ctrl |= ETMCR_CYC_ACC;
140 else
141 drvdata->ctrl &= ~ETMCR_CYC_ACC;
142
143 if (drvdata->mode & ETM_MODE_STALL) {
144 if (!(drvdata->etmccr & ETMCCR_FIFOFULL)) {
145 dev_warn(drvdata->dev, "stall mode not supported\n");
146 ret = -EINVAL;
147 goto err_unlock;
148 }
149 drvdata->ctrl |= ETMCR_STALL_MODE;
150 } else
151 drvdata->ctrl &= ~ETMCR_STALL_MODE;
152
153 if (drvdata->mode & ETM_MODE_TIMESTAMP) {
154 if (!(drvdata->etmccer & ETMCCER_TIMESTAMP)) {
155 dev_warn(drvdata->dev, "timestamp not supported\n");
156 ret = -EINVAL;
157 goto err_unlock;
158 }
159 drvdata->ctrl |= ETMCR_TIMESTAMP_EN;
160 } else
161 drvdata->ctrl &= ~ETMCR_TIMESTAMP_EN;
162
163 if (drvdata->mode & ETM_MODE_CTXID)
164 drvdata->ctrl |= ETMCR_CTXID_SIZE;
165 else
166 drvdata->ctrl &= ~ETMCR_CTXID_SIZE;
167 spin_unlock(&drvdata->spinlock);
168
169 return size;
170
171err_unlock:
172 spin_unlock(&drvdata->spinlock);
173 return ret;
174}
175static DEVICE_ATTR_RW(mode);
176
177static ssize_t trigger_event_show(struct device *dev,
178 struct device_attribute *attr, char *buf)
179{
180 unsigned long val;
181 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
182
183 val = drvdata->trigger_event;
184 return sprintf(buf, "%#lx\n", val);
185}
186
187static ssize_t trigger_event_store(struct device *dev,
188 struct device_attribute *attr,
189 const char *buf, size_t size)
190{
191 int ret;
192 unsigned long val;
193 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
194
195 ret = kstrtoul(buf, 16, &val);
196 if (ret)
197 return ret;
198
199 drvdata->trigger_event = val & ETM_EVENT_MASK;
200
201 return size;
202}
203static DEVICE_ATTR_RW(trigger_event);
204
205static ssize_t enable_event_show(struct device *dev,
206 struct device_attribute *attr, char *buf)
207{
208 unsigned long val;
209 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
210
211 val = drvdata->enable_event;
212 return sprintf(buf, "%#lx\n", val);
213}
214
215static ssize_t enable_event_store(struct device *dev,
216 struct device_attribute *attr,
217 const char *buf, size_t size)
218{
219 int ret;
220 unsigned long val;
221 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
222
223 ret = kstrtoul(buf, 16, &val);
224 if (ret)
225 return ret;
226
227 drvdata->enable_event = val & ETM_EVENT_MASK;
228
229 return size;
230}
231static DEVICE_ATTR_RW(enable_event);
232
233static ssize_t fifofull_level_show(struct device *dev,
234 struct device_attribute *attr, char *buf)
235{
236 unsigned long val;
237 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
238
239 val = drvdata->fifofull_level;
240 return sprintf(buf, "%#lx\n", val);
241}
242
243static ssize_t fifofull_level_store(struct device *dev,
244 struct device_attribute *attr,
245 const char *buf, size_t size)
246{
247 int ret;
248 unsigned long val;
249 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
250
251 ret = kstrtoul(buf, 16, &val);
252 if (ret)
253 return ret;
254
255 drvdata->fifofull_level = val;
256
257 return size;
258}
259static DEVICE_ATTR_RW(fifofull_level);
260
261static ssize_t addr_idx_show(struct device *dev,
262 struct device_attribute *attr, char *buf)
263{
264 unsigned long val;
265 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
266
267 val = drvdata->addr_idx;
268 return sprintf(buf, "%#lx\n", val);
269}
270
271static ssize_t addr_idx_store(struct device *dev,
272 struct device_attribute *attr,
273 const char *buf, size_t size)
274{
275 int ret;
276 unsigned long val;
277 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
278
279 ret = kstrtoul(buf, 16, &val);
280 if (ret)
281 return ret;
282
283 if (val >= drvdata->nr_addr_cmp)
284 return -EINVAL;
285
286 /*
287 * Use spinlock to ensure index doesn't change while it gets
288 * dereferenced multiple times within a spinlock block elsewhere.
289 */
290 spin_lock(&drvdata->spinlock);
291 drvdata->addr_idx = val;
292 spin_unlock(&drvdata->spinlock);
293
294 return size;
295}
296static DEVICE_ATTR_RW(addr_idx);
297
298static ssize_t addr_single_show(struct device *dev,
299 struct device_attribute *attr, char *buf)
300{
301 u8 idx;
302 unsigned long val;
303 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
304
305 spin_lock(&drvdata->spinlock);
306 idx = drvdata->addr_idx;
307 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
308 drvdata->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
309 spin_unlock(&drvdata->spinlock);
310 return -EINVAL;
311 }
312
313 val = drvdata->addr_val[idx];
314 spin_unlock(&drvdata->spinlock);
315
316 return sprintf(buf, "%#lx\n", val);
317}
318
319static ssize_t addr_single_store(struct device *dev,
320 struct device_attribute *attr,
321 const char *buf, size_t size)
322{
323 u8 idx;
324 int ret;
325 unsigned long val;
326 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
327
328 ret = kstrtoul(buf, 16, &val);
329 if (ret)
330 return ret;
331
332 spin_lock(&drvdata->spinlock);
333 idx = drvdata->addr_idx;
334 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
335 drvdata->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
336 spin_unlock(&drvdata->spinlock);
337 return -EINVAL;
338 }
339
340 drvdata->addr_val[idx] = val;
341 drvdata->addr_type[idx] = ETM_ADDR_TYPE_SINGLE;
342 spin_unlock(&drvdata->spinlock);
343
344 return size;
345}
346static DEVICE_ATTR_RW(addr_single);
347
348static ssize_t addr_range_show(struct device *dev,
349 struct device_attribute *attr, char *buf)
350{
351 u8 idx;
352 unsigned long val1, val2;
353 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
354
355 spin_lock(&drvdata->spinlock);
356 idx = drvdata->addr_idx;
357 if (idx % 2 != 0) {
358 spin_unlock(&drvdata->spinlock);
359 return -EPERM;
360 }
361 if (!((drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE &&
362 drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
363 (drvdata->addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
364 drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
365 spin_unlock(&drvdata->spinlock);
366 return -EPERM;
367 }
368
369 val1 = drvdata->addr_val[idx];
370 val2 = drvdata->addr_val[idx + 1];
371 spin_unlock(&drvdata->spinlock);
372
373 return sprintf(buf, "%#lx %#lx\n", val1, val2);
374}
375
376static ssize_t addr_range_store(struct device *dev,
377 struct device_attribute *attr,
378 const char *buf, size_t size)
379{
380 u8 idx;
381 unsigned long val1, val2;
382 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
383
384 if (sscanf(buf, "%lx %lx", &val1, &val2) != 2)
385 return -EINVAL;
386 /* Lower address comparator cannot have a higher address value */
387 if (val1 > val2)
388 return -EINVAL;
389
390 spin_lock(&drvdata->spinlock);
391 idx = drvdata->addr_idx;
392 if (idx % 2 != 0) {
393 spin_unlock(&drvdata->spinlock);
394 return -EPERM;
395 }
396 if (!((drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE &&
397 drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
398 (drvdata->addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
399 drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
400 spin_unlock(&drvdata->spinlock);
401 return -EPERM;
402 }
403
404 drvdata->addr_val[idx] = val1;
405 drvdata->addr_type[idx] = ETM_ADDR_TYPE_RANGE;
406 drvdata->addr_val[idx + 1] = val2;
407 drvdata->addr_type[idx + 1] = ETM_ADDR_TYPE_RANGE;
408 drvdata->enable_ctrl1 |= (1 << (idx/2));
409 spin_unlock(&drvdata->spinlock);
410
411 return size;
412}
413static DEVICE_ATTR_RW(addr_range);
414
415static ssize_t addr_start_show(struct device *dev,
416 struct device_attribute *attr, char *buf)
417{
418 u8 idx;
419 unsigned long val;
420 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
421
422 spin_lock(&drvdata->spinlock);
423 idx = drvdata->addr_idx;
424 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
425 drvdata->addr_type[idx] == ETM_ADDR_TYPE_START)) {
426 spin_unlock(&drvdata->spinlock);
427 return -EPERM;
428 }
429
430 val = drvdata->addr_val[idx];
431 spin_unlock(&drvdata->spinlock);
432
433 return sprintf(buf, "%#lx\n", val);
434}
435
436static ssize_t addr_start_store(struct device *dev,
437 struct device_attribute *attr,
438 const char *buf, size_t size)
439{
440 u8 idx;
441 int ret;
442 unsigned long val;
443 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
444
445 ret = kstrtoul(buf, 16, &val);
446 if (ret)
447 return ret;
448
449 spin_lock(&drvdata->spinlock);
450 idx = drvdata->addr_idx;
451 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
452 drvdata->addr_type[idx] == ETM_ADDR_TYPE_START)) {
453 spin_unlock(&drvdata->spinlock);
454 return -EPERM;
455 }
456
457 drvdata->addr_val[idx] = val;
458 drvdata->addr_type[idx] = ETM_ADDR_TYPE_START;
459 drvdata->startstop_ctrl |= (1 << idx);
460 drvdata->enable_ctrl1 |= BIT(25);
461 spin_unlock(&drvdata->spinlock);
462
463 return size;
464}
465static DEVICE_ATTR_RW(addr_start);
466
467static ssize_t addr_stop_show(struct device *dev,
468 struct device_attribute *attr, char *buf)
469{
470 u8 idx;
471 unsigned long val;
472 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
473
474 spin_lock(&drvdata->spinlock);
475 idx = drvdata->addr_idx;
476 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
477 drvdata->addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
478 spin_unlock(&drvdata->spinlock);
479 return -EPERM;
480 }
481
482 val = drvdata->addr_val[idx];
483 spin_unlock(&drvdata->spinlock);
484
485 return sprintf(buf, "%#lx\n", val);
486}
487
488static ssize_t addr_stop_store(struct device *dev,
489 struct device_attribute *attr,
490 const char *buf, size_t size)
491{
492 u8 idx;
493 int ret;
494 unsigned long val;
495 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
496
497 ret = kstrtoul(buf, 16, &val);
498 if (ret)
499 return ret;
500
501 spin_lock(&drvdata->spinlock);
502 idx = drvdata->addr_idx;
503 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
504 drvdata->addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
505 spin_unlock(&drvdata->spinlock);
506 return -EPERM;
507 }
508
509 drvdata->addr_val[idx] = val;
510 drvdata->addr_type[idx] = ETM_ADDR_TYPE_STOP;
511 drvdata->startstop_ctrl |= (1 << (idx + 16));
512 drvdata->enable_ctrl1 |= ETMTECR1_START_STOP;
513 spin_unlock(&drvdata->spinlock);
514
515 return size;
516}
517static DEVICE_ATTR_RW(addr_stop);
518
519static ssize_t addr_acctype_show(struct device *dev,
520 struct device_attribute *attr, char *buf)
521{
522 unsigned long val;
523 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
524
525 spin_lock(&drvdata->spinlock);
526 val = drvdata->addr_acctype[drvdata->addr_idx];
527 spin_unlock(&drvdata->spinlock);
528
529 return sprintf(buf, "%#lx\n", val);
530}
531
532static ssize_t addr_acctype_store(struct device *dev,
533 struct device_attribute *attr,
534 const char *buf, size_t size)
535{
536 int ret;
537 unsigned long val;
538 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
539
540 ret = kstrtoul(buf, 16, &val);
541 if (ret)
542 return ret;
543
544 spin_lock(&drvdata->spinlock);
545 drvdata->addr_acctype[drvdata->addr_idx] = val;
546 spin_unlock(&drvdata->spinlock);
547
548 return size;
549}
550static DEVICE_ATTR_RW(addr_acctype);
551
552static ssize_t cntr_idx_show(struct device *dev,
553 struct device_attribute *attr, char *buf)
554{
555 unsigned long val;
556 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
557
558 val = drvdata->cntr_idx;
559 return sprintf(buf, "%#lx\n", val);
560}
561
562static ssize_t cntr_idx_store(struct device *dev,
563 struct device_attribute *attr,
564 const char *buf, size_t size)
565{
566 int ret;
567 unsigned long val;
568 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
569
570 ret = kstrtoul(buf, 16, &val);
571 if (ret)
572 return ret;
573
574 if (val >= drvdata->nr_cntr)
575 return -EINVAL;
576 /*
577 * Use spinlock to ensure index doesn't change while it gets
578 * dereferenced multiple times within a spinlock block elsewhere.
579 */
580 spin_lock(&drvdata->spinlock);
581 drvdata->cntr_idx = val;
582 spin_unlock(&drvdata->spinlock);
583
584 return size;
585}
586static DEVICE_ATTR_RW(cntr_idx);
587
588static ssize_t cntr_rld_val_show(struct device *dev,
589 struct device_attribute *attr, char *buf)
590{
591 unsigned long val;
592 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
593
594 spin_lock(&drvdata->spinlock);
595 val = drvdata->cntr_rld_val[drvdata->cntr_idx];
596 spin_unlock(&drvdata->spinlock);
597
598 return sprintf(buf, "%#lx\n", val);
599}
600
601static ssize_t cntr_rld_val_store(struct device *dev,
602 struct device_attribute *attr,
603 const char *buf, size_t size)
604{
605 int ret;
606 unsigned long val;
607 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
608
609 ret = kstrtoul(buf, 16, &val);
610 if (ret)
611 return ret;
612
613 spin_lock(&drvdata->spinlock);
614 drvdata->cntr_rld_val[drvdata->cntr_idx] = val;
615 spin_unlock(&drvdata->spinlock);
616
617 return size;
618}
619static DEVICE_ATTR_RW(cntr_rld_val);
620
621static ssize_t cntr_event_show(struct device *dev,
622 struct device_attribute *attr, char *buf)
623{
624 unsigned long val;
625 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
626
627 spin_lock(&drvdata->spinlock);
628 val = drvdata->cntr_event[drvdata->cntr_idx];
629 spin_unlock(&drvdata->spinlock);
630
631 return sprintf(buf, "%#lx\n", val);
632}
633
634static ssize_t cntr_event_store(struct device *dev,
635 struct device_attribute *attr,
636 const char *buf, size_t size)
637{
638 int ret;
639 unsigned long val;
640 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
641
642 ret = kstrtoul(buf, 16, &val);
643 if (ret)
644 return ret;
645
646 spin_lock(&drvdata->spinlock);
647 drvdata->cntr_event[drvdata->cntr_idx] = val & ETM_EVENT_MASK;
648 spin_unlock(&drvdata->spinlock);
649
650 return size;
651}
652static DEVICE_ATTR_RW(cntr_event);
653
654static ssize_t cntr_rld_event_show(struct device *dev,
655 struct device_attribute *attr, char *buf)
656{
657 unsigned long val;
658 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
659
660 spin_lock(&drvdata->spinlock);
661 val = drvdata->cntr_rld_event[drvdata->cntr_idx];
662 spin_unlock(&drvdata->spinlock);
663
664 return sprintf(buf, "%#lx\n", val);
665}
666
667static ssize_t cntr_rld_event_store(struct device *dev,
668 struct device_attribute *attr,
669 const char *buf, size_t size)
670{
671 int ret;
672 unsigned long val;
673 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
674
675 ret = kstrtoul(buf, 16, &val);
676 if (ret)
677 return ret;
678
679 spin_lock(&drvdata->spinlock);
680 drvdata->cntr_rld_event[drvdata->cntr_idx] = val & ETM_EVENT_MASK;
681 spin_unlock(&drvdata->spinlock);
682
683 return size;
684}
685static DEVICE_ATTR_RW(cntr_rld_event);
686
687static ssize_t cntr_val_show(struct device *dev,
688 struct device_attribute *attr, char *buf)
689{
690 int i, ret = 0;
691 u32 val;
692 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
693
694 if (!drvdata->enable) {
695 spin_lock(&drvdata->spinlock);
696 for (i = 0; i < drvdata->nr_cntr; i++)
697 ret += sprintf(buf, "counter %d: %x\n",
698 i, drvdata->cntr_val[i]);
699 spin_unlock(&drvdata->spinlock);
700 return ret;
701 }
702
703 for (i = 0; i < drvdata->nr_cntr; i++) {
704 val = etm_readl(drvdata, ETMCNTVRn(i));
705 ret += sprintf(buf, "counter %d: %x\n", i, val);
706 }
707
708 return ret;
709}
710
711static ssize_t cntr_val_store(struct device *dev,
712 struct device_attribute *attr,
713 const char *buf, size_t size)
714{
715 int ret;
716 unsigned long val;
717 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
718
719 ret = kstrtoul(buf, 16, &val);
720 if (ret)
721 return ret;
722
723 spin_lock(&drvdata->spinlock);
724 drvdata->cntr_val[drvdata->cntr_idx] = val;
725 spin_unlock(&drvdata->spinlock);
726
727 return size;
728}
729static DEVICE_ATTR_RW(cntr_val);
730
731static ssize_t seq_12_event_show(struct device *dev,
732 struct device_attribute *attr, char *buf)
733{
734 unsigned long val;
735 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
736
737 val = drvdata->seq_12_event;
738 return sprintf(buf, "%#lx\n", val);
739}
740
741static ssize_t seq_12_event_store(struct device *dev,
742 struct device_attribute *attr,
743 const char *buf, size_t size)
744{
745 int ret;
746 unsigned long val;
747 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
748
749 ret = kstrtoul(buf, 16, &val);
750 if (ret)
751 return ret;
752
753 drvdata->seq_12_event = val & ETM_EVENT_MASK;
754 return size;
755}
756static DEVICE_ATTR_RW(seq_12_event);
757
758static ssize_t seq_21_event_show(struct device *dev,
759 struct device_attribute *attr, char *buf)
760{
761 unsigned long val;
762 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
763
764 val = drvdata->seq_21_event;
765 return sprintf(buf, "%#lx\n", val);
766}
767
768static ssize_t seq_21_event_store(struct device *dev,
769 struct device_attribute *attr,
770 const char *buf, size_t size)
771{
772 int ret;
773 unsigned long val;
774 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
775
776 ret = kstrtoul(buf, 16, &val);
777 if (ret)
778 return ret;
779
780 drvdata->seq_21_event = val & ETM_EVENT_MASK;
781 return size;
782}
783static DEVICE_ATTR_RW(seq_21_event);
784
785static ssize_t seq_23_event_show(struct device *dev,
786 struct device_attribute *attr, char *buf)
787{
788 unsigned long val;
789 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
790
791 val = drvdata->seq_23_event;
792 return sprintf(buf, "%#lx\n", val);
793}
794
795static ssize_t seq_23_event_store(struct device *dev,
796 struct device_attribute *attr,
797 const char *buf, size_t size)
798{
799 int ret;
800 unsigned long val;
801 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
802
803 ret = kstrtoul(buf, 16, &val);
804 if (ret)
805 return ret;
806
807 drvdata->seq_23_event = val & ETM_EVENT_MASK;
808 return size;
809}
810static DEVICE_ATTR_RW(seq_23_event);
811
812static ssize_t seq_31_event_show(struct device *dev,
813 struct device_attribute *attr, char *buf)
814{
815 unsigned long val;
816 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
817
818 val = drvdata->seq_31_event;
819 return sprintf(buf, "%#lx\n", val);
820}
821
822static ssize_t seq_31_event_store(struct device *dev,
823 struct device_attribute *attr,
824 const char *buf, size_t size)
825{
826 int ret;
827 unsigned long val;
828 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
829
830 ret = kstrtoul(buf, 16, &val);
831 if (ret)
832 return ret;
833
834 drvdata->seq_31_event = val & ETM_EVENT_MASK;
835 return size;
836}
837static DEVICE_ATTR_RW(seq_31_event);
838
839static ssize_t seq_32_event_show(struct device *dev,
840 struct device_attribute *attr, char *buf)
841{
842 unsigned long val;
843 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
844
845 val = drvdata->seq_32_event;
846 return sprintf(buf, "%#lx\n", val);
847}
848
849static ssize_t seq_32_event_store(struct device *dev,
850 struct device_attribute *attr,
851 const char *buf, size_t size)
852{
853 int ret;
854 unsigned long val;
855 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
856
857 ret = kstrtoul(buf, 16, &val);
858 if (ret)
859 return ret;
860
861 drvdata->seq_32_event = val & ETM_EVENT_MASK;
862 return size;
863}
864static DEVICE_ATTR_RW(seq_32_event);
865
866static ssize_t seq_13_event_show(struct device *dev,
867 struct device_attribute *attr, char *buf)
868{
869 unsigned long val;
870 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
871
872 val = drvdata->seq_13_event;
873 return sprintf(buf, "%#lx\n", val);
874}
875
876static ssize_t seq_13_event_store(struct device *dev,
877 struct device_attribute *attr,
878 const char *buf, size_t size)
879{
880 int ret;
881 unsigned long val;
882 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
883
884 ret = kstrtoul(buf, 16, &val);
885 if (ret)
886 return ret;
887
888 drvdata->seq_13_event = val & ETM_EVENT_MASK;
889 return size;
890}
891static DEVICE_ATTR_RW(seq_13_event);
892
893static ssize_t seq_curr_state_show(struct device *dev,
894 struct device_attribute *attr, char *buf)
895{
896 unsigned long val, flags;
897 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
898
899 if (!drvdata->enable) {
900 val = drvdata->seq_curr_state;
901 goto out;
902 }
903
904 pm_runtime_get_sync(drvdata->dev);
905 spin_lock_irqsave(&drvdata->spinlock, flags);
906
907 CS_UNLOCK(drvdata->base);
908 val = (etm_readl(drvdata, ETMSQR) & ETM_SQR_MASK);
909 CS_LOCK(drvdata->base);
910
911 spin_unlock_irqrestore(&drvdata->spinlock, flags);
912 pm_runtime_put(drvdata->dev);
913out:
914 return sprintf(buf, "%#lx\n", val);
915}
916
917static ssize_t seq_curr_state_store(struct device *dev,
918 struct device_attribute *attr,
919 const char *buf, size_t size)
920{
921 int ret;
922 unsigned long val;
923 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
924
925 ret = kstrtoul(buf, 16, &val);
926 if (ret)
927 return ret;
928
929 if (val > ETM_SEQ_STATE_MAX_VAL)
930 return -EINVAL;
931
932 drvdata->seq_curr_state = val;
933
934 return size;
935}
936static DEVICE_ATTR_RW(seq_curr_state);
937
938static ssize_t ctxid_idx_show(struct device *dev,
939 struct device_attribute *attr, char *buf)
940{
941 unsigned long val;
942 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
943
944 val = drvdata->ctxid_idx;
945 return sprintf(buf, "%#lx\n", val);
946}
947
948static ssize_t ctxid_idx_store(struct device *dev,
949 struct device_attribute *attr,
950 const char *buf, size_t size)
951{
952 int ret;
953 unsigned long val;
954 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
955
956 ret = kstrtoul(buf, 16, &val);
957 if (ret)
958 return ret;
959
960 if (val >= drvdata->nr_ctxid_cmp)
961 return -EINVAL;
962
963 /*
964 * Use spinlock to ensure index doesn't change while it gets
965 * dereferenced multiple times within a spinlock block elsewhere.
966 */
967 spin_lock(&drvdata->spinlock);
968 drvdata->ctxid_idx = val;
969 spin_unlock(&drvdata->spinlock);
970
971 return size;
972}
973static DEVICE_ATTR_RW(ctxid_idx);
974
975static ssize_t ctxid_pid_show(struct device *dev,
976 struct device_attribute *attr, char *buf)
977{
978 unsigned long val;
979 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
980
981 spin_lock(&drvdata->spinlock);
982 val = drvdata->ctxid_vpid[drvdata->ctxid_idx];
983 spin_unlock(&drvdata->spinlock);
984
985 return sprintf(buf, "%#lx\n", val);
986}
987
988static ssize_t ctxid_pid_store(struct device *dev,
989 struct device_attribute *attr,
990 const char *buf, size_t size)
991{
992 int ret;
993 unsigned long vpid, pid;
994 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
995
996 ret = kstrtoul(buf, 16, &vpid);
997 if (ret)
998 return ret;
999
1000 pid = coresight_vpid_to_pid(vpid);
1001
1002 spin_lock(&drvdata->spinlock);
1003 drvdata->ctxid_pid[drvdata->ctxid_idx] = pid;
1004 drvdata->ctxid_vpid[drvdata->ctxid_idx] = vpid;
1005 spin_unlock(&drvdata->spinlock);
1006
1007 return size;
1008}
1009static DEVICE_ATTR_RW(ctxid_pid);
1010
1011static ssize_t ctxid_mask_show(struct device *dev,
1012 struct device_attribute *attr, char *buf)
1013{
1014 unsigned long val;
1015 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1016
1017 val = drvdata->ctxid_mask;
1018 return sprintf(buf, "%#lx\n", val);
1019}
1020
1021static ssize_t ctxid_mask_store(struct device *dev,
1022 struct device_attribute *attr,
1023 const char *buf, size_t size)
1024{
1025 int ret;
1026 unsigned long val;
1027 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1028
1029 ret = kstrtoul(buf, 16, &val);
1030 if (ret)
1031 return ret;
1032
1033 drvdata->ctxid_mask = val;
1034 return size;
1035}
1036static DEVICE_ATTR_RW(ctxid_mask);
1037
1038static ssize_t sync_freq_show(struct device *dev,
1039 struct device_attribute *attr, char *buf)
1040{
1041 unsigned long val;
1042 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1043
1044 val = drvdata->sync_freq;
1045 return sprintf(buf, "%#lx\n", val);
1046}
1047
1048static ssize_t sync_freq_store(struct device *dev,
1049 struct device_attribute *attr,
1050 const char *buf, size_t size)
1051{
1052 int ret;
1053 unsigned long val;
1054 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1055
1056 ret = kstrtoul(buf, 16, &val);
1057 if (ret)
1058 return ret;
1059
1060 drvdata->sync_freq = val & ETM_SYNC_MASK;
1061 return size;
1062}
1063static DEVICE_ATTR_RW(sync_freq);
1064
1065static ssize_t timestamp_event_show(struct device *dev,
1066 struct device_attribute *attr, char *buf)
1067{
1068 unsigned long val;
1069 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1070
1071 val = drvdata->timestamp_event;
1072 return sprintf(buf, "%#lx\n", val);
1073}
1074
1075static ssize_t timestamp_event_store(struct device *dev,
1076 struct device_attribute *attr,
1077 const char *buf, size_t size)
1078{
1079 int ret;
1080 unsigned long val;
1081 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1082
1083 ret = kstrtoul(buf, 16, &val);
1084 if (ret)
1085 return ret;
1086
1087 drvdata->timestamp_event = val & ETM_EVENT_MASK;
1088 return size;
1089}
1090static DEVICE_ATTR_RW(timestamp_event);
1091
1092static ssize_t cpu_show(struct device *dev,
1093 struct device_attribute *attr, char *buf)
1094{
1095 int val;
1096 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1097
1098 val = drvdata->cpu;
1099 return scnprintf(buf, PAGE_SIZE, "%d\n", val);
1100
1101}
1102static DEVICE_ATTR_RO(cpu);
1103
1104static ssize_t traceid_show(struct device *dev,
1105 struct device_attribute *attr, char *buf)
1106{
1107 unsigned long val;
1108 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1109
1110 val = etm_get_trace_id(drvdata);
1111
1112 return sprintf(buf, "%#lx\n", val);
1113}
1114
1115static ssize_t traceid_store(struct device *dev,
1116 struct device_attribute *attr,
1117 const char *buf, size_t size)
1118{
1119 int ret;
1120 unsigned long val;
1121 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1122
1123 ret = kstrtoul(buf, 16, &val);
1124 if (ret)
1125 return ret;
1126
1127 drvdata->traceid = val & ETM_TRACEID_MASK;
1128 return size;
1129}
1130static DEVICE_ATTR_RW(traceid);
1131
1132static struct attribute *coresight_etm_attrs[] = {
1133 &dev_attr_nr_addr_cmp.attr,
1134 &dev_attr_nr_cntr.attr,
1135 &dev_attr_nr_ctxid_cmp.attr,
1136 &dev_attr_etmsr.attr,
1137 &dev_attr_reset.attr,
1138 &dev_attr_mode.attr,
1139 &dev_attr_trigger_event.attr,
1140 &dev_attr_enable_event.attr,
1141 &dev_attr_fifofull_level.attr,
1142 &dev_attr_addr_idx.attr,
1143 &dev_attr_addr_single.attr,
1144 &dev_attr_addr_range.attr,
1145 &dev_attr_addr_start.attr,
1146 &dev_attr_addr_stop.attr,
1147 &dev_attr_addr_acctype.attr,
1148 &dev_attr_cntr_idx.attr,
1149 &dev_attr_cntr_rld_val.attr,
1150 &dev_attr_cntr_event.attr,
1151 &dev_attr_cntr_rld_event.attr,
1152 &dev_attr_cntr_val.attr,
1153 &dev_attr_seq_12_event.attr,
1154 &dev_attr_seq_21_event.attr,
1155 &dev_attr_seq_23_event.attr,
1156 &dev_attr_seq_31_event.attr,
1157 &dev_attr_seq_32_event.attr,
1158 &dev_attr_seq_13_event.attr,
1159 &dev_attr_seq_curr_state.attr,
1160 &dev_attr_ctxid_idx.attr,
1161 &dev_attr_ctxid_pid.attr,
1162 &dev_attr_ctxid_mask.attr,
1163 &dev_attr_sync_freq.attr,
1164 &dev_attr_timestamp_event.attr,
1165 &dev_attr_traceid.attr,
1166 &dev_attr_cpu.attr,
1167 NULL,
1168};
1169
1170#define coresight_simple_func(name, offset) \
1171static ssize_t name##_show(struct device *_dev, \
1172 struct device_attribute *attr, char *buf) \
1173{ \
1174 struct etm_drvdata *drvdata = dev_get_drvdata(_dev->parent); \
1175 return scnprintf(buf, PAGE_SIZE, "0x%x\n", \
1176 readl_relaxed(drvdata->base + offset)); \
1177} \
1178DEVICE_ATTR_RO(name)
1179
1180coresight_simple_func(etmccr, ETMCCR);
1181coresight_simple_func(etmccer, ETMCCER);
1182coresight_simple_func(etmscr, ETMSCR);
1183coresight_simple_func(etmidr, ETMIDR);
1184coresight_simple_func(etmcr, ETMCR);
1185coresight_simple_func(etmtraceidr, ETMTRACEIDR);
1186coresight_simple_func(etmteevr, ETMTEEVR);
1187coresight_simple_func(etmtssvr, ETMTSSCR);
1188coresight_simple_func(etmtecr1, ETMTECR1);
1189coresight_simple_func(etmtecr2, ETMTECR2);
1190
1191static struct attribute *coresight_etm_mgmt_attrs[] = {
1192 &dev_attr_etmccr.attr,
1193 &dev_attr_etmccer.attr,
1194 &dev_attr_etmscr.attr,
1195 &dev_attr_etmidr.attr,
1196 &dev_attr_etmcr.attr,
1197 &dev_attr_etmtraceidr.attr,
1198 &dev_attr_etmteevr.attr,
1199 &dev_attr_etmtssvr.attr,
1200 &dev_attr_etmtecr1.attr,
1201 &dev_attr_etmtecr2.attr,
1202 NULL,
1203};
1204
1205static const struct attribute_group coresight_etm_group = {
1206 .attrs = coresight_etm_attrs,
1207};
1208
1209static const struct attribute_group coresight_etm_mgmt_group = {
1210 .attrs = coresight_etm_mgmt_attrs,
1211 .name = "mgmt",
1212};
1213
1214const struct attribute_group *coresight_etm_groups[] = {
1215 &coresight_etm_group,
1216 &coresight_etm_mgmt_group,
1217 NULL,
1218};
diff --git a/drivers/hwtracing/coresight/coresight-etm3x.c b/drivers/hwtracing/coresight/coresight-etm3x.c
index d53440e9af6f..6ea35b350958 100644
--- a/drivers/hwtracing/coresight/coresight-etm3x.c
+++ b/drivers/hwtracing/coresight/coresight-etm3x.c
@@ -186,7 +186,7 @@ static void etm_clr_prog(struct etm_drvdata *drvdata)
186 } 186 }
187} 187}
188 188
189static void etm_set_default(struct etm_drvdata *drvdata) 189void etm_set_default(struct etm_drvdata *drvdata)
190{ 190{
191 int i; 191 int i;
192 192
@@ -293,15 +293,18 @@ static int etm_cpu_id(struct coresight_device *csdev)
293 return drvdata->cpu; 293 return drvdata->cpu;
294} 294}
295 295
296static int etm_trace_id(struct coresight_device *csdev) 296int etm_get_trace_id(struct etm_drvdata *drvdata)
297{ 297{
298 struct etm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
299 unsigned long flags; 298 unsigned long flags;
300 int trace_id = -1; 299 int trace_id = -1;
301 300
301 if (!drvdata)
302 goto out;
303
302 if (!drvdata->enable) 304 if (!drvdata->enable)
303 return drvdata->traceid; 305 return drvdata->traceid;
304 pm_runtime_get_sync(csdev->dev.parent); 306
307 pm_runtime_get_sync(drvdata->dev);
305 308
306 spin_lock_irqsave(&drvdata->spinlock, flags); 309 spin_lock_irqsave(&drvdata->spinlock, flags);
307 310
@@ -310,9 +313,18 @@ static int etm_trace_id(struct coresight_device *csdev)
310 CS_LOCK(drvdata->base); 313 CS_LOCK(drvdata->base);
311 314
312 spin_unlock_irqrestore(&drvdata->spinlock, flags); 315 spin_unlock_irqrestore(&drvdata->spinlock, flags);
313 pm_runtime_put(csdev->dev.parent); 316 pm_runtime_put(drvdata->dev);
314 317
318out:
315 return trace_id; 319 return trace_id;
320
321}
322
323static int etm_trace_id(struct coresight_device *csdev)
324{
325 struct etm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
326
327 return etm_get_trace_id(drvdata);
316} 328}
317 329
318static int etm_enable(struct coresight_device *csdev) 330static int etm_enable(struct coresight_device *csdev)
@@ -406,1218 +418,6 @@ static const struct coresight_ops etm_cs_ops = {
406 .source_ops = &etm_source_ops, 418 .source_ops = &etm_source_ops,
407}; 419};
408 420
409static ssize_t nr_addr_cmp_show(struct device *dev,
410 struct device_attribute *attr, char *buf)
411{
412 unsigned long val;
413 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
414
415 val = drvdata->nr_addr_cmp;
416 return sprintf(buf, "%#lx\n", val);
417}
418static DEVICE_ATTR_RO(nr_addr_cmp);
419
420static ssize_t nr_cntr_show(struct device *dev,
421 struct device_attribute *attr, char *buf)
422{ unsigned long val;
423 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
424
425 val = drvdata->nr_cntr;
426 return sprintf(buf, "%#lx\n", val);
427}
428static DEVICE_ATTR_RO(nr_cntr);
429
430static ssize_t nr_ctxid_cmp_show(struct device *dev,
431 struct device_attribute *attr, char *buf)
432{
433 unsigned long val;
434 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
435
436 val = drvdata->nr_ctxid_cmp;
437 return sprintf(buf, "%#lx\n", val);
438}
439static DEVICE_ATTR_RO(nr_ctxid_cmp);
440
441static ssize_t etmsr_show(struct device *dev,
442 struct device_attribute *attr, char *buf)
443{
444 unsigned long flags, val;
445 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
446
447 pm_runtime_get_sync(drvdata->dev);
448 spin_lock_irqsave(&drvdata->spinlock, flags);
449 CS_UNLOCK(drvdata->base);
450
451 val = etm_readl(drvdata, ETMSR);
452
453 CS_LOCK(drvdata->base);
454 spin_unlock_irqrestore(&drvdata->spinlock, flags);
455 pm_runtime_put(drvdata->dev);
456
457 return sprintf(buf, "%#lx\n", val);
458}
459static DEVICE_ATTR_RO(etmsr);
460
461static ssize_t reset_store(struct device *dev,
462 struct device_attribute *attr,
463 const char *buf, size_t size)
464{
465 int i, ret;
466 unsigned long val;
467 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
468
469 ret = kstrtoul(buf, 16, &val);
470 if (ret)
471 return ret;
472
473 if (val) {
474 spin_lock(&drvdata->spinlock);
475 drvdata->mode = ETM_MODE_EXCLUDE;
476 drvdata->ctrl = 0x0;
477 drvdata->trigger_event = ETM_DEFAULT_EVENT_VAL;
478 drvdata->startstop_ctrl = 0x0;
479 drvdata->addr_idx = 0x0;
480 for (i = 0; i < drvdata->nr_addr_cmp; i++) {
481 drvdata->addr_val[i] = 0x0;
482 drvdata->addr_acctype[i] = 0x0;
483 drvdata->addr_type[i] = ETM_ADDR_TYPE_NONE;
484 }
485 drvdata->cntr_idx = 0x0;
486
487 etm_set_default(drvdata);
488 spin_unlock(&drvdata->spinlock);
489 }
490
491 return size;
492}
493static DEVICE_ATTR_WO(reset);
494
495static ssize_t mode_show(struct device *dev,
496 struct device_attribute *attr, char *buf)
497{
498 unsigned long val;
499 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
500
501 val = drvdata->mode;
502 return sprintf(buf, "%#lx\n", val);
503}
504
505static ssize_t mode_store(struct device *dev,
506 struct device_attribute *attr,
507 const char *buf, size_t size)
508{
509 int ret;
510 unsigned long val;
511 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
512
513 ret = kstrtoul(buf, 16, &val);
514 if (ret)
515 return ret;
516
517 spin_lock(&drvdata->spinlock);
518 drvdata->mode = val & ETM_MODE_ALL;
519
520 if (drvdata->mode & ETM_MODE_EXCLUDE)
521 drvdata->enable_ctrl1 |= ETMTECR1_INC_EXC;
522 else
523 drvdata->enable_ctrl1 &= ~ETMTECR1_INC_EXC;
524
525 if (drvdata->mode & ETM_MODE_CYCACC)
526 drvdata->ctrl |= ETMCR_CYC_ACC;
527 else
528 drvdata->ctrl &= ~ETMCR_CYC_ACC;
529
530 if (drvdata->mode & ETM_MODE_STALL) {
531 if (!(drvdata->etmccr & ETMCCR_FIFOFULL)) {
532 dev_warn(drvdata->dev, "stall mode not supported\n");
533 ret = -EINVAL;
534 goto err_unlock;
535 }
536 drvdata->ctrl |= ETMCR_STALL_MODE;
537 } else
538 drvdata->ctrl &= ~ETMCR_STALL_MODE;
539
540 if (drvdata->mode & ETM_MODE_TIMESTAMP) {
541 if (!(drvdata->etmccer & ETMCCER_TIMESTAMP)) {
542 dev_warn(drvdata->dev, "timestamp not supported\n");
543 ret = -EINVAL;
544 goto err_unlock;
545 }
546 drvdata->ctrl |= ETMCR_TIMESTAMP_EN;
547 } else
548 drvdata->ctrl &= ~ETMCR_TIMESTAMP_EN;
549
550 if (drvdata->mode & ETM_MODE_CTXID)
551 drvdata->ctrl |= ETMCR_CTXID_SIZE;
552 else
553 drvdata->ctrl &= ~ETMCR_CTXID_SIZE;
554 spin_unlock(&drvdata->spinlock);
555
556 return size;
557
558err_unlock:
559 spin_unlock(&drvdata->spinlock);
560 return ret;
561}
562static DEVICE_ATTR_RW(mode);
563
564static ssize_t trigger_event_show(struct device *dev,
565 struct device_attribute *attr, char *buf)
566{
567 unsigned long val;
568 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
569
570 val = drvdata->trigger_event;
571 return sprintf(buf, "%#lx\n", val);
572}
573
574static ssize_t trigger_event_store(struct device *dev,
575 struct device_attribute *attr,
576 const char *buf, size_t size)
577{
578 int ret;
579 unsigned long val;
580 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
581
582 ret = kstrtoul(buf, 16, &val);
583 if (ret)
584 return ret;
585
586 drvdata->trigger_event = val & ETM_EVENT_MASK;
587
588 return size;
589}
590static DEVICE_ATTR_RW(trigger_event);
591
592static ssize_t enable_event_show(struct device *dev,
593 struct device_attribute *attr, char *buf)
594{
595 unsigned long val;
596 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
597
598 val = drvdata->enable_event;
599 return sprintf(buf, "%#lx\n", val);
600}
601
602static ssize_t enable_event_store(struct device *dev,
603 struct device_attribute *attr,
604 const char *buf, size_t size)
605{
606 int ret;
607 unsigned long val;
608 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
609
610 ret = kstrtoul(buf, 16, &val);
611 if (ret)
612 return ret;
613
614 drvdata->enable_event = val & ETM_EVENT_MASK;
615
616 return size;
617}
618static DEVICE_ATTR_RW(enable_event);
619
620static ssize_t fifofull_level_show(struct device *dev,
621 struct device_attribute *attr, char *buf)
622{
623 unsigned long val;
624 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
625
626 val = drvdata->fifofull_level;
627 return sprintf(buf, "%#lx\n", val);
628}
629
630static ssize_t fifofull_level_store(struct device *dev,
631 struct device_attribute *attr,
632 const char *buf, size_t size)
633{
634 int ret;
635 unsigned long val;
636 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
637
638 ret = kstrtoul(buf, 16, &val);
639 if (ret)
640 return ret;
641
642 drvdata->fifofull_level = val;
643
644 return size;
645}
646static DEVICE_ATTR_RW(fifofull_level);
647
648static ssize_t addr_idx_show(struct device *dev,
649 struct device_attribute *attr, char *buf)
650{
651 unsigned long val;
652 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
653
654 val = drvdata->addr_idx;
655 return sprintf(buf, "%#lx\n", val);
656}
657
658static ssize_t addr_idx_store(struct device *dev,
659 struct device_attribute *attr,
660 const char *buf, size_t size)
661{
662 int ret;
663 unsigned long val;
664 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
665
666 ret = kstrtoul(buf, 16, &val);
667 if (ret)
668 return ret;
669
670 if (val >= drvdata->nr_addr_cmp)
671 return -EINVAL;
672
673 /*
674 * Use spinlock to ensure index doesn't change while it gets
675 * dereferenced multiple times within a spinlock block elsewhere.
676 */
677 spin_lock(&drvdata->spinlock);
678 drvdata->addr_idx = val;
679 spin_unlock(&drvdata->spinlock);
680
681 return size;
682}
683static DEVICE_ATTR_RW(addr_idx);
684
685static ssize_t addr_single_show(struct device *dev,
686 struct device_attribute *attr, char *buf)
687{
688 u8 idx;
689 unsigned long val;
690 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
691
692 spin_lock(&drvdata->spinlock);
693 idx = drvdata->addr_idx;
694 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
695 drvdata->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
696 spin_unlock(&drvdata->spinlock);
697 return -EINVAL;
698 }
699
700 val = drvdata->addr_val[idx];
701 spin_unlock(&drvdata->spinlock);
702
703 return sprintf(buf, "%#lx\n", val);
704}
705
706static ssize_t addr_single_store(struct device *dev,
707 struct device_attribute *attr,
708 const char *buf, size_t size)
709{
710 u8 idx;
711 int ret;
712 unsigned long val;
713 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
714
715 ret = kstrtoul(buf, 16, &val);
716 if (ret)
717 return ret;
718
719 spin_lock(&drvdata->spinlock);
720 idx = drvdata->addr_idx;
721 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
722 drvdata->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
723 spin_unlock(&drvdata->spinlock);
724 return -EINVAL;
725 }
726
727 drvdata->addr_val[idx] = val;
728 drvdata->addr_type[idx] = ETM_ADDR_TYPE_SINGLE;
729 spin_unlock(&drvdata->spinlock);
730
731 return size;
732}
733static DEVICE_ATTR_RW(addr_single);
734
735static ssize_t addr_range_show(struct device *dev,
736 struct device_attribute *attr, char *buf)
737{
738 u8 idx;
739 unsigned long val1, val2;
740 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
741
742 spin_lock(&drvdata->spinlock);
743 idx = drvdata->addr_idx;
744 if (idx % 2 != 0) {
745 spin_unlock(&drvdata->spinlock);
746 return -EPERM;
747 }
748 if (!((drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE &&
749 drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
750 (drvdata->addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
751 drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
752 spin_unlock(&drvdata->spinlock);
753 return -EPERM;
754 }
755
756 val1 = drvdata->addr_val[idx];
757 val2 = drvdata->addr_val[idx + 1];
758 spin_unlock(&drvdata->spinlock);
759
760 return sprintf(buf, "%#lx %#lx\n", val1, val2);
761}
762
763static ssize_t addr_range_store(struct device *dev,
764 struct device_attribute *attr,
765 const char *buf, size_t size)
766{
767 u8 idx;
768 unsigned long val1, val2;
769 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
770
771 if (sscanf(buf, "%lx %lx", &val1, &val2) != 2)
772 return -EINVAL;
773 /* Lower address comparator cannot have a higher address value */
774 if (val1 > val2)
775 return -EINVAL;
776
777 spin_lock(&drvdata->spinlock);
778 idx = drvdata->addr_idx;
779 if (idx % 2 != 0) {
780 spin_unlock(&drvdata->spinlock);
781 return -EPERM;
782 }
783 if (!((drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE &&
784 drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
785 (drvdata->addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
786 drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
787 spin_unlock(&drvdata->spinlock);
788 return -EPERM;
789 }
790
791 drvdata->addr_val[idx] = val1;
792 drvdata->addr_type[idx] = ETM_ADDR_TYPE_RANGE;
793 drvdata->addr_val[idx + 1] = val2;
794 drvdata->addr_type[idx + 1] = ETM_ADDR_TYPE_RANGE;
795 drvdata->enable_ctrl1 |= (1 << (idx/2));
796 spin_unlock(&drvdata->spinlock);
797
798 return size;
799}
800static DEVICE_ATTR_RW(addr_range);
801
802static ssize_t addr_start_show(struct device *dev,
803 struct device_attribute *attr, char *buf)
804{
805 u8 idx;
806 unsigned long val;
807 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
808
809 spin_lock(&drvdata->spinlock);
810 idx = drvdata->addr_idx;
811 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
812 drvdata->addr_type[idx] == ETM_ADDR_TYPE_START)) {
813 spin_unlock(&drvdata->spinlock);
814 return -EPERM;
815 }
816
817 val = drvdata->addr_val[idx];
818 spin_unlock(&drvdata->spinlock);
819
820 return sprintf(buf, "%#lx\n", val);
821}
822
823static ssize_t addr_start_store(struct device *dev,
824 struct device_attribute *attr,
825 const char *buf, size_t size)
826{
827 u8 idx;
828 int ret;
829 unsigned long val;
830 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
831
832 ret = kstrtoul(buf, 16, &val);
833 if (ret)
834 return ret;
835
836 spin_lock(&drvdata->spinlock);
837 idx = drvdata->addr_idx;
838 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
839 drvdata->addr_type[idx] == ETM_ADDR_TYPE_START)) {
840 spin_unlock(&drvdata->spinlock);
841 return -EPERM;
842 }
843
844 drvdata->addr_val[idx] = val;
845 drvdata->addr_type[idx] = ETM_ADDR_TYPE_START;
846 drvdata->startstop_ctrl |= (1 << idx);
847 drvdata->enable_ctrl1 |= BIT(25);
848 spin_unlock(&drvdata->spinlock);
849
850 return size;
851}
852static DEVICE_ATTR_RW(addr_start);
853
854static ssize_t addr_stop_show(struct device *dev,
855 struct device_attribute *attr, char *buf)
856{
857 u8 idx;
858 unsigned long val;
859 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
860
861 spin_lock(&drvdata->spinlock);
862 idx = drvdata->addr_idx;
863 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
864 drvdata->addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
865 spin_unlock(&drvdata->spinlock);
866 return -EPERM;
867 }
868
869 val = drvdata->addr_val[idx];
870 spin_unlock(&drvdata->spinlock);
871
872 return sprintf(buf, "%#lx\n", val);
873}
874
875static ssize_t addr_stop_store(struct device *dev,
876 struct device_attribute *attr,
877 const char *buf, size_t size)
878{
879 u8 idx;
880 int ret;
881 unsigned long val;
882 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
883
884 ret = kstrtoul(buf, 16, &val);
885 if (ret)
886 return ret;
887
888 spin_lock(&drvdata->spinlock);
889 idx = drvdata->addr_idx;
890 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
891 drvdata->addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
892 spin_unlock(&drvdata->spinlock);
893 return -EPERM;
894 }
895
896 drvdata->addr_val[idx] = val;
897 drvdata->addr_type[idx] = ETM_ADDR_TYPE_STOP;
898 drvdata->startstop_ctrl |= (1 << (idx + 16));
899 drvdata->enable_ctrl1 |= ETMTECR1_START_STOP;
900 spin_unlock(&drvdata->spinlock);
901
902 return size;
903}
904static DEVICE_ATTR_RW(addr_stop);
905
906static ssize_t addr_acctype_show(struct device *dev,
907 struct device_attribute *attr, char *buf)
908{
909 unsigned long val;
910 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
911
912 spin_lock(&drvdata->spinlock);
913 val = drvdata->addr_acctype[drvdata->addr_idx];
914 spin_unlock(&drvdata->spinlock);
915
916 return sprintf(buf, "%#lx\n", val);
917}
918
919static ssize_t addr_acctype_store(struct device *dev,
920 struct device_attribute *attr,
921 const char *buf, size_t size)
922{
923 int ret;
924 unsigned long val;
925 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
926
927 ret = kstrtoul(buf, 16, &val);
928 if (ret)
929 return ret;
930
931 spin_lock(&drvdata->spinlock);
932 drvdata->addr_acctype[drvdata->addr_idx] = val;
933 spin_unlock(&drvdata->spinlock);
934
935 return size;
936}
937static DEVICE_ATTR_RW(addr_acctype);
938
939static ssize_t cntr_idx_show(struct device *dev,
940 struct device_attribute *attr, char *buf)
941{
942 unsigned long val;
943 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
944
945 val = drvdata->cntr_idx;
946 return sprintf(buf, "%#lx\n", val);
947}
948
949static ssize_t cntr_idx_store(struct device *dev,
950 struct device_attribute *attr,
951 const char *buf, size_t size)
952{
953 int ret;
954 unsigned long val;
955 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
956
957 ret = kstrtoul(buf, 16, &val);
958 if (ret)
959 return ret;
960
961 if (val >= drvdata->nr_cntr)
962 return -EINVAL;
963 /*
964 * Use spinlock to ensure index doesn't change while it gets
965 * dereferenced multiple times within a spinlock block elsewhere.
966 */
967 spin_lock(&drvdata->spinlock);
968 drvdata->cntr_idx = val;
969 spin_unlock(&drvdata->spinlock);
970
971 return size;
972}
973static DEVICE_ATTR_RW(cntr_idx);
974
975static ssize_t cntr_rld_val_show(struct device *dev,
976 struct device_attribute *attr, char *buf)
977{
978 unsigned long val;
979 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
980
981 spin_lock(&drvdata->spinlock);
982 val = drvdata->cntr_rld_val[drvdata->cntr_idx];
983 spin_unlock(&drvdata->spinlock);
984
985 return sprintf(buf, "%#lx\n", val);
986}
987
988static ssize_t cntr_rld_val_store(struct device *dev,
989 struct device_attribute *attr,
990 const char *buf, size_t size)
991{
992 int ret;
993 unsigned long val;
994 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
995
996 ret = kstrtoul(buf, 16, &val);
997 if (ret)
998 return ret;
999
1000 spin_lock(&drvdata->spinlock);
1001 drvdata->cntr_rld_val[drvdata->cntr_idx] = val;
1002 spin_unlock(&drvdata->spinlock);
1003
1004 return size;
1005}
1006static DEVICE_ATTR_RW(cntr_rld_val);
1007
1008static ssize_t cntr_event_show(struct device *dev,
1009 struct device_attribute *attr, char *buf)
1010{
1011 unsigned long val;
1012 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1013
1014 spin_lock(&drvdata->spinlock);
1015 val = drvdata->cntr_event[drvdata->cntr_idx];
1016 spin_unlock(&drvdata->spinlock);
1017
1018 return sprintf(buf, "%#lx\n", val);
1019}
1020
1021static ssize_t cntr_event_store(struct device *dev,
1022 struct device_attribute *attr,
1023 const char *buf, size_t size)
1024{
1025 int ret;
1026 unsigned long val;
1027 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1028
1029 ret = kstrtoul(buf, 16, &val);
1030 if (ret)
1031 return ret;
1032
1033 spin_lock(&drvdata->spinlock);
1034 drvdata->cntr_event[drvdata->cntr_idx] = val & ETM_EVENT_MASK;
1035 spin_unlock(&drvdata->spinlock);
1036
1037 return size;
1038}
1039static DEVICE_ATTR_RW(cntr_event);
1040
1041static ssize_t cntr_rld_event_show(struct device *dev,
1042 struct device_attribute *attr, char *buf)
1043{
1044 unsigned long val;
1045 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1046
1047 spin_lock(&drvdata->spinlock);
1048 val = drvdata->cntr_rld_event[drvdata->cntr_idx];
1049 spin_unlock(&drvdata->spinlock);
1050
1051 return sprintf(buf, "%#lx\n", val);
1052}
1053
1054static ssize_t cntr_rld_event_store(struct device *dev,
1055 struct device_attribute *attr,
1056 const char *buf, size_t size)
1057{
1058 int ret;
1059 unsigned long val;
1060 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1061
1062 ret = kstrtoul(buf, 16, &val);
1063 if (ret)
1064 return ret;
1065
1066 spin_lock(&drvdata->spinlock);
1067 drvdata->cntr_rld_event[drvdata->cntr_idx] = val & ETM_EVENT_MASK;
1068 spin_unlock(&drvdata->spinlock);
1069
1070 return size;
1071}
1072static DEVICE_ATTR_RW(cntr_rld_event);
1073
1074static ssize_t cntr_val_show(struct device *dev,
1075 struct device_attribute *attr, char *buf)
1076{
1077 int i, ret = 0;
1078 u32 val;
1079 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1080
1081 if (!drvdata->enable) {
1082 spin_lock(&drvdata->spinlock);
1083 for (i = 0; i < drvdata->nr_cntr; i++)
1084 ret += sprintf(buf, "counter %d: %x\n",
1085 i, drvdata->cntr_val[i]);
1086 spin_unlock(&drvdata->spinlock);
1087 return ret;
1088 }
1089
1090 for (i = 0; i < drvdata->nr_cntr; i++) {
1091 val = etm_readl(drvdata, ETMCNTVRn(i));
1092 ret += sprintf(buf, "counter %d: %x\n", i, val);
1093 }
1094
1095 return ret;
1096}
1097
1098static ssize_t cntr_val_store(struct device *dev,
1099 struct device_attribute *attr,
1100 const char *buf, size_t size)
1101{
1102 int ret;
1103 unsigned long val;
1104 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1105
1106 ret = kstrtoul(buf, 16, &val);
1107 if (ret)
1108 return ret;
1109
1110 spin_lock(&drvdata->spinlock);
1111 drvdata->cntr_val[drvdata->cntr_idx] = val;
1112 spin_unlock(&drvdata->spinlock);
1113
1114 return size;
1115}
1116static DEVICE_ATTR_RW(cntr_val);
1117
1118static ssize_t seq_12_event_show(struct device *dev,
1119 struct device_attribute *attr, char *buf)
1120{
1121 unsigned long val;
1122 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1123
1124 val = drvdata->seq_12_event;
1125 return sprintf(buf, "%#lx\n", val);
1126}
1127
1128static ssize_t seq_12_event_store(struct device *dev,
1129 struct device_attribute *attr,
1130 const char *buf, size_t size)
1131{
1132 int ret;
1133 unsigned long val;
1134 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1135
1136 ret = kstrtoul(buf, 16, &val);
1137 if (ret)
1138 return ret;
1139
1140 drvdata->seq_12_event = val & ETM_EVENT_MASK;
1141 return size;
1142}
1143static DEVICE_ATTR_RW(seq_12_event);
1144
1145static ssize_t seq_21_event_show(struct device *dev,
1146 struct device_attribute *attr, char *buf)
1147{
1148 unsigned long val;
1149 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1150
1151 val = drvdata->seq_21_event;
1152 return sprintf(buf, "%#lx\n", val);
1153}
1154
1155static ssize_t seq_21_event_store(struct device *dev,
1156 struct device_attribute *attr,
1157 const char *buf, size_t size)
1158{
1159 int ret;
1160 unsigned long val;
1161 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1162
1163 ret = kstrtoul(buf, 16, &val);
1164 if (ret)
1165 return ret;
1166
1167 drvdata->seq_21_event = val & ETM_EVENT_MASK;
1168 return size;
1169}
1170static DEVICE_ATTR_RW(seq_21_event);
1171
1172static ssize_t seq_23_event_show(struct device *dev,
1173 struct device_attribute *attr, char *buf)
1174{
1175 unsigned long val;
1176 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1177
1178 val = drvdata->seq_23_event;
1179 return sprintf(buf, "%#lx\n", val);
1180}
1181
1182static ssize_t seq_23_event_store(struct device *dev,
1183 struct device_attribute *attr,
1184 const char *buf, size_t size)
1185{
1186 int ret;
1187 unsigned long val;
1188 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1189
1190 ret = kstrtoul(buf, 16, &val);
1191 if (ret)
1192 return ret;
1193
1194 drvdata->seq_23_event = val & ETM_EVENT_MASK;
1195 return size;
1196}
1197static DEVICE_ATTR_RW(seq_23_event);
1198
1199static ssize_t seq_31_event_show(struct device *dev,
1200 struct device_attribute *attr, char *buf)
1201{
1202 unsigned long val;
1203 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1204
1205 val = drvdata->seq_31_event;
1206 return sprintf(buf, "%#lx\n", val);
1207}
1208
1209static ssize_t seq_31_event_store(struct device *dev,
1210 struct device_attribute *attr,
1211 const char *buf, size_t size)
1212{
1213 int ret;
1214 unsigned long val;
1215 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1216
1217 ret = kstrtoul(buf, 16, &val);
1218 if (ret)
1219 return ret;
1220
1221 drvdata->seq_31_event = val & ETM_EVENT_MASK;
1222 return size;
1223}
1224static DEVICE_ATTR_RW(seq_31_event);
1225
1226static ssize_t seq_32_event_show(struct device *dev,
1227 struct device_attribute *attr, char *buf)
1228{
1229 unsigned long val;
1230 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1231
1232 val = drvdata->seq_32_event;
1233 return sprintf(buf, "%#lx\n", val);
1234}
1235
1236static ssize_t seq_32_event_store(struct device *dev,
1237 struct device_attribute *attr,
1238 const char *buf, size_t size)
1239{
1240 int ret;
1241 unsigned long val;
1242 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1243
1244 ret = kstrtoul(buf, 16, &val);
1245 if (ret)
1246 return ret;
1247
1248 drvdata->seq_32_event = val & ETM_EVENT_MASK;
1249 return size;
1250}
1251static DEVICE_ATTR_RW(seq_32_event);
1252
1253static ssize_t seq_13_event_show(struct device *dev,
1254 struct device_attribute *attr, char *buf)
1255{
1256 unsigned long val;
1257 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1258
1259 val = drvdata->seq_13_event;
1260 return sprintf(buf, "%#lx\n", val);
1261}
1262
1263static ssize_t seq_13_event_store(struct device *dev,
1264 struct device_attribute *attr,
1265 const char *buf, size_t size)
1266{
1267 int ret;
1268 unsigned long val;
1269 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1270
1271 ret = kstrtoul(buf, 16, &val);
1272 if (ret)
1273 return ret;
1274
1275 drvdata->seq_13_event = val & ETM_EVENT_MASK;
1276 return size;
1277}
1278static DEVICE_ATTR_RW(seq_13_event);
1279
1280static ssize_t seq_curr_state_show(struct device *dev,
1281 struct device_attribute *attr, char *buf)
1282{
1283 unsigned long val, flags;
1284 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1285
1286 if (!drvdata->enable) {
1287 val = drvdata->seq_curr_state;
1288 goto out;
1289 }
1290
1291 pm_runtime_get_sync(drvdata->dev);
1292 spin_lock_irqsave(&drvdata->spinlock, flags);
1293
1294 CS_UNLOCK(drvdata->base);
1295 val = (etm_readl(drvdata, ETMSQR) & ETM_SQR_MASK);
1296 CS_LOCK(drvdata->base);
1297
1298 spin_unlock_irqrestore(&drvdata->spinlock, flags);
1299 pm_runtime_put(drvdata->dev);
1300out:
1301 return sprintf(buf, "%#lx\n", val);
1302}
1303
1304static ssize_t seq_curr_state_store(struct device *dev,
1305 struct device_attribute *attr,
1306 const char *buf, size_t size)
1307{
1308 int ret;
1309 unsigned long val;
1310 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1311
1312 ret = kstrtoul(buf, 16, &val);
1313 if (ret)
1314 return ret;
1315
1316 if (val > ETM_SEQ_STATE_MAX_VAL)
1317 return -EINVAL;
1318
1319 drvdata->seq_curr_state = val;
1320
1321 return size;
1322}
1323static DEVICE_ATTR_RW(seq_curr_state);
1324
1325static ssize_t ctxid_idx_show(struct device *dev,
1326 struct device_attribute *attr, char *buf)
1327{
1328 unsigned long val;
1329 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1330
1331 val = drvdata->ctxid_idx;
1332 return sprintf(buf, "%#lx\n", val);
1333}
1334
1335static ssize_t ctxid_idx_store(struct device *dev,
1336 struct device_attribute *attr,
1337 const char *buf, size_t size)
1338{
1339 int ret;
1340 unsigned long val;
1341 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1342
1343 ret = kstrtoul(buf, 16, &val);
1344 if (ret)
1345 return ret;
1346
1347 if (val >= drvdata->nr_ctxid_cmp)
1348 return -EINVAL;
1349
1350 /*
1351 * Use spinlock to ensure index doesn't change while it gets
1352 * dereferenced multiple times within a spinlock block elsewhere.
1353 */
1354 spin_lock(&drvdata->spinlock);
1355 drvdata->ctxid_idx = val;
1356 spin_unlock(&drvdata->spinlock);
1357
1358 return size;
1359}
1360static DEVICE_ATTR_RW(ctxid_idx);
1361
1362static ssize_t ctxid_pid_show(struct device *dev,
1363 struct device_attribute *attr, char *buf)
1364{
1365 unsigned long val;
1366 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1367
1368 spin_lock(&drvdata->spinlock);
1369 val = drvdata->ctxid_vpid[drvdata->ctxid_idx];
1370 spin_unlock(&drvdata->spinlock);
1371
1372 return sprintf(buf, "%#lx\n", val);
1373}
1374
1375static ssize_t ctxid_pid_store(struct device *dev,
1376 struct device_attribute *attr,
1377 const char *buf, size_t size)
1378{
1379 int ret;
1380 unsigned long vpid, pid;
1381 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1382
1383 ret = kstrtoul(buf, 16, &vpid);
1384 if (ret)
1385 return ret;
1386
1387 pid = coresight_vpid_to_pid(vpid);
1388
1389 spin_lock(&drvdata->spinlock);
1390 drvdata->ctxid_pid[drvdata->ctxid_idx] = pid;
1391 drvdata->ctxid_vpid[drvdata->ctxid_idx] = vpid;
1392 spin_unlock(&drvdata->spinlock);
1393
1394 return size;
1395}
1396static DEVICE_ATTR_RW(ctxid_pid);
1397
1398static ssize_t ctxid_mask_show(struct device *dev,
1399 struct device_attribute *attr, char *buf)
1400{
1401 unsigned long val;
1402 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1403
1404 val = drvdata->ctxid_mask;
1405 return sprintf(buf, "%#lx\n", val);
1406}
1407
1408static ssize_t ctxid_mask_store(struct device *dev,
1409 struct device_attribute *attr,
1410 const char *buf, size_t size)
1411{
1412 int ret;
1413 unsigned long val;
1414 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1415
1416 ret = kstrtoul(buf, 16, &val);
1417 if (ret)
1418 return ret;
1419
1420 drvdata->ctxid_mask = val;
1421 return size;
1422}
1423static DEVICE_ATTR_RW(ctxid_mask);
1424
1425static ssize_t sync_freq_show(struct device *dev,
1426 struct device_attribute *attr, char *buf)
1427{
1428 unsigned long val;
1429 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1430
1431 val = drvdata->sync_freq;
1432 return sprintf(buf, "%#lx\n", val);
1433}
1434
1435static ssize_t sync_freq_store(struct device *dev,
1436 struct device_attribute *attr,
1437 const char *buf, size_t size)
1438{
1439 int ret;
1440 unsigned long val;
1441 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1442
1443 ret = kstrtoul(buf, 16, &val);
1444 if (ret)
1445 return ret;
1446
1447 drvdata->sync_freq = val & ETM_SYNC_MASK;
1448 return size;
1449}
1450static DEVICE_ATTR_RW(sync_freq);
1451
1452static ssize_t timestamp_event_show(struct device *dev,
1453 struct device_attribute *attr, char *buf)
1454{
1455 unsigned long val;
1456 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1457
1458 val = drvdata->timestamp_event;
1459 return sprintf(buf, "%#lx\n", val);
1460}
1461
1462static ssize_t timestamp_event_store(struct device *dev,
1463 struct device_attribute *attr,
1464 const char *buf, size_t size)
1465{
1466 int ret;
1467 unsigned long val;
1468 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1469
1470 ret = kstrtoul(buf, 16, &val);
1471 if (ret)
1472 return ret;
1473
1474 drvdata->timestamp_event = val & ETM_EVENT_MASK;
1475 return size;
1476}
1477static DEVICE_ATTR_RW(timestamp_event);
1478
1479static ssize_t cpu_show(struct device *dev,
1480 struct device_attribute *attr, char *buf)
1481{
1482 int val;
1483 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1484
1485 val = drvdata->cpu;
1486 return scnprintf(buf, PAGE_SIZE, "%d\n", val);
1487
1488}
1489static DEVICE_ATTR_RO(cpu);
1490
1491static ssize_t traceid_show(struct device *dev,
1492 struct device_attribute *attr, char *buf)
1493{
1494 unsigned long val, flags;
1495 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1496
1497 if (!drvdata->enable) {
1498 val = drvdata->traceid;
1499 goto out;
1500 }
1501
1502 pm_runtime_get_sync(drvdata->dev);
1503 spin_lock_irqsave(&drvdata->spinlock, flags);
1504 CS_UNLOCK(drvdata->base);
1505
1506 val = (etm_readl(drvdata, ETMTRACEIDR) & ETM_TRACEID_MASK);
1507
1508 CS_LOCK(drvdata->base);
1509 spin_unlock_irqrestore(&drvdata->spinlock, flags);
1510 pm_runtime_put(drvdata->dev);
1511out:
1512 return sprintf(buf, "%#lx\n", val);
1513}
1514
1515static ssize_t traceid_store(struct device *dev,
1516 struct device_attribute *attr,
1517 const char *buf, size_t size)
1518{
1519 int ret;
1520 unsigned long val;
1521 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1522
1523 ret = kstrtoul(buf, 16, &val);
1524 if (ret)
1525 return ret;
1526
1527 drvdata->traceid = val & ETM_TRACEID_MASK;
1528 return size;
1529}
1530static DEVICE_ATTR_RW(traceid);
1531
1532static struct attribute *coresight_etm_attrs[] = {
1533 &dev_attr_nr_addr_cmp.attr,
1534 &dev_attr_nr_cntr.attr,
1535 &dev_attr_nr_ctxid_cmp.attr,
1536 &dev_attr_etmsr.attr,
1537 &dev_attr_reset.attr,
1538 &dev_attr_mode.attr,
1539 &dev_attr_trigger_event.attr,
1540 &dev_attr_enable_event.attr,
1541 &dev_attr_fifofull_level.attr,
1542 &dev_attr_addr_idx.attr,
1543 &dev_attr_addr_single.attr,
1544 &dev_attr_addr_range.attr,
1545 &dev_attr_addr_start.attr,
1546 &dev_attr_addr_stop.attr,
1547 &dev_attr_addr_acctype.attr,
1548 &dev_attr_cntr_idx.attr,
1549 &dev_attr_cntr_rld_val.attr,
1550 &dev_attr_cntr_event.attr,
1551 &dev_attr_cntr_rld_event.attr,
1552 &dev_attr_cntr_val.attr,
1553 &dev_attr_seq_12_event.attr,
1554 &dev_attr_seq_21_event.attr,
1555 &dev_attr_seq_23_event.attr,
1556 &dev_attr_seq_31_event.attr,
1557 &dev_attr_seq_32_event.attr,
1558 &dev_attr_seq_13_event.attr,
1559 &dev_attr_seq_curr_state.attr,
1560 &dev_attr_ctxid_idx.attr,
1561 &dev_attr_ctxid_pid.attr,
1562 &dev_attr_ctxid_mask.attr,
1563 &dev_attr_sync_freq.attr,
1564 &dev_attr_timestamp_event.attr,
1565 &dev_attr_traceid.attr,
1566 &dev_attr_cpu.attr,
1567 NULL,
1568};
1569
1570#define coresight_simple_func(name, offset) \
1571static ssize_t name##_show(struct device *_dev, \
1572 struct device_attribute *attr, char *buf) \
1573{ \
1574 struct etm_drvdata *drvdata = dev_get_drvdata(_dev->parent); \
1575 return scnprintf(buf, PAGE_SIZE, "0x%x\n", \
1576 readl_relaxed(drvdata->base + offset)); \
1577} \
1578DEVICE_ATTR_RO(name)
1579
1580coresight_simple_func(etmccr, ETMCCR);
1581coresight_simple_func(etmccer, ETMCCER);
1582coresight_simple_func(etmscr, ETMSCR);
1583coresight_simple_func(etmidr, ETMIDR);
1584coresight_simple_func(etmcr, ETMCR);
1585coresight_simple_func(etmtraceidr, ETMTRACEIDR);
1586coresight_simple_func(etmteevr, ETMTEEVR);
1587coresight_simple_func(etmtssvr, ETMTSSCR);
1588coresight_simple_func(etmtecr1, ETMTECR1);
1589coresight_simple_func(etmtecr2, ETMTECR2);
1590
1591static struct attribute *coresight_etm_mgmt_attrs[] = {
1592 &dev_attr_etmccr.attr,
1593 &dev_attr_etmccer.attr,
1594 &dev_attr_etmscr.attr,
1595 &dev_attr_etmidr.attr,
1596 &dev_attr_etmcr.attr,
1597 &dev_attr_etmtraceidr.attr,
1598 &dev_attr_etmteevr.attr,
1599 &dev_attr_etmtssvr.attr,
1600 &dev_attr_etmtecr1.attr,
1601 &dev_attr_etmtecr2.attr,
1602 NULL,
1603};
1604
1605static const struct attribute_group coresight_etm_group = {
1606 .attrs = coresight_etm_attrs,
1607};
1608
1609
1610static const struct attribute_group coresight_etm_mgmt_group = {
1611 .attrs = coresight_etm_mgmt_attrs,
1612 .name = "mgmt",
1613};
1614
1615static const struct attribute_group *coresight_etm_groups[] = {
1616 &coresight_etm_group,
1617 &coresight_etm_mgmt_group,
1618 NULL,
1619};
1620
1621static int etm_cpu_callback(struct notifier_block *nfb, unsigned long action, 421static int etm_cpu_callback(struct notifier_block *nfb, unsigned long action,
1622 void *hcpu) 422 void *hcpu)
1623{ 423{
generated by cgit v1.2.2 (git 2.25.0) at 2025-09-01 20:55:56 -0400