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

342 lines
8.8 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/slab.h>
#include <linux/io.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/debugfs.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <soc/qcom/subsystem_notif.h>
#include <soc/qcom/hvc.h>
#include "peripheral-loader.h"
#define hyp_dbg_err(fmt, ...) \
pr_err("%s: " fmt, "hyp-debug", ##__VA_ARGS__)
#define hyp_dbg_info(fmt, ...) \
pr_info("%s: " fmt, "hyp-debug", ##__VA_ARGS__)
#define HVC_FN_DBG_MAP_RANGE HVC_FN_SIP(1)
#define HVC_FN_DBG_UNMAP_RANGE HVC_FN_SIP(2)
#define MEM_PERM_EXECUTE BIT(0)
#define MEM_PERM_WRITE BIT(1)
#define MEM_PERM_READ BIT(2)
#define MEM_CACHE_nGnRnE 0x0
#define MEM_CACHE_nGnRE 0x1
#define MEM_CACHE_nGRE 0x2
#define MEM_CACHE_GRE 0x3
#define MEM_CACHE_ONC_INC 0x5
#define MEM_CACHE_ONC_IWT 0x6
#define MEM_CACHE_ONC_IWB 0x7
#define MEM_CACHE_OWT_INC 0x9
#define MEM_CACHE_OWT_IWT 0xA
#define MEM_CACHE_OWT_IWB 0xB
#define MEM_CACHE_OWB_INC 0xD
#define MEM_CACHE_OWB_IWT 0xE
#define MEM_CACHE_OWB_IWB 0xF
#define MEM_SHARE_NS 0x0
#define MEM_SHARE_OS 0x2
#define MEM_SHARE_IS 0x3
static u64 mem_addr, mem_size, mem_perm_attr, mem_cache_attr, mem_share_attr;
static int hyp_debug_mem_addr_get(void *data, u64 *val)
{
*val = mem_addr;
return 0;
}
static int hyp_debug_mem_addr_set(void *data, u64 val)
{
mem_addr = val;
return 0;
}
DEFINE_SIMPLE_ATTRIBUTE(hyp_debug_mem_addr_fops, hyp_debug_mem_addr_get,
hyp_debug_mem_addr_set, "%llu\n");
static int hyp_debug_mem_size_get(void *data, u64 *val)
{
*val = mem_size;
return 0;
}
static int hyp_debug_mem_size_set(void *data, u64 val)
{
mem_size = val;
return 0;
}
DEFINE_SIMPLE_ATTRIBUTE(hyp_debug_mem_size_fops, hyp_debug_mem_size_get,
hyp_debug_mem_size_set, "%llu\n");
static int hyp_debug_mem_perm_attr_get(void *data, u64 *val)
{
*val = mem_perm_attr;
return 0;
}
static int hyp_debug_mem_perm_attr_set(void *data, u64 val)
{
mem_perm_attr = val;
return 0;
}
DEFINE_SIMPLE_ATTRIBUTE(hyp_debug_mem_perm_attr_fops,
hyp_debug_mem_perm_attr_get,
hyp_debug_mem_perm_attr_set, "%llu\n");
static int hyp_debug_mem_cache_attr_get(void *data, u64 *val)
{
*val = mem_cache_attr;
return 0;
}
static int hyp_debug_mem_cache_attr_set(void *data, u64 val)
{
mem_cache_attr = val;
return 0;
}
DEFINE_SIMPLE_ATTRIBUTE(hyp_debug_mem_cache_attr_fops,
hyp_debug_mem_cache_attr_get,
hyp_debug_mem_cache_attr_set, "%llu\n");
static int hyp_debug_mem_share_attr_get(void *data, u64 *val)
{
*val = mem_share_attr;
return 0;
}
static int hyp_debug_mem_share_attr_set(void *data, u64 val)
{
mem_share_attr = val;
return 0;
}
DEFINE_SIMPLE_ATTRIBUTE(hyp_debug_mem_share_attr_fops,
hyp_debug_mem_share_attr_get,
hyp_debug_mem_share_attr_set, "%llu\n");
static int hyp_debug_mem_map_set(void *data, u64 val)
{
struct hvc_desc desc = { {0}, {0} };
int ret;
desc.arg[0] = mem_addr;
desc.arg[1] = mem_size;
desc.arg[2] = mem_perm_attr;
desc.arg[3] = mem_cache_attr;
desc.arg[4] = mem_share_attr;
ret = hvc(HVC_FN_DBG_MAP_RANGE, &desc);
if (ret)
hyp_dbg_err("user specified hvc map range failed: %d\n", ret);
return ret;
}
DEFINE_SIMPLE_ATTRIBUTE(hyp_debug_mem_map_fops, NULL, hyp_debug_mem_map_set,
"%llu\n");
static int hyp_debug_mem_unmap_set(void *data, u64 val)
{
struct hvc_desc desc = { {0}, {0} };
int ret;
desc.arg[0] = mem_addr;
desc.arg[1] = mem_size;
ret = hvc(HVC_FN_DBG_UNMAP_RANGE, &desc);
if (ret)
hyp_dbg_err("user specified hvc unmap range failed: %d\n", ret);
return ret;
}
DEFINE_SIMPLE_ATTRIBUTE(hyp_debug_mem_unmap_fops, NULL, hyp_debug_mem_unmap_set,
"%llu\n");
struct restart_notifier_block {
struct pil_image_info __iomem *pil_info;
struct notifier_block nb;
};
static struct restart_notifier_block *restart_nbs;
static int restart_notifier_cb(struct notifier_block *this, unsigned long code,
void *data)
{
struct restart_notifier_block *restart_nb;
struct hvc_desc desc = { {0}, {0} };
u64 addr;
u32 size;
int ret;
restart_nb = container_of(this, struct restart_notifier_block, nb);
switch (code) {
case SUBSYS_AFTER_POWERUP:
memcpy_fromio(&addr, &restart_nb->pil_info->start, sizeof(u64));
size = readl_relaxed(&restart_nb->pil_info->size);
desc.arg[0] = addr;
desc.arg[1] = size;
ret = hvc(HVC_FN_DBG_UNMAP_RANGE, &desc);
if (ret)
hyp_dbg_err("subsys hvc unmap range failed: %lu %d\n",
code, ret);
break;
case SUBSYS_BEFORE_SHUTDOWN:
memcpy_fromio(&addr, &restart_nb->pil_info->start, sizeof(u64));
size = readl_relaxed(&restart_nb->pil_info->size);
desc.arg[0] = addr;
desc.arg[1] = size;
desc.arg[2] = MEM_PERM_EXECUTE | MEM_PERM_WRITE | MEM_PERM_READ;
desc.arg[3] = MEM_CACHE_OWB_IWB;
desc.arg[4] = MEM_SHARE_NS;
ret = hvc(HVC_FN_DBG_MAP_RANGE, &desc);
if (ret)
hyp_dbg_err("subsys hvc map range failed: %lu %d\n",
code, ret);
break;
}
return NOTIFY_DONE;
}
static int __init hyp_debug_init(void)
{
struct device_node *np;
struct resource res;
struct dentry *debugfs_dir, *debugfs_file;
char subsys_name[FIELD_SIZEOF(struct pil_image_info, name)];
void __iomem *pil_info_base, __iomem *addr;
void *handle;
u32 nr_restart_nb;
int i, ret;
np = of_find_compatible_node(NULL, NULL, "qcom,msm-imem-pil");
if (!np) {
hyp_dbg_err("pil imem DT node does not exist\n");
return -ENODEV;
}
ret = of_address_to_resource(np, 0, &res);
if (ret)
return ret;
pil_info_base = ioremap(res.start, resource_size(&res));
if (!pil_info_base) {
hyp_dbg_err("pil info imem base offset mapping failed\n");
return -ENOMEM;
}
nr_restart_nb = resource_size(&res) / sizeof(struct pil_image_info);
restart_nbs = kzalloc(nr_restart_nb *
sizeof(struct restart_notifier_block), GFP_KERNEL);
if (!restart_nbs) {
ret = -ENOMEM;
hyp_dbg_err("restart notifiers allocation failed\n");
goto err0;
}
for (i = 0; i < nr_restart_nb; i++) {
addr = pil_info_base + sizeof(struct pil_image_info) * i;
restart_nbs[i].pil_info = (struct pil_image_info __iomem *)addr;
memcpy_fromio(subsys_name, restart_nbs[i].pil_info->name,
sizeof(restart_nbs[i].pil_info->name));
if (subsys_name[0] == '\0')
break;
restart_nbs[i].nb.notifier_call = restart_notifier_cb;
handle = subsys_notif_register_notifier(subsys_name,
&restart_nbs[i].nb);
if (IS_ERR_OR_NULL(handle)) {
ret = PTR_ERR(handle);
hyp_dbg_err("subsys notif register %d failed: %d\n", i,
ret);
goto err1;
}
}
mem_perm_attr = MEM_PERM_EXECUTE | MEM_PERM_WRITE | MEM_PERM_READ;
mem_cache_attr = MEM_CACHE_OWB_IWB;
mem_share_attr = MEM_SHARE_NS;
debugfs_dir = debugfs_create_dir("hyp_debug", NULL);
if (IS_ERR_OR_NULL(debugfs_dir)) {
ret = PTR_ERR(debugfs_dir);
goto err1;
}
debugfs_file = debugfs_create_file("mem_addr", S_IRUGO, debugfs_dir,
NULL, &hyp_debug_mem_addr_fops);
if (IS_ERR_OR_NULL(debugfs_file)) {
ret = PTR_ERR(debugfs_file);
goto err2;
}
debugfs_file = debugfs_create_file("mem_size", S_IRUGO, debugfs_dir,
NULL, &hyp_debug_mem_size_fops);
if (IS_ERR_OR_NULL(debugfs_file)) {
ret = PTR_ERR(debugfs_file);
goto err2;
}
debugfs_file = debugfs_create_file("mem_perm_attr", S_IRUGO,
debugfs_dir, NULL,
&hyp_debug_mem_perm_attr_fops);
if (IS_ERR_OR_NULL(debugfs_file)) {
ret = PTR_ERR(debugfs_file);
goto err2;
}
debugfs_file = debugfs_create_file("mem_cache_attr", S_IRUGO,
debugfs_dir, NULL,
&hyp_debug_mem_cache_attr_fops);
if (IS_ERR_OR_NULL(debugfs_file)) {
ret = PTR_ERR(debugfs_file);
goto err2;
}
debugfs_file = debugfs_create_file("mem_share_attr", S_IRUGO,
debugfs_dir, NULL,
&hyp_debug_mem_share_attr_fops);
if (IS_ERR_OR_NULL(debugfs_file)) {
ret = PTR_ERR(debugfs_file);
goto err2;
}
debugfs_file = debugfs_create_file("mem_map", S_IRUGO, debugfs_dir,
NULL, &hyp_debug_mem_map_fops);
if (IS_ERR_OR_NULL(debugfs_file)) {
ret = PTR_ERR(debugfs_file);
goto err2;
}
debugfs_file = debugfs_create_file("mem_unmap", S_IRUGO, debugfs_dir,
NULL, &hyp_debug_mem_unmap_fops);
if (IS_ERR_OR_NULL(debugfs_file)) {
ret = PTR_ERR(debugfs_file);
goto err2;
}
hyp_dbg_info("MSM Hyp Debug initialized\n");
return 0;
err2:
debugfs_remove_recursive(debugfs_dir);
err1:
for (i--; i >= 0; i--)
subsys_notif_unregister_notifier(handle, &restart_nbs[i].nb);
kfree(restart_nbs);
err0:
iounmap(pil_info_base);
return ret;
}
late_initcall(hyp_debug_init);