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

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