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

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