drivers/hwtracing/coresight/coresight-etm4x-sysfs.c

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