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

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