drivers/hwtracing/coresight/coresight-etm3x-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-etm.h"
  21 #include "coresight-priv.h"
  22
  23 static ssize_t nr_addr_cmp_show(struct device *dev,
  24                                 struct device_attribute *attr, char *buf)
  25 {
  26         unsigned long val;
  27         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
  28
  29         val = drvdata->nr_addr_cmp;
  30         return sprintf(buf, "%#lx\n", val);
  31 }
  32 static DEVICE_ATTR_RO(nr_addr_cmp);
  33
  34 static ssize_t nr_cntr_show(struct device *dev,
  35                             struct device_attribute *attr, char *buf)
  36 {       unsigned long val;
  37         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
  38
  39         val = drvdata->nr_cntr;
  40         return sprintf(buf, "%#lx\n", val);
  41 }
  42 static DEVICE_ATTR_RO(nr_cntr);
  43
  44 static ssize_t nr_ctxid_cmp_show(struct device *dev,
  45                                  struct device_attribute *attr, char *buf)
  46 {
  47         unsigned long val;
  48         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
  49
  50         val = drvdata->nr_ctxid_cmp;
  51         return sprintf(buf, "%#lx\n", val);
  52 }
  53 static DEVICE_ATTR_RO(nr_ctxid_cmp);
  54
  55 static ssize_t etmsr_show(struct device *dev,
  56                           struct device_attribute *attr, char *buf)
  57 {
  58         unsigned long flags, val;
  59         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
  60
  61         pm_runtime_get_sync(drvdata->dev);
  62         spin_lock_irqsave(&drvdata->spinlock, flags);
  63         CS_UNLOCK(drvdata->base);
  64
  65         val = etm_readl(drvdata, ETMSR);
  66
  67         CS_LOCK(drvdata->base);
  68         spin_unlock_irqrestore(&drvdata->spinlock, flags);
  69         pm_runtime_put(drvdata->dev);
  70
  71         return sprintf(buf, "%#lx\n", val);
  72 }
  73 static DEVICE_ATTR_RO(etmsr);
  74
  75 static ssize_t reset_store(struct device *dev,
  76                            struct device_attribute *attr,
  77                            const char *buf, size_t size)
  78 {
  79         int i, ret;
  80         unsigned long val;
  81         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
  82         struct etm_config *config = &drvdata->config;
  83
  84         ret = kstrtoul(buf, 16, &val);
  85         if (ret)
  86                 return ret;
  87
  88         if (val) {
  89                 spin_lock(&drvdata->spinlock);
  90                 memset(config, 0, sizeof(struct etm_config));
  91                 config->mode = ETM_MODE_EXCLUDE;
  92                 config->trigger_event = ETM_DEFAULT_EVENT_VAL;
  93                 for (i = 0; i < drvdata->nr_addr_cmp; i++) {
  94                         config->addr_type[i] = ETM_ADDR_TYPE_NONE;
  95                 }
  96
  97                 etm_set_default(config);
  98                 spin_unlock(&drvdata->spinlock);
  99         }
 100
 101         return size;
 102 }
 103 static DEVICE_ATTR_WO(reset);
 104
 105 static ssize_t mode_show(struct device *dev,
 106                          struct device_attribute *attr, char *buf)
 107 {
 108         unsigned long val;
 109         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 110         struct etm_config *config = &drvdata->config;
 111
 112         val = config->mode;
 113         return sprintf(buf, "%#lx\n", val);
 114 }
 115
 116 static ssize_t mode_store(struct device *dev,
 117                           struct device_attribute *attr,
 118                           const char *buf, size_t size)
 119 {
 120         int ret;
 121         unsigned long val;
 122         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 123         struct etm_config *config = &drvdata->config;
 124
 125         ret = kstrtoul(buf, 16, &val);
 126         if (ret)
 127                 return ret;
 128
 129         spin_lock(&drvdata->spinlock);
 130         config->mode = val & ETM_MODE_ALL;
 131
 132         if (config->mode & ETM_MODE_EXCLUDE)
 133                 config->enable_ctrl1 |= ETMTECR1_INC_EXC;
 134         else
 135                 config->enable_ctrl1 &= ~ETMTECR1_INC_EXC;
 136
 137         if (config->mode & ETM_MODE_CYCACC)
 138                 config->ctrl |= ETMCR_CYC_ACC;
 139         else
 140                 config->ctrl &= ~ETMCR_CYC_ACC;
 141
 142         if (config->mode & ETM_MODE_STALL) {
 143                 if (!(drvdata->etmccr & ETMCCR_FIFOFULL)) {
 144                         dev_warn(drvdata->dev, "stall mode not supported\n");
 145                         ret = -EINVAL;
 146                         goto err_unlock;
 147                 }
 148                 config->ctrl |= ETMCR_STALL_MODE;
 149          } else
 150                 config->ctrl &= ~ETMCR_STALL_MODE;
 151
 152         if (config->mode & ETM_MODE_TIMESTAMP) {
 153                 if (!(drvdata->etmccer & ETMCCER_TIMESTAMP)) {
 154                         dev_warn(drvdata->dev, "timestamp not supported\n");
 155                         ret = -EINVAL;
 156                         goto err_unlock;
 157                 }
 158                 config->ctrl |= ETMCR_TIMESTAMP_EN;
 159         } else
 160                 config->ctrl &= ~ETMCR_TIMESTAMP_EN;
 161
 162         if (config->mode & ETM_MODE_CTXID)
 163                 config->ctrl |= ETMCR_CTXID_SIZE;
 164         else
 165                 config->ctrl &= ~ETMCR_CTXID_SIZE;
 166
 167         if (config->mode & (ETM_MODE_EXCL_KERN | ETM_MODE_EXCL_USER))
 168                 etm_config_trace_mode(config);
 169
 170         spin_unlock(&drvdata->spinlock);
 171
 172         return size;
 173
 174 err_unlock:
 175         spin_unlock(&drvdata->spinlock);
 176         return ret;
 177 }
 178 static DEVICE_ATTR_RW(mode);
 179
 180 static ssize_t trigger_event_show(struct device *dev,
 181                                   struct device_attribute *attr, char *buf)
 182 {
 183         unsigned long val;
 184         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 185         struct etm_config *config = &drvdata->config;
 186
 187         val = config->trigger_event;
 188         return sprintf(buf, "%#lx\n", val);
 189 }
 190
 191 static ssize_t trigger_event_store(struct device *dev,
 192                                    struct device_attribute *attr,
 193                                    const char *buf, size_t size)
 194 {
 195         int ret;
 196         unsigned long val;
 197         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 198         struct etm_config *config = &drvdata->config;
 199
 200         ret = kstrtoul(buf, 16, &val);
 201         if (ret)
 202                 return ret;
 203
 204         config->trigger_event = val & ETM_EVENT_MASK;
 205
 206         return size;
 207 }
 208 static DEVICE_ATTR_RW(trigger_event);
 209
 210 static ssize_t enable_event_show(struct device *dev,
 211                                  struct device_attribute *attr, char *buf)
 212 {
 213         unsigned long val;
 214         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 215         struct etm_config *config = &drvdata->config;
 216
 217         val = config->enable_event;
 218         return sprintf(buf, "%#lx\n", val);
 219 }
 220
 221 static ssize_t enable_event_store(struct device *dev,
 222                                   struct device_attribute *attr,
 223                                   const char *buf, size_t size)
 224 {
 225         int ret;
 226         unsigned long val;
 227         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 228         struct etm_config *config = &drvdata->config;
 229
 230         ret = kstrtoul(buf, 16, &val);
 231         if (ret)
 232                 return ret;
 233
 234         config->enable_event = val & ETM_EVENT_MASK;
 235
 236         return size;
 237 }
 238 static DEVICE_ATTR_RW(enable_event);
 239
 240 static ssize_t fifofull_level_show(struct device *dev,
 241                                    struct device_attribute *attr, char *buf)
 242 {
 243         unsigned long val;
 244         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 245         struct etm_config *config = &drvdata->config;
 246
 247         val = config->fifofull_level;
 248         return sprintf(buf, "%#lx\n", val);
 249 }
 250
 251 static ssize_t fifofull_level_store(struct device *dev,
 252                                     struct device_attribute *attr,
 253                                     const char *buf, size_t size)
 254 {
 255         int ret;
 256         unsigned long val;
 257         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 258         struct etm_config *config = &drvdata->config;
 259
 260         ret = kstrtoul(buf, 16, &val);
 261         if (ret)
 262                 return ret;
 263
 264         config->fifofull_level = val;
 265
 266         return size;
 267 }
 268 static DEVICE_ATTR_RW(fifofull_level);
 269
 270 static ssize_t addr_idx_show(struct device *dev,
 271                              struct device_attribute *attr, char *buf)
 272 {
 273         unsigned long val;
 274         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 275         struct etm_config *config = &drvdata->config;
 276
 277         val = config->addr_idx;
 278         return sprintf(buf, "%#lx\n", val);
 279 }
 280
 281 static ssize_t addr_idx_store(struct device *dev,
 282                               struct device_attribute *attr,
 283                               const char *buf, size_t size)
 284 {
 285         int ret;
 286         unsigned long val;
 287         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 288         struct etm_config *config = &drvdata->config;
 289
 290         ret = kstrtoul(buf, 16, &val);
 291         if (ret)
 292                 return ret;
 293
 294         if (val >= drvdata->nr_addr_cmp)
 295                 return -EINVAL;
 296
 297         /*
 298          * Use spinlock to ensure index doesn't change while it gets
 299          * dereferenced multiple times within a spinlock block elsewhere.
 300          */
 301         spin_lock(&drvdata->spinlock);
 302         config->addr_idx = val;
 303         spin_unlock(&drvdata->spinlock);
 304
 305         return size;
 306 }
 307 static DEVICE_ATTR_RW(addr_idx);
 308
 309 static ssize_t addr_single_show(struct device *dev,
 310                                 struct device_attribute *attr, char *buf)
 311 {
 312         u8 idx;
 313         unsigned long val;
 314         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 315         struct etm_config *config = &drvdata->config;
 316
 317         spin_lock(&drvdata->spinlock);
 318         idx = config->addr_idx;
 319         if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
 320               config->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
 321                 spin_unlock(&drvdata->spinlock);
 322                 return -EINVAL;
 323         }
 324
 325         val = config->addr_val[idx];
 326         spin_unlock(&drvdata->spinlock);
 327
 328         return sprintf(buf, "%#lx\n", val);
 329 }
 330
 331 static ssize_t addr_single_store(struct device *dev,
 332                                  struct device_attribute *attr,
 333                                  const char *buf, size_t size)
 334 {
 335         u8 idx;
 336         int ret;
 337         unsigned long val;
 338         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 339         struct etm_config *config = &drvdata->config;
 340
 341         ret = kstrtoul(buf, 16, &val);
 342         if (ret)
 343                 return ret;
 344
 345         spin_lock(&drvdata->spinlock);
 346         idx = config->addr_idx;
 347         if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
 348               config->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
 349                 spin_unlock(&drvdata->spinlock);
 350                 return -EINVAL;
 351         }
 352
 353         config->addr_val[idx] = val;
 354         config->addr_type[idx] = ETM_ADDR_TYPE_SINGLE;
 355         spin_unlock(&drvdata->spinlock);
 356
 357         return size;
 358 }
 359 static DEVICE_ATTR_RW(addr_single);
 360
 361 static ssize_t addr_range_show(struct device *dev,
 362                                struct device_attribute *attr, char *buf)
 363 {
 364         u8 idx;
 365         unsigned long val1, val2;
 366         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 367         struct etm_config *config = &drvdata->config;
 368
 369         spin_lock(&drvdata->spinlock);
 370         idx = config->addr_idx;
 371         if (idx % 2 != 0) {
 372                 spin_unlock(&drvdata->spinlock);
 373                 return -EPERM;
 374         }
 375         if (!((config->addr_type[idx] == ETM_ADDR_TYPE_NONE &&
 376                config->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
 377               (config->addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
 378                config->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
 379                 spin_unlock(&drvdata->spinlock);
 380                 return -EPERM;
 381         }
 382
 383         val1 = config->addr_val[idx];
 384         val2 = config->addr_val[idx + 1];
 385         spin_unlock(&drvdata->spinlock);
 386
 387         return sprintf(buf, "%#lx %#lx\n", val1, val2);
 388 }
 389
 390 static ssize_t addr_range_store(struct device *dev,
 391                               struct device_attribute *attr,
 392                               const char *buf, size_t size)
 393 {
 394         u8 idx;
 395         unsigned long val1, val2;
 396         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 397         struct etm_config *config = &drvdata->config;
 398
 399         if (sscanf(buf, "%lx %lx", &val1, &val2) != 2)
 400                 return -EINVAL;
 401         /* Lower address comparator cannot have a higher address value */
 402         if (val1 > val2)
 403                 return -EINVAL;
 404
 405         spin_lock(&drvdata->spinlock);
 406         idx = config->addr_idx;
 407         if (idx % 2 != 0) {
 408                 spin_unlock(&drvdata->spinlock);
 409                 return -EPERM;
 410         }
 411         if (!((config->addr_type[idx] == ETM_ADDR_TYPE_NONE &&
 412                config->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
 413               (config->addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
 414                config->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
 415                 spin_unlock(&drvdata->spinlock);
 416                 return -EPERM;
 417         }
 418
 419         config->addr_val[idx] = val1;
 420         config->addr_type[idx] = ETM_ADDR_TYPE_RANGE;
 421         config->addr_val[idx + 1] = val2;
 422         config->addr_type[idx + 1] = ETM_ADDR_TYPE_RANGE;
 423         config->enable_ctrl1 |= (1 << (idx/2));
 424         spin_unlock(&drvdata->spinlock);
 425
 426         return size;
 427 }
 428 static DEVICE_ATTR_RW(addr_range);
 429
 430 static ssize_t addr_start_show(struct device *dev,
 431                                struct device_attribute *attr, char *buf)
 432 {
 433         u8 idx;
 434         unsigned long val;
 435         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 436         struct etm_config *config = &drvdata->config;
 437
 438         spin_lock(&drvdata->spinlock);
 439         idx = config->addr_idx;
 440         if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
 441               config->addr_type[idx] == ETM_ADDR_TYPE_START)) {
 442                 spin_unlock(&drvdata->spinlock);
 443                 return -EPERM;
 444         }
 445
 446         val = config->addr_val[idx];
 447         spin_unlock(&drvdata->spinlock);
 448
 449         return sprintf(buf, "%#lx\n", val);
 450 }
 451
 452 static ssize_t addr_start_store(struct device *dev,
 453                                 struct device_attribute *attr,
 454                                 const char *buf, size_t size)
 455 {
 456         u8 idx;
 457         int ret;
 458         unsigned long val;
 459         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 460         struct etm_config *config = &drvdata->config;
 461
 462         ret = kstrtoul(buf, 16, &val);
 463         if (ret)
 464                 return ret;
 465
 466         spin_lock(&drvdata->spinlock);
 467         idx = config->addr_idx;
 468         if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
 469               config->addr_type[idx] == ETM_ADDR_TYPE_START)) {
 470                 spin_unlock(&drvdata->spinlock);
 471                 return -EPERM;
 472         }
 473
 474         config->addr_val[idx] = val;
 475         config->addr_type[idx] = ETM_ADDR_TYPE_START;
 476         config->startstop_ctrl |= (1 << idx);
 477         config->enable_ctrl1 |= BIT(25);
 478         spin_unlock(&drvdata->spinlock);
 479
 480         return size;
 481 }
 482 static DEVICE_ATTR_RW(addr_start);
 483
 484 static ssize_t addr_stop_show(struct device *dev,
 485                               struct device_attribute *attr, char *buf)
 486 {
 487         u8 idx;
 488         unsigned long val;
 489         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 490         struct etm_config *config = &drvdata->config;
 491
 492         spin_lock(&drvdata->spinlock);
 493         idx = config->addr_idx;
 494         if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
 495               config->addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
 496                 spin_unlock(&drvdata->spinlock);
 497                 return -EPERM;
 498         }
 499
 500         val = config->addr_val[idx];
 501         spin_unlock(&drvdata->spinlock);
 502
 503         return sprintf(buf, "%#lx\n", val);
 504 }
 505
 506 static ssize_t addr_stop_store(struct device *dev,
 507                                struct device_attribute *attr,
 508                                const char *buf, size_t size)
 509 {
 510         u8 idx;
 511         int ret;
 512         unsigned long val;
 513         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 514         struct etm_config *config = &drvdata->config;
 515
 516         ret = kstrtoul(buf, 16, &val);
 517         if (ret)
 518                 return ret;
 519
 520         spin_lock(&drvdata->spinlock);
 521         idx = config->addr_idx;
 522         if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
 523               config->addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
 524                 spin_unlock(&drvdata->spinlock);
 525                 return -EPERM;
 526         }
 527
 528         config->addr_val[idx] = val;
 529         config->addr_type[idx] = ETM_ADDR_TYPE_STOP;
 530         config->startstop_ctrl |= (1 << (idx + 16));
 531         config->enable_ctrl1 |= ETMTECR1_START_STOP;
 532         spin_unlock(&drvdata->spinlock);
 533
 534         return size;
 535 }
 536 static DEVICE_ATTR_RW(addr_stop);
 537
 538 static ssize_t addr_acctype_show(struct device *dev,
 539                                  struct device_attribute *attr, char *buf)
 540 {
 541         unsigned long val;
 542         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 543         struct etm_config *config = &drvdata->config;
 544
 545         spin_lock(&drvdata->spinlock);
 546         val = config->addr_acctype[config->addr_idx];
 547         spin_unlock(&drvdata->spinlock);
 548
 549         return sprintf(buf, "%#lx\n", val);
 550 }
 551
 552 static ssize_t addr_acctype_store(struct device *dev,
 553                                   struct device_attribute *attr,
 554                                   const char *buf, size_t size)
 555 {
 556         int ret;
 557         unsigned long val;
 558         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 559         struct etm_config *config = &drvdata->config;
 560
 561         ret = kstrtoul(buf, 16, &val);
 562         if (ret)
 563                 return ret;
 564
 565         spin_lock(&drvdata->spinlock);
 566         config->addr_acctype[config->addr_idx] = val;
 567         spin_unlock(&drvdata->spinlock);
 568
 569         return size;
 570 }
 571 static DEVICE_ATTR_RW(addr_acctype);
 572
 573 static ssize_t cntr_idx_show(struct device *dev,
 574                              struct device_attribute *attr, char *buf)
 575 {
 576         unsigned long val;
 577         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 578         struct etm_config *config = &drvdata->config;
 579
 580         val = config->cntr_idx;
 581         return sprintf(buf, "%#lx\n", val);
 582 }
 583
 584 static ssize_t cntr_idx_store(struct device *dev,
 585                               struct device_attribute *attr,
 586                               const char *buf, size_t size)
 587 {
 588         int ret;
 589         unsigned long val;
 590         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 591         struct etm_config *config = &drvdata->config;
 592
 593         ret = kstrtoul(buf, 16, &val);
 594         if (ret)
 595                 return ret;
 596
 597         if (val >= drvdata->nr_cntr)
 598                 return -EINVAL;
 599         /*
 600          * Use spinlock to ensure index doesn't change while it gets
 601          * dereferenced multiple times within a spinlock block elsewhere.
 602          */
 603         spin_lock(&drvdata->spinlock);
 604         config->cntr_idx = val;
 605         spin_unlock(&drvdata->spinlock);
 606
 607         return size;
 608 }
 609 static DEVICE_ATTR_RW(cntr_idx);
 610
 611 static ssize_t cntr_rld_val_show(struct device *dev,
 612                                  struct device_attribute *attr, char *buf)
 613 {
 614         unsigned long val;
 615         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 616         struct etm_config *config = &drvdata->config;
 617
 618         spin_lock(&drvdata->spinlock);
 619         val = config->cntr_rld_val[config->cntr_idx];
 620         spin_unlock(&drvdata->spinlock);
 621
 622         return sprintf(buf, "%#lx\n", val);
 623 }
 624
 625 static ssize_t cntr_rld_val_store(struct device *dev,
 626                                   struct device_attribute *attr,
 627                                   const char *buf, size_t size)
 628 {
 629         int ret;
 630         unsigned long val;
 631         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 632         struct etm_config *config = &drvdata->config;
 633
 634         ret = kstrtoul(buf, 16, &val);
 635         if (ret)
 636                 return ret;
 637
 638         spin_lock(&drvdata->spinlock);
 639         config->cntr_rld_val[config->cntr_idx] = val;
 640         spin_unlock(&drvdata->spinlock);
 641
 642         return size;
 643 }
 644 static DEVICE_ATTR_RW(cntr_rld_val);
 645
 646 static ssize_t cntr_event_show(struct device *dev,
 647                                struct device_attribute *attr, char *buf)
 648 {
 649         unsigned long val;
 650         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 651         struct etm_config *config = &drvdata->config;
 652
 653         spin_lock(&drvdata->spinlock);
 654         val = config->cntr_event[config->cntr_idx];
 655         spin_unlock(&drvdata->spinlock);
 656
 657         return sprintf(buf, "%#lx\n", val);
 658 }
 659
 660 static ssize_t cntr_event_store(struct device *dev,
 661                                 struct device_attribute *attr,
 662                                 const char *buf, size_t size)
 663 {
 664         int ret;
 665         unsigned long val;
 666         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 667         struct etm_config *config = &drvdata->config;
 668
 669         ret = kstrtoul(buf, 16, &val);
 670         if (ret)
 671                 return ret;
 672
 673         spin_lock(&drvdata->spinlock);
 674         config->cntr_event[config->cntr_idx] = val & ETM_EVENT_MASK;
 675         spin_unlock(&drvdata->spinlock);
 676
 677         return size;
 678 }
 679 static DEVICE_ATTR_RW(cntr_event);
 680
 681 static ssize_t cntr_rld_event_show(struct device *dev,
 682                                    struct device_attribute *attr, char *buf)
 683 {
 684         unsigned long val;
 685         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 686         struct etm_config *config = &drvdata->config;
 687
 688         spin_lock(&drvdata->spinlock);
 689         val = config->cntr_rld_event[config->cntr_idx];
 690         spin_unlock(&drvdata->spinlock);
 691
 692         return sprintf(buf, "%#lx\n", val);
 693 }
 694
 695 static ssize_t cntr_rld_event_store(struct device *dev,
 696                                     struct device_attribute *attr,
 697                                     const char *buf, size_t size)
 698 {
 699         int ret;
 700         unsigned long val;
 701         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 702         struct etm_config *config = &drvdata->config;
 703
 704         ret = kstrtoul(buf, 16, &val);
 705         if (ret)
 706                 return ret;
 707
 708         spin_lock(&drvdata->spinlock);
 709         config->cntr_rld_event[config->cntr_idx] = val & ETM_EVENT_MASK;
 710         spin_unlock(&drvdata->spinlock);
 711
 712         return size;
 713 }
 714 static DEVICE_ATTR_RW(cntr_rld_event);
 715
 716 static ssize_t cntr_val_show(struct device *dev,
 717                              struct device_attribute *attr, char *buf)
 718 {
 719         int i, ret = 0;
 720         u32 val;
 721         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 722         struct etm_config *config = &drvdata->config;
 723
 724         if (!local_read(&drvdata->mode)) {
 725                 spin_lock(&drvdata->spinlock);
 726                 for (i = 0; i < drvdata->nr_cntr; i++)
 727                         ret += sprintf(buf, "counter %d: %x\n",
 728                                        i, config->cntr_val[i]);
 729                 spin_unlock(&drvdata->spinlock);
 730                 return ret;
 731         }
 732
 733         for (i = 0; i < drvdata->nr_cntr; i++) {
 734                 val = etm_readl(drvdata, ETMCNTVRn(i));
 735                 ret += sprintf(buf, "counter %d: %x\n", i, val);
 736         }
 737
 738         return ret;
 739 }
 740
 741 static ssize_t cntr_val_store(struct device *dev,
 742                               struct device_attribute *attr,
 743                               const char *buf, size_t size)
 744 {
 745         int ret;
 746         unsigned long val;
 747         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 748         struct etm_config *config = &drvdata->config;
 749
 750         ret = kstrtoul(buf, 16, &val);
 751         if (ret)
 752                 return ret;
 753
 754         spin_lock(&drvdata->spinlock);
 755         config->cntr_val[config->cntr_idx] = val;
 756         spin_unlock(&drvdata->spinlock);
 757
 758         return size;
 759 }
 760 static DEVICE_ATTR_RW(cntr_val);
 761
 762 static ssize_t seq_12_event_show(struct device *dev,
 763                                  struct device_attribute *attr, char *buf)
 764 {
 765         unsigned long val;
 766         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 767         struct etm_config *config = &drvdata->config;
 768
 769         val = config->seq_12_event;
 770         return sprintf(buf, "%#lx\n", val);
 771 }
 772
 773 static ssize_t seq_12_event_store(struct device *dev,
 774                                   struct device_attribute *attr,
 775                                   const char *buf, size_t size)
 776 {
 777         int ret;
 778         unsigned long val;
 779         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 780         struct etm_config *config = &drvdata->config;
 781
 782         ret = kstrtoul(buf, 16, &val);
 783         if (ret)
 784                 return ret;
 785
 786         config->seq_12_event = val & ETM_EVENT_MASK;
 787         return size;
 788 }
 789 static DEVICE_ATTR_RW(seq_12_event);
 790
 791 static ssize_t seq_21_event_show(struct device *dev,
 792                                  struct device_attribute *attr, char *buf)
 793 {
 794         unsigned long val;
 795         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 796         struct etm_config *config = &drvdata->config;
 797
 798         val = config->seq_21_event;
 799         return sprintf(buf, "%#lx\n", val);
 800 }
 801
 802 static ssize_t seq_21_event_store(struct device *dev,
 803                                   struct device_attribute *attr,
 804                                   const char *buf, size_t size)
 805 {
 806         int ret;
 807         unsigned long val;
 808         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 809         struct etm_config *config = &drvdata->config;
 810
 811         ret = kstrtoul(buf, 16, &val);
 812         if (ret)
 813                 return ret;
 814
 815         config->seq_21_event = val & ETM_EVENT_MASK;
 816         return size;
 817 }
 818 static DEVICE_ATTR_RW(seq_21_event);
 819
 820 static ssize_t seq_23_event_show(struct device *dev,
 821                                  struct device_attribute *attr, char *buf)
 822 {
 823         unsigned long val;
 824         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 825         struct etm_config *config = &drvdata->config;
 826
 827         val = config->seq_23_event;
 828         return sprintf(buf, "%#lx\n", val);
 829 }
 830
 831 static ssize_t seq_23_event_store(struct device *dev,
 832                                   struct device_attribute *attr,
 833                                   const char *buf, size_t size)
 834 {
 835         int ret;
 836         unsigned long val;
 837         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 838         struct etm_config *config = &drvdata->config;
 839
 840         ret = kstrtoul(buf, 16, &val);
 841         if (ret)
 842                 return ret;
 843
 844         config->seq_23_event = val & ETM_EVENT_MASK;
 845         return size;
 846 }
 847 static DEVICE_ATTR_RW(seq_23_event);
 848
 849 static ssize_t seq_31_event_show(struct device *dev,
 850                                  struct device_attribute *attr, char *buf)
 851 {
 852         unsigned long val;
 853         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 854         struct etm_config *config = &drvdata->config;
 855
 856         val = config->seq_31_event;
 857         return sprintf(buf, "%#lx\n", val);
 858 }
 859
 860 static ssize_t seq_31_event_store(struct device *dev,
 861                                   struct device_attribute *attr,
 862                                   const char *buf, size_t size)
 863 {
 864         int ret;
 865         unsigned long val;
 866         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 867         struct etm_config *config = &drvdata->config;
 868
 869         ret = kstrtoul(buf, 16, &val);
 870         if (ret)
 871                 return ret;
 872
 873         config->seq_31_event = val & ETM_EVENT_MASK;
 874         return size;
 875 }
 876 static DEVICE_ATTR_RW(seq_31_event);
 877
 878 static ssize_t seq_32_event_show(struct device *dev,
 879                                  struct device_attribute *attr, char *buf)
 880 {
 881         unsigned long val;
 882         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 883         struct etm_config *config = &drvdata->config;
 884
 885         val = config->seq_32_event;
 886         return sprintf(buf, "%#lx\n", val);
 887 }
 888
 889 static ssize_t seq_32_event_store(struct device *dev,
 890                                   struct device_attribute *attr,
 891                                   const char *buf, size_t size)
 892 {
 893         int ret;
 894         unsigned long val;
 895         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 896         struct etm_config *config = &drvdata->config;
 897
 898         ret = kstrtoul(buf, 16, &val);
 899         if (ret)
 900                 return ret;
 901
 902         config->seq_32_event = val & ETM_EVENT_MASK;
 903         return size;
 904 }
 905 static DEVICE_ATTR_RW(seq_32_event);
 906
 907 static ssize_t seq_13_event_show(struct device *dev,
 908                                  struct device_attribute *attr, char *buf)
 909 {
 910         unsigned long val;
 911         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 912         struct etm_config *config = &drvdata->config;
 913
 914         val = config->seq_13_event;
 915         return sprintf(buf, "%#lx\n", val);
 916 }
 917
 918 static ssize_t seq_13_event_store(struct device *dev,
 919                                   struct device_attribute *attr,
 920                                   const char *buf, size_t size)
 921 {
 922         int ret;
 923         unsigned long val;
 924         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 925         struct etm_config *config = &drvdata->config;
 926
 927         ret = kstrtoul(buf, 16, &val);
 928         if (ret)
 929                 return ret;
 930
 931         config->seq_13_event = val & ETM_EVENT_MASK;
 932         return size;
 933 }
 934 static DEVICE_ATTR_RW(seq_13_event);
 935
 936 static ssize_t seq_curr_state_show(struct device *dev,
 937                                    struct device_attribute *attr, char *buf)
 938 {
 939         unsigned long val, flags;
 940         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 941         struct etm_config *config = &drvdata->config;
 942
 943         if (!local_read(&drvdata->mode)) {
 944                 val = config->seq_curr_state;
 945                 goto out;
 946         }
 947
 948         pm_runtime_get_sync(drvdata->dev);
 949         spin_lock_irqsave(&drvdata->spinlock, flags);
 950
 951         CS_UNLOCK(drvdata->base);
 952         val = (etm_readl(drvdata, ETMSQR) & ETM_SQR_MASK);
 953         CS_LOCK(drvdata->base);
 954
 955         spin_unlock_irqrestore(&drvdata->spinlock, flags);
 956         pm_runtime_put(drvdata->dev);
 957 out:
 958         return sprintf(buf, "%#lx\n", val);
 959 }
 960
 961 static ssize_t seq_curr_state_store(struct device *dev,
 962                                     struct device_attribute *attr,
 963                                     const char *buf, size_t size)
 964 {
 965         int ret;
 966         unsigned long val;
 967         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 968         struct etm_config *config = &drvdata->config;
 969
 970         ret = kstrtoul(buf, 16, &val);
 971         if (ret)
 972                 return ret;
 973
 974         if (val > ETM_SEQ_STATE_MAX_VAL)
 975                 return -EINVAL;
 976
 977         config->seq_curr_state = val;
 978
 979         return size;
 980 }
 981 static DEVICE_ATTR_RW(seq_curr_state);
 982
 983 static ssize_t ctxid_idx_show(struct device *dev,
 984                               struct device_attribute *attr, char *buf)
 985 {
 986         unsigned long val;
 987         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 988         struct etm_config *config = &drvdata->config;
 989
 990         val = config->ctxid_idx;
 991         return sprintf(buf, "%#lx\n", val);
 992 }
 993
 994 static ssize_t ctxid_idx_store(struct device *dev,
 995                                 struct device_attribute *attr,
 996                                 const char *buf, size_t size)
 997 {
 998         int ret;
 999         unsigned long val;
1000         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1001         struct etm_config *config = &drvdata->config;
1002
1003         ret = kstrtoul(buf, 16, &val);
1004         if (ret)
1005                 return ret;
1006
1007         if (val >= drvdata->nr_ctxid_cmp)
1008                 return -EINVAL;
1009
1010         /*
1011          * Use spinlock to ensure index doesn't change while it gets
1012          * dereferenced multiple times within a spinlock block elsewhere.
1013          */
1014         spin_lock(&drvdata->spinlock);
1015         config->ctxid_idx = val;
1016         spin_unlock(&drvdata->spinlock);
1017
1018         return size;
1019 }
1020 static DEVICE_ATTR_RW(ctxid_idx);
1021
1022 static ssize_t ctxid_pid_show(struct device *dev,
1023                               struct device_attribute *attr, char *buf)
1024 {
1025         unsigned long val;
1026         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1027         struct etm_config *config = &drvdata->config;
1028
1029         spin_lock(&drvdata->spinlock);
1030         val = config->ctxid_vpid[config->ctxid_idx];
1031         spin_unlock(&drvdata->spinlock);
1032
1033         return sprintf(buf, "%#lx\n", val);
1034 }
1035
1036 static ssize_t ctxid_pid_store(struct device *dev,
1037                                struct device_attribute *attr,
1038                                const char *buf, size_t size)
1039 {
1040         int ret;
1041         unsigned long vpid, pid;
1042         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1043         struct etm_config *config = &drvdata->config;
1044
1045         ret = kstrtoul(buf, 16, &vpid);
1046         if (ret)
1047                 return ret;
1048
1049         pid = coresight_vpid_to_pid(vpid);
1050
1051         spin_lock(&drvdata->spinlock);
1052         config->ctxid_pid[config->ctxid_idx] = pid;
1053         config->ctxid_vpid[config->ctxid_idx] = vpid;
1054         spin_unlock(&drvdata->spinlock);
1055
1056         return size;
1057 }
1058 static DEVICE_ATTR_RW(ctxid_pid);
1059
1060 static ssize_t ctxid_mask_show(struct device *dev,
1061                                struct device_attribute *attr, char *buf)
1062 {
1063         unsigned long val;
1064         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1065         struct etm_config *config = &drvdata->config;
1066
1067         val = config->ctxid_mask;
1068         return sprintf(buf, "%#lx\n", val);
1069 }
1070
1071 static ssize_t ctxid_mask_store(struct device *dev,
1072                                 struct device_attribute *attr,
1073                                 const char *buf, size_t size)
1074 {
1075         int ret;
1076         unsigned long val;
1077         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1078         struct etm_config *config = &drvdata->config;
1079
1080         ret = kstrtoul(buf, 16, &val);
1081         if (ret)
1082                 return ret;
1083
1084         config->ctxid_mask = val;
1085         return size;
1086 }
1087 static DEVICE_ATTR_RW(ctxid_mask);
1088
1089 static ssize_t sync_freq_show(struct device *dev,
1090                               struct device_attribute *attr, char *buf)
1091 {
1092         unsigned long val;
1093         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1094         struct etm_config *config = &drvdata->config;
1095
1096         val = config->sync_freq;
1097         return sprintf(buf, "%#lx\n", val);
1098 }
1099
1100 static ssize_t sync_freq_store(struct device *dev,
1101                                struct device_attribute *attr,
1102                                const char *buf, size_t size)
1103 {
1104         int ret;
1105         unsigned long val;
1106         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1107         struct etm_config *config = &drvdata->config;
1108
1109         ret = kstrtoul(buf, 16, &val);
1110         if (ret)
1111                 return ret;
1112
1113         config->sync_freq = val & ETM_SYNC_MASK;
1114         return size;
1115 }
1116 static DEVICE_ATTR_RW(sync_freq);
1117
1118 static ssize_t timestamp_event_show(struct device *dev,
1119                                     struct device_attribute *attr, char *buf)
1120 {
1121         unsigned long val;
1122         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1123         struct etm_config *config = &drvdata->config;
1124
1125         val = config->timestamp_event;
1126         return sprintf(buf, "%#lx\n", val);
1127 }
1128
1129 static ssize_t timestamp_event_store(struct device *dev,
1130                                      struct device_attribute *attr,
1131                                      const char *buf, size_t size)
1132 {
1133         int ret;
1134         unsigned long val;
1135         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1136         struct etm_config *config = &drvdata->config;
1137
1138         ret = kstrtoul(buf, 16, &val);
1139         if (ret)
1140                 return ret;
1141
1142         config->timestamp_event = val & ETM_EVENT_MASK;
1143         return size;
1144 }
1145 static DEVICE_ATTR_RW(timestamp_event);
1146
1147 static ssize_t cpu_show(struct device *dev,
1148                         struct device_attribute *attr, char *buf)
1149 {
1150         int val;
1151         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1152
1153         val = drvdata->cpu;
1154         return scnprintf(buf, PAGE_SIZE, "%d\n", val);
1155
1156 }
1157 static DEVICE_ATTR_RO(cpu);
1158
1159 static ssize_t traceid_show(struct device *dev,
1160                             struct device_attribute *attr, char *buf)
1161 {
1162         unsigned long val;
1163         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1164
1165         val = etm_get_trace_id(drvdata);
1166
1167         return sprintf(buf, "%#lx\n", val);
1168 }
1169
1170 static ssize_t traceid_store(struct device *dev,
1171                              struct device_attribute *attr,
1172                              const char *buf, size_t size)
1173 {
1174         int ret;
1175         unsigned long val;
1176         struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1177
1178         ret = kstrtoul(buf, 16, &val);
1179         if (ret)
1180                 return ret;
1181
1182         drvdata->traceid = val & ETM_TRACEID_MASK;
1183         return size;
1184 }
1185 static DEVICE_ATTR_RW(traceid);
1186
1187 static struct attribute *coresight_etm_attrs[] = {
1188         &dev_attr_nr_addr_cmp.attr,
1189         &dev_attr_nr_cntr.attr,
1190         &dev_attr_nr_ctxid_cmp.attr,
1191         &dev_attr_etmsr.attr,
1192         &dev_attr_reset.attr,
1193         &dev_attr_mode.attr,
1194         &dev_attr_trigger_event.attr,
1195         &dev_attr_enable_event.attr,
1196         &dev_attr_fifofull_level.attr,
1197         &dev_attr_addr_idx.attr,
1198         &dev_attr_addr_single.attr,
1199         &dev_attr_addr_range.attr,
1200         &dev_attr_addr_start.attr,
1201         &dev_attr_addr_stop.attr,
1202         &dev_attr_addr_acctype.attr,
1203         &dev_attr_cntr_idx.attr,
1204         &dev_attr_cntr_rld_val.attr,
1205         &dev_attr_cntr_event.attr,
1206         &dev_attr_cntr_rld_event.attr,
1207         &dev_attr_cntr_val.attr,
1208         &dev_attr_seq_12_event.attr,
1209         &dev_attr_seq_21_event.attr,
1210         &dev_attr_seq_23_event.attr,
1211         &dev_attr_seq_31_event.attr,
1212         &dev_attr_seq_32_event.attr,
1213         &dev_attr_seq_13_event.attr,
1214         &dev_attr_seq_curr_state.attr,
1215         &dev_attr_ctxid_idx.attr,
1216         &dev_attr_ctxid_pid.attr,
1217         &dev_attr_ctxid_mask.attr,
1218         &dev_attr_sync_freq.attr,
1219         &dev_attr_timestamp_event.attr,
1220         &dev_attr_traceid.attr,
1221         &dev_attr_cpu.attr,
1222         NULL,
1223 };
1224
1225 #define coresight_etm3x_simple_func(name, offset)                       \
1226         coresight_simple_func(struct etm_drvdata, NULL, name, offset)
1227
1228 coresight_etm3x_simple_func(etmccr, ETMCCR);
1229 coresight_etm3x_simple_func(etmccer, ETMCCER);
1230 coresight_etm3x_simple_func(etmscr, ETMSCR);
1231 coresight_etm3x_simple_func(etmidr, ETMIDR);
1232 coresight_etm3x_simple_func(etmcr, ETMCR);
1233 coresight_etm3x_simple_func(etmtraceidr, ETMTRACEIDR);
1234 coresight_etm3x_simple_func(etmteevr, ETMTEEVR);
1235 coresight_etm3x_simple_func(etmtssvr, ETMTSSCR);
1236 coresight_etm3x_simple_func(etmtecr1, ETMTECR1);
1237 coresight_etm3x_simple_func(etmtecr2, ETMTECR2);
1238
1239 static struct attribute *coresight_etm_mgmt_attrs[] = {
1240         &dev_attr_etmccr.attr,
1241         &dev_attr_etmccer.attr,
1242         &dev_attr_etmscr.attr,
1243         &dev_attr_etmidr.attr,
1244         &dev_attr_etmcr.attr,
1245         &dev_attr_etmtraceidr.attr,
1246         &dev_attr_etmteevr.attr,
1247         &dev_attr_etmtssvr.attr,
1248         &dev_attr_etmtecr1.attr,
1249         &dev_attr_etmtecr2.attr,
1250         NULL,
1251 };
1252
1253 static const struct attribute_group coresight_etm_group = {
1254         .attrs = coresight_etm_attrs,
1255 };
1256
1257 static const struct attribute_group coresight_etm_mgmt_group = {
1258         .attrs = coresight_etm_mgmt_attrs,
1259         .name = "mgmt",
1260 };
1261
1262 const struct attribute_group *coresight_etm_groups[] = {
1263         &coresight_etm_group,
1264         &coresight_etm_mgmt_group,
1265         NULL,
1266 };