android_kernel_samsung_hero.../drivers/soc/qcom/shared_memory.c
2016-08-17 16:41:52 +08:00

159 lines
3.6 KiB
C

/* 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;
request.start = base;
request.size = size;
request.proc = proc_type;
request.share_type = SHARED_HEAP_TYPE_READ |
SHARED_HEAP_TYPE_WRITE;
rc = scm_call(SHARED_HEAP_SVC_ID, SHARED_HEAP_CMD_ID, &request,
sizeof(request), &resp, 1);
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 = (size_t)len;
*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);