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"); 531