LXR linux/drivers/hwtracing/coresight/coresight-etm3x-sysfs.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright(C) 2015 Linaro Limited. All rights reserved.
   4 * Author: Mathieu Poirier <mathieu.poirier@linaro.org>
   5 */
   6
   7#include <linux/pid_namespace.h>
   8#include <linux/pm_runtime.h>
   9#include <linux/sysfs.h>
  10#include "coresight-etm.h"
  11#include "coresight-priv.h"
  12
  13static ssize_t nr_addr_cmp_show(struct device *dev,
  14                                struct device_attribute *attr, char *buf)
  15{
  16        unsigned long val;
  17        struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
  18
  19        val = drvdata->nr_addr_cmp;
  20        return sprintf(buf, "%#lx\n", val);
  21}
  22static DEVICE_ATTR_RO(nr_addr_cmp);
  23
  24static ssize_t nr_cntr_show(struct device *dev,
  25                            struct device_attribute *attr, char *buf)
  26{       unsigned long val;
  27        struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
  28
  29        val = drvdata->nr_cntr;
  30        return sprintf(buf, "%#lx\n", val);
  31}
  32static DEVICE_ATTR_RO(nr_cntr);
  33
  34static ssize_t nr_ctxid_cmp_show(struct device *dev,
  35                                 struct device_attribute *attr, char *buf)
  36{
  37        unsigned long val;
  38        struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
  39
  40        val = drvdata->nr_ctxid_cmp;
  41        return sprintf(buf, "%#lx\n", val);
  42}
  43static DEVICE_ATTR_RO(nr_ctxid_cmp);
  44
  45static ssize_t etmsr_show(struct device *dev,
  46                          struct device_attribute *attr, char *buf)
  47{
  48        unsigned long flags, val;
  49        struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
  50
  51        pm_runtime_get_sync(drvdata->dev);
  52        spin_lock_irqsave(&drvdata->spinlock, flags);
  53        CS_UNLOCK(drvdata->base);
  54
  55        val = etm_readl(drvdata, ETMSR);
  56
  57        CS_LOCK(drvdata->base);
  58        spin_unlock_irqrestore(&drvdata->spinlock, flags);
  59        pm_runtime_put(drvdata->dev);
  60
  61        return sprintf(buf, "%#lx\n", val);
  62}
  63static DEVICE_ATTR_RO(etmsr);
  64
  65static ssize_t reset_store(struct device *dev,
  66                           struct device_attribute *attr,
  67                           const char *buf, size_t size)
  68{
  69        int i, ret;
  70        unsigned long val;
  71        struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
  72        struct etm_config *config = &drvdata->config;
  73
  74        ret = kstrtoul(buf, 16, &val);
  75        if (ret)
  76                return ret;
  77
  78        if (val) {
  79                spin_lock(&drvdata->spinlock);
  80                memset(config, 0, sizeof(struct etm_config));
  81                config->mode = ETM_MODE_EXCLUDE;
  82                config->trigger_event = ETM_DEFAULT_EVENT_VAL;
  83                for (i = 0; i < drvdata->nr_addr_cmp; i++) {
  84                        config->addr_type[i] = ETM_ADDR_TYPE_NONE;
  85                }
  86
  87                etm_set_default(config);
  88                spin_unlock(&drvdata->spinlock);
  89        }
  90
  91        return size;
  92}
  93static DEVICE_ATTR_WO(reset);
  94
  95static ssize_t mode_show(struct device *dev,
  96                         struct device_attribute *attr, char *buf)
  97{
  98        unsigned long val;
  99        struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 100        struct etm_config *config = &drvdata->config;
 101
 102        val = config->mode;
 103        return sprintf(buf, "%#lx\n", val);
 104}
 105
 106static ssize_t mode_store(struct device *dev,
 107                          struct device_attribute *attr,
 108                          const char *buf, size_t size)
 109{
 110        int ret;
 111        unsigned long val;
 112        struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
 113        struct etm_config *config = &drvdata->config;
 114
 115        ret = kstrtoul(buf, 16, &val);
 116        if (ret)
 117                return ret;
 118
 119        spin_lock(&drvdata->spinlock);
 120        config->mode = val & ETM_MODE_ALL;
 121
 122        if (config->mode & ETM_MODE_EXCLUDE)
 123                config->enable_ctrl1 |= ETMTECR1_INC_EXC;
 124        else
 125                config->enable_ctrl1 &= ~ETMTECR1_INC_EXC;
 126
 127        if (config->mode & ETM_MODE_CYCACC)
 128                config->ctrl |= ETMCR_CYC_ACC;
 129        else
 130                config->ctrl &= ~ETMCR_CYC_ACC;
 131
 132        if (config->mode & ETM_MODE_STALL) {
 133                if (!(drvdata->etmccr & ETMCCR_FIFOFULL)) {
 134                        dev_warn(drvdata->dev, "stall mode not supported\n");
 135                        ret = -EINVAL;
 136                        goto err_unlock;
 137                }
 138                config->ctrl |= ETMCR_STALL_MODE;
 139        } else
 140                config->ctrl &= ~ETMCR_STALL_MODE;
 141
 142        if (config->mode & ETM_MODE_TIMESTAMP) {
 143                if (!(drvdata->etmccer & ETMCCER_TIMESTAMP)) {
 144                        dev_warn(drvdata->dev, "timestamp not supported\n");
 145                        ret = -EINVAL;
 146                        goto err_unlock;
 147                }
 148                config->ctrl |= ETMCR_TIMESTAMP_EN;
 149        } else
 150                config->ctrl &= ~ETMCR_TIMESTAMP_EN;
 151
 152        if (config->mode & ETM_MODE_CTXID)
 153                config->ctrl |= ETMCR_CTXID_SIZE;
 154        else
 155                config->ctrl &= ~ETMCR_CTXID_SIZE;
 156
 157        if (config->mode & ETM_MODE_BBROAD)
 158                config->ctrl |= ETMCR_BRANCH_BROADCAST;
 159        else
 160                config->ctrl &= ~ETMCR_BRANCH_BROADCAST;
 161
 162        if (config->mode & ETM_MODE_RET_STACK)
 163                config->ctrl |= ETMCR_RETURN_STACK;
 164        else
 165                config->ctrl &= ~ETMCR_RETURN_STACK;
 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
 174err_unlock:
 175        spin_unlock(&drvdata->spinlock);
 176        return ret;
 177}
 178static DEVICE_ATTR_RW(mode);
 179
 180static 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
 191static 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}
 208static DEVICE_ATTR_RW(trigger_event);
 209
 210static 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
 221static 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}
 238static DEVICE_ATTR_RW(enable_event);
 239
 240static 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
 251static 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}
 268static DEVICE_ATTR_RW(fifofull_level);
 269
 270static 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
 281static 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}
 307static DEVICE_ATTR_RW(addr_idx);
 308
 309static 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
 331static 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}
 359static DEVICE_ATTR_RW(addr_single);
 360
 361static 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
 390static 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}
 428static DEVICE_ATTR_RW(addr_range);
 429
 430static 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
 452static 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}
 482static DEVICE_ATTR_RW(addr_start);
 483
 484static 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
 506static 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}
 536static DEVICE_ATTR_RW(addr_stop);
 537
 538static 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
 552static 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}
 571static DEVICE_ATTR_RW(addr_acctype);
 572
 573static 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
 584static 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}
 609static DEVICE_ATTR_RW(cntr_idx);
 610
 611static 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
 625static 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}
 644static DEVICE_ATTR_RW(cntr_rld_val);
 645
 646static 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
 660static 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}
 679static DEVICE_ATTR_RW(cntr_event);
 680
 681static 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
 695static 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}
 714static DEVICE_ATTR_RW(cntr_rld_event);
 715
 716static 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
 741static 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}
 760static DEVICE_ATTR_RW(cntr_val);
 761
 762static 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
 773static 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}
 789static DEVICE_ATTR_RW(seq_12_event);
 790
 791static 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
 802static 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}
 818static DEVICE_ATTR_RW(seq_21_event);
 819
 820static 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
 831static 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}
 847static DEVICE_ATTR_RW(seq_23_event);
 848
 849static 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
 860static 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}
 876static DEVICE_ATTR_RW(seq_31_event);
 877
 878static 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
 889static 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}
 905static DEVICE_ATTR_RW(seq_32_event);
 906
 907static 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
 918static 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}
 934static DEVICE_ATTR_RW(seq_13_event);
 935
 936static 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);
 957out:
 958        return sprintf(buf, "%#lx\n", val);
 959}
 960
 961static 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}
 981static DEVICE_ATTR_RW(seq_curr_state);
 982
 983static 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
 994static 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}
