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