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