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