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

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2018 Linaro Limited, All rights reserved.
   4  * Author: Mike Leach <mike.leach@linaro.org>
   5  */
   6
   7 #include <linux/amba/bus.h>
   8 #include <linux/atomic.h>
   9 #include <linux/bits.h>
  10 #include <linux/coresight.h>
  11 #include <linux/cpu_pm.h>
  12 #include <linux/cpuhotplug.h>
  13 #include <linux/device.h>
  14 #include <linux/io.h>
  15 #include <linux/kernel.h>
  16 #include <linux/list.h>
  17 #include <linux/mutex.h>
  18 #include <linux/pm_runtime.h>
  19 #include <linux/property.h>
  20 #include <linux/spinlock.h>
  21
  22 #include "coresight-priv.h"
  23 #include "coresight-cti.h"
  24
  25 /*
  26  * CTI devices can be associated with a PE, or be connected to CoreSight
  27  * hardware. We have a list of all CTIs irrespective of CPU bound or
  28  * otherwise.
  29  *
  30  * We assume that the non-CPU CTIs are always powered as we do with sinks etc.
  31  *
  32  * We leave the client to figure out if all the CTIs are interconnected with
  33  * the same CTM, in general this is the case but does not always have to be.
  34  */
  35
  36 /* net of CTI devices connected via CTM */
  37 static LIST_HEAD(ect_net);
  38
  39 /* protect the list */
  40 static DEFINE_MUTEX(ect_mutex);
  41
  42 #define csdev_to_cti_drvdata(csdev)     \
  43         dev_get_drvdata(csdev->dev.parent)
  44
  45 /* power management handling */
  46 static int nr_cti_cpu;
  47
  48 /* quick lookup list for CPU bound CTIs when power handling */
  49 static struct cti_drvdata *cti_cpu_drvdata[NR_CPUS];
  50
  51 /*
  52  * CTI naming. CTI bound to cores will have the name cti_cpu<N> where
  53  * N is the CPU ID. System CTIs will have the name cti_sys<I> where I
  54  * is an index allocated by order of discovery.
  55  *
  56  * CTI device name list - for CTI not bound to cores.
  57  */
  58 DEFINE_CORESIGHT_DEVLIST(cti_sys_devs, "cti_sys");
  59
  60 /* write set of regs to hardware - call with spinlock claimed */
  61 void cti_write_all_hw_regs(struct cti_drvdata *drvdata)
  62 {
  63         struct cti_config *config = &drvdata->config;
  64         int i;
  65
  66         CS_UNLOCK(drvdata->base);
  67
  68         /* disable CTI before writing registers */
  69         writel_relaxed(0, drvdata->base + CTICONTROL);
  70
  71         /* write the CTI trigger registers */
  72         for (i = 0; i < config->nr_trig_max; i++) {
  73                 writel_relaxed(config->ctiinen[i], drvdata->base + CTIINEN(i));
  74                 writel_relaxed(config->ctiouten[i],
  75                                drvdata->base + CTIOUTEN(i));
  76         }
  77
  78         /* other regs */
  79         writel_relaxed(config->ctigate, drvdata->base + CTIGATE);
  80         writel_relaxed(config->asicctl, drvdata->base + ASICCTL);
  81         writel_relaxed(config->ctiappset, drvdata->base + CTIAPPSET);
  82
  83         /* re-enable CTI */
  84         writel_relaxed(1, drvdata->base + CTICONTROL);
  85
  86         CS_LOCK(drvdata->base);
  87 }
  88
  89 /* write regs to hardware and enable */
  90 static int cti_enable_hw(struct cti_drvdata *drvdata)
  91 {
  92         struct cti_config *config = &drvdata->config;
  93         unsigned long flags;
  94         int rc = 0;
  95
  96         spin_lock_irqsave(&drvdata->spinlock, flags);
  97
  98         /* no need to do anything if enabled or unpowered*/
  99         if (config->hw_enabled || !config->hw_powered)
 100                 goto cti_state_unchanged;
 101
 102         /* claim the device */
 103         rc = coresight_claim_device(drvdata->csdev);
 104         if (rc)
 105                 goto cti_err_not_enabled;
 106
 107         cti_write_all_hw_regs(drvdata);
 108
 109         config->hw_enabled = true;
 110         drvdata->config.enable_req_count++;
 111         spin_unlock_irqrestore(&drvdata->spinlock, flags);
 112         return rc;
 113
 114 cti_state_unchanged:
 115         drvdata->config.enable_req_count++;
 116
 117         /* cannot enable due to error */
 118 cti_err_not_enabled:
 119         spin_unlock_irqrestore(&drvdata->spinlock, flags);
 120         return rc;
 121 }
 122
 123 /* re-enable CTI on CPU when using CPU hotplug */
 124 static void cti_cpuhp_enable_hw(struct cti_drvdata *drvdata)
 125 {
 126         struct cti_config *config = &drvdata->config;
 127
 128         spin_lock(&drvdata->spinlock);
 129         config->hw_powered = true;
 130
 131         /* no need to do anything if no enable request */
 132         if (!drvdata->config.enable_req_count)
 133                 goto cti_hp_not_enabled;
 134
 135         /* try to claim the device */
 136         if (coresight_claim_device(drvdata->csdev))
 137                 goto cti_hp_not_enabled;
 138
 139         cti_write_all_hw_regs(drvdata);
 140         config->hw_enabled = true;
 141         spin_unlock(&drvdata->spinlock);
 142         return;
 143
 144         /* did not re-enable due to no claim / no request */
 145 cti_hp_not_enabled:
 146         spin_unlock(&drvdata->spinlock);
 147 }
 148
 149 /* disable hardware */
 150 static int cti_disable_hw(struct cti_drvdata *drvdata)
 151 {
 152         struct cti_config *config = &drvdata->config;
 153         struct coresight_device *csdev = drvdata->csdev;
 154         int ret = 0;
 155
 156         spin_lock(&drvdata->spinlock);
 157
 158         /* don't allow negative refcounts, return an error */
 159         if (!drvdata->config.enable_req_count) {
 160                 ret = -EINVAL;
 161                 goto cti_not_disabled;
 162         }
 163
 164         /* check refcount - disable on 0 */
 165         if (--drvdata->config.enable_req_count > 0)
 166                 goto cti_not_disabled;
 167
 168         /* no need to do anything if disabled or cpu unpowered */
 169         if (!config->hw_enabled || !config->hw_powered)
 170                 goto cti_not_disabled;
 171
 172         CS_UNLOCK(drvdata->base);
 173
 174         /* disable CTI */
 175         writel_relaxed(0, drvdata->base + CTICONTROL);
 176         config->hw_enabled = false;
 177
 178         coresight_disclaim_device_unlocked(csdev);
 179         CS_LOCK(drvdata->base);
 180         spin_unlock(&drvdata->spinlock);
 181         return ret;
 182
 183         /* not disabled this call */
 184 cti_not_disabled:
 185         spin_unlock(&drvdata->spinlock);
 186         return ret;
 187 }
 188
 189 void cti_write_single_reg(struct cti_drvdata *drvdata, int offset, u32 value)
 190 {
 191         CS_UNLOCK(drvdata->base);
 192         writel_relaxed(value, drvdata->base + offset);
 193         CS_LOCK(drvdata->base);
 194 }
 195
 196 void cti_write_intack(struct device *dev, u32 ackval)
 197 {
 198         struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
 199         struct cti_config *config = &drvdata->config;
 200
 201         spin_lock(&drvdata->spinlock);
 202         /* write if enabled */
 203         if (cti_active(config))
 204                 cti_write_single_reg(drvdata, CTIINTACK, ackval);
 205         spin_unlock(&drvdata->spinlock);
 206 }
 207
 208 /*
 209  * Look at the HW DEVID register for some of the HW settings.
 210  * DEVID[15:8] - max number of in / out triggers.
 211  */
 212 #define CTI_DEVID_MAXTRIGS(devid_val) ((int) BMVAL(devid_val, 8, 15))
 213
 214 /* DEVID[19:16] - number of CTM channels */
 215 #define CTI_DEVID_CTMCHANNELS(devid_val) ((int) BMVAL(devid_val, 16, 19))
 216
 217 static void cti_set_default_config(struct device *dev,
 218                                    struct cti_drvdata *drvdata)
 219 {
 220         struct cti_config *config = &drvdata->config;
 221         u32 devid;
 222
 223         devid = readl_relaxed(drvdata->base + CORESIGHT_DEVID);
 224         config->nr_trig_max = CTI_DEVID_MAXTRIGS(devid);
 225
 226         /*
 227          * no current hardware should exceed this, but protect the driver
 228          * in case of fault / out of spec hw
 229          */
 230         if (config->nr_trig_max > CTIINOUTEN_MAX) {
 231                 dev_warn_once(dev,
 232                         "Limiting HW MaxTrig value(%d) to driver max(%d)\n",
 233                         config->nr_trig_max, CTIINOUTEN_MAX);
 234                 config->nr_trig_max = CTIINOUTEN_MAX;
 235         }
 236
 237         config->nr_ctm_channels = CTI_DEVID_CTMCHANNELS(devid);
 238
 239         /* Most regs default to 0 as zalloc'ed except...*/
 240         config->trig_filter_enable = true;
 241         config->ctigate = GENMASK(config->nr_ctm_channels - 1, 0);
 242         config->enable_req_count = 0;
 243 }
 244
 245 /*
 246  * Add a connection entry to the list of connections for this
 247  * CTI device.
 248  */
 249 int cti_add_connection_entry(struct device *dev, struct cti_drvdata *drvdata,
 250                              struct cti_trig_con *tc,
 251                              struct coresight_device *csdev,
 252                              const char *assoc_dev_name)
 253 {
 254         struct cti_device *cti_dev = &drvdata->ctidev;
 255
 256         tc->con_dev = csdev;
 257         /*
 258          * Prefer actual associated CS device dev name to supplied value -
 259          * which is likely to be node name / other conn name.
 260          */
 261         if (csdev)
 262                 tc->con_dev_name = dev_name(&csdev->dev);
 263         else if (assoc_dev_name != NULL) {
 264                 tc->con_dev_name = devm_kstrdup(dev,
 265                                                 assoc_dev_name, GFP_KERNEL);
 266                 if (!tc->con_dev_name)
 267                         return -ENOMEM;
 268         }
 269         list_add_tail(&tc->node, &cti_dev->trig_cons);
 270         cti_dev->nr_trig_con++;
 271
 272         /* add connection usage bit info to overall info */
 273         drvdata->config.trig_in_use |= tc->con_in->used_mask;
 274         drvdata->config.trig_out_use |= tc->con_out->used_mask;
 275
 276         return 0;
 277 }
 278
 279 /* create a trigger connection with appropriately sized signal groups */
 280 struct cti_trig_con *cti_allocate_trig_con(struct device *dev, int in_sigs,
 281                                            int out_sigs)
 282 {
 283         struct cti_trig_con *tc = NULL;
 284         struct cti_trig_grp *in = NULL, *out = NULL;
 285
 286         tc = devm_kzalloc(dev, sizeof(struct cti_trig_con), GFP_KERNEL);
 287         if (!tc)
 288                 return tc;
 289
 290         in = devm_kzalloc(dev,
 291                           offsetof(struct cti_trig_grp, sig_types[in_sigs]),
 292                           GFP_KERNEL);
 293         if (!in)
 294                 return NULL;
 295
 296         out = devm_kzalloc(dev,
 297                            offsetof(struct cti_trig_grp, sig_types[out_sigs]),
 298                            GFP_KERNEL);
 299         if (!out)
 300                 return NULL;
 301
 302         tc->con_in = in;
 303         tc->con_out = out;
 304         tc->con_in->nr_sigs = in_sigs;
 305         tc->con_out->nr_sigs = out_sigs;
 306         return tc;
 307 }
 308
 309 /*
 310  * Add a default connection if nothing else is specified.
 311  * single connection based on max in/out info, no assoc device
 312  */
 313 int cti_add_default_connection(struct device *dev, struct cti_drvdata *drvdata)
 314 {
 315         int ret = 0;
 316         int n_trigs = drvdata->config.nr_trig_max;
 317         u32 n_trig_mask = GENMASK(n_trigs - 1, 0);
 318         struct cti_trig_con *tc = NULL;
 319
 320         /*
 321          * Assume max trigs for in and out,
 322          * all used, default sig types allocated
 323          */
 324         tc = cti_allocate_trig_con(dev, n_trigs, n_trigs);
 325         if (!tc)
 326                 return -ENOMEM;
 327
 328         tc->con_in->used_mask = n_trig_mask;
 329         tc->con_out->used_mask = n_trig_mask;
 330         ret = cti_add_connection_entry(dev, drvdata, tc, NULL, "default");
 331         return ret;
 332 }
 333
 334 /** cti channel api **/
 335 /* attach/detach channel from trigger - write through if enabled. */
 336 int cti_channel_trig_op(struct device *dev, enum cti_chan_op op,
 337                         enum cti_trig_dir direction, u32 channel_idx,
 338                         u32 trigger_idx)
 339 {
 340         struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
 341         struct cti_config *config = &drvdata->config;
 342         u32 trig_bitmask;
 343         u32 chan_bitmask;
 344         u32 reg_value;
 345         int reg_offset;
 346
 347         /* ensure indexes in range */
 348         if ((channel_idx >= config->nr_ctm_channels) ||
 349            (trigger_idx >= config->nr_trig_max))
 350                 return -EINVAL;
 351
 352         trig_bitmask = BIT(trigger_idx);
 353
 354         /* ensure registered triggers and not out filtered */
 355         if (direction == CTI_TRIG_IN)   {
 356                 if (!(trig_bitmask & config->trig_in_use))
 357                         return -EINVAL;
 358         } else {
 359                 if (!(trig_bitmask & config->trig_out_use))
 360                         return -EINVAL;
 361
 362                 if ((config->trig_filter_enable) &&
 363                     (config->trig_out_filter & trig_bitmask))
 364                         return -EINVAL;
 365         }
 366
 367         /* update the local register values */
 368         chan_bitmask = BIT(channel_idx);
 369         reg_offset = (direction == CTI_TRIG_IN ? CTIINEN(trigger_idx) :
 370                       CTIOUTEN(trigger_idx));
 371
 372         spin_lock(&drvdata->spinlock);
 373
 374         /* read - modify write - the trigger / channel enable value */
 375         reg_value = direction == CTI_TRIG_IN ? config->ctiinen[trigger_idx] :
 376                      config->ctiouten[trigger_idx];
 377         if (op == CTI_CHAN_ATTACH)
 378                 reg_value |= chan_bitmask;
 379         else
 380                 reg_value &= ~chan_bitmask;
 381
 382         /* write local copy */
 383         if (direction == CTI_TRIG_IN)
 384                 config->ctiinen[trigger_idx] = reg_value;
 385         else
 386                 config->ctiouten[trigger_idx] = reg_value;
 387
 388         /* write through if enabled */
 389         if (cti_active(config))
 390                 cti_write_single_reg(drvdata, reg_offset, reg_value);
 391         spin_unlock(&drvdata->spinlock);
 392         return 0;
 393 }
 394
 395 int cti_channel_gate_op(struct device *dev, enum cti_chan_gate_op op,
 396                         u32 channel_idx)
 397 {
 398         struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
 399         struct cti_config *config = &drvdata->config;
 400         u32 chan_bitmask;
 401         u32 reg_value;
 402         int err = 0;
 403
 404         if (channel_idx >= config->nr_ctm_channels)
 405                 return -EINVAL;
 406
 407         chan_bitmask = BIT(channel_idx);
 408
 409         spin_lock(&drvdata->spinlock);
 410         reg_value = config->ctigate;
 411         switch (op) {
 412         case CTI_GATE_CHAN_ENABLE:
 413                 reg_value |= chan_bitmask;
 414                 break;
 415
 416         case CTI_GATE_CHAN_DISABLE:
 417                 reg_value &= ~chan_bitmask;
 418                 break;
 419
 420         default:
 421                 err = -EINVAL;
 422                 break;
 423         }
 424         if (err == 0) {
 425                 config->ctigate = reg_value;
 426                 if (cti_active(config))
 427                         cti_write_single_reg(drvdata, CTIGATE, reg_value);
 428         }
 429         spin_unlock(&drvdata->spinlock);
 430         return err;
 431 }
 432
 433 int cti_channel_setop(struct device *dev, enum cti_chan_set_op op,
 434                       u32 channel_idx)
 435 {
 436         struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
 437         struct cti_config *config = &drvdata->config;
 438         u32 chan_bitmask;
 439         u32 reg_value;
 440         u32 reg_offset;
 441         int err = 0;
 442
 443         if (channel_idx >= config->nr_ctm_channels)
 444                 return -EINVAL;
 445
 446         chan_bitmask = BIT(channel_idx);
 447
 448         spin_lock(&drvdata->spinlock);
 449         reg_value = config->ctiappset;
 450         switch (op) {
 451         case CTI_CHAN_SET:
 452                 config->ctiappset |= chan_bitmask;
 453                 reg_value  = config->ctiappset;
 454                 reg_offset = CTIAPPSET;
 455                 break;
 456
 457         case CTI_CHAN_CLR:
 458                 config->ctiappset &= ~chan_bitmask;
 459                 reg_value = chan_bitmask;
 460                 reg_offset = CTIAPPCLEAR;
 461                 break;
 462
 463         case CTI_CHAN_PULSE:
 464                 config->ctiappset &= ~chan_bitmask;
 465                 reg_value = chan_bitmask;
 466                 reg_offset = CTIAPPPULSE;
 467                 break;
 468
 469         default:
 470                 err = -EINVAL;
 471                 break;
 472         }
 473
 474         if ((err == 0) && cti_active(config))
 475                 cti_write_single_reg(drvdata, reg_offset, reg_value);
 476         spin_unlock(&drvdata->spinlock);
 477
 478         return err;
 479 }
 480
 481 static bool cti_add_sysfs_link(struct cti_drvdata *drvdata,
 482                                struct cti_trig_con *tc)
 483 {
 484         struct coresight_sysfs_link link_info;
 485         int link_err = 0;
 486
 487         link_info.orig = drvdata->csdev;
 488         link_info.orig_name = tc->con_dev_name;
 489         link_info.target = tc->con_dev;
 490         link_info.target_name = dev_name(&drvdata->csdev->dev);
 491
 492         link_err = coresight_add_sysfs_link(&link_info);
 493         if (link_err)
 494                 dev_warn(&drvdata->csdev->dev,
 495                          "Failed to set CTI sysfs link %s<=>%s\n",
 496                          link_info.orig_name, link_info.target_name);
 497         return !link_err;
 498 }
 499
 500 static void cti_remove_sysfs_link(struct cti_drvdata *drvdata,
 501                                   struct cti_trig_con *tc)
 502 {
 503         struct coresight_sysfs_link link_info;
 504
 505         link_info.orig = drvdata->csdev;
 506         link_info.orig_name = tc->con_dev_name;
 507         link_info.target = tc->con_dev;
 508         link_info.target_name = dev_name(&drvdata->csdev->dev);
 509         coresight_remove_sysfs_link(&link_info);
 510 }
 511
 512 /*
 513  * Look for a matching connection device name in the list of connections.
 514  * If found then swap in the csdev name, set trig con association pointer
 515  * and return found.
 516  */
 517 static bool
 518 cti_match_fixup_csdev(struct cti_device *ctidev, const char *node_name,
 519                       struct coresight_device *csdev)
 520 {
 521         struct cti_trig_con *tc;
 522         struct cti_drvdata *drvdata = container_of(ctidev, struct cti_drvdata,
 523                                                    ctidev);
 524
 525         list_for_each_entry(tc, &ctidev->trig_cons, node) {
 526                 if (tc->con_dev_name) {
 527                         if (!strcmp(node_name, tc->con_dev_name)) {
 528                                 /* match: so swap in csdev name & dev */
 529                                 tc->con_dev_name = dev_name(&csdev->dev);
 530                                 tc->con_dev = csdev;
 531                                 /* try to set sysfs link */
 532                                 if (cti_add_sysfs_link(drvdata, tc))
 533                                         return true;
 534                                 /* link failed - remove CTI reference */
 535                                 tc->con_dev = NULL;
 536                                 break;
 537                         }
 538                 }
 539         }
 540         return false;
 541 }
 542
 543 /*
 544  * Search the cti list to add an associated CTI into the supplied CS device
 545  * This will set the association if CTI declared before the CS device.
 546  * (called from coresight_register() without coresight_mutex locked).
 547  */
 548 static void cti_add_assoc_to_csdev(struct coresight_device *csdev)
 549 {
 550         struct cti_drvdata *ect_item;
 551         struct cti_device *ctidev;
 552         const char *node_name = NULL;
 553
 554         /* protect the list */
 555         mutex_lock(&ect_mutex);
 556
 557         /* exit if current is an ECT device.*/
 558         if ((csdev->type == CORESIGHT_DEV_TYPE_HELPER &&
 559              csdev->subtype.helper_subtype ==
 560                      CORESIGHT_DEV_SUBTYPE_HELPER_ECT_CTI) ||
 561             list_empty(&ect_net))
 562                 goto cti_add_done;
 563
 564         /* if we didn't find the csdev previously we used the fwnode name */
 565         node_name = cti_plat_get_node_name(dev_fwnode(csdev->dev.parent));
 566         if (!node_name)
 567                 goto cti_add_done;
 568
 569         /* for each CTI in list... */
 570         list_for_each_entry(ect_item, &ect_net, node) {
 571                 ctidev = &ect_item->ctidev;
 572                 if (cti_match_fixup_csdev(ctidev, node_name, csdev)) {
 573                         /*
 574                          * if we found a matching csdev then update the ECT
 575                          * association pointer for the device with this CTI.
 576                          */
 577                         coresight_add_helper(csdev, ect_item->csdev);
 578                         break;
 579                 }
 580         }
 581 cti_add_done:
 582         mutex_unlock(&ect_mutex);
 583 }
 584
 585 /*
 586  * Removing the associated devices is easier.
 587  */
 588 static void cti_remove_assoc_from_csdev(struct coresight_device *csdev)
 589 {
 590         struct cti_drvdata *ctidrv;
 591         struct cti_trig_con *tc;
 592         struct cti_device *ctidev;
 593         union coresight_dev_subtype cti_subtype = {
 594                 .helper_subtype = CORESIGHT_DEV_SUBTYPE_HELPER_ECT_CTI
 595         };
 596         struct coresight_device *cti_csdev = coresight_find_output_type(
 597                 csdev->pdata, CORESIGHT_DEV_TYPE_HELPER, cti_subtype);
 598
 599         if (!cti_csdev)
 600                 return;
 601
 602         mutex_lock(&ect_mutex);
 603         ctidrv = csdev_to_cti_drvdata(cti_csdev);
 604         ctidev = &ctidrv->ctidev;
 605         list_for_each_entry(tc, &ctidev->trig_cons, node) {
 606                 if (tc->con_dev == csdev) {
 607                         cti_remove_sysfs_link(ctidrv, tc);
 608                         tc->con_dev = NULL;
 609                         break;
 610                 }
 611         }
 612         mutex_unlock(&ect_mutex);
 613 }
 614
 615 /*
 616  * Operations to add and remove associated CTI.
 617  * Register to coresight core driver as call back function.
 618  */
 619 static struct cti_assoc_op cti_assoc_ops = {
 620         .add = cti_add_assoc_to_csdev,
 621         .remove = cti_remove_assoc_from_csdev
 622 };
 623
 624 /*
 625  * Update the cross references where the associated device was found
 626  * while we were building the connection info. This will occur if the
 627  * assoc device was registered before the CTI.
 628  */
 629 static void cti_update_conn_xrefs(struct cti_drvdata *drvdata)
 630 {
 631         struct cti_trig_con *tc;
 632         struct cti_device *ctidev = &drvdata->ctidev;
 633
 634         list_for_each_entry(tc, &ctidev->trig_cons, node) {
 635                 if (tc->con_dev) {
 636                         /* if we can set the sysfs link */
 637                         if (cti_add_sysfs_link(drvdata, tc))
 638                                 /* set the CTI/csdev association */
 639                                 coresight_add_helper(tc->con_dev,
 640                                                      drvdata->csdev);
 641                         else
 642                                 /* otherwise remove reference from CTI */
 643                                 tc->con_dev = NULL;
 644                 }
 645         }
 646 }
 647
 648 static void cti_remove_conn_xrefs(struct cti_drvdata *drvdata)
 649 {
 650         struct cti_trig_con *tc;
 651         struct cti_device *ctidev = &drvdata->ctidev;
 652
 653         list_for_each_entry(tc, &ctidev->trig_cons, node) {
 654                 if (tc->con_dev) {
 655                         cti_remove_sysfs_link(drvdata, tc);
 656                         tc->con_dev = NULL;
 657                 }
 658         }
 659 }
 660
 661 /** cti PM callbacks **/
 662 static int cti_cpu_pm_notify(struct notifier_block *nb, unsigned long cmd,
 663                              void *v)
 664 {
 665         struct cti_drvdata *drvdata;
 666         struct coresight_device *csdev;
 667         unsigned int cpu = smp_processor_id();
 668         int notify_res = NOTIFY_OK;
 669
 670         if (!cti_cpu_drvdata[cpu])
 671                 return NOTIFY_OK;
 672
 673         drvdata = cti_cpu_drvdata[cpu];
 674         csdev = drvdata->csdev;
 675
 676         if (WARN_ON_ONCE(drvdata->ctidev.cpu != cpu))
 677                 return NOTIFY_BAD;
 678
 679         spin_lock(&drvdata->spinlock);
 680
 681         switch (cmd) {
 682         case CPU_PM_ENTER:
 683                 /* CTI regs all static - we have a copy & nothing to save */
 684                 drvdata->config.hw_powered = false;
 685                 if (drvdata->config.hw_enabled)
 686                         coresight_disclaim_device(csdev);
 687                 break;
 688
 689         case CPU_PM_ENTER_FAILED:
 690                 drvdata->config.hw_powered = true;
 691                 if (drvdata->config.hw_enabled) {
 692                         if (coresight_claim_device(csdev))
 693                                 drvdata->config.hw_enabled = false;
 694                 }
 695                 break;
 696
 697         case CPU_PM_EXIT:
 698                 /* write hardware registers to re-enable. */
 699                 drvdata->config.hw_powered = true;
 700                 drvdata->config.hw_enabled = false;
 701
 702                 /* check enable reference count to enable HW */
 703                 if (drvdata->config.enable_req_count) {
 704                         /* check we can claim the device as we re-power */
 705                         if (coresight_claim_device(csdev))
 706                                 goto cti_notify_exit;
 707
 708                         drvdata->config.hw_enabled = true;
 709                         cti_write_all_hw_regs(drvdata);
 710                 }
 711                 break;
 712
 713         default:
 714                 notify_res = NOTIFY_DONE;
 715                 break;
 716         }
 717
 718 cti_notify_exit:
 719         spin_unlock(&drvdata->spinlock);
 720         return notify_res;
 721 }
 722
 723 static struct notifier_block cti_cpu_pm_nb = {
 724         .notifier_call = cti_cpu_pm_notify,
 725 };
 726
 727 /* CPU HP handlers */
 728 static int cti_starting_cpu(unsigned int cpu)
 729 {
 730         struct cti_drvdata *drvdata = cti_cpu_drvdata[cpu];
 731
 732         if (!drvdata)
 733                 return 0;
 734
 735         cti_cpuhp_enable_hw(drvdata);
 736         return 0;
 737 }
 738
 739 static int cti_dying_cpu(unsigned int cpu)
 740 {
 741         struct cti_drvdata *drvdata = cti_cpu_drvdata[cpu];
 742
 743         if (!drvdata)
 744                 return 0;
 745
 746         spin_lock(&drvdata->spinlock);
 747         drvdata->config.hw_powered = false;
 748         if (drvdata->config.hw_enabled)
 749                 coresight_disclaim_device(drvdata->csdev);
 750         spin_unlock(&drvdata->spinlock);
 751         return 0;
 752 }
 753
 754 static int cti_pm_setup(struct cti_drvdata *drvdata)
 755 {
 756         int ret;
 757
 758         if (drvdata->ctidev.cpu == -1)
 759                 return 0;
 760
 761         if (nr_cti_cpu)
 762                 goto done;
 763
 764         cpus_read_lock();
 765         ret = cpuhp_setup_state_nocalls_cpuslocked(
 766                         CPUHP_AP_ARM_CORESIGHT_CTI_STARTING,
 767                         "arm/coresight_cti:starting",
 768                         cti_starting_cpu, cti_dying_cpu);
 769         if (ret) {
 770                 cpus_read_unlock();
 771                 return ret;
 772         }
 773
 774         ret = cpu_pm_register_notifier(&cti_cpu_pm_nb);
 775         cpus_read_unlock();
 776         if (ret) {
 777                 cpuhp_remove_state_nocalls(CPUHP_AP_ARM_CORESIGHT_CTI_STARTING);
 778                 return ret;
 779         }
 780
 781 done:
 782         nr_cti_cpu++;
 783         cti_cpu_drvdata[drvdata->ctidev.cpu] = drvdata;
 784
 785         return 0;
 786 }
 787
 788 /* release PM registrations */
 789 static void cti_pm_release(struct cti_drvdata *drvdata)
 790 {
 791         if (drvdata->ctidev.cpu == -1)
 792                 return;
 793
 794         cti_cpu_drvdata[drvdata->ctidev.cpu] = NULL;
 795         if (--nr_cti_cpu == 0) {
 796                 cpu_pm_unregister_notifier(&cti_cpu_pm_nb);
 797                 cpuhp_remove_state_nocalls(CPUHP_AP_ARM_CORESIGHT_CTI_STARTING);
 798         }
 799 }
 800
 801 /** cti ect operations **/
 802 int cti_enable(struct coresight_device *csdev, enum cs_mode mode, void *data)
 803 {
 804         struct cti_drvdata *drvdata = csdev_to_cti_drvdata(csdev);
 805
 806         return cti_enable_hw(drvdata);
 807 }
 808
 809 int cti_disable(struct coresight_device *csdev, void *data)
 810 {
 811         struct cti_drvdata *drvdata = csdev_to_cti_drvdata(csdev);
 812
 813         return cti_disable_hw(drvdata);
 814 }
 815
 816 static const struct coresight_ops_helper cti_ops_ect = {
 817         .enable = cti_enable,
 818         .disable = cti_disable,
 819 };
 820
 821 static const struct coresight_ops cti_ops = {
 822         .helper_ops = &cti_ops_ect,
 823 };
 824
 825 /*
 826  * Free up CTI specific resources
 827  * called by dev->release, need to call down to underlying csdev release.
 828  */
 829 static void cti_device_release(struct device *dev)
 830 {
 831         struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent);
 832         struct cti_drvdata *ect_item, *ect_tmp;
 833
 834         mutex_lock(&ect_mutex);
 835         cti_pm_release(drvdata);
 836
 837         /* remove from the list */
 838         list_for_each_entry_safe(ect_item, ect_tmp, &ect_net, node) {
 839                 if (ect_item == drvdata) {
 840                         list_del(&ect_item->node);
 841                         break;
 842                 }
 843         }
 844         mutex_unlock(&ect_mutex);
 845
 846         if (drvdata->csdev_release)
 847                 drvdata->csdev_release(dev);
 848 }
 849 static void cti_remove(struct amba_device *adev)
 850 {
 851         struct cti_drvdata *drvdata = dev_get_drvdata(&adev->dev);
 852
 853         mutex_lock(&ect_mutex);
 854         cti_remove_conn_xrefs(drvdata);
 855         mutex_unlock(&ect_mutex);
 856
 857         coresight_unregister(drvdata->csdev);
 858 }
 859
 860 static int cti_probe(struct amba_device *adev, const struct amba_id *id)
 861 {
 862         int ret = 0;
 863         void __iomem *base;
 864         struct device *dev = &adev->dev;
 865         struct cti_drvdata *drvdata = NULL;
 866         struct coresight_desc cti_desc;
 867         struct coresight_platform_data *pdata = NULL;
 868         struct resource *res = &adev->res;
 869
 870         /* driver data*/
 871         drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL);
 872         if (!drvdata)
 873                 return -ENOMEM;
 874
 875         /* Validity for the resource is already checked by the AMBA core */
 876         base = devm_ioremap_resource(dev, res);
 877         if (IS_ERR(base))
 878                 return PTR_ERR(base);
 879
 880         drvdata->base = base;
 881         cti_desc.access = CSDEV_ACCESS_IOMEM(base);
 882
 883         dev_set_drvdata(dev, drvdata);
 884
 885         /* default CTI device info  */
 886         drvdata->ctidev.cpu = -1;
 887         drvdata->ctidev.nr_trig_con = 0;
 888         drvdata->ctidev.ctm_id = 0;
 889         INIT_LIST_HEAD(&drvdata->ctidev.trig_cons);
 890
 891         spin_lock_init(&drvdata->spinlock);
 892
 893         /* initialise CTI driver config values */
 894         cti_set_default_config(dev, drvdata);
 895
 896         pdata = coresight_cti_get_platform_data(dev);
 897         if (IS_ERR(pdata)) {
 898                 dev_err(dev, "coresight_cti_get_platform_data err\n");
 899                 return  PTR_ERR(pdata);
 900         }
 901
 902         /* default to powered - could change on PM notifications */
 903         drvdata->config.hw_powered = true;
 904
 905         /* set up device name - will depend if cpu bound or otherwise */
 906         if (drvdata->ctidev.cpu >= 0)
 907                 cti_desc.name = devm_kasprintf(dev, GFP_KERNEL, "cti_cpu%d",
 908                                                drvdata->ctidev.cpu);
 909         else
 910                 cti_desc.name = coresight_alloc_device_name(&cti_sys_devs, dev);
 911         if (!cti_desc.name)
 912                 return -ENOMEM;
 913
 914         /* setup CPU power management handling for CPU bound CTI devices. */
 915         ret = cti_pm_setup(drvdata);
 916         if (ret)
 917                 return ret;
 918
 919         /* create dynamic attributes for connections */
 920         ret = cti_create_cons_sysfs(dev, drvdata);
 921         if (ret) {
 922                 dev_err(dev, "%s: create dynamic sysfs entries failed\n",
 923                         cti_desc.name);
 924                 goto pm_release;
 925         }
 926
 927         /* set up coresight component description */
 928         cti_desc.pdata = pdata;
 929         cti_desc.type = CORESIGHT_DEV_TYPE_HELPER;
 930         cti_desc.subtype.helper_subtype = CORESIGHT_DEV_SUBTYPE_HELPER_ECT_CTI;
 931         cti_desc.ops = &cti_ops;
 932         cti_desc.groups = drvdata->ctidev.con_groups;
 933         cti_desc.dev = dev;
 934         drvdata->csdev = coresight_register(&cti_desc);
 935         if (IS_ERR(drvdata->csdev)) {
 936                 ret = PTR_ERR(drvdata->csdev);
 937                 goto pm_release;
 938         }
 939
 940         /* add to list of CTI devices */
 941         mutex_lock(&ect_mutex);
 942         list_add(&drvdata->node, &ect_net);
 943         /* set any cross references */
 944         cti_update_conn_xrefs(drvdata);
 945         mutex_unlock(&ect_mutex);
 946
 947         /* set up release chain */
 948         drvdata->csdev_release = drvdata->csdev->dev.release;
 949         drvdata->csdev->dev.release = cti_device_release;
 950
 951         /* all done - dec pm refcount */
 952         pm_runtime_put(&adev->dev);
 953         dev_info(&drvdata->csdev->dev, "CTI initialized\n");
 954         return 0;
 955
 956 pm_release:
 957         cti_pm_release(drvdata);
 958         return ret;
 959 }
 960
 961 static struct amba_cs_uci_id uci_id_cti[] = {
 962         {
 963                 /*  CTI UCI data */
 964                 .devarch        = 0x47701a14, /* CTI v2 */
 965                 .devarch_mask   = 0xfff0ffff,
 966                 .devtype        = 0x00000014, /* maj(0x4-debug) min(0x1-ECT) */
 967         }
 968 };
 969
 970 static const struct amba_id cti_ids[] = {
 971         CS_AMBA_ID(0x000bb906), /* Coresight CTI (SoC 400), C-A72, C-A57 */
 972         CS_AMBA_ID(0x000bb922), /* CTI - C-A8 */
 973         CS_AMBA_ID(0x000bb9a8), /* CTI - C-A53 */
 974         CS_AMBA_ID(0x000bb9aa), /* CTI - C-A73 */
 975         CS_AMBA_UCI_ID(0x000bb9da, uci_id_cti), /* CTI - C-A35 */
 976         CS_AMBA_UCI_ID(0x000bb9ed, uci_id_cti), /* Coresight CTI (SoC 600) */
 977         { 0, 0, NULL },
 978 };
 979
 980 MODULE_DEVICE_TABLE(amba, cti_ids);
 981
 982 static struct amba_driver cti_driver = {
 983         .drv = {
 984                 .name   = "coresight-cti",
 985                 .suppress_bind_attrs = true,
 986         },
 987         .probe          = cti_probe,
 988         .remove         = cti_remove,
 989         .id_table       = cti_ids,
 990 };
 991
 992 static int __init cti_init(void)
 993 {
 994         int ret;
 995
 996         ret = amba_driver_register(&cti_driver);
 997         if (ret)
 998                 pr_info("Error registering cti driver\n");
 999         coresight_set_cti_ops(&cti_assoc_ops);
1000         return ret;
1001 }
1002
1003 static void __exit cti_exit(void)
1004 {
1005         coresight_remove_cti_ops();
1006         amba_driver_unregister(&cti_driver);
1007 }
1008
1009 module_init(cti_init);
1010 module_exit(cti_exit);
1011
1012 MODULE_AUTHOR("Mike Leach <mike.leach@linaro.org>");
1013 MODULE_DESCRIPTION("Arm CoreSight CTI Driver");
1014 MODULE_LICENSE("GPL v2");