1020static DEVICE_ATTR_RW(ctxid_idx);
1021
1022static 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        /*
1030         * Don't use contextID tracing if coming from a PID namespace.  See
1031         * comment in ctxid_pid_store().
1032         */
1033        if (task_active_pid_ns(current) != &init_pid_ns)
1034                return -EINVAL;
1035
1036        spin_lock(&drvdata->spinlock);
1037        val = config->ctxid_pid[config->ctxid_idx];
1038        spin_unlock(&drvdata->spinlock);
1039
1040        return sprintf(buf, "%#lx\n", val);
1041}
1042
1043static ssize_t ctxid_pid_store(struct device *dev,
1044                               struct device_attribute *attr,
1045                               const char *buf, size_t size)
1046{
1047        int ret;
1048        unsigned long pid;
1049        struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1050        struct etm_config *config = &drvdata->config;
1051
1052        /*
1053         * When contextID tracing is enabled the tracers will insert the
1054         * value found in the contextID register in the trace stream.  But if
1055         * a process is in a namespace the PID of that process as seen from the
1056         * namespace won't be what the kernel sees, something that makes the
1057         * feature confusing and can potentially leak kernel only information.
1058         * As such refuse to use the feature if @current is not in the initial
1059         * PID namespace.
1060         */
1061        if (task_active_pid_ns(current) != &init_pid_ns)
1062                return -EINVAL;
1063
1064        ret = kstrtoul(buf, 16, &pid);
1065        if (ret)
1066                return ret;
1067
1068        spin_lock(&drvdata->spinlock);
1069        config->ctxid_pid[config->ctxid_idx] = pid;
1070        spin_unlock(&drvdata->spinlock);
1071
1072        return size;
1073}
1074static DEVICE_ATTR_RW(ctxid_pid);
1075
1076static ssize_t ctxid_mask_show(struct device *dev,
1077                               struct device_attribute *attr, char *buf)
1078{
1079        unsigned long val;
1080        struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1081        struct etm_config *config = &drvdata->config;
1082
1083        /*
1084         * Don't use contextID tracing if coming from a PID namespace.  See
1085         * comment in ctxid_pid_store().
1086         */
1087        if (task_active_pid_ns(current) != &init_pid_ns)
1088                return -EINVAL;
1089
1090        val = config->ctxid_mask;
1091        return sprintf(buf, "%#lx\n", val);
1092}
1093
1094static ssize_t ctxid_mask_store(struct device *dev,
1095                                struct device_attribute *attr,
1096                                const char *buf, size_t size)
1097{
1098        int ret;
1099        unsigned long val;
1100        struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1101        struct etm_config *config = &drvdata->config;
1102
1103        /*
1104         * Don't use contextID tracing if coming from a PID namespace.  See
1105         * comment in ctxid_pid_store().
1106         */
1107        if (task_active_pid_ns(current) != &init_pid_ns)
1108                return -EINVAL;
1109
1110        ret = kstrtoul(buf, 16, &val);
1111        if (ret)
1112                return ret;
1113
1114        config->ctxid_mask = val;
1115        return size;
1116}
1117static DEVICE_ATTR_RW(ctxid_mask);
1118
1119static ssize_t sync_freq_show(struct device *dev,
1120                              struct device_attribute *attr, char *buf)
1121{
1122        unsigned long val;
1123        struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1124        struct etm_config *config = &drvdata->config;
1125
1126        val = config->sync_freq;
1127        return sprintf(buf, "%#lx\n", val);
1128}
1129
1130static ssize_t sync_freq_store(struct device *dev,
1131                               struct device_attribute *attr,
1132                               const char *buf, size_t size)
1133{
1134        int ret;
1135        unsigned long val;
1136        struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1137        struct etm_config *config = &drvdata->config;
1138
1139        ret = kstrtoul(buf, 16, &val);
1140        if (ret)
1141                return ret;
1142
1143        config->sync_freq = val & ETM_SYNC_MASK;
1144        return size;
1145}
1146static DEVICE_ATTR_RW(sync_freq);
1147
1148static ssize_t timestamp_event_show(struct device *dev,
1149                                    struct device_attribute *attr, char *buf)
1150{
1151        unsigned long val;
1152        struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1153        struct etm_config *config = &drvdata->config;
1154
1155        val = config->timestamp_event;
1156        return sprintf(buf, "%#lx\n", val);
1157}
1158
1159static ssize_t timestamp_event_store(struct device *dev,
1160                                     struct device_attribute *attr,
1161                                     const char *buf, size_t size)
1162{
1163        int ret;
1164        unsigned long val;
1165        struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1166        struct etm_config *config = &drvdata->config;
1167
1168        ret = kstrtoul(buf, 16, &val);
1169        if (ret)
1170                return ret;
1171
1172        config->timestamp_event = val & ETM_EVENT_MASK;
1173        return size;
1174}
1175static DEVICE_ATTR_RW(timestamp_event);
1176
1177static ssize_t cpu_show(struct device *dev,
1178                        struct device_attribute *attr, char *buf)
1179{
1180        int val;
1181        struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1182
1183        val = drvdata->cpu;
1184        return scnprintf(buf, PAGE_SIZE, "%d\n", val);
1185
1186}
1187static DEVICE_ATTR_RO(cpu);
1188
1189static ssize_t traceid_show(struct device *dev,
1190                            struct device_attribute *attr, char *buf)
1191{
1192        unsigned long val;
1193        struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1194
1195        val = etm_get_trace_id(drvdata);
1196
1197        return sprintf(buf, "%#lx\n", val);
1198}
1199
1200static ssize_t traceid_store(struct device *dev,
1201                             struct device_attribute *attr,
1202                             const char *buf, size_t size)
1203{
1204        int ret;
1205        unsigned long val;
1206        struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent);
1207
1208        ret = kstrtoul(buf, 16, &val);
1209        if (ret)
1210                return ret;
1211
1212        drvdata->traceid = val & ETM_TRACEID_MASK;
1213        return size;
1214}
1215static DEVICE_ATTR_RW(traceid);
1216
1217static struct attribute *coresight_etm_attrs[] = {
1218        &dev_attr_nr_addr_cmp.attr,
1219        &dev_attr_nr_cntr.attr,
1220        &dev_attr_nr_ctxid_cmp.attr,
1221        &dev_attr_etmsr.attr,
1222        &dev_attr_reset.attr,
1223        &dev_attr_mode.attr,
1224        &dev_attr_trigger_event.attr,
1225        &dev_attr_enable_event.attr,
1226        &dev_attr_fifofull_level.attr,
1227        &dev_attr_addr_idx.attr,
1228        &dev_attr_addr_single.attr,
1229        &dev_attr_addr_range.attr,
1230        &dev_attr_addr_start.attr,
1231        &dev_attr_addr_stop.attr,
1232        &dev_attr_addr_acctype.attr,
1233        &dev_attr_cntr_idx.attr,
1234        &dev_attr_cntr_rld_val.attr,
1235        &dev_attr_cntr_event.attr,
1236        &dev_attr_cntr_rld_event.attr,
1237        &dev_attr_cntr_val.attr,
1238        &dev_attr_seq_12_event.attr,
1239        &dev_attr_seq_21_event.attr,
1240        &dev_attr_seq_23_event.attr,
1241        &dev_attr_seq_31_event.attr,
1242        &dev_attr_seq_32_event.attr,
1243        &dev_attr_seq_13_event.attr,
1244        &dev_attr_seq_curr_state.attr,
1245        &dev_attr_ctxid_idx.attr,
1246        &dev_attr_ctxid_pid.attr,
1247        &dev_attr_ctxid_mask.attr,
1248        &dev_attr_sync_freq.attr,
1249        &dev_attr_timestamp_event.attr,
1250        &dev_attr_traceid.attr,
1251        &dev_attr_cpu.attr,
1252        NULL,
1253};
1254
1255#define coresight_etm3x_reg(name, offset)                       \
1256        coresight_simple_reg32(struct etm_drvdata, name, offset)
1257
1258coresight_etm3x_reg(etmccr, ETMCCR);
1259coresight_etm3x_reg(etmccer, ETMCCER);
1260coresight_etm3x_reg(etmscr, ETMSCR);
1261coresight_etm3x_reg(etmidr, ETMIDR);
1262coresight_etm3x_reg(etmcr, ETMCR);
1263coresight_etm3x_reg(etmtraceidr, ETMTRACEIDR);
1264coresight_etm3x_reg(etmteevr, ETMTEEVR);
1265coresight_etm3x_reg(etmtssvr, ETMTSSCR);
1266coresight_etm3x_reg(etmtecr1, ETMTECR1);
1267coresight_etm3x_reg(etmtecr2, ETMTECR2);
1268
1269static struct attribute *coresight_etm_mgmt_attrs[] = {
1270        &dev_attr_etmccr.attr,
1271        &dev_attr_etmccer.attr,
1272        &dev_attr_etmscr.attr,
1273        &dev_attr_etmidr.attr,
1274        &dev_attr_etmcr.attr,
1275        &dev_attr_etmtraceidr.attr,
1276        &dev_attr_etmteevr.attr,
1277        &dev_attr_etmtssvr.attr,
1278        &dev_attr_etmtecr1.attr,
1279        &dev_attr_etmtecr2.attr,
1280        NULL,
1281};
1282
1283static const struct attribute_group coresight_etm_group = {
1284        .attrs = coresight_etm_attrs,
1285};
1286
1287static const struct attribute_group coresight_etm_mgmt_group = {
1288        .attrs = coresight_etm_mgmt_attrs,
1289        .name = "mgmt",
1290};
1291
1292const struct attribute_group *coresight_etm_groups[] = {
1293        &coresight_etm_group,
1294        &coresight_etm_mgmt_group,
1295        NULL,
1296};
1297