8 files changed, 242 insertions, 6 deletions

diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig
index 8cc62289a63e..53e48a617fef 100644
--- a/arch/arm64/Kconfig
+++ b/arch/arm64/Kconfig
@@ -756,6 +756,15 @@ endmenu
 
 menu "Boot options"
 
+config ARM64_ACPI_PARKING_PROTOCOL
+        bool "Enable support for the ARM64 ACPI parking protocol"
+        depends on ACPI
+        help
+          Enable support for the ARM64 ACPI parking protocol. If disabled
+          the kernel will not allow booting through the ARM64 ACPI parking
+          protocol even if the corresponding data is present in the ACPI
+          MADT table.
+
 config CMDLINE
         string "Default kernel command string"
         default ""
diff --git a/arch/arm64/include/asm/acpi.h b/arch/arm64/include/asm/acpi.h
index caafd63b8092..aee323b13802 100644
--- a/arch/arm64/include/asm/acpi.h
+++ b/arch/arm64/include/asm/acpi.h
@@ -87,9 +87,26 @@ void __init acpi_init_cpus(void);
 static inline void acpi_init_cpus(void) { }
 #endif /* CONFIG_ACPI */
 
+#ifdef CONFIG_ARM64_ACPI_PARKING_PROTOCOL
+bool acpi_parking_protocol_valid(int cpu);
+void __init
+acpi_set_mailbox_entry(int cpu, struct acpi_madt_generic_interrupt *processor);
+#else
+static inline bool acpi_parking_protocol_valid(int cpu) { return false; }
+static inline void
+acpi_set_mailbox_entry(int cpu, struct acpi_madt_generic_interrupt *processor)
+{}
+#endif
+
 static inline const char *acpi_get_enable_method(int cpu)
 {
-        return acpi_psci_present() ? "psci" : NULL;
+        if (acpi_psci_present())
+                return "psci";
+
+        if (acpi_parking_protocol_valid(cpu))
+                return "parking-protocol";
+
+        return NULL;
 }
 
 #ifdef  CONFIG_ACPI_APEI
diff --git a/arch/arm64/include/asm/hardirq.h b/arch/arm64/include/asm/hardirq.h
index a57601f9d17c..8740297dac77 100644
--- a/arch/arm64/include/asm/hardirq.h
+++ b/arch/arm64/include/asm/hardirq.h
@@ -20,7 +20,7 @@
 #include <linux/threads.h>
 #include <asm/irq.h>
 
