GitHub-Mirror/opensbi
2
0
Fork 0
mirror of https://github.com/Fishwaldo/opensbi.git synced 2025-06-30 01:59:08 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

lib: sbi: Prefer hartindex over hartid in IPI framework

Browse source 
Let us prefer hartindex over hartid in IPI framework which in-turn
forces IPI users to also prefer hartindex.

Signed-off-by: Anup Patel <apatel@ventanamicro.com>
This commit is contained in:
Anup Patel 2023-09-01 17:41:07 +05:30 • committed by Anup Patel
parent e632cd7c81
commit 78c667b6fc
9 changed files with 44 additions and 38 deletions
Download patch file Download diff file Expand all files Collapse all files

14
include/sbi/sbi_ipi.h
View file

@ -23,11 +23,11 @@ struct sbi_ipi_device {
/** Name of the IPI device */ /** Name of the IPI device */
char name[32]; char name[32];
/** Send IPI to a target HART */ /** Send IPI to a target HART index */
void (*ipi_send)(u32 target_hart); void (*ipi_send)(u32 hart_index);
/** Clear IPI for a target HART */ /** Clear IPI for a target HART index */
void (*ipi_clear)(u32 target_hart); void (*ipi_clear)(u32 hart_index);
}; };
enum sbi_ipi_update_type { enum sbi_ipi_update_type {
@ -54,7 +54,7 @@ struct sbi_ipi_event_ops {
*/ */
int (* update)(struct sbi_scratch *scratch, int (* update)(struct sbi_scratch *scratch,
struct sbi_scratch *remote_scratch, struct sbi_scratch *remote_scratch,
u32 remote_hartid, void *data); u32 remote_hartindex, void *data);
/** /**
* Sync callback to wait for remote HART * Sync callback to wait for remote HART
@ -85,9 +85,9 @@ int sbi_ipi_send_halt(ulong hmask, ulong hbase);
void sbi_ipi_process(void); void sbi_ipi_process(void);
int sbi_ipi_raw_send(u32 target_hart); int sbi_ipi_raw_send(u32 hartindex);
void sbi_ipi_raw_clear(u32 target_hart); void sbi_ipi_raw_clear(u32 hartindex);
const struct sbi_ipi_device *sbi_ipi_get_device(void); const struct sbi_ipi_device *sbi_ipi_get_device(void);

2
lib/sbi/sbi_hsm.c
View file

@ -356,7 +356,7 @@ int sbi_hsm_hart_start(struct sbi_scratch *scratch,
(hsm_device_has_hart_secondary_boot() && !init_count)) { (hsm_device_has_hart_secondary_boot() && !init_count)) {
rc = hsm_device_hart_start(hartid, scratch->warmboot_addr); rc = hsm_device_hart_start(hartid, scratch->warmboot_addr);
} else { } else {
rc = sbi_ipi_raw_send(hartid); rc = sbi_ipi_raw_send(sbi_hartid_to_hartindex(hartid));
} }
if (!rc) if (!rc)

4
lib/sbi/sbi_init.c
View file

@ -252,7 +252,7 @@ static void wake_coldboot_harts(struct sbi_scratch *scratch, u32 hartid)
for (u32 i = 0; i <= sbi_scratch_last_hartid(); i++) { for (u32 i = 0; i <= sbi_scratch_last_hartid(); i++) {
if ((i != hartid) && if ((i != hartid) &&
sbi_hartmask_test_hartid(i, &coldboot_wait_hmask)) sbi_hartmask_test_hartid(i, &coldboot_wait_hmask))
sbi_ipi_raw_send(i); sbi_ipi_raw_send(sbi_hartid_to_hartindex(i));
} }
/* Release coldboot lock */ /* Release coldboot lock */
@ -499,7 +499,7 @@ static void __noreturn init_warmboot(struct sbi_scratch *scratch, u32 hartid)
if (hstate == SBI_HSM_STATE_SUSPENDED) { if (hstate == SBI_HSM_STATE_SUSPENDED) {
init_warm_resume(scratch, hartid); init_warm_resume(scratch, hartid);
} else { } else {
sbi_ipi_raw_clear(hartid); sbi_ipi_raw_clear(sbi_hartid_to_hartindex(hartid));
init_warm_startup(scratch, hartid); init_warm_startup(scratch, hartid);
} }
} }

26
lib/sbi/sbi_ipi.c
View file

@ -36,7 +36,7 @@ static unsigned long ipi_data_off;
static const struct sbi_ipi_device *ipi_dev = NULL; static const struct sbi_ipi_device *ipi_dev = NULL;
static const struct sbi_ipi_event_ops *ipi_ops_array[SBI_IPI_EVENT_MAX]; static const struct sbi_ipi_event_ops *ipi_ops_array[SBI_IPI_EVENT_MAX];
static int sbi_ipi_send(struct sbi_scratch *scratch, u32 remote_hartid, static int sbi_ipi_send(struct sbi_scratch *scratch, u32 remote_hartindex,
u32 event, void *data) u32 event, void *data)
{ {
int ret; int ret;
@ -49,7 +49,7 @@ static int sbi_ipi_send(struct sbi_scratch *scratch, u32 remote_hartid,
return SBI_EINVAL; return SBI_EINVAL;
ipi_ops = ipi_ops_array[event]; ipi_ops = ipi_ops_array[event];
remote_scratch = sbi_hartid_to_scratch(remote_hartid); remote_scratch = sbi_hartindex_to_scratch(remote_hartindex);
if (!remote_scratch) if (!remote_scratch)
return SBI_EINVAL; return SBI_EINVAL;
@ -57,7 +57,7 @@ static int sbi_ipi_send(struct sbi_scratch *scratch, u32 remote_hartid,
if (ipi_ops->update) { if (ipi_ops->update) {
ret = ipi_ops->update(scratch, remote_scratch, ret = ipi_ops->update(scratch, remote_scratch,
remote_hartid, data); remote_hartindex, data);
if (ret != SBI_IPI_UPDATE_SUCCESS) if (ret != SBI_IPI_UPDATE_SUCCESS)
return ret; return ret;
} }
@ -70,7 +70,7 @@ static int sbi_ipi_send(struct sbi_scratch *scratch, u32 remote_hartid,
smp_wmb(); smp_wmb();
if (ipi_dev && ipi_dev->ipi_send) if (ipi_dev && ipi_dev->ipi_send)
ipi_dev->ipi_send(remote_hartid); ipi_dev->ipi_send(remote_hartindex);
sbi_pmu_ctr_incr_fw(SBI_PMU_FW_IPI_SENT); sbi_pmu_ctr_incr_fw(SBI_PMU_FW_IPI_SENT);
@ -101,7 +101,7 @@ int sbi_ipi_send_many(ulong hmask, ulong hbase, u32 event, void *data)
{ {
int rc; int rc;
bool retry_needed; bool retry_needed;
ulong i, j, m; ulong i, m;
struct sbi_hartmask target_mask = {0}; struct sbi_hartmask target_mask = {0};
struct sbi_domain *dom = sbi_domain_thishart_ptr(); struct sbi_domain *dom = sbi_domain_thishart_ptr();
struct sbi_scratch *scratch = sbi_scratch_thishart_ptr(); struct sbi_scratch *scratch = sbi_scratch_thishart_ptr();
@ -131,12 +131,12 @@ int sbi_ipi_send_many(ulong hmask, ulong hbase, u32 event, void *data)
/* Send IPIs */ /* Send IPIs */
do { do {
retry_needed = false; retry_needed = false;
sbi_hartmask_for_each_hart(i, j, &target_mask) { sbi_hartmask_for_each_hartindex(i, &target_mask) {
rc = sbi_ipi_send(scratch, i, event, data); rc = sbi_ipi_send(scratch, i, event, data);
if (rc == SBI_IPI_UPDATE_RETRY) if (rc == SBI_IPI_UPDATE_RETRY)
retry_needed = true; retry_needed = true;
else else
sbi_hartmask_clear_hartid(i, &target_mask); sbi_hartmask_clear_hartindex(i, &target_mask);
} }
} while (retry_needed); } while (retry_needed);
@ -219,11 +219,11 @@ void sbi_ipi_process(void)
struct sbi_scratch *scratch = sbi_scratch_thishart_ptr(); struct sbi_scratch *scratch = sbi_scratch_thishart_ptr();
struct sbi_ipi_data *ipi_data = struct sbi_ipi_data *ipi_data =
sbi_scratch_offset_ptr(scratch, ipi_data_off); sbi_scratch_offset_ptr(scratch, ipi_data_off);
u32 hartid = current_hartid(); u32 hartindex = sbi_hartid_to_hartindex(current_hartid());
sbi_pmu_ctr_incr_fw(SBI_PMU_FW_IPI_RECVD); sbi_pmu_ctr_incr_fw(SBI_PMU_FW_IPI_RECVD);
if (ipi_dev && ipi_dev->ipi_clear) if (ipi_dev && ipi_dev->ipi_clear)
ipi_dev->ipi_clear(hartid); ipi_dev->ipi_clear(hartindex);
ipi_type = atomic_raw_xchg_ulong(&ipi_data->ipi_type, 0); ipi_type = atomic_raw_xchg_ulong(&ipi_data->ipi_type, 0);
ipi_event = 0; ipi_event = 0;
@ -238,19 +238,19 @@ void sbi_ipi_process(void)
} }
} }
int sbi_ipi_raw_send(u32 target_hart) int sbi_ipi_raw_send(u32 hartindex)
{ {
if (!ipi_dev || !ipi_dev->ipi_send) if (!ipi_dev || !ipi_dev->ipi_send)
return SBI_EINVAL; return SBI_EINVAL;
ipi_dev->ipi_send(target_hart); ipi_dev->ipi_send(hartindex);
return 0; return 0;
} }
void sbi_ipi_raw_clear(u32 target_hart) void sbi_ipi_raw_clear(u32 hartindex)
{ {
if (ipi_dev && ipi_dev->ipi_clear) if (ipi_dev && ipi_dev->ipi_clear)
ipi_dev->ipi_clear(target_hart); ipi_dev->ipi_clear(hartindex);
} }
const struct sbi_ipi_device *sbi_ipi_get_device(void) const struct sbi_ipi_device *sbi_ipi_get_device(void)

8
lib/sbi/sbi_tlb.c
View file

@ -334,7 +334,7 @@ static int tlb_update_cb(void *in, void *data)
static int tlb_update(struct sbi_scratch *scratch, static int tlb_update(struct sbi_scratch *scratch,
struct sbi_scratch *remote_scratch, struct sbi_scratch *remote_scratch,
u32 remote_hartid, void *data) u32 remote_hartindex, void *data)
{ {
int ret; int ret;
atomic_t *tlb_sync; atomic_t *tlb_sync;
@ -356,7 +356,7 @@ static int tlb_update(struct sbi_scratch *scratch,
* If the request is to queue a tlb flush entry for itself * If the request is to queue a tlb flush entry for itself
* then just do a local flush and return; * then just do a local flush and return;
*/ */
if (remote_hartid == curr_hartid) { if (sbi_hartindex_to_hartid(remote_hartindex) == curr_hartid) {
tinfo->local_fn(tinfo); tinfo->local_fn(tinfo);
return SBI_IPI_UPDATE_BREAK; return SBI_IPI_UPDATE_BREAK;
} }
@ -375,8 +375,8 @@ static int tlb_update(struct sbi_scratch *scratch,
* this properly. * this properly.
*/ */
tlb_process_once(scratch); tlb_process_once(scratch);
sbi_dprintf("hart%d: hart%d tlb fifo full\n", sbi_dprintf("hart%d: hart%d tlb fifo full\n", curr_hartid,
curr_hartid, remote_hartid); sbi_hartindex_to_hartid(remote_hartindex));
return SBI_IPI_UPDATE_RETRY; return SBI_IPI_UPDATE_RETRY;
} }

14
lib/utils/ipi/aclint_mswi.c
View file

@ -25,13 +25,13 @@ static unsigned long mswi_ptr_offset;
#define mswi_set_hart_data_ptr(__scratch, __mswi) \ #define mswi_set_hart_data_ptr(__scratch, __mswi) \
sbi_scratch_write_type((__scratch), void *, mswi_ptr_offset, (__mswi)) sbi_scratch_write_type((__scratch), void *, mswi_ptr_offset, (__mswi))
static void mswi_ipi_send(u32 target_hart) static void mswi_ipi_send(u32 hart_index)
{ {
u32 *msip; u32 *msip;
struct sbi_scratch *scratch; struct sbi_scratch *scratch;
struct aclint_mswi_data *mswi; struct aclint_mswi_data *mswi;
scratch = sbi_hartid_to_scratch(target_hart); scratch = sbi_hartindex_to_scratch(hart_index);
if (!scratch) if (!scratch)
return; return;
@ -41,16 +41,17 @@ static void mswi_ipi_send(u32 target_hart)
/* Set ACLINT IPI */ /* Set ACLINT IPI */
msip = (void *)mswi->addr; msip = (void *)mswi->addr;
writel(1, &msip[target_hart - mswi->first_hartid]); writel(1, &msip[sbi_hartindex_to_hartid(hart_index) -
mswi->first_hartid]);
} }
static void mswi_ipi_clear(u32 target_hart) static void mswi_ipi_clear(u32 hart_index)
{ {
u32 *msip; u32 *msip;
struct sbi_scratch *scratch; struct sbi_scratch *scratch;
struct aclint_mswi_data *mswi; struct aclint_mswi_data *mswi;
scratch = sbi_hartid_to_scratch(target_hart); scratch = sbi_hartindex_to_scratch(hart_index);
if (!scratch) if (!scratch)
return; return;
@ -60,7 +61,8 @@ static void mswi_ipi_clear(u32 target_hart)
/* Clear ACLINT IPI */ /* Clear ACLINT IPI */
msip = (void *)mswi->addr; msip = (void *)mswi->addr;
writel(0, &msip[target_hart - mswi->first_hartid]); writel(0, &msip[sbi_hartindex_to_hartid(hart_index) -
mswi->first_hartid]);
} }
static struct sbi_ipi_device aclint_mswi = { static struct sbi_ipi_device aclint_mswi = {

8
lib/utils/ipi/andes_plicsw.c
View file

@ -68,8 +68,10 @@ static inline void plic_sw_pending(u32 target_hart)
writel(val, (void *)plicsw.addr + PLICSW_PENDING_BASE + word_index * 4); writel(val, (void *)plicsw.addr + PLICSW_PENDING_BASE + word_index * 4);
} }
static void plicsw_ipi_send(u32 target_hart) static void plicsw_ipi_send(u32 hart_index)
{ {
u32 target_hart = sbi_hartindex_to_hartid(hart_index);
if (plicsw.hart_count <= target_hart) if (plicsw.hart_count <= target_hart)
ebreak(); ebreak();
@ -77,8 +79,10 @@ static void plicsw_ipi_send(u32 target_hart)
plic_sw_pending(target_hart); plic_sw_pending(target_hart);
} }
static void plicsw_ipi_clear(u32 target_hart) static void plicsw_ipi_clear(u32 hart_index)
{ {
u32 target_hart = sbi_hartindex_to_hartid(hart_index);
if (plicsw.hart_count <= target_hart) if (plicsw.hart_count <= target_hart)
ebreak(); ebreak();

4
lib/utils/irqchip/imsic.c
View file

@ -161,7 +161,7 @@ static int imsic_external_irqfn(struct sbi_trap_regs *regs)
return 0; return 0;
} }
static void imsic_ipi_send(u32 target_hart) static void imsic_ipi_send(u32 hart_index)
{ {
unsigned long reloff; unsigned long reloff;
struct imsic_regs *regs; struct imsic_regs *regs;
@ -169,7 +169,7 @@ static void imsic_ipi_send(u32 target_hart)
struct sbi_scratch *scratch; struct sbi_scratch *scratch;
int file; int file;
scratch = sbi_hartid_to_scratch(target_hart); scratch = sbi_hartindex_to_scratch(hart_index);
if (!scratch) if (!scratch)
return; return;

2
platform/generic/andes/ae350.c
View file

@ -33,7 +33,7 @@ static int ae350_hart_start(u32 hartid, ulong saddr)
{ {
/* Don't send wakeup command at boot-time */ /* Don't send wakeup command at boot-time */
if (!sbi_init_count(hartid) || (is_andes25() && hartid == 0)) if (!sbi_init_count(hartid) || (is_andes25() && hartid == 0))
return sbi_ipi_raw_send(hartid); return sbi_ipi_raw_send(sbi_hartid_to_hartindex(hartid));
/* Write wakeup command to the sleep hart */ /* Write wakeup command to the sleep hart */
smu_set_command(&smu, WAKEUP_CMD, hartid); smu_set_command(&smu, WAKEUP_CMD, hartid);