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         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 };