| /* Copyright (c) 2014, 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/export.h> |
| #include <linux/err.h> |
| #include <linux/platform_device.h> |
| #include <linux/slab.h> |
| #include <linux/of.h> |
| #include <linux/of_platform.h> |
| #include <linux/of_address.h> |
| #include <linux/dma-contiguous.h> |
| #include <soc/qcom/scm.h> |
| |
| #define SHARED_HEAP_SVC_ID 0x2 |
| #define SHARED_HEAP_CMD_ID 0xB |
| #define SHARED_HEAP_TYPE_READ 0x1 |
| #define SHARED_HEAP_TYPE_WRITE 0x2 |
| |
| static int msm_shared_heap_unlock(dma_addr_t base, |
| size_t size, unsigned int proc_type) |
| { |
| int rc; |
| struct shared_heap_unlock { |
| u32 start; |
| u32 size; |
| u32 proc; |
| u32 share_type; |
| } request; |
| int resp = 0; |
| struct scm_desc desc = {0}; |
| |
| desc.arginfo = SCM_ARGS(4); |
| desc.args[0] = request.start = base; |
| desc.args[1] = request.size = size; |
| desc.args[2] = request.proc = proc_type; |
| desc.args[3] = request.share_type = SHARED_HEAP_TYPE_READ | |
| SHARED_HEAP_TYPE_WRITE; |
| if (!is_scm_armv8()) |
| rc = scm_call(SHARED_HEAP_SVC_ID, SHARED_HEAP_CMD_ID, &request, |
| sizeof(request), &resp, 1); |
| else |
| rc = scm_call2(SCM_SIP_FNID(SHARED_HEAP_SVC_ID, |
| SHARED_HEAP_CMD_ID), &desc); |
| |
| if (rc) |
| pr_err("shared_heap: Failed to unlock the shared heap %d\n", |
| rc); |
| return rc; |
| } |
| |
| static int msm_shared_heap_populate_base_and_size |
| (struct device_node *node, size_t *size, |
| dma_addr_t *base, struct device *priv) |
| { |
| int ret = 0; |
| struct device_node *pnode; |
| pnode = of_parse_phandle(node, "linux,contiguous-region", 0); |
| if (pnode != NULL) { |
| const u32 *addr; |
| u64 len; |
| |
| addr = of_get_address(pnode, 0, &len, NULL); |
| if (!addr) { |
| of_node_put(pnode); |
| ret = -EINVAL; |
| goto out; |
| } |
| *size = cma_get_size(priv); |
| *base = cma_get_base(priv); |
| of_node_put(pnode); |
| } else { |
| pr_err("%s: Unable to parse phandle\n", __func__); |
| ret = -EINVAL; |
| } |
| out: |
| return ret; |
| } |
| |
| static int get_heap_and_unlock(struct platform_device *pdev) |
| { |
| struct device_node *node = pdev->dev.of_node; |
| struct device *priv; |
| dma_addr_t base; |
| size_t size; |
| int proc_type; |
| int ret = 0; |
| |
| priv = &pdev->dev; |
| |
| ret = msm_shared_heap_populate_base_and_size(node, &size, &base, priv); |
| if (ret) |
| return ret; |
| |
| ret = of_property_read_u32(node, "qcom,proc-id", &proc_type); |
| if (ret) { |
| pr_err("Unable to find the proc_type\n"); |
| return ret; |
| } |
| |
| ret = msm_shared_heap_unlock(base, size, proc_type); |
| if (ret) |
| pr_err("%s: Cannot unlock memory %pa of size %zx, error = %d\n", |
| __func__, &base, size, ret); |
| else |
| pr_info("shared_mem: Unlocked memory %pa of size %zx\n", |
| &base, size); |
| |
| return ret; |
| } |
| |
| static int msm_shared_memory_probe(struct platform_device *pdev) |
| { |
| int ret = 0; |
| |
| if (pdev->dev.of_node) |
| ret = get_heap_and_unlock(pdev); |
| |
| if (ret) |
| pr_err("%s: Unable to unlock heap due to error %d\n", |
| __func__, ret); |
| |
| return ret; |
| } |
| |
| static int msm_shared_memory_remove(struct platform_device *pdev) |
| { |
| return 0; |
| } |
| |
| static struct of_device_id msm_shared_memory_table[] = { |
| {.compatible = "qcom,msm-shared-memory", |
| }, |
| {} |
| }; |
| |
| static struct platform_driver msm_shared_memory = { |
| .probe = msm_shared_memory_probe, |
| .remove = msm_shared_memory_remove, |
| .driver = { |
| .name = "msm-shared-memory", |
| .of_match_table = msm_shared_memory_table, |
| }, |
| }; |
| |
| static int __init msm_shared_memory_init(void) |
| { |
| return platform_driver_register(&msm_shared_memory); |
| } |
| |
| static void __exit msm_shared_memory_exit(void) |
| { |
| platform_driver_unregister(&msm_shared_memory); |
| }; |
| |
| subsys_initcall(msm_shared_memory_init); |
| module_exit(msm_shared_memory_exit); |
| |