drivers/hwtracing/coresight/coresight-replicator.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
   4  *
   5  * Description: CoreSight Replicator driver
   6  */
   7
   8 #include <linux/acpi.h>
   9 #include <linux/amba/bus.h>
  10 #include <linux/kernel.h>
  11 #include <linux/device.h>
  12 #include <linux/platform_device.h>
  13 #include <linux/io.h>
  14 #include <linux/err.h>
  15 #include <linux/slab.h>
  16 #include <linux/pm_runtime.h>
  17 #include <linux/property.h>
  18 #include <linux/clk.h>
  19 #include <linux/of.h>
  20 #include <linux/coresight.h>
  21
  22 #include "coresight-priv.h"
  23
  24 #define REPLICATOR_IDFILTER0            0x000
  25 #define REPLICATOR_IDFILTER1            0x004
  26
  27 DEFINE_CORESIGHT_DEVLIST(replicator_devs, "replicator");
  28
  29 /**
  30  * struct replicator_drvdata - specifics associated to a replicator component
  31  * @base:       memory mapped base address for this component. Also indicates
  32  *              whether this one is programmable or not.
  33  * @atclk:      optional clock for the core parts of the replicator.
  34  * @csdev:      component vitals needed by the framework
  35  * @spinlock:   serialize enable/disable operations.
  36  * @check_idfilter_val: check if the context is lost upon clock removal.
  37  */
  38 struct replicator_drvdata {
  39         void __iomem            *base;
  40         struct clk              *atclk;
  41         struct coresight_device *csdev;
  42         spinlock_t              spinlock;
  43         bool                    check_idfilter_val;
  44 };
  45
  46 static void dynamic_replicator_reset(struct replicator_drvdata *drvdata)
  47 {
  48         struct coresight_device *csdev = drvdata->csdev;
  49
  50         CS_UNLOCK(drvdata->base);
  51
  52         if (!coresight_claim_device_unlocked(csdev)) {
  53                 writel_relaxed(0xff, drvdata->base + REPLICATOR_IDFILTER0);
  54                 writel_relaxed(0xff, drvdata->base + REPLICATOR_IDFILTER1);
  55                 coresight_disclaim_device_unlocked(csdev);
  56         }
  57
  58         CS_LOCK(drvdata->base);
  59 }
  60
  61 /*
  62  * replicator_reset : Reset the replicator configuration to sane values.
  63  */
  64 static inline void replicator_reset(struct replicator_drvdata *drvdata)
  65 {
  66         if (drvdata->base)
  67                 dynamic_replicator_reset(drvdata);
  68 }
  69
  70 static int dynamic_replicator_enable(struct replicator_drvdata *drvdata,
  71                                      int inport, int outport)
  72 {
  73         int rc = 0;
  74         u32 id0val, id1val;
  75         struct coresight_device *csdev = drvdata->csdev;
  76
  77         CS_UNLOCK(drvdata->base);
  78
  79         id0val = readl_relaxed(drvdata->base + REPLICATOR_IDFILTER0);
  80         id1val = readl_relaxed(drvdata->base + REPLICATOR_IDFILTER1);
  81
  82         /*
  83          * Some replicator designs lose context when AMBA clocks are removed,
  84          * so have a check for this.
  85          */
  86         if (drvdata->check_idfilter_val && id0val == 0x0 && id1val == 0x0)
  87                 id0val = id1val = 0xff;
  88
  89         if (id0val == 0xff && id1val == 0xff)
  90                 rc = coresight_claim_device_unlocked(csdev);
  91
  92         if (!rc) {
  93                 switch (outport) {
  94                 case 0:
  95                         id0val = 0x0;
  96                         break;
  97                 case 1:
  98                         id1val = 0x0;
  99                         break;
 100                 default:
 101                         WARN_ON(1);
 102                         rc = -EINVAL;
 103                 }
 104         }
 105
 106         /* Ensure that the outport is enabled. */
 107         if (!rc) {
 108                 writel_relaxed(id0val, drvdata->base + REPLICATOR_IDFILTER0);
 109                 writel_relaxed(id1val, drvdata->base + REPLICATOR_IDFILTER1);
 110         }
 111
 112         CS_LOCK(drvdata->base);
 113
 114         return rc;
 115 }
 116
 117 static int replicator_enable(struct coresight_device *csdev,
 118                              struct coresight_connection *in,
 119                              struct coresight_connection *out)
 120 {
 121         int rc = 0;
 122         struct replicator_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
 123         unsigned long flags;
 124         bool first_enable = false;
 125
 126         spin_lock_irqsave(&drvdata->spinlock, flags);
 127         if (atomic_read(&out->src_refcnt) == 0) {
 128                 if (drvdata->base)
 129                         rc = dynamic_replicator_enable(drvdata, in->dest_port,
 130                                                        out->src_port);
 131                 if (!rc)
 132                         first_enable = true;
 133         }
 134         if (!rc)
 135                 atomic_inc(&out->src_refcnt);
 136         spin_unlock_irqrestore(&drvdata->spinlock, flags);
 137
 138         if (first_enable)
 139                 dev_dbg(&csdev->dev, "REPLICATOR enabled\n");
 140         return rc;
 141 }
 142
 143 static void dynamic_replicator_disable(struct replicator_drvdata *drvdata,
 144                                        int inport, int outport)
 145 {
 146         u32 reg;
 147         struct coresight_device *csdev = drvdata->csdev;
 148
 149         switch (outport) {
 150         case 0:
 151                 reg = REPLICATOR_IDFILTER0;
 152                 break;
 153         case 1:
 154                 reg = REPLICATOR_IDFILTER1;
 155                 break;
 156         default:
 157                 WARN_ON(1);
 158                 return;
 159         }
 160
 161         CS_UNLOCK(drvdata->base);
 162
 163         /* disable the flow of ATB data through port */
 164         writel_relaxed(0xff, drvdata->base + reg);
 165
 166         if ((readl_relaxed(drvdata->base + REPLICATOR_IDFILTER0) == 0xff) &&
 167             (readl_relaxed(drvdata->base + REPLICATOR_IDFILTER1) == 0xff))
 168                 coresight_disclaim_device_unlocked(csdev);
 169         CS_LOCK(drvdata->base);
 170 }
 171
 172 static void replicator_disable(struct coresight_device *csdev,
 173                                struct coresight_connection *in,
 174                                struct coresight_connection *out)
 175 {
 176         struct replicator_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
 177         unsigned long flags;
 178         bool last_disable = false;
 179
 180         spin_lock_irqsave(&drvdata->spinlock, flags);
 181         if (atomic_dec_return(&out->src_refcnt) == 0) {
 182                 if (drvdata->base)
 183                         dynamic_replicator_disable(drvdata, in->dest_port,
 184                                                    out->src_port);
 185                 last_disable = true;
 186         }
 187         spin_unlock_irqrestore(&drvdata->spinlock, flags);
 188
 189         if (last_disable)
 190                 dev_dbg(&csdev->dev, "REPLICATOR disabled\n");
 191 }
 192
 193 static const struct coresight_ops_link replicator_link_ops = {
 194         .enable         = replicator_enable,
 195         .disable        = replicator_disable,
 196 };
 197
 198 static const struct coresight_ops replicator_cs_ops = {
 199         .link_ops       = &replicator_link_ops,
 200 };
 201
 202 static struct attribute *replicator_mgmt_attrs[] = {
 203         coresight_simple_reg32(idfilter0, REPLICATOR_IDFILTER0),
 204         coresight_simple_reg32(idfilter1, REPLICATOR_IDFILTER1),
 205         NULL,
 206 };
 207
 208 static const struct attribute_group replicator_mgmt_group = {
 209         .attrs = replicator_mgmt_attrs,
 210         .name = "mgmt",
 211 };
 212
 213 static const struct attribute_group *replicator_groups[] = {
 214         &replicator_mgmt_group,
 215         NULL,
 216 };
 217
 218 static int replicator_probe(struct device *dev, struct resource *res)
 219 {
 220         int ret = 0;
 221         struct coresight_platform_data *pdata = NULL;
 222         struct replicator_drvdata *drvdata;
 223         struct coresight_desc desc = { 0 };
 224         void __iomem *base;
 225
 226         if (is_of_node(dev_fwnode(dev)) &&
 227             of_device_is_compatible(dev->of_node, "arm,coresight-replicator"))
 228                 dev_warn_once(dev,
 229                               "Uses OBSOLETE CoreSight replicator binding\n");
 230
 231         desc.name = coresight_alloc_device_name(&replicator_devs, dev);
 232         if (!desc.name)
 233                 return -ENOMEM;
 234
 235         drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL);
 236         if (!drvdata)
 237                 return -ENOMEM;
 238
 239         drvdata->atclk = devm_clk_get(dev, "atclk"); /* optional */
 240         if (!IS_ERR(drvdata->atclk)) {
 241                 ret = clk_prepare_enable(drvdata->atclk);
 242                 if (ret)
 243                         return ret;
 244         }
 245
 246         /*
 247          * Map the device base for dynamic-replicator, which has been
 248          * validated by AMBA core
 249          */
 250         if (res) {
 251                 base = devm_ioremap_resource(dev, res);
 252                 if (IS_ERR(base)) {
 253                         ret = PTR_ERR(base);
 254                         goto out_disable_clk;
 255                 }
 256                 drvdata->base = base;
 257                 desc.groups = replicator_groups;
 258                 desc.access = CSDEV_ACCESS_IOMEM(base);
 259         }
 260
 261         if (fwnode_property_present(dev_fwnode(dev),
 262                                     "qcom,replicator-loses-context"))
 263                 drvdata->check_idfilter_val = true;
 264
 265         dev_set_drvdata(dev, drvdata);
 266
 267         pdata = coresight_get_platform_data(dev);
 268         if (IS_ERR(pdata)) {
 269                 ret = PTR_ERR(pdata);
 270                 goto out_disable_clk;
 271         }
 272         dev->platform_data = pdata;
 273
 274         spin_lock_init(&drvdata->spinlock);
 275         desc.type = CORESIGHT_DEV_TYPE_LINK;
 276         desc.subtype.link_subtype = CORESIGHT_DEV_SUBTYPE_LINK_SPLIT;
 277         desc.ops = &replicator_cs_ops;
 278         desc.pdata = dev->platform_data;
 279         desc.dev = dev;
 280
 281         drvdata->csdev = coresight_register(&desc);
 282         if (IS_ERR(drvdata->csdev)) {
 283                 ret = PTR_ERR(drvdata->csdev);
 284                 goto out_disable_clk;
 285         }
 286
 287         replicator_reset(drvdata);
 288         pm_runtime_put(dev);
 289
 290 out_disable_clk:
 291         if (ret && !IS_ERR_OR_NULL(drvdata->atclk))
 292                 clk_disable_unprepare(drvdata->atclk);
 293         return ret;
 294 }
 295
 296 static int replicator_remove(struct device *dev)
 297 {
 298         struct replicator_drvdata *drvdata = dev_get_drvdata(dev);
 299
 300         coresight_unregister(drvdata->csdev);
 301         return 0;
 302 }
 303
 304 static int static_replicator_probe(struct platform_device *pdev)
 305 {
 306         int ret;
 307
 308         pm_runtime_get_noresume(&pdev->dev);
 309         pm_runtime_set_active(&pdev->dev);
 310         pm_runtime_enable(&pdev->dev);
 311
 312         /* Static replicators do not have programming base */
 313         ret = replicator_probe(&pdev->dev, NULL);
 314
 315         if (ret) {
 316                 pm_runtime_put_noidle(&pdev->dev);
 317                 pm_runtime_disable(&pdev->dev);
 318         }
 319
 320         return ret;
 321 }
 322
 323 static int static_replicator_remove(struct platform_device *pdev)
 324 {
 325         replicator_remove(&pdev->dev);
 326         pm_runtime_disable(&pdev->dev);
 327         return 0;
 328 }
 329
 330 #ifdef CONFIG_PM
 331 static int replicator_runtime_suspend(struct device *dev)
 332 {
 333         struct replicator_drvdata *drvdata = dev_get_drvdata(dev);
 334
 335         if (drvdata && !IS_ERR(drvdata->atclk))
 336                 clk_disable_unprepare(drvdata->atclk);
 337
 338         return 0;
 339 }
 340
 341 static int replicator_runtime_resume(struct device *dev)
 342 {
 343         struct replicator_drvdata *drvdata = dev_get_drvdata(dev);
 344
 345         if (drvdata && !IS_ERR(drvdata->atclk))
 346                 clk_prepare_enable(drvdata->atclk);
 347
 348         return 0;
 349 }
 350 #endif
 351
 352 static const struct dev_pm_ops replicator_dev_pm_ops = {
 353         SET_RUNTIME_PM_OPS(replicator_runtime_suspend,
 354                            replicator_runtime_resume, NULL)
 355 };
 356
 357 static const struct of_device_id static_replicator_match[] = {
 358         {.compatible = "arm,coresight-replicator"},
 359         {.compatible = "arm,coresight-static-replicator"},
 360         {}
 361 };
 362
 363 MODULE_DEVICE_TABLE(of, static_replicator_match);
 364
 365 #ifdef CONFIG_ACPI
 366 static const struct acpi_device_id static_replicator_acpi_ids[] = {
 367         {"ARMHC985", 0}, /* ARM CoreSight Static Replicator */
 368         {}
 369 };
 370
 371 MODULE_DEVICE_TABLE(acpi, static_replicator_acpi_ids);
 372 #endif
 373
 374 static struct platform_driver static_replicator_driver = {
 375         .probe          = static_replicator_probe,
 376         .remove         = static_replicator_remove,
 377         .driver         = {
 378                 .name   = "coresight-static-replicator",
 379                 /* THIS_MODULE is taken care of by platform_driver_register() */
 380                 .of_match_table = of_match_ptr(static_replicator_match),
 381                 .acpi_match_table = ACPI_PTR(static_replicator_acpi_ids),
 382                 .pm     = &replicator_dev_pm_ops,
 383                 .suppress_bind_attrs = true,
 384         },
 385 };
 386
 387 static int dynamic_replicator_probe(struct amba_device *adev,
 388                                     const struct amba_id *id)
 389 {
 390         return replicator_probe(&adev->dev, &adev->res);
 391 }
 392
 393 static void dynamic_replicator_remove(struct amba_device *adev)
 394 {
 395         replicator_remove(&adev->dev);
 396 }
 397
 398 static const struct amba_id dynamic_replicator_ids[] = {
 399         CS_AMBA_ID(0x000bb909),
 400         CS_AMBA_ID(0x000bb9ec),         /* Coresight SoC-600 */
 401         {},
 402 };
 403
 404 MODULE_DEVICE_TABLE(amba, dynamic_replicator_ids);
 405
 406 static struct amba_driver dynamic_replicator_driver = {
 407         .drv = {
 408                 .name   = "coresight-dynamic-replicator",
 409                 .pm     = &replicator_dev_pm_ops,
 410                 .owner  = THIS_MODULE,
 411                 .suppress_bind_attrs = true,
 412         },
 413         .probe          = dynamic_replicator_probe,
 414         .remove         = dynamic_replicator_remove,
 415         .id_table       = dynamic_replicator_ids,
 416 };
 417
 418 static int __init replicator_init(void)
 419 {
 420         int ret;
 421
 422         ret = platform_driver_register(&static_replicator_driver);
 423         if (ret) {
 424                 pr_info("Error registering platform driver\n");
 425                 return ret;
 426         }
 427
 428         ret = amba_driver_register(&dynamic_replicator_driver);
 429         if (ret) {
 430                 pr_info("Error registering amba driver\n");
 431                 platform_driver_unregister(&static_replicator_driver);
 432         }
 433
 434         return ret;
 435 }
 436
 437 static void __exit replicator_exit(void)
 438 {
 439         platform_driver_unregister(&static_replicator_driver);
 440         amba_driver_unregister(&dynamic_replicator_driver);
 441 }
 442
 443 module_init(replicator_init);
 444 module_exit(replicator_exit);
 445
 446 MODULE_AUTHOR("Pratik Patel <pratikp@codeaurora.org>");
 447 MODULE_AUTHOR("Mathieu Poirier <mathieu.poirier@linaro.org>");
 448 MODULE_DESCRIPTION("Arm CoreSight Replicator Driver");
 449 MODULE_LICENSE("GPL v2");