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