From ffd10e3562cd00c08ca24d98749fb4b91fb39e35 Mon Sep 17 00:00:00 2001 From: Peng Yang Date: Sat, 2 Jul 2022 08:11:16 -0700 Subject: [PATCH] gunyah: rm: Porting gunyah vIRQ lending library Add library for client drivers to lend interrupts to each other. This is just snapshot of kalama's vIRQ lending driver from 'commit 5beb98404269 ("Merge "i3c: i3c-master-msm-geni: Fix IBI for invalid device OR handler"")'from msm-5.15 branch. Change-Id: Ia956778784a74535509edd6e7fcf95ae44fcdee2 Signed-off-by: Peng Yang --- drivers/virt/gunyah/Kconfig | 9 + drivers/virt/gunyah/Makefile | 1 + drivers/virt/gunyah/gh_irq_lend.c | 455 ++++++++++++++++++++++++++++++ 3 files changed, 465 insertions(+) create mode 100644 drivers/virt/gunyah/gh_irq_lend.c diff --git a/drivers/virt/gunyah/Kconfig b/drivers/virt/gunyah/Kconfig index e8ac775665e4..b5646586fb33 100644 --- a/drivers/virt/gunyah/Kconfig +++ b/drivers/virt/gunyah/Kconfig @@ -57,4 +57,13 @@ config GH_RM_DRV interface to other driver in order to obtain the services provided by the RM-VM. +config GH_IRQ_LEND + tristate "Gunyah IRQ Lending Framework" + depends on GH_RM_DRV + help + Gunyah Resource Manager permits interrupts to be shared between + virtual machines. This config enables a framework which + supports sharing these interrupts. The follows RM recommended + protocol. + endif diff --git a/drivers/virt/gunyah/Makefile b/drivers/virt/gunyah/Makefile index 2e7548bf8948..783158d60119 100644 --- a/drivers/virt/gunyah/Makefile +++ b/drivers/virt/gunyah/Makefile @@ -4,3 +4,4 @@ obj-$(CONFIG_GH_DBL) += gh_dbl.o obj-$(CONFIG_GH_MSGQ) += gh_msgq.o obj-$(CONFIG_GH_RM_DRV) += gh_rm_drv.o gh_rm_drv-y += gh_rm_core.o gh_rm_iface.o +obj-$(CONFIG_GH_IRQ_LEND) += gh_irq_lend.o diff --git a/drivers/virt/gunyah/gh_irq_lend.c b/drivers/virt/gunyah/gh_irq_lend.c new file mode 100644 index 000000000000..419433919cc6 --- /dev/null +++ b/drivers/virt/gunyah/gh_irq_lend.c @@ -0,0 +1,455 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (c) 2020-2021, The Linux Foundation. All rights reserved. + * + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "gh_rm_drv_private.h" + +struct gh_irq_entry { + gh_vmid_t vmid; + enum gh_vm_names vm_name; + gh_irq_handle_fn_v2 v2_handle; + gh_irq_handle_fn handle; + void *data; + + enum { + GH_IRQ_STATE_NONE, + + GH_IRQ_STATE_WAIT_RELEASE_OR_ACCEPT, + GH_IRQ_STATE_WAIT_LEND, + + /* notification states */ + GH_IRQ_STATE_RELEASED, /* svm -> pvm */ + GH_IRQ_STATE_ACCEPTED, /* svm -> pvm */ + GH_IRQ_STATE_LENT, /* pvm -> svm */ + } state; + gh_virq_handle_t virq_handle; +}; + +static struct gh_irq_entry gh_irq_entries[GH_IRQ_LABEL_MAX]; +static DEFINE_SPINLOCK(gh_irq_lend_lock); + +static int gh_irq_released_accepted_nb_handler(struct notifier_block *this, + unsigned long cmd, void *data) +{ + unsigned long flags; + enum gh_irq_label label; + struct gh_irq_entry *entry; + struct gh_rm_notif_vm_irq_released_payload *released; + struct gh_rm_notif_vm_irq_accepted_payload *accepted; + + if (cmd != GH_RM_NOTIF_VM_IRQ_RELEASED && + cmd != GH_RM_NOTIF_VM_IRQ_ACCEPTED) + return NOTIFY_DONE; + + spin_lock_irqsave(&gh_irq_lend_lock, flags); + for (label = 0; label < GH_IRQ_LABEL_MAX; label++) { + entry = &gh_irq_entries[label]; + + if (entry->state != GH_IRQ_STATE_WAIT_RELEASE_OR_ACCEPT && + entry->state != GH_IRQ_STATE_ACCEPTED) + continue; + + switch (cmd) { + case GH_RM_NOTIF_VM_IRQ_RELEASED: + released = data; + if (released->virq_handle == entry->virq_handle) { + entry->state = GH_IRQ_STATE_RELEASED; + spin_unlock_irqrestore(&gh_irq_lend_lock, + flags); + entry->v2_handle(entry->data, cmd, label); + return NOTIFY_OK; + } + + break; + case GH_RM_NOTIF_VM_IRQ_ACCEPTED: + accepted = data; + if (accepted->virq_handle == entry->virq_handle) { + entry->state = GH_IRQ_STATE_ACCEPTED; + spin_unlock_irqrestore(&gh_irq_lend_lock, + flags); + entry->v2_handle(entry->data, cmd, label); + return NOTIFY_OK; + } + + break; + } + } + spin_unlock_irqrestore(&gh_irq_lend_lock, flags); + + return NOTIFY_DONE; +} + +static struct notifier_block gh_irq_released_accepted_nb = { + .notifier_call = gh_irq_released_accepted_nb_handler, +}; + +static int gh_irq_lent_nb_handler(struct notifier_block *this, + unsigned long cmd, void *data) +{ + unsigned long flags; + enum gh_irq_label label; + enum gh_vm_names owner_name; + struct gh_irq_entry *entry; + struct gh_rm_notif_vm_irq_lent_payload *lent = data; + int ret; + + if (cmd != GH_RM_NOTIF_VM_IRQ_LENT) + return NOTIFY_DONE; + + ret = gh_rm_get_vm_name(lent->owner_vmid, &owner_name); + if (ret) { + pr_warn_ratelimited("%s: unknown name for vmid: %d\n", __func__, + lent->owner_vmid); + return ret; + } + + spin_lock_irqsave(&gh_irq_lend_lock, flags); + for (label = 0; label < GH_IRQ_LABEL_MAX; label++) { + entry = &gh_irq_entries[label]; + if (entry->state != GH_IRQ_STATE_WAIT_LEND && + entry->state != GH_IRQ_STATE_LENT) + continue; + + if (label == lent->virq_label && + (entry->vm_name == GH_VM_MAX || + entry->vm_name == owner_name)) { + entry->vmid = lent->owner_vmid; + entry->virq_handle = lent->virq_handle; + + entry->state = GH_IRQ_STATE_LENT; + spin_unlock_irqrestore(&gh_irq_lend_lock, + flags); + + entry->v2_handle(entry->data, cmd, label); + + return NOTIFY_OK; + } + } + spin_unlock_irqrestore(&gh_irq_lend_lock, flags); + + return NOTIFY_DONE; +} + +static struct notifier_block gh_irq_lent_nb = { + .notifier_call = gh_irq_lent_nb_handler, +}; + +/** + * gh_irq_lend_v2: Lend a hardware interrupt to another VM + * @label: vIRQ high-level label + * @name: VM name to send interrupt to + * @irq: Linux IRQ number to lend + * @cb_handle: callback to invoke when other VM release or accept the interrupt + * @data: Argument to pass to cb_handle + * + * Returns 0 on success also the handle corresponding to Linux IRQ#. + * Returns < 0 on error + */ +int gh_irq_lend_v2(enum gh_irq_label label, enum gh_vm_names name, + int irq, gh_irq_handle_fn_v2 cb_handle, void *data) +{ + int ret, virq; + unsigned long flags; + struct gh_irq_entry *entry; + + if (label >= GH_IRQ_LABEL_MAX || !cb_handle) + return -EINVAL; + + entry = &gh_irq_entries[label]; + + if (gh_rm_irq_to_virq(irq, &virq)) + return -EINVAL; + + spin_lock_irqsave(&gh_irq_lend_lock, flags); + if (entry->state != GH_IRQ_STATE_NONE) { + spin_unlock_irqrestore(&gh_irq_lend_lock, flags); + return -EINVAL; + } + + ret = gh_rm_get_vmid(name, &entry->vmid); + if (ret) { + entry->state = GH_IRQ_STATE_NONE; + spin_unlock_irqrestore(&gh_irq_lend_lock, flags); + return ret; + } + + entry->v2_handle = cb_handle; + entry->data = data; + entry->state = GH_IRQ_STATE_WAIT_RELEASE_OR_ACCEPT; + spin_unlock_irqrestore(&gh_irq_lend_lock, flags); + + return gh_rm_vm_irq_lend(entry->vmid, virq, label, &entry->virq_handle); +} +EXPORT_SYMBOL(gh_irq_lend_v2); + +/** + * gh_irq_lend: Lend a hardware interrupt to another VM + * @label: vIRQ high-level label + * @name: VM name to send interrupt to + * @irq: Linux IRQ number to lend + * @cb_handle: callback to invoke when other VM release or accept the interrupt + * @data: Argument to pass to cb_handle + * + * Returns 0 on success also the handle corresponding to Linux IRQ#. + * Returns < 0 on error + */ +int gh_irq_lend(enum gh_irq_label label, enum gh_vm_names name, + int irq, gh_irq_handle_fn cb_handle, void *data) +{ + struct gh_irq_entry *entry; + + if (label >= GH_IRQ_LABEL_MAX || !cb_handle) + return -EINVAL; + + entry = &gh_irq_entries[label]; + entry->handle = cb_handle; + + return 0; +} +EXPORT_SYMBOL(gh_irq_lend); + +/** + * gh_irq_lend_notify: Pass the irq handle to other VM for accept + * @label: vIRQ high-level label + * + * Returns 0 on success, < 0 on error + */ +int gh_irq_lend_notify(enum gh_irq_label label) +{ + struct gh_irq_entry *entry; + + if (label >= GH_IRQ_LABEL_MAX) + return -EINVAL; + + entry = &gh_irq_entries[label]; + if (entry->state == GH_IRQ_STATE_NONE) + return -EINVAL; + + return gh_rm_vm_irq_lend_notify(entry->vmid, entry->virq_handle); +} +EXPORT_SYMBOL(gh_irq_lend_notify); + +/** + * gh_irq_reclaim: Reclaim a hardware interrupt after other VM + * has released. + * @label: vIRQ high-level label + * + * This function should be called inside or after on_release() + * callback from gh_irq_lend. + * This function is not thread-safe. Do not race with another gh_irq_reclaim + * with same label + */ +int gh_irq_reclaim(enum gh_irq_label label) +{ + int ret; + struct gh_irq_entry *entry; + + if (label >= GH_IRQ_LABEL_MAX) + return -EINVAL; + + entry = &gh_irq_entries[label]; + + if (entry->state != GH_IRQ_STATE_WAIT_RELEASE_OR_ACCEPT && + (entry->state != GH_IRQ_STATE_RELEASED)) + return -EINVAL; + + ret = gh_rm_vm_irq_reclaim(entry->virq_handle); + if (!ret) + entry->state = GH_IRQ_STATE_NONE; + return ret; +} +EXPORT_SYMBOL(gh_irq_reclaim); + +/** + * gh_irq_wait_for_lend_v2: Register to claim a lent interrupt from another VM + * @label: vIRQ high-level label + * @name: Lender's VM name. If don't care, then use GH_VM_MAX + * @on_lend: callback to invoke when other VM lends the interrupt + * @data: Argument to pass to on_lend + */ +int gh_irq_wait_for_lend_v2(enum gh_irq_label label, enum gh_vm_names name, + gh_irq_handle_fn_v2 on_lend, void *data) +{ + unsigned long flags; + struct gh_irq_entry *entry; + + if (label >= GH_IRQ_LABEL_MAX || !on_lend) + return -EINVAL; + + entry = &gh_irq_entries[label]; + + spin_lock_irqsave(&gh_irq_lend_lock, flags); + if (entry->state != GH_IRQ_STATE_NONE) { + spin_unlock_irqrestore(&gh_irq_lend_lock, flags); + return -EINVAL; + } + + entry->vm_name = name; + entry->v2_handle = on_lend; + entry->data = data; + entry->state = GH_IRQ_STATE_WAIT_LEND; + spin_unlock_irqrestore(&gh_irq_lend_lock, flags); + + return 0; +} +EXPORT_SYMBOL(gh_irq_wait_for_lend_v2); + +/** + * gh_irq_wait_lend: Register to claim a lent interrupt from another VM + * @label: vIRQ high-level label + * @name: Lender's VM name. If don't care, then use GH_VM_MAX + * @on_lend: callback to invoke when other VM lends the interrupt + * @data: Argument to pass to on_lend + */ +int gh_irq_wait_for_lend(enum gh_irq_label label, enum gh_vm_names name, + gh_irq_handle_fn on_lend, void *data) +{ + return 0; +} +EXPORT_SYMBOL(gh_irq_wait_for_lend); + +/** + * gh_irq_accept: Register to receive interrupts with a lent vIRQ + * @label: vIRQ high-level label + * @irq: Linux IRQ# to associate vIRQ with. If don't care, use -1 + * @type: IRQ flags to use when allowing RM to choose the IRQ. If irq parameter + * is specified, then type is unused. + * + * Returns the Linux IRQ# that vIRQ was registered to on success. + * Returns <0 on error + * This function is not thread-safe w.r.t. IRQ lend state. Do not race with + * gh_irq_release or another gh_irq_accept with same label. + */ +int gh_irq_accept(enum gh_irq_label label, int irq, int type) +{ + struct gh_irq_entry *entry; + int virq; + + if (label >= GH_IRQ_LABEL_MAX) + return -EINVAL; + + entry = &gh_irq_entries[label]; + + if (entry->state != GH_IRQ_STATE_LENT) + return -EINVAL; + + if (irq != -1) { + if (gh_rm_irq_to_virq(irq, &virq)) + return -EINVAL; + } else + virq = -1; + + virq = gh_rm_vm_irq_accept(entry->virq_handle, virq); + if (virq < 0) + return virq; + + if (irq == -1) + irq = gh_rm_virq_to_irq(virq, type); + + entry->state = GH_IRQ_STATE_ACCEPTED; + return irq; +} +EXPORT_SYMBOL(gh_irq_accept); + +/** + * gh_irq_accept_notify: Notify the lend vm (pvm) that IRQ is accepted + * @label: vIRQ high-level label + * @irq: Linux IRQ# to associate vIRQ with. If don't care, use -1 + * + * Returns the Linux IRQ# that vIRQ was registered to on success. + * Returns <0 on error + * This function is not thread-safe w.r.t. IRQ lend state. Do not race with + * gh_irq_release or another gh_irq_accept with same label. + */ +int gh_irq_accept_notify(enum gh_irq_label label) +{ + struct gh_irq_entry *entry; + + if (label >= GH_IRQ_LABEL_MAX) + return -EINVAL; + + entry = &gh_irq_entries[label]; + + if (entry->state != GH_IRQ_STATE_ACCEPTED) + return -EINVAL; + + return gh_rm_vm_irq_accept_notify(entry->vmid, + entry->virq_handle); +} +EXPORT_SYMBOL(gh_irq_accept_notify); + +/** + * gh_irq_release: Release a lent interrupt + * @label: vIRQ high-level label + * This function is not thread-safe w.r.t. IRQ lend state. Do not race with + * gh_irq_accept or another gh_irq_release with same label. + */ +int gh_irq_release(enum gh_irq_label label) +{ + int ret; + struct gh_irq_entry *entry; + + if (label >= GH_IRQ_LABEL_MAX) + return -EINVAL; + + entry = &gh_irq_entries[label]; + + if (entry->state != GH_IRQ_STATE_ACCEPTED) + return -EINVAL; + + ret = gh_rm_vm_irq_release(entry->virq_handle); + if (!ret) + entry->state = GH_IRQ_STATE_WAIT_LEND; + return ret; +} +EXPORT_SYMBOL(gh_irq_release); + +int gh_irq_release_notify(enum gh_irq_label label) +{ + struct gh_irq_entry *entry; + + if (label >= GH_IRQ_LABEL_MAX) + return -EINVAL; + + entry = &gh_irq_entries[label]; + + if (entry->state != GH_IRQ_STATE_ACCEPTED && + entry->state != GH_IRQ_STATE_WAIT_LEND) + return -EINVAL; + + return gh_rm_vm_irq_release_notify(entry->vmid, + entry->virq_handle); +} +EXPORT_SYMBOL(gh_irq_release_notify); + +static int __init gh_irq_lend_init(void) +{ + int ret; + + ret = gh_rm_register_notifier(&gh_irq_lent_nb); + if (ret) + return ret; + + return gh_rm_register_notifier(&gh_irq_released_accepted_nb); +} +module_init(gh_irq_lend_init); + +static void gh_irq_lend_exit(void) +{ + gh_rm_unregister_notifier(&gh_irq_lent_nb); + gh_rm_unregister_notifier(&gh_irq_released_accepted_nb); +} +module_exit(gh_irq_lend_exit); + +MODULE_LICENSE("GPL"); +MODULE_DESCRIPTION("Qualcomm Technologies, Inc. Gunyah IRQ Lending Library");