dsp: support mdf memory share cmd (542582cb) · Commits · e / devices / android_kernel_xiaomi_nabu

dsp/Kbuild

+4 −0

Original line number	Diff line number	Diff line
		@@ -123,6 +123,10 @@ ifdef CONFIG_MSM_ULTRASOUND
		USF_OBJS += usf.o usfcdev.o q6usm.o
		endif

		ifdef CONFIG_MSM_MDF
		Q6_OBJS += msm_mdf.o
		endif

		LINUX_INC += -Iinclude/linux

		INCS += $(COMMON_INC) \

dsp/msm_audio_ion.c

+22 −0

Original line number	Diff line number	Diff line
		@@ -220,6 +220,28 @@ static int msm_audio_ion_get_phys(struct dma_buf *dma_buf,
		return rc;
		}

		int msm_audio_ion_get_smmu_info(struct device **cb_dev,
		u64 *smmu_sid)
		{
		if (!cb_dev \|\| !smmu_sid) {
		pr_err("%s: Invalid params\n",
		__func__);
		return -EINVAL;
		}

		if (!msm_audio_ion_data.cb_dev \|\|
		!msm_audio_ion_data.smmu_sid_bits) {
		pr_err("%s: Params not initialized\n",
		__func__);
		return -EINVAL;
		}

		*cb_dev = msm_audio_ion_data.cb_dev;
		*smmu_sid = msm_audio_ion_data.smmu_sid_bits;

		return 0;
		}

		static void msm_audio_ion_map_kernel(struct dma_buf dma_buf)
		{
		int rc = 0;

dsp/msm_mdf.c

0 → 100644

+637 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (c) 2018, The Linux Foundation. All rights reserved.
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 and
		* only 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.
		*
		*/
		#include <linux/init.h>
		#include <linux/kernel.h>
		#include <linux/module.h>
		#include <linux/err.h>
		#include <linux/clk.h>
		#include <linux/delay.h>
		#include <linux/slab.h>
		#include <linux/list.h>
		#include <linux/scatterlist.h>
		#include <linux/dma-mapping.h>
		#include <linux/dma-buf.h>
		#include <linux/iommu.h>
		#include <linux/platform_device.h>
		#include <linux/of_device.h>
		#include <linux/ion_kernel.h>
		#include <linux/msm_ion.h>
		#include <dsp/msm_audio_ion.h>
		#include <ipc/apr.h>
		#include <dsp/msm_mdf.h>
		#include <asm/dma-iommu.h>
		#include <soc/qcom/secure_buffer.h>
		#include <soc/qcom/subsystem_notif.h>
		#include <soc/qcom/subsystem_restart.h>
		#include <dsp/q6audio-v2.h>
		#include <dsp/q6core.h>

		#define VMID_SSC_Q6 5
		#define VMID_LPASS 6
		#define VMID_MSS_MSA 15
		#define VMID_CDSP 8

		#define MSM_MDF_PROBED (1 << 0)
		#define MSM_MDF_INITIALIZED (1 << 1)
		#define MSM_MDF_MEM_ALLOCATED (1 << 2)
		#define MSM_MDF_MEM_MAPPED (1 << 3)
		#define MSM_MDF_MEM_PERMISSION (1 << 4) /* 0 - HLOS, 1 - Subsys */

		/* TODO: Update IOVA range for subsys SMMUs */
		#define MSM_MDF_IOVA_START 0x80000000
		#define MSM_MDF_IOVA_LEN 0x800000

		#define MSM_MDF_SMMU_SID_OFFSET 32

		#define ADSP_STATE_READY_TIMEOUT_MS 3000

		enum {
		SUBSYS_ADSP, /* Audio DSP must have index 0 */
		SUBSYS_SCC, /* Sensor DSP */
		SUBSYS_MSS, /* Modem DSP */
		SUBSYS_CDSP, /* Compute DSP */
		SUBSYS_MAX,
		};

		struct msm_mdf_mem {
		struct device *dev;
		uint8_t device_status;
		uint32_t map_handle;
		struct dma_buf *dma_buf;
		dma_addr_t dma_addr;
		size_t size;
		void *va;
		};

		static struct msm_mdf_mem mdf_mem_data = {NULL,};

		struct msm_mdf_smmu {
		bool enabled;
		char *subsys;
		int vmid;
		uint32_t proc_id;
		struct device *cb_dev;
		uint8_t device_status;
		uint64_t sid;
		struct dma_iommu_mapping *mapping;
		dma_addr_t pa;
		size_t pa_len;
		};

		static struct msm_mdf_smmu mdf_smmu_data[SUBSYS_MAX] = {
		{
		.subsys = "adsp",
		.vmid = VMID_LPASS,
		},
		{
		.subsys = "dsps",
		.vmid = VMID_SSC_Q6,
		.proc_id = AVS_MDF_SSC_PROC_ID,
		},
		{
		.subsys = "modem",
		.vmid = VMID_MSS_MSA,
		.proc_id = AVS_MDF_MDSP_PROC_ID,
		},
		{
		.subsys = "cdsp",
		.vmid = VMID_CDSP,
		.proc_id = AVS_MDF_CDSP_PROC_ID,
		},
		};

		static void *ssr_handle;

		static inline uint64_t buf_page_start(uint64_t buf)
		{
		uint64_t start = (uint64_t) buf & PAGE_MASK;
		return start;
		}

		static inline uint64_t buf_page_offset(uint64_t buf)
		{
		uint64_t offset = (uint64_t) buf & (PAGE_SIZE - 1);
		return offset;
		}

		static inline int buf_num_pages(uint64_t buf, ssize_t len)
		{
		uint64_t start = buf_page_start(buf) >> PAGE_SHIFT;
		uint64_t end = (((uint64_t) buf + len - 1) & PAGE_MASK) >> PAGE_SHIFT;
		int nPages = end - start + 1;
		return nPages;
		}

		static inline uint64_t buf_page_size(uint32_t size)
		{
		uint64_t sz = (size + (PAGE_SIZE - 1)) & PAGE_MASK;

		return sz > PAGE_SIZE ? sz : PAGE_SIZE;
		}

		static inline void *uint64_to_ptr(uint64_t addr)
		{
		void ptr = (void )((uintptr_t)addr);
		return ptr;
		}

		static inline uint64_t ptr_to_uint64(void *ptr)
		{
		uint64_t addr = (uint64_t)((uintptr_t)ptr);
		return addr;
		}

		static int msm_mdf_dma_buf_map(struct msm_mdf_mem *mem,
		struct msm_mdf_smmu *smmu)
		{
		int rc = 0;

		if (!smmu)
		return -EINVAL;
		if (smmu->device_status & MSM_MDF_MEM_MAPPED)
		return 0;
		if (smmu->enabled) {
		if (smmu->cb_dev == NULL) {
		pr_err("%s: cb device is not initialized\n",
		__func__);
		/* Retry if LPASS cb device is not ready
		* from audio ION during probing.
		*/
		if (!strcmp("adsp", smmu->subsys)) {
		rc = msm_audio_ion_get_smmu_info(&smmu->cb_dev,
		&smmu->sid);
		if (rc) {
		pr_err("%s: msm_audio_ion_get_smmu_info failed, rc = %d\n",
		__func__, rc);
		goto err;
		}
		} else
		return -ENODEV;
		}

		smmu->pa = dma_map_single(smmu->cb_dev, mem->va,
		mem->size, DMA_BIDIRECTIONAL);
		if (dma_mapping_error(smmu->cb_dev, smmu->pa)) {
		rc = -ENOMEM;
		pr_err("%s: failed to map single, rc = %d\n",
		__func__, rc);
		goto err;
		}
		smmu->pa_len = mem->size;

		/* Append the SMMU SID information to the IOVA address */
		if (smmu->sid)
		smmu->pa \|= smmu->sid;
		} else {
		smmu->pa = mem->dma_addr;
		smmu->pa_len = mem->size;
		}
		pr_err("%s: pa=%pa, pa_len=%zd\n", __func__,
		&smmu->pa, smmu->pa_len);

		smmu->device_status \|= MSM_MDF_MEM_MAPPED;

		return 0;
		err:
		return rc;
		}

		static int msm_mdf_alloc_dma_buf(struct msm_mdf_mem *mem)
		{
		int rc = 0;

		if (!mem)
		return -EINVAL;

		if (mem->device_status & MSM_MDF_MEM_ALLOCATED)
		return 0;

		if (mem->dev == NULL) {
		pr_err("%s: device is not initialized\n",
		__func__);
		return -ENODEV;
		}

		mem->va = dma_alloc_coherent(mem->dev, mem->size,
		&mem->dma_addr, GFP_KERNEL);
		if (IS_ERR_OR_NULL(mem->va)) {
		pr_err("%s: failed to allocate dma memory, rc = %d\n",
		__func__, rc);
		return -ENOMEM;
		}
		mem->va = phys_to_virt(mem->dma_addr);
		mem->device_status \|= MSM_MDF_MEM_ALLOCATED;
		return rc;
		}

		static int msm_mdf_free_dma_buf(struct msm_mdf_mem *mem)
		{
		if (!mem)
		return -EINVAL;

		if (mem->dev == NULL) {
		pr_err("%s: device is not initialized\n",
		__func__);
		return -ENODEV;
		}

		//dma_free_coherent(mem->dev, mem->size, mem->va,
		// mem->dma_addr);

		mem->device_status &= ~MSM_MDF_MEM_ALLOCATED;
		return 0;
		}

		static int msm_mdf_dma_buf_unmap(struct msm_mdf_mem *mem,
		struct msm_mdf_smmu *smmu)
		{
		if (!smmu)
		return -EINVAL;

		if (smmu->enabled) {
		if (smmu->cb_dev == NULL) {
		pr_err("%s: cb device is not initialized\n",
		__func__);
		return -ENODEV;
		}
		//if (smmu->pa && mem->size)
		//dma_unmap_single(smmu->cb_dev, smmu->pa,
		// mem->size, DMA_BIDIRECTIONAL);
		}

		smmu->device_status &= ~MSM_MDF_MEM_MAPPED;

		return 0;
		}

		static int msm_mdf_map_memory_to_subsys(struct msm_mdf_mem *mem,
		struct msm_mdf_smmu *smmu)
		{
		int rc = 0;

		if (!mem \|\| !smmu)
		return -EINVAL;

		/* Map mdf shared memory to ADSP */
		if (!strcmp("adsp", smmu->subsys)) {
		rc = q6core_map_memory_regions((phys_addr_t *)&smmu->pa,
		ADSP_MEMORY_MAP_MDF_SHMEM_4K_POOL,
		(uint32_t *)&smmu->pa_len, 1, &mem->map_handle);
		if (rc) {
		pr_err("%s: q6core_map_memory_regions failed, rc = %d\n",
		__func__, rc);
		}
		} else {
		if (mem->map_handle) {
		/* Map mdf shared memory to remote DSPs */
		rc = q6core_map_mdf_shared_memory(mem->map_handle,
		(phys_addr_t *)&smmu->pa, smmu->proc_id,
		(uint32_t *)&smmu->pa_len, 1);
		if (rc) {
		pr_err("%s: q6core_map_mdf_shared_memory failed, rc = %d\n",
		__func__, rc);
		}
		}
		}
		return rc;
		}

		static void msm_mdf_unmap_memory_to_subsys(struct msm_mdf_mem *mem,
		struct msm_mdf_smmu *smmu)
		{
		if (!mem \|\| !smmu)
		return;

		if (!strcmp("adsp", smmu->subsys)) {
		if (mem->map_handle)
		q6core_memory_unmap_regions(mem->map_handle);
		}
		}

		/**
		* msm_mdf_mem_init - Initializes MDF memory pool and
		* map memory to subsystem
		*
		* Returns 0 on success or ret on failure.
		*/

		int msm_mdf_mem_init(void)
		{
		int rc = 0, i, j;
		struct msm_mdf_mem *mem = &mdf_mem_data;
		struct msm_mdf_smmu *smmu;
		unsigned long timeout = jiffies +
		msecs_to_jiffies(ADSP_STATE_READY_TIMEOUT_MS);
		int adsp_ready = 0;

		if (!(mdf_mem_data.device_status & MSM_MDF_PROBED))
		return -ENODEV;

		if (mdf_mem_data.device_status & MSM_MDF_INITIALIZED)
		return 0;

		/* TODO: pulling may not be needed as Q6 Core state should be
		* checked during machine driver probing.
		*/
		do {
		if (!q6core_is_adsp_ready()) {
		pr_err("%s: ADSP Audio NOT Ready\n",
		__func__);
		/* ADSP will be coming up after subsystem restart and
		* it might not be fully up when the control reaches
		* here. So, wait for 50msec before checking ADSP state
		*/
		msleep(50);
		} else {
		pr_debug("%s: ADSP Audio Ready\n",
		__func__);
		adsp_ready = 1;
		break;
		}
		} while (time_after(timeout, jiffies));

		if (!adsp_ready) {
		pr_err("%s: timed out waiting for ADSP Audio\n",
		__func__);
		return -ETIMEDOUT;
		}

		if (mem->device_status & MSM_MDF_MEM_ALLOCATED) {
		for (i = 0; i < SUBSYS_MAX; i++) {
		smmu = &mdf_smmu_data[i];
		rc = msm_mdf_dma_buf_map(mem, smmu);
		if (rc) {
		pr_err("%s: msm_mdf_dma_buf_map failed, rc = %d\n",
		__func__, rc);
		goto err;
		}
		}

		for (j = 0; j < SUBSYS_MAX; j++) {
		smmu = &mdf_smmu_data[j];
		rc = msm_mdf_map_memory_to_subsys(mem, smmu);
		if (rc) {
		pr_err("%s: msm_mdf_map_memory_to_subsys failed\n",
		__func__);
		goto err;
		}
		}

		mdf_mem_data.device_status \|= MSM_MDF_INITIALIZED;
		}
		return 0;
		err:
		return rc;
		}
		EXPORT_SYMBOL(msm_mdf_mem_init);

		int msm_mdf_mem_deinit(void)
		{
		int rc = 0, i;
		struct msm_mdf_mem *mem = &mdf_mem_data;
		struct msm_mdf_smmu *smmu;

		if (!(mdf_mem_data.device_status & MSM_MDF_INITIALIZED))
		return -ENODEV;

		for (i = SUBSYS_MAX - 1; i >= 0; i--) {
		smmu = &mdf_smmu_data[i];
		msm_mdf_unmap_memory_to_subsys(mem, smmu);
		}

		if (!rc) {
		for (i = SUBSYS_MAX - 1; i >= 0; i--) {
		smmu = &mdf_smmu_data[i];
		msm_mdf_dma_buf_unmap(mem, smmu);
		}

		msm_mdf_free_dma_buf(mem);
		mem->device_status &= ~MSM_MDF_MEM_ALLOCATED;
		}

		mdf_mem_data.device_status &= ~MSM_MDF_INITIALIZED;

		return 0;
		}
		EXPORT_SYMBOL(msm_mdf_mem_deinit);

		static int msm_mdf_restart_notifier_cb(struct notifier_block *this,
		unsigned long code,
		void *_cmd)
		{
		static int boot_count = 3;

		/* During LPASS boot, HLOS receives events:
		* SUBSYS_BEFORE_POWERUP
		* SUBSYS_PROXY_VOTE
		* SUBSYS_AFTER_POWERUP - need skip
		* SUBSYS_PROXY_UNVOTE
		*/
		if (boot_count) {
		boot_count--;
		return NOTIFY_OK;
		}

		switch (code) {
		case SUBSYS_BEFORE_SHUTDOWN:
		pr_debug("Subsys Notify: Shutdown Started\n");
		/* Unmap and free memory upon restart event. */
		msm_mdf_mem_deinit();
		break;
		case SUBSYS_AFTER_SHUTDOWN:
		pr_debug("Subsys Notify: Shutdown Completed\n");
		break;
		case SUBSYS_BEFORE_POWERUP:
		pr_debug("Subsys Notify: Bootup Started\n");
		break;
		case SUBSYS_AFTER_POWERUP:
		pr_debug("Subsys Notify: Bootup Completed\n");
		/* Allocate and map memory after restart complete. */
		if (msm_mdf_mem_init())
		pr_err("msm_mdf_mem_init failed\n");
		break;
		default:
		pr_err("Subsys Notify: Generel: %lu\n", code);
		break;
		}
		return NOTIFY_DONE;
		}

		static const struct of_device_id msm_mdf_match_table[] = {
		{ .compatible = "qcom,msm-mdf", },
		{ .compatible = "qcom,msm-mdf-mem-region", },
		{ .compatible = "qcom,msm-mdf-cb", },
		{}
		};
		MODULE_DEVICE_TABLE(of, msm_mdf_match_table);

		static int msm_mdf_cb_probe(struct device *dev)
		{
		struct msm_mdf_smmu *smmu;
		const char *subsys;
		int rc = 0, i;

		subsys = of_get_property(dev->of_node, "label", NULL);
		if (!subsys) {
		dev_err(dev, "%s: could not get label\n",
		__func__);
		return -EINVAL;
		}

		for (i = 0; i < SUBSYS_MAX; i++) {
		if (!mdf_smmu_data[i].subsys)
		continue;
		if (!strcmp(subsys, mdf_smmu_data[i].subsys))
		break;
		}
		if (i >= SUBSYS_MAX) {
		dev_err(dev, "%s: subsys %s not supported\n",
		__func__, subsys);
		return -EINVAL;
		}

		smmu = &mdf_smmu_data[i];

		smmu->enabled = of_property_read_bool(dev->of_node,
		"qcom,smmu-enabled");

		dev_info(dev, "%s: SMMU is %s for %s\n", __func__,
		(smmu->enabled) ? "enabled" : "disabled",
		smmu->subsys);

		if (smmu->enabled) {
		if (!strcmp("adsp", smmu->subsys)) {
		/* Get SMMU info from audio ION */
		rc = msm_audio_ion_get_smmu_info(&smmu->cb_dev,
		&smmu->sid);
		if (rc) {
		dev_err(dev, "%s: msm_audio_ion_get_smmu_info failed, rc = %d\n",
		__func__, rc);
		goto err;
		}
		}
		} else {
		/* Setup SMMU CB if enabled for subsys other than ADSP */
		}
		return 0;
		err:
		return rc;
		}

		static int msm_mdf_remove(struct platform_device *pdev)
		{
		int rc = 0, i;

		for (i = 0; i < SUBSYS_MAX; i++) {
		if (!IS_ERR_OR_NULL(mdf_smmu_data[i].cb_dev))
		arm_iommu_detach_device(mdf_smmu_data[i].cb_dev);
		if (!IS_ERR_OR_NULL(mdf_smmu_data[i].mapping))
		arm_iommu_release_mapping(mdf_smmu_data[i].mapping);
		mdf_smmu_data[i].enabled = 0;
		}
		mdf_mem_data.device_status = 0;

		return rc;
		}

		static int msm_mdf_probe(struct platform_device *pdev)
		{
		int rc = 0;
		enum apr_subsys_state q6_state;
		struct device *dev = &pdev->dev;
		uint32_t mdf_mem_data_size = 0;

		/* TODO: MDF probing should have no dependency
		* on ADSP Q6 state.
		*/
		q6_state = apr_get_q6_state();
		if (q6_state == APR_SUBSYS_DOWN) {
		dev_dbg(dev, "defering %s, adsp_state %d\n",
		__func__, q6_state);
		rc = -EPROBE_DEFER;
		goto err;
		} else
		dev_dbg(dev, "%s: adsp is ready\n", __func__);

		if (of_device_is_compatible(dev->of_node,
		"qcom,msm-mdf-cb"))
		return msm_mdf_cb_probe(dev);

		if (of_device_is_compatible(dev->of_node,
		"qcom,msm-mdf-mem-region")) {
		mdf_mem_data.dev = dev;

		rc = of_property_read_u32(dev->of_node,
		"qcom,msm-mdf-mem-data-size",
		&mdf_mem_data_size);
		if (rc) {
		dev_dbg(&pdev->dev, "MDF mem data size entry not found\n");
		goto err;
		}

		mdf_mem_data.size = mdf_mem_data_size;
		dev_info(dev, "%s: mem region size %zd\n",
		__func__, mdf_mem_data.size);
		msm_mdf_alloc_dma_buf(&mdf_mem_data);
		return 0;
		}

		rc = of_platform_populate(pdev->dev.of_node,
		msm_mdf_match_table,
		NULL, &pdev->dev);
		if (rc) {
		dev_err(&pdev->dev, "%s: failed to populate child nodes",
		__func__);
		goto err;
		}
		mdf_mem_data.device_status \|= MSM_MDF_PROBED;

		err:
		return rc;
		}

		static struct platform_driver msm_mdf_driver = {
		.probe = msm_mdf_probe,
		.remove = msm_mdf_remove,
		.driver = {
		.name = "msm-mdf",
		.owner = THIS_MODULE,
		.of_match_table = msm_mdf_match_table,
		},
		};

		static struct notifier_block nb = {
		.priority = 0,
		.notifier_call = msm_mdf_restart_notifier_cb,
		};

		int __init msm_mdf_init(void)
		{
		/* Only need to monitor SSR from ADSP, which
		* is the master DSP managing MDF memory.
		*/
		ssr_handle = subsys_notif_register_notifier("adsp", &nb);
		return platform_driver_register(&msm_mdf_driver);
		}

		void __exit msm_mdf_exit(void)
		{
		platform_driver_unregister(&msm_mdf_driver);

		if (ssr_handle)
		subsys_notif_unregister_notifier(ssr_handle, &nb);
		}

		MODULE_DESCRIPTION("MSM MDF Module");
		MODULE_LICENSE("GPL v2");

dsp/q6_init.c

+2 −0

Original line number	Diff line number	Diff line
		@@ -30,11 +30,13 @@ static int __init audio_q6_init(void)
		msm_audio_ion_init();
		audio_slimslave_init();
		avtimer_init();
		msm_mdf_init();
		return 0;
		}

		static void __exit audio_q6_exit(void)
		{
		msm_mdf_exit();
		avtimer_exit();
		audio_slimslave_exit();
		msm_audio_ion_exit();

dsp/q6_init.h

+14 −0

Original line number	Diff line number	Diff line
		@@ -26,6 +26,20 @@ int rtac_init(void);
		int msm_audio_ion_init(void);
		int audio_slimslave_init(void);
		int avtimer_init(void);
		#ifdef CONFIG_MSM_MDF
		int msm_mdf_init(void);
		void msm_mdf_exit(void);
		#else
		static inline int msm_mdf_init(void)
		{
		return 0;
		}

		static inline void msm_mdf_exit(void)
		{
		return;
		}
		#endif

		void avtimer_exit(void);
		void audio_slimslave_exit(void);