LXR uboot/arch/riscv/lib/smp.c

   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * Copyright (C) 2019 Fraunhofer AISEC,
   4 * Lukas Auer <lukas.auer@aisec.fraunhofer.de>
   5 */
   6
   7#include <common.h>
   8#include <cpu_func.h>
   9#include <dm.h>
  10#include <asm/barrier.h>
  11#include <asm/global_data.h>
  12#include <asm/smp.h>
  13
  14DECLARE_GLOBAL_DATA_PTR;
  15
  16static int send_ipi_many(struct ipi_data *ipi, int wait)
  17{
  18        ofnode node, cpus;
  19        u32 reg;
  20        int ret, pending;
  21
  22        cpus = ofnode_path("/cpus");
  23        if (!ofnode_valid(cpus)) {
  24                pr_err("Can't find cpus node!\n");
  25                return -EINVAL;
  26        }
  27
  28        ofnode_for_each_subnode(node, cpus) {
  29                /* skip if hart is marked as not available in the device tree */
  30                if (!ofnode_is_available(node))
  31                        continue;
  32
  33                /* read hart ID of CPU */
  34                ret = ofnode_read_u32(node, "reg", &reg);
  35                if (ret)
  36                        continue;
  37
  38                /* skip if it is the hart we are running on */
  39                if (reg == gd->arch.boot_hart)
  40                        continue;
  41
  42                if (reg >= CONFIG_NR_CPUS) {
  43                        pr_err("Hart ID %d is out of range, increase CONFIG_NR_CPUS\n",
  44                               reg);
  45                        continue;
  46                }
  47
  48#ifndef CONFIG_XIP
  49                /* skip if hart is not available */
  50                if (!(gd->arch.available_harts & (1 << reg)))
  51                        continue;
  52#endif
  53
  54                gd->arch.ipi[reg].addr = ipi->addr;
  55                gd->arch.ipi[reg].arg0 = ipi->arg0;
  56                gd->arch.ipi[reg].arg1 = ipi->arg1;
  57
  58                /*
  59                 * Ensure valid only becomes set when the IPI parameters are
  60                 * set. An IPI may already be pending on other harts, so we
  61                 * need a way to signal that the IPI device has been
  62                 * initialized, and that it is ok to call the function.
  63                 */
  64                __smp_store_release(&gd->arch.ipi[reg].valid, 1);
  65
  66                ret = riscv_send_ipi(reg);
  67                if (ret) {
  68                        pr_err("Cannot send IPI to hart %d\n", reg);
  69                        return ret;
  70                }
  71
  72                if (wait) {
  73                        pending = 1;
  74                        while (pending) {
  75                                ret = riscv_get_ipi(reg, &pending);
  76                                if (ret)
  77                                        return ret;
  78                        }
  79                }
  80        }
  81
  82        return 0;
  83}
  84
  85void handle_ipi(ulong hart)
  86{
  87        int ret;
  88        void (*smp_function)(ulong hart, ulong arg0, ulong arg1);
  89
  90        if (hart >= CONFIG_NR_CPUS)
  91                return;
  92
  93        /*
  94         * If valid is not set, then U-Boot has not requested the IPI. The
  95         * IPI device may not be initialized, so all we can do is wait for
  96         * U-Boot to initialize it and send an IPI
  97         */
  98        if (!__smp_load_acquire(&gd->arch.ipi[hart].valid))
  99                return;
 100
 101        smp_function = (void (*)(ulong, ulong, ulong))gd->arch.ipi[hart].addr;
 102        invalidate_icache_all();
 103
 104        /*
 105         * Clear the IPI to acknowledge the request before jumping to the
 106         * requested function.
 107         */
 108        ret = riscv_clear_ipi(hart);
 109        if (ret) {
 110                pr_err("Cannot clear IPI of hart %ld (error %d)\n", hart, ret);
 111                return;
 112        }
 113
 114        smp_function(hart, gd->arch.ipi[hart].arg0, gd->arch.ipi[hart].arg1);
 115}
 116
 117int smp_call_function(ulong addr, ulong arg0, ulong arg1, int wait)
 118{
 119        struct ipi_data ipi = {
 120                .addr = addr,
 121                .arg0 = arg0,
 122                .arg1 = arg1,
 123        };
 124
 125        return send_ipi_many(&ipi, wait);
 126}
 127