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

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

DEFINITIONS
