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