1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (c) 2018, The Linux Foundation. All rights reserved.*/ 3 4 #include <linux/err.h> 5 #include <linux/init.h> 6 #include <linux/kernel.h> 7 #include <linux/module.h> 8 #include <linux/mutex.h> 9 #include <linux/pm_domain.h> 10 #include <linux/slab.h> 11 #include <linux/of.h> 12 #include <linux/platform_device.h> 13 #include <linux/pm_opp.h> 14 #include <soc/qcom/cmd-db.h> 15 #include <soc/qcom/rpmh.h> 16 #include <dt-bindings/power/qcom-rpmpd.h> 17 #include <dt-bindings/power/qcom,rpmhpd.h> 18 19 #define domain_to_rpmhpd(domain) container_of(domain, struct rpmhpd, pd) 20 21 #define RPMH_ARC_MAX_LEVELS 16 22 23 /** 24 * struct rpmhpd - top level RPMh power domain resource data structure 25 * @dev: rpmh power domain controller device 26 * @pd: generic_pm_domain corresponding to the power domain 27 * @parent: generic_pm_domain corresponding to the parent's power domain 28 * @peer: A peer power domain in case Active only Voting is 29 * supported 30 * @active_only: True if it represents an Active only peer 31 * @corner: current corner 32 * @active_corner: current active corner 33 * @enable_corner: lowest non-zero corner 34 * @level: An array of level (vlvl) to corner (hlvl) mappings 35 * derived from cmd-db 36 * @level_count: Number of levels supported by the power domain. max 37 * being 16 (0 - 15) 38 * @enabled: true if the power domain is enabled 39 * @res_name: Resource name used for cmd-db lookup 40 * @addr: Resource address as looped up using resource name from 41 * cmd-db 42 * @state_synced: Indicator that sync_state has been invoked for the rpmhpd resource 43 */ 44 struct rpmhpd { 45 struct device *dev; 46 struct generic_pm_domain pd; 47 struct generic_pm_domain *parent; 48 struct rpmhpd *peer; 49 const bool active_only; 50 unsigned int corner; 51 unsigned int active_corner; 52 unsigned int enable_corner; 53 u32 level[RPMH_ARC_MAX_LEVELS]; 54 size_t level_count; 55 bool enabled; 56 const char *res_name; 57 u32 addr; 58 bool state_synced; 59 }; 60 61 struct rpmhpd_desc { 62 struct rpmhpd **rpmhpds; 63 size_t num_pds; 64 }; 65 66 static DEFINE_MUTEX(rpmhpd_lock); 67 68 /* RPMH powerdomains */ 69 70 static struct rpmhpd cx_ao; 71 static struct rpmhpd mx; 72 static struct rpmhpd mx_ao; 73 static struct rpmhpd cx = { 74 .pd = { .name = "cx", }, 75 .peer = &cx_ao, 76 .res_name = "cx.lvl", 77 }; 78 79 static struct rpmhpd cx_ao = { 80 .pd = { .name = "cx_ao", }, 81 .active_only = true, 82 .peer = &cx, 83 .res_name = "cx.lvl", 84 }; 85 86 static struct rpmhpd cx_ao_w_mx_parent; 87 static struct rpmhpd cx_w_mx_parent = { 88 .pd = { .name = "cx", }, 89 .peer = &cx_ao_w_mx_parent, 90 .parent = &mx.pd, 91 .res_name = "cx.lvl", 92 }; 93 94 static struct rpmhpd cx_ao_w_mx_parent = { 95 .pd = { .name = "cx_ao", }, 96 .active_only = true, 97 .peer = &cx_w_mx_parent, 98 .parent = &mx_ao.pd, 99 .res_name = "cx.lvl", 100 }; 101 102 static struct rpmhpd ebi = { 103 .pd = { .name = "ebi", }, 104 .res_name = "ebi.lvl", 105 }; 106 107 static struct rpmhpd gfx = { 108 .pd = { .name = "gfx", }, 109 .res_name = "gfx.lvl", 110 }; 111 112 static struct rpmhpd lcx = { 113 .pd = { .name = "lcx", }, 114 .res_name = "lcx.lvl", 115 }; 116 117 static struct rpmhpd lmx = { 118 .pd = { .name = "lmx", }, 119 .res_name = "lmx.lvl", 120 }; 121 122 static struct rpmhpd mmcx_ao; 123 static struct rpmhpd mmcx = { 124 .pd = { .name = "mmcx", }, 125 .peer = &mmcx_ao, 126 .res_name = "mmcx.lvl", 127 }; 128 129 static struct rpmhpd mmcx_ao = { 130 .pd = { .name = "mmcx_ao", }, 131 .active_only = true, 132 .peer = &mmcx, 133 .res_name = "mmcx.lvl", 134 }; 135 136 static struct rpmhpd mmcx_ao_w_cx_parent; 137 static struct rpmhpd mmcx_w_cx_parent = { 138 .pd = { .name = "mmcx", }, 139 .peer = &mmcx_ao_w_cx_parent, 140 .parent = &cx.pd, 141 .res_name = "mmcx.lvl", 142 }; 143 144 static struct rpmhpd mmcx_ao_w_cx_parent = { 145 .pd = { .name = "mmcx_ao", }, 146 .active_only = true, 147 .peer = &mmcx_w_cx_parent, 148 .parent = &cx_ao.pd, 149 .res_name = "mmcx.lvl", 150 }; 151 152 static struct rpmhpd mss = { 153 .pd = { .name = "mss", }, 154 .res_name = "mss.lvl", 155 }; 156 157 static struct rpmhpd mx_ao; 158 static struct rpmhpd mx = { 159 .pd = { .name = "mx", }, 160 .peer = &mx_ao, 161 .res_name = "mx.lvl", 162 }; 163 164 static struct rpmhpd mx_ao = { 165 .pd = { .name = "mx_ao", }, 166 .active_only = true, 167 .peer = &mx, 168 .res_name = "mx.lvl", 169 }; 170 171 static struct rpmhpd mxc_ao; 172 static struct rpmhpd mxc = { 173 .pd = { .name = "mxc", }, 174 .peer = &mxc_ao, 175 .res_name = "mxc.lvl", 176 }; 177 178 static struct rpmhpd mxc_ao = { 179 .pd = { .name = "mxc_ao", }, 180 .active_only = true, 181 .peer = &mxc, 182 .res_name = "mxc.lvl", 183 }; 184 185 static struct rpmhpd nsp = { 186 .pd = { .name = "nsp", }, 187 .res_name = "nsp.lvl", 188 }; 189 190 static struct rpmhpd nsp0 = { 191 .pd = { .name = "nsp0", }, 192 .res_name = "nsp0.lvl", 193 }; 194 195 static struct rpmhpd nsp1 = { 196 .pd = { .name = "nsp1", }, 197 .res_name = "nsp1.lvl", 198 }; 199 200 static struct rpmhpd nsp2 = { 201 .pd = { .name = "nsp2", }, 202 .res_name = "nsp2.lvl", 203 }; 204 205 static struct rpmhpd qphy = { 206 .pd = { .name = "qphy", }, 207 .res_name = "qphy.lvl", 208 }; 209 210 static struct rpmhpd gmxc = { 211 .pd = { .name = "gmxc", }, 212 .res_name = "gmxc.lvl", 213 }; 214 215 /* SA8540P RPMH powerdomains */ 216 static struct rpmhpd *sa8540p_rpmhpds[] = { 217 [SC8280XP_CX] = &cx, 218 [SC8280XP_CX_AO] = &cx_ao, 219 [SC8280XP_EBI] = &ebi, 220 [SC8280XP_LCX] = &lcx, 221 [SC8280XP_LMX] = &lmx, 222 [SC8280XP_MMCX] = &mmcx, 223 [SC8280XP_MMCX_AO] = &mmcx_ao, 224 [SC8280XP_MX] = &mx, 225 [SC8280XP_MX_AO] = &mx_ao, 226 [SC8280XP_NSP] = &nsp, 227 }; 228 229 static const struct rpmhpd_desc sa8540p_desc = { 230 .rpmhpds = sa8540p_rpmhpds, 231 .num_pds = ARRAY_SIZE(sa8540p_rpmhpds), 232 }; 233 234 /* SA8775P RPMH power domains */ 235 static struct rpmhpd *sa8775p_rpmhpds[] = { 236 [SA8775P_CX] = &cx, 237 [SA8775P_CX_AO] = &cx_ao, 238 [SA8775P_EBI] = &ebi, 239 [SA8775P_GFX] = &gfx, 240 [SA8775P_LCX] = &lcx, 241 [SA8775P_LMX] = &lmx, 242 [SA8775P_MMCX] = &mmcx, 243 [SA8775P_MMCX_AO] = &mmcx_ao, 244 [SA8775P_MXC] = &mxc, 245 [SA8775P_MXC_AO] = &mxc_ao, 246 [SA8775P_MX] = &mx, 247 [SA8775P_MX_AO] = &mx_ao, 248 [SA8775P_NSP0] = &nsp0, 249 [SA8775P_NSP1] = &nsp1, 250 }; 251 252 static const struct rpmhpd_desc sa8775p_desc = { 253 .rpmhpds = sa8775p_rpmhpds, 254 .num_pds = ARRAY_SIZE(sa8775p_rpmhpds), 255 }; 256 257 /* SDM670 RPMH powerdomains */ 258 static struct rpmhpd *sdm670_rpmhpds[] = { 259 [SDM670_CX] = &cx_w_mx_parent, 260 [SDM670_CX_AO] = &cx_ao_w_mx_parent, 261 [SDM670_GFX] = &gfx, 262 [SDM670_LCX] = &lcx, 263 [SDM670_LMX] = &lmx, 264 [SDM670_MSS] = &mss, 265 [SDM670_MX] = &mx, 266 [SDM670_MX_AO] = &mx_ao, 267 }; 268 269 static const struct rpmhpd_desc sdm670_desc = { 270 .rpmhpds = sdm670_rpmhpds, 271 .num_pds = ARRAY_SIZE(sdm670_rpmhpds), 272 }; 273 274 /* SDM845 RPMH powerdomains */ 275 static struct rpmhpd *sdm845_rpmhpds[] = { 276 [SDM845_CX] = &cx_w_mx_parent, 277 [SDM845_CX_AO] = &cx_ao_w_mx_parent, 278 [SDM845_EBI] = &ebi, 279 [SDM845_GFX] = &gfx, 280 [SDM845_LCX] = &lcx, 281 [SDM845_LMX] = &lmx, 282 [SDM845_MSS] = &mss, 283 [SDM845_MX] = &mx, 284 [SDM845_MX_AO] = &mx_ao, 285 }; 286 287 static const struct rpmhpd_desc sdm845_desc = { 288 .rpmhpds = sdm845_rpmhpds, 289 .num_pds = ARRAY_SIZE(sdm845_rpmhpds), 290 }; 291 292 /* SDX55 RPMH powerdomains */ 293 static struct rpmhpd *sdx55_rpmhpds[] = { 294 [SDX55_CX] = &cx_w_mx_parent, 295 [SDX55_MSS] = &mss, 296 [SDX55_MX] = &mx, 297 }; 298 299 static const struct rpmhpd_desc sdx55_desc = { 300 .rpmhpds = sdx55_rpmhpds, 301 .num_pds = ARRAY_SIZE(sdx55_rpmhpds), 302 }; 303 304 /* SDX65 RPMH powerdomains */ 305 static struct rpmhpd *sdx65_rpmhpds[] = { 306 [SDX65_CX] = &cx_w_mx_parent, 307 [SDX65_CX_AO] = &cx_ao_w_mx_parent, 308 [SDX65_MSS] = &mss, 309 [SDX65_MX] = &mx, 310 [SDX65_MX_AO] = &mx_ao, 311 [SDX65_MXC] = &mxc, 312 }; 313 314 static const struct rpmhpd_desc sdx65_desc = { 315 .rpmhpds = sdx65_rpmhpds, 316 .num_pds = ARRAY_SIZE(sdx65_rpmhpds), 317 }; 318 319 /* SDX75 RPMH powerdomains */ 320 static struct rpmhpd *sdx75_rpmhpds[] = { 321 [RPMHPD_CX] = &cx, 322 [RPMHPD_CX_AO] = &cx_ao, 323 [RPMHPD_MSS] = &mss, 324 [RPMHPD_MX] = &mx, 325 [RPMHPD_MX_AO] = &mx_ao, 326 [RPMHPD_MXC] = &mxc, 327 }; 328 329 static const struct rpmhpd_desc sdx75_desc = { 330 .rpmhpds = sdx75_rpmhpds, 331 .num_pds = ARRAY_SIZE(sdx75_rpmhpds), 332 }; 333 334 /* SM6350 RPMH powerdomains */ 335 static struct rpmhpd *sm6350_rpmhpds[] = { 336 [SM6350_CX] = &cx_w_mx_parent, 337 [SM6350_GFX] = &gfx, 338 [SM6350_LCX] = &lcx, 339 [SM6350_LMX] = &lmx, 340 [SM6350_MSS] = &mss, 341 [SM6350_MX] = &mx, 342 }; 343 344 static const struct rpmhpd_desc sm6350_desc = { 345 .rpmhpds = sm6350_rpmhpds, 346 .num_pds = ARRAY_SIZE(sm6350_rpmhpds), 347 }; 348 349 /* SM7150 RPMH powerdomains */ 350 static struct rpmhpd *sm7150_rpmhpds[] = { 351 [RPMHPD_CX] = &cx_w_mx_parent, 352 [RPMHPD_CX_AO] = &cx_ao_w_mx_parent, 353 [RPMHPD_GFX] = &gfx, 354 [RPMHPD_LCX] = &lcx, 355 [RPMHPD_LMX] = &lmx, 356 [RPMHPD_MX] = &mx, 357 [RPMHPD_MX_AO] = &mx_ao, 358 [RPMHPD_MSS] = &mss, 359 }; 360 361 static const struct rpmhpd_desc sm7150_desc = { 362 .rpmhpds = sm7150_rpmhpds, 363 .num_pds = ARRAY_SIZE(sm7150_rpmhpds), 364 }; 365 366 /* SM8150 RPMH powerdomains */ 367 static struct rpmhpd *sm8150_rpmhpds[] = { 368 [SM8150_CX] = &cx_w_mx_parent, 369 [SM8150_CX_AO] = &cx_ao_w_mx_parent, 370 [SM8150_EBI] = &ebi, 371 [SM8150_GFX] = &gfx, 372 [SM8150_LCX] = &lcx, 373 [SM8150_LMX] = &lmx, 374 [SM8150_MMCX] = &mmcx, 375 [SM8150_MMCX_AO] = &mmcx_ao, 376 [SM8150_MSS] = &mss, 377 [SM8150_MX] = &mx, 378 [SM8150_MX_AO] = &mx_ao, 379 }; 380 381 static const struct rpmhpd_desc sm8150_desc = { 382 .rpmhpds = sm8150_rpmhpds, 383 .num_pds = ARRAY_SIZE(sm8150_rpmhpds), 384 }; 385 386 static struct rpmhpd *sa8155p_rpmhpds[] = { 387 [SA8155P_CX] = &cx_w_mx_parent, 388 [SA8155P_CX_AO] = &cx_ao_w_mx_parent, 389 [SA8155P_EBI] = &ebi, 390 [SA8155P_GFX] = &gfx, 391 [SA8155P_MSS] = &mss, 392 [SA8155P_MX] = &mx, 393 [SA8155P_MX_AO] = &mx_ao, 394 }; 395 396 static const struct rpmhpd_desc sa8155p_desc = { 397 .rpmhpds = sa8155p_rpmhpds, 398 .num_pds = ARRAY_SIZE(sa8155p_rpmhpds), 399 }; 400 401 /* SM8250 RPMH powerdomains */ 402 static struct rpmhpd *sm8250_rpmhpds[] = { 403 [RPMHPD_CX] = &cx_w_mx_parent, 404 [RPMHPD_CX_AO] = &cx_ao_w_mx_parent, 405 [RPMHPD_EBI] = &ebi, 406 [RPMHPD_GFX] = &gfx, 407 [RPMHPD_LCX] = &lcx, 408 [RPMHPD_LMX] = &lmx, 409 [RPMHPD_MMCX] = &mmcx, 410 [RPMHPD_MMCX_AO] = &mmcx_ao, 411 [RPMHPD_MX] = &mx, 412 [RPMHPD_MX_AO] = &mx_ao, 413 }; 414 415 static const struct rpmhpd_desc sm8250_desc = { 416 .rpmhpds = sm8250_rpmhpds, 417 .num_pds = ARRAY_SIZE(sm8250_rpmhpds), 418 }; 419 420 /* SM8350 Power domains */ 421 static struct rpmhpd *sm8350_rpmhpds[] = { 422 [RPMHPD_CX] = &cx_w_mx_parent, 423 [RPMHPD_CX_AO] = &cx_ao_w_mx_parent, 424 [RPMHPD_EBI] = &ebi, 425 [RPMHPD_GFX] = &gfx, 426 [RPMHPD_LCX] = &lcx, 427 [RPMHPD_LMX] = &lmx, 428 [RPMHPD_MMCX] = &mmcx, 429 [RPMHPD_MMCX_AO] = &mmcx_ao, 430 [RPMHPD_MSS] = &mss, 431 [RPMHPD_MX] = &mx, 432 [RPMHPD_MX_AO] = &mx_ao, 433 [RPMHPD_MXC] = &mxc, 434 [RPMHPD_MXC_AO] = &mxc_ao, 435 }; 436 437 static const struct rpmhpd_desc sm8350_desc = { 438 .rpmhpds = sm8350_rpmhpds, 439 .num_pds = ARRAY_SIZE(sm8350_rpmhpds), 440 }; 441 442 /* SM8450 RPMH powerdomains */ 443 static struct rpmhpd *sm8450_rpmhpds[] = { 444 [RPMHPD_CX] = &cx, 445 [RPMHPD_CX_AO] = &cx_ao, 446 [RPMHPD_EBI] = &ebi, 447 [RPMHPD_GFX] = &gfx, 448 [RPMHPD_LCX] = &lcx, 449 [RPMHPD_LMX] = &lmx, 450 [RPMHPD_MMCX] = &mmcx_w_cx_parent, 451 [RPMHPD_MMCX_AO] = &mmcx_ao_w_cx_parent, 452 [RPMHPD_MSS] = &mss, 453 [RPMHPD_MX] = &mx, 454 [RPMHPD_MX_AO] = &mx_ao, 455 [RPMHPD_MXC] = &mxc, 456 [RPMHPD_MXC_AO] = &mxc_ao, 457 }; 458 459 static const struct rpmhpd_desc sm8450_desc = { 460 .rpmhpds = sm8450_rpmhpds, 461 .num_pds = ARRAY_SIZE(sm8450_rpmhpds), 462 }; 463 464 /* SM8550 RPMH powerdomains */ 465 static struct rpmhpd *sm8550_rpmhpds[] = { 466 [RPMHPD_CX] = &cx, 467 [RPMHPD_CX_AO] = &cx_ao, 468 [RPMHPD_EBI] = &ebi, 469 [RPMHPD_GFX] = &gfx, 470 [RPMHPD_LCX] = &lcx, 471 [RPMHPD_LMX] = &lmx, 472 [RPMHPD_MMCX] = &mmcx_w_cx_parent, 473 [RPMHPD_MMCX_AO] = &mmcx_ao_w_cx_parent, 474 [RPMHPD_MSS] = &mss, 475 [RPMHPD_MX] = &mx, 476 [RPMHPD_MX_AO] = &mx_ao, 477 [RPMHPD_MXC] = &mxc, 478 [RPMHPD_MXC_AO] = &mxc_ao, 479 [RPMHPD_NSP] = &nsp, 480 }; 481 482 static const struct rpmhpd_desc sm8550_desc = { 483 .rpmhpds = sm8550_rpmhpds, 484 .num_pds = ARRAY_SIZE(sm8550_rpmhpds), 485 }; 486 487 /* SM8650 RPMH powerdomains */ 488 static struct rpmhpd *sm8650_rpmhpds[] = { 489 [RPMHPD_CX] = &cx, 490 [RPMHPD_CX_AO] = &cx_ao, 491 [RPMHPD_EBI] = &ebi, 492 [RPMHPD_GFX] = &gfx, 493 [RPMHPD_LCX] = &lcx, 494 [RPMHPD_LMX] = &lmx, 495 [RPMHPD_MMCX] = &mmcx_w_cx_parent, 496 [RPMHPD_MMCX_AO] = &mmcx_ao_w_cx_parent, 497 [RPMHPD_MSS] = &mss, 498 [RPMHPD_MX] = &mx, 499 [RPMHPD_MX_AO] = &mx_ao, 500 [RPMHPD_MXC] = &mxc, 501 [RPMHPD_MXC_AO] = &mxc_ao, 502 [RPMHPD_NSP] = &nsp, 503 [RPMHPD_NSP2] = &nsp2, 504 }; 505 506 static const struct rpmhpd_desc sm8650_desc = { 507 .rpmhpds = sm8650_rpmhpds, 508 .num_pds = ARRAY_SIZE(sm8650_rpmhpds), 509 }; 510 511 /* QDU1000/QRU1000 RPMH powerdomains */ 512 static struct rpmhpd *qdu1000_rpmhpds[] = { 513 [QDU1000_CX] = &cx, 514 [QDU1000_EBI] = &ebi, 515 [QDU1000_MSS] = &mss, 516 [QDU1000_MX] = &mx, 517 }; 518 519 static const struct rpmhpd_desc qdu1000_desc = { 520 .rpmhpds = qdu1000_rpmhpds, 521 .num_pds = ARRAY_SIZE(qdu1000_rpmhpds), 522 }; 523 524 /* SC7180 RPMH powerdomains */ 525 static struct rpmhpd *sc7180_rpmhpds[] = { 526 [SC7180_CX] = &cx_w_mx_parent, 527 [SC7180_CX_AO] = &cx_ao_w_mx_parent, 528 [SC7180_GFX] = &gfx, 529 [SC7180_LCX] = &lcx, 530 [SC7180_LMX] = &lmx, 531 [SC7180_MSS] = &mss, 532 [SC7180_MX] = &mx, 533 [SC7180_MX_AO] = &mx_ao, 534 }; 535 536 static const struct rpmhpd_desc sc7180_desc = { 537 .rpmhpds = sc7180_rpmhpds, 538 .num_pds = ARRAY_SIZE(sc7180_rpmhpds), 539 }; 540 541 /* SC7280 RPMH powerdomains */ 542 static struct rpmhpd *sc7280_rpmhpds[] = { 543 [SC7280_CX] = &cx, 544 [SC7280_CX_AO] = &cx_ao, 545 [SC7280_EBI] = &ebi, 546 [SC7280_GFX] = &gfx, 547 [SC7280_LCX] = &lcx, 548 [SC7280_LMX] = &lmx, 549 [SC7280_MSS] = &mss, 550 [SC7280_MX] = &mx, 551 [SC7280_MX_AO] = &mx_ao, 552 }; 553 554 static const struct rpmhpd_desc sc7280_desc = { 555 .rpmhpds = sc7280_rpmhpds, 556 .num_pds = ARRAY_SIZE(sc7280_rpmhpds), 557 }; 558 559 /* SC8180x RPMH powerdomains */ 560 static struct rpmhpd *sc8180x_rpmhpds[] = { 561 [SC8180X_CX] = &cx_w_mx_parent, 562 [SC8180X_CX_AO] = &cx_ao_w_mx_parent, 563 [SC8180X_EBI] = &ebi, 564 [SC8180X_GFX] = &gfx, 565 [SC8180X_LCX] = &lcx, 566 [SC8180X_LMX] = &lmx, 567 [SC8180X_MMCX] = &mmcx, 568 [SC8180X_MMCX_AO] = &mmcx_ao, 569 [SC8180X_MSS] = &mss, 570 [SC8180X_MX] = &mx, 571 [SC8180X_MX_AO] = &mx_ao, 572 }; 573 574 static const struct rpmhpd_desc sc8180x_desc = { 575 .rpmhpds = sc8180x_rpmhpds, 576 .num_pds = ARRAY_SIZE(sc8180x_rpmhpds), 577 }; 578 579 /* SC8280xp RPMH powerdomains */ 580 static struct rpmhpd *sc8280xp_rpmhpds[] = { 581 [SC8280XP_CX] = &cx, 582 [SC8280XP_CX_AO] = &cx_ao, 583 [SC8280XP_EBI] = &ebi, 584 [SC8280XP_GFX] = &gfx, 585 [SC8280XP_LCX] = &lcx, 586 [SC8280XP_LMX] = &lmx, 587 [SC8280XP_MMCX] = &mmcx, 588 [SC8280XP_MMCX_AO] = &mmcx_ao, 589 [SC8280XP_MX] = &mx, 590 [SC8280XP_MX_AO] = &mx_ao, 591 [SC8280XP_NSP] = &nsp, 592 [SC8280XP_QPHY] = &qphy, 593 }; 594 595 static const struct rpmhpd_desc sc8280xp_desc = { 596 .rpmhpds = sc8280xp_rpmhpds, 597 .num_pds = ARRAY_SIZE(sc8280xp_rpmhpds), 598 }; 599 600 /* X1E80100 RPMH powerdomains */ 601 static struct rpmhpd *x1e80100_rpmhpds[] = { 602 [RPMHPD_CX] = &cx, 603 [RPMHPD_CX_AO] = &cx_ao, 604 [RPMHPD_EBI] = &ebi, 605 [RPMHPD_GFX] = &gfx, 606 [RPMHPD_LCX] = &lcx, 607 [RPMHPD_LMX] = &lmx, 608 [RPMHPD_MMCX] = &mmcx, 609 [RPMHPD_MMCX_AO] = &mmcx_ao, 610 [RPMHPD_MX] = &mx, 611 [RPMHPD_MX_AO] = &mx_ao, 612 [RPMHPD_NSP] = &nsp, 613 [RPMHPD_MXC] = &mxc, 614 [RPMHPD_GMXC] = &gmxc, 615 }; 616 617 static const struct rpmhpd_desc x1e80100_desc = { 618 .rpmhpds = x1e80100_rpmhpds, 619 .num_pds = ARRAY_SIZE(x1e80100_rpmhpds), 620 }; 621 622 static const struct of_device_id rpmhpd_match_table[] = { 623 { .compatible = "qcom,qdu1000-rpmhpd", .data = &qdu1000_desc }, 624 { .compatible = "qcom,sa8155p-rpmhpd", .data = &sa8155p_desc }, 625 { .compatible = "qcom,sa8540p-rpmhpd", .data = &sa8540p_desc }, 626 { .compatible = "qcom,sa8775p-rpmhpd", .data = &sa8775p_desc }, 627 { .compatible = "qcom,sc7180-rpmhpd", .data = &sc7180_desc }, 628 { .compatible = "qcom,sc7280-rpmhpd", .data = &sc7280_desc }, 629 { .compatible = "qcom,sc8180x-rpmhpd", .data = &sc8180x_desc }, 630 { .compatible = "qcom,sc8280xp-rpmhpd", .data = &sc8280xp_desc }, 631 { .compatible = "qcom,sdm670-rpmhpd", .data = &sdm670_desc }, 632 { .compatible = "qcom,sdm845-rpmhpd", .data = &sdm845_desc }, 633 { .compatible = "qcom,sdx55-rpmhpd", .data = &sdx55_desc}, 634 { .compatible = "qcom,sdx65-rpmhpd", .data = &sdx65_desc}, 635 { .compatible = "qcom,sdx75-rpmhpd", .data = &sdx75_desc}, 636 { .compatible = "qcom,sm6350-rpmhpd", .data = &sm6350_desc }, 637 { .compatible = "qcom,sm7150-rpmhpd", .data = &sm7150_desc }, 638 { .compatible = "qcom,sm8150-rpmhpd", .data = &sm8150_desc }, 639 { .compatible = "qcom,sm8250-rpmhpd", .data = &sm8250_desc }, 640 { .compatible = "qcom,sm8350-rpmhpd", .data = &sm8350_desc }, 641 { .compatible = "qcom,sm8450-rpmhpd", .data = &sm8450_desc }, 642 { .compatible = "qcom,sm8550-rpmhpd", .data = &sm8550_desc }, 643 { .compatible = "qcom,sm8650-rpmhpd", .data = &sm8650_desc }, 644 { .compatible = "qcom,x1e80100-rpmhpd", .data = &x1e80100_desc }, 645 { } 646 }; 647 MODULE_DEVICE_TABLE(of, rpmhpd_match_table); 648 649 static int rpmhpd_send_corner(struct rpmhpd *pd, int state, 650 unsigned int corner, bool sync) 651 { 652 struct tcs_cmd cmd = { 653 .addr = pd->addr, 654 .data = corner, 655 }; 656 657 /* 658 * Wait for an ack only when we are increasing the 659 * perf state of the power domain 660 */ 661 if (sync) 662 return rpmh_write(pd->dev, state, &cmd, 1); 663 else 664 return rpmh_write_async(pd->dev, state, &cmd, 1); 665 } 666 667 static void to_active_sleep(struct rpmhpd *pd, unsigned int corner, 668 unsigned int *active, unsigned int *sleep) 669 { 670 *active = corner; 671 672 if (pd->active_only) 673 *sleep = 0; 674 else 675 *sleep = *active; 676 } 677 678 /* 679 * This function is used to aggregate the votes across the active only 680 * resources and its peers. The aggregated votes are sent to RPMh as 681 * ACTIVE_ONLY votes (which take effect immediately), as WAKE_ONLY votes 682 * (applied by RPMh on system wakeup) and as SLEEP votes (applied by RPMh 683 * on system sleep). 684 * We send ACTIVE_ONLY votes for resources without any peers. For others, 685 * which have an active only peer, all 3 votes are sent. 686 */ 687 static int rpmhpd_aggregate_corner(struct rpmhpd *pd, unsigned int corner) 688 { 689 int ret; 690 struct rpmhpd *peer = pd->peer; 691 unsigned int active_corner, sleep_corner; 692 unsigned int this_active_corner = 0, this_sleep_corner = 0; 693 unsigned int peer_active_corner = 0, peer_sleep_corner = 0; 694 unsigned int peer_enabled_corner; 695 696 if (pd->state_synced) { 697 to_active_sleep(pd, corner, &this_active_corner, &this_sleep_corner); 698 } else { 699 /* Clamp to highest corner if sync_state hasn't happened */ 700 this_active_corner = pd->level_count - 1; 701 this_sleep_corner = pd->level_count - 1; 702 } 703 704 if (peer && peer->enabled) { 705 peer_enabled_corner = max(peer->corner, peer->enable_corner); 706 to_active_sleep(peer, peer_enabled_corner, &peer_active_corner, 707 &peer_sleep_corner); 708 } 709 710 active_corner = max(this_active_corner, peer_active_corner); 711 712 ret = rpmhpd_send_corner(pd, RPMH_ACTIVE_ONLY_STATE, active_corner, 713 active_corner > pd->active_corner); 714 if (ret) 715 return ret; 716 717 pd->active_corner = active_corner; 718 719 if (peer) { 720 peer->active_corner = active_corner; 721 722 ret = rpmhpd_send_corner(pd, RPMH_WAKE_ONLY_STATE, 723 active_corner, false); 724 if (ret) 725 return ret; 726 727 sleep_corner = max(this_sleep_corner, peer_sleep_corner); 728 729 return rpmhpd_send_corner(pd, RPMH_SLEEP_STATE, sleep_corner, 730 false); 731 } 732 733 return ret; 734 } 735 736 static int rpmhpd_power_on(struct generic_pm_domain *domain) 737 { 738 struct rpmhpd *pd = domain_to_rpmhpd(domain); 739 unsigned int corner; 740 int ret; 741 742 mutex_lock(&rpmhpd_lock); 743 744 corner = max(pd->corner, pd->enable_corner); 745 ret = rpmhpd_aggregate_corner(pd, corner); 746 if (!ret) 747 pd->enabled = true; 748 749 mutex_unlock(&rpmhpd_lock); 750 751 return ret; 752 } 753 754 static int rpmhpd_power_off(struct generic_pm_domain *domain) 755 { 756 struct rpmhpd *pd = domain_to_rpmhpd(domain); 757 int ret; 758 759 mutex_lock(&rpmhpd_lock); 760 761 ret = rpmhpd_aggregate_corner(pd, 0); 762 if (!ret) 763 pd->enabled = false; 764 765 mutex_unlock(&rpmhpd_lock); 766 767 return ret; 768 } 769 770 static int rpmhpd_set_performance_state(struct generic_pm_domain *domain, 771 unsigned int level) 772 { 773 struct rpmhpd *pd = domain_to_rpmhpd(domain); 774 int ret = 0, i; 775 776 mutex_lock(&rpmhpd_lock); 777 778 for (i = 0; i < pd->level_count; i++) 779 if (level <= pd->level[i]) 780 break; 781 782 /* 783 * If the level requested is more than that supported by the 784 * max corner, just set it to max anyway. 785 */ 786 if (i == pd->level_count) 787 i--; 788 789 if (pd->enabled) { 790 /* Ensure that the domain isn't turn off */ 791 if (i < pd->enable_corner) 792 i = pd->enable_corner; 793 794 ret = rpmhpd_aggregate_corner(pd, i); 795 if (ret) 796 goto out; 797 } 798 799 pd->corner = i; 800 out: 801 mutex_unlock(&rpmhpd_lock); 802 803 return ret; 804 } 805 806 static int rpmhpd_update_level_mapping(struct rpmhpd *rpmhpd) 807 { 808 int i; 809 const u16 *buf; 810 811 buf = cmd_db_read_aux_data(rpmhpd->res_name, &rpmhpd->level_count); 812 if (IS_ERR(buf)) 813 return PTR_ERR(buf); 814 815 /* 2 bytes used for each command DB aux data entry */ 816 rpmhpd->level_count >>= 1; 817 818 if (rpmhpd->level_count > RPMH_ARC_MAX_LEVELS) 819 return -EINVAL; 820 821 for (i = 0; i < rpmhpd->level_count; i++) { 822 rpmhpd->level[i] = buf[i]; 823 824 /* Remember the first corner with non-zero level */ 825 if (!rpmhpd->level[rpmhpd->enable_corner] && rpmhpd->level[i]) 826 rpmhpd->enable_corner = i; 827 828 /* 829 * The AUX data may be zero padded. These 0 valued entries at 830 * the end of the map must be ignored. 831 */ 832 if (i > 0 && rpmhpd->level[i] == 0) { 833 rpmhpd->level_count = i; 834 break; 835 } 836 pr_debug("%s: ARC hlvl=%2d --> vlvl=%4u\n", rpmhpd->res_name, i, 837 rpmhpd->level[i]); 838 } 839 840 return 0; 841 } 842 843 static int rpmhpd_probe(struct platform_device *pdev) 844 { 845 int i, ret; 846 size_t num_pds; 847 struct device *dev = &pdev->dev; 848 struct genpd_onecell_data *data; 849 struct rpmhpd **rpmhpds; 850 const struct rpmhpd_desc *desc; 851 852 desc = of_device_get_match_data(dev); 853 if (!desc) 854 return -EINVAL; 855 856 rpmhpds = desc->rpmhpds; 857 num_pds = desc->num_pds; 858 859 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 860 if (!data) 861 return -ENOMEM; 862 863 data->domains = devm_kcalloc(dev, num_pds, sizeof(*data->domains), 864 GFP_KERNEL); 865 if (!data->domains) 866 return -ENOMEM; 867 868 data->num_domains = num_pds; 869 870 for (i = 0; i < num_pds; i++) { 871 if (!rpmhpds[i]) 872 continue; 873 874 rpmhpds[i]->dev = dev; 875 rpmhpds[i]->addr = cmd_db_read_addr(rpmhpds[i]->res_name); 876 if (!rpmhpds[i]->addr) { 877 dev_err(dev, "Could not find RPMh address for resource %s\n", 878 rpmhpds[i]->res_name); 879 return -ENODEV; 880 } 881 882 ret = cmd_db_read_slave_id(rpmhpds[i]->res_name); 883 if (ret != CMD_DB_HW_ARC) { 884 dev_err(dev, "RPMh slave ID mismatch\n"); 885 return -EINVAL; 886 } 887 888 ret = rpmhpd_update_level_mapping(rpmhpds[i]); 889 if (ret) 890 return ret; 891 892 rpmhpds[i]->pd.power_off = rpmhpd_power_off; 893 rpmhpds[i]->pd.power_on = rpmhpd_power_on; 894 rpmhpds[i]->pd.set_performance_state = rpmhpd_set_performance_state; 895 pm_genpd_init(&rpmhpds[i]->pd, NULL, true); 896 897 data->domains[i] = &rpmhpds[i]->pd; 898 } 899 900 /* Add subdomains */ 901 for (i = 0; i < num_pds; i++) { 902 if (!rpmhpds[i]) 903 continue; 904 if (rpmhpds[i]->parent) 905 pm_genpd_add_subdomain(rpmhpds[i]->parent, 906 &rpmhpds[i]->pd); 907 } 908 909 return of_genpd_add_provider_onecell(pdev->dev.of_node, data); 910 } 911 912 static void rpmhpd_sync_state(struct device *dev) 913 { 914 const struct rpmhpd_desc *desc = of_device_get_match_data(dev); 915 struct rpmhpd **rpmhpds = desc->rpmhpds; 916 unsigned int corner; 917 struct rpmhpd *pd; 918 unsigned int i; 919 int ret; 920 921 mutex_lock(&rpmhpd_lock); 922 for (i = 0; i < desc->num_pds; i++) { 923 pd = rpmhpds[i]; 924 if (!pd) 925 continue; 926 927 pd->state_synced = true; 928 if (pd->enabled) 929 corner = max(pd->corner, pd->enable_corner); 930 else 931 corner = 0; 932 933 ret = rpmhpd_aggregate_corner(pd, corner); 934 if (ret) 935 dev_err(dev, "failed to sync %s\n", pd->res_name); 936 } 937 mutex_unlock(&rpmhpd_lock); 938 } 939 940 static struct platform_driver rpmhpd_driver = { 941 .driver = { 942 .name = "qcom-rpmhpd", 943 .of_match_table = rpmhpd_match_table, 944 .suppress_bind_attrs = true, 945 .sync_state = rpmhpd_sync_state, 946 }, 947 .probe = rpmhpd_probe, 948 }; 949 950 static int __init rpmhpd_init(void) 951 { 952 return platform_driver_register(&rpmhpd_driver); 953 } 954 core_initcall(rpmhpd_init); 955 956 MODULE_DESCRIPTION("Qualcomm Technologies, Inc. RPMh Power Domain Driver"); 957 MODULE_LICENSE("GPL v2"); 958