-#define NR_IPI  5
+#define NR_IPI  6
 
 typedef struct {
         unsigned int __softirq_pending;
diff --git a/arch/arm64/include/asm/smp.h b/arch/arm64/include/asm/smp.h
index d9c3d6a6100a..2013a4dc5124 100644
--- a/arch/arm64/include/asm/smp.h
+++ b/arch/arm64/include/asm/smp.h
@@ -64,6 +64,15 @@ extern void secondary_entry(void);
 extern void arch_send_call_function_single_ipi(int cpu);
 extern void arch_send_call_function_ipi_mask(const struct cpumask *mask);
 
+#ifdef CONFIG_ARM64_ACPI_PARKING_PROTOCOL
+extern void arch_send_wakeup_ipi_mask(const struct cpumask *mask);
+#else
+static inline void arch_send_wakeup_ipi_mask(const struct cpumask *mask)
+{
+        BUILD_BUG();
+}
+#endif
+
 extern int __cpu_disable(void);
 
 extern void __cpu_die(unsigned int cpu);
diff --git a/arch/arm64/kernel/Makefile b/arch/arm64/kernel/Makefile
index 83cd7e68e83b..8a9c65ccb636 100644
--- a/arch/arm64/kernel/Makefile
+++ b/arch/arm64/kernel/Makefile
@@ -41,6 +41,7 @@ arm64-obj-$(CONFIG_EFI)			+= efi.o efi-entry.stub.o
 arm64-obj-$(CONFIG_PCI)                 += pci.o
 arm64-obj-$(CONFIG_ARMV8_DEPRECATED)    += armv8_deprecated.o
 arm64-obj-$(CONFIG_ACPI)                += acpi.o
+arm64-obj-$(CONFIG_ARM64_ACPI_PARKING_PROTOCOL) += acpi_parking_protocol.o
 arm64-obj-$(CONFIG_PARAVIRT)            += paravirt.o
 
 obj-y                                   += $(arm64-obj-y) vdso/
diff --git a/arch/arm64/kernel/acpi_parking_protocol.c b/arch/arm64/kernel/acpi_parking_protocol.c
new file mode 100644
index 000000000000..4b1e5a7a98da
--- /dev/null
+++ b/arch/arm64/kernel/acpi_parking_protocol.c
@@ -0,0 +1,153 @@
+/*
+ * ARM64 ACPI Parking Protocol implementation
+ *
+ * Authors: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
+ *          Mark Salter <msalter@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <linux/acpi.h>
+#include <linux/types.h>
+
+#include <asm/cpu_ops.h>
+
+struct cpu_mailbox_entry {
+        phys_addr_t mailbox_addr;
+        u8 version;
+        u8 gic_cpu_id;
+};
+
+static struct cpu_mailbox_entry cpu_mailbox_entries[NR_CPUS];
+
+void __init acpi_set_mailbox_entry(int cpu,
+                                   struct acpi_madt_generic_interrupt *p)
+{
+        struct cpu_mailbox_entry *cpu_entry = &cpu_mailbox_entries[cpu];
+
+        cpu_entry->mailbox_addr = p->parked_address;
+        cpu_entry->version = p->parking_version;
+        cpu_entry->gic_cpu_id = p->cpu_interface_number;
+}
+
+bool acpi_parking_protocol_valid(int cpu)
+{
+        struct cpu_mailbox_entry *cpu_entry = &cpu_mailbox_entries[cpu];
+
+        return cpu_entry->mailbox_addr && cpu_entry->version;
+}
+
+static int acpi_parking_protocol_cpu_init(unsigned int cpu)
+{
+        pr_debug("%s: ACPI parked addr=%llx\n", __func__,
+                  cpu_mailbox_entries[cpu].mailbox_addr);
+
+        return 0;
+}
+
+static int acpi_parking_protocol_cpu_prepare(unsigned int cpu)
+{
+        return 0;
+}
+
+struct parking_protocol_mailbox {
+        __le32 cpu_id;
+        __le32 reserved;
+        __le64 entry_point;
+};
+
+static int acpi_parking_protocol_cpu_boot(unsigned int cpu)
+{
+        struct cpu_mailbox_entry *cpu_entry = &cpu_mailbox_entries[cpu];
+        struct parking_protocol_mailbox __iomem *mailbox;
+        __le32 cpu_id;
+
+        /*
+         * Map mailbox memory with attribute device nGnRE (ie ioremap -
+         * this deviates from the parking protocol specifications since
+         * the mailboxes are required to be mapped nGnRnE; the attribute
+         * discrepancy is harmless insofar as the protocol specification
+         * is concerned).
+         * If the mailbox is mistakenly allocated in the linear mapping
+         * by FW ioremap will fail since the mapping will be prevented
+         * by the kernel (it clashes with the linear mapping attributes
+         * specifications).
+         */
+        mailbox = ioremap(cpu_entry->mailbox_addr, sizeof(*mailbox));
+        if (!mailbox)
+                return -EIO;
+
+        cpu_id = readl_relaxed(&mailbox->cpu_id);
+        /*
+         * Check if firmware has set-up the mailbox entry properly
+         * before kickstarting the respective cpu.
+         */
+        if (cpu_id != ~0U) {
+                iounmap(mailbox);
+                return -ENXIO;
+        }
+
+        /*
+         * We write the entry point and cpu id as LE regardless of the
+         * native endianness of the kernel. Therefore, any boot-loaders
+         * that read this address need to convert this address to the
+         * Boot-Loader's endianness before jumping.
+         */
+        writeq_relaxed(__pa(secondary_entry), &mailbox->entry_point);
+        writel_relaxed(cpu_entry->gic_cpu_id, &mailbox->cpu_id);
+
+        arch_send_wakeup_ipi_mask(cpumask_of(cpu));
+
+        iounmap(mailbox);
+
+        return 0;
+}
+
+static void acpi_parking_protocol_cpu_postboot(void)
+{
+        int cpu = smp_processor_id();
+        struct cpu_mailbox_entry *cpu_entry = &cpu_mailbox_entries[cpu];
+        struct parking_protocol_mailbox __iomem *mailbox;
+        __le64 entry_point;
+
+        /*
+         * Map mailbox memory with attribute device nGnRE (ie ioremap -
+         * this deviates from the parking protocol specifications since
+         * the mailboxes are required to be mapped nGnRnE; the attribute
+         * discrepancy is harmless insofar as the protocol specification
+         * is concerned).
+         * If the mailbox is mistakenly allocated in the linear mapping
+         * by FW ioremap will fail since the mapping will be prevented
+         * by the kernel (it clashes with the linear mapping attributes
+         * specifications).
+         */
+        mailbox = ioremap(cpu_entry->mailbox_addr, sizeof(*mailbox));
+        if (!mailbox)
+                return;
+
+        entry_point = readl_relaxed(&mailbox->entry_point);
+        /*
+         * Check if firmware has cleared the entry_point as expected
+         * by the protocol specification.
+         */
+        WARN_ON(entry_point);
+
+        iounmap(mailbox);
+}
+
+const struct cpu_operations acpi_parking_protocol_ops = {
+        .name           = "parking-protocol",
+        .cpu_init       = acpi_parking_protocol_cpu_init,
+        .cpu_prepare    = acpi_parking_protocol_cpu_prepare,
+        .cpu_boot       = acpi_parking_protocol_cpu_boot,
+        .cpu_postboot   = acpi_parking_protocol_cpu_postboot
+};
diff --git a/arch/arm64/kernel/cpu_ops.c b/arch/arm64/kernel/cpu_ops.c
index b6bd7d447768..c7cfb8fe06f9 100644
--- a/arch/arm64/kernel/cpu_ops.c
+++ b/arch/arm64/kernel/cpu_ops.c
@@ -25,19 +25,30 @@
 #include <asm/smp_plat.h>
 
 extern const struct cpu_operations smp_spin_table_ops;
