Merge "net: qrtr: haven: Add svm device tree parsing" (30e36e95) · Commits · e / devices / android_kernel_fairphone_FP5

net/qrtr/haven.c

+125 −6

Original line number	Diff line number	Diff line
		@@ -10,7 +10,9 @@
		#include <linux/platform_device.h>
		#include <linux/types.h>
		#include <linux/skbuff.h>
		#include <linux/haven/hh_rm_drv.h>
		#include <linux/haven/hh_dbl.h>
		#include <soc/qcom/secure_buffer.h>
		#include "qrtr.h"

		#define HAVEN_MAGIC_KEY 0x24495043 /* "$IPC" */
		@@ -37,10 +39,13 @@ struct haven_pipe {
		* @ep: qrtr endpoint specific info.
		* @dev: device from platform_device.
		* @buf: buf for reading from fifo.
		* @res: resource of reserved mem region
		* @memparcel: memparcel handle returned from sharing mem
		* @base: Base of the shared fifo.
		* @size: fifo size.
		* @master: primary vm indicator.
		* @peer_name: name of vm peer.
		* @rm_nb: notifier block for vm status from rm
		* @label: label for haven resources
		* @tx_dbl: doorbell for tx notifications.
		* @rx_dbl: doorbell for rx notifications.
		@@ -52,10 +57,13 @@ struct qrtr_haven_dev {
		struct device *dev;
		void *buf;

		struct resource res;
		u32 memparcel;
		void *base;
		size_t size;
		bool master;
		u32 peer_name;
		struct notifier_block rm_nb;

		u32 label;
		void *tx_dbl;
		@@ -228,6 +236,81 @@ static void qrtr_haven_read(struct qrtr_haven_dev *qdev)
		}
		}

		static int qrtr_haven_share_mem(struct qrtr_haven_dev *qdev,
		hh_vmid_t self, hh_vmid_t peer)
		{
		u32 src_vmlist[1] = {self};
		int dst_vmlist[2] = {self, peer};
		int dst_perms[2] = {PERM_READ \| PERM_WRITE, PERM_READ \| PERM_WRITE};
		struct hh_acl_desc *acl;
		struct hh_sgl_desc *sgl;
		int ret;

		ret = hyp_assign_phys(qdev->res.start, resource_size(&qdev->res),
		src_vmlist, 1,
		dst_vmlist, dst_perms, 2);
		if (ret) {
		pr_err("%s: hyp_assign_phys failed addr=%x size=%u err=%d\n",
		__func__, qdev->res.start, qdev->size, ret);
		return ret;
		}

		acl = kzalloc(offsetof(struct hh_acl_desc, acl_entries[2]), GFP_KERNEL);
		if (!acl)
		return -ENOMEM;
		sgl = kzalloc(offsetof(struct hh_sgl_desc, sgl_entries[1]), GFP_KERNEL);
		if (!sgl) {
		kfree(acl);
		return -ENOMEM;
		}
		acl->n_acl_entries = 2;
		acl->acl_entries[0].vmid = (u16)self;
		acl->acl_entries[0].perms = HH_RM_ACL_R \| HH_RM_ACL_W;
		acl->acl_entries[1].vmid = (u16)peer;
		acl->acl_entries[1].perms = HH_RM_ACL_R \| HH_RM_ACL_W;

		sgl->n_sgl_entries = 1;
		sgl->sgl_entries[0].ipa_base = qdev->res.start;
		sgl->sgl_entries[0].size = resource_size(&qdev->res);
		ret = hh_rm_mem_qcom_lookup_sgl(HH_RM_MEM_TYPE_NORMAL,
		qdev->label,
		acl, sgl, NULL,
		&qdev->memparcel);
		kfree(acl);
		kfree(sgl);

		return ret;
		}

		static int qrtr_haven_rm_cb(struct notifier_block *nb, unsigned long cmd,
		void *data)
		{
		struct hh_rm_notif_vm_status_payload *vm_status_payload;
		struct qrtr_haven_dev *qdev;
		hh_vmid_t peer_vmid;
		hh_vmid_t self_vmid;

		qdev = container_of(nb, struct qrtr_haven_dev, rm_nb);

		if (cmd != HH_RM_NOTIF_VM_STATUS)
		return NOTIFY_DONE;

		vm_status_payload = data;
		if (vm_status_payload->vm_status != HH_RM_VM_STATUS_READY)
		return NOTIFY_DONE;
		if (hh_rm_get_vmid(qdev->peer_name, &peer_vmid))
		return NOTIFY_DONE;
		if (hh_rm_get_vmid(HH_PRIMARY_VM, &self_vmid))
		return NOTIFY_DONE;
		if (peer_vmid != vm_status_payload->vmid)
		return NOTIFY_DONE;

		if (qrtr_haven_share_mem(qdev, self_vmid, peer_vmid))
		pr_err("%s: failed to share memory\n", __func__);

		return NOTIFY_DONE;
		}

		/**
		* qrtr_haven_fifo_init() - init haven xprt configs
		*
		@@ -273,29 +356,61 @@ static void qrtr_haven_fifo_init(struct qrtr_haven_dev *qdev)
		*qdev->rx_pipe.tail = 0;
		}

		static struct device_node qrtr_haven_svm_of_parse(struct qrtr_haven_dev qdev)
		{
		const char *compat = "qcom,qrtr-haven-gen";
		struct device_node *np = NULL;
		struct device_node *shm_np;
		u32 label;
		int ret;

		while ((np = of_find_compatible_node(np, NULL, compat))) {
		ret = of_property_read_u32(np, "qcom,label", &label);
		if (ret) {
		of_node_put(np);
		continue;
		}
		if (label == qdev->label)
		break;

		of_node_put(np);
		}
		if (!np)
		return NULL;

		shm_np = of_parse_phandle(np, "memory-region", 0);
		if (!shm_np)
		dev_err(qdev->dev, "cant parse svm shared mem node!\n");

		of_node_put(np);
		return shm_np;
		}

		static int qrtr_haven_map_memory(struct qrtr_haven_dev *qdev)
		{
		struct device *dev = qdev->dev;
		struct device_node *np;
		resource_size_t size;
		struct resource r;
		int ret;

		np = of_parse_phandle(dev->of_node, "shared-buffer", 0);
		if (!np) {
		dev_err(dev, "shared-buffer node missing!\n");
		np = qrtr_haven_svm_of_parse(qdev);
		if (!np) {
		dev_err(dev, "cant parse shared mem node!\n");
		return -EINVAL;
		}
		}

		ret = of_address_to_resource(np, 0, &r);
		ret = of_address_to_resource(np, 0, &qdev->res);
		of_node_put(np);
		if (ret) {
		dev_err(dev, "of_address_to_resource failed!\n");
		return -EINVAL;
		}
		size = resource_size(&r);
		size = resource_size(&qdev->res);

		qdev->base = devm_ioremap_nocache(dev, r.start, size);
		qdev->base = devm_ioremap_nocache(dev, qdev->res.start, size);
		if (!qdev->base) {
		dev_err(dev, "ioremap failed!\n");
		return -ENXIO;
		@@ -349,6 +464,10 @@ static int qrtr_haven_probe(struct platform_device *pdev)
		ret = of_property_read_u32(node, "peer-name", &qdev->peer_name);
		if (ret)
		qdev->peer_name = HH_SELF_VM;

		qdev->rm_nb.notifier_call = qrtr_haven_rm_cb;
		qdev->rm_nb.priority = INT_MAX;
		hh_rm_register_notifier(&qdev->rm_nb);
		}

		dbl_label = qdev->label;