1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2011-2012, The Linux Foundation. All rights reserved. 4 * 5 * Description: CoreSight Funnel driver 6 */ 7 8 #include <linux/acpi.h> 9 #include <linux/kernel.h> 10 #include <linux/init.h> 11 #include <linux/types.h> 12 #include <linux/device.h> 13 #include <linux/err.h> 14 #include <linux/fs.h> 15 #include <linux/slab.h> 16 #include <linux/of.h> 17 #include <linux/platform_device.h> 18 #include <linux/pm_runtime.h> 19 #include <linux/coresight.h> 20 #include <linux/amba/bus.h> 21 #include <linux/clk.h> 22 23 #include "coresight-priv.h" 24 25 #define FUNNEL_FUNCTL 0x000 26 #define FUNNEL_PRICTL 0x004 27 28 #define FUNNEL_HOLDTIME_MASK 0xf00 29 #define FUNNEL_HOLDTIME_SHFT 0x8 30 #define FUNNEL_HOLDTIME (0x7 << FUNNEL_HOLDTIME_SHFT) 31 #define FUNNEL_ENSx_MASK 0xff 32 33 DEFINE_CORESIGHT_DEVLIST(funnel_devs, "funnel"); 34 35 /** 36 * struct funnel_drvdata - specifics associated to a funnel component 37 * @base: memory mapped base address for this component. 38 * @atclk: optional clock for the core parts of the funnel. 39 * @pclk: APB clock if present, otherwise NULL 40 * @csdev: component vitals needed by the framework. 41 * @priority: port selection order. 42 * @spinlock: serialize enable/disable operations. 43 */ 44 struct funnel_drvdata { 45 void __iomem *base; 46 struct clk *atclk; 47 struct clk *pclk; 48 struct coresight_device *csdev; 49 unsigned long priority; 50 raw_spinlock_t spinlock; 51 }; 52 53 static int dynamic_funnel_enable_hw(struct funnel_drvdata *drvdata, int port) 54 { 55 u32 functl; 56 int rc = 0; 57 struct coresight_device *csdev = drvdata->csdev; 58 59 CS_UNLOCK(drvdata->base); 60 61 functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL); 62 /* Claim the device only when we enable the first slave */ 63 if (!(functl & FUNNEL_ENSx_MASK)) { 64 rc = coresight_claim_device_unlocked(csdev); 65 if (rc) 66 goto done; 67 } 68 69 functl &= ~FUNNEL_HOLDTIME_MASK; 70 functl |= FUNNEL_HOLDTIME; 71 functl |= (1 << port); 72 writel_relaxed(functl, drvdata->base + FUNNEL_FUNCTL); 73 writel_relaxed(drvdata->priority, drvdata->base + FUNNEL_PRICTL); 74 done: 75 CS_LOCK(drvdata->base); 76 return rc; 77 } 78 79 static int funnel_enable(struct coresight_device *csdev, 80 struct coresight_connection *in, 81 struct coresight_connection *out) 82 { 83 int rc = 0; 84 struct funnel_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); 85 unsigned long flags; 86 bool first_enable = false; 87 88 raw_spin_lock_irqsave(&drvdata->spinlock, flags); 89 if (in->dest_refcnt == 0) { 90 if (drvdata->base) 91 rc = dynamic_funnel_enable_hw(drvdata, in->dest_port); 92 if (!rc) 93 first_enable = true; 94 } 95 if (!rc) 96 in->dest_refcnt++; 97 raw_spin_unlock_irqrestore(&drvdata->spinlock, flags); 98 99 if (first_enable) 100 dev_dbg(&csdev->dev, "FUNNEL inport %d enabled\n", 101 in->dest_port); 102 return rc; 103 } 104 105 static void dynamic_funnel_disable_hw(struct funnel_drvdata *drvdata, 106 int inport) 107 { 108 u32 functl; 109 struct coresight_device *csdev = drvdata->csdev; 110 111 CS_UNLOCK(drvdata->base); 112 113 functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL); 114 functl &= ~(1 << inport); 115 writel_relaxed(functl, drvdata->base + FUNNEL_FUNCTL); 116 117 /* Disclaim the device if none of the slaves are now active */ 118 if (!(functl & FUNNEL_ENSx_MASK)) 119 coresight_disclaim_device_unlocked(csdev); 120 121 CS_LOCK(drvdata->base); 122 } 123 124 static void funnel_disable(struct coresight_device *csdev, 125 struct coresight_connection *in, 126 struct coresight_connection *out) 127 { 128 struct funnel_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); 129 unsigned long flags; 130 bool last_disable = false; 131 132 raw_spin_lock_irqsave(&drvdata->spinlock, flags); 133 if (--in->dest_refcnt == 0) { 134 if (drvdata->base) 135 dynamic_funnel_disable_hw(drvdata, in->dest_port); 136 last_disable = true; 137 } 138 raw_spin_unlock_irqrestore(&drvdata->spinlock, flags); 139 140 if (last_disable) 141 dev_dbg(&csdev->dev, "FUNNEL inport %d disabled\n", 142 in->dest_port); 143 } 144 145 static const struct coresight_ops_link funnel_link_ops = { 146 .enable = funnel_enable, 147 .disable = funnel_disable, 148 }; 149 150 static const struct coresight_ops funnel_cs_ops = { 151 .link_ops = &funnel_link_ops, 152 }; 153 154 static ssize_t priority_show(struct device *dev, 155 struct device_attribute *attr, char *buf) 156 { 157 struct funnel_drvdata *drvdata = dev_get_drvdata(dev->parent); 158 unsigned long val = drvdata->priority; 159 160 return sprintf(buf, "%#lx\n", val); 161 } 162 163 static ssize_t priority_store(struct device *dev, 164 struct device_attribute *attr, 165 const char *buf, size_t size) 166 { 167 int ret; 168 unsigned long val; 169 struct funnel_drvdata *drvdata = dev_get_drvdata(dev->parent); 170 171 ret = kstrtoul(buf, 16, &val); 172 if (ret) 173 return ret; 174 175 drvdata->priority = val; 176 return size; 177 } 178 static DEVICE_ATTR_RW(priority); 179 180 static u32 get_funnel_ctrl_hw(struct funnel_drvdata *drvdata) 181 { 182 u32 functl; 183 184 CS_UNLOCK(drvdata->base); 185 functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL); 186 CS_LOCK(drvdata->base); 187 188 return functl; 189 } 190 191 static ssize_t funnel_ctrl_show(struct device *dev, 192 struct device_attribute *attr, char *buf) 193 { 194 u32 val; 195 struct funnel_drvdata *drvdata = dev_get_drvdata(dev->parent); 196 197 pm_runtime_get_sync(dev->parent); 198 199 val = get_funnel_ctrl_hw(drvdata); 200 201 pm_runtime_put(dev->parent); 202 203 return sprintf(buf, "%#x\n", val); 204 } 205 static DEVICE_ATTR_RO(funnel_ctrl); 206 207 static struct attribute *coresight_funnel_attrs[] = { 208 &dev_attr_funnel_ctrl.attr, 209 &dev_attr_priority.attr, 210 NULL, 211 }; 212 ATTRIBUTE_GROUPS(coresight_funnel); 213 214 static int funnel_probe(struct device *dev, struct resource *res) 215 { 216 void __iomem *base; 217 struct coresight_platform_data *pdata = NULL; 218 struct funnel_drvdata *drvdata; 219 struct coresight_desc desc = { 0 }; 220 int ret; 221 222 if (is_of_node(dev_fwnode(dev)) && 223 of_device_is_compatible(dev->of_node, "arm,coresight-funnel")) 224 dev_warn_once(dev, "Uses OBSOLETE CoreSight funnel binding\n"); 225 226 desc.name = coresight_alloc_device_name(&funnel_devs, dev); 227 if (!desc.name) 228 return -ENOMEM; 229 230 drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL); 231 if (!drvdata) 232 return -ENOMEM; 233 234 ret = coresight_get_enable_clocks(dev, &drvdata->pclk, &drvdata->atclk); 235 if (ret) 236 return ret; 237 238 /* 239 * Map the device base for dynamic-funnel, which has been 240 * validated by AMBA core. 241 */ 242 if (res) { 243 base = devm_ioremap_resource(dev, res); 244 if (IS_ERR(base)) 245 return PTR_ERR(base); 246 drvdata->base = base; 247 desc.groups = coresight_funnel_groups; 248 desc.access = CSDEV_ACCESS_IOMEM(base); 249 coresight_clear_self_claim_tag(&desc.access); 250 } 251 252 dev_set_drvdata(dev, drvdata); 253 254 pdata = coresight_get_platform_data(dev); 255 if (IS_ERR(pdata)) 256 return PTR_ERR(pdata); 257 258 dev->platform_data = pdata; 259 260 raw_spin_lock_init(&drvdata->spinlock); 261 desc.type = CORESIGHT_DEV_TYPE_LINK; 262 desc.subtype.link_subtype = CORESIGHT_DEV_SUBTYPE_LINK_MERG; 263 desc.ops = &funnel_cs_ops; 264 desc.pdata = pdata; 265 desc.dev = dev; 266 drvdata->csdev = coresight_register(&desc); 267 if (IS_ERR(drvdata->csdev)) 268 return PTR_ERR(drvdata->csdev); 269 270 return 0; 271 } 272 273 static int funnel_remove(struct device *dev) 274 { 275 struct funnel_drvdata *drvdata = dev_get_drvdata(dev); 276 277 coresight_unregister(drvdata->csdev); 278 279 return 0; 280 } 281 282 #ifdef CONFIG_PM 283 static int funnel_runtime_suspend(struct device *dev) 284 { 285 struct funnel_drvdata *drvdata = dev_get_drvdata(dev); 286 287 clk_disable_unprepare(drvdata->atclk); 288 clk_disable_unprepare(drvdata->pclk); 289 290 return 0; 291 } 292 293 static int funnel_runtime_resume(struct device *dev) 294 { 295 struct funnel_drvdata *drvdata = dev_get_drvdata(dev); 296 int ret; 297 298 ret = clk_prepare_enable(drvdata->pclk); 299 if (ret) 300 return ret; 301 302 ret = clk_prepare_enable(drvdata->atclk); 303 if (ret) 304 clk_disable_unprepare(drvdata->pclk); 305 306 return ret; 307 } 308 #endif 309 310 static const struct dev_pm_ops funnel_dev_pm_ops = { 311 SET_RUNTIME_PM_OPS(funnel_runtime_suspend, funnel_runtime_resume, NULL) 312 }; 313 314 static int funnel_platform_probe(struct platform_device *pdev) 315 { 316 struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 317 int ret; 318 319 pm_runtime_get_noresume(&pdev->dev); 320 pm_runtime_set_active(&pdev->dev); 321 pm_runtime_enable(&pdev->dev); 322 323 ret = funnel_probe(&pdev->dev, res); 324 pm_runtime_put(&pdev->dev); 325 if (ret) 326 pm_runtime_disable(&pdev->dev); 327 328 return ret; 329 } 330 331 static void funnel_platform_remove(struct platform_device *pdev) 332 { 333 struct funnel_drvdata *drvdata = dev_get_drvdata(&pdev->dev); 334 335 if (WARN_ON(!drvdata)) 336 return; 337 338 funnel_remove(&pdev->dev); 339 pm_runtime_disable(&pdev->dev); 340 } 341 342 static const struct of_device_id funnel_match[] = { 343 {.compatible = "arm,coresight-static-funnel"}, 344 {} 345 }; 346 347 MODULE_DEVICE_TABLE(of, funnel_match); 348 349 #ifdef CONFIG_ACPI 350 static const struct acpi_device_id funnel_acpi_ids[] = { 351 {"ARMHC9FE", 0, 0, 0}, /* ARM Coresight Static Funnel */ 352 {"ARMHC9FF", 0, 0, 0}, /* ARM CoreSight Dynamic Funnel */ 353 {}, 354 }; 355 356 MODULE_DEVICE_TABLE(acpi, funnel_acpi_ids); 357 #endif 358 359 static struct platform_driver funnel_driver = { 360 .probe = funnel_platform_probe, 361 .remove = funnel_platform_remove, 362 .driver = { 363 .name = "coresight-funnel", 364 /* THIS_MODULE is taken care of by platform_driver_register() */ 365 .of_match_table = funnel_match, 366 .acpi_match_table = ACPI_PTR(funnel_acpi_ids), 367 .pm = &funnel_dev_pm_ops, 368 .suppress_bind_attrs = true, 369 }, 370 }; 371 372 static int dynamic_funnel_probe(struct amba_device *adev, 373 const struct amba_id *id) 374 { 375 int ret; 376 377 ret = funnel_probe(&adev->dev, &adev->res); 378 if (!ret) 379 pm_runtime_put(&adev->dev); 380 381 return ret; 382 } 383 384 static void dynamic_funnel_remove(struct amba_device *adev) 385 { 386 funnel_remove(&adev->dev); 387 } 388 389 static const struct amba_id dynamic_funnel_ids[] = { 390 { 391 .id = 0x000bb908, 392 .mask = 0x000fffff, 393 }, 394 { 395 /* Coresight SoC-600 */ 396 .id = 0x000bb9eb, 397 .mask = 0x000fffff, 398 }, 399 { 0, 0, NULL }, 400 }; 401 402 MODULE_DEVICE_TABLE(amba, dynamic_funnel_ids); 403 404 static struct amba_driver dynamic_funnel_driver = { 405 .drv = { 406 .name = "coresight-dynamic-funnel", 407 .pm = &funnel_dev_pm_ops, 408 .suppress_bind_attrs = true, 409 }, 410 .probe = dynamic_funnel_probe, 411 .remove = dynamic_funnel_remove, 412 .id_table = dynamic_funnel_ids, 413 }; 414 415 static int __init funnel_init(void) 416 { 417 return coresight_init_driver("funnel", &dynamic_funnel_driver, &funnel_driver, 418 THIS_MODULE); 419 } 420 421 static void __exit funnel_exit(void) 422 { 423 coresight_remove_driver(&dynamic_funnel_driver, &funnel_driver); 424 } 425 426 module_init(funnel_init); 427 module_exit(funnel_exit); 428 429 MODULE_AUTHOR("Pratik Patel <pratikp@codeaurora.org>"); 430 MODULE_AUTHOR("Mathieu Poirier <mathieu.poirier@linaro.org>"); 431 MODULE_DESCRIPTION("Arm CoreSight Funnel Driver"); 432 MODULE_LICENSE("GPL v2"); 433