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