drivers/devfreq/event/exynos-ppmu.c

   1 /*
   2  * exynos_ppmu.c - EXYNOS PPMU (Platform Performance Monitoring Unit) support
   3  *
   4  * Copyright (c) 2014-2015 Samsung Electronics Co., Ltd.
   5  * Author : Chanwoo Choi <cw00.choi@samsung.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  * This driver is based on drivers/devfreq/exynos/exynos_ppmu.c
  12  */
  13
  14 #include <linux/clk.h>
  15 #include <linux/io.h>
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/mutex.h>
  19 #include <linux/of_address.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/suspend.h>
  22 #include <linux/devfreq-event.h>
  23
  24 #include "exynos-ppmu.h"
  25
  26 struct exynos_ppmu_data {
  27         void __iomem *base;
  28         struct clk *clk;
  29 };
  30
  31 struct exynos_ppmu {
  32         struct devfreq_event_dev **edev;
  33         struct devfreq_event_desc *desc;
  34         unsigned int num_events;
  35
  36         struct device *dev;
  37         struct mutex lock;
  38
  39         struct exynos_ppmu_data ppmu;
  40 };
  41
  42 #define PPMU_EVENT(name)                        \
  43         { "ppmu-event0-"#name, PPMU_PMNCNT0 },  \
  44         { "ppmu-event1-"#name, PPMU_PMNCNT1 },  \
  45         { "ppmu-event2-"#name, PPMU_PMNCNT2 },  \
  46         { "ppmu-event3-"#name, PPMU_PMNCNT3 }
  47
  48 struct __exynos_ppmu_events {
  49         char *name;
  50         int id;
  51 } ppmu_events[] = {
  52         /* For Exynos3250, Exynos4 and Exynos5260 */
  53         PPMU_EVENT(g3d),
  54         PPMU_EVENT(fsys),
  55
  56         /* For Exynos4 SoCs and Exynos3250 */
  57         PPMU_EVENT(dmc0),
  58         PPMU_EVENT(dmc1),
  59         PPMU_EVENT(cpu),
  60         PPMU_EVENT(rightbus),
  61         PPMU_EVENT(leftbus),
  62         PPMU_EVENT(lcd0),
  63         PPMU_EVENT(camif),
  64
  65         /* Only for Exynos3250 and Exynos5260 */
  66         PPMU_EVENT(mfc),
  67
  68         /* Only for Exynos4 SoCs */
  69         PPMU_EVENT(mfc-left),
  70         PPMU_EVENT(mfc-right),
  71
  72         /* Only for Exynos5260 SoCs */
  73         PPMU_EVENT(drex0-s0),
  74         PPMU_EVENT(drex0-s1),
  75         PPMU_EVENT(drex1-s0),
  76         PPMU_EVENT(drex1-s1),
  77         PPMU_EVENT(eagle),
  78         PPMU_EVENT(kfc),
  79         PPMU_EVENT(isp),
  80         PPMU_EVENT(fimc),
  81         PPMU_EVENT(gscl),
  82         PPMU_EVENT(mscl),
  83         PPMU_EVENT(fimd0x),
  84         PPMU_EVENT(fimd1x),
  85
  86         /* Only for Exynos5433 SoCs */
  87         PPMU_EVENT(d0-cpu),
  88         PPMU_EVENT(d0-general),
  89         PPMU_EVENT(d0-rt),
  90         PPMU_EVENT(d1-cpu),
  91         PPMU_EVENT(d1-general),
  92         PPMU_EVENT(d1-rt),
  93
  94         { /* sentinel */ },
  95 };
  96
  97 static int exynos_ppmu_find_ppmu_id(struct devfreq_event_dev *edev)
  98 {
  99         int i;
 100
 101         for (i = 0; i < ARRAY_SIZE(ppmu_events); i++)
 102                 if (!strcmp(edev->desc->name, ppmu_events[i].name))
 103                         return ppmu_events[i].id;
 104
 105         return -EINVAL;
 106 }
 107
 108 /*
 109  * The devfreq-event ops structure for PPMU v1.1
 110  */
 111 static int exynos_ppmu_disable(struct devfreq_event_dev *edev)
 112 {
 113         struct exynos_ppmu *info = devfreq_event_get_drvdata(edev);
 114         u32 pmnc;
 115
 116         /* Disable all counters */
 117         __raw_writel(PPMU_CCNT_MASK |
 118                      PPMU_PMCNT0_MASK |
 119                      PPMU_PMCNT1_MASK |
 120                      PPMU_PMCNT2_MASK |
 121                      PPMU_PMCNT3_MASK,
 122                      info->ppmu.base + PPMU_CNTENC);
 123
 124         /* Disable PPMU */
 125         pmnc = __raw_readl(info->ppmu.base + PPMU_PMNC);
 126         pmnc &= ~PPMU_PMNC_ENABLE_MASK;
 127         __raw_writel(pmnc, info->ppmu.base + PPMU_PMNC);
 128
 129         return 0;
 130 }
 131
 132 static int exynos_ppmu_set_event(struct devfreq_event_dev *edev)
 133 {
 134         struct exynos_ppmu *info = devfreq_event_get_drvdata(edev);
 135         int id = exynos_ppmu_find_ppmu_id(edev);
 136         u32 pmnc, cntens;
 137
 138         if (id < 0)
 139                 return id;
 140
 141         /* Enable specific counter */
 142         cntens = __raw_readl(info->ppmu.base + PPMU_CNTENS);
 143         cntens |= (PPMU_CCNT_MASK | (PPMU_ENABLE << id));
 144         __raw_writel(cntens, info->ppmu.base + PPMU_CNTENS);
 145
 146         /* Set the event of Read/Write data count  */
 147         __raw_writel(PPMU_RO_DATA_CNT | PPMU_WO_DATA_CNT,
 148                         info->ppmu.base + PPMU_BEVTxSEL(id));
 149
 150         /* Reset cycle counter/performance counter and enable PPMU */
 151         pmnc = __raw_readl(info->ppmu.base + PPMU_PMNC);
 152         pmnc &= ~(PPMU_PMNC_ENABLE_MASK
 153                         | PPMU_PMNC_COUNTER_RESET_MASK
 154                         | PPMU_PMNC_CC_RESET_MASK);
 155         pmnc |= (PPMU_ENABLE << PPMU_PMNC_ENABLE_SHIFT);
 156         pmnc |= (PPMU_ENABLE << PPMU_PMNC_COUNTER_RESET_SHIFT);
 157         pmnc |= (PPMU_ENABLE << PPMU_PMNC_CC_RESET_SHIFT);
 158         __raw_writel(pmnc, info->ppmu.base + PPMU_PMNC);
 159
 160         return 0;
 161 }
 162
 163 static int exynos_ppmu_get_event(struct devfreq_event_dev *edev,
 164                                 struct devfreq_event_data *edata)
 165 {
 166         struct exynos_ppmu *info = devfreq_event_get_drvdata(edev);
 167         int id = exynos_ppmu_find_ppmu_id(edev);
 168         u32 pmnc, cntenc;
 169
 170         if (id < 0)
 171                 return -EINVAL;
 172
 173         /* Disable PPMU */
 174         pmnc = __raw_readl(info->ppmu.base + PPMU_PMNC);
 175         pmnc &= ~PPMU_PMNC_ENABLE_MASK;
 176         __raw_writel(pmnc, info->ppmu.base + PPMU_PMNC);
 177
 178         /* Read cycle count */
 179         edata->total_count = __raw_readl(info->ppmu.base + PPMU_CCNT);
 180
 181         /* Read performance count */
 182         switch (id) {
 183         case PPMU_PMNCNT0:
 184         case PPMU_PMNCNT1:
 185         case PPMU_PMNCNT2:
 186                 edata->load_count
 187                         = __raw_readl(info->ppmu.base + PPMU_PMNCT(id));
 188                 break;
 189         case PPMU_PMNCNT3:
 190                 edata->load_count =
 191                         ((__raw_readl(info->ppmu.base + PPMU_PMCNT3_HIGH) << 8)
 192                         | __raw_readl(info->ppmu.base + PPMU_PMCNT3_LOW));
 193                 break;
 194         default:
 195                 return -EINVAL;
 196         }
 197
 198         /* Disable specific counter */
 199         cntenc = __raw_readl(info->ppmu.base + PPMU_CNTENC);
 200         cntenc |= (PPMU_CCNT_MASK | (PPMU_ENABLE << id));
 201         __raw_writel(cntenc, info->ppmu.base + PPMU_CNTENC);
 202
 203         dev_dbg(&edev->dev, "%s (event: %ld/%ld)\n", edev->desc->name,
 204                                         edata->load_count, edata->total_count);
 205
 206         return 0;
 207 }
 208
 209 static const struct devfreq_event_ops exynos_ppmu_ops = {
 210         .disable = exynos_ppmu_disable,
 211         .set_event = exynos_ppmu_set_event,
 212         .get_event = exynos_ppmu_get_event,
 213 };
 214
 215 /*
 216  * The devfreq-event ops structure for PPMU v2.0
 217  */
 218 static int exynos_ppmu_v2_disable(struct devfreq_event_dev *edev)
 219 {
 220         struct exynos_ppmu *info = devfreq_event_get_drvdata(edev);
 221         u32 pmnc, clear;
 222
 223         /* Disable all counters */
 224         clear = (PPMU_CCNT_MASK | PPMU_PMCNT0_MASK | PPMU_PMCNT1_MASK
 225                 | PPMU_PMCNT2_MASK | PPMU_PMCNT3_MASK);
 226
 227         __raw_writel(clear, info->ppmu.base + PPMU_V2_FLAG);
 228         __raw_writel(clear, info->ppmu.base + PPMU_V2_INTENC);
 229         __raw_writel(clear, info->ppmu.base + PPMU_V2_CNTENC);
 230         __raw_writel(clear, info->ppmu.base + PPMU_V2_CNT_RESET);
 231
 232         __raw_writel(0x0, info->ppmu.base + PPMU_V2_CIG_CFG0);
 233         __raw_writel(0x0, info->ppmu.base + PPMU_V2_CIG_CFG1);
 234         __raw_writel(0x0, info->ppmu.base + PPMU_V2_CIG_CFG2);
 235         __raw_writel(0x0, info->ppmu.base + PPMU_V2_CIG_RESULT);
 236         __raw_writel(0x0, info->ppmu.base + PPMU_V2_CNT_AUTO);
 237         __raw_writel(0x0, info->ppmu.base + PPMU_V2_CH_EV0_TYPE);
 238         __raw_writel(0x0, info->ppmu.base + PPMU_V2_CH_EV1_TYPE);
 239         __raw_writel(0x0, info->ppmu.base + PPMU_V2_CH_EV2_TYPE);
 240         __raw_writel(0x0, info->ppmu.base + PPMU_V2_CH_EV3_TYPE);
 241         __raw_writel(0x0, info->ppmu.base + PPMU_V2_SM_ID_V);
 242         __raw_writel(0x0, info->ppmu.base + PPMU_V2_SM_ID_A);
 243         __raw_writel(0x0, info->ppmu.base + PPMU_V2_SM_OTHERS_V);
 244         __raw_writel(0x0, info->ppmu.base + PPMU_V2_SM_OTHERS_A);
 245         __raw_writel(0x0, info->ppmu.base + PPMU_V2_INTERRUPT_RESET);
 246
 247         /* Disable PPMU */
 248         pmnc = __raw_readl(info->ppmu.base + PPMU_V2_PMNC);
 249         pmnc &= ~PPMU_PMNC_ENABLE_MASK;
 250         __raw_writel(pmnc, info->ppmu.base + PPMU_V2_PMNC);
 251
 252         return 0;
 253 }
 254
 255 static int exynos_ppmu_v2_set_event(struct devfreq_event_dev *edev)
 256 {
 257         struct exynos_ppmu *info = devfreq_event_get_drvdata(edev);
 258         int id = exynos_ppmu_find_ppmu_id(edev);
 259         u32 pmnc, cntens;
 260
 261         /* Enable all counters */
 262         cntens = __raw_readl(info->ppmu.base + PPMU_V2_CNTENS);
 263         cntens |= (PPMU_CCNT_MASK | (PPMU_ENABLE << id));
 264         __raw_writel(cntens, info->ppmu.base + PPMU_V2_CNTENS);
 265
 266         /* Set the event of Read/Write data count  */
 267         switch (id) {
 268         case PPMU_PMNCNT0:
 269         case PPMU_PMNCNT1:
 270         case PPMU_PMNCNT2:
 271                 __raw_writel(PPMU_V2_RO_DATA_CNT | PPMU_V2_WO_DATA_CNT,
 272                                 info->ppmu.base + PPMU_V2_CH_EVx_TYPE(id));
 273                 break;
 274         case PPMU_PMNCNT3:
 275                 __raw_writel(PPMU_V2_EVT3_RW_DATA_CNT,
 276                                 info->ppmu.base + PPMU_V2_CH_EVx_TYPE(id));
 277                 break;
 278         }
 279
 280         /* Reset cycle counter/performance counter and enable PPMU */
 281         pmnc = __raw_readl(info->ppmu.base + PPMU_V2_PMNC);
 282         pmnc &= ~(PPMU_PMNC_ENABLE_MASK
 283                         | PPMU_PMNC_COUNTER_RESET_MASK
 284                         | PPMU_PMNC_CC_RESET_MASK
 285                         | PPMU_PMNC_CC_DIVIDER_MASK
 286                         | PPMU_V2_PMNC_START_MODE_MASK);
 287         pmnc |= (PPMU_ENABLE << PPMU_PMNC_ENABLE_SHIFT);
 288         pmnc |= (PPMU_ENABLE << PPMU_PMNC_COUNTER_RESET_SHIFT);
 289         pmnc |= (PPMU_ENABLE << PPMU_PMNC_CC_RESET_SHIFT);
 290         pmnc |= (PPMU_V2_MODE_MANUAL << PPMU_V2_PMNC_START_MODE_SHIFT);
 291         __raw_writel(pmnc, info->ppmu.base + PPMU_V2_PMNC);
 292
 293         return 0;
 294 }
 295
 296 static int exynos_ppmu_v2_get_event(struct devfreq_event_dev *edev,
 297                                     struct devfreq_event_data *edata)
 298 {
 299         struct exynos_ppmu *info = devfreq_event_get_drvdata(edev);
 300         int id = exynos_ppmu_find_ppmu_id(edev);
 301         u32 pmnc, cntenc;
 302         u32 pmcnt_high, pmcnt_low;
 303         u64 load_count = 0;
 304
 305         /* Disable PPMU */
 306         pmnc = __raw_readl(info->ppmu.base + PPMU_V2_PMNC);
 307         pmnc &= ~PPMU_PMNC_ENABLE_MASK;
 308         __raw_writel(pmnc, info->ppmu.base + PPMU_V2_PMNC);
 309
 310         /* Read cycle count and performance count */
 311         edata->total_count = __raw_readl(info->ppmu.base + PPMU_V2_CCNT);
 312
 313         switch (id) {
 314         case PPMU_PMNCNT0:
 315         case PPMU_PMNCNT1:
 316         case PPMU_PMNCNT2:
 317                 load_count = __raw_readl(info->ppmu.base + PPMU_V2_PMNCT(id));
 318                 break;
 319         case PPMU_PMNCNT3:
 320                 pmcnt_high = __raw_readl(info->ppmu.base + PPMU_V2_PMCNT3_HIGH);
 321                 pmcnt_low = __raw_readl(info->ppmu.base + PPMU_V2_PMCNT3_LOW);
 322                 load_count = (u64)((pmcnt_high & 0xff) << 32) + (u64)pmcnt_low;
 323                 break;
 324         }
 325         edata->load_count = load_count;
 326
 327         /* Disable all counters */
 328         cntenc = __raw_readl(info->ppmu.base + PPMU_V2_CNTENC);
 329         cntenc |= (PPMU_CCNT_MASK | (PPMU_ENABLE << id));
 330         __raw_writel(cntenc, info->ppmu.base + PPMU_V2_CNTENC);
 331
 332         dev_dbg(&edev->dev, "%25s (load: %ld / %ld)\n", edev->desc->name,
 333                                         edata->load_count, edata->total_count);
 334         return 0;
 335 }
 336
 337 static const struct devfreq_event_ops exynos_ppmu_v2_ops = {
 338         .disable = exynos_ppmu_v2_disable,
 339         .set_event = exynos_ppmu_v2_set_event,
 340         .get_event = exynos_ppmu_v2_get_event,
 341 };
 342
 343 static const struct of_device_id exynos_ppmu_id_match[] = {
 344         {
 345                 .compatible = "samsung,exynos-ppmu",
 346                 .data = (void *)&exynos_ppmu_ops,
 347         }, {
 348                 .compatible = "samsung,exynos-ppmu-v2",
 349                 .data = (void *)&exynos_ppmu_v2_ops,
 350         },
 351         { /* sentinel */ },
 352 };
 353
 354 static struct devfreq_event_ops *exynos_bus_get_ops(struct device_node *np)
 355 {
 356         const struct of_device_id *match;
 357
 358         match = of_match_node(exynos_ppmu_id_match, np);
 359         return (struct devfreq_event_ops *)match->data;
 360 }
 361
 362 static int of_get_devfreq_events(struct device_node *np,
 363                                  struct exynos_ppmu *info)
 364 {
 365         struct devfreq_event_desc *desc;
 366         struct devfreq_event_ops *event_ops;
 367         struct device *dev = info->dev;
 368         struct device_node *events_np, *node;
 369         int i, j, count;
 370
 371         events_np = of_get_child_by_name(np, "events");
 372         if (!events_np) {
 373                 dev_err(dev,
 374                         "failed to get child node of devfreq-event devices\n");
 375                 return -EINVAL;
 376         }
 377         event_ops = exynos_bus_get_ops(np);
 378
 379         count = of_get_child_count(events_np);
 380         desc = devm_kzalloc(dev, sizeof(*desc) * count, GFP_KERNEL);
 381         if (!desc)
 382                 return -ENOMEM;
 383         info->num_events = count;
 384
 385         j = 0;
 386         for_each_child_of_node(events_np, node) {
 387                 for (i = 0; i < ARRAY_SIZE(ppmu_events); i++) {
 388                         if (!ppmu_events[i].name)
 389                                 continue;
 390
 391                         if (!of_node_cmp(node->name, ppmu_events[i].name))
 392                                 break;
 393                 }
 394
 395                 if (i == ARRAY_SIZE(ppmu_events)) {
 396                         dev_warn(dev,
 397                                 "don't know how to configure events : %s\n",
 398                                 node->name);
 399                         continue;
 400                 }
 401
 402                 desc[j].ops = event_ops;
 403                 desc[j].driver_data = info;
 404
 405                 of_property_read_string(node, "event-name", &desc[j].name);
 406
 407                 j++;
 408
 409                 of_node_put(node);
 410         }
 411         info->desc = desc;
 412
 413         of_node_put(events_np);
 414
 415         return 0;
 416 }
 417
 418 static int exynos_ppmu_parse_dt(struct exynos_ppmu *info)
 419 {
 420         struct device *dev = info->dev;
 421         struct device_node *np = dev->of_node;
 422         int ret = 0;
 423
 424         if (!np) {
 425                 dev_err(dev, "failed to find devicetree node\n");
 426                 return -EINVAL;
 427         }
 428
 429         /* Maps the memory mapped IO to control PPMU register */
 430         info->ppmu.base = of_iomap(np, 0);
 431         if (IS_ERR_OR_NULL(info->ppmu.base)) {
 432                 dev_err(dev, "failed to map memory region\n");
 433                 return -ENOMEM;
 434         }
 435
 436         info->ppmu.clk = devm_clk_get(dev, "ppmu");
 437         if (IS_ERR(info->ppmu.clk)) {
 438                 info->ppmu.clk = NULL;
 439                 dev_warn(dev, "cannot get PPMU clock\n");
 440         }
 441
 442         ret = of_get_devfreq_events(np, info);
 443         if (ret < 0) {
 444                 dev_err(dev, "failed to parse exynos ppmu dt node\n");
 445                 goto err;
 446         }
 447
 448         return 0;
 449
 450 err:
 451         iounmap(info->ppmu.base);
 452
 453         return ret;
 454 }
 455
 456 static int exynos_ppmu_probe(struct platform_device *pdev)
 457 {
 458         struct exynos_ppmu *info;
 459         struct devfreq_event_dev **edev;
 460         struct devfreq_event_desc *desc;
 461         int i, ret = 0, size;
 462
 463         info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
 464         if (!info)
 465                 return -ENOMEM;
 466
 467         mutex_init(&info->lock);
 468         info->dev = &pdev->dev;
 469
 470         /* Parse dt data to get resource */
 471         ret = exynos_ppmu_parse_dt(info);
 472         if (ret < 0) {
 473                 dev_err(&pdev->dev,
 474                         "failed to parse devicetree for resource\n");
 475                 return ret;
 476         }
 477         desc = info->desc;
 478
 479         size = sizeof(struct devfreq_event_dev *) * info->num_events;
 480         info->edev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
 481         if (!info->edev) {
 482                 dev_err(&pdev->dev,
 483                         "failed to allocate memory devfreq-event devices\n");
 484                 return -ENOMEM;
 485         }
 486         edev = info->edev;
 487         platform_set_drvdata(pdev, info);
 488
 489         for (i = 0; i < info->num_events; i++) {
 490                 edev[i] = devm_devfreq_event_add_edev(&pdev->dev, &desc[i]);
 491                 if (IS_ERR(edev[i])) {
 492                         ret = PTR_ERR(edev[i]);
 493                         dev_err(&pdev->dev,
 494                                 "failed to add devfreq-event device\n");
 495                         goto err;
 496                 }
 497         }
 498
 499         clk_prepare_enable(info->ppmu.clk);
 500
 501         return 0;
 502 err:
 503         iounmap(info->ppmu.base);
 504
 505         return ret;
 506 }
 507
 508 static int exynos_ppmu_remove(struct platform_device *pdev)
 509 {
 510         struct exynos_ppmu *info = platform_get_drvdata(pdev);
 511
 512         clk_disable_unprepare(info->ppmu.clk);
 513         iounmap(info->ppmu.base);
 514
 515         return 0;
 516 }
 517
 518 static struct platform_driver exynos_ppmu_driver = {
 519         .probe  = exynos_ppmu_probe,
 520         .remove = exynos_ppmu_remove,
 521         .driver = {
 522                 .name   = "exynos-ppmu",
 523                 .of_match_table = exynos_ppmu_id_match,
 524         },
 525 };
 526 module_platform_driver(exynos_ppmu_driver);
 527
 528 MODULE_DESCRIPTION("Exynos PPMU(Platform Performance Monitoring Unit) driver");
 529 MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>");
 530 MODULE_LICENSE("GPL");