1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2019 Linaro Limited, All rights reserved. 4 * Author: Mike Leach <mike.leach@linaro.org> 5 */ 6 7 #include <linux/atomic.h> 8 #include <linux/coresight.h> 9 #include <linux/device.h> 10 #include <linux/io.h> 11 #include <linux/kernel.h> 12 #include <linux/spinlock.h> 13 #include <linux/sysfs.h> 14 15 #include "coresight-cti.h" 16 17 /* 18 * Declare the number of static declared attribute groups 19 * Value includes groups + NULL value at end of table. 20 */ 21 #define CORESIGHT_CTI_STATIC_GROUPS_MAX 5 22 23 /* 24 * List of trigger signal type names. Match the constants declared in 25 * include\dt-bindings\arm\coresight-cti-dt.h 26 */ 27 static const char * const sig_type_names[] = { 28 "genio", /* GEN_IO */ 29 "intreq", /* GEN_INTREQ */ 30 "intack", /* GEN_INTACK */ 31 "haltreq", /* GEN_HALTREQ */ 32 "restartreq", /* GEN_RESTARTREQ */ 33 "pe_edbgreq", /* PE_EDBGREQ */ 34 "pe_dbgrestart",/* PE_DBGRESTART */ 35 "pe_ctiirq", /* PE_CTIIRQ */ 36 "pe_pmuirq", /* PE_PMUIRQ */ 37 "pe_dbgtrigger",/* PE_DBGTRIGGER */ 38 "etm_extout", /* ETM_EXTOUT */ 39 "etm_extin", /* ETM_EXTIN */ 40 "snk_full", /* SNK_FULL */ 41 "snk_acqcomp", /* SNK_ACQCOMP */ 42 "snk_flushcomp",/* SNK_FLUSHCOMP */ 43 "snk_flushin", /* SNK_FLUSHIN */ 44 "snk_trigin", /* SNK_TRIGIN */ 45 "stm_asyncout", /* STM_ASYNCOUT */ 46 "stm_tout_spte",/* STM_TOUT_SPTE */ 47 "stm_tout_sw", /* STM_TOUT_SW */ 48 "stm_tout_hete",/* STM_TOUT_HETE */ 49 "stm_hwevent", /* STM_HWEVENT */ 50 "ela_tstart", /* ELA_TSTART */ 51 "ela_tstop", /* ELA_TSTOP */ 52 "ela_dbgreq", /* ELA_DBGREQ */ 53 }; 54 55 /* Show function pointer used in the connections dynamic declared attributes*/ 56 typedef ssize_t (*p_show_fn)(struct device *dev, struct device_attribute *attr, 57 char *buf); 58 59 /* Connection attribute types */ 60 enum cti_conn_attr_type { 61 CTI_CON_ATTR_NAME, 62 CTI_CON_ATTR_TRIGIN_SIG, 63 CTI_CON_ATTR_TRIGOUT_SIG, 64 CTI_CON_ATTR_TRIGIN_TYPES, 65 CTI_CON_ATTR_TRIGOUT_TYPES, 66 CTI_CON_ATTR_MAX, 67 }; 68 69 /* Names for the connection attributes */ 70 static const char * const con_attr_names[CTI_CON_ATTR_MAX] = { 71 "name", 72 "in_signals", 73 "out_signals", 74 "in_types", 75 "out_types", 76 }; 77 78 /* basic attributes */ 79 static ssize_t enable_show(struct device *dev, 80 struct device_attribute *attr, 81 char *buf) 82 { 83 int enable_req; 84 bool enabled, powered; 85 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 86 87 enable_req = atomic_read(&drvdata->config.enable_req_count); 88 spin_lock(&drvdata->spinlock); 89 powered = drvdata->config.hw_powered; 90 enabled = drvdata->config.hw_enabled; 91 spin_unlock(&drvdata->spinlock); 92 93 if (powered) 94 return sprintf(buf, "%d\n", enabled); 95 else 96 return sprintf(buf, "%d\n", !!enable_req); 97 } 98 99 static ssize_t enable_store(struct device *dev, 100 struct device_attribute *attr, 101 const char *buf, size_t size) 102 { 103 int ret = 0; 104 unsigned long val; 105 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 106 107 ret = kstrtoul(buf, 0, &val); 108 if (ret) 109 return ret; 110 111 if (val) 112 ret = cti_enable(drvdata->csdev); 113 else 114 ret = cti_disable(drvdata->csdev); 115 if (ret) 116 return ret; 117 return size; 118 } 119 static DEVICE_ATTR_RW(enable); 120 121 static ssize_t powered_show(struct device *dev, 122 struct device_attribute *attr, 123 char *buf) 124 { 125 bool powered; 126 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 127 128 spin_lock(&drvdata->spinlock); 129 powered = drvdata->config.hw_powered; 130 spin_unlock(&drvdata->spinlock); 131 132 return sprintf(buf, "%d\n", powered); 133 } 134 static DEVICE_ATTR_RO(powered); 135 136 static ssize_t ctmid_show(struct device *dev, 137 struct device_attribute *attr, char *buf) 138 { 139 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 140 141 return sprintf(buf, "%d\n", drvdata->ctidev.ctm_id); 142 } 143 static DEVICE_ATTR_RO(ctmid); 144 145 static ssize_t nr_trigger_cons_show(struct device *dev, 146 struct device_attribute *attr, 147 char *buf) 148 { 149 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 150 151 return sprintf(buf, "%d\n", drvdata->ctidev.nr_trig_con); 152 } 153 static DEVICE_ATTR_RO(nr_trigger_cons); 154 155 /* attribute and group sysfs tables. */ 156 static struct attribute *coresight_cti_attrs[] = { 157 &dev_attr_enable.attr, 158 &dev_attr_powered.attr, 159 &dev_attr_ctmid.attr, 160 &dev_attr_nr_trigger_cons.attr, 161 NULL, 162 }; 163 164 /* register based attributes */ 165 166 /* macro to access RO registers with power check only (no enable check). */ 167 #define coresight_cti_reg(name, offset) \ 168 static ssize_t name##_show(struct device *dev, \ 169 struct device_attribute *attr, char *buf) \ 170 { \ 171 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); \ 172 u32 val = 0; \ 173 pm_runtime_get_sync(dev->parent); \ 174 spin_lock(&drvdata->spinlock); \ 175 if (drvdata->config.hw_powered) \ 176 val = readl_relaxed(drvdata->base + offset); \ 177 spin_unlock(&drvdata->spinlock); \ 178 pm_runtime_put_sync(dev->parent); \ 179 return sprintf(buf, "0x%x\n", val); \ 180 } \ 181 static DEVICE_ATTR_RO(name) 182 183 /* coresight management registers */ 184 coresight_cti_reg(devaff0, CTIDEVAFF0); 185 coresight_cti_reg(devaff1, CTIDEVAFF1); 186 coresight_cti_reg(authstatus, CORESIGHT_AUTHSTATUS); 187 coresight_cti_reg(devarch, CORESIGHT_DEVARCH); 188 coresight_cti_reg(devid, CORESIGHT_DEVID); 189 coresight_cti_reg(devtype, CORESIGHT_DEVTYPE); 190 coresight_cti_reg(pidr0, CORESIGHT_PERIPHIDR0); 191 coresight_cti_reg(pidr1, CORESIGHT_PERIPHIDR1); 192 coresight_cti_reg(pidr2, CORESIGHT_PERIPHIDR2); 193 coresight_cti_reg(pidr3, CORESIGHT_PERIPHIDR3); 194 coresight_cti_reg(pidr4, CORESIGHT_PERIPHIDR4); 195 196 static struct attribute *coresight_cti_mgmt_attrs[] = { 197 &dev_attr_devaff0.attr, 198 &dev_attr_devaff1.attr, 199 &dev_attr_authstatus.attr, 200 &dev_attr_devarch.attr, 201 &dev_attr_devid.attr, 202 &dev_attr_devtype.attr, 203 &dev_attr_pidr0.attr, 204 &dev_attr_pidr1.attr, 205 &dev_attr_pidr2.attr, 206 &dev_attr_pidr3.attr, 207 &dev_attr_pidr4.attr, 208 NULL, 209 }; 210 211 /* CTI low level programming registers */ 212 213 /* 214 * Show a simple 32 bit value if enabled and powered. 215 * If inaccessible & pcached_val not NULL then show cached value. 216 */ 217 static ssize_t cti_reg32_show(struct device *dev, char *buf, 218 u32 *pcached_val, int reg_offset) 219 { 220 u32 val = 0; 221 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 222 struct cti_config *config = &drvdata->config; 223 224 spin_lock(&drvdata->spinlock); 225 if ((reg_offset >= 0) && cti_active(config)) { 226 CS_UNLOCK(drvdata->base); 227 val = readl_relaxed(drvdata->base + reg_offset); 228 if (pcached_val) 229 *pcached_val = val; 230 CS_LOCK(drvdata->base); 231 } else if (pcached_val) { 232 val = *pcached_val; 233 } 234 spin_unlock(&drvdata->spinlock); 235 return sprintf(buf, "%#x\n", val); 236 } 237 238 /* 239 * Store a simple 32 bit value. 240 * If pcached_val not NULL, then copy to here too, 241 * if reg_offset >= 0 then write through if enabled. 242 */ 243 static ssize_t cti_reg32_store(struct device *dev, const char *buf, 244 size_t size, u32 *pcached_val, int reg_offset) 245 { 246 unsigned long val; 247 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 248 struct cti_config *config = &drvdata->config; 249 250 if (kstrtoul(buf, 0, &val)) 251 return -EINVAL; 252 253 spin_lock(&drvdata->spinlock); 254 /* local store */ 255 if (pcached_val) 256 *pcached_val = (u32)val; 257 258 /* write through if offset and enabled */ 259 if ((reg_offset >= 0) && cti_active(config)) 260 cti_write_single_reg(drvdata, reg_offset, val); 261 spin_unlock(&drvdata->spinlock); 262 return size; 263 } 264 265 /* Standard macro for simple rw cti config registers */ 266 #define cti_config_reg32_rw(name, cfgname, offset) \ 267 static ssize_t name##_show(struct device *dev, \ 268 struct device_attribute *attr, \ 269 char *buf) \ 270 { \ 271 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); \ 272 return cti_reg32_show(dev, buf, \ 273 &drvdata->config.cfgname, offset); \ 274 } \ 275 \ 276 static ssize_t name##_store(struct device *dev, \ 277 struct device_attribute *attr, \ 278 const char *buf, size_t size) \ 279 { \ 280 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); \ 281 return cti_reg32_store(dev, buf, size, \ 282 &drvdata->config.cfgname, offset); \ 283 } \ 284 static DEVICE_ATTR_RW(name) 285 286 static ssize_t inout_sel_show(struct device *dev, 287 struct device_attribute *attr, 288 char *buf) 289 { 290 u32 val; 291 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 292 293 val = (u32)drvdata->config.ctiinout_sel; 294 return sprintf(buf, "%d\n", val); 295 } 296 297 static ssize_t inout_sel_store(struct device *dev, 298 struct device_attribute *attr, 299 const char *buf, size_t size) 300 { 301 unsigned long val; 302 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 303 304 if (kstrtoul(buf, 0, &val)) 305 return -EINVAL; 306 if (val > (CTIINOUTEN_MAX - 1)) 307 return -EINVAL; 308 309 spin_lock(&drvdata->spinlock); 310 drvdata->config.ctiinout_sel = val; 311 spin_unlock(&drvdata->spinlock); 312 return size; 313 } 314 static DEVICE_ATTR_RW(inout_sel); 315 316 static ssize_t inen_show(struct device *dev, 317 struct device_attribute *attr, 318 char *buf) 319 { 320 unsigned long val; 321 int index; 322 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 323 324 spin_lock(&drvdata->spinlock); 325 index = drvdata->config.ctiinout_sel; 326 val = drvdata->config.ctiinen[index]; 327 spin_unlock(&drvdata->spinlock); 328 return sprintf(buf, "%#lx\n", val); 329 } 330 331 static ssize_t inen_store(struct device *dev, 332 struct device_attribute *attr, 333 const char *buf, size_t size) 334 { 335 unsigned long val; 336 int index; 337 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 338 struct cti_config *config = &drvdata->config; 339 340 if (kstrtoul(buf, 0, &val)) 341 return -EINVAL; 342 343 spin_lock(&drvdata->spinlock); 344 index = config->ctiinout_sel; 345 config->ctiinen[index] = val; 346 347 /* write through if enabled */ 348 if (cti_active(config)) 349 cti_write_single_reg(drvdata, CTIINEN(index), val); 350 spin_unlock(&drvdata->spinlock); 351 return size; 352 } 353 static DEVICE_ATTR_RW(inen); 354 355 static ssize_t outen_show(struct device *dev, 356 struct device_attribute *attr, 357 char *buf) 358 { 359 unsigned long val; 360 int index; 361 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 362 363 spin_lock(&drvdata->spinlock); 364 index = drvdata->config.ctiinout_sel; 365 val = drvdata->config.ctiouten[index]; 366 spin_unlock(&drvdata->spinlock); 367 return sprintf(buf, "%#lx\n", val); 368 } 369 370 static ssize_t outen_store(struct device *dev, 371 struct device_attribute *attr, 372 const char *buf, size_t size) 373 { 374 unsigned long val; 375 int index; 376 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 377 struct cti_config *config = &drvdata->config; 378 379 if (kstrtoul(buf, 0, &val)) 380 return -EINVAL; 381 382 spin_lock(&drvdata->spinlock); 383 index = config->ctiinout_sel; 384 config->ctiouten[index] = val; 385 386 /* write through if enabled */ 387 if (cti_active(config)) 388 cti_write_single_reg(drvdata, CTIOUTEN(index), val); 389 spin_unlock(&drvdata->spinlock); 390 return size; 391 } 392 static DEVICE_ATTR_RW(outen); 393 394 static ssize_t intack_store(struct device *dev, 395 struct device_attribute *attr, 396 const char *buf, size_t size) 397 { 398 unsigned long val; 399 400 if (kstrtoul(buf, 0, &val)) 401 return -EINVAL; 402 403 cti_write_intack(dev, val); 404 return size; 405 } 406 static DEVICE_ATTR_WO(intack); 407 408 cti_config_reg32_rw(gate, ctigate, CTIGATE); 409 cti_config_reg32_rw(asicctl, asicctl, ASICCTL); 410 cti_config_reg32_rw(appset, ctiappset, CTIAPPSET); 411 412 static ssize_t appclear_store(struct device *dev, 413 struct device_attribute *attr, 414 const char *buf, size_t size) 415 { 416 unsigned long val; 417 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 418 struct cti_config *config = &drvdata->config; 419 420 if (kstrtoul(buf, 0, &val)) 421 return -EINVAL; 422 423 spin_lock(&drvdata->spinlock); 424 425 /* a 1'b1 in appclr clears down the same bit in appset*/ 426 config->ctiappset &= ~val; 427 428 /* write through if enabled */ 429 if (cti_active(config)) 430 cti_write_single_reg(drvdata, CTIAPPCLEAR, val); 431 spin_unlock(&drvdata->spinlock); 432 return size; 433 } 434 static DEVICE_ATTR_WO(appclear); 435 436 static ssize_t apppulse_store(struct device *dev, 437 struct device_attribute *attr, 438 const char *buf, size_t size) 439 { 440 unsigned long val; 441 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 442 struct cti_config *config = &drvdata->config; 443 444 if (kstrtoul(buf, 0, &val)) 445 return -EINVAL; 446 447 spin_lock(&drvdata->spinlock); 448 449 /* write through if enabled */ 450 if (cti_active(config)) 451 cti_write_single_reg(drvdata, CTIAPPPULSE, val); 452 spin_unlock(&drvdata->spinlock); 453 return size; 454 } 455 static DEVICE_ATTR_WO(apppulse); 456 457 coresight_cti_reg(triginstatus, CTITRIGINSTATUS); 458 coresight_cti_reg(trigoutstatus, CTITRIGOUTSTATUS); 459 coresight_cti_reg(chinstatus, CTICHINSTATUS); 460 coresight_cti_reg(choutstatus, CTICHOUTSTATUS); 461 462 /* 463 * Define CONFIG_CORESIGHT_CTI_INTEGRATION_REGS to enable the access to the 464 * integration control registers. Normally only used to investigate connection 465 * data. 466 */ 467 #ifdef CONFIG_CORESIGHT_CTI_INTEGRATION_REGS 468 469 /* macro to access RW registers with power check only (no enable check). */ 470 #define coresight_cti_reg_rw(name, offset) \ 471 static ssize_t name##_show(struct device *dev, \ 472 struct device_attribute *attr, char *buf) \ 473 { \ 474 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); \ 475 u32 val = 0; \ 476 pm_runtime_get_sync(dev->parent); \ 477 spin_lock(&drvdata->spinlock); \ 478 if (drvdata->config.hw_powered) \ 479 val = readl_relaxed(drvdata->base + offset); \ 480 spin_unlock(&drvdata->spinlock); \ 481 pm_runtime_put_sync(dev->parent); \ 482 return sprintf(buf, "0x%x\n", val); \ 483 } \ 484 \ 485 static ssize_t name##_store(struct device *dev, \ 486 struct device_attribute *attr, \ 487 const char *buf, size_t size) \ 488 { \ 489 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); \ 490 unsigned long val = 0; \ 491 if (kstrtoul(buf, 0, &val)) \ 492 return -EINVAL; \ 493 \ 494 pm_runtime_get_sync(dev->parent); \ 495 spin_lock(&drvdata->spinlock); \ 496 if (drvdata->config.hw_powered) \ 497 cti_write_single_reg(drvdata, offset, val); \ 498 spin_unlock(&drvdata->spinlock); \ 499 pm_runtime_put_sync(dev->parent); \ 500 return size; \ 501 } \ 502 static DEVICE_ATTR_RW(name) 503 504 /* macro to access WO registers with power check only (no enable check). */ 505 #define coresight_cti_reg_wo(name, offset) \ 506 static ssize_t name##_store(struct device *dev, \ 507 struct device_attribute *attr, \ 508 const char *buf, size_t size) \ 509 { \ 510 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); \ 511 unsigned long val = 0; \ 512 if (kstrtoul(buf, 0, &val)) \ 513 return -EINVAL; \ 514 \ 515 pm_runtime_get_sync(dev->parent); \ 516 spin_lock(&drvdata->spinlock); \ 517 if (drvdata->config.hw_powered) \ 518 cti_write_single_reg(drvdata, offset, val); \ 519 spin_unlock(&drvdata->spinlock); \ 520 pm_runtime_put_sync(dev->parent); \ 521 return size; \ 522 } \ 523 static DEVICE_ATTR_WO(name) 524 525 coresight_cti_reg_rw(itchout, ITCHOUT); 526 coresight_cti_reg_rw(ittrigout, ITTRIGOUT); 527 coresight_cti_reg_rw(itctrl, CORESIGHT_ITCTRL); 528 coresight_cti_reg_wo(itchinack, ITCHINACK); 529 coresight_cti_reg_wo(ittriginack, ITTRIGINACK); 530 coresight_cti_reg(ittrigin, ITTRIGIN); 531 coresight_cti_reg(itchin, ITCHIN); 532 coresight_cti_reg(itchoutack, ITCHOUTACK); 533 coresight_cti_reg(ittrigoutack, ITTRIGOUTACK); 534 535 #endif /* CORESIGHT_CTI_INTEGRATION_REGS */ 536 537 static struct attribute *coresight_cti_regs_attrs[] = { 538 &dev_attr_inout_sel.attr, 539 &dev_attr_inen.attr, 540 &dev_attr_outen.attr, 541 &dev_attr_gate.attr, 542 &dev_attr_asicctl.attr, 543 &dev_attr_intack.attr, 544 &dev_attr_appset.attr, 545 &dev_attr_appclear.attr, 546 &dev_attr_apppulse.attr, 547 &dev_attr_triginstatus.attr, 548 &dev_attr_trigoutstatus.attr, 549 &dev_attr_chinstatus.attr, 550 &dev_attr_choutstatus.attr, 551 #ifdef CONFIG_CORESIGHT_CTI_INTEGRATION_REGS 552 &dev_attr_itctrl.attr, 553 &dev_attr_ittrigin.attr, 554 &dev_attr_itchin.attr, 555 &dev_attr_ittrigout.attr, 556 &dev_attr_itchout.attr, 557 &dev_attr_itchoutack.attr, 558 &dev_attr_ittrigoutack.attr, 559 &dev_attr_ittriginack.attr, 560 &dev_attr_itchinack.attr, 561 #endif 562 NULL, 563 }; 564 565 /* CTI channel x-trigger programming */ 566 static int 567 cti_trig_op_parse(struct device *dev, enum cti_chan_op op, 568 enum cti_trig_dir dir, const char *buf, size_t size) 569 { 570 u32 chan_idx; 571 u32 trig_idx; 572 int items, err = -EINVAL; 573 574 /* extract chan idx and trigger idx */ 575 items = sscanf(buf, "%d %d", &chan_idx, &trig_idx); 576 if (items == 2) { 577 err = cti_channel_trig_op(dev, op, dir, chan_idx, trig_idx); 578 if (!err) 579 err = size; 580 } 581 return err; 582 } 583 584 static ssize_t trigin_attach_store(struct device *dev, 585 struct device_attribute *attr, 586 const char *buf, size_t size) 587 { 588 return cti_trig_op_parse(dev, CTI_CHAN_ATTACH, CTI_TRIG_IN, 589 buf, size); 590 } 591 static DEVICE_ATTR_WO(trigin_attach); 592 593 static ssize_t trigin_detach_store(struct device *dev, 594 struct device_attribute *attr, 595 const char *buf, size_t size) 596 { 597 return cti_trig_op_parse(dev, CTI_CHAN_DETACH, CTI_TRIG_IN, 598 buf, size); 599 } 600 static DEVICE_ATTR_WO(trigin_detach); 601 602 static ssize_t trigout_attach_store(struct device *dev, 603 struct device_attribute *attr, 604 const char *buf, size_t size) 605 { 606 return cti_trig_op_parse(dev, CTI_CHAN_ATTACH, CTI_TRIG_OUT, 607 buf, size); 608 } 609 static DEVICE_ATTR_WO(trigout_attach); 610 611 static ssize_t trigout_detach_store(struct device *dev, 612 struct device_attribute *attr, 613 const char *buf, size_t size) 614 { 615 return cti_trig_op_parse(dev, CTI_CHAN_DETACH, CTI_TRIG_OUT, 616 buf, size); 617 } 618 static DEVICE_ATTR_WO(trigout_detach); 619 620 621 static ssize_t chan_gate_enable_store(struct device *dev, 622 struct device_attribute *attr, 623 const char *buf, size_t size) 624 { 625 int err = 0, channel = 0; 626 627 if (kstrtoint(buf, 0, &channel)) 628 return -EINVAL; 629 630 err = cti_channel_gate_op(dev, CTI_GATE_CHAN_ENABLE, channel); 631 return err ? err : size; 632 } 633 634 static ssize_t chan_gate_enable_show(struct device *dev, 635 struct device_attribute *attr, 636 char *buf) 637 { 638 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 639 struct cti_config *cfg = &drvdata->config; 640 unsigned long ctigate_bitmask = cfg->ctigate; 641 int size = 0; 642 643 if (cfg->ctigate == 0) 644 size = sprintf(buf, "\n"); 645 else 646 size = bitmap_print_to_pagebuf(true, buf, &ctigate_bitmask, 647 cfg->nr_ctm_channels); 648 return size; 649 } 650 static DEVICE_ATTR_RW(chan_gate_enable); 651 652 static ssize_t chan_gate_disable_store(struct device *dev, 653 struct device_attribute *attr, 654 const char *buf, size_t size) 655 { 656 int err = 0, channel = 0; 657 658 if (kstrtoint(buf, 0, &channel)) 659 return -EINVAL; 660 661 err = cti_channel_gate_op(dev, CTI_GATE_CHAN_DISABLE, channel); 662 return err ? err : size; 663 } 664 static DEVICE_ATTR_WO(chan_gate_disable); 665 666 static int 667 chan_op_parse(struct device *dev, enum cti_chan_set_op op, const char *buf) 668 { 669 int err = 0, channel = 0; 670 671 if (kstrtoint(buf, 0, &channel)) 672 return -EINVAL; 673 674 err = cti_channel_setop(dev, op, channel); 675 return err; 676 677 } 678 679 static ssize_t chan_set_store(struct device *dev, 680 struct device_attribute *attr, 681 const char *buf, size_t size) 682 { 683 int err = chan_op_parse(dev, CTI_CHAN_SET, buf); 684 685 return err ? err : size; 686 } 687 static DEVICE_ATTR_WO(chan_set); 688 689 static ssize_t chan_clear_store(struct device *dev, 690 struct device_attribute *attr, 691 const char *buf, size_t size) 692 { 693 int err = chan_op_parse(dev, CTI_CHAN_CLR, buf); 694 695 return err ? err : size; 696 } 697 static DEVICE_ATTR_WO(chan_clear); 698 699 static ssize_t chan_pulse_store(struct device *dev, 700 struct device_attribute *attr, 701 const char *buf, size_t size) 702 { 703 int err = chan_op_parse(dev, CTI_CHAN_PULSE, buf); 704 705 return err ? err : size; 706 } 707 static DEVICE_ATTR_WO(chan_pulse); 708 709 static ssize_t trig_filter_enable_show(struct device *dev, 710 struct device_attribute *attr, 711 char *buf) 712 { 713 u32 val; 714 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 715 716 spin_lock(&drvdata->spinlock); 717 val = drvdata->config.trig_filter_enable; 718 spin_unlock(&drvdata->spinlock); 719 return sprintf(buf, "%d\n", val); 720 } 721 722 static ssize_t trig_filter_enable_store(struct device *dev, 723 struct device_attribute *attr, 724 const char *buf, size_t size) 725 { 726 unsigned long val; 727 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 728 729 if (kstrtoul(buf, 0, &val)) 730 return -EINVAL; 731 732 spin_lock(&drvdata->spinlock); 733 drvdata->config.trig_filter_enable = !!val; 734 spin_unlock(&drvdata->spinlock); 735 return size; 736 } 737 static DEVICE_ATTR_RW(trig_filter_enable); 738 739 static ssize_t trigout_filtered_show(struct device *dev, 740 struct device_attribute *attr, 741 char *buf) 742 { 743 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 744 struct cti_config *cfg = &drvdata->config; 745 int size = 0, nr_trig_max = cfg->nr_trig_max; 746 unsigned long mask = cfg->trig_out_filter; 747 748 if (mask) 749 size = bitmap_print_to_pagebuf(true, buf, &mask, nr_trig_max); 750 return size; 751 } 752 static DEVICE_ATTR_RO(trigout_filtered); 753 754 /* clear all xtrigger / channel programming */ 755 static ssize_t chan_xtrigs_reset_store(struct device *dev, 756 struct device_attribute *attr, 757 const char *buf, size_t size) 758 { 759 int i; 760 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 761 struct cti_config *config = &drvdata->config; 762 763 spin_lock(&drvdata->spinlock); 764 765 /* clear the CTI trigger / channel programming registers */ 766 for (i = 0; i < config->nr_trig_max; i++) { 767 config->ctiinen[i] = 0; 768 config->ctiouten[i] = 0; 769 } 770 771 /* clear the other regs */ 772 config->ctigate = GENMASK(config->nr_ctm_channels - 1, 0); 773 config->asicctl = 0; 774 config->ctiappset = 0; 775 config->ctiinout_sel = 0; 776 config->xtrig_rchan_sel = 0; 777 778 /* if enabled then write through */ 779 if (cti_active(config)) 780 cti_write_all_hw_regs(drvdata); 781 782 spin_unlock(&drvdata->spinlock); 783 return size; 784 } 785 static DEVICE_ATTR_WO(chan_xtrigs_reset); 786 787 /* 788 * Write to select a channel to view, read to display the 789 * cross triggers for the selected channel. 790 */ 791 static ssize_t chan_xtrigs_sel_store(struct device *dev, 792 struct device_attribute *attr, 793 const char *buf, size_t size) 794 { 795 unsigned long val; 796 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 797 798 if (kstrtoul(buf, 0, &val)) 799 return -EINVAL; 800 if (val > (drvdata->config.nr_ctm_channels - 1)) 801 return -EINVAL; 802 803 spin_lock(&drvdata->spinlock); 804 drvdata->config.xtrig_rchan_sel = val; 805 spin_unlock(&drvdata->spinlock); 806 return size; 807 } 808 809 static ssize_t chan_xtrigs_sel_show(struct device *dev, 810 struct device_attribute *attr, 811 char *buf) 812 { 813 unsigned long val; 814 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 815 816 spin_lock(&drvdata->spinlock); 817 val = drvdata->config.xtrig_rchan_sel; 818 spin_unlock(&drvdata->spinlock); 819 820 return sprintf(buf, "%ld\n", val); 821 } 822 static DEVICE_ATTR_RW(chan_xtrigs_sel); 823 824 static ssize_t chan_xtrigs_in_show(struct device *dev, 825 struct device_attribute *attr, 826 char *buf) 827 { 828 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 829 struct cti_config *cfg = &drvdata->config; 830 int used = 0, reg_idx; 831 int nr_trig_max = drvdata->config.nr_trig_max; 832 u32 chan_mask = BIT(cfg->xtrig_rchan_sel); 833 834 for (reg_idx = 0; reg_idx < nr_trig_max; reg_idx++) { 835 if (chan_mask & cfg->ctiinen[reg_idx]) 836 used += sprintf(buf + used, "%d ", reg_idx); 837 } 838 839 used += sprintf(buf + used, "\n"); 840 return used; 841 } 842 static DEVICE_ATTR_RO(chan_xtrigs_in); 843 844 static ssize_t chan_xtrigs_out_show(struct device *dev, 845 struct device_attribute *attr, 846 char *buf) 847 { 848 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 849 struct cti_config *cfg = &drvdata->config; 850 int used = 0, reg_idx; 851 int nr_trig_max = drvdata->config.nr_trig_max; 852 u32 chan_mask = BIT(cfg->xtrig_rchan_sel); 853 854 for (reg_idx = 0; reg_idx < nr_trig_max; reg_idx++) { 855 if (chan_mask & cfg->ctiouten[reg_idx]) 856 used += sprintf(buf + used, "%d ", reg_idx); 857 } 858 859 used += sprintf(buf + used, "\n"); 860 return used; 861 } 862 static DEVICE_ATTR_RO(chan_xtrigs_out); 863 864 static ssize_t print_chan_list(struct device *dev, 865 char *buf, bool inuse) 866 { 867 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 868 struct cti_config *config = &drvdata->config; 869 int size, i; 870 unsigned long inuse_bits = 0, chan_mask; 871 872 /* scan regs to get bitmap of channels in use. */ 873 spin_lock(&drvdata->spinlock); 874 for (i = 0; i < config->nr_trig_max; i++) { 875 inuse_bits |= config->ctiinen[i]; 876 inuse_bits |= config->ctiouten[i]; 877 } 878 spin_unlock(&drvdata->spinlock); 879 880 /* inverse bits if printing free channels */ 881 if (!inuse) 882 inuse_bits = ~inuse_bits; 883 884 /* list of channels, or 'none' */ 885 chan_mask = GENMASK(config->nr_ctm_channels - 1, 0); 886 if (inuse_bits & chan_mask) 887 size = bitmap_print_to_pagebuf(true, buf, &inuse_bits, 888 config->nr_ctm_channels); 889 else 890 size = sprintf(buf, "\n"); 891 return size; 892 } 893 894 static ssize_t chan_inuse_show(struct device *dev, 895 struct device_attribute *attr, 896 char *buf) 897 { 898 return print_chan_list(dev, buf, true); 899 } 900 static DEVICE_ATTR_RO(chan_inuse); 901 902 static ssize_t chan_free_show(struct device *dev, 903 struct device_attribute *attr, 904 char *buf) 905 { 906 return print_chan_list(dev, buf, false); 907 } 908 static DEVICE_ATTR_RO(chan_free); 909 910 static struct attribute *coresight_cti_channel_attrs[] = { 911 &dev_attr_trigin_attach.attr, 912 &dev_attr_trigin_detach.attr, 913 &dev_attr_trigout_attach.attr, 914 &dev_attr_trigout_detach.attr, 915 &dev_attr_trig_filter_enable.attr, 916 &dev_attr_trigout_filtered.attr, 917 &dev_attr_chan_gate_enable.attr, 918 &dev_attr_chan_gate_disable.attr, 919 &dev_attr_chan_set.attr, 920 &dev_attr_chan_clear.attr, 921 &dev_attr_chan_pulse.attr, 922 &dev_attr_chan_inuse.attr, 923 &dev_attr_chan_free.attr, 924 &dev_attr_chan_xtrigs_sel.attr, 925 &dev_attr_chan_xtrigs_in.attr, 926 &dev_attr_chan_xtrigs_out.attr, 927 &dev_attr_chan_xtrigs_reset.attr, 928 NULL, 929 }; 930 931 /* Create the connections trigger groups and attrs dynamically */ 932 /* 933 * Each connection has dynamic group triggers<N> + name, trigin/out sigs/types 934 * attributes, + each device has static nr_trigger_cons giving the number 935 * of groups. e.g. in sysfs:- 936 * /cti_<name>/triggers0 937 * /cti_<name>/triggers1 938 * /cti_<name>/nr_trigger_cons 939 * where nr_trigger_cons = 2 940 */ 941 static ssize_t con_name_show(struct device *dev, 942 struct device_attribute *attr, 943 char *buf) 944 { 945 struct dev_ext_attribute *ext_attr = 946 container_of(attr, struct dev_ext_attribute, attr); 947 struct cti_trig_con *con = (struct cti_trig_con *)ext_attr->var; 948 949 return sprintf(buf, "%s\n", con->con_dev_name); 950 } 951 952 static ssize_t trigin_sig_show(struct device *dev, 953 struct device_attribute *attr, 954 char *buf) 955 { 956 struct dev_ext_attribute *ext_attr = 957 container_of(attr, struct dev_ext_attribute, attr); 958 struct cti_trig_con *con = (struct cti_trig_con *)ext_attr->var; 959 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 960 struct cti_config *cfg = &drvdata->config; 961 unsigned long mask = con->con_in->used_mask; 962 963 return bitmap_print_to_pagebuf(true, buf, &mask, cfg->nr_trig_max); 964 } 965 966 static ssize_t trigout_sig_show(struct device *dev, 967 struct device_attribute *attr, 968 char *buf) 969 { 970 struct dev_ext_attribute *ext_attr = 971 container_of(attr, struct dev_ext_attribute, attr); 972 struct cti_trig_con *con = (struct cti_trig_con *)ext_attr->var; 973 struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); 974 struct cti_config *cfg = &drvdata->config; 975 unsigned long mask = con->con_out->used_mask; 976 977 return bitmap_print_to_pagebuf(true, buf, &mask, cfg->nr_trig_max); 978 } 979 980 /* convert a sig type id to a name */ 981 static const char * 982 cti_sig_type_name(struct cti_trig_con *con, int used_count, bool in) 983 { 984 int idx = 0; 985 struct cti_trig_grp *grp = in ? con->con_in : con->con_out; 986 987 if (used_count < grp->nr_sigs) 988 idx = grp->sig_types[used_count]; 989 return sig_type_names[idx]; 990 } 991 992 static ssize_t trigin_type_show(struct device *dev, 993 struct device_attribute *attr, 994 char *buf) 995 { 996 struct dev_ext_attribute *ext_attr = 997 container_of(attr, struct dev_ext_attribute, attr); 998 struct cti_trig_con *con = (struct cti_trig_con *)ext_attr->var; 999 int sig_idx, used = 0; 1000 const char *name; 1001 1002 for (sig_idx = 0; sig_idx < con->con_in->nr_sigs; sig_idx++) { 1003 name = cti_sig_type_name(con, sig_idx, true); 1004 used += sprintf(buf + used, "%s ", name); 1005 } 1006 used += sprintf(buf + used, "\n"); 1007 return used; 1008 } 1009 1010 static ssize_t trigout_type_show(struct device *dev, 1011 struct device_attribute *attr, 1012 char *buf) 1013 { 1014 struct dev_ext_attribute *ext_attr = 1015 container_of(attr, struct dev_ext_attribute, attr); 1016 struct cti_trig_con *con = (struct cti_trig_con *)ext_attr->var; 1017 int sig_idx, used = 0; 1018 const char *name; 1019 1020 for (sig_idx = 0; sig_idx < con->con_out->nr_sigs; sig_idx++) { 1021 name = cti_sig_type_name(con, sig_idx, false); 1022 used += sprintf(buf + used, "%s ", name); 1023 } 1024 used += sprintf(buf + used, "\n"); 1025 return used; 1026 } 1027 1028 /* 1029 * Array of show function names declared above to allow selection 1030 * for the connection attributes 1031 */ 1032 static p_show_fn show_fns[CTI_CON_ATTR_MAX] = { 1033 con_name_show, 1034 trigin_sig_show, 1035 trigout_sig_show, 1036 trigin_type_show, 1037 trigout_type_show, 1038 }; 1039 1040 static int cti_create_con_sysfs_attr(struct device *dev, 1041 struct cti_trig_con *con, 1042 enum cti_conn_attr_type attr_type, 1043 int attr_idx) 1044 { 1045 struct dev_ext_attribute *eattr; 1046 char *name; 1047 1048 eattr = devm_kzalloc(dev, sizeof(struct dev_ext_attribute), 1049 GFP_KERNEL); 1050 if (eattr) { 1051 name = devm_kstrdup(dev, con_attr_names[attr_type], 1052 GFP_KERNEL); 1053 if (name) { 1054 /* fill out the underlying attribute struct */ 1055 eattr->attr.attr.name = name; 1056 eattr->attr.attr.mode = 0444; 1057 1058 /* now the device_attribute struct */ 1059 eattr->attr.show = show_fns[attr_type]; 1060 } else { 1061 return -ENOMEM; 1062 } 1063 } else { 1064 return -ENOMEM; 1065 } 1066 eattr->var = con; 1067 con->con_attrs[attr_idx] = &eattr->attr.attr; 1068 /* 1069 * Initialize the dynamically allocated attribute 1070 * to avoid LOCKDEP splat. See include/linux/sysfs.h 1071 * for more details. 1072 */ 1073 sysfs_attr_init(con->con_attrs[attr_idx]); 1074 1075 return 0; 1076 } 1077 1078 static struct attribute_group * 1079 cti_create_con_sysfs_group(struct device *dev, struct cti_device *ctidev, 1080 int con_idx, struct cti_trig_con *tc) 1081 { 1082 struct attribute_group *group = NULL; 1083 int grp_idx; 1084 1085 group = devm_kzalloc(dev, sizeof(struct attribute_group), GFP_KERNEL); 1086 if (!group) 1087 return NULL; 1088 1089 group->name = devm_kasprintf(dev, GFP_KERNEL, "triggers%d", con_idx); 1090 if (!group->name) 1091 return NULL; 1092 1093 grp_idx = con_idx + CORESIGHT_CTI_STATIC_GROUPS_MAX - 1; 1094 ctidev->con_groups[grp_idx] = group; 1095 tc->attr_group = group; 1096 return group; 1097 } 1098 1099 /* create a triggers connection group and the attributes for that group */ 1100 static int cti_create_con_attr_set(struct device *dev, int con_idx, 1101 struct cti_device *ctidev, 1102 struct cti_trig_con *tc) 1103 { 1104 struct attribute_group *attr_group = NULL; 1105 int attr_idx = 0; 1106 int err = -ENOMEM; 1107 1108 attr_group = cti_create_con_sysfs_group(dev, ctidev, con_idx, tc); 1109 if (!attr_group) 1110 return -ENOMEM; 1111 1112 /* allocate NULL terminated array of attributes */ 1113 tc->con_attrs = devm_kcalloc(dev, CTI_CON_ATTR_MAX + 1, 1114 sizeof(struct attribute *), GFP_KERNEL); 1115 if (!tc->con_attrs) 1116 return -ENOMEM; 1117 1118 err = cti_create_con_sysfs_attr(dev, tc, CTI_CON_ATTR_NAME, 1119 attr_idx++); 1120 if (err) 1121 return err; 1122 1123 if (tc->con_in->nr_sigs > 0) { 1124 err = cti_create_con_sysfs_attr(dev, tc, 1125 CTI_CON_ATTR_TRIGIN_SIG, 1126 attr_idx++); 1127 if (err) 1128 return err; 1129 1130 err = cti_create_con_sysfs_attr(dev, tc, 1131 CTI_CON_ATTR_TRIGIN_TYPES, 1132 attr_idx++); 1133 if (err) 1134 return err; 1135 } 1136 1137 if (tc->con_out->nr_sigs > 0) { 1138 err = cti_create_con_sysfs_attr(dev, tc, 1139 CTI_CON_ATTR_TRIGOUT_SIG, 1140 attr_idx++); 1141 if (err) 1142 return err; 1143 1144 err = cti_create_con_sysfs_attr(dev, tc, 1145 CTI_CON_ATTR_TRIGOUT_TYPES, 1146 attr_idx++); 1147 if (err) 1148 return err; 1149 } 1150 attr_group->attrs = tc->con_attrs; 1151 return 0; 1152 } 1153 1154 /* create the array of group pointers for the CTI sysfs groups */ 1155 static int cti_create_cons_groups(struct device *dev, struct cti_device *ctidev) 1156 { 1157 int nr_groups; 1158 1159 /* nr groups = dynamic + static + NULL terminator */ 1160 nr_groups = ctidev->nr_trig_con + CORESIGHT_CTI_STATIC_GROUPS_MAX; 1161 ctidev->con_groups = devm_kcalloc(dev, nr_groups, 1162 sizeof(struct attribute_group *), 1163 GFP_KERNEL); 1164 if (!ctidev->con_groups) 1165 return -ENOMEM; 1166 return 0; 1167 } 1168 1169 int cti_create_cons_sysfs(struct device *dev, struct cti_drvdata *drvdata) 1170 { 1171 struct cti_device *ctidev = &drvdata->ctidev; 1172 int err, con_idx = 0, i; 1173 struct cti_trig_con *tc; 1174 1175 err = cti_create_cons_groups(dev, ctidev); 1176 if (err) 1177 return err; 1178 1179 /* populate first locations with the static set of groups */ 1180 for (i = 0; i < (CORESIGHT_CTI_STATIC_GROUPS_MAX - 1); i++) 1181 ctidev->con_groups[i] = coresight_cti_groups[i]; 1182 1183 /* add dynamic set for each connection */ 1184 list_for_each_entry(tc, &ctidev->trig_cons, node) { 1185 err = cti_create_con_attr_set(dev, con_idx++, ctidev, tc); 1186 if (err) 1187 break; 1188 } 1189 return err; 1190 } 1191 1192 /* attribute and group sysfs tables. */ 1193 static const struct attribute_group coresight_cti_group = { 1194 .attrs = coresight_cti_attrs, 1195 }; 1196 1197 static const struct attribute_group coresight_cti_mgmt_group = { 1198 .attrs = coresight_cti_mgmt_attrs, 1199 .name = "mgmt", 1200 }; 1201 1202 static const struct attribute_group coresight_cti_regs_group = { 1203 .attrs = coresight_cti_regs_attrs, 1204 .name = "regs", 1205 }; 1206 1207 static const struct attribute_group coresight_cti_channels_group = { 1208 .attrs = coresight_cti_channel_attrs, 1209 .name = "channels", 1210 }; 1211 1212 const struct attribute_group * 1213 coresight_cti_groups[CORESIGHT_CTI_STATIC_GROUPS_MAX] = { 1214 &coresight_cti_group, 1215 &coresight_cti_mgmt_group, 1216 &coresight_cti_regs_group, 1217 &coresight_cti_channels_group, 1218 NULL, 1219 }; 1220