1
2
3
4
5
6
7#include <linux/pid_namespace.h>
8#include <linux/pm_runtime.h>
9#include <linux/sysfs.h>
10#include "coresight-etm4x.h"
11#include "coresight-priv.h"
12#include "coresight-syscfg.h"
13
14static int etm4_set_mode_exclude(struct etmv4_drvdata *drvdata, bool exclude)
15{
16 u8 idx;
17 struct etmv4_config *config = &drvdata->config;
18
19 idx = config->addr_idx;
20
21
22
23
24
25 if (BMVAL(config->addr_acc[idx], 0, 1) == ETM_INSTR_ADDR) {
26 if (idx % 2 != 0)
27 return -EINVAL;
28
29
30
31
32
33
34 if (config->addr_type[idx] != ETM_ADDR_TYPE_RANGE ||
35 config->addr_type[idx + 1] != ETM_ADDR_TYPE_RANGE)
36 return -EINVAL;
37
38 if (exclude == true) {
39
40
41
42
43 config->viiectlr |= BIT(idx / 2 + 16);
44 config->viiectlr &= ~BIT(idx / 2);
45 } else {
46
47
48
49
50 config->viiectlr |= BIT(idx / 2);
51 config->viiectlr &= ~BIT(idx / 2 + 16);
52 }
53 }
54 return 0;
55}
56
57static ssize_t nr_pe_cmp_show(struct device *dev,
58 struct device_attribute *attr,
59 char *buf)
60{
61 unsigned long val;
62 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
63
64 val = drvdata->nr_pe_cmp;
65 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
66}
67static DEVICE_ATTR_RO(nr_pe_cmp);
68
69static ssize_t nr_addr_cmp_show(struct device *dev,
70 struct device_attribute *attr,
71 char *buf)
72{
73 unsigned long val;
74 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
75
76 val = drvdata->nr_addr_cmp;
77 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
78}
79static DEVICE_ATTR_RO(nr_addr_cmp);
80
81static ssize_t nr_cntr_show(struct device *dev,
82 struct device_attribute *attr,
83 char *buf)
84{
85 unsigned long val;
86 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
87
88 val = drvdata->nr_cntr;
89 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
90}
91static DEVICE_ATTR_RO(nr_cntr);
92
93static ssize_t nr_ext_inp_show(struct device *dev,
94 struct device_attribute *attr,
95 char *buf)
96{
97 unsigned long val;
98 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
99
100 val = drvdata->nr_ext_inp;
101 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
102}
103static DEVICE_ATTR_RO(nr_ext_inp);
104
105static ssize_t numcidc_show(struct device *dev,
106 struct device_attribute *attr,
107 char *buf)
108{
109 unsigned long val;
110 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
111
112 val = drvdata->numcidc;
113 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
114}
115static DEVICE_ATTR_RO(numcidc);
116
117static ssize_t numvmidc_show(struct device *dev,
118 struct device_attribute *attr,
119 char *buf)
120{
121 unsigned long val;
122 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
123
124 val = drvdata->numvmidc;
125 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
126}
127static DEVICE_ATTR_RO(numvmidc);
128
129static ssize_t nrseqstate_show(struct device *dev,
130 struct device_attribute *attr,
131 char *buf)
132{
133 unsigned long val;
134 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
135
136 val = drvdata->nrseqstate;
137 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
138}
139static DEVICE_ATTR_RO(nrseqstate);
140
141static ssize_t nr_resource_show(struct device *dev,
142 struct device_attribute *attr,
143 char *buf)
144{
145 unsigned long val;
146 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
147
148 val = drvdata->nr_resource;
149 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
150}
151static DEVICE_ATTR_RO(nr_resource);
152
153static ssize_t nr_ss_cmp_show(struct device *dev,
154 struct device_attribute *attr,
155 char *buf)
156{
157 unsigned long val;
158 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
159
160 val = drvdata->nr_ss_cmp;
161 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
162}
163static DEVICE_ATTR_RO(nr_ss_cmp);
164
165static ssize_t reset_store(struct device *dev,
166 struct device_attribute *attr,
167 const char *buf, size_t size)
168{
169 int i;
170 unsigned long val;
171 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
172 struct etmv4_config *config = &drvdata->config;
173
174 if (kstrtoul(buf, 16, &val))
175 return -EINVAL;
176
177 spin_lock(&drvdata->spinlock);
178 if (val)
179 config->mode = 0x0;
180
181
182 config->mode &= ~(ETM_MODE_LOAD | ETM_MODE_STORE);
183 config->cfg &= ~(BIT(1) | BIT(2));
184
185
186 config->mode &= ~(ETM_MODE_DATA_TRACE_ADDR |
187 ETM_MODE_DATA_TRACE_VAL);
188 config->cfg &= ~(BIT(16) | BIT(17));
189
190
191 config->eventctrl0 = 0x0;
192 config->eventctrl1 = 0x0;
193
194
195 config->ts_ctrl = 0x0;
196
197
198 config->stall_ctrl = 0x0;
199
200
201 if (drvdata->syncpr == false)
202 config->syncfreq = 0x8;
203
204
205
206
207
208
209 config->vinst_ctrl = BIT(0);
210 if (drvdata->nr_addr_cmp > 0) {
211 config->mode |= ETM_MODE_VIEWINST_STARTSTOP;
212
213 config->vinst_ctrl |= BIT(9);
214 }
215
216
217 config->viiectlr = 0x0;
218
219
220 config->vissctlr = 0x0;
221 config->vipcssctlr = 0x0;
222
223
224 for (i = 0; i < drvdata->nrseqstate-1; i++)
225 config->seq_ctrl[i] = 0x0;
226 config->seq_rst = 0x0;
227 config->seq_state = 0x0;
228
229
230 config->ext_inp = 0x0;
231
232 config->cntr_idx = 0x0;
233 for (i = 0; i < drvdata->nr_cntr; i++) {
234 config->cntrldvr[i] = 0x0;
235 config->cntr_ctrl[i] = 0x0;
236 config->cntr_val[i] = 0x0;
237 }
238
239 config->res_idx = 0x0;
240 for (i = 2; i < 2 * drvdata->nr_resource; i++)
241 config->res_ctrl[i] = 0x0;
242
243 config->ss_idx = 0x0;
244 for (i = 0; i < drvdata->nr_ss_cmp; i++) {
245 config->ss_ctrl[i] = 0x0;
246 config->ss_pe_cmp[i] = 0x0;
247 }
248
249 config->addr_idx = 0x0;
250 for (i = 0; i < drvdata->nr_addr_cmp * 2; i++) {
251 config->addr_val[i] = 0x0;
252 config->addr_acc[i] = 0x0;
253 config->addr_type[i] = ETM_ADDR_TYPE_NONE;
254 }
255
256 config->ctxid_idx = 0x0;
257 for (i = 0; i < drvdata->numcidc; i++)
258 config->ctxid_pid[i] = 0x0;
259
260 config->ctxid_mask0 = 0x0;
261 config->ctxid_mask1 = 0x0;
262
263 config->vmid_idx = 0x0;
264 for (i = 0; i < drvdata->numvmidc; i++)
265 config->vmid_val[i] = 0x0;
266 config->vmid_mask0 = 0x0;
267 config->vmid_mask1 = 0x0;
268
269 drvdata->trcid = drvdata->cpu + 1;
270
271 spin_unlock(&drvdata->spinlock);
272
273 cscfg_csdev_reset_feats(to_coresight_device(dev));
274
275 return size;
276}
277static DEVICE_ATTR_WO(reset);
278
279static ssize_t mode_show(struct device *dev,
280 struct device_attribute *attr,
281 char *buf)
282{
283 unsigned long val;
284 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
285 struct etmv4_config *config = &drvdata->config;
286
287 val = config->mode;
288 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
289}
290
291static ssize_t mode_store(struct device *dev,
292 struct device_attribute *attr,
293 const char *buf, size_t size)
294{
295 unsigned long val, mode;
296 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
297 struct etmv4_config *config = &drvdata->config;
298
299 if (kstrtoul(buf, 16, &val))
300 return -EINVAL;
301
302 spin_lock(&drvdata->spinlock);
303 config->mode = val & ETMv4_MODE_ALL;
304
305 if (drvdata->instrp0 == true) {
306
307 config->cfg &= ~(BIT(1) | BIT(2));
308 if (config->mode & ETM_MODE_LOAD)
309
310 config->cfg |= BIT(1);
311 if (config->mode & ETM_MODE_STORE)
312
313 config->cfg |= BIT(2);
314 if (config->mode & ETM_MODE_LOAD_STORE)
315
316
317
318
319 config->cfg |= BIT(1) | BIT(2);
320 }
321
322
323 if ((config->mode & ETM_MODE_BB) && (drvdata->trcbb == true))
324 config->cfg |= BIT(3);
325 else
326 config->cfg &= ~BIT(3);
327
328
329 if ((config->mode & ETMv4_MODE_CYCACC) &&
330 (drvdata->trccci == true))
331 config->cfg |= BIT(4);
332 else
333 config->cfg &= ~BIT(4);
334
335
336 if ((config->mode & ETMv4_MODE_CTXID) && (drvdata->ctxid_size))
337 config->cfg |= BIT(6);
338 else
339 config->cfg &= ~BIT(6);
340
341 if ((config->mode & ETM_MODE_VMID) && (drvdata->vmid_size))
342 config->cfg |= BIT(7);
343 else
344 config->cfg &= ~BIT(7);
345
346
347 mode = ETM_MODE_COND(config->mode);
348 if (drvdata->trccond == true) {
349 config->cfg &= ~(BIT(8) | BIT(9) | BIT(10));
350 config->cfg |= mode << 8;
351 }
352
353
354 if ((config->mode & ETMv4_MODE_TIMESTAMP) && (drvdata->ts_size))
355 config->cfg |= BIT(11);
356 else
357 config->cfg &= ~BIT(11);
358
359
360 if ((config->mode & ETM_MODE_RETURNSTACK) &&
361 (drvdata->retstack == true))
362 config->cfg |= BIT(12);
363 else
364 config->cfg &= ~BIT(12);
365
366
367 mode = ETM_MODE_QELEM(config->mode);
368
369 config->cfg &= ~(BIT(13) | BIT(14));
370
371 if ((mode & BIT(0)) && (drvdata->q_support & BIT(0)))
372 config->cfg |= BIT(13);
373
374
375
376
377 if ((mode & BIT(1)) && (drvdata->q_support & BIT(1)))
378 config->cfg |= BIT(14);
379
380
381 if ((config->mode & ETM_MODE_ATB_TRIGGER) &&
382 (drvdata->atbtrig == true))
383 config->eventctrl1 |= BIT(11);
384 else
385 config->eventctrl1 &= ~BIT(11);
386
387
388 if ((config->mode & ETM_MODE_LPOVERRIDE) &&
389 (drvdata->lpoverride == true))
390 config->eventctrl1 |= BIT(12);
391 else
392 config->eventctrl1 &= ~BIT(12);
393
394
395 if ((config->mode & ETM_MODE_ISTALL_EN) && (drvdata->stallctl == true))
396 config->stall_ctrl |= BIT(8);
397 else
398 config->stall_ctrl &= ~BIT(8);
399
400
401 if (config->mode & ETM_MODE_INSTPRIO)
402 config->stall_ctrl |= BIT(10);
403 else
404 config->stall_ctrl &= ~BIT(10);
405
406
407 if ((config->mode & ETM_MODE_NOOVERFLOW) &&
408 (drvdata->nooverflow == true))
409 config->stall_ctrl |= BIT(13);
410 else
411 config->stall_ctrl &= ~BIT(13);
412
413
414 if (config->mode & ETM_MODE_VIEWINST_STARTSTOP)
415 config->vinst_ctrl |= BIT(9);
416 else
417 config->vinst_ctrl &= ~BIT(9);
418
419
420 if (config->mode & ETM_MODE_TRACE_RESET)
421 config->vinst_ctrl |= BIT(10);
422 else
423 config->vinst_ctrl &= ~BIT(10);
424
425
426 if ((config->mode & ETM_MODE_TRACE_ERR) &&
427 (drvdata->trc_error == true))
428 config->vinst_ctrl |= BIT(11);
429 else
430 config->vinst_ctrl &= ~BIT(11);
431
432 if (config->mode & (ETM_MODE_EXCL_KERN | ETM_MODE_EXCL_USER))
433 etm4_config_trace_mode(config);
434
435 spin_unlock(&drvdata->spinlock);
436
437 return size;
438}
439static DEVICE_ATTR_RW(mode);
440
441static ssize_t pe_show(struct device *dev,
442 struct device_attribute *attr,
443 char *buf)
444{
445 unsigned long val;
446 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
447 struct etmv4_config *config = &drvdata->config;
448
449 val = config->pe_sel;
450 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
451}
452
453static ssize_t pe_store(struct device *dev,
454 struct device_attribute *attr,
455 const char *buf, size_t size)
456{
457 unsigned long val;
458 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
459 struct etmv4_config *config = &drvdata->config;
460
461 if (kstrtoul(buf, 16, &val))
462 return -EINVAL;
463
464 spin_lock(&drvdata->spinlock);
465 if (val > drvdata->nr_pe) {
466 spin_unlock(&drvdata->spinlock);
467 return -EINVAL;
468 }
469
470 config->pe_sel = val;
471 spin_unlock(&drvdata->spinlock);
472 return size;
473}
474static DEVICE_ATTR_RW(pe);
475
476static ssize_t event_show(struct device *dev,
477 struct device_attribute *attr,
478 char *buf)
479{
480 unsigned long val;
481 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
482 struct etmv4_config *config = &drvdata->config;
483
484 val = config->eventctrl0;
485 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
486}
487
488static ssize_t event_store(struct device *dev,
489 struct device_attribute *attr,
490 const char *buf, size_t size)
491{
492 unsigned long val;
493 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
494 struct etmv4_config *config = &drvdata->config;
495
496 if (kstrtoul(buf, 16, &val))
497 return -EINVAL;
498
499 spin_lock(&drvdata->spinlock);
500 switch (drvdata->nr_event) {
501 case 0x0:
502
503 config->eventctrl0 = val & 0xFF;
504 break;
505 case 0x1:
506
507 config->eventctrl0 = val & 0xFFFF;
508 break;
509 case 0x2:
510
511 config->eventctrl0 = val & 0xFFFFFF;
512 break;
513 case 0x3:
514
515 config->eventctrl0 = val;
516 break;
517 default:
518 break;
519 }
520 spin_unlock(&drvdata->spinlock);
521 return size;
522}
523static DEVICE_ATTR_RW(event);
524
525static ssize_t event_instren_show(struct device *dev,
526 struct device_attribute *attr,
527 char *buf)
528{
529 unsigned long val;
530 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
531 struct etmv4_config *config = &drvdata->config;
532
533 val = BMVAL(config->eventctrl1, 0, 3);
534 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
535}
536
537static ssize_t event_instren_store(struct device *dev,
538 struct device_attribute *attr,
539 const char *buf, size_t size)
540{
541 unsigned long val;
542 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
543 struct etmv4_config *config = &drvdata->config;
544
545 if (kstrtoul(buf, 16, &val))
546 return -EINVAL;
547
548 spin_lock(&drvdata->spinlock);
549
550 config->eventctrl1 &= ~(BIT(0) | BIT(1) | BIT(2) | BIT(3));
551 switch (drvdata->nr_event) {
552 case 0x0:
553
554 config->eventctrl1 |= val & BIT(1);
555 break;
556 case 0x1:
557
558 config->eventctrl1 |= val & (BIT(0) | BIT(1));
559 break;
560 case 0x2:
561
562 config->eventctrl1 |= val & (BIT(0) | BIT(1) | BIT(2));
563 break;
564 case 0x3:
565
566 config->eventctrl1 |= val & 0xF;
567 break;
568 default:
569 break;
570 }
571 spin_unlock(&drvdata->spinlock);
572 return size;
573}
574static DEVICE_ATTR_RW(event_instren);
575
576static ssize_t event_ts_show(struct device *dev,
577 struct device_attribute *attr,
578 char *buf)
579{
580 unsigned long val;
581 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
582 struct etmv4_config *config = &drvdata->config;
583
584 val = config->ts_ctrl;
585 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
586}
587
588static ssize_t event_ts_store(struct device *dev,
589 struct device_attribute *attr,
590 const char *buf, size_t size)
591{
592 unsigned long val;
593 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
594 struct etmv4_config *config = &drvdata->config;
595
596 if (kstrtoul(buf, 16, &val))
597 return -EINVAL;
598 if (!drvdata->ts_size)
599 return -EINVAL;
600
601 config->ts_ctrl = val & ETMv4_EVENT_MASK;
602 return size;
603}
604static DEVICE_ATTR_RW(event_ts);
605
606static ssize_t syncfreq_show(struct device *dev,
607 struct device_attribute *attr,
608 char *buf)
609{
610 unsigned long val;
611 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
612 struct etmv4_config *config = &drvdata->config;
613
614 val = config->syncfreq;
615 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
616}
617
618static ssize_t syncfreq_store(struct device *dev,
619 struct device_attribute *attr,
620 const char *buf, size_t size)
621{
622 unsigned long val;
623 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
624 struct etmv4_config *config = &drvdata->config;
625
626 if (kstrtoul(buf, 16, &val))
627 return -EINVAL;
628 if (drvdata->syncpr == true)
629 return -EINVAL;
630
631 config->syncfreq = val & ETMv4_SYNC_MASK;
632 return size;
633}
634static DEVICE_ATTR_RW(syncfreq);
635
636static ssize_t cyc_threshold_show(struct device *dev,
637 struct device_attribute *attr,
638 char *buf)
639{
640 unsigned long val;
641 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
642 struct etmv4_config *config = &drvdata->config;
643
644 val = config->ccctlr;
645 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
646}
647
648static ssize_t cyc_threshold_store(struct device *dev,
649 struct device_attribute *attr,
650 const char *buf, size_t size)
651{
652 unsigned long val;
653 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
654 struct etmv4_config *config = &drvdata->config;
655
656 if (kstrtoul(buf, 16, &val))
657 return -EINVAL;
658
659
660 val &= ETM_CYC_THRESHOLD_MASK;
661 if (val < drvdata->ccitmin)
662 return -EINVAL;
663
664 config->ccctlr = val;
665 return size;
666}
667static DEVICE_ATTR_RW(cyc_threshold);
668
669static ssize_t bb_ctrl_show(struct device *dev,
670 struct device_attribute *attr,
671 char *buf)
672{
673 unsigned long val;
674 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
675 struct etmv4_config *config = &drvdata->config;
676
677 val = config->bb_ctrl;
678 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
679}
680
681static ssize_t bb_ctrl_store(struct device *dev,
682 struct device_attribute *attr,
683 const char *buf, size_t size)
684{
685 unsigned long val;
686 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
687 struct etmv4_config *config = &drvdata->config;
688
689 if (kstrtoul(buf, 16, &val))
690 return -EINVAL;
691 if (drvdata->trcbb == false)
692 return -EINVAL;
693 if (!drvdata->nr_addr_cmp)
694 return -EINVAL;
695
696
697
698
699
700
701 if ((val & BIT(8)) && (BMVAL(val, 0, 7) == 0))
702 return -EINVAL;
703
704 config->bb_ctrl = val & GENMASK(8, 0);
705 return size;
706}
707static DEVICE_ATTR_RW(bb_ctrl);
708
709static ssize_t event_vinst_show(struct device *dev,
710 struct device_attribute *attr,
711 char *buf)
712{
713 unsigned long val;
714 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
715 struct etmv4_config *config = &drvdata->config;
716
717 val = config->vinst_ctrl & ETMv4_EVENT_MASK;
718 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
719}
720
721static ssize_t event_vinst_store(struct device *dev,
722 struct device_attribute *attr,
723 const char *buf, size_t size)
724{
725 unsigned long val;
726 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
727 struct etmv4_config *config = &drvdata->config;
728
729 if (kstrtoul(buf, 16, &val))
730 return -EINVAL;
731
732 spin_lock(&drvdata->spinlock);
733 val &= ETMv4_EVENT_MASK;
734 config->vinst_ctrl &= ~ETMv4_EVENT_MASK;
735 config->vinst_ctrl |= val;
736 spin_unlock(&drvdata->spinlock);
737 return size;
738}
739static DEVICE_ATTR_RW(event_vinst);
740
741static ssize_t s_exlevel_vinst_show(struct device *dev,
742 struct device_attribute *attr,
743 char *buf)
744{
745 unsigned long val;
746 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
747 struct etmv4_config *config = &drvdata->config;
748
749 val = (config->vinst_ctrl & TRCVICTLR_EXLEVEL_S_MASK) >> TRCVICTLR_EXLEVEL_S_SHIFT;
750 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
751}
752
753static ssize_t s_exlevel_vinst_store(struct device *dev,
754 struct device_attribute *attr,
755 const char *buf, size_t size)
756{
757 unsigned long val;
758 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
759 struct etmv4_config *config = &drvdata->config;
760
761 if (kstrtoul(buf, 16, &val))
762 return -EINVAL;
763
764 spin_lock(&drvdata->spinlock);
765
766 config->vinst_ctrl &= ~(TRCVICTLR_EXLEVEL_S_MASK);
767
768 val &= drvdata->s_ex_level;
769 config->vinst_ctrl |= (val << TRCVICTLR_EXLEVEL_S_SHIFT);
770 spin_unlock(&drvdata->spinlock);
771 return size;
772}
773static DEVICE_ATTR_RW(s_exlevel_vinst);
774
775static ssize_t ns_exlevel_vinst_show(struct device *dev,
776 struct device_attribute *attr,
777 char *buf)
778{
779 unsigned long val;
780 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
781 struct etmv4_config *config = &drvdata->config;
782
783
784 val = (config->vinst_ctrl & TRCVICTLR_EXLEVEL_NS_MASK) >> TRCVICTLR_EXLEVEL_NS_SHIFT;
785 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
786}
787
788static ssize_t ns_exlevel_vinst_store(struct device *dev,
789 struct device_attribute *attr,
790 const char *buf, size_t size)
791{
792 unsigned long val;
793 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
794 struct etmv4_config *config = &drvdata->config;
795
796 if (kstrtoul(buf, 16, &val))
797 return -EINVAL;
798
799 spin_lock(&drvdata->spinlock);
800
801 config->vinst_ctrl &= ~(TRCVICTLR_EXLEVEL_NS_MASK);
802
803 val &= drvdata->ns_ex_level;
804 config->vinst_ctrl |= (val << TRCVICTLR_EXLEVEL_NS_SHIFT);
805 spin_unlock(&drvdata->spinlock);
806 return size;
807}
808static DEVICE_ATTR_RW(ns_exlevel_vinst);
809
810static ssize_t addr_idx_show(struct device *dev,
811 struct device_attribute *attr,
812 char *buf)
813{
814 unsigned long val;
815 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
816 struct etmv4_config *config = &drvdata->config;
817
818 val = config->addr_idx;
819 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
820}
821
822static ssize_t addr_idx_store(struct device *dev,
823 struct device_attribute *attr,
824 const char *buf, size_t size)
825{
826 unsigned long val;
827 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
828 struct etmv4_config *config = &drvdata->config;
829
830 if (kstrtoul(buf, 16, &val))
831 return -EINVAL;
832 if (val >= drvdata->nr_addr_cmp * 2)
833 return -EINVAL;
834
835
836
837
838
839 spin_lock(&drvdata->spinlock);
840 config->addr_idx = val;
841 spin_unlock(&drvdata->spinlock);
842 return size;
843}
844static DEVICE_ATTR_RW(addr_idx);
845
846static ssize_t addr_instdatatype_show(struct device *dev,
847 struct device_attribute *attr,
848 char *buf)
849{
850 ssize_t len;
851 u8 val, idx;
852 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
853 struct etmv4_config *config = &drvdata->config;
854
855 spin_lock(&drvdata->spinlock);
856 idx = config->addr_idx;
857 val = BMVAL(config->addr_acc[idx], 0, 1);
858 len = scnprintf(buf, PAGE_SIZE, "%s\n",
859 val == ETM_INSTR_ADDR ? "instr" :
860 (val == ETM_DATA_LOAD_ADDR ? "data_load" :
861 (val == ETM_DATA_STORE_ADDR ? "data_store" :
862 "data_load_store")));
863 spin_unlock(&drvdata->spinlock);
864 return len;
865}
866
867static ssize_t addr_instdatatype_store(struct device *dev,
868 struct device_attribute *attr,
869 const char *buf, size_t size)
870{
871 u8 idx;
872 char str[20] = "";
873 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
874 struct etmv4_config *config = &drvdata->config;
875
876 if (strlen(buf) >= 20)
877 return -EINVAL;
878 if (sscanf(buf, "%s", str) != 1)
879 return -EINVAL;
880
881 spin_lock(&drvdata->spinlock);
882 idx = config->addr_idx;
883 if (!strcmp(str, "instr"))
884
885 config->addr_acc[idx] &= ~(BIT(0) | BIT(1));
886
887 spin_unlock(&drvdata->spinlock);
888 return size;
889}
890static DEVICE_ATTR_RW(addr_instdatatype);
891
892static ssize_t addr_single_show(struct device *dev,
893 struct device_attribute *attr,
894 char *buf)
895{
896 u8 idx;
897 unsigned long val;
898 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
899 struct etmv4_config *config = &drvdata->config;
900
901 idx = config->addr_idx;
902 spin_lock(&drvdata->spinlock);
903 if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
904 config->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
905 spin_unlock(&drvdata->spinlock);
906 return -EPERM;
907 }
908 val = (unsigned long)config->addr_val[idx];
909 spin_unlock(&drvdata->spinlock);
910 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
911}
912
913static ssize_t addr_single_store(struct device *dev,
914 struct device_attribute *attr,
915 const char *buf, size_t size)
916{
917 u8 idx;
918 unsigned long val;
919 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
920 struct etmv4_config *config = &drvdata->config;
921
922 if (kstrtoul(buf, 16, &val))
923 return -EINVAL;
924
925 spin_lock(&drvdata->spinlock);
926 idx = config->addr_idx;
927 if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
928 config->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
929 spin_unlock(&drvdata->spinlock);
930 return -EPERM;
931 }
932
933 config->addr_val[idx] = (u64)val;
934 config->addr_type[idx] = ETM_ADDR_TYPE_SINGLE;
935 spin_unlock(&drvdata->spinlock);
936 return size;
937}
938static DEVICE_ATTR_RW(addr_single);
939
940static ssize_t addr_range_show(struct device *dev,
941 struct device_attribute *attr,
942 char *buf)
943{
944 u8 idx;
945 unsigned long val1, val2;
946 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
947 struct etmv4_config *config = &drvdata->config;
948
949 spin_lock(&drvdata->spinlock);
950 idx = config->addr_idx;
951 if (idx % 2 != 0) {
952 spin_unlock(&drvdata->spinlock);
953 return -EPERM;
954 }
955 if (!((config->addr_type[idx] == ETM_ADDR_TYPE_NONE &&
956 config->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
957 (config->addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
958 config->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
959 spin_unlock(&drvdata->spinlock);
960 return -EPERM;
961 }
962
963 val1 = (unsigned long)config->addr_val[idx];
964 val2 = (unsigned long)config->addr_val[idx + 1];
965 spin_unlock(&drvdata->spinlock);
966 return scnprintf(buf, PAGE_SIZE, "%#lx %#lx\n", val1, val2);
967}
968
969static ssize_t addr_range_store(struct device *dev,
970 struct device_attribute *attr,
971 const char *buf, size_t size)
972{
973 u8 idx;
974 unsigned long val1, val2;
975 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
976 struct etmv4_config *config = &drvdata->config;
977 int elements, exclude;
978
979 elements = sscanf(buf, "%lx %lx %x", &val1, &val2, &exclude);
980
981
982 if (elements < 2)
983 return -EINVAL;
984
985 if (val1 > val2)
986 return -EINVAL;
987
988 spin_lock(&drvdata->spinlock);
989 idx = config->addr_idx;
990 if (idx % 2 != 0) {
991 spin_unlock(&drvdata->spinlock);
992 return -EPERM;
993 }
994
995 if (!((config->addr_type[idx] == ETM_ADDR_TYPE_NONE &&
996 config->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
997 (config->addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
998 config->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
999 spin_unlock(&drvdata->spinlock);
1000 return -EPERM;
1001 }
1002
1003 config->addr_val[idx] = (u64)val1;
1004 config->addr_type[idx] = ETM_ADDR_TYPE_RANGE;
1005 config->addr_val[idx + 1] = (u64)val2;
1006 config->addr_type[idx + 1] = ETM_ADDR_TYPE_RANGE;
1007
1008
1009
1010
1011
1012 if (elements != 3)
1013 exclude = config->mode & ETM_MODE_EXCLUDE;
1014 etm4_set_mode_exclude(drvdata, exclude ? true : false);
1015
1016 spin_unlock(&drvdata->spinlock);
1017 return size;
1018}
1019static DEVICE_ATTR_RW(addr_range);
1020
1021static ssize_t addr_start_show(struct device *dev,
1022 struct device_attribute *attr,
1023 char *buf)
1024{
1025 u8 idx;
1026 unsigned long val;
1027 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1028 struct etmv4_config *config = &drvdata->config;
1029
1030 spin_lock(&drvdata->spinlock);
1031 idx = config->addr_idx;
1032
1033 if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
1034 config->addr_type[idx] == ETM_ADDR_TYPE_START)) {
1035 spin_unlock(&drvdata->spinlock);
1036 return -EPERM;
1037 }
1038
1039 val = (unsigned long)config->addr_val[idx];
1040 spin_unlock(&drvdata->spinlock);
1041 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1042}
1043
1044static ssize_t addr_start_store(struct device *dev,
1045 struct device_attribute *attr,
1046 const char *buf, size_t size)
1047{
1048 u8 idx;
1049 unsigned long val;
1050 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1051 struct etmv4_config *config = &drvdata->config;
1052
1053 if (kstrtoul(buf, 16, &val))
1054 return -EINVAL;
1055
1056 spin_lock(&drvdata->spinlock);
1057 idx = config->addr_idx;
1058 if (!drvdata->nr_addr_cmp) {
1059 spin_unlock(&drvdata->spinlock);
1060 return -EINVAL;
1061 }
1062 if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
1063 config->addr_type[idx] == ETM_ADDR_TYPE_START)) {
1064 spin_unlock(&drvdata->spinlock);
1065 return -EPERM;
1066 }
1067
1068 config->addr_val[idx] = (u64)val;
1069 config->addr_type[idx] = ETM_ADDR_TYPE_START;
1070 config->vissctlr |= BIT(idx);
1071 spin_unlock(&drvdata->spinlock);
1072 return size;
1073}
1074static DEVICE_ATTR_RW(addr_start);
1075
1076static ssize_t addr_stop_show(struct device *dev,
1077 struct device_attribute *attr,
1078 char *buf)
1079{
1080 u8 idx;
1081 unsigned long val;
1082 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1083 struct etmv4_config *config = &drvdata->config;
1084
1085 spin_lock(&drvdata->spinlock);
1086 idx = config->addr_idx;
1087
1088 if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
1089 config->addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
1090 spin_unlock(&drvdata->spinlock);
1091 return -EPERM;
1092 }
1093
1094 val = (unsigned long)config->addr_val[idx];
1095 spin_unlock(&drvdata->spinlock);
1096 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1097}
1098
1099static ssize_t addr_stop_store(struct device *dev,
1100 struct device_attribute *attr,
1101 const char *buf, size_t size)
1102{
1103 u8 idx;
1104 unsigned long val;
1105 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1106 struct etmv4_config *config = &drvdata->config;
1107
1108 if (kstrtoul(buf, 16, &val))
1109 return -EINVAL;
1110
1111 spin_lock(&drvdata->spinlock);
1112 idx = config->addr_idx;
1113 if (!drvdata->nr_addr_cmp) {
1114 spin_unlock(&drvdata->spinlock);
1115 return -EINVAL;
1116 }
1117 if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
1118 config->addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
1119 spin_unlock(&drvdata->spinlock);
1120 return -EPERM;
1121 }
1122
1123 config->addr_val[idx] = (u64)val;
1124 config->addr_type[idx] = ETM_ADDR_TYPE_STOP;
1125 config->vissctlr |= BIT(idx + 16);
1126 spin_unlock(&drvdata->spinlock);
1127 return size;
1128}
1129static DEVICE_ATTR_RW(addr_stop);
1130
1131static ssize_t addr_ctxtype_show(struct device *dev,
1132 struct device_attribute *attr,
1133 char *buf)
1134{
1135 ssize_t len;
1136 u8 idx, val;
1137 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1138 struct etmv4_config *config = &drvdata->config;
1139
1140 spin_lock(&drvdata->spinlock);
1141 idx = config->addr_idx;
1142
1143 val = BMVAL(config->addr_acc[idx], 2, 3);
1144 len = scnprintf(buf, PAGE_SIZE, "%s\n", val == ETM_CTX_NONE ? "none" :
1145 (val == ETM_CTX_CTXID ? "ctxid" :
1146 (val == ETM_CTX_VMID ? "vmid" : "all")));
1147 spin_unlock(&drvdata->spinlock);
1148 return len;
1149}
1150
1151static ssize_t addr_ctxtype_store(struct device *dev,
1152 struct device_attribute *attr,
1153 const char *buf, size_t size)
1154{
1155 u8 idx;
1156 char str[10] = "";
1157 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1158 struct etmv4_config *config = &drvdata->config;
1159
1160 if (strlen(buf) >= 10)
1161 return -EINVAL;
1162 if (sscanf(buf, "%s", str) != 1)
1163 return -EINVAL;
1164
1165 spin_lock(&drvdata->spinlock);
1166 idx = config->addr_idx;
1167 if (!strcmp(str, "none"))
1168
1169 config->addr_acc[idx] &= ~(BIT(2) | BIT(3));
1170 else if (!strcmp(str, "ctxid")) {
1171
1172 if (drvdata->numcidc) {
1173 config->addr_acc[idx] |= BIT(2);
1174 config->addr_acc[idx] &= ~BIT(3);
1175 }
1176 } else if (!strcmp(str, "vmid")) {
1177
1178 if (drvdata->numvmidc) {
1179 config->addr_acc[idx] &= ~BIT(2);
1180 config->addr_acc[idx] |= BIT(3);
1181 }
1182 } else if (!strcmp(str, "all")) {
1183
1184
1185
1186
1187 if (drvdata->numcidc)
1188 config->addr_acc[idx] |= BIT(2);
1189 if (drvdata->numvmidc)
1190 config->addr_acc[idx] |= BIT(3);
1191 }
1192 spin_unlock(&drvdata->spinlock);
1193 return size;
1194}
1195static DEVICE_ATTR_RW(addr_ctxtype);
1196
1197static ssize_t addr_context_show(struct device *dev,
1198 struct device_attribute *attr,
1199 char *buf)
1200{
1201 u8 idx;
1202 unsigned long val;
1203 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1204 struct etmv4_config *config = &drvdata->config;
1205
1206 spin_lock(&drvdata->spinlock);
1207 idx = config->addr_idx;
1208
1209 val = BMVAL(config->addr_acc[idx], 4, 6);
1210 spin_unlock(&drvdata->spinlock);
1211 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1212}
1213
1214static ssize_t addr_context_store(struct device *dev,
1215 struct device_attribute *attr,
1216 const char *buf, size_t size)
1217{
1218 u8 idx;
1219 unsigned long val;
1220 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1221 struct etmv4_config *config = &drvdata->config;
1222
1223 if (kstrtoul(buf, 16, &val))
1224 return -EINVAL;
1225 if ((drvdata->numcidc <= 1) && (drvdata->numvmidc <= 1))
1226 return -EINVAL;
1227 if (val >= (drvdata->numcidc >= drvdata->numvmidc ?
1228 drvdata->numcidc : drvdata->numvmidc))
1229 return -EINVAL;
1230
1231 spin_lock(&drvdata->spinlock);
1232 idx = config->addr_idx;
1233
1234 config->addr_acc[idx] &= ~(BIT(4) | BIT(5) | BIT(6));
1235 config->addr_acc[idx] |= (val << 4);
1236 spin_unlock(&drvdata->spinlock);
1237 return size;
1238}
1239static DEVICE_ATTR_RW(addr_context);
1240
1241static ssize_t addr_exlevel_s_ns_show(struct device *dev,
1242 struct device_attribute *attr,
1243 char *buf)
1244{
1245 u8 idx;
1246 unsigned long val;
1247 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1248 struct etmv4_config *config = &drvdata->config;
1249
1250 spin_lock(&drvdata->spinlock);
1251 idx = config->addr_idx;
1252 val = BMVAL(config->addr_acc[idx], 8, 14);
1253 spin_unlock(&drvdata->spinlock);
1254 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1255}
1256
1257static ssize_t addr_exlevel_s_ns_store(struct device *dev,
1258 struct device_attribute *attr,
1259 const char *buf, size_t size)
1260{
1261 u8 idx;
1262 unsigned long val;
1263 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1264 struct etmv4_config *config = &drvdata->config;
1265
1266 if (kstrtoul(buf, 0, &val))
1267 return -EINVAL;
1268
1269 if (val & ~((GENMASK(14, 8) >> 8)))
1270 return -EINVAL;
1271
1272 spin_lock(&drvdata->spinlock);
1273 idx = config->addr_idx;
1274
1275 config->addr_acc[idx] &= ~(GENMASK(14, 8));
1276 config->addr_acc[idx] |= (val << 8);
1277 spin_unlock(&drvdata->spinlock);
1278 return size;
1279}
1280static DEVICE_ATTR_RW(addr_exlevel_s_ns);
1281
1282static const char * const addr_type_names[] = {
1283 "unused",
1284 "single",
1285 "range",
1286 "start",
1287 "stop"
1288};
1289
1290static ssize_t addr_cmp_view_show(struct device *dev,
1291 struct device_attribute *attr, char *buf)
1292{
1293 u8 idx, addr_type;
1294 unsigned long addr_v, addr_v2, addr_ctrl;
1295 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1296 struct etmv4_config *config = &drvdata->config;
1297 int size = 0;
1298 bool exclude = false;
1299
1300 spin_lock(&drvdata->spinlock);
1301 idx = config->addr_idx;
1302 addr_v = config->addr_val[idx];
1303 addr_ctrl = config->addr_acc[idx];
1304 addr_type = config->addr_type[idx];
1305 if (addr_type == ETM_ADDR_TYPE_RANGE) {
1306 if (idx & 0x1) {
1307 idx -= 1;
1308 addr_v2 = addr_v;
1309 addr_v = config->addr_val[idx];
1310 } else {
1311 addr_v2 = config->addr_val[idx + 1];
1312 }
1313 exclude = config->viiectlr & BIT(idx / 2 + 16);
1314 }
1315 spin_unlock(&drvdata->spinlock);
1316 if (addr_type) {
1317 size = scnprintf(buf, PAGE_SIZE, "addr_cmp[%i] %s %#lx", idx,
1318 addr_type_names[addr_type], addr_v);
1319 if (addr_type == ETM_ADDR_TYPE_RANGE) {
1320 size += scnprintf(buf + size, PAGE_SIZE - size,
1321 " %#lx %s", addr_v2,
1322 exclude ? "exclude" : "include");
1323 }
1324 size += scnprintf(buf + size, PAGE_SIZE - size,
1325 " ctrl(%#lx)\n", addr_ctrl);
1326 } else {
1327 size = scnprintf(buf, PAGE_SIZE, "addr_cmp[%i] unused\n", idx);
1328 }
1329 return size;
1330}
1331static DEVICE_ATTR_RO(addr_cmp_view);
1332
1333static ssize_t vinst_pe_cmp_start_stop_show(struct device *dev,
1334 struct device_attribute *attr,
1335 char *buf)
1336{
1337 unsigned long val;
1338 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1339 struct etmv4_config *config = &drvdata->config;
1340
1341 if (!drvdata->nr_pe_cmp)
1342 return -EINVAL;
1343 val = config->vipcssctlr;
1344 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1345}
1346static ssize_t vinst_pe_cmp_start_stop_store(struct device *dev,
1347 struct device_attribute *attr,
1348 const char *buf, size_t size)
1349{
1350 unsigned long val;
1351 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1352 struct etmv4_config *config = &drvdata->config;
1353
1354 if (kstrtoul(buf, 16, &val))
1355 return -EINVAL;
1356 if (!drvdata->nr_pe_cmp)
1357 return -EINVAL;
1358
1359 spin_lock(&drvdata->spinlock);
1360 config->vipcssctlr = val;
1361 spin_unlock(&drvdata->spinlock);
1362 return size;
1363}
1364static DEVICE_ATTR_RW(vinst_pe_cmp_start_stop);
1365
1366static ssize_t seq_idx_show(struct device *dev,
1367 struct device_attribute *attr,
1368 char *buf)
1369{
1370 unsigned long val;
1371 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1372 struct etmv4_config *config = &drvdata->config;
1373
1374 val = config->seq_idx;
1375 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1376}
1377
1378static ssize_t seq_idx_store(struct device *dev,
1379 struct device_attribute *attr,
1380 const char *buf, size_t size)
1381{
1382 unsigned long val;
1383 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1384 struct etmv4_config *config = &drvdata->config;
1385
1386 if (kstrtoul(buf, 16, &val))
1387 return -EINVAL;
1388 if (val >= drvdata->nrseqstate - 1)
1389 return -EINVAL;
1390
1391
1392
1393
1394
1395 spin_lock(&drvdata->spinlock);
1396 config->seq_idx = val;
1397 spin_unlock(&drvdata->spinlock);
1398 return size;
1399}
1400static DEVICE_ATTR_RW(seq_idx);
1401
1402static ssize_t seq_state_show(struct device *dev,
1403 struct device_attribute *attr,
1404 char *buf)
1405{
1406 unsigned long val;
1407 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1408 struct etmv4_config *config = &drvdata->config;
1409
1410 val = config->seq_state;
1411 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1412}
1413
1414static ssize_t seq_state_store(struct device *dev,
1415 struct device_attribute *attr,
1416 const char *buf, size_t size)
1417{
1418 unsigned long val;
1419 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1420 struct etmv4_config *config = &drvdata->config;
1421
1422 if (kstrtoul(buf, 16, &val))
1423 return -EINVAL;
1424 if (val >= drvdata->nrseqstate)
1425 return -EINVAL;
1426
1427 config->seq_state = val;
1428 return size;
1429}
1430static DEVICE_ATTR_RW(seq_state);
1431
1432static ssize_t seq_event_show(struct device *dev,
1433 struct device_attribute *attr,
1434 char *buf)
1435{
1436 u8 idx;
1437 unsigned long val;
1438 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1439 struct etmv4_config *config = &drvdata->config;
1440
1441 spin_lock(&drvdata->spinlock);
1442 idx = config->seq_idx;
1443 val = config->seq_ctrl[idx];
1444 spin_unlock(&drvdata->spinlock);
1445 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1446}
1447
1448static ssize_t seq_event_store(struct device *dev,
1449 struct device_attribute *attr,
1450 const char *buf, size_t size)
1451{
1452 u8 idx;
1453 unsigned long val;
1454 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1455 struct etmv4_config *config = &drvdata->config;
1456
1457 if (kstrtoul(buf, 16, &val))
1458 return -EINVAL;
1459
1460 spin_lock(&drvdata->spinlock);
1461 idx = config->seq_idx;
1462
1463 config->seq_ctrl[idx] = val & 0xFFFF;
1464 spin_unlock(&drvdata->spinlock);
1465 return size;
1466}
1467static DEVICE_ATTR_RW(seq_event);
1468
1469static ssize_t seq_reset_event_show(struct device *dev,
1470 struct device_attribute *attr,
1471 char *buf)
1472{
1473 unsigned long val;
1474 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1475 struct etmv4_config *config = &drvdata->config;
1476
1477 val = config->seq_rst;
1478 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1479}
1480
1481static ssize_t seq_reset_event_store(struct device *dev,
1482 struct device_attribute *attr,
1483 const char *buf, size_t size)
1484{
1485 unsigned long val;
1486 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1487 struct etmv4_config *config = &drvdata->config;
1488
1489 if (kstrtoul(buf, 16, &val))
1490 return -EINVAL;
1491 if (!(drvdata->nrseqstate))
1492 return -EINVAL;
1493
1494 config->seq_rst = val & ETMv4_EVENT_MASK;
1495 return size;
1496}
1497static DEVICE_ATTR_RW(seq_reset_event);
1498
1499static ssize_t cntr_idx_show(struct device *dev,
1500 struct device_attribute *attr,
1501 char *buf)
1502{
1503 unsigned long val;
1504 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1505 struct etmv4_config *config = &drvdata->config;
1506
1507 val = config->cntr_idx;
1508 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1509}
1510
1511static ssize_t cntr_idx_store(struct device *dev,
1512 struct device_attribute *attr,
1513 const char *buf, size_t size)
1514{
1515 unsigned long val;
1516 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1517 struct etmv4_config *config = &drvdata->config;
1518
1519 if (kstrtoul(buf, 16, &val))
1520 return -EINVAL;
1521 if (val >= drvdata->nr_cntr)
1522 return -EINVAL;
1523
1524
1525
1526
1527
1528 spin_lock(&drvdata->spinlock);
1529 config->cntr_idx = val;
1530 spin_unlock(&drvdata->spinlock);
1531 return size;
1532}
1533static DEVICE_ATTR_RW(cntr_idx);
1534
1535static ssize_t cntrldvr_show(struct device *dev,
1536 struct device_attribute *attr,
1537 char *buf)
1538{
1539 u8 idx;
1540 unsigned long val;
1541 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1542 struct etmv4_config *config = &drvdata->config;
1543
1544 spin_lock(&drvdata->spinlock);
1545 idx = config->cntr_idx;
1546 val = config->cntrldvr[idx];
1547 spin_unlock(&drvdata->spinlock);
1548 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1549}
1550
1551static ssize_t cntrldvr_store(struct device *dev,
1552 struct device_attribute *attr,
1553 const char *buf, size_t size)
1554{
1555 u8 idx;
1556 unsigned long val;
1557 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1558 struct etmv4_config *config = &drvdata->config;
1559
1560 if (kstrtoul(buf, 16, &val))
1561 return -EINVAL;
1562 if (val > ETM_CNTR_MAX_VAL)
1563 return -EINVAL;
1564
1565 spin_lock(&drvdata->spinlock);
1566 idx = config->cntr_idx;
1567 config->cntrldvr[idx] = val;
1568 spin_unlock(&drvdata->spinlock);
1569 return size;
1570}
1571static DEVICE_ATTR_RW(cntrldvr);
1572
1573static ssize_t cntr_val_show(struct device *dev,
1574 struct device_attribute *attr,
1575 char *buf)
1576{
1577 u8 idx;
1578 unsigned long val;
1579 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1580 struct etmv4_config *config = &drvdata->config;
1581
1582 spin_lock(&drvdata->spinlock);
1583 idx = config->cntr_idx;
1584 val = config->cntr_val[idx];
1585 spin_unlock(&drvdata->spinlock);
1586 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1587}
1588
1589static ssize_t cntr_val_store(struct device *dev,
1590 struct device_attribute *attr,
1591 const char *buf, size_t size)
1592{
1593 u8 idx;
1594 unsigned long val;
1595 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1596 struct etmv4_config *config = &drvdata->config;
1597
1598 if (kstrtoul(buf, 16, &val))
1599 return -EINVAL;
1600 if (val > ETM_CNTR_MAX_VAL)
1601 return -EINVAL;
1602
1603 spin_lock(&drvdata->spinlock);
1604 idx = config->cntr_idx;
1605 config->cntr_val[idx] = val;
1606 spin_unlock(&drvdata->spinlock);
1607 return size;
1608}
1609static DEVICE_ATTR_RW(cntr_val);
1610
1611static ssize_t cntr_ctrl_show(struct device *dev,
1612 struct device_attribute *attr,
1613 char *buf)
1614{
1615 u8 idx;
1616 unsigned long val;
1617 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1618 struct etmv4_config *config = &drvdata->config;
1619
1620 spin_lock(&drvdata->spinlock);
1621 idx = config->cntr_idx;
1622 val = config->cntr_ctrl[idx];
1623 spin_unlock(&drvdata->spinlock);
1624 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1625}
1626
1627static ssize_t cntr_ctrl_store(struct device *dev,
1628 struct device_attribute *attr,
1629 const char *buf, size_t size)
1630{
1631 u8 idx;
1632 unsigned long val;
1633 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1634 struct etmv4_config *config = &drvdata->config;
1635
1636 if (kstrtoul(buf, 16, &val))
1637 return -EINVAL;
1638
1639 spin_lock(&drvdata->spinlock);
1640 idx = config->cntr_idx;
1641 config->cntr_ctrl[idx] = val;
1642 spin_unlock(&drvdata->spinlock);
1643 return size;
1644}
1645static DEVICE_ATTR_RW(cntr_ctrl);
1646
1647static ssize_t res_idx_show(struct device *dev,
1648 struct device_attribute *attr,
1649 char *buf)
1650{
1651 unsigned long val;
1652 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1653 struct etmv4_config *config = &drvdata->config;
1654
1655 val = config->res_idx;
1656 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1657}
1658
1659static ssize_t res_idx_store(struct device *dev,
1660 struct device_attribute *attr,
1661 const char *buf, size_t size)
1662{
1663 unsigned long val;
1664 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1665 struct etmv4_config *config = &drvdata->config;
1666
1667 if (kstrtoul(buf, 16, &val))
1668 return -EINVAL;
1669
1670
1671
1672
1673 if ((val < 2) || (val >= 2 * drvdata->nr_resource))
1674 return -EINVAL;
1675
1676
1677
1678
1679
1680 spin_lock(&drvdata->spinlock);
1681 config->res_idx = val;
1682 spin_unlock(&drvdata->spinlock);
1683 return size;
1684}
1685static DEVICE_ATTR_RW(res_idx);
1686
1687static ssize_t res_ctrl_show(struct device *dev,
1688 struct device_attribute *attr,
1689 char *buf)
1690{
1691 u8 idx;
1692 unsigned long val;
1693 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1694 struct etmv4_config *config = &drvdata->config;
1695
1696 spin_lock(&drvdata->spinlock);
1697 idx = config->res_idx;
1698 val = config->res_ctrl[idx];
1699 spin_unlock(&drvdata->spinlock);
1700 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1701}
1702
1703static ssize_t res_ctrl_store(struct device *dev,
1704 struct device_attribute *attr,
1705 const char *buf, size_t size)
1706{
1707 u8 idx;
1708 unsigned long val;
1709 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1710 struct etmv4_config *config = &drvdata->config;
1711
1712 if (kstrtoul(buf, 16, &val))
1713 return -EINVAL;
1714
1715 spin_lock(&drvdata->spinlock);
1716 idx = config->res_idx;
1717
1718 if (idx % 2 != 0)
1719
1720 val &= ~BIT(21);
1721 config->res_ctrl[idx] = val & GENMASK(21, 0);
1722 spin_unlock(&drvdata->spinlock);
1723 return size;
1724}
1725static DEVICE_ATTR_RW(res_ctrl);
1726
1727static ssize_t sshot_idx_show(struct device *dev,
1728 struct device_attribute *attr, char *buf)
1729{
1730 unsigned long val;
1731 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1732 struct etmv4_config *config = &drvdata->config;
1733
1734 val = config->ss_idx;
1735 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1736}
1737
1738static ssize_t sshot_idx_store(struct device *dev,
1739 struct device_attribute *attr,
1740 const char *buf, size_t size)
1741{
1742 unsigned long val;
1743 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1744 struct etmv4_config *config = &drvdata->config;
1745
1746 if (kstrtoul(buf, 16, &val))
1747 return -EINVAL;
1748 if (val >= drvdata->nr_ss_cmp)
1749 return -EINVAL;
1750
1751 spin_lock(&drvdata->spinlock);
1752 config->ss_idx = val;
1753 spin_unlock(&drvdata->spinlock);
1754 return size;
1755}
1756static DEVICE_ATTR_RW(sshot_idx);
1757
1758static ssize_t sshot_ctrl_show(struct device *dev,
1759 struct device_attribute *attr,
1760 char *buf)
1761{
1762 unsigned long val;
1763 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1764 struct etmv4_config *config = &drvdata->config;
1765
1766 spin_lock(&drvdata->spinlock);
1767 val = config->ss_ctrl[config->ss_idx];
1768 spin_unlock(&drvdata->spinlock);
1769 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1770}
1771
1772static ssize_t sshot_ctrl_store(struct device *dev,
1773 struct device_attribute *attr,
1774 const char *buf, size_t size)
1775{
1776 u8 idx;
1777 unsigned long val;
1778 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1779 struct etmv4_config *config = &drvdata->config;
1780
1781 if (kstrtoul(buf, 16, &val))
1782 return -EINVAL;
1783
1784 spin_lock(&drvdata->spinlock);
1785 idx = config->ss_idx;
1786 config->ss_ctrl[idx] = val & GENMASK(24, 0);
1787
1788 config->ss_status[idx] &= ~BIT(31);
1789 spin_unlock(&drvdata->spinlock);
1790 return size;
1791}
1792static DEVICE_ATTR_RW(sshot_ctrl);
1793
1794static ssize_t sshot_status_show(struct device *dev,
1795 struct device_attribute *attr, char *buf)
1796{
1797 unsigned long val;
1798 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1799 struct etmv4_config *config = &drvdata->config;
1800
1801 spin_lock(&drvdata->spinlock);
1802 val = config->ss_status[config->ss_idx];
1803 spin_unlock(&drvdata->spinlock);
1804 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1805}
1806static DEVICE_ATTR_RO(sshot_status);
1807
1808static ssize_t sshot_pe_ctrl_show(struct device *dev,
1809 struct device_attribute *attr,
1810 char *buf)
1811{
1812 unsigned long val;
1813 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1814 struct etmv4_config *config = &drvdata->config;
1815
1816 spin_lock(&drvdata->spinlock);
1817 val = config->ss_pe_cmp[config->ss_idx];
1818 spin_unlock(&drvdata->spinlock);
1819 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1820}
1821
1822static ssize_t sshot_pe_ctrl_store(struct device *dev,
1823 struct device_attribute *attr,
1824 const char *buf, size_t size)
1825{
1826 u8 idx;
1827 unsigned long val;
1828 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1829 struct etmv4_config *config = &drvdata->config;
1830
1831 if (kstrtoul(buf, 16, &val))
1832 return -EINVAL;
1833
1834 spin_lock(&drvdata->spinlock);
1835 idx = config->ss_idx;
1836 config->ss_pe_cmp[idx] = val & GENMASK(7, 0);
1837
1838 config->ss_status[idx] &= ~BIT(31);
1839 spin_unlock(&drvdata->spinlock);
1840 return size;
1841}
1842static DEVICE_ATTR_RW(sshot_pe_ctrl);
1843
1844static ssize_t ctxid_idx_show(struct device *dev,
1845 struct device_attribute *attr,
1846 char *buf)
1847{
1848 unsigned long val;
1849 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1850 struct etmv4_config *config = &drvdata->config;
1851
1852 val = config->ctxid_idx;
1853 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1854}
1855
1856static ssize_t ctxid_idx_store(struct device *dev,
1857 struct device_attribute *attr,
1858 const char *buf, size_t size)
1859{
1860 unsigned long val;
1861 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1862 struct etmv4_config *config = &drvdata->config;
1863
1864 if (kstrtoul(buf, 16, &val))
1865 return -EINVAL;
1866 if (val >= drvdata->numcidc)
1867 return -EINVAL;
1868
1869
1870
1871
1872
1873 spin_lock(&drvdata->spinlock);
1874 config->ctxid_idx = val;
1875 spin_unlock(&drvdata->spinlock);
1876 return size;
1877}
1878static DEVICE_ATTR_RW(ctxid_idx);
1879
1880static ssize_t ctxid_pid_show(struct device *dev,
1881 struct device_attribute *attr,
1882 char *buf)
1883{
1884 u8 idx;
1885 unsigned long val;
1886 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1887 struct etmv4_config *config = &drvdata->config;
1888
1889
1890
1891
1892
1893 if (task_active_pid_ns(current) != &init_pid_ns)
1894 return -EINVAL;
1895
1896 spin_lock(&drvdata->spinlock);
1897 idx = config->ctxid_idx;
1898 val = (unsigned long)config->ctxid_pid[idx];
1899 spin_unlock(&drvdata->spinlock);
1900 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1901}
1902
1903static ssize_t ctxid_pid_store(struct device *dev,
1904 struct device_attribute *attr,
1905 const char *buf, size_t size)
1906{
1907 u8 idx;
1908 unsigned long pid;
1909 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1910 struct etmv4_config *config = &drvdata->config;
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921 if (task_active_pid_ns(current) != &init_pid_ns)
1922 return -EINVAL;
1923
1924
1925
1926
1927
1928
1929 if (!drvdata->ctxid_size || !drvdata->numcidc)
1930 return -EINVAL;
1931 if (kstrtoul(buf, 16, &pid))
1932 return -EINVAL;
1933
1934 spin_lock(&drvdata->spinlock);
1935 idx = config->ctxid_idx;
1936 config->ctxid_pid[idx] = (u64)pid;
1937 spin_unlock(&drvdata->spinlock);
1938 return size;
1939}
1940static DEVICE_ATTR_RW(ctxid_pid);
1941
1942static ssize_t ctxid_masks_show(struct device *dev,
1943 struct device_attribute *attr,
1944 char *buf)
1945{
1946 unsigned long val1, val2;
1947 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1948 struct etmv4_config *config = &drvdata->config;
1949
1950
1951
1952
1953
1954 if (task_active_pid_ns(current) != &init_pid_ns)
1955 return -EINVAL;
1956
1957 spin_lock(&drvdata->spinlock);
1958 val1 = config->ctxid_mask0;
1959 val2 = config->ctxid_mask1;
1960 spin_unlock(&drvdata->spinlock);
1961 return scnprintf(buf, PAGE_SIZE, "%#lx %#lx\n", val1, val2);
1962}
1963
1964static ssize_t ctxid_masks_store(struct device *dev,
1965 struct device_attribute *attr,
1966 const char *buf, size_t size)
1967{
1968 u8 i, j, maskbyte;
1969 unsigned long val1, val2, mask;
1970 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1971 struct etmv4_config *config = &drvdata->config;
1972 int nr_inputs;
1973
1974
1975
1976
1977
1978 if (task_active_pid_ns(current) != &init_pid_ns)
1979 return -EINVAL;
1980
1981
1982
1983
1984
1985
1986 if (!drvdata->ctxid_size || !drvdata->numcidc)
1987 return -EINVAL;
1988
1989 nr_inputs = sscanf(buf, "%lx %lx", &val1, &val2);
1990 if ((drvdata->numcidc > 4) && (nr_inputs != 2))
1991 return -EINVAL;
1992
1993 spin_lock(&drvdata->spinlock);
1994
1995
1996
1997
1998 switch (drvdata->numcidc) {
1999 case 0x1:
2000
2001 config->ctxid_mask0 = val1 & 0xFF;
2002 break;
2003 case 0x2:
2004
2005 config->ctxid_mask0 = val1 & 0xFFFF;
2006 break;
2007 case 0x3:
2008
2009 config->ctxid_mask0 = val1 & 0xFFFFFF;
2010 break;
2011 case 0x4:
2012
2013 config->ctxid_mask0 = val1;
2014 break;
2015 case 0x5:
2016
2017 config->ctxid_mask0 = val1;
2018 config->ctxid_mask1 = val2 & 0xFF;
2019 break;
2020 case 0x6:
2021
2022 config->ctxid_mask0 = val1;
2023 config->ctxid_mask1 = val2 & 0xFFFF;
2024 break;
2025 case 0x7:
2026
2027 config->ctxid_mask0 = val1;
2028 config->ctxid_mask1 = val2 & 0xFFFFFF;
2029 break;
2030 case 0x8:
2031
2032 config->ctxid_mask0 = val1;
2033 config->ctxid_mask1 = val2;
2034 break;
2035 default:
2036 break;
2037 }
2038
2039
2040
2041
2042
2043
2044 mask = config->ctxid_mask0;
2045 for (i = 0; i < drvdata->numcidc; i++) {
2046
2047 maskbyte = mask & ETMv4_EVENT_MASK;
2048
2049
2050
2051
2052 for (j = 0; j < 8; j++) {
2053 if (maskbyte & 1)
2054 config->ctxid_pid[i] &= ~(0xFFUL << (j * 8));
2055 maskbyte >>= 1;
2056 }
2057
2058 if (i == 3)
2059
2060 mask = config->ctxid_mask1;
2061 else
2062 mask >>= 0x8;
2063 }
2064
2065 spin_unlock(&drvdata->spinlock);
2066 return size;
2067}
2068static DEVICE_ATTR_RW(ctxid_masks);
2069
2070static ssize_t vmid_idx_show(struct device *dev,
2071 struct device_attribute *attr,
2072 char *buf)
2073{
2074 unsigned long val;
2075 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
2076 struct etmv4_config *config = &drvdata->config;
2077
2078 val = config->vmid_idx;
2079 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
2080}
2081
2082static ssize_t vmid_idx_store(struct device *dev,
2083 struct device_attribute *attr,
2084 const char *buf, size_t size)
2085{
2086 unsigned long val;
2087 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
2088 struct etmv4_config *config = &drvdata->config;
2089
2090 if (kstrtoul(buf, 16, &val))
2091 return -EINVAL;
2092 if (val >= drvdata->numvmidc)
2093 return -EINVAL;
2094
2095
2096
2097
2098
2099 spin_lock(&drvdata->spinlock);
2100 config->vmid_idx = val;
2101 spin_unlock(&drvdata->spinlock);
2102 return size;
2103}
2104static DEVICE_ATTR_RW(vmid_idx);
2105
2106static ssize_t vmid_val_show(struct device *dev,
2107 struct device_attribute *attr,
2108 char *buf)
2109{
2110 unsigned long val;
2111 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
2112 struct etmv4_config *config = &drvdata->config;
2113
2114 val = (unsigned long)config->vmid_val[config->vmid_idx];
2115 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
2116}
2117
2118static ssize_t vmid_val_store(struct device *dev,
2119 struct device_attribute *attr,
2120 const char *buf, size_t size)
2121{
2122 unsigned long val;
2123 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
2124 struct etmv4_config *config = &drvdata->config;
2125
2126
2127
2128
2129
2130 if (!drvdata->vmid_size || !drvdata->numvmidc)
2131 return -EINVAL;
2132 if (kstrtoul(buf, 16, &val))
2133 return -EINVAL;
2134
2135 spin_lock(&drvdata->spinlock);
2136 config->vmid_val[config->vmid_idx] = (u64)val;
2137 spin_unlock(&drvdata->spinlock);
2138 return size;
2139}
2140static DEVICE_ATTR_RW(vmid_val);
2141
2142static ssize_t vmid_masks_show(struct device *dev,
2143 struct device_attribute *attr, char *buf)
2144{
2145 unsigned long val1, val2;
2146 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
2147 struct etmv4_config *config = &drvdata->config;
2148
2149 spin_lock(&drvdata->spinlock);
2150 val1 = config->vmid_mask0;
2151 val2 = config->vmid_mask1;
2152 spin_unlock(&drvdata->spinlock);
2153 return scnprintf(buf, PAGE_SIZE, "%#lx %#lx\n", val1, val2);
2154}
2155
2156static ssize_t vmid_masks_store(struct device *dev,
2157 struct device_attribute *attr,
2158 const char *buf, size_t size)
2159{
2160 u8 i, j, maskbyte;
2161 unsigned long val1, val2, mask;
2162 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
2163 struct etmv4_config *config = &drvdata->config;
2164 int nr_inputs;
2165
2166
2167
2168
2169
2170 if (!drvdata->vmid_size || !drvdata->numvmidc)
2171 return -EINVAL;
2172
2173 nr_inputs = sscanf(buf, "%lx %lx", &val1, &val2);
2174 if ((drvdata->numvmidc > 4) && (nr_inputs != 2))
2175 return -EINVAL;
2176
2177 spin_lock(&drvdata->spinlock);
2178
2179
2180
2181
2182
2183 switch (drvdata->numvmidc) {
2184 case 0x1:
2185
2186 config->vmid_mask0 = val1 & 0xFF;
2187 break;
2188 case 0x2:
2189
2190 config->vmid_mask0 = val1 & 0xFFFF;
2191 break;
2192 case 0x3:
2193
2194 config->vmid_mask0 = val1 & 0xFFFFFF;
2195 break;
2196 case 0x4:
2197
2198 config->vmid_mask0 = val1;
2199 break;
2200 case 0x5:
2201
2202 config->vmid_mask0 = val1;
2203 config->vmid_mask1 = val2 & 0xFF;
2204 break;
2205 case 0x6:
2206
2207 config->vmid_mask0 = val1;
2208 config->vmid_mask1 = val2 & 0xFFFF;
2209 break;
2210 case 0x7:
2211
2212 config->vmid_mask0 = val1;
2213 config->vmid_mask1 = val2 & 0xFFFFFF;
2214 break;
2215 case 0x8:
2216
2217 config->vmid_mask0 = val1;
2218 config->vmid_mask1 = val2;
2219 break;
2220 default:
2221 break;
2222 }
2223
2224
2225
2226
2227
2228
2229
2230 mask = config->vmid_mask0;
2231 for (i = 0; i < drvdata->numvmidc; i++) {
2232
2233 maskbyte = mask & ETMv4_EVENT_MASK;
2234
2235
2236
2237
2238 for (j = 0; j < 8; j++) {
2239 if (maskbyte & 1)
2240 config->vmid_val[i] &= ~(0xFFUL << (j * 8));
2241 maskbyte >>= 1;
2242 }
2243
2244 if (i == 3)
2245
2246 mask = config->vmid_mask1;
2247 else
2248 mask >>= 0x8;
2249 }
2250 spin_unlock(&drvdata->spinlock);
2251 return size;
2252}
2253static DEVICE_ATTR_RW(vmid_masks);
2254
2255static ssize_t cpu_show(struct device *dev,
2256 struct device_attribute *attr, char *buf)
2257{
2258 int val;
2259 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
2260
2261 val = drvdata->cpu;
2262 return scnprintf(buf, PAGE_SIZE, "%d\n", val);
2263
2264}
2265static DEVICE_ATTR_RO(cpu);
2266
2267static struct attribute *coresight_etmv4_attrs[] = {
2268 &dev_attr_nr_pe_cmp.attr,
2269 &dev_attr_nr_addr_cmp.attr,
2270 &dev_attr_nr_cntr.attr,
2271 &dev_attr_nr_ext_inp.attr,
2272 &dev_attr_numcidc.attr,
2273 &dev_attr_numvmidc.attr,
2274 &dev_attr_nrseqstate.attr,
2275 &dev_attr_nr_resource.attr,
2276 &dev_attr_nr_ss_cmp.attr,
2277 &dev_attr_reset.attr,
2278 &dev_attr_mode.attr,
2279 &dev_attr_pe.attr,
2280 &dev_attr_event.attr,
2281 &dev_attr_event_instren.attr,
2282 &dev_attr_event_ts.attr,
2283 &dev_attr_syncfreq.attr,
2284 &dev_attr_cyc_threshold.attr,
2285 &dev_attr_bb_ctrl.attr,
2286 &dev_attr_event_vinst.attr,
2287 &dev_attr_s_exlevel_vinst.attr,
2288 &dev_attr_ns_exlevel_vinst.attr,
2289 &dev_attr_addr_idx.attr,
2290 &dev_attr_addr_instdatatype.attr,
2291 &dev_attr_addr_single.attr,
2292 &dev_attr_addr_range.attr,
2293 &dev_attr_addr_start.attr,
2294 &dev_attr_addr_stop.attr,
2295 &dev_attr_addr_ctxtype.attr,
2296 &dev_attr_addr_context.attr,
2297 &dev_attr_addr_exlevel_s_ns.attr,
2298 &dev_attr_addr_cmp_view.attr,
2299 &dev_attr_vinst_pe_cmp_start_stop.attr,
2300 &dev_attr_sshot_idx.attr,
2301 &dev_attr_sshot_ctrl.attr,
2302 &dev_attr_sshot_pe_ctrl.attr,
2303 &dev_attr_sshot_status.attr,
2304 &dev_attr_seq_idx.attr,
2305 &dev_attr_seq_state.attr,
2306 &dev_attr_seq_event.attr,
2307 &dev_attr_seq_reset_event.attr,
2308 &dev_attr_cntr_idx.attr,
2309 &dev_attr_cntrldvr.attr,
2310 &dev_attr_cntr_val.attr,
2311 &dev_attr_cntr_ctrl.attr,
2312 &dev_attr_res_idx.attr,
2313 &dev_attr_res_ctrl.attr,
2314 &dev_attr_ctxid_idx.attr,
2315 &dev_attr_ctxid_pid.attr,
2316 &dev_attr_ctxid_masks.attr,
2317 &dev_attr_vmid_idx.attr,
2318 &dev_attr_vmid_val.attr,
2319 &dev_attr_vmid_masks.attr,
2320 &dev_attr_cpu.attr,
2321 NULL,
2322};
2323
2324struct etmv4_reg {
2325 struct coresight_device *csdev;
2326 u32 offset;
2327 u32 data;
2328};
2329
2330static void do_smp_cross_read(void *data)
2331{
2332 struct etmv4_reg *reg = data;
2333
2334 reg->data = etm4x_relaxed_read32(®->csdev->access, reg->offset);
2335}
2336
2337static u32 etmv4_cross_read(const struct etmv4_drvdata *drvdata, u32 offset)
2338{
2339 struct etmv4_reg reg;
2340
2341 reg.offset = offset;
2342 reg.csdev = drvdata->csdev;
2343
2344
2345
2346
2347
2348 smp_call_function_single(drvdata->cpu, do_smp_cross_read, ®, 1);
2349 return reg.data;
2350}
2351
2352static inline u32 coresight_etm4x_attr_to_offset(struct device_attribute *attr)
2353{
2354 struct dev_ext_attribute *eattr;
2355
2356 eattr = container_of(attr, struct dev_ext_attribute, attr);
2357 return (u32)(unsigned long)eattr->var;
2358}
2359
2360static ssize_t coresight_etm4x_reg_show(struct device *dev,
2361 struct device_attribute *d_attr,
2362 char *buf)
2363{
2364 u32 val, offset;
2365 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
2366
2367 offset = coresight_etm4x_attr_to_offset(d_attr);
2368
2369 pm_runtime_get_sync(dev->parent);
2370 val = etmv4_cross_read(drvdata, offset);
2371 pm_runtime_put_sync(dev->parent);
2372
2373 return scnprintf(buf, PAGE_SIZE, "0x%x\n", val);
2374}
2375
2376static inline bool
2377etm4x_register_implemented(struct etmv4_drvdata *drvdata, u32 offset)
2378{
2379 switch (offset) {
2380 ETM_COMMON_SYSREG_LIST_CASES
2381
2382
2383
2384
2385 return true;
2386
2387 ETM4x_ONLY_SYSREG_LIST_CASES
2388
2389
2390
2391
2392 return !etm4x_is_ete(drvdata);
2393
2394 ETM4x_MMAP_LIST_CASES
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406 return !!drvdata->base;
2407
2408 ETE_ONLY_SYSREG_LIST_CASES
2409 return etm4x_is_ete(drvdata);
2410 }
2411
2412 return false;
2413}
2414
2415
2416
2417
2418
2419
2420
2421
2422static umode_t
2423coresight_etm4x_attr_reg_implemented(struct kobject *kobj,
2424 struct attribute *attr, int unused)
2425{
2426 struct device *dev = kobj_to_dev(kobj);
2427 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
2428 struct device_attribute *d_attr;
2429 u32 offset;
2430
2431 d_attr = container_of(attr, struct device_attribute, attr);
2432 offset = coresight_etm4x_attr_to_offset(d_attr);
2433
2434 if (etm4x_register_implemented(drvdata, offset))
2435 return attr->mode;
2436 return 0;
2437}
2438
2439#define coresight_etm4x_reg(name, offset) \
2440 &((struct dev_ext_attribute[]) { \
2441 { \
2442 __ATTR(name, 0444, coresight_etm4x_reg_show, NULL), \
2443 (void *)(unsigned long)offset \
2444 } \
2445 })[0].attr.attr
2446
2447static struct attribute *coresight_etmv4_mgmt_attrs[] = {
2448 coresight_etm4x_reg(trcpdcr, TRCPDCR),
2449 coresight_etm4x_reg(trcpdsr, TRCPDSR),
2450 coresight_etm4x_reg(trclsr, TRCLSR),
2451 coresight_etm4x_reg(trcauthstatus, TRCAUTHSTATUS),
2452 coresight_etm4x_reg(trcdevid, TRCDEVID),
2453 coresight_etm4x_reg(trcdevtype, TRCDEVTYPE),
2454 coresight_etm4x_reg(trcpidr0, TRCPIDR0),
2455 coresight_etm4x_reg(trcpidr1, TRCPIDR1),
2456 coresight_etm4x_reg(trcpidr2, TRCPIDR2),
2457 coresight_etm4x_reg(trcpidr3, TRCPIDR3),
2458 coresight_etm4x_reg(trcoslsr, TRCOSLSR),
2459 coresight_etm4x_reg(trcconfig, TRCCONFIGR),
2460 coresight_etm4x_reg(trctraceid, TRCTRACEIDR),
2461 coresight_etm4x_reg(trcdevarch, TRCDEVARCH),
2462 NULL,
2463};
2464
2465static struct attribute *coresight_etmv4_trcidr_attrs[] = {
2466 coresight_etm4x_reg(trcidr0, TRCIDR0),
2467 coresight_etm4x_reg(trcidr1, TRCIDR1),
2468 coresight_etm4x_reg(trcidr2, TRCIDR2),
2469 coresight_etm4x_reg(trcidr3, TRCIDR3),
2470 coresight_etm4x_reg(trcidr4, TRCIDR4),
2471 coresight_etm4x_reg(trcidr5, TRCIDR5),
2472
2473 coresight_etm4x_reg(trcidr8, TRCIDR8),
2474 coresight_etm4x_reg(trcidr9, TRCIDR9),
2475 coresight_etm4x_reg(trcidr10, TRCIDR10),
2476 coresight_etm4x_reg(trcidr11, TRCIDR11),
2477 coresight_etm4x_reg(trcidr12, TRCIDR12),
2478 coresight_etm4x_reg(trcidr13, TRCIDR13),
2479 NULL,
2480};
2481
2482static const struct attribute_group coresight_etmv4_group = {
2483 .attrs = coresight_etmv4_attrs,
2484};
2485
2486static const struct attribute_group coresight_etmv4_mgmt_group = {
2487 .is_visible = coresight_etm4x_attr_reg_implemented,
2488 .attrs = coresight_etmv4_mgmt_attrs,
2489 .name = "mgmt",
2490};
2491
2492static const struct attribute_group coresight_etmv4_trcidr_group = {
2493 .attrs = coresight_etmv4_trcidr_attrs,
2494 .name = "trcidr",
2495};
2496
2497const struct attribute_group *coresight_etmv4_groups[] = {
2498 &coresight_etmv4_group,
2499 &coresight_etmv4_mgmt_group,
2500 &coresight_etmv4_trcidr_group,
2501 NULL,
2502};
2503