M7350/kernel/arch/arm/mach-msm/qdsp6v2/dsp_debug.c
2024-09-09 08:52:07 +00:00

262 lines
5.8 KiB
C

/* arch/arm/mach-msm/qdsp6/dsp_dump.c
*
* Copyright (C) 2009 Google, Inc.
* Author: Brian Swetland <swetland@google.com>
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* 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/io.h>
#include <linux/fs.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/uaccess.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <asm/atomic.h>
#include <mach/proc_comm.h>
#include <mach/debug_mm.h>
#include <mach/qdsp6v2/dsp_debug.h>
static wait_queue_head_t dsp_wait;
static int dsp_has_crashed;
static int dsp_wait_count;
static atomic_t dsp_crash_count = ATOMIC_INIT(0);
dsp_state_cb cb_ptr;
void q6audio_dsp_not_responding(void)
{
int i;
if (cb_ptr)
cb_ptr(DSP_STATE_CRASHED);
if (atomic_add_return(1, &dsp_crash_count) != 1) {
pr_err("q6audio_dsp_not_responding() \
- parking additional crasher...\n");
for (i = 0; i < 600; i++)
msleep(1000);
}
if (dsp_wait_count) {
dsp_has_crashed = 1;
wake_up(&dsp_wait);
while (dsp_has_crashed != 2)
wait_event(dsp_wait, dsp_has_crashed == 2);
} else {
pr_err("q6audio_dsp_not_responding() - no waiter?\n");
}
if (cb_ptr)
cb_ptr(DSP_STATE_CRASH_DUMP_DONE);
}
static int dsp_open(struct inode *inode, struct file *file)
{
return 0;
}
#define DSP_NMI_ADDR 0x28800010
static ssize_t dsp_write(struct file *file, const char __user *buf,
size_t count, loff_t *pos)
{
char cmd[32];
void __iomem *ptr;
void *mem_buffer;
if (count >= sizeof(cmd))
return -EINVAL;
if (copy_from_user(cmd, buf, count))
return -EFAULT;
cmd[count] = 0;
if ((count > 1) && (cmd[count-1] == '\n'))
cmd[count-1] = 0;
if (!strcmp(cmd, "wait-for-crash")) {
while (!dsp_has_crashed) {
int res;
dsp_wait_count++;
res = wait_event_interruptible(dsp_wait,
dsp_has_crashed);
if (res < 0) {
dsp_wait_count--;
return res;
}
}
/* assert DSP NMI */
mem_buffer = ioremap(DSP_NMI_ADDR, 0x16);
if (IS_ERR((void *)mem_buffer)) {
pr_err("%s:map_buffer failed, error = %ld\n", __func__,
PTR_ERR((void *)mem_buffer));
return -ENOMEM;
}
ptr = mem_buffer;
if (!ptr) {
pr_err("Unable to map DSP NMI\n");
return -EFAULT;
}
writel(0x1, (void *)ptr);
iounmap(mem_buffer);
} else if (!strcmp(cmd, "boom")) {
q6audio_dsp_not_responding();
} else if (!strcmp(cmd, "continue-crash")) {
dsp_has_crashed = 2;
wake_up(&dsp_wait);
} else {
pr_err("[%s:%s] unknown dsp_debug command: %s\n", __MM_FILE__,
__func__, cmd);
}
return count;
}
static unsigned copy_ok_count;
static uint32_t dsp_ram_size;
static uint32_t dsp_ram_base;
static ssize_t dsp_read(struct file *file, char __user *buf,
size_t count, loff_t *pos)
{
size_t actual = 0;
size_t mapsize = PAGE_SIZE;
unsigned addr;
void __iomem *ptr;
void *mem_buffer;
if ((dsp_ram_base == 0) || (dsp_ram_size == 0)) {
pr_err("[%s:%s] Memory Invalid or not initialized, Base = 0x%x,"
" size = 0x%x\n", __MM_FILE__,
__func__, dsp_ram_base, dsp_ram_size);
return -EINVAL;
}
if (*pos >= dsp_ram_size)
return 0;
if (*pos & (PAGE_SIZE - 1))
return -EINVAL;
addr = (*pos + dsp_ram_base);
/* don't blow up if we're unaligned */
if (addr & (PAGE_SIZE - 1))
mapsize *= 2;
while (count >= PAGE_SIZE) {
mem_buffer = ioremap(addr, mapsize);
if (IS_ERR((void *)mem_buffer)) {
pr_err("%s:map_buffer failed, error = %ld\n",
__func__, PTR_ERR((void *)mem_buffer));
return -ENOMEM;
}
ptr = mem_buffer;
if (!ptr) {
pr_err("[%s:%s] map error @ %x\n", __MM_FILE__,
__func__, addr);
return -EFAULT;
}
if (copy_to_user(buf, ptr, PAGE_SIZE)) {
iounmap(mem_buffer);
pr_err("[%s:%s] copy error @ %p\n", __MM_FILE__,
__func__, buf);
return -EFAULT;
}
copy_ok_count += PAGE_SIZE;
iounmap(mem_buffer);
addr += PAGE_SIZE;
buf += PAGE_SIZE;
actual += PAGE_SIZE;
count -= PAGE_SIZE;
}
*pos += actual;
return actual;
}
static int dsp_release(struct inode *inode, struct file *file)
{
return 0;
}
int dsp_debug_register(dsp_state_cb ptr)
{
if (ptr == NULL)
return -EINVAL;
cb_ptr = ptr;
return 0;
}
static int dspcrashd_probe(struct platform_device *pdev)
{
int rc = 0;
struct resource *res;
int *pdata;
pdata = pdev->dev.platform_data;
res = platform_get_resource_byname(pdev, IORESOURCE_DMA,
"msm_dspcrashd");
if (!res) {
pr_err("%s: failed to get resources for dspcrashd\n", __func__);
return -ENODEV;
}
dsp_ram_base = res->start;
dsp_ram_size = res->end - res->start;
pr_info("%s: Platform driver values: Base = 0x%x, Size = 0x%x,"
"pdata = 0x%x\n", __func__,
dsp_ram_base, dsp_ram_size, *pdata);
return rc;
}
static const struct file_operations dsp_fops = {
.owner = THIS_MODULE,
.open = dsp_open,
.read = dsp_read,
.write = dsp_write,
.release = dsp_release,
};
static struct miscdevice dsp_misc = {
.minor = MISC_DYNAMIC_MINOR,
.name = "dsp_debug",
.fops = &dsp_fops,
};
static struct platform_driver dspcrashd_driver = {
.probe = dspcrashd_probe,
.driver = { .name = "msm_dspcrashd"}
};
static int __init dsp_init(void)
{
int rc = 0;
init_waitqueue_head(&dsp_wait);
rc = platform_driver_register(&dspcrashd_driver);
if (IS_ERR_VALUE(rc)) {
pr_err("%s: platform_driver_register for dspcrashd failed\n",
__func__);
}
return misc_register(&dsp_misc);
}
static int __exit dsp_exit(void)
{
platform_driver_unregister(&dspcrashd_driver);
return 0;
}
device_initcall(dsp_init);