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