]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - drivers/hwtracing/coresight/coresight-etm4x-sysfs.c
projects / mirror_ubuntu-zesty-kernel.git / blob
? search:


7c84308c55643440486517d26ca58b908e31188d
[mirror_ubuntu-zesty-kernel.git] / drivers / hwtracing / coresight / coresight-etm4x-sysfs.c
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-etm4x.h"
21
22 static int etm4_set_mode_exclude(struct etmv4_drvdata *drvdata, bool exclude)
23 {
24 u8 idx;
25 struct etmv4_config *config = &drvdata->config;
26
27 idx = config->addr_idx;
28
29 /*
30 * TRCACATRn.TYPE bit[1:0]: type of comparison
31 * the trace unit performs
32 */
33 if (BMVAL(config->addr_acc[idx], 0, 1) == ETM_INSTR_ADDR) {
34 if (idx % 2 != 0)
35 return -EINVAL;
36
37 /*
38 * We are performing instruction address comparison. Set the
39 * relevant bit of ViewInst Include/Exclude Control register
40 * for corresponding address comparator pair.
41 */
42 if (config->addr_type[idx] != ETM_ADDR_TYPE_RANGE ||
43 config->addr_type[idx + 1] != ETM_ADDR_TYPE_RANGE)
44 return -EINVAL;
45
46 if (exclude == true) {
47 /*
48 * Set exclude bit and unset the include bit
49 * corresponding to comparator pair
50 */
51 config->viiectlr |= BIT(idx / 2 + 16);
52 config->viiectlr &= ~BIT(idx / 2);
53 } else {
54 /*
55 * Set include bit and unset exclude bit
56 * corresponding to comparator pair
57 */
58 config->viiectlr |= BIT(idx / 2);
59 config->viiectlr &= ~BIT(idx / 2 + 16);
60 }
61 }
62 return 0;
63 }
64
65 static ssize_t nr_pe_cmp_show(struct device *dev,
66 struct device_attribute *attr,
67 char *buf)
68 {
69 unsigned long val;
70 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
71
72 val = drvdata->nr_pe_cmp;
73 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
74 }
75 static DEVICE_ATTR_RO(nr_pe_cmp);
76
77 static ssize_t nr_addr_cmp_show(struct device *dev,
78 struct device_attribute *attr,
79 char *buf)
80 {
81 unsigned long val;
82 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
83
84 val = drvdata->nr_addr_cmp;
85 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
86 }
87 static DEVICE_ATTR_RO(nr_addr_cmp);
88
89 static ssize_t nr_cntr_show(struct device *dev,
90 struct device_attribute *attr,
91 char *buf)
92 {
93 unsigned long val;
94 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
95
96 val = drvdata->nr_cntr;
97 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
98 }
99 static DEVICE_ATTR_RO(nr_cntr);
100
101 static ssize_t nr_ext_inp_show(struct device *dev,
102 struct device_attribute *attr,
103 char *buf)
104 {
105 unsigned long val;
106 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
107
108 val = drvdata->nr_ext_inp;
109 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
110 }
111 static DEVICE_ATTR_RO(nr_ext_inp);
112
113 static ssize_t numcidc_show(struct device *dev,
114 struct device_attribute *attr,
115 char *buf)
116 {
117 unsigned long val;
118 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
119
120 val = drvdata->numcidc;
121 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
122 }
123 static DEVICE_ATTR_RO(numcidc);
124
125 static ssize_t numvmidc_show(struct device *dev,
126 struct device_attribute *attr,
127 char *buf)
128 {
129 unsigned long val;
130 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
131
132 val = drvdata->numvmidc;
133 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
134 }
135 static DEVICE_ATTR_RO(numvmidc);
136
137 static ssize_t nrseqstate_show(struct device *dev,
138 struct device_attribute *attr,
139 char *buf)
140 {
141 unsigned long val;
142 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
143
144 val = drvdata->nrseqstate;
145 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
146 }
147 static DEVICE_ATTR_RO(nrseqstate);
148
149 static ssize_t nr_resource_show(struct device *dev,
150 struct device_attribute *attr,
151 char *buf)
152 {
153 unsigned long val;
154 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
155
156 val = drvdata->nr_resource;
157 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
158 }
159 static DEVICE_ATTR_RO(nr_resource);
160
161 static ssize_t nr_ss_cmp_show(struct device *dev,
162 struct device_attribute *attr,
163 char *buf)
164 {
165 unsigned long val;
166 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
167
168 val = drvdata->nr_ss_cmp;
169 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
170 }
171 static DEVICE_ATTR_RO(nr_ss_cmp);
172
173 static ssize_t reset_store(struct device *dev,
174 struct device_attribute *attr,
175 const char *buf, size_t size)
176 {
177 int i;
178 unsigned long val;
179 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
180 struct etmv4_config *config = &drvdata->config;
181
182 if (kstrtoul(buf, 16, &val))
183 return -EINVAL;
184
185 spin_lock(&drvdata->spinlock);
186 if (val)
187 config->mode = 0x0;
188
189 /* Disable data tracing: do not trace load and store data transfers */
190 config->mode &= ~(ETM_MODE_LOAD | ETM_MODE_STORE);
191 config->cfg &= ~(BIT(1) | BIT(2));
192
193 /* Disable data value and data address tracing */
194 config->mode &= ~(ETM_MODE_DATA_TRACE_ADDR |
195 ETM_MODE_DATA_TRACE_VAL);
196 config->cfg &= ~(BIT(16) | BIT(17));
197
198 /* Disable all events tracing */
199 config->eventctrl0 = 0x0;
200 config->eventctrl1 = 0x0;
201
202 /* Disable timestamp event */
203 config->ts_ctrl = 0x0;
204
205 /* Disable stalling */
206 config->stall_ctrl = 0x0;
207
208 /* Reset trace synchronization period to 2^8 = 256 bytes*/
209 if (drvdata->syncpr == false)
210 config->syncfreq = 0x8;
211
212 /*
213 * Enable ViewInst to trace everything with start-stop logic in
214 * started state. ARM recommends start-stop logic is set before
215 * each trace run.
216 */
217 config->vinst_ctrl |= BIT(0);
218 if (drvdata->nr_addr_cmp == true) {
219 config->mode |= ETM_MODE_VIEWINST_STARTSTOP;
220 /* SSSTATUS, bit[9] */
221 config->vinst_ctrl |= BIT(9);
222 }
223
224 /* No address range filtering for ViewInst */
225 config->viiectlr = 0x0;
226
227 /* No start-stop filtering for ViewInst */
228 config->vissctlr = 0x0;
229
230 /* Disable seq events */
231 for (i = 0; i < drvdata->nrseqstate-1; i++)
232 config->seq_ctrl[i] = 0x0;
233 config->seq_rst = 0x0;
234 config->seq_state = 0x0;
235
236 /* Disable external input events */
237 config->ext_inp = 0x0;
238
239 config->cntr_idx = 0x0;
240 for (i = 0; i < drvdata->nr_cntr; i++) {
241 config->cntrldvr[i] = 0x0;
242 config->cntr_ctrl[i] = 0x0;
243 config->cntr_val[i] = 0x0;
244 }
245
246 config->res_idx = 0x0;
247 for (i = 0; i < drvdata->nr_resource; i++)
248 config->res_ctrl[i] = 0x0;
249
250 for (i = 0; i < drvdata->nr_ss_cmp; i++) {
251 config->ss_ctrl[i] = 0x0;
252 config->ss_pe_cmp[i] = 0x0;
253 }
254
255 config->addr_idx = 0x0;
256 for (i = 0; i < drvdata->nr_addr_cmp * 2; i++) {
257 config->addr_val[i] = 0x0;
258 config->addr_acc[i] = 0x0;
259 config->addr_type[i] = ETM_ADDR_TYPE_NONE;
260 }
261
262 config->ctxid_idx = 0x0;
263 for (i = 0; i < drvdata->numcidc; i++) {
264 config->ctxid_pid[i] = 0x0;
265 config->ctxid_vpid[i] = 0x0;
266 }
267
268 config->ctxid_mask0 = 0x0;
269 config->ctxid_mask1 = 0x0;
270
271 config->vmid_idx = 0x0;
272 for (i = 0; i < drvdata->numvmidc; i++)
273 config->vmid_val[i] = 0x0;
274 config->vmid_mask0 = 0x0;
275 config->vmid_mask1 = 0x0;
276
277 drvdata->trcid = drvdata->cpu + 1;
278
279 spin_unlock(&drvdata->spinlock);
280
281 return size;
282 }
283 static DEVICE_ATTR_WO(reset);
284
285 static ssize_t mode_show(struct device *dev,
286 struct device_attribute *attr,
287 char *buf)
288 {
289 unsigned long val;
290 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
291 struct etmv4_config *config = &drvdata->config;
292
293 val = config->mode;
294 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
295 }
296
297 static ssize_t mode_store(struct device *dev,
298 struct device_attribute *attr,
299 const char *buf, size_t size)
300 {
301 unsigned long val, mode;
302 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
303 struct etmv4_config *config = &drvdata->config;
304
305 if (kstrtoul(buf, 16, &val))
306 return -EINVAL;
307
308 spin_lock(&drvdata->spinlock);
309 config->mode = val & ETMv4_MODE_ALL;
310
311 if (config->mode & ETM_MODE_EXCLUDE)
312 etm4_set_mode_exclude(drvdata, true);
313 else
314 etm4_set_mode_exclude(drvdata, false);
315
316 if (drvdata->instrp0 == true) {
317 /* start by clearing instruction P0 field */
318 config->cfg &= ~(BIT(1) | BIT(2));
319 if (config->mode & ETM_MODE_LOAD)
320 /* 0b01 Trace load instructions as P0 instructions */
321 config->cfg |= BIT(1);
322 if (config->mode & ETM_MODE_STORE)
323 /* 0b10 Trace store instructions as P0 instructions */
324 config->cfg |= BIT(2);
325 if (config->mode & ETM_MODE_LOAD_STORE)
326 /*
327 * 0b11 Trace load and store instructions
328 * as P0 instructions
329 */
330 config->cfg |= BIT(1) | BIT(2);
331 }
332
333 /* bit[3], Branch broadcast mode */
334 if ((config->mode & ETM_MODE_BB) && (drvdata->trcbb == true))
335 config->cfg |= BIT(3);
336 else
337 config->cfg &= ~BIT(3);
338
339 /* bit[4], Cycle counting instruction trace bit */
340 if ((config->mode & ETMv4_MODE_CYCACC) &&
341 (drvdata->trccci == true))
342 config->cfg |= BIT(4);
343 else
344 config->cfg &= ~BIT(4);
345
346 /* bit[6], Context ID tracing bit */
347 if ((config->mode & ETMv4_MODE_CTXID) && (drvdata->ctxid_size))
348 config->cfg |= BIT(6);
349 else
350 config->cfg &= ~BIT(6);
351
352 if ((config->mode & ETM_MODE_VMID) && (drvdata->vmid_size))
353 config->cfg |= BIT(7);
354 else
355 config->cfg &= ~BIT(7);
356
357 /* bits[10:8], Conditional instruction tracing bit */
358 mode = ETM_MODE_COND(config->mode);
359 if (drvdata->trccond == true) {
360 config->cfg &= ~(BIT(8) | BIT(9) | BIT(10));
361 config->cfg |= mode << 8;
362 }
363
364 /* bit[11], Global timestamp tracing bit */
365 if ((config->mode & ETMv4_MODE_TIMESTAMP) && (drvdata->ts_size))
366 config->cfg |= BIT(11);
367 else
368 config->cfg &= ~BIT(11);
369
370 /* bit[12], Return stack enable bit */
371 if ((config->mode & ETM_MODE_RETURNSTACK) &&
372 (drvdata->retstack == true))
373 config->cfg |= BIT(12);
374 else
375 config->cfg &= ~BIT(12);
376
377 /* bits[14:13], Q element enable field */
378 mode = ETM_MODE_QELEM(config->mode);
379 /* start by clearing QE bits */
380 config->cfg &= ~(BIT(13) | BIT(14));
381 /* if supported, Q elements with instruction counts are enabled */
382 if ((mode & BIT(0)) && (drvdata->q_support & BIT(0)))
383 config->cfg |= BIT(13);
384 /*
385 * if supported, Q elements with and without instruction
386 * counts are enabled
387 */
388 if ((mode & BIT(1)) && (drvdata->q_support & BIT(1)))
389 config->cfg |= BIT(14);
390
391 /* bit[11], AMBA Trace Bus (ATB) trigger enable bit */
392 if ((config->mode & ETM_MODE_ATB_TRIGGER) &&
393 (drvdata->atbtrig == true))
394 config->eventctrl1 |= BIT(11);
395 else
396 config->eventctrl1 &= ~BIT(11);
397
398 /* bit[12], Low-power state behavior override bit */
399 if ((config->mode & ETM_MODE_LPOVERRIDE) &&
400 (drvdata->lpoverride == true))
401 config->eventctrl1 |= BIT(12);
402 else
403 config->eventctrl1 &= ~BIT(12);
404
405 /* bit[8], Instruction stall bit */
406 if (config->mode & ETM_MODE_ISTALL_EN)
407 config->stall_ctrl |= BIT(8);
408 else
409 config->stall_ctrl &= ~BIT(8);
410
411 /* bit[10], Prioritize instruction trace bit */
412 if (config->mode & ETM_MODE_INSTPRIO)
413 config->stall_ctrl |= BIT(10);
414 else
415 config->stall_ctrl &= ~BIT(10);
416
417 /* bit[13], Trace overflow prevention bit */
418 if ((config->mode & ETM_MODE_NOOVERFLOW) &&
419 (drvdata->nooverflow == true))
420 config->stall_ctrl |= BIT(13);
421 else
422 config->stall_ctrl &= ~BIT(13);
423
424 /* bit[9] Start/stop logic control bit */
425 if (config->mode & ETM_MODE_VIEWINST_STARTSTOP)
426 config->vinst_ctrl |= BIT(9);
427 else
428 config->vinst_ctrl &= ~BIT(9);
429
430 /* bit[10], Whether a trace unit must trace a Reset exception */
431 if (config->mode & ETM_MODE_TRACE_RESET)
432 config->vinst_ctrl |= BIT(10);
433 else
434 config->vinst_ctrl &= ~BIT(10);
435
436 /* bit[11], Whether a trace unit must trace a system error exception */
437 if ((config->mode & ETM_MODE_TRACE_ERR) &&
438 (drvdata->trc_error == true))
439 config->vinst_ctrl |= BIT(11);
440 else
441 config->vinst_ctrl &= ~BIT(11);
442
443 if (config->mode & (ETM_MODE_EXCL_KERN | ETM_MODE_EXCL_USER))
444 etm4_config_trace_mode(config);
445
446 spin_unlock(&drvdata->spinlock);
447
448 return size;
449 }
450 static DEVICE_ATTR_RW(mode);
451
452 static ssize_t pe_show(struct device *dev,
453 struct device_attribute *attr,
454 char *buf)
455 {
456 unsigned long val;
457 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
458 struct etmv4_config *config = &drvdata->config;
459
460 val = config->pe_sel;
461 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
462 }
463
464 static ssize_t pe_store(struct device *dev,
465 struct device_attribute *attr,
466 const char *buf, size_t size)
467 {
468 unsigned long val;
469 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
470 struct etmv4_config *config = &drvdata->config;
471
472 if (kstrtoul(buf, 16, &val))
473 return -EINVAL;
474
475 spin_lock(&drvdata->spinlock);
476 if (val > drvdata->nr_pe) {
477 spin_unlock(&drvdata->spinlock);
478 return -EINVAL;
479 }
480
481 config->pe_sel = val;
482 spin_unlock(&drvdata->spinlock);
483 return size;
484 }
485 static DEVICE_ATTR_RW(pe);
486
487 static ssize_t event_show(struct device *dev,
488 struct device_attribute *attr,
489 char *buf)
490 {
491 unsigned long val;
492 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
493 struct etmv4_config *config = &drvdata->config;
494
495 val = config->eventctrl0;
496 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
497 }
498
499 static ssize_t event_store(struct device *dev,
500 struct device_attribute *attr,
501 const char *buf, size_t size)
502 {
503 unsigned long val;
504 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
505 struct etmv4_config *config = &drvdata->config;
506
507 if (kstrtoul(buf, 16, &val))
508 return -EINVAL;
509
510 spin_lock(&drvdata->spinlock);
511 switch (drvdata->nr_event) {
512 case 0x0:
513 /* EVENT0, bits[7:0] */
514 config->eventctrl0 = val & 0xFF;
515 break;
516 case 0x1:
517 /* EVENT1, bits[15:8] */
518 config->eventctrl0 = val & 0xFFFF;
519 break;
520 case 0x2:
521 /* EVENT2, bits[23:16] */
522 config->eventctrl0 = val & 0xFFFFFF;
523 break;
524 case 0x3:
525 /* EVENT3, bits[31:24] */
526 config->eventctrl0 = val;
527 break;
528 default:
529 break;
530 }
531 spin_unlock(&drvdata->spinlock);
532 return size;
533 }
534 static DEVICE_ATTR_RW(event);
535
536 static ssize_t event_instren_show(struct device *dev,
537 struct device_attribute *attr,
538 char *buf)
539 {
540 unsigned long val;
541 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
542 struct etmv4_config *config = &drvdata->config;
543
544 val = BMVAL(config->eventctrl1, 0, 3);
545 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
546 }
547
548 static ssize_t event_instren_store(struct device *dev,
549 struct device_attribute *attr,
550 const char *buf, size_t size)
551 {
552 unsigned long val;
553 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
554 struct etmv4_config *config = &drvdata->config;
555
556 if (kstrtoul(buf, 16, &val))
557 return -EINVAL;
558
559 spin_lock(&drvdata->spinlock);
560 /* start by clearing all instruction event enable bits */
561 config->eventctrl1 &= ~(BIT(0) | BIT(1) | BIT(2) | BIT(3));
562 switch (drvdata->nr_event) {
563 case 0x0:
564 /* generate Event element for event 1 */
565 config->eventctrl1 |= val & BIT(1);
566 break;
567 case 0x1:
568 /* generate Event element for event 1 and 2 */
569 config->eventctrl1 |= val & (BIT(0) | BIT(1));
570 break;
571 case 0x2:
572 /* generate Event element for event 1, 2 and 3 */
573 config->eventctrl1 |= val & (BIT(0) | BIT(1) | BIT(2));
574 break;
575 case 0x3:
576 /* generate Event element for all 4 events */
577 config->eventctrl1 |= val & 0xF;
578 break;
579 default:
580 break;
581 }
582 spin_unlock(&drvdata->spinlock);
583 return size;
584 }
585 static DEVICE_ATTR_RW(event_instren);
586
587 static ssize_t event_ts_show(struct device *dev,
588 struct device_attribute *attr,
589 char *buf)
590 {
591 unsigned long val;
592 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
593 struct etmv4_config *config = &drvdata->config;
594
595 val = config->ts_ctrl;
596 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
597 }
598
599 static ssize_t event_ts_store(struct device *dev,
600 struct device_attribute *attr,
601 const char *buf, size_t size)
602 {
603 unsigned long val;
604 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
605 struct etmv4_config *config = &drvdata->config;
606
607 if (kstrtoul(buf, 16, &val))
608 return -EINVAL;
609 if (!drvdata->ts_size)
610 return -EINVAL;
611
612 config->ts_ctrl = val & ETMv4_EVENT_MASK;
613 return size;
614 }
615 static DEVICE_ATTR_RW(event_ts);
616
617 static ssize_t syncfreq_show(struct device *dev,
618 struct device_attribute *attr,
619 char *buf)
620 {
621 unsigned long val;
622 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
623 struct etmv4_config *config = &drvdata->config;
624
625 val = config->syncfreq;
626 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
627 }
628
629 static ssize_t syncfreq_store(struct device *dev,
630 struct device_attribute *attr,
631 const char *buf, size_t size)
632 {
633 unsigned long val;
634 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
635 struct etmv4_config *config = &drvdata->config;
636
637 if (kstrtoul(buf, 16, &val))
638 return -EINVAL;
639 if (drvdata->syncpr == true)
640 return -EINVAL;
641
642 config->syncfreq = val & ETMv4_SYNC_MASK;
643 return size;
644 }
645 static DEVICE_ATTR_RW(syncfreq);
646
647 static ssize_t cyc_threshold_show(struct device *dev,
648 struct device_attribute *attr,
649 char *buf)
650 {
651 unsigned long val;
652 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
653 struct etmv4_config *config = &drvdata->config;
654
655 val = config->ccctlr;
656 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
657 }
658
659 static ssize_t cyc_threshold_store(struct device *dev,
660 struct device_attribute *attr,
661 const char *buf, size_t size)
662 {
663 unsigned long val;
664 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
665 struct etmv4_config *config = &drvdata->config;
666
667 if (kstrtoul(buf, 16, &val))
668 return -EINVAL;
669 if (val < drvdata->ccitmin)
670 return -EINVAL;
671
672 config->ccctlr = val & ETM_CYC_THRESHOLD_MASK;
673 return size;
674 }
675 static DEVICE_ATTR_RW(cyc_threshold);
676
677 static ssize_t bb_ctrl_show(struct device *dev,
678 struct device_attribute *attr,
679 char *buf)
680 {
681 unsigned long val;
682 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
683 struct etmv4_config *config = &drvdata->config;
684
685 val = config->bb_ctrl;
686 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
687 }
688
689 static ssize_t bb_ctrl_store(struct device *dev,
690 struct device_attribute *attr,
691 const char *buf, size_t size)
692 {
693 unsigned long val;
694 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
695 struct etmv4_config *config = &drvdata->config;
696
697 if (kstrtoul(buf, 16, &val))
698 return -EINVAL;
699 if (drvdata->trcbb == false)
700 return -EINVAL;
701 if (!drvdata->nr_addr_cmp)
702 return -EINVAL;
703 /*
704 * Bit[7:0] selects which address range comparator is used for
705 * branch broadcast control.
706 */
707 if (BMVAL(val, 0, 7) > drvdata->nr_addr_cmp)
708 return -EINVAL;
709
710 config->bb_ctrl = val;
711 return size;
712 }
713 static DEVICE_ATTR_RW(bb_ctrl);
714
715 static ssize_t event_vinst_show(struct device *dev,
716 struct device_attribute *attr,
717 char *buf)
718 {
719 unsigned long val;
720 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
721 struct etmv4_config *config = &drvdata->config;
722
723 val = config->vinst_ctrl & ETMv4_EVENT_MASK;
724 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
725 }
726
727 static ssize_t event_vinst_store(struct device *dev,
728 struct device_attribute *attr,
729 const char *buf, size_t size)
730 {
731 unsigned long val;
732 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
733 struct etmv4_config *config = &drvdata->config;
734
735 if (kstrtoul(buf, 16, &val))
736 return -EINVAL;
737
738 spin_lock(&drvdata->spinlock);
739 val &= ETMv4_EVENT_MASK;
740 config->vinst_ctrl &= ~ETMv4_EVENT_MASK;
741 config->vinst_ctrl |= val;
742 spin_unlock(&drvdata->spinlock);
743 return size;
744 }
745 static DEVICE_ATTR_RW(event_vinst);
746
747 static ssize_t s_exlevel_vinst_show(struct device *dev,
748 struct device_attribute *attr,
749 char *buf)
750 {
751 unsigned long val;
752 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
753 struct etmv4_config *config = &drvdata->config;
754
755 val = BMVAL(config->vinst_ctrl, 16, 19);
756 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
757 }
758
759 static ssize_t s_exlevel_vinst_store(struct device *dev,
760 struct device_attribute *attr,
761 const char *buf, size_t size)
762 {
763 unsigned long val;
764 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
765 struct etmv4_config *config = &drvdata->config;
766
767 if (kstrtoul(buf, 16, &val))
768 return -EINVAL;
769
770 spin_lock(&drvdata->spinlock);
771 /* clear all EXLEVEL_S bits (bit[18] is never implemented) */
772 config->vinst_ctrl &= ~(BIT(16) | BIT(17) | BIT(19));
773 /* enable instruction tracing for corresponding exception level */
774 val &= drvdata->s_ex_level;
775 config->vinst_ctrl |= (val << 16);
776 spin_unlock(&drvdata->spinlock);
777 return size;
778 }
779 static DEVICE_ATTR_RW(s_exlevel_vinst);
780
781 static ssize_t ns_exlevel_vinst_show(struct device *dev,
782 struct device_attribute *attr,
783 char *buf)
784 {
785 unsigned long val;
786 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
787 struct etmv4_config *config = &drvdata->config;
788
789 /* EXLEVEL_NS, bits[23:20] */
790 val = BMVAL(config->vinst_ctrl, 20, 23);
791 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
792 }
793
794 static ssize_t ns_exlevel_vinst_store(struct device *dev,
795 struct device_attribute *attr,
796 const char *buf, size_t size)
797 {
798 unsigned long val;
799 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
800 struct etmv4_config *config = &drvdata->config;
801
802 if (kstrtoul(buf, 16, &val))
803 return -EINVAL;
804
805 spin_lock(&drvdata->spinlock);
806 /* clear EXLEVEL_NS bits (bit[23] is never implemented */
807 config->vinst_ctrl &= ~(BIT(20) | BIT(21) | BIT(22));
808 /* enable instruction tracing for corresponding exception level */
809 val &= drvdata->ns_ex_level;
810 config->vinst_ctrl |= (val << 20);
811 spin_unlock(&drvdata->spinlock);
812 return size;
813 }
814 static DEVICE_ATTR_RW(ns_exlevel_vinst);
815
816 static ssize_t addr_idx_show(struct device *dev,
817 struct device_attribute *attr,
818 char *buf)
819 {
820 unsigned long val;
821 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
822 struct etmv4_config *config = &drvdata->config;
823
824 val = config->addr_idx;
825 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
826 }
827
828 static ssize_t addr_idx_store(struct device *dev,
829 struct device_attribute *attr,
830 const char *buf, size_t size)
831 {
832 unsigned long val;
833 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
834 struct etmv4_config *config = &drvdata->config;
835
836 if (kstrtoul(buf, 16, &val))
837 return -EINVAL;
838 if (val >= drvdata->nr_addr_cmp * 2)
839 return -EINVAL;
840
841 /*
842 * Use spinlock to ensure index doesn't change while it gets
843 * dereferenced multiple times within a spinlock block elsewhere.
844 */
845 spin_lock(&drvdata->spinlock);
846 config->addr_idx = val;
847 spin_unlock(&drvdata->spinlock);
848 return size;
849 }
850 static DEVICE_ATTR_RW(addr_idx);
851
852 static ssize_t addr_instdatatype_show(struct device *dev,
853 struct device_attribute *attr,
854 char *buf)
855 {
856 ssize_t len;
857 u8 val, idx;
858 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
859 struct etmv4_config *config = &drvdata->config;
860
861 spin_lock(&drvdata->spinlock);
862 idx = config->addr_idx;
863 val = BMVAL(config->addr_acc[idx], 0, 1);
864 len = scnprintf(buf, PAGE_SIZE, "%s\n",
865 val == ETM_INSTR_ADDR ? "instr" :
866 (val == ETM_DATA_LOAD_ADDR ? "data_load" :
867 (val == ETM_DATA_STORE_ADDR ? "data_store" :
868 "data_load_store")));
869 spin_unlock(&drvdata->spinlock);
870 return len;
871 }
872
873 static ssize_t addr_instdatatype_store(struct device *dev,
874 struct device_attribute *attr,
875 const char *buf, size_t size)
876 {
877 u8 idx;
878 char str[20] = "";
879 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
880 struct etmv4_config *config = &drvdata->config;
881
882 if (strlen(buf) >= 20)
883 return -EINVAL;
884 if (sscanf(buf, "%s", str) != 1)
885 return -EINVAL;
886
887 spin_lock(&drvdata->spinlock);
888 idx = config->addr_idx;
889 if (!strcmp(str, "instr"))
890 /* TYPE, bits[1:0] */
891 config->addr_acc[idx] &= ~(BIT(0) | BIT(1));
892
893 spin_unlock(&drvdata->spinlock);
894 return size;
895 }
896 static DEVICE_ATTR_RW(addr_instdatatype);
897
898 static ssize_t addr_single_show(struct device *dev,
899 struct device_attribute *attr,
900 char *buf)
901 {
902 u8 idx;
903 unsigned long val;
904 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
905 struct etmv4_config *config = &drvdata->config;
906
907 idx = config->addr_idx;
908 spin_lock(&drvdata->spinlock);
909 if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
910 config->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
911 spin_unlock(&drvdata->spinlock);
912 return -EPERM;
913 }
914 val = (unsigned long)config->addr_val[idx];
915 spin_unlock(&drvdata->spinlock);
916 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
917 }
918
919 static ssize_t addr_single_store(struct device *dev,
920 struct device_attribute *attr,
921 const char *buf, size_t size)
922 {
923 u8 idx;
924 unsigned long val;
925 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
926 struct etmv4_config *config = &drvdata->config;
927
928 if (kstrtoul(buf, 16, &val))
929 return -EINVAL;
930
931 spin_lock(&drvdata->spinlock);
932 idx = config->addr_idx;
933 if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
934 config->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
935 spin_unlock(&drvdata->spinlock);
936 return -EPERM;
937 }
938
939 config->addr_val[idx] = (u64)val;
940 config->addr_type[idx] = ETM_ADDR_TYPE_SINGLE;
941 spin_unlock(&drvdata->spinlock);
942 return size;
943 }
944 static DEVICE_ATTR_RW(addr_single);
945
946 static ssize_t addr_range_show(struct device *dev,
947 struct device_attribute *attr,
948 char *buf)
949 {
950 u8 idx;
951 unsigned long val1, val2;
952 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
953 struct etmv4_config *config = &drvdata->config;
954
955 spin_lock(&drvdata->spinlock);
956 idx = config->addr_idx;
957 if (idx % 2 != 0) {
958 spin_unlock(&drvdata->spinlock);
959 return -EPERM;
960 }
961 if (!((config->addr_type[idx] == ETM_ADDR_TYPE_NONE &&
962 config->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
963 (config->addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
964 config->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
965 spin_unlock(&drvdata->spinlock);
966 return -EPERM;
967 }
968
969 val1 = (unsigned long)config->addr_val[idx];
970 val2 = (unsigned long)config->addr_val[idx + 1];
971 spin_unlock(&drvdata->spinlock);
972 return scnprintf(buf, PAGE_SIZE, "%#lx %#lx\n", val1, val2);
973 }
974
975 static ssize_t addr_range_store(struct device *dev,
976 struct device_attribute *attr,
977 const char *buf, size_t size)
978 {
979 u8 idx;
980 unsigned long val1, val2;
981 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
982 struct etmv4_config *config = &drvdata->config;
983
984 if (sscanf(buf, "%lx %lx", &val1, &val2) != 2)
985 return -EINVAL;
986 /* lower address comparator cannot have a higher address value */
987 if (val1 > val2)
988 return -EINVAL;
989
990 spin_lock(&drvdata->spinlock);
991 idx = config->addr_idx;
992 if (idx % 2 != 0) {
993 spin_unlock(&drvdata->spinlock);
994 return -EPERM;
995 }
996
997 if (!((config->addr_type[idx] == ETM_ADDR_TYPE_NONE &&
998 config->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
999 (config->addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
1000 config->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
1001 spin_unlock(&drvdata->spinlock);
1002 return -EPERM;
1003 }
1004
1005 config->addr_val[idx] = (u64)val1;
1006 config->addr_type[idx] = ETM_ADDR_TYPE_RANGE;
1007 config->addr_val[idx + 1] = (u64)val2;
1008 config->addr_type[idx + 1] = ETM_ADDR_TYPE_RANGE;
1009 /*
1010 * Program include or exclude control bits for vinst or vdata
1011 * whenever we change addr comparators to ETM_ADDR_TYPE_RANGE
1012 */
1013 if (config->mode & ETM_MODE_EXCLUDE)
1014 etm4_set_mode_exclude(drvdata, true);
1015 else
1016 etm4_set_mode_exclude(drvdata, false);
1017
1018 spin_unlock(&drvdata->spinlock);
1019 return size;
1020 }
1021 static DEVICE_ATTR_RW(addr_range);
1022
1023 static ssize_t addr_start_show(struct device *dev,
1024 struct device_attribute *attr,
1025 char *buf)
1026 {
1027 u8 idx;
1028 unsigned long val;
1029 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1030 struct etmv4_config *config = &drvdata->config;
1031
1032 spin_lock(&drvdata->spinlock);
1033 idx = config->addr_idx;
1034
1035 if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
1036 config->addr_type[idx] == ETM_ADDR_TYPE_START)) {
1037 spin_unlock(&drvdata->spinlock);
1038 return -EPERM;
1039 }
1040
1041 val = (unsigned long)config->addr_val[idx];
1042 spin_unlock(&drvdata->spinlock);
1043 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1044 }
1045
1046 static ssize_t addr_start_store(struct device *dev,
1047 struct device_attribute *attr,
1048 const char *buf, size_t size)
1049 {
1050 u8 idx;
1051 unsigned long val;
1052 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1053 struct etmv4_config *config = &drvdata->config;
1054
1055 if (kstrtoul(buf, 16, &val))
1056 return -EINVAL;
1057
1058 spin_lock(&drvdata->spinlock);
1059 idx = config->addr_idx;
1060 if (!drvdata->nr_addr_cmp) {
1061 spin_unlock(&drvdata->spinlock);
1062 return -EINVAL;
1063 }
1064 if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
1065 config->addr_type[idx] == ETM_ADDR_TYPE_START)) {
1066 spin_unlock(&drvdata->spinlock);
1067 return -EPERM;
1068 }
1069
1070 config->addr_val[idx] = (u64)val;
1071 config->addr_type[idx] = ETM_ADDR_TYPE_START;
1072 config->vissctlr |= BIT(idx);
1073 /* SSSTATUS, bit[9] - turn on start/stop logic */
1074 config->vinst_ctrl |= BIT(9);
1075 spin_unlock(&drvdata->spinlock);
1076 return size;
1077 }
1078 static DEVICE_ATTR_RW(addr_start);
1079
1080 static ssize_t addr_stop_show(struct device *dev,
1081 struct device_attribute *attr,
1082 char *buf)
1083 {
1084 u8 idx;
1085 unsigned long val;
1086 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1087 struct etmv4_config *config = &drvdata->config;
1088
1089 spin_lock(&drvdata->spinlock);
1090 idx = config->addr_idx;
1091
1092 if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
1093 config->addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
1094 spin_unlock(&drvdata->spinlock);
1095 return -EPERM;
1096 }
1097
1098 val = (unsigned long)config->addr_val[idx];
1099 spin_unlock(&drvdata->spinlock);
1100 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1101 }
1102
1103 static ssize_t addr_stop_store(struct device *dev,
1104 struct device_attribute *attr,
1105 const char *buf, size_t size)
1106 {
1107 u8 idx;
1108 unsigned long val;
1109 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1110 struct etmv4_config *config = &drvdata->config;
1111
1112 if (kstrtoul(buf, 16, &val))
1113 return -EINVAL;
1114
1115 spin_lock(&drvdata->spinlock);
1116 idx = config->addr_idx;
1117 if (!drvdata->nr_addr_cmp) {
1118 spin_unlock(&drvdata->spinlock);
1119 return -EINVAL;
1120 }
1121 if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
1122 config->addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
1123 spin_unlock(&drvdata->spinlock);
1124 return -EPERM;
1125 }
1126
1127 config->addr_val[idx] = (u64)val;
1128 config->addr_type[idx] = ETM_ADDR_TYPE_STOP;
1129 config->vissctlr |= BIT(idx + 16);
1130 /* SSSTATUS, bit[9] - turn on start/stop logic */
1131 config->vinst_ctrl |= BIT(9);
1132 spin_unlock(&drvdata->spinlock);
1133 return size;
1134 }
1135 static DEVICE_ATTR_RW(addr_stop);
1136
1137 static ssize_t addr_ctxtype_show(struct device *dev,
1138 struct device_attribute *attr,
1139 char *buf)
1140 {
1141 ssize_t len;
1142 u8 idx, val;
1143 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1144 struct etmv4_config *config = &drvdata->config;
1145
1146 spin_lock(&drvdata->spinlock);
1147 idx = config->addr_idx;
1148 /* CONTEXTTYPE, bits[3:2] */
1149 val = BMVAL(config->addr_acc[idx], 2, 3);
1150 len = scnprintf(buf, PAGE_SIZE, "%s\n", val == ETM_CTX_NONE ? "none" :
1151 (val == ETM_CTX_CTXID ? "ctxid" :
1152 (val == ETM_CTX_VMID ? "vmid" : "all")));
1153 spin_unlock(&drvdata->spinlock);
1154 return len;
1155 }
1156
1157 static ssize_t addr_ctxtype_store(struct device *dev,
1158 struct device_attribute *attr,
1159 const char *buf, size_t size)
1160 {
1161 u8 idx;
1162 char str[10] = "";
1163 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1164 struct etmv4_config *config = &drvdata->config;
1165
1166 if (strlen(buf) >= 10)
1167 return -EINVAL;
1168 if (sscanf(buf, "%s", str) != 1)
1169 return -EINVAL;
1170
1171 spin_lock(&drvdata->spinlock);
1172 idx = config->addr_idx;
1173 if (!strcmp(str, "none"))
1174 /* start by clearing context type bits */
1175 config->addr_acc[idx] &= ~(BIT(2) | BIT(3));
1176 else if (!strcmp(str, "ctxid")) {
1177 /* 0b01 The trace unit performs a Context ID */
1178 if (drvdata->numcidc) {
1179 config->addr_acc[idx] |= BIT(2);
1180 config->addr_acc[idx] &= ~BIT(3);
1181 }
1182 } else if (!strcmp(str, "vmid")) {
1183 /* 0b10 The trace unit performs a VMID */
1184 if (drvdata->numvmidc) {
1185 config->addr_acc[idx] &= ~BIT(2);
1186 config->addr_acc[idx] |= BIT(3);
1187 }
1188 } else if (!strcmp(str, "all")) {
1189 /*
1190 * 0b11 The trace unit performs a Context ID
1191 * comparison and a VMID
1192 */
1193 if (drvdata->numcidc)
1194 config->addr_acc[idx] |= BIT(2);
1195 if (drvdata->numvmidc)
1196 config->addr_acc[idx] |= BIT(3);
1197 }
1198 spin_unlock(&drvdata->spinlock);
1199 return size;
1200 }
1201 static DEVICE_ATTR_RW(addr_ctxtype);
1202
1203 static ssize_t addr_context_show(struct device *dev,
1204 struct device_attribute *attr,
1205 char *buf)
1206 {
1207 u8 idx;
1208 unsigned long val;
1209 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1210 struct etmv4_config *config = &drvdata->config;
1211
1212 spin_lock(&drvdata->spinlock);
1213 idx = config->addr_idx;
1214 /* context ID comparator bits[6:4] */
1215 val = BMVAL(config->addr_acc[idx], 4, 6);
1216 spin_unlock(&drvdata->spinlock);
1217 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1218 }
1219
1220 static ssize_t addr_context_store(struct device *dev,
1221 struct device_attribute *attr,
1222 const char *buf, size_t size)
1223 {
1224 u8 idx;
1225 unsigned long val;
1226 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1227 struct etmv4_config *config = &drvdata->config;
1228
1229 if (kstrtoul(buf, 16, &val))
1230 return -EINVAL;
1231 if ((drvdata->numcidc <= 1) && (drvdata->numvmidc <= 1))
1232 return -EINVAL;
1233 if (val >= (drvdata->numcidc >= drvdata->numvmidc ?
1234 drvdata->numcidc : drvdata->numvmidc))
1235 return -EINVAL;
1236
1237 spin_lock(&drvdata->spinlock);
1238 idx = config->addr_idx;
1239 /* clear context ID comparator bits[6:4] */
1240 config->addr_acc[idx] &= ~(BIT(4) | BIT(5) | BIT(6));
1241 config->addr_acc[idx] |= (val << 4);
1242 spin_unlock(&drvdata->spinlock);
1243 return size;
1244 }
1245 static DEVICE_ATTR_RW(addr_context);
1246
1247 static ssize_t seq_idx_show(struct device *dev,
1248 struct device_attribute *attr,
1249 char *buf)
1250 {
1251 unsigned long val;
1252 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1253 struct etmv4_config *config = &drvdata->config;
1254
1255 val = config->seq_idx;
1256 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1257 }
1258
1259 static ssize_t seq_idx_store(struct device *dev,
1260 struct device_attribute *attr,
1261 const char *buf, size_t size)
1262 {
1263 unsigned long val;
1264 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1265 struct etmv4_config *config = &drvdata->config;
1266
1267 if (kstrtoul(buf, 16, &val))
1268 return -EINVAL;
1269 if (val >= drvdata->nrseqstate - 1)
1270 return -EINVAL;
1271
1272 /*
1273 * Use spinlock to ensure index doesn't change while it gets
1274 * dereferenced multiple times within a spinlock block elsewhere.
1275 */
1276 spin_lock(&drvdata->spinlock);
1277 config->seq_idx = val;
1278 spin_unlock(&drvdata->spinlock);
1279 return size;
1280 }
1281 static DEVICE_ATTR_RW(seq_idx);
1282
1283 static ssize_t seq_state_show(struct device *dev,
1284 struct device_attribute *attr,
1285 char *buf)
1286 {
1287 unsigned long val;
1288 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1289 struct etmv4_config *config = &drvdata->config;
1290
1291 val = config->seq_state;
1292 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1293 }
1294
1295 static ssize_t seq_state_store(struct device *dev,
1296 struct device_attribute *attr,
1297 const char *buf, size_t size)
1298 {
1299 unsigned long val;
1300 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1301 struct etmv4_config *config = &drvdata->config;
1302
1303 if (kstrtoul(buf, 16, &val))
1304 return -EINVAL;
1305 if (val >= drvdata->nrseqstate)
1306 return -EINVAL;
1307
1308 config->seq_state = val;
1309 return size;
1310 }
1311 static DEVICE_ATTR_RW(seq_state);
1312
1313 static ssize_t seq_event_show(struct device *dev,
1314 struct device_attribute *attr,
1315 char *buf)
1316 {
1317 u8 idx;
1318 unsigned long val;
1319 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1320 struct etmv4_config *config = &drvdata->config;
1321
1322 spin_lock(&drvdata->spinlock);
1323 idx = config->seq_idx;
1324 val = config->seq_ctrl[idx];
1325 spin_unlock(&drvdata->spinlock);
1326 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1327 }
1328
1329 static ssize_t seq_event_store(struct device *dev,
1330 struct device_attribute *attr,
1331 const char *buf, size_t size)
1332 {
1333 u8 idx;
1334 unsigned long val;
1335 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1336 struct etmv4_config *config = &drvdata->config;
1337
1338 if (kstrtoul(buf, 16, &val))
1339 return -EINVAL;
1340
1341 spin_lock(&drvdata->spinlock);
1342 idx = config->seq_idx;
1343 /* RST, bits[7:0] */
1344 config->seq_ctrl[idx] = val & 0xFF;
1345 spin_unlock(&drvdata->spinlock);
1346 return size;
1347 }
1348 static DEVICE_ATTR_RW(seq_event);
1349
1350 static ssize_t seq_reset_event_show(struct device *dev,
1351 struct device_attribute *attr,
1352 char *buf)
1353 {
1354 unsigned long val;
1355 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1356 struct etmv4_config *config = &drvdata->config;
1357
1358 val = config->seq_rst;
1359 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1360 }
1361
1362 static ssize_t seq_reset_event_store(struct device *dev,
1363 struct device_attribute *attr,
1364 const char *buf, size_t size)
1365 {
1366 unsigned long val;
1367 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1368 struct etmv4_config *config = &drvdata->config;
1369
1370 if (kstrtoul(buf, 16, &val))
1371 return -EINVAL;
1372 if (!(drvdata->nrseqstate))
1373 return -EINVAL;
1374
1375 config->seq_rst = val & ETMv4_EVENT_MASK;
1376 return size;
1377 }
1378 static DEVICE_ATTR_RW(seq_reset_event);
1379
1380 static ssize_t cntr_idx_show(struct device *dev,
1381 struct device_attribute *attr,
1382 char *buf)
1383 {
1384 unsigned long val;
1385 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1386 struct etmv4_config *config = &drvdata->config;
1387
1388 val = config->cntr_idx;
1389 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1390 }
1391
1392 static ssize_t cntr_idx_store(struct device *dev,
1393 struct device_attribute *attr,
1394 const char *buf, size_t size)
1395 {
1396 unsigned long val;
1397 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1398 struct etmv4_config *config = &drvdata->config;
1399
1400 if (kstrtoul(buf, 16, &val))
1401 return -EINVAL;
1402 if (val >= drvdata->nr_cntr)
1403 return -EINVAL;
1404
1405 /*
1406 * Use spinlock to ensure index doesn't change while it gets
1407 * dereferenced multiple times within a spinlock block elsewhere.
1408 */
1409 spin_lock(&drvdata->spinlock);
1410 config->cntr_idx = val;
1411 spin_unlock(&drvdata->spinlock);
1412 return size;
1413 }
1414 static DEVICE_ATTR_RW(cntr_idx);
1415
1416 static ssize_t cntrldvr_show(struct device *dev,
1417 struct device_attribute *attr,
1418 char *buf)
1419 {
1420 u8 idx;
1421 unsigned long val;
1422 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1423 struct etmv4_config *config = &drvdata->config;
1424
1425 spin_lock(&drvdata->spinlock);
1426 idx = config->cntr_idx;
1427 val = config->cntrldvr[idx];
1428 spin_unlock(&drvdata->spinlock);
1429 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1430 }
1431
1432 static ssize_t cntrldvr_store(struct device *dev,
1433 struct device_attribute *attr,
1434 const char *buf, size_t size)
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 if (kstrtoul(buf, 16, &val))
1442 return -EINVAL;
1443 if (val > ETM_CNTR_MAX_VAL)
1444 return -EINVAL;
1445
1446 spin_lock(&drvdata->spinlock);
1447 idx = config->cntr_idx;
1448 config->cntrldvr[idx] = val;
1449 spin_unlock(&drvdata->spinlock);
1450 return size;
1451 }
1452 static DEVICE_ATTR_RW(cntrldvr);
1453
1454 static ssize_t cntr_val_show(struct device *dev,
1455 struct device_attribute *attr,
1456 char *buf)
1457 {
1458 u8 idx;
1459 unsigned long val;
1460 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1461 struct etmv4_config *config = &drvdata->config;
1462
1463 spin_lock(&drvdata->spinlock);
1464 idx = config->cntr_idx;
1465 val = config->cntr_val[idx];
1466 spin_unlock(&drvdata->spinlock);
1467 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1468 }
1469
1470 static ssize_t cntr_val_store(struct device *dev,
1471 struct device_attribute *attr,
1472 const char *buf, size_t size)
1473 {
1474 u8 idx;
1475 unsigned long val;
1476 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1477 struct etmv4_config *config = &drvdata->config;
1478
1479 if (kstrtoul(buf, 16, &val))
1480 return -EINVAL;
1481 if (val > ETM_CNTR_MAX_VAL)
1482 return -EINVAL;
1483
1484 spin_lock(&drvdata->spinlock);
1485 idx = config->cntr_idx;
1486 config->cntr_val[idx] = val;
1487 spin_unlock(&drvdata->spinlock);
1488 return size;
1489 }
1490 static DEVICE_ATTR_RW(cntr_val);
1491
1492 static ssize_t cntr_ctrl_show(struct device *dev,
1493 struct device_attribute *attr,
1494 char *buf)
1495 {
1496 u8 idx;
1497 unsigned long val;
1498 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1499 struct etmv4_config *config = &drvdata->config;
1500
1501 spin_lock(&drvdata->spinlock);
1502 idx = config->cntr_idx;
1503 val = config->cntr_ctrl[idx];
1504 spin_unlock(&drvdata->spinlock);
1505 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1506 }
1507
1508 static ssize_t cntr_ctrl_store(struct device *dev,
1509 struct device_attribute *attr,
1510 const char *buf, size_t size)
1511 {
1512 u8 idx;
1513 unsigned long val;
1514 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1515 struct etmv4_config *config = &drvdata->config;
1516
1517 if (kstrtoul(buf, 16, &val))
1518 return -EINVAL;
1519
1520 spin_lock(&drvdata->spinlock);
1521 idx = config->cntr_idx;
1522 config->cntr_ctrl[idx] = val;
1523 spin_unlock(&drvdata->spinlock);
1524 return size;
1525 }
1526 static DEVICE_ATTR_RW(cntr_ctrl);
1527
1528 static ssize_t res_idx_show(struct device *dev,
1529 struct device_attribute *attr,
1530 char *buf)
1531 {
1532 unsigned long val;
1533 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1534 struct etmv4_config *config = &drvdata->config;
1535
1536 val = config->res_idx;
1537 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1538 }
1539
1540 static ssize_t res_idx_store(struct device *dev,
1541 struct device_attribute *attr,
1542 const char *buf, size_t size)
1543 {
1544 unsigned long val;
1545 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1546 struct etmv4_config *config = &drvdata->config;
1547
1548 if (kstrtoul(buf, 16, &val))
1549 return -EINVAL;
1550 /* Resource selector pair 0 is always implemented and reserved */
1551 if ((val == 0) || (val >= drvdata->nr_resource))
1552 return -EINVAL;
1553
1554 /*
1555 * Use spinlock to ensure index doesn't change while it gets
1556 * dereferenced multiple times within a spinlock block elsewhere.
1557 */
1558 spin_lock(&drvdata->spinlock);
1559 config->res_idx = val;
1560 spin_unlock(&drvdata->spinlock);
1561 return size;
1562 }
1563 static DEVICE_ATTR_RW(res_idx);
1564
1565 static ssize_t res_ctrl_show(struct device *dev,
1566 struct device_attribute *attr,
1567 char *buf)
1568 {
1569 u8 idx;
1570 unsigned long val;
1571 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1572 struct etmv4_config *config = &drvdata->config;
1573
1574 spin_lock(&drvdata->spinlock);
1575 idx = config->res_idx;
1576 val = config->res_ctrl[idx];
1577 spin_unlock(&drvdata->spinlock);
1578 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1579 }
1580
1581 static ssize_t res_ctrl_store(struct device *dev,
1582 struct device_attribute *attr,
1583 const char *buf, size_t size)
1584 {
1585 u8 idx;
1586 unsigned long val;
1587 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1588 struct etmv4_config *config = &drvdata->config;
1589
1590 if (kstrtoul(buf, 16, &val))
1591 return -EINVAL;
1592
1593 spin_lock(&drvdata->spinlock);
1594 idx = config->res_idx;
1595 /* For odd idx pair inversal bit is RES0 */
1596 if (idx % 2 != 0)
1597 /* PAIRINV, bit[21] */
1598 val &= ~BIT(21);
1599 config->res_ctrl[idx] = val;
1600 spin_unlock(&drvdata->spinlock);
1601 return size;
1602 }
1603 static DEVICE_ATTR_RW(res_ctrl);
1604
1605 static ssize_t ctxid_idx_show(struct device *dev,
1606 struct device_attribute *attr,
1607 char *buf)
1608 {
1609 unsigned long val;
1610 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1611 struct etmv4_config *config = &drvdata->config;
1612
1613 val = config->ctxid_idx;
1614 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1615 }
1616
1617 static ssize_t ctxid_idx_store(struct device *dev,
1618 struct device_attribute *attr,
1619 const char *buf, size_t size)
1620 {
1621 unsigned long val;
1622 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1623 struct etmv4_config *config = &drvdata->config;
1624
1625 if (kstrtoul(buf, 16, &val))
1626 return -EINVAL;
1627 if (val >= drvdata->numcidc)
1628 return -EINVAL;
1629
1630 /*
1631 * Use spinlock to ensure index doesn't change while it gets
1632 * dereferenced multiple times within a spinlock block elsewhere.
1633 */
1634 spin_lock(&drvdata->spinlock);
1635 config->ctxid_idx = val;
1636 spin_unlock(&drvdata->spinlock);
1637 return size;
1638 }
1639 static DEVICE_ATTR_RW(ctxid_idx);
1640
1641 static ssize_t ctxid_pid_show(struct device *dev,
1642 struct device_attribute *attr,
1643 char *buf)
1644 {
1645 u8 idx;
1646 unsigned long val;
1647 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1648 struct etmv4_config *config = &drvdata->config;
1649
1650 spin_lock(&drvdata->spinlock);
1651 idx = config->ctxid_idx;
1652 val = (unsigned long)config->ctxid_vpid[idx];
1653 spin_unlock(&drvdata->spinlock);
1654 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1655 }
1656
1657 static ssize_t ctxid_pid_store(struct device *dev,
1658 struct device_attribute *attr,
1659 const char *buf, size_t size)
1660 {
1661 u8 idx;
1662 unsigned long vpid, pid;
1663 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1664 struct etmv4_config *config = &drvdata->config;
1665
1666 /*
1667 * only implemented when ctxid tracing is enabled, i.e. at least one
1668 * ctxid comparator is implemented and ctxid is greater than 0 bits
1669 * in length
1670 */
1671 if (!drvdata->ctxid_size || !drvdata->numcidc)
1672 return -EINVAL;
1673 if (kstrtoul(buf, 16, &vpid))
1674 return -EINVAL;
1675
1676 pid = coresight_vpid_to_pid(vpid);
1677
1678 spin_lock(&drvdata->spinlock);
1679 idx = config->ctxid_idx;
1680 config->ctxid_pid[idx] = (u64)pid;
1681 config->ctxid_vpid[idx] = (u64)vpid;
1682 spin_unlock(&drvdata->spinlock);
1683 return size;
1684 }
1685 static DEVICE_ATTR_RW(ctxid_pid);
1686
1687 static ssize_t ctxid_masks_show(struct device *dev,
1688 struct device_attribute *attr,
1689 char *buf)
1690 {
1691 unsigned long val1, val2;
1692 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1693 struct etmv4_config *config = &drvdata->config;
1694
1695 spin_lock(&drvdata->spinlock);
1696 val1 = config->ctxid_mask0;
1697 val2 = config->ctxid_mask1;
1698 spin_unlock(&drvdata->spinlock);
1699 return scnprintf(buf, PAGE_SIZE, "%#lx %#lx\n", val1, val2);
1700 }
1701
1702 static ssize_t ctxid_masks_store(struct device *dev,
1703 struct device_attribute *attr,
1704 const char *buf, size_t size)
1705 {
1706 u8 i, j, maskbyte;
1707 unsigned long val1, val2, mask;
1708 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1709 struct etmv4_config *config = &drvdata->config;
1710
1711 /*
1712 * only implemented when ctxid tracing is enabled, i.e. at least one
1713 * ctxid comparator is implemented and ctxid is greater than 0 bits
1714 * in length
1715 */
1716 if (!drvdata->ctxid_size || !drvdata->numcidc)
1717 return -EINVAL;
1718 if (sscanf(buf, "%lx %lx", &val1, &val2) != 2)
1719 return -EINVAL;
1720
1721 spin_lock(&drvdata->spinlock);
1722 /*
1723 * each byte[0..3] controls mask value applied to ctxid
1724 * comparator[0..3]
1725 */
1726 switch (drvdata->numcidc) {
1727 case 0x1:
1728 /* COMP0, bits[7:0] */
1729 config->ctxid_mask0 = val1 & 0xFF;
1730 break;
1731 case 0x2:
1732 /* COMP1, bits[15:8] */
1733 config->ctxid_mask0 = val1 & 0xFFFF;
1734 break;
1735 case 0x3:
1736 /* COMP2, bits[23:16] */
1737 config->ctxid_mask0 = val1 & 0xFFFFFF;
1738 break;
1739 case 0x4:
1740 /* COMP3, bits[31:24] */
1741 config->ctxid_mask0 = val1;
1742 break;
1743 case 0x5:
1744 /* COMP4, bits[7:0] */
1745 config->ctxid_mask0 = val1;
1746 config->ctxid_mask1 = val2 & 0xFF;
1747 break;
1748 case 0x6:
1749 /* COMP5, bits[15:8] */
1750 config->ctxid_mask0 = val1;
1751 config->ctxid_mask1 = val2 & 0xFFFF;
1752 break;
1753 case 0x7:
1754 /* COMP6, bits[23:16] */
1755 config->ctxid_mask0 = val1;
1756 config->ctxid_mask1 = val2 & 0xFFFFFF;
1757 break;
1758 case 0x8:
1759 /* COMP7, bits[31:24] */
1760 config->ctxid_mask0 = val1;
1761 config->ctxid_mask1 = val2;
1762 break;
1763 default:
1764 break;
1765 }
1766 /*
1767 * If software sets a mask bit to 1, it must program relevant byte
1768 * of ctxid comparator value 0x0, otherwise behavior is unpredictable.
1769 * For example, if bit[3] of ctxid_mask0 is 1, we must clear bits[31:24]
1770 * of ctxid comparator0 value (corresponding to byte 0) register.
1771 */
1772 mask = config->ctxid_mask0;
1773 for (i = 0; i < drvdata->numcidc; i++) {
1774 /* mask value of corresponding ctxid comparator */
1775 maskbyte = mask & ETMv4_EVENT_MASK;
1776 /*
1777 * each bit corresponds to a byte of respective ctxid comparator
1778 * value register
1779 */
1780 for (j = 0; j < 8; j++) {
1781 if (maskbyte & 1)
1782 config->ctxid_pid[i] &= ~(0xFF << (j * 8));
1783 maskbyte >>= 1;
1784 }
1785 /* Select the next ctxid comparator mask value */
1786 if (i == 3)
1787 /* ctxid comparators[4-7] */
1788 mask = config->ctxid_mask1;
1789 else
1790 mask >>= 0x8;
1791 }
1792
1793 spin_unlock(&drvdata->spinlock);
1794 return size;
1795 }
1796 static DEVICE_ATTR_RW(ctxid_masks);
1797
1798 static ssize_t vmid_idx_show(struct device *dev,
1799 struct device_attribute *attr,
1800 char *buf)
1801 {
1802 unsigned long val;
1803 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1804 struct etmv4_config *config = &drvdata->config;
1805
1806 val = config->vmid_idx;
1807 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1808 }
1809
1810 static ssize_t vmid_idx_store(struct device *dev,
1811 struct device_attribute *attr,
1812 const char *buf, size_t size)
1813 {
1814 unsigned long val;
1815 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1816 struct etmv4_config *config = &drvdata->config;
1817
1818 if (kstrtoul(buf, 16, &val))
1819 return -EINVAL;
1820 if (val >= drvdata->numvmidc)
1821 return -EINVAL;
1822
1823 /*
1824 * Use spinlock to ensure index doesn't change while it gets
1825 * dereferenced multiple times within a spinlock block elsewhere.
1826 */
1827 spin_lock(&drvdata->spinlock);
1828 config->vmid_idx = val;
1829 spin_unlock(&drvdata->spinlock);
1830 return size;
1831 }
1832 static DEVICE_ATTR_RW(vmid_idx);
1833
1834 static ssize_t vmid_val_show(struct device *dev,
1835 struct device_attribute *attr,
1836 char *buf)
1837 {
1838 unsigned long val;
1839 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1840 struct etmv4_config *config = &drvdata->config;
1841
1842 val = (unsigned long)config->vmid_val[config->vmid_idx];
1843 return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
1844 }
1845
1846 static ssize_t vmid_val_store(struct device *dev,
1847 struct device_attribute *attr,
1848 const char *buf, size_t size)
1849 {
1850 unsigned long val;
1851 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1852 struct etmv4_config *config = &drvdata->config;
1853
1854 /*
1855 * only implemented when vmid tracing is enabled, i.e. at least one
1856 * vmid comparator is implemented and at least 8 bit vmid size
1857 */
1858 if (!drvdata->vmid_size || !drvdata->numvmidc)
1859 return -EINVAL;
1860 if (kstrtoul(buf, 16, &val))
1861 return -EINVAL;
1862
1863 spin_lock(&drvdata->spinlock);
1864 config->vmid_val[config->vmid_idx] = (u64)val;
1865 spin_unlock(&drvdata->spinlock);
1866 return size;
1867 }
1868 static DEVICE_ATTR_RW(vmid_val);
1869
1870 static ssize_t vmid_masks_show(struct device *dev,
1871 struct device_attribute *attr, char *buf)
1872 {
1873 unsigned long val1, val2;
1874 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1875 struct etmv4_config *config = &drvdata->config;
1876
1877 spin_lock(&drvdata->spinlock);
1878 val1 = config->vmid_mask0;
1879 val2 = config->vmid_mask1;
1880 spin_unlock(&drvdata->spinlock);
1881 return scnprintf(buf, PAGE_SIZE, "%#lx %#lx\n", val1, val2);
1882 }
1883
1884 static ssize_t vmid_masks_store(struct device *dev,
1885 struct device_attribute *attr,
1886 const char *buf, size_t size)
1887 {
1888 u8 i, j, maskbyte;
1889 unsigned long val1, val2, mask;
1890 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1891 struct etmv4_config *config = &drvdata->config;
1892
1893 /*
1894 * only implemented when vmid tracing is enabled, i.e. at least one
1895 * vmid comparator is implemented and at least 8 bit vmid size
1896 */
1897 if (!drvdata->vmid_size || !drvdata->numvmidc)
1898 return -EINVAL;
1899 if (sscanf(buf, "%lx %lx", &val1, &val2) != 2)
1900 return -EINVAL;
1901
1902 spin_lock(&drvdata->spinlock);
1903
1904 /*
1905 * each byte[0..3] controls mask value applied to vmid
1906 * comparator[0..3]
1907 */
1908 switch (drvdata->numvmidc) {
1909 case 0x1:
1910 /* COMP0, bits[7:0] */
1911 config->vmid_mask0 = val1 & 0xFF;
1912 break;
1913 case 0x2:
1914 /* COMP1, bits[15:8] */
1915 config->vmid_mask0 = val1 & 0xFFFF;
1916 break;
1917 case 0x3:
1918 /* COMP2, bits[23:16] */
1919 config->vmid_mask0 = val1 & 0xFFFFFF;
1920 break;
1921 case 0x4:
1922 /* COMP3, bits[31:24] */
1923 config->vmid_mask0 = val1;
1924 break;
1925 case 0x5:
1926 /* COMP4, bits[7:0] */
1927 config->vmid_mask0 = val1;
1928 config->vmid_mask1 = val2 & 0xFF;
1929 break;
1930 case 0x6:
1931 /* COMP5, bits[15:8] */
1932 config->vmid_mask0 = val1;
1933 config->vmid_mask1 = val2 & 0xFFFF;
1934 break;
1935 case 0x7:
1936 /* COMP6, bits[23:16] */
1937 config->vmid_mask0 = val1;
1938 config->vmid_mask1 = val2 & 0xFFFFFF;
1939 break;
1940 case 0x8:
1941 /* COMP7, bits[31:24] */
1942 config->vmid_mask0 = val1;
1943 config->vmid_mask1 = val2;
1944 break;
1945 default:
1946 break;
1947 }
1948
1949 /*
1950 * If software sets a mask bit to 1, it must program relevant byte
1951 * of vmid comparator value 0x0, otherwise behavior is unpredictable.
1952 * For example, if bit[3] of vmid_mask0 is 1, we must clear bits[31:24]
1953 * of vmid comparator0 value (corresponding to byte 0) register.
1954 */
1955 mask = config->vmid_mask0;
1956 for (i = 0; i < drvdata->numvmidc; i++) {
1957 /* mask value of corresponding vmid comparator */
1958 maskbyte = mask & ETMv4_EVENT_MASK;
1959 /*
1960 * each bit corresponds to a byte of respective vmid comparator
1961 * value register
1962 */
1963 for (j = 0; j < 8; j++) {
1964 if (maskbyte & 1)
1965 config->vmid_val[i] &= ~(0xFF << (j * 8));
1966 maskbyte >>= 1;
1967 }
1968 /* Select the next vmid comparator mask value */
1969 if (i == 3)
1970 /* vmid comparators[4-7] */
1971 mask = config->vmid_mask1;
1972 else
1973 mask >>= 0x8;
1974 }
1975 spin_unlock(&drvdata->spinlock);
1976 return size;
1977 }
1978 static DEVICE_ATTR_RW(vmid_masks);
1979
1980 static ssize_t cpu_show(struct device *dev,
1981 struct device_attribute *attr, char *buf)
1982 {
1983 int val;
1984 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
1985
1986 val = drvdata->cpu;
1987 return scnprintf(buf, PAGE_SIZE, "%d\n", val);
1988
1989 }
1990 static DEVICE_ATTR_RO(cpu);
1991
1992 static struct attribute *coresight_etmv4_attrs[] = {
1993 &dev_attr_nr_pe_cmp.attr,
1994 &dev_attr_nr_addr_cmp.attr,
1995 &dev_attr_nr_cntr.attr,
1996 &dev_attr_nr_ext_inp.attr,
1997 &dev_attr_numcidc.attr,
1998 &dev_attr_numvmidc.attr,
1999 &dev_attr_nrseqstate.attr,
2000 &dev_attr_nr_resource.attr,
2001 &dev_attr_nr_ss_cmp.attr,
2002 &dev_attr_reset.attr,
2003 &dev_attr_mode.attr,
2004 &dev_attr_pe.attr,
2005 &dev_attr_event.attr,
2006 &dev_attr_event_instren.attr,
2007 &dev_attr_event_ts.attr,
2008 &dev_attr_syncfreq.attr,
2009 &dev_attr_cyc_threshold.attr,
2010 &dev_attr_bb_ctrl.attr,
2011 &dev_attr_event_vinst.attr,
2012 &dev_attr_s_exlevel_vinst.attr,
2013 &dev_attr_ns_exlevel_vinst.attr,
2014 &dev_attr_addr_idx.attr,
2015 &dev_attr_addr_instdatatype.attr,
2016 &dev_attr_addr_single.attr,
2017 &dev_attr_addr_range.attr,
2018 &dev_attr_addr_start.attr,
2019 &dev_attr_addr_stop.attr,
2020 &dev_attr_addr_ctxtype.attr,
2021 &dev_attr_addr_context.attr,
2022 &dev_attr_seq_idx.attr,
2023 &dev_attr_seq_state.attr,
2024 &dev_attr_seq_event.attr,
2025 &dev_attr_seq_reset_event.attr,
2026 &dev_attr_cntr_idx.attr,
2027 &dev_attr_cntrldvr.attr,
2028 &dev_attr_cntr_val.attr,
2029 &dev_attr_cntr_ctrl.attr,
2030 &dev_attr_res_idx.attr,
2031 &dev_attr_res_ctrl.attr,
2032 &dev_attr_ctxid_idx.attr,
2033 &dev_attr_ctxid_pid.attr,
2034 &dev_attr_ctxid_masks.attr,
2035 &dev_attr_vmid_idx.attr,
2036 &dev_attr_vmid_val.attr,
2037 &dev_attr_vmid_masks.attr,
2038 &dev_attr_cpu.attr,
2039 NULL,
2040 };
2041
2042 #define coresight_etm4x_simple_func(name, offset) \
2043 coresight_simple_func(struct etmv4_drvdata, name, offset)
2044
2045 coresight_etm4x_simple_func(trcoslsr, TRCOSLSR);
2046 coresight_etm4x_simple_func(trcpdcr, TRCPDCR);
2047 coresight_etm4x_simple_func(trcpdsr, TRCPDSR);
2048 coresight_etm4x_simple_func(trclsr, TRCLSR);
2049 coresight_etm4x_simple_func(trcconfig, TRCCONFIGR);
2050 coresight_etm4x_simple_func(trctraceid, TRCTRACEIDR);
2051 coresight_etm4x_simple_func(trcauthstatus, TRCAUTHSTATUS);
2052 coresight_etm4x_simple_func(trcdevid, TRCDEVID);
2053 coresight_etm4x_simple_func(trcdevtype, TRCDEVTYPE);
2054 coresight_etm4x_simple_func(trcpidr0, TRCPIDR0);
2055 coresight_etm4x_simple_func(trcpidr1, TRCPIDR1);
2056 coresight_etm4x_simple_func(trcpidr2, TRCPIDR2);
2057 coresight_etm4x_simple_func(trcpidr3, TRCPIDR3);
2058
2059 static struct attribute *coresight_etmv4_mgmt_attrs[] = {
2060 &dev_attr_trcoslsr.attr,
2061 &dev_attr_trcpdcr.attr,
2062 &dev_attr_trcpdsr.attr,
2063 &dev_attr_trclsr.attr,
2064 &dev_attr_trcconfig.attr,
2065 &dev_attr_trctraceid.attr,
2066 &dev_attr_trcauthstatus.attr,
2067 &dev_attr_trcdevid.attr,
2068 &dev_attr_trcdevtype.attr,
2069 &dev_attr_trcpidr0.attr,
2070 &dev_attr_trcpidr1.attr,
2071 &dev_attr_trcpidr2.attr,
2072 &dev_attr_trcpidr3.attr,
2073 NULL,
2074 };
2075
2076 coresight_etm4x_simple_func(trcidr0, TRCIDR0);
2077 coresight_etm4x_simple_func(trcidr1, TRCIDR1);
2078 coresight_etm4x_simple_func(trcidr2, TRCIDR2);
2079 coresight_etm4x_simple_func(trcidr3, TRCIDR3);
2080 coresight_etm4x_simple_func(trcidr4, TRCIDR4);
2081 coresight_etm4x_simple_func(trcidr5, TRCIDR5);
2082 /* trcidr[6,7] are reserved */
2083 coresight_etm4x_simple_func(trcidr8, TRCIDR8);
2084 coresight_etm4x_simple_func(trcidr9, TRCIDR9);
2085 coresight_etm4x_simple_func(trcidr10, TRCIDR10);
2086 coresight_etm4x_simple_func(trcidr11, TRCIDR11);
2087 coresight_etm4x_simple_func(trcidr12, TRCIDR12);
2088 coresight_etm4x_simple_func(trcidr13, TRCIDR13);
2089
2090 static struct attribute *coresight_etmv4_trcidr_attrs[] = {
2091 &dev_attr_trcidr0.attr,
2092 &dev_attr_trcidr1.attr,
2093 &dev_attr_trcidr2.attr,
2094 &dev_attr_trcidr3.attr,
2095 &dev_attr_trcidr4.attr,
2096 &dev_attr_trcidr5.attr,
2097 /* trcidr[6,7] are reserved */
2098 &dev_attr_trcidr8.attr,
2099 &dev_attr_trcidr9.attr,
2100 &dev_attr_trcidr10.attr,
2101 &dev_attr_trcidr11.attr,
2102 &dev_attr_trcidr12.attr,
2103 &dev_attr_trcidr13.attr,
2104 NULL,
2105 };
2106
2107 static const struct attribute_group coresight_etmv4_group = {
2108 .attrs = coresight_etmv4_attrs,
2109 };
2110
2111 static const struct attribute_group coresight_etmv4_mgmt_group = {
2112 .attrs = coresight_etmv4_mgmt_attrs,
2113 .name = "mgmt",
2114 };
2115
2116 static const struct attribute_group coresight_etmv4_trcidr_group = {
2117 .attrs = coresight_etmv4_trcidr_attrs,
2118 .name = "trcidr",
2119 };
2120
2121 const struct attribute_group *coresight_etmv4_groups[] = {
2122 &coresight_etmv4_group,
2123 &coresight_etmv4_mgmt_group,
2124 &coresight_etmv4_trcidr_group,
2125 NULL,
2126 };
ubuntu-zesty-kernel mirror