1 /*- 2 * Copyright (c) 2014 Robin Randhawa 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 */ 27 28 /* 29 * This implements support for ARM's Power State Co-ordination Interface 30 * [PSCI]. The implementation adheres to version 0.2 of the PSCI specification 31 * but also supports v0.1. PSCI standardizes operations such as system reset, CPU 32 * on/off/suspend. PSCI requires a compliant firmware implementation. 33 * 34 * The PSCI specification used for this implementation is available at: 35 * 36 * <http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.den0022b/index.html>. 37 * 38 * TODO: 39 * - Add support for remaining PSCI calls [this implementation only 40 * supports get_version, system_reset and cpu_on]. 41 */ 42 43 #include <sys/cdefs.h> 44 __FBSDID("$FreeBSD$"); 45 46 #include "opt_acpi.h" 47 #include "opt_platform.h" 48 49 #include <sys/param.h> 50 #include <sys/systm.h> 51 #include <sys/bus.h> 52 #include <sys/eventhandler.h> 53 #include <sys/kernel.h> 54 #include <sys/module.h> 55 #include <sys/reboot.h> 56 57 #include <machine/bus.h> 58 #include <machine/machdep.h> 59 60 #ifdef DEV_ACPI 61 #include <contrib/dev/acpica/include/acpi.h> 62 #include <dev/acpica/acpivar.h> 63 #endif 64 65 #ifdef FDT 66 #include <dev/fdt/fdt_common.h> 67 #include <dev/ofw/openfirm.h> 68 #include <dev/ofw/ofw_bus.h> 69 #include <dev/ofw/ofw_bus_subr.h> 70 #endif 71 72 #include <dev/psci/psci.h> 73 74 struct psci_softc { 75 device_t dev; 76 77 psci_callfn_t psci_call; 78 uint32_t psci_fnids[PSCI_FN_MAX]; 79 }; 80 81 #ifdef FDT 82 static int psci_v0_1_init(device_t dev); 83 #endif 84 static int psci_v0_2_init(device_t dev); 85 86 struct psci_softc *psci_softc = NULL; 87 88 #ifdef __arm__ 89 #define USE_ACPI 0 90 #define USE_FDT 1 91 #elif defined(__aarch64__) 92 #define USE_ACPI (arm64_bus_method == ARM64_BUS_ACPI) 93 #define USE_FDT (arm64_bus_method == ARM64_BUS_FDT) 94 #else 95 #error Unknown architecture 96 #endif 97 98 #ifdef FDT 99 static struct ofw_compat_data compat_data[] = { 100 {"arm,psci-0.2", (uintptr_t)psci_v0_2_init}, 101 {"arm,psci", (uintptr_t)psci_v0_1_init}, 102 {NULL, 0} 103 }; 104 #endif 105 106 static int psci_attach(device_t, psci_initfn_t); 107 static void psci_shutdown(void *, int); 108 109 #ifdef FDT 110 static int psci_fdt_probe(device_t dev); 111 static int psci_fdt_attach(device_t dev); 112 113 static device_method_t psci_fdt_methods[] = { 114 DEVMETHOD(device_probe, psci_fdt_probe), 115 DEVMETHOD(device_attach, psci_fdt_attach), 116 117 DEVMETHOD_END 118 }; 119 120 static driver_t psci_fdt_driver = { 121 "psci", 122 psci_fdt_methods, 123 sizeof(struct psci_softc), 124 }; 125 126 static devclass_t psci_fdt_devclass; 127 128 EARLY_DRIVER_MODULE(psci, simplebus, psci_fdt_driver, psci_fdt_devclass, 0, 0, 129 BUS_PASS_CPU + BUS_PASS_ORDER_FIRST); 130 EARLY_DRIVER_MODULE(psci, ofwbus, psci_fdt_driver, psci_fdt_devclass, 0, 0, 131 BUS_PASS_CPU + BUS_PASS_ORDER_FIRST); 132 133 static psci_callfn_t 134 psci_fdt_get_callfn(phandle_t node) 135 { 136 char method[16]; 137 138 if ((OF_getprop(node, "method", method, sizeof(method))) > 0) { 139 if (strcmp(method, "hvc") == 0) 140 return (psci_hvc_despatch); 141 else if (strcmp(method, "smc") == 0) 142 return (psci_smc_despatch); 143 else 144 printf("psci: PSCI conduit \"%s\" invalid\n", method); 145 } else 146 printf("psci: PSCI conduit not supplied in the device tree\n"); 147 148 return (NULL); 149 } 150 151 static int 152 psci_fdt_probe(device_t dev) 153 { 154 const struct ofw_compat_data *ocd; 155 156 if (!ofw_bus_status_okay(dev)) 157 return (ENXIO); 158 159 ocd = ofw_bus_search_compatible(dev, compat_data); 160 if (ocd->ocd_str == NULL) 161 return (ENXIO); 162 163 device_set_desc(dev, "ARM Power State Co-ordination Interface Driver"); 164 165 return (BUS_PROBE_SPECIFIC); 166 } 167 168 static int 169 psci_fdt_attach(device_t dev) 170 { 171 struct psci_softc *sc = device_get_softc(dev); 172 const struct ofw_compat_data *ocd; 173 psci_initfn_t psci_init; 174 phandle_t node; 175 176 ocd = ofw_bus_search_compatible(dev, compat_data); 177 psci_init = (psci_initfn_t)ocd->ocd_data; 178 179 node = ofw_bus_get_node(dev); 180 sc->psci_call = psci_fdt_get_callfn(node); 181 182 return (psci_attach(dev, psci_init)); 183 } 184 #endif 185 186 #ifdef DEV_ACPI 187 static void psci_acpi_identify(driver_t *, device_t); 188 static int psci_acpi_probe(device_t); 189 static int psci_acpi_attach(device_t); 190 191 static device_method_t psci_acpi_methods[] = { 192 /* Device interface */ 193 DEVMETHOD(device_identify, psci_acpi_identify), 194 DEVMETHOD(device_probe, psci_acpi_probe), 195 DEVMETHOD(device_attach, psci_acpi_attach), 196 197 DEVMETHOD_END 198 }; 199 200 static driver_t psci_acpi_driver = { 201 "psci", 202 psci_acpi_methods, 203 sizeof(struct psci_softc), 204 }; 205 206 static devclass_t psci_acpi_devclass; 207 208 EARLY_DRIVER_MODULE(psci, acpi, psci_acpi_driver, psci_acpi_devclass, 0, 0, 209 BUS_PASS_CPU + BUS_PASS_ORDER_FIRST); 210 211 static int 212 psci_acpi_bootflags(void) 213 { 214 ACPI_TABLE_FADT *fadt; 215 vm_paddr_t physaddr; 216 int flags; 217 218 physaddr = acpi_find_table(ACPI_SIG_FADT); 219 if (physaddr == 0) 220 return (0); 221 222 fadt = acpi_map_table(physaddr, ACPI_SIG_FADT); 223 if (fadt == NULL) { 224 printf("psci: Unable to map the FADT\n"); 225 return (0); 226 } 227 228 flags = fadt->ArmBootFlags; 229 230 acpi_unmap_table(fadt); 231 return (flags); 232 } 233 234 static psci_callfn_t 235 psci_acpi_get_callfn(int flags) 236 { 237 238 if ((flags & ACPI_FADT_PSCI_COMPLIANT) != 0) { 239 if ((flags & ACPI_FADT_PSCI_USE_HVC) != 0) 240 return (psci_hvc_despatch); 241 else 242 return (psci_smc_despatch); 243 } else { 244 printf("psci: PSCI conduit not supplied in the device tree\n"); 245 } 246 247 return (NULL); 248 } 249 250 static void 251 psci_acpi_identify(driver_t *driver, device_t parent) 252 { 253 device_t dev; 254 int flags; 255 256 flags = psci_acpi_bootflags(); 257 if ((flags & ACPI_FADT_PSCI_COMPLIANT) != 0) { 258 dev = BUS_ADD_CHILD(parent, 259 BUS_PASS_CPU + BUS_PASS_ORDER_FIRST, "psci", -1); 260 261 if (dev != NULL) 262 acpi_set_private(dev, (void *)(uintptr_t)flags); 263 } 264 } 265 266 static int 267 psci_acpi_probe(device_t dev) 268 { 269 uintptr_t flags; 270 271 flags = (uintptr_t)acpi_get_private(dev); 272 if ((flags & ACPI_FADT_PSCI_COMPLIANT) == 0) 273 return (ENXIO); 274 275 device_set_desc(dev, "ARM Power State Co-ordination Interface Driver"); 276 return (BUS_PROBE_SPECIFIC); 277 } 278 279 static int 280 psci_acpi_attach(device_t dev) 281 { 282 struct psci_softc *sc = device_get_softc(dev); 283 uintptr_t flags; 284 285 flags = (uintptr_t)acpi_get_private(dev); 286 if ((flags & ACPI_FADT_PSCI_USE_HVC) != 0) 287 sc->psci_call = psci_hvc_despatch; 288 else 289 sc->psci_call = psci_smc_despatch; 290 291 return (psci_attach(dev, psci_v0_2_init)); 292 } 293 #endif 294 295 static int 296 psci_attach(device_t dev, psci_initfn_t psci_init) 297 { 298 struct psci_softc *sc = device_get_softc(dev); 299 300 if (psci_softc != NULL) 301 return (ENXIO); 302 303 if (sc->psci_call == NULL) 304 return (ENXIO); 305 306 KASSERT(psci_init != NULL, ("PSCI init function cannot be NULL")); 307 if (psci_init(dev)) 308 return (ENXIO); 309 310 psci_softc = sc; 311 312 return (0); 313 } 314 315 static int 316 psci_get_version(struct psci_softc *sc) 317 { 318 uint32_t fnid; 319 320 /* PSCI version wasn't supported in v0.1. */ 321 fnid = sc->psci_fnids[PSCI_FN_VERSION]; 322 if (fnid) 323 return (sc->psci_call(fnid, 0, 0, 0)); 324 325 return (PSCI_RETVAL_NOT_SUPPORTED); 326 } 327 328 #ifdef FDT 329 static int 330 psci_fdt_callfn(psci_callfn_t *callfn) 331 { 332 phandle_t node; 333 334 node = ofw_bus_find_compatible(OF_peer(0), "arm,psci-0.2"); 335 if (node == 0) 336 /* TODO: Handle psci 0.1 */ 337 return (PSCI_MISSING); 338 339 *callfn = psci_fdt_get_callfn(node); 340 return (0); 341 } 342 #endif 343 344 #ifdef DEV_ACPI 345 static int 346 psci_acpi_callfn(psci_callfn_t *callfn) 347 { 348 int flags; 349 350 flags = psci_acpi_bootflags(); 351 if ((flags & ACPI_FADT_PSCI_COMPLIANT) == 0) 352 return (PSCI_MISSING); 353 354 *callfn = psci_acpi_get_callfn(flags); 355 return (0); 356 } 357 #endif 358 359 int 360 psci_cpu_on(unsigned long cpu, unsigned long entry, unsigned long context_id) 361 { 362 psci_callfn_t callfn; 363 uint32_t fnid; 364 int error; 365 366 if (psci_softc == NULL) { 367 fnid = PSCI_FNID_CPU_ON; 368 callfn = NULL; 369 #ifdef FDT 370 if (USE_FDT) { 371 error = psci_fdt_callfn(&callfn); 372 if (error != 0) 373 return (error); 374 } 375 #endif 376 #ifdef DEV_ACPI 377 if (callfn == NULL && USE_ACPI) { 378 error = psci_acpi_callfn(&callfn); 379 if (error != 0) 380 return (error); 381 } 382 #endif 383 384 if (callfn == NULL) 385 return (PSCI_MISSING); 386 } else { 387 callfn = psci_softc->psci_call; 388 fnid = psci_softc->psci_fnids[PSCI_FN_CPU_ON]; 389 } 390 391 /* PSCI v0.1 and v0.2 both support cpu_on. */ 392 return (callfn(fnid, cpu, entry, context_id)); 393 } 394 395 static void 396 psci_shutdown(void *xsc, int howto) 397 { 398 uint32_t fn = 0; 399 400 if (psci_softc == NULL) 401 return; 402 403 /* PSCI system_off and system_reset werent't supported in v0.1. */ 404 if ((howto & RB_POWEROFF) != 0) 405 fn = psci_softc->psci_fnids[PSCI_FN_SYSTEM_OFF]; 406 else if ((howto & RB_HALT) == 0) 407 fn = psci_softc->psci_fnids[PSCI_FN_SYSTEM_RESET]; 408 409 if (fn) 410 psci_softc->psci_call(fn, 0, 0, 0); 411 412 /* System reset and off do not return. */ 413 } 414 415 void 416 psci_reset(void) 417 { 418 419 psci_shutdown(NULL, 0); 420 } 421 422 #ifdef FDT 423 /* Only support PSCI 0.1 on FDT */ 424 static int 425 psci_v0_1_init(device_t dev) 426 { 427 struct psci_softc *sc = device_get_softc(dev); 428 int psci_fn; 429 uint32_t psci_fnid; 430 phandle_t node; 431 int len; 432 433 434 /* Zero out the function ID table - Is this needed ? */ 435 for (psci_fn = PSCI_FN_VERSION, psci_fnid = PSCI_FNID_VERSION; 436 psci_fn < PSCI_FN_MAX; psci_fn++, psci_fnid++) 437 sc->psci_fnids[psci_fn] = 0; 438 439 /* PSCI v0.1 doesn't specify function IDs. Get them from DT */ 440 node = ofw_bus_get_node(dev); 441 442 if ((len = OF_getproplen(node, "cpu_suspend")) > 0) { 443 OF_getencprop(node, "cpu_suspend", &psci_fnid, len); 444 sc->psci_fnids[PSCI_FN_CPU_SUSPEND] = psci_fnid; 445 } 446 447 if ((len = OF_getproplen(node, "cpu_on")) > 0) { 448 OF_getencprop(node, "cpu_on", &psci_fnid, len); 449 sc->psci_fnids[PSCI_FN_CPU_ON] = psci_fnid; 450 } 451 452 if ((len = OF_getproplen(node, "cpu_off")) > 0) { 453 OF_getencprop(node, "cpu_off", &psci_fnid, len); 454 sc->psci_fnids[PSCI_FN_CPU_OFF] = psci_fnid; 455 } 456 457 if ((len = OF_getproplen(node, "migrate")) > 0) { 458 OF_getencprop(node, "migrate", &psci_fnid, len); 459 sc->psci_fnids[PSCI_FN_MIGRATE] = psci_fnid; 460 } 461 462 if (bootverbose) 463 device_printf(dev, "PSCI version 0.1 available\n"); 464 465 return(0); 466 } 467 #endif 468 469 static int 470 psci_v0_2_init(device_t dev) 471 { 472 struct psci_softc *sc = device_get_softc(dev); 473 int version; 474 475 /* PSCI v0.2 specifies explicit function IDs. */ 476 sc->psci_fnids[PSCI_FN_VERSION] = PSCI_FNID_VERSION; 477 sc->psci_fnids[PSCI_FN_CPU_SUSPEND] = PSCI_FNID_CPU_SUSPEND; 478 sc->psci_fnids[PSCI_FN_CPU_OFF] = PSCI_FNID_CPU_OFF; 479 sc->psci_fnids[PSCI_FN_CPU_ON] = PSCI_FNID_CPU_ON; 480 sc->psci_fnids[PSCI_FN_AFFINITY_INFO] = PSCI_FNID_AFFINITY_INFO; 481 sc->psci_fnids[PSCI_FN_MIGRATE] = PSCI_FNID_MIGRATE; 482 sc->psci_fnids[PSCI_FN_MIGRATE_INFO_TYPE] = PSCI_FNID_MIGRATE_INFO_TYPE; 483 sc->psci_fnids[PSCI_FN_MIGRATE_INFO_UP_CPU] = PSCI_FNID_MIGRATE_INFO_UP_CPU; 484 sc->psci_fnids[PSCI_FN_SYSTEM_OFF] = PSCI_FNID_SYSTEM_OFF; 485 sc->psci_fnids[PSCI_FN_SYSTEM_RESET] = PSCI_FNID_SYSTEM_RESET; 486 487 version = psci_get_version(sc); 488 489 if (version == PSCI_RETVAL_NOT_SUPPORTED) 490 return (1); 491 492 if ((PSCI_VER_MAJOR(version) == 0 && PSCI_VER_MINOR(version) == 2) || 493 (PSCI_VER_MAJOR(version) == 1 && PSCI_VER_MINOR(version) == 0)) { 494 if (bootverbose) 495 device_printf(dev, "PSCI version 0.2 available\n"); 496 497 /* 498 * We only register this for v0.2 since v0.1 doesn't support 499 * system_reset. 500 */ 501 EVENTHANDLER_REGISTER(shutdown_final, psci_shutdown, sc, 502 SHUTDOWN_PRI_LAST); 503 504 return (0); 505 } 506 507 device_printf(dev, "PSCI version number mismatched with DT\n"); 508 return (1); 509 } 510