Aarch64 powerdown: add support for GPIO power key

platform/virt/Makefile

@@ -17,6 +17,7 @@ SRCS-kernel.elf= \
 	$(SRCDIR)/aarch64/crt0.S \
 	$(SRCDIR)/aarch64/elf64.c \
 	$(SRCDIR)/aarch64/gic.c \
+	$(SRCDIR)/aarch64/gpio.c \
 	$(SRCDIR)/aarch64/hyperv.c \
 	$(SRCDIR)/aarch64/interrupt.c \
 	$(SRCDIR)/aarch64/kernel_machine.c \

platform/virt/kernel_platform.h

@@ -32,6 +32,7 @@
 
 #define VIRT_PCIE_IRQ_BASE 3
 #define VIRT_PCIE_IRQ_NUM  4
+#define VIRT_GPIO_IRQ      7
 #define VIRT_MMIO_IRQ_BASE 16
 #define VIRT_MMIO_IRQ_NUM  32
 

platform/virt/service.c

@@ -13,6 +13,8 @@
 #include <management.h>
 #include <virtio/virtio.h>
 #include <devicetree.h>
+#include <gic.h>
+#include <gpio.h>
 #include <hyperv_platform.h>
 #include "serial.h"
 
@@ -32,6 +34,8 @@
 #define init_dump(p, len)
 #endif
 
+static RO_AFTER_INIT u8 gpio_key_power = -1;
+
 BSS_RO_AFTER_INIT struct uefi_boot_params boot_params;
 
 u64 machine_random_seed(void)
@@ -396,6 +400,12 @@ void __attribute__((noreturn)) start(u64 x0, u64 x1)
     while (1);
 }
 
+closure_func_basic(thunk, void, gpio_key_handler)
+{
+    kernel_powerdown();
+    gpio_irq_clear(U64_FROM_BIT(gpio_key_power));
+}
+
 static void platform_dtb_parse(kernel_heaps kh, vector cpu_ids)
 {
     struct fdt fdt;
@@ -441,6 +451,18 @@ static void platform_dtb_parse(kernel_heaps kh, vector cpu_ids)
                     }
                 }
             }
+        } else if (!runtime_strcmp(name, ss("gpio-keys"))) {
+            fdt_foreach_node(&fdt, node) {
+                if (!runtime_strcmp(fdt_node_name(&fdt, node), ss("poweroff"))) {
+                    dt_prop gpio_prop = fdt_get_prop(&fdt, ss("gpios"));
+                    if ((gpio_prop != INVALID_ADDRESS) &&
+                        (dt_prop_cell_count(gpio_prop) >= 2))
+                        /* cell #0: phandle of GPIO controller
+                         * cell #1: GPIO number
+                         */
+                        gpio_key_power = dt_prop_get_cell(gpio_prop, 1);
+                }
+            }
         }
     }
 }
@@ -491,6 +513,13 @@ void detect_hypervisor(kernel_heaps kh)
 
 void detect_devices(kernel_heaps kh, storage_attach sa)
 {
+    if (gpio_key_power != (typeof(gpio_key_power))-1) {
+        thunk handler = closure_func(heap_locked(kh), thunk, gpio_key_handler);
+        assert(handler != INVALID_ADDRESS);
+        irq_register_handler(GIC_SPI_INTS_START + VIRT_GPIO_IRQ, handler, ss("gpio-keys"),
+                             irange(0, 0));
+        gpio_irq_enable(U64_FROM_BIT(gpio_key_power));
+    }
     init_acpi(kh);
     if (hyperv_detected()) {
         boolean hv_storvsc_attached = false;

src/aarch64/gpio.c

@@ -0,0 +1,17 @@
+#include <kernel.h>
+#include <gpio.h>
+
+#define PL061_GPIOIEV   0x40c
+#define PL061_GPIOIE    0x410
+#define PL061_GPIOIC    0x41c
+
+void gpio_irq_enable(u64 mask)
+{
+    mmio_write_32(mmio_base_addr(GPIO) + PL061_GPIOIEV, mask);
+    mmio_write_32(mmio_base_addr(GPIO) + PL061_GPIOIE, mask);
+}
+
+void gpio_irq_clear(u64 mask)
+{
+    mmio_write_32(mmio_base_addr(GPIO) + PL061_GPIOIC, mask);
+}

src/aarch64/gpio.h

@@ -0,0 +1,2 @@
+void gpio_irq_enable(u64 mask);
+void gpio_irq_clear(u64 mask);

src/devicetree/devicetree.c

@@ -87,6 +87,17 @@ static struct prop_value_map {
     { ss_static_init("cpu"), DT_VALUE_PHANDLE },
 };
 
+unsigned int dt_prop_cell_count(dt_prop prop)
+{
+    return dt_u32(prop->data_length) / sizeof(u32);
+}
+
+u32 dt_prop_get_cell(dt_prop prop, unsigned int index)
+{
+    void *ptr = prop->data + index * sizeof(u32);
+    return dt_u32(*((u32 *)ptr));
+}
+
 sstring dtb_string(void *dtb, u64 off)
 {
     dt_header fdt = dtb;
@@ -665,3 +676,25 @@ boolean fdt_get_reg(fdt fdt, u32 acells, u32 scells, dt_reg_iterator *iter)
     fdt->ptr = ptr;
     return found;
 }
+
+/* Consumes all the properties of the current node (i.e. only children of the current node can be
+ * parsed after this function is called). */
+dt_prop fdt_get_prop(fdt fdt, sstring name)
+{
+    void *ptr = fdt->ptr;
+    void *end = fdt->end;
+    dt_prop prop = INVALID_ADDRESS;
+    while (ptr < end) {
+        u32 token = dt_u32(*(u32 *)ptr);
+        if (token != FDT_PROP)
+            break;
+        ptr += sizeof(token);
+        dt_prop p = ptr;
+        u32 prop_len = dt_u32(p->data_length);
+        ptr += sizeof(*p) + pad(prop_len, 4);
+        if (!runtime_strcmp(fdt_prop_name(fdt, p), name))
+            prop = p;
+    }
+    fdt->ptr = ptr;
+    return prop;
+}

src/devicetree/devicetree.h

@@ -42,6 +42,9 @@ typedef struct dt_value {
 
 closure_type(dt_node_handler, boolean, dt_node n, sstring name);
 
+unsigned int dt_prop_cell_count(dt_prop prop);
+u32 dt_prop_get_cell(dt_prop prop, unsigned int index);
+
 typedef struct fdt {
     void *ptr, *end;
     char *strings_start, *strings_end;
@@ -72,6 +75,7 @@ dt_node fdt_next_node(fdt fdt);
 sstring fdt_node_name(fdt fdt, dt_node node);
 void fdt_get_cells(fdt fdt, u32 *acells, u32 *scells);
 boolean fdt_get_reg(fdt fdt, u32 acells, u32 scells, dt_reg_iterator *iter);
+dt_prop fdt_get_prop(fdt fdt, sstring name);
 
 #define fdt_foreach_node(fdt, node) \
     for (dt_node node = fdt_get_node(fdt); node; node = fdt_next_node(fdt))