+extern const struct cpu_operations acpi_parking_protocol_ops;
 extern const struct cpu_operations cpu_psci_ops;
 
 const struct cpu_operations *cpu_ops[NR_CPUS];
 
-static const struct cpu_operations *supported_cpu_ops[] __initconst = {
+static const struct cpu_operations *dt_supported_cpu_ops[] __initconst = {
         &smp_spin_table_ops,
         &cpu_psci_ops,
         NULL,
 };
 
+static const struct cpu_operations *acpi_supported_cpu_ops[] __initconst = {
+#ifdef CONFIG_ARM64_ACPI_PARKING_PROTOCOL
+        &acpi_parking_protocol_ops,
+#endif
+        &cpu_psci_ops,
+        NULL,
+};
+
 static const struct cpu_operations * __init cpu_get_ops(const char *name)
 {
-        const struct cpu_operations **ops = supported_cpu_ops;
+        const struct cpu_operations **ops;
+
+        ops = acpi_disabled ? dt_supported_cpu_ops : acpi_supported_cpu_ops;
 
         while (*ops) {
                 if (!strcmp(name, (*ops)->name))
@@ -75,8 +86,16 @@ static const char *__init cpu_read_enable_method(int cpu)
                 }
         } else {
                 enable_method = acpi_get_enable_method(cpu);
-                if (!enable_method)
-                        pr_err("Unsupported ACPI enable-method\n");
+                if (!enable_method) {
+                        /*
+                         * In ACPI systems the boot CPU does not require
+                         * checking the enable method since for some
+                         * boot protocol (ie parking protocol) it need not
+                         * be initialized. Don't warn spuriously.
+                         */
+                        if (cpu != 0)
+                                pr_err("Unsupported ACPI enable-method\n");
+                }
         }
 
         return enable_method;
diff --git a/arch/arm64/kernel/smp.c b/arch/arm64/kernel/smp.c
index 68e7f79630d4..24cb4f800033 100644
--- a/arch/arm64/kernel/smp.c
+++ b/arch/arm64/kernel/smp.c
@@ -70,6 +70,7 @@ enum ipi_msg_type {
         IPI_CPU_STOP,
         IPI_TIMER,
         IPI_IRQ_WORK,
+        IPI_WAKEUP
 };
 
 /*
@@ -443,6 +444,17 @@ acpi_map_gic_cpu_interface(struct acpi_madt_generic_interrupt *processor)
         /* map the logical cpu id to cpu MPIDR */
         cpu_logical_map(cpu_count) = hwid;
 
+        /*
+         * Set-up the ACPI parking protocol cpu entries
+         * while initializing the cpu_logical_map to
+         * avoid parsing MADT entries multiple times for
+         * nothing (ie a valid cpu_logical_map entry should
+         * contain a valid parking protocol data set to
+         * initialize the cpu if the parking protocol is
+         * the only available enable method).
+         */
+        acpi_set_mailbox_entry(cpu_count, processor);
+
         cpu_count++;
 }
 
@@ -625,6 +637,7 @@ static const char *ipi_types[NR_IPI] __tracepoint_string = {
         S(IPI_CPU_STOP, "CPU stop interrupts"),
         S(IPI_TIMER, "Timer broadcast interrupts"),
         S(IPI_IRQ_WORK, "IRQ work interrupts"),
+        S(IPI_WAKEUP, "CPU wake-up interrupts"),
 };
 
 static void smp_cross_call(const struct cpumask *target, unsigned int ipinr)
@@ -668,6 +681,13 @@ void arch_send_call_function_single_ipi(int cpu)
         smp_cross_call(cpumask_of(cpu), IPI_CALL_FUNC);
 }
 
+#ifdef CONFIG_ARM64_ACPI_PARKING_PROTOCOL
+void arch_send_wakeup_ipi_mask(const struct cpumask *mask)
+{
+        smp_cross_call(mask, IPI_WAKEUP);
+}
+#endif
+
 #ifdef CONFIG_IRQ_WORK
 void arch_irq_work_raise(void)
 {
@@ -745,6 +765,14 @@ void handle_IPI(int ipinr, struct pt_regs *regs)
                 break;
 #endif
 
+#ifdef CONFIG_ARM64_ACPI_PARKING_PROTOCOL
+        case IPI_WAKEUP:
+                WARN_ONCE(!acpi_parking_protocol_valid(cpu),
+                          "CPU%u: Wake-up IPI outside the ACPI parking protocol\n",
+                          cpu);
+                break;
+#endif
+
         default:
                 pr_crit("CPU%u: Unknown IPI message 0x%x\n", cpu, ipinr);
                 break;