sys/dev/psci/psci.c

   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         uint32_t        psci_version;
  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-1.0",        (uintptr_t)psci_v0_2_init},
 101         {"arm,psci-0.2",        (uintptr_t)psci_v0_2_init},
 102         {"arm,psci",            (uintptr_t)psci_v0_1_init},
 103         {NULL,                  0}
 104 };
 105 #endif
 106
 107 static int psci_attach(device_t, psci_initfn_t);
 108 static void psci_shutdown(void *, int);
 109
 110 static int psci_find_callfn(psci_callfn_t *);
 111 static int psci_def_callfn(register_t, register_t, register_t, register_t);
 112
 113 psci_callfn_t psci_callfn = psci_def_callfn;
 114
 115 static void
 116 psci_init(void *dummy)
 117 {
 118         psci_callfn_t new_callfn;
 119
 120         if (psci_find_callfn(&new_callfn) != PSCI_RETVAL_SUCCESS) {
 121                 printf("No PSCI/SMCCC call function found\n");
 122                 return;
 123         }
 124
 125         psci_callfn = new_callfn;
 126 }
 127 /* This needs to be before cpu_mp at SI_SUB_CPU, SI_ORDER_THIRD */
 128 SYSINIT(psci_start, SI_SUB_CPU, SI_ORDER_FIRST, psci_init, NULL);
 129
 130 static int
 131 psci_def_callfn(register_t a __unused, register_t b __unused,
 132     register_t c __unused, register_t d __unused)
 133 {
 134
 135         panic("No PSCI/SMCCC call function set");
 136 }
 137
 138 #ifdef FDT
 139 static int psci_fdt_probe(device_t dev);
 140 static int psci_fdt_attach(device_t dev);
 141
 142 static device_method_t psci_fdt_methods[] = {
 143         DEVMETHOD(device_probe,     psci_fdt_probe),
 144         DEVMETHOD(device_attach,    psci_fdt_attach),
 145
 146         DEVMETHOD_END
 147 };
 148
 149 static driver_t psci_fdt_driver = {
 150         "psci",
 151         psci_fdt_methods,
 152         sizeof(struct psci_softc),
 153 };
 154
 155 static devclass_t psci_fdt_devclass;
 156
 157 EARLY_DRIVER_MODULE(psci, simplebus, psci_fdt_driver, psci_fdt_devclass, 0, 0,
 158     BUS_PASS_CPU + BUS_PASS_ORDER_FIRST);
 159 EARLY_DRIVER_MODULE(psci, ofwbus, psci_fdt_driver, psci_fdt_devclass, 0, 0,
 160     BUS_PASS_CPU + BUS_PASS_ORDER_FIRST);
 161
 162 static psci_callfn_t
 163 psci_fdt_get_callfn(phandle_t node)
 164 {
 165         char method[16];
 166
 167         if ((OF_getprop(node, "method", method, sizeof(method))) > 0) {
 168                 if (strcmp(method, "hvc") == 0)
 169                         return (psci_hvc_despatch);
 170                 else if (strcmp(method, "smc") == 0)
 171                         return (psci_smc_despatch);
 172                 else
 173                         printf("psci: PSCI conduit \"%s\" invalid\n", method);
 174         } else
 175                 printf("psci: PSCI conduit not supplied in the device tree\n");
 176
 177         return (NULL);
 178 }
 179
 180 static int
 181 psci_fdt_probe(device_t dev)
 182 {
 183         const struct ofw_compat_data *ocd;
 184
 185         if (!ofw_bus_status_okay(dev))
 186                 return (ENXIO);
 187
 188         ocd = ofw_bus_search_compatible(dev, compat_data);
 189         if (ocd->ocd_str == NULL)
 190                 return (ENXIO);
 191
 192         device_set_desc(dev, "ARM Power State Co-ordination Interface Driver");
 193
 194         return (BUS_PROBE_SPECIFIC);
 195 }
 196
 197 static int
 198 psci_fdt_attach(device_t dev)
 199 {
 200         const struct ofw_compat_data *ocd;
 201         psci_initfn_t psci_init;
 202
 203         ocd = ofw_bus_search_compatible(dev, compat_data);
 204         psci_init = (psci_initfn_t)ocd->ocd_data;
 205
 206         return (psci_attach(dev, psci_init));
 207 }
 208 #endif
 209
 210 #ifdef DEV_ACPI
 211 static void psci_acpi_identify(driver_t *, device_t);
 212 static int psci_acpi_probe(device_t);
 213 static int psci_acpi_attach(device_t);
 214
 215 static device_method_t psci_acpi_methods[] = {
 216         /* Device interface */
 217         DEVMETHOD(device_identify,      psci_acpi_identify),
 218         DEVMETHOD(device_probe,         psci_acpi_probe),
 219         DEVMETHOD(device_attach,        psci_acpi_attach),
 220
 221         DEVMETHOD_END
 222 };
 223
 224 static driver_t psci_acpi_driver = {
 225         "psci",
 226         psci_acpi_methods,
 227         sizeof(struct psci_softc),
 228 };
 229
 230 static devclass_t psci_acpi_devclass;
 231
 232 EARLY_DRIVER_MODULE(psci, acpi, psci_acpi_driver, psci_acpi_devclass, 0, 0,
 233     BUS_PASS_CPU + BUS_PASS_ORDER_FIRST);
 234
 235 static int
 236 psci_acpi_bootflags(void)
 237 {
 238         ACPI_TABLE_FADT *fadt;
 239         vm_paddr_t physaddr;
 240         int flags;
 241
 242         physaddr = acpi_find_table(ACPI_SIG_FADT);
 243         if (physaddr == 0)
 244                 return (0);
 245
 246         fadt = acpi_map_table(physaddr, ACPI_SIG_FADT);
 247         if (fadt == NULL) {
 248                 printf("psci: Unable to map the FADT\n");
 249                 return (0);
 250         }
 251
 252         flags = fadt->ArmBootFlags;
 253
 254         acpi_unmap_table(fadt);
 255         return (flags);
 256 }
 257
 258 static psci_callfn_t
 259 psci_acpi_get_callfn(int flags)
 260 {
 261
 262         if ((flags & ACPI_FADT_PSCI_COMPLIANT) != 0) {
 263                 if ((flags & ACPI_FADT_PSCI_USE_HVC) != 0)
 264                         return (psci_hvc_despatch);
 265                 else
 266                         return (psci_smc_despatch);
 267         } else {
 268                 printf("psci: PSCI conduit not supplied in the device tree\n");
 269         }
 270
 271         return (NULL);
 272 }
 273
 274 static void
 275 psci_acpi_identify(driver_t *driver, device_t parent)
 276 {
 277         device_t dev;
 278         int flags;
 279
 280         flags = psci_acpi_bootflags();
 281         if ((flags & ACPI_FADT_PSCI_COMPLIANT) != 0) {
 282                 dev = BUS_ADD_CHILD(parent,
 283                     BUS_PASS_CPU + BUS_PASS_ORDER_FIRST, "psci", -1);
 284
 285                 if (dev != NULL)
 286                         acpi_set_private(dev, (void *)(uintptr_t)flags);
 287         }
 288 }
 289
 290 static int
 291 psci_acpi_probe(device_t dev)
 292 {
 293         uintptr_t flags;
 294
 295         flags = (uintptr_t)acpi_get_private(dev);
 296         if ((flags & ACPI_FADT_PSCI_COMPLIANT) == 0)
 297                 return (ENXIO);
 298
 299         device_set_desc(dev, "ARM Power State Co-ordination Interface Driver");
 300         return (BUS_PROBE_SPECIFIC);
 301 }
 302
 303 static int
 304 psci_acpi_attach(device_t dev)
 305 {
 306
 307         return (psci_attach(dev, psci_v0_2_init));
 308 }
 309 #endif
 310
 311 static int
 312 psci_attach(device_t dev, psci_initfn_t psci_init)
 313 {
 314         struct psci_softc *sc = device_get_softc(dev);
 315
 316         if (psci_softc != NULL)
 317                 return (ENXIO);
 318
 319         KASSERT(psci_init != NULL, ("PSCI init function cannot be NULL"));
 320         if (psci_init(dev))
 321                 return (ENXIO);
 322
 323         psci_softc = sc;
 324
 325         return (0);
 326 }
 327
 328 static int
 329 _psci_get_version(struct psci_softc *sc)
 330 {
 331         uint32_t fnid;
 332
 333         /* PSCI version wasn't supported in v0.1. */
 334         fnid = sc->psci_fnids[PSCI_FN_VERSION];
 335         if (fnid)
 336                 return (psci_call(fnid, 0, 0, 0));
 337
 338         return (PSCI_RETVAL_NOT_SUPPORTED);
 339 }
 340
 341 int
 342 psci_get_version(void)
 343 {
 344
 345         if (psci_softc == NULL)
 346                 return (PSCI_RETVAL_NOT_SUPPORTED);
 347         return (_psci_get_version(psci_softc));
 348 }
 349
 350 #ifdef FDT
 351 static int
 352 psci_fdt_callfn(psci_callfn_t *callfn)
 353 {
 354         phandle_t node;
 355
 356         node = ofw_bus_find_compatible(OF_peer(0), "arm,psci-0.2");
 357         if (node == 0) {
 358                 node = ofw_bus_find_compatible(OF_peer(0), "arm,psci-1.0");
 359                 if (node == 0)
 360                         return (PSCI_MISSING);
 361         }
 362
 363         *callfn = psci_fdt_get_callfn(node);
 364         return (0);
 365 }
 366 #endif
 367
 368 #ifdef DEV_ACPI
 369 static int
 370 psci_acpi_callfn(psci_callfn_t *callfn)
 371 {
 372         int flags;
 373
 374         flags = psci_acpi_bootflags();
 375         if ((flags & ACPI_FADT_PSCI_COMPLIANT) == 0)
 376                 return (PSCI_MISSING);
 377
 378         *callfn = psci_acpi_get_callfn(flags);
 379         return (0);
 380 }
 381 #endif
 382
 383 static int
 384 psci_find_callfn(psci_callfn_t *callfn)
 385 {
 386         int error;
 387
 388         *callfn = NULL;
 389 #ifdef FDT
 390         if (USE_FDT) {
 391                 error = psci_fdt_callfn(callfn);
 392                 if (error != 0)
 393                         return (error);
 394         }
 395 #endif
 396 #ifdef DEV_ACPI
 397         if (*callfn == NULL && USE_ACPI) {
 398                 error = psci_acpi_callfn(callfn);
 399                 if (error != 0)
 400                         return (error);
 401         }
 402 #endif
 403
 404         if (*callfn == NULL)
 405                 return (PSCI_MISSING);
 406
 407         return (PSCI_RETVAL_SUCCESS);
 408 }
 409
 410 int32_t
 411 psci_features(uint32_t psci_func_id)
 412 {
 413
 414         if (psci_softc == NULL)
 415                 return (PSCI_RETVAL_NOT_SUPPORTED);
 416
 417         /* The feature flags were added to PSCI 1.0 */
 418         if (PSCI_VER_MAJOR(psci_softc->psci_version) < 1)
 419                 return (PSCI_RETVAL_NOT_SUPPORTED);
 420
 421         return (psci_call(PSCI_FNID_FEATURES, psci_func_id, 0, 0));
 422 }
 423
 424 int
 425 psci_cpu_on(unsigned long cpu, unsigned long entry, unsigned long context_id)
 426 {
 427         uint32_t fnid;
 428
 429         fnid = PSCI_FNID_CPU_ON;
 430         if (psci_softc != NULL)
 431                 fnid = psci_softc->psci_fnids[PSCI_FN_CPU_ON];
 432
 433         /* PSCI v0.1 and v0.2 both support cpu_on. */
 434         return (psci_call(fnid, cpu, entry, context_id));
 435 }
 436
 437 static void
 438 psci_shutdown(void *xsc, int howto)
 439 {
 440         uint32_t fn = 0;
 441
 442         if (psci_softc == NULL)
 443                 return;
 444
 445         /* PSCI system_off and system_reset werent't supported in v0.1. */
 446         if ((howto & RB_POWEROFF) != 0)
 447                 fn = psci_softc->psci_fnids[PSCI_FN_SYSTEM_OFF];
 448         else if ((howto & RB_HALT) == 0)
 449                 fn = psci_softc->psci_fnids[PSCI_FN_SYSTEM_RESET];
 450
 451         if (fn)
 452                 psci_call(fn, 0, 0, 0);
 453
 454         /* System reset and off do not return. */
 455 }
 456
 457 void
 458 psci_reset(void)
 459 {
 460
 461         psci_shutdown(NULL, 0);
 462 }
 463
 464 #ifdef FDT
 465 /* Only support PSCI 0.1 on FDT */
 466 static int
 467 psci_v0_1_init(device_t dev)
 468 {
 469         struct psci_softc *sc = device_get_softc(dev);
 470         int psci_fn;
 471         uint32_t psci_fnid;
 472         phandle_t node;
 473         int len;
 474
 475
 476         /* Zero out the function ID table - Is this needed ? */
 477         for (psci_fn = PSCI_FN_VERSION, psci_fnid = PSCI_FNID_VERSION;
 478             psci_fn < PSCI_FN_MAX; psci_fn++, psci_fnid++)
 479                 sc->psci_fnids[psci_fn] = 0;
 480
 481         /* PSCI v0.1 doesn't specify function IDs. Get them from DT */
 482         node = ofw_bus_get_node(dev);
 483
 484         if ((len = OF_getproplen(node, "cpu_suspend")) > 0) {
 485                 OF_getencprop(node, "cpu_suspend", &psci_fnid, len);
 486                 sc->psci_fnids[PSCI_FN_CPU_SUSPEND] = psci_fnid;
 487         }
 488
 489         if ((len = OF_getproplen(node, "cpu_on")) > 0) {
 490                 OF_getencprop(node, "cpu_on", &psci_fnid, len);
 491                 sc->psci_fnids[PSCI_FN_CPU_ON] = psci_fnid;
 492         }
 493
 494         if ((len = OF_getproplen(node, "cpu_off")) > 0) {
 495                 OF_getencprop(node, "cpu_off", &psci_fnid, len);
 496                 sc->psci_fnids[PSCI_FN_CPU_OFF] = psci_fnid;
 497         }
 498
 499         if ((len = OF_getproplen(node, "migrate")) > 0) {
 500                 OF_getencprop(node, "migrate", &psci_fnid, len);
 501                 sc->psci_fnids[PSCI_FN_MIGRATE] = psci_fnid;
 502         }
 503
 504         sc->psci_version = (0 << 16) | 1;
 505         if (bootverbose)
 506                 device_printf(dev, "PSCI version 0.1 available\n");
 507
 508         return(0);
 509 }
 510 #endif
 511
 512 static int
 513 psci_v0_2_init(device_t dev)
 514 {
 515         struct psci_softc *sc = device_get_softc(dev);
 516         int version;
 517
 518         /* PSCI v0.2 specifies explicit function IDs. */
 519         sc->psci_fnids[PSCI_FN_VERSION]             = PSCI_FNID_VERSION;
 520         sc->psci_fnids[PSCI_FN_CPU_SUSPEND]         = PSCI_FNID_CPU_SUSPEND;
 521         sc->psci_fnids[PSCI_FN_CPU_OFF]             = PSCI_FNID_CPU_OFF;
 522         sc->psci_fnids[PSCI_FN_CPU_ON]              = PSCI_FNID_CPU_ON;
 523         sc->psci_fnids[PSCI_FN_AFFINITY_INFO]       = PSCI_FNID_AFFINITY_INFO;
 524         sc->psci_fnids[PSCI_FN_MIGRATE]             = PSCI_FNID_MIGRATE;
 525         sc->psci_fnids[PSCI_FN_MIGRATE_INFO_TYPE]   = PSCI_FNID_MIGRATE_INFO_TYPE;
 526         sc->psci_fnids[PSCI_FN_MIGRATE_INFO_UP_CPU] = PSCI_FNID_MIGRATE_INFO_UP_CPU;
 527         sc->psci_fnids[PSCI_FN_SYSTEM_OFF]          = PSCI_FNID_SYSTEM_OFF;
 528         sc->psci_fnids[PSCI_FN_SYSTEM_RESET]        = PSCI_FNID_SYSTEM_RESET;
 529
 530         version = _psci_get_version(sc);
 531
 532         if (version == PSCI_RETVAL_NOT_SUPPORTED)
 533                 return (1);
 534
 535         sc->psci_version = version;
 536         if ((PSCI_VER_MAJOR(version) == 0 && PSCI_VER_MINOR(version) == 2) ||
 537             PSCI_VER_MAJOR(version) == 1) {
 538                 if (bootverbose)
 539                         device_printf(dev, "PSCI version 0.2 compatible\n");
 540
 541                 /*
 542                  * We only register this for v0.2 since v0.1 doesn't support
 543                  * system_reset.
 544                  */
 545                 EVENTHANDLER_REGISTER(shutdown_final, psci_shutdown, sc,
 546                     SHUTDOWN_PRI_LAST);
 547
 548                 return (0);
 549         }
 550
 551         device_printf(dev, "PSCI version number mismatched with DT\n");
 552         return (1);
 553 }