mirror of
https://github.com/linux-sunxi/meta-sunxi.git
synced 2024-11-08 14:28:22 +01:00
1553 lines
41 KiB
Diff
1553 lines
41 KiB
Diff
From ad291f3fffe361a3a424f9a892475b6343870ed9 Mon Sep 17 00:00:00 2001
|
|
From: afaulkner420 <afaulkner420@gmail.com>
|
|
Date: Fri, 25 Mar 2022 19:28:00 +0000
|
|
Subject: [PATCH 03/11] Add dump_reg and sunxi-sysinfo drivers
|
|
|
|
---
|
|
drivers/char/Kconfig | 2 +
|
|
drivers/char/Makefile | 2 +
|
|
drivers/char/dump_reg/Kconfig | 21 +
|
|
drivers/char/dump_reg/Makefile | 2 +
|
|
drivers/char/dump_reg/dump_reg.c | 888 +++++++++++++++++++++
|
|
drivers/char/dump_reg/dump_reg.h | 132 +++
|
|
drivers/char/dump_reg/dump_reg_misc.c | 209 +++++
|
|
drivers/char/sunxi-sysinfo/Kconfig | 10 +
|
|
drivers/char/sunxi-sysinfo/Makefile | 5 +
|
|
drivers/char/sunxi-sysinfo/sunxi-sysinfo.c | 178 +++++
|
|
10 files changed, 1449 insertions(+)
|
|
create mode 100644 drivers/char/dump_reg/Kconfig
|
|
create mode 100644 drivers/char/dump_reg/Makefile
|
|
create mode 100644 drivers/char/dump_reg/dump_reg.c
|
|
create mode 100644 drivers/char/dump_reg/dump_reg.h
|
|
create mode 100644 drivers/char/dump_reg/dump_reg_misc.c
|
|
create mode 100644 drivers/char/sunxi-sysinfo/Kconfig
|
|
create mode 100644 drivers/char/sunxi-sysinfo/Makefile
|
|
create mode 100644 drivers/char/sunxi-sysinfo/sunxi-sysinfo.c
|
|
|
|
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
|
|
index 740811893..e8d6b5cb1 100644
|
|
--- a/drivers/char/Kconfig
|
|
+++ b/drivers/char/Kconfig
|
|
@@ -131,6 +131,8 @@ config POWERNV_OP_PANEL
|
|
If unsure, say M here to build it as a module called powernv-op-panel.
|
|
|
|
source "drivers/char/ipmi/Kconfig"
|
|
+source "drivers/char/sunxi-sysinfo/Kconfig"
|
|
+source "drivers/char/dump_reg/Kconfig"
|
|
|
|
config DS1620
|
|
tristate "NetWinder thermometer support"
|
|
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
|
|
index 264eb398f..c638d4426 100644
|
|
--- a/drivers/char/Makefile
|
|
+++ b/drivers/char/Makefile
|
|
@@ -11,6 +11,7 @@ obj-$(CONFIG_VIRTIO_CONSOLE) += virtio_console.o
|
|
obj-$(CONFIG_MSPEC) += mspec.o
|
|
obj-$(CONFIG_UV_MMTIMER) += uv_mmtimer.o
|
|
obj-$(CONFIG_IBM_BSR) += bsr.o
|
|
+obj-$(CONFIG_ARCH_SUNXI) += sunxi-sysinfo/
|
|
|
|
obj-$(CONFIG_PRINTER) += lp.o
|
|
|
|
@@ -46,3 +47,4 @@ obj-$(CONFIG_PS3_FLASH) += ps3flash.o
|
|
obj-$(CONFIG_XILLYBUS_CLASS) += xillybus/
|
|
obj-$(CONFIG_POWERNV_OP_PANEL) += powernv-op-panel.o
|
|
obj-$(CONFIG_ADI) += adi.o
|
|
+obj-$(CONFIG_DUMP_REG) += dump_reg/
|
|
diff --git a/drivers/char/dump_reg/Kconfig b/drivers/char/dump_reg/Kconfig
|
|
new file mode 100644
|
|
index 000000000..dbf24c59f
|
|
--- /dev/null
|
|
+++ b/drivers/char/dump_reg/Kconfig
|
|
@@ -0,0 +1,21 @@
|
|
+#
|
|
+# dump reg config.
|
|
+#
|
|
+
|
|
+config DUMP_REG
|
|
+ tristate "dump reg driver for sunxi platform"
|
|
+ default y
|
|
+ help
|
|
+ Say y here if you want to support dump regs module.
|
|
+ The dump regs module is used to dump regs of any devices
|
|
+ if you want it, When in doubt, say "Y".
|
|
+
|
|
+config DUMP_REG_MISC
|
|
+ tristate "dump reg misc driver"
|
|
+ depends on DUMP_REG
|
|
+ default y
|
|
+ help
|
|
+ Add misc driver support, you can use dump regs function
|
|
+ via ("/sys/class/...") sysfs interface.
|
|
+ When in doubt, say "Y".
|
|
+
|
|
diff --git a/drivers/char/dump_reg/Makefile b/drivers/char/dump_reg/Makefile
|
|
new file mode 100644
|
|
index 000000000..e953f413b
|
|
--- /dev/null
|
|
+++ b/drivers/char/dump_reg/Makefile
|
|
@@ -0,0 +1,2 @@
|
|
+obj-$(CONFIG_DUMP_REG) += dump_reg.o
|
|
+obj-$(CONFIG_DUMP_REG_MISC) += dump_reg_misc.o
|
|
diff --git a/drivers/char/dump_reg/dump_reg.c b/drivers/char/dump_reg/dump_reg.c
|
|
new file mode 100644
|
|
index 000000000..8c227b08d
|
|
--- /dev/null
|
|
+++ b/drivers/char/dump_reg/dump_reg.c
|
|
@@ -0,0 +1,888 @@
|
|
+/*
|
|
+ * dump registers sysfs driver
|
|
+ *
|
|
+ * Copyright(c) 2015-2018 Allwinnertech Co., Ltd.
|
|
+ * http://www.allwinnertech.com
|
|
+ *
|
|
+ * Author: Liugang <liugang@allwinnertech.com>
|
|
+ * Xiafeng <xiafeng@allwinnertech.com>
|
|
+ * Martin <wuyan@allwinnertech.com>
|
|
+ * Lewis <liuyu@allwinnertech.com>
|
|
+ * This program is free software; you can redistribute it and/or modify
|
|
+ * it under the terms of the GNU General Public License as published by
|
|
+ * the Free Software Foundation; either version 2 of the License, or
|
|
+ * (at your option) any later version.
|
|
+ */
|
|
+
|
|
+#include <linux/kernel.h>
|
|
+#include <linux/module.h>
|
|
+#include <linux/device.h>
|
|
+#include <linux/err.h>
|
|
+#include <linux/kdev_t.h>
|
|
+#include <linux/clk.h>
|
|
+#include <linux/io.h>
|
|
+#include <linux/slab.h>
|
|
+#include <linux/miscdevice.h>
|
|
+#include <linux/seq_file.h>
|
|
+#include <linux/platform_device.h>
|
|
+#include <linux/sysfs.h>
|
|
+#include <linux/mod_devicetable.h>
|
|
+#include "dump_reg.h"
|
|
+
|
|
+/* the register and vaule to be test by dump_reg */
|
|
+static u32 test_addr;
|
|
+static u32 test_size;
|
|
+static struct class *dump_class;
|
|
+
|
|
+/* Access in byte mode ? 1: byte-mode, 0: word-mode */
|
|
+static unsigned int rw_byte_mode;
|
|
+
|
|
+/* for dump_reg class */
|
|
+static struct dump_addr dump_para;
|
|
+static struct write_group *wt_group;
|
|
+static struct compare_group *cmp_group;
|
|
+
|
|
+static u32 _read(void __iomem *vaddr)
|
|
+{
|
|
+ if (rw_byte_mode)
|
|
+ return (u32)readb(vaddr);
|
|
+ else
|
|
+ return readl(vaddr);
|
|
+}
|
|
+
|
|
+static void _write(u32 val, void __iomem *vaddr)
|
|
+{
|
|
+ if (rw_byte_mode)
|
|
+ writeb((u8)val, vaddr);
|
|
+ else
|
|
+ writel(val, vaddr);
|
|
+}
|
|
+
|
|
+static void __iomem *_io_remap(unsigned long paddr, size_t size)
|
|
+{
|
|
+ return ioremap(paddr, size);
|
|
+}
|
|
+
|
|
+static void _io_unmap(void __iomem *vaddr)
|
|
+{
|
|
+ iounmap(vaddr);
|
|
+}
|
|
+
|
|
+static void __iomem *_mem_remap(unsigned long paddr, size_t size)
|
|
+{
|
|
+ return (void __iomem *)phys_to_virt(paddr);
|
|
+}
|
|
+
|
|
+/*
|
|
+ * Convert a physical address (which is already mapped) to virtual address
|
|
+ */
|
|
+static void __iomem *_get_vaddr(struct dump_addr *dump_addr, unsigned long uaddr)
|
|
+{
|
|
+ unsigned long offset = uaddr - dump_addr->uaddr_start;
|
|
+ return (void __iomem *)(dump_addr->vaddr_start + offset);
|
|
+}
|
|
+
|
|
+const struct dump_struct dump_table[] = {
|
|
+ {
|
|
+ .addr_start = SUNXI_IO_PHYS_START,
|
|
+ .addr_end = SUNXI_IO_PHYS_END,
|
|
+ .remap = _io_remap,
|
|
+ .unmap = _io_unmap,
|
|
+ .get_vaddr = _get_vaddr,
|
|
+ .read = _read,
|
|
+ .write = _write,
|
|
+ },
|
|
+ {
|
|
+ .addr_start = SUNXI_PLAT_PHYS_START,
|
|
+ .addr_end = SUNXI_PLAT_PHYS_END,
|
|
+ .remap = _mem_remap,
|
|
+ .unmap = NULL,
|
|
+ .get_vaddr = _get_vaddr,
|
|
+ .read = _read,
|
|
+ .write = _write,
|
|
+ },
|
|
+#if defined(SUNXI_IOMEM_START)
|
|
+ {
|
|
+ .addr_start = SUNXI_IOMEM_START,
|
|
+ .addr_end = SUNXI_IOMEM_END,
|
|
+ .remap = NULL, /* .remap = NULL: uaddr is a virtual address */
|
|
+ .unmap = NULL,
|
|
+ .get_vaddr = _get_vaddr,
|
|
+ .read = _read,
|
|
+ .write = _write,
|
|
+ },
|
|
+#endif
|
|
+ {
|
|
+ .addr_start = SUNXI_MEM_PHYS_START,
|
|
+ .addr_end = SUNXI_MEM_PHYS_END,
|
|
+ .remap = NULL, /* .remap = NULL: uaddr is a virtual address */
|
|
+ .unmap = NULL,
|
|
+ .get_vaddr = _get_vaddr,
|
|
+ .read = _read,
|
|
+ .write = _write,
|
|
+ },
|
|
+};
|
|
+EXPORT_SYMBOL(dump_table);
|
|
+
|
|
+/**
|
|
+ * __addr_valid - check if @uaddr is valid.
|
|
+ * @uaddr: addr to judge.
|
|
+ *
|
|
+ * return index if @addr is valid, -ENXIO if not.
|
|
+ */
|
|
+int __addr_valid(unsigned long uaddr)
|
|
+{
|
|
+ int i;
|
|
+
|
|
+ for (i = 0; i < ARRAY_SIZE(dump_table); i++)
|
|
+ if (uaddr >= dump_table[i].addr_start &&
|
|
+ uaddr <= dump_table[i].addr_end)
|
|
+ return i;
|
|
+ return -ENXIO;
|
|
+}
|
|
+EXPORT_SYMBOL(__addr_valid);
|
|
+
|
|
+/**
|
|
+ * __dump_regs_ex - dump a range of registers' value, copy to buf.
|
|
+ * @dump_addr: start and end address of registers.
|
|
+ * @buf: store the dump info.
|
|
+ * @buf_size: buf size
|
|
+ *
|
|
+ * return bytes written to buf, <=0 indicate err
|
|
+ */
|
|
+ssize_t __dump_regs_ex(struct dump_addr *dump_addr, char *buf, ssize_t buf_size)
|
|
+{
|
|
+ int index;
|
|
+ ssize_t cnt = 0;
|
|
+ unsigned long uaddr;
|
|
+ unsigned long remap_size;
|
|
+ const struct dump_struct *dump;
|
|
+
|
|
+ /* Make the address 4-bytes aligned */
|
|
+ dump_addr->uaddr_start &= (~0x3UL);
|
|
+ dump_addr->uaddr_end &= (~0x3UL);
|
|
+ remap_size = dump_addr->uaddr_end - dump_addr->uaddr_start + 4;
|
|
+
|
|
+ index = __addr_valid(dump_addr->uaddr_start);
|
|
+ if ((index < 0) || (index != __addr_valid(dump_addr->uaddr_end)) ||
|
|
+ (buf == NULL)) {
|
|
+ pr_err("%s(): Invalid para: index=%d, start=0x%lx, end=0x%lx, buf=0x%p\n",
|
|
+ __func__, index, dump_addr->uaddr_start, dump_addr->uaddr_end, buf);
|
|
+ return -EIO;
|
|
+ }
|
|
+
|
|
+ dump = &dump_table[index];
|
|
+ if (dump->remap) {
|
|
+ dump_addr->vaddr_start = dump->remap(dump_addr->uaddr_start, remap_size);
|
|
+ if (!dump_addr->vaddr_start) {
|
|
+ pr_err("%s(): remap failed\n", __func__);
|
|
+ return -EIO;
|
|
+ }
|
|
+ } else /* if (dump->remap = NULL), then treat uaddr as a virtual address */
|
|
+ dump_addr->vaddr_start = (void __iomem *)dump_addr->uaddr_start;
|
|
+
|
|
+ if (dump_addr->uaddr_start == dump_addr->uaddr_end) {
|
|
+ cnt = sprintf(buf, "0x%08x\n", dump->read(dump_addr->vaddr_start));
|
|
+ goto out;
|
|
+ }
|
|
+
|
|
+ for (uaddr = (dump_addr->uaddr_start & ~0x0F); uaddr <= dump_addr->uaddr_end;
|
|
+ uaddr += 4) {
|
|
+ if (!(uaddr & 0x0F))
|
|
+ cnt += snprintf(buf + cnt, buf_size - cnt,
|
|
+ "\n" PRINT_ADDR_FMT ":", uaddr);
|
|
+
|
|
+ if (cnt >= buf_size) {
|
|
+ pr_warn("Range too large, strings buffer overflow\n");
|
|
+ cnt = buf_size;
|
|
+ goto out;
|
|
+ }
|
|
+
|
|
+ if (uaddr < dump_addr->uaddr_start) /* Don't show unused uaddr */
|
|
+ /* "0x12345678 ", 11 space */
|
|
+ cnt += snprintf(buf + cnt, buf_size - cnt, " ");
|
|
+ else
|
|
+ cnt += snprintf(buf + cnt, buf_size - cnt, " 0x%08x",
|
|
+ dump->read(dump->get_vaddr(dump_addr, uaddr)));
|
|
+ }
|
|
+ cnt += snprintf(buf + cnt, buf_size - cnt, "\n");
|
|
+
|
|
+ pr_debug("%s(): start=0x%lx, end=0x%lx, return=%zd\n", __func__,
|
|
+ dump_addr->uaddr_start, dump_addr->uaddr_end, cnt);
|
|
+
|
|
+out:
|
|
+ if (dump->unmap)
|
|
+ dump->unmap(dump_addr->vaddr_start);
|
|
+
|
|
+ return cnt;
|
|
+}
|
|
+EXPORT_SYMBOL(__dump_regs_ex);
|
|
+
|
|
+/**
|
|
+ * __parse_dump_str - parse the input string for dump attri.
|
|
+ * @buf: the input string, eg: "0x01c20000,0x01c20300".
|
|
+ * @size: buf size.
|
|
+ * @start: store the start reg's addr parsed from buf, eg 0x01c20000.
|
|
+ * @end: store the end reg's addr parsed from buf, eg 0x01c20300.
|
|
+ *
|
|
+ * return 0 if success, otherwise failed.
|
|
+ */
|
|
+int __parse_dump_str(const char *buf, size_t size,
|
|
+ unsigned long *start, unsigned long *end)
|
|
+{
|
|
+ char *ptr = NULL;
|
|
+ char *ptr2 = (char *)buf;
|
|
+ int ret = 0, times = 0;
|
|
+
|
|
+ /* Support single address mode, some time it haven't ',' */
|
|
+next:
|
|
+ /*
|
|
+ * Default dump only one register(*start =*end).
|
|
+ * If ptr is not NULL, we will cover the default value of end.
|
|
+ */
|
|
+ if (times == 1)
|
|
+ *start = *end;
|
|
+
|
|
+ if (!ptr2 || (ptr2 - buf) >= size)
|
|
+ goto out;
|
|
+
|
|
+ ptr = ptr2;
|
|
+ ptr2 = strnchr(ptr, size - (ptr - buf), ',');
|
|
+ if (ptr2) {
|
|
+ *ptr2 = '\0';
|
|
+ ptr2++;
|
|
+ }
|
|
+
|
|
+ ptr = strim(ptr);
|
|
+ if (!strlen(ptr))
|
|
+ goto next;
|
|
+
|
|
+ ret = kstrtoul(ptr, 16, end);
|
|
+ if (!ret) {
|
|
+ times++;
|
|
+ goto next;
|
|
+ } else
|
|
+ pr_warn("String syntax errors: \"%s\"\n", ptr);
|
|
+
|
|
+out:
|
|
+ return ret;
|
|
+}
|
|
+EXPORT_SYMBOL(__parse_dump_str);
|
|
+
|
|
+/**
|
|
+ * __write_show - dump a register's value, copy to buf.
|
|
+ * @pgroup: the addresses to read.
|
|
+ * @buf: store the dump info.
|
|
+ *
|
|
+ * return bytes written to buf, <=0 indicate err.
|
|
+ */
|
|
+ssize_t __write_show(struct write_group *pgroup, char *buf, ssize_t len)
|
|
+{
|
|
+#define WR_DATA_FMT PRINT_ADDR_FMT" 0x%08x %s"
|
|
+
|
|
+ int i = 0;
|
|
+ ssize_t cnt = 0;
|
|
+ unsigned long reg = 0;
|
|
+ u32 val;
|
|
+ u8 rval_buf[16];
|
|
+ struct dump_addr dump_addr;
|
|
+
|
|
+ if (!pgroup) {
|
|
+ pr_err("%s,%d err, pgroup is NULL!\n", __func__, __LINE__);
|
|
+ goto end;
|
|
+ }
|
|
+
|
|
+ cnt += snprintf(buf, len - cnt, WR_PRINT_FMT);
|
|
+ if (cnt > len) {
|
|
+ cnt = -EINVAL;
|
|
+ goto end;
|
|
+ }
|
|
+
|
|
+ for (i = 0; i < pgroup->num; i++) {
|
|
+ reg = pgroup->pitem[i].reg_addr;
|
|
+ val = pgroup->pitem[i].val;
|
|
+ dump_addr.uaddr_start = reg;
|
|
+ dump_addr.uaddr_end = reg;
|
|
+ if (__dump_regs_ex(&dump_addr, rval_buf, sizeof(rval_buf)) < 0)
|
|
+ return -EINVAL;
|
|
+
|
|
+ cnt +=
|
|
+ snprintf(buf + cnt, len - cnt, WR_DATA_FMT, reg, val,
|
|
+ rval_buf);
|
|
+ if (cnt > len) {
|
|
+ cnt = len;
|
|
+ goto end;
|
|
+ }
|
|
+ }
|
|
+
|
|
+end:
|
|
+ return cnt;
|
|
+}
|
|
+EXPORT_SYMBOL(__write_show);
|
|
+
|
|
+/**
|
|
+ * __parse_write_str - parse the input string for write attri.
|
|
+ * @str: string to be parsed, eg: "0x01c20818 0x55555555".
|
|
+ * @reg_addr: store the reg address. eg: 0x01c20818.
|
|
+ * @val: store the expect value. eg: 0x55555555.
|
|
+ *
|
|
+ * return 0 if success, otherwise failed.
|
|
+ */
|
|
+static int __parse_write_str(char *str, unsigned long *reg_addr, u32 *val)
|
|
+{
|
|
+ char *ptr = str;
|
|
+ char *tstr = NULL;
|
|
+ int ret = 0;
|
|
+
|
|
+ /*
|
|
+ * Skip the leading whitespace, find the true split symbol.
|
|
+ * And it must be 'address value'.
|
|
+ */
|
|
+ tstr = strim(str);
|
|
+ ptr = strchr(tstr, ' ');
|
|
+ if (!ptr)
|
|
+ return -EINVAL;
|
|
+
|
|
+ /*
|
|
+ * Replaced split symbol with a %NUL-terminator temporary.
|
|
+ * Will be fixed at end.
|
|
+ */
|
|
+ *ptr = '\0';
|
|
+ ret = kstrtoul(tstr, 16, reg_addr);
|
|
+ if (ret)
|
|
+ goto out;
|
|
+
|
|
+ ret = kstrtou32(skip_spaces(ptr + 1), 16, val);
|
|
+
|
|
+out:
|
|
+ return ret;
|
|
+}
|
|
+
|
|
+/**
|
|
+ * __write_item_init - init for write attri. parse input string,
|
|
+ * and construct write struct.
|
|
+ * @ppgroup: store the struct allocated, the struct contains items parsed from
|
|
+ * input buf.
|
|
+ * @buf: input string, eg: "0x01c20800 0x00000031,0x01c20818 0x55555555,...".
|
|
+ * @size: buf size.
|
|
+ *
|
|
+ * return 0 if success, otherwise failed.
|
|
+ */
|
|
+int __write_item_init(struct write_group **ppgroup, const char *buf,
|
|
+ size_t size)
|
|
+{
|
|
+ char *ptr, *ptr2;
|
|
+ unsigned long addr = 0;
|
|
+ u32 val;
|
|
+ struct write_group *pgroup;
|
|
+
|
|
+ /* alloc item buffer */
|
|
+ pgroup = kmalloc(sizeof(struct write_group), GFP_KERNEL);
|
|
+ if (!pgroup)
|
|
+ return -ENOMEM;
|
|
+
|
|
+ pgroup->pitem = kmalloc(sizeof(struct write_item) * MAX_WRITE_ITEM,
|
|
+ GFP_KERNEL);
|
|
+ if (!pgroup->pitem) {
|
|
+ kfree(pgroup);
|
|
+ return -ENOMEM;
|
|
+ }
|
|
+
|
|
+ pgroup->num = 0;
|
|
+ ptr = (char *)buf;
|
|
+ do {
|
|
+ ptr2 = strchr(ptr, ',');
|
|
+ if (ptr2)
|
|
+ *ptr2 = '\0';
|
|
+
|
|
+ if (!__parse_write_str(ptr, &addr, &val)) {
|
|
+ pgroup->pitem[pgroup->num].reg_addr = addr;
|
|
+ pgroup->pitem[pgroup->num].val = val;
|
|
+ pgroup->num++;
|
|
+ } else
|
|
+ pr_err("%s: Failed to parse string: %s\n", __func__,
|
|
+ ptr);
|
|
+
|
|
+ if (!ptr2)
|
|
+ break;
|
|
+
|
|
+ ptr = ptr2 + 1;
|
|
+ *ptr2 = ',';
|
|
+
|
|
+ } while (pgroup->num <= MAX_WRITE_ITEM);
|
|
+
|
|
+ /* free buffer if no valid item */
|
|
+ if (pgroup->num == 0) {
|
|
+ kfree(pgroup->pitem);
|
|
+ kfree(pgroup);
|
|
+ return -EINVAL;
|
|
+ }
|
|
+
|
|
+ *ppgroup = pgroup;
|
|
+ return 0;
|
|
+}
|
|
+EXPORT_SYMBOL(__write_item_init);
|
|
+
|
|
+/**
|
|
+ * __write_item_deinit - reled_addrse memory that cred_addrted by
|
|
+ * __write_item_init.
|
|
+ * @pgroup: the write struct allocated in __write_item_init.
|
|
+ */
|
|
+void __write_item_deinit(struct write_group *pgroup)
|
|
+{
|
|
+ if (pgroup != NULL) {
|
|
+ if (pgroup->pitem != NULL)
|
|
+ kfree(pgroup->pitem);
|
|
+ kfree(pgroup);
|
|
+ }
|
|
+}
|
|
+EXPORT_SYMBOL(__write_item_deinit);
|
|
+
|
|
+/**
|
|
+ * __compare_regs_ex - dump a range of registers' value, copy to buf.
|
|
+ * @pgroup: addresses of registers.
|
|
+ * @buf: store the dump info.
|
|
+ *
|
|
+ * return bytes written to buf, <= 0 indicate err.
|
|
+ */
|
|
+ssize_t __compare_regs_ex(struct compare_group *pgroup, char *buf,
|
|
+ ssize_t len)
|
|
+{
|
|
+#define CMP_DATAO_FMT PRINT_ADDR_FMT" 0x%08x 0x%08x 0x%08x OK\n"
|
|
+#define CMP_DATAE_FMT PRINT_ADDR_FMT" 0x%08x 0x%08x 0x%08x ERR\n"
|
|
+
|
|
+ int i;
|
|
+ ssize_t cnt = 0;
|
|
+ unsigned long reg;
|
|
+ u32 expect, actual, mask;
|
|
+ u8 actualb[16];
|
|
+ struct dump_addr dump_addr;
|
|
+
|
|
+ if (!pgroup) {
|
|
+ pr_err("%s,%d err, pgroup is NULL!\n", __func__, __LINE__);
|
|
+ goto end;
|
|
+ }
|
|
+
|
|
+ cnt += snprintf(buf, len - cnt, CMP_PRINT_FMT);
|
|
+ if (cnt > len) {
|
|
+ cnt = -EINVAL;
|
|
+ goto end;
|
|
+ }
|
|
+
|
|
+ for (i = 0; i < pgroup->num; i++) {
|
|
+ reg = pgroup->pitem[i].reg_addr;
|
|
+ expect = pgroup->pitem[i].val_expect;
|
|
+ dump_addr.uaddr_start = reg;
|
|
+ dump_addr.uaddr_end = reg;
|
|
+ if (__dump_regs_ex(&dump_addr, actualb, sizeof(actualb)) < 0)
|
|
+ return -EINVAL;
|
|
+
|
|
+ if (kstrtou32(actualb, 16, &actual))
|
|
+ return -EINVAL;
|
|
+
|
|
+ mask = pgroup->pitem[i].val_mask;
|
|
+ if ((actual & mask) == (expect & mask))
|
|
+ cnt +=
|
|
+ snprintf(buf + cnt, len - cnt, CMP_DATAO_FMT, reg,
|
|
+ expect, actual, mask);
|
|
+ else
|
|
+ cnt +=
|
|
+ snprintf(buf + cnt, len - cnt, CMP_DATAE_FMT, reg,
|
|
+ expect, actual, mask);
|
|
+ if (cnt > len) {
|
|
+ cnt = -EINVAL;
|
|
+ goto end;
|
|
+ }
|
|
+ }
|
|
+
|
|
+end:
|
|
+ return cnt;
|
|
+}
|
|
+EXPORT_SYMBOL(__compare_regs_ex);
|
|
+
|
|
+/**
|
|
+ * __parse_compare_str - parse the input string for compare attri.
|
|
+ * @str: string to be parsed, eg: "0x01c20000 0x80000011 0x00000011".
|
|
+ * @reg_addr: store the reg address. eg: 0x01c20000.
|
|
+ * @val_expect: store the expect value. eg: 0x80000011.
|
|
+ * @val_mask: store the mask value. eg: 0x00000011.
|
|
+ *
|
|
+ * return 0 if success, otherwise failed.
|
|
+ */
|
|
+static int __parse_compare_str(char *str, unsigned long *reg_addr,
|
|
+ u32 *val_expect, u32 *val_mask)
|
|
+{
|
|
+ unsigned long result_addr[3] = { 0 };
|
|
+ char *ptr = str;
|
|
+ char *ptr2 = NULL;
|
|
+ int i, ret = 0;
|
|
+
|
|
+ for (i = 0; i < ARRAY_SIZE(result_addr); i++) {
|
|
+ ptr = skip_spaces(ptr);
|
|
+ ptr2 = strchr(ptr, ' ');
|
|
+ if (ptr2)
|
|
+ *ptr2 = '\0';
|
|
+
|
|
+ ret = kstrtoul(ptr, 16, &result_addr[i]);
|
|
+ if (!ptr2)
|
|
+ break;
|
|
+
|
|
+ *ptr2 = ' ';
|
|
+
|
|
+ if (ret)
|
|
+ break;
|
|
+
|
|
+ ptr = ptr2 + 1;
|
|
+ }
|
|
+
|
|
+ *reg_addr = result_addr[0];
|
|
+ *val_expect = (u32) result_addr[1];
|
|
+ *val_mask = (u32) result_addr[2];
|
|
+
|
|
+ return ret;
|
|
+}
|
|
+
|
|
+/**
|
|
+ * __compare_item_init - init for compare attri. parse input string,
|
|
+ * and construct compare struct.
|
|
+ * @ppgroup: store the struct allocated, the struct contains items parsed from
|
|
+ * input buf.
|
|
+ * @buf: input string,
|
|
+ * eg: "0x01c20000 0x80000011 0x00000011,0x01c20004 0x0000c0a4 0x0000c0a0,...".
|
|
+ * @size: buf size.
|
|
+ *
|
|
+ * return 0 if success, otherwise failed.
|
|
+ */
|
|
+int __compare_item_init(struct compare_group **ppgroup,
|
|
+ const char *buf, size_t size)
|
|
+{
|
|
+ char *ptr, *ptr2;
|
|
+ unsigned long addr = 0;
|
|
+ u32 val_expect = 0, val_mask = 0;
|
|
+ struct compare_group *pgroup = NULL;
|
|
+
|
|
+ /* alloc item buffer */
|
|
+ pgroup = kmalloc(sizeof(struct compare_group), GFP_KERNEL);
|
|
+ if (pgroup == NULL)
|
|
+ return -EINVAL;
|
|
+
|
|
+ pgroup->pitem = kmalloc(sizeof(struct compare_item) * MAX_COMPARE_ITEM,
|
|
+ GFP_KERNEL);
|
|
+ if (pgroup->pitem == NULL) {
|
|
+ kfree(pgroup);
|
|
+ return -EINVAL;
|
|
+ }
|
|
+
|
|
+ pgroup->num = 0;
|
|
+
|
|
+ /* get item from buf */
|
|
+ ptr = (char *)buf;
|
|
+ do {
|
|
+ ptr2 = strchr(ptr, ',');
|
|
+ if (ptr2)
|
|
+ *ptr2 = '\0';
|
|
+
|
|
+ if (!__parse_compare_str(ptr, &addr, &val_expect, &val_mask)) {
|
|
+ pgroup->pitem[pgroup->num].reg_addr = addr;
|
|
+ pgroup->pitem[pgroup->num].val_expect = val_expect;
|
|
+ pgroup->pitem[pgroup->num].val_mask = val_mask;
|
|
+ pgroup->num++;
|
|
+ } else
|
|
+ pr_err("%s: Failed to parse string: %s\n", __func__,
|
|
+ ptr);
|
|
+
|
|
+ if (!ptr2)
|
|
+ break;
|
|
+
|
|
+ *ptr2 = ',';
|
|
+ ptr = ptr2 + 1;
|
|
+
|
|
+ } while (pgroup->num <= MAX_COMPARE_ITEM);
|
|
+
|
|
+ /* free buffer if no valid item */
|
|
+ if (pgroup->num == 0) {
|
|
+ kfree(pgroup->pitem);
|
|
+ kfree(pgroup);
|
|
+ return -EINVAL;
|
|
+ }
|
|
+ *ppgroup = pgroup;
|
|
+
|
|
+ return 0;
|
|
+}
|
|
+EXPORT_SYMBOL(__compare_item_init);
|
|
+
|
|
+/**
|
|
+ * __compare_item_deinit - reled_addrse memory that cred_addrted by
|
|
+ * __compare_item_init.
|
|
+ * @pgroup: the compare struct allocated in __compare_item_init.
|
|
+ */
|
|
+void __compare_item_deinit(struct compare_group *pgroup)
|
|
+{
|
|
+ if (pgroup) {
|
|
+ kfree(pgroup->pitem);
|
|
+ kfree(pgroup);
|
|
+ }
|
|
+}
|
|
+EXPORT_SYMBOL(__compare_item_deinit);
|
|
+
|
|
+/**
|
|
+ * dump_show - show func of dump attribute.
|
|
+ * @dev: class ptr.
|
|
+ * @attr: attribute ptr.
|
|
+ * @buf: the input buf which contain the start and end reg.
|
|
+ * eg: "0x01c20000,0x01c20100\n".
|
|
+ *
|
|
+ * return size written to the buf, otherwise failed.
|
|
+ */
|
|
+static ssize_t
|
|
+dump_show(struct class *class, struct class_attribute *attr, char *buf)
|
|
+{
|
|
+ return __dump_regs_ex(&dump_para, buf, PAGE_SIZE);
|
|
+}
|
|
+
|
|
+static ssize_t
|
|
+dump_store(struct class *class, struct class_attribute *attr,
|
|
+ const char *buf, size_t count)
|
|
+{
|
|
+ int index;
|
|
+ unsigned long start_reg = 0;
|
|
+ unsigned long end_reg = 0;
|
|
+
|
|
+ if (__parse_dump_str(buf, count, &start_reg, &end_reg)) {
|
|
+ pr_err("%s,%d err, invalid para!\n", __func__, __LINE__);
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ index = __addr_valid(start_reg);
|
|
+ if ((index < 0) || (index != __addr_valid(end_reg))) {
|
|
+ pr_err("%s,%d err, invalid para!\n", __func__, __LINE__);
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ dump_para.uaddr_start = start_reg;
|
|
+ dump_para.uaddr_end = end_reg;
|
|
+ pr_debug("%s,%d, start_reg:" PRINT_ADDR_FMT ", end_reg:" PRINT_ADDR_FMT
|
|
+ "\n", __func__, __LINE__, start_reg, end_reg);
|
|
+
|
|
+ return count;
|
|
+
|
|
+err:
|
|
+ dump_para.uaddr_start = 0;
|
|
+ dump_para.uaddr_end = 0;
|
|
+
|
|
+ return -EINVAL;
|
|
+}
|
|
+
|
|
+static ssize_t
|
|
+write_show(struct class *class, struct class_attribute *attr, char *buf)
|
|
+{
|
|
+ /* display write result */
|
|
+ return __write_show(wt_group, buf, PAGE_SIZE);
|
|
+}
|
|
+
|
|
+static ssize_t
|
|
+write_store(struct class *class, struct class_attribute *attr,
|
|
+ const char *buf, size_t count)
|
|
+{
|
|
+ int i;
|
|
+ int index;
|
|
+ unsigned long reg;
|
|
+ u32 val;
|
|
+ const struct dump_struct *dump;
|
|
+ struct dump_addr dump_addr;
|
|
+
|
|
+ /* free if not NULL */
|
|
+ if (wt_group) {
|
|
+ __write_item_deinit(wt_group);
|
|
+ wt_group = NULL;
|
|
+ }
|
|
+
|
|
+ /* parse input buf for items that will be dumped */
|
|
+ if (__write_item_init(&wt_group, buf, count) < 0)
|
|
+ return -EINVAL;
|
|
+
|
|
+ /**
|
|
+ * write reg
|
|
+ * it is better if the regs been remaped and unmaped only once,
|
|
+ * but we map everytime for the range between min and max address
|
|
+ * maybe too large.
|
|
+ */
|
|
+ for (i = 0; i < wt_group->num; i++) {
|
|
+ reg = wt_group->pitem[i].reg_addr;
|
|
+ dump_addr.uaddr_start = reg;
|
|
+ val = wt_group->pitem[i].val;
|
|
+ index = __addr_valid(reg);
|
|
+ dump = &dump_table[index];
|
|
+ if (dump->remap)
|
|
+ dump_addr.vaddr_start = dump->remap(reg, 4);
|
|
+ else
|
|
+ dump_addr.vaddr_start = (void __iomem *)reg;
|
|
+ dump->write(val, dump->get_vaddr(&dump_addr, reg));
|
|
+ if (dump->unmap)
|
|
+ dump->unmap(dump_addr.vaddr_start);
|
|
+ }
|
|
+
|
|
+ return count;
|
|
+}
|
|
+
|
|
+static ssize_t
|
|
+compare_show(struct class *class, struct class_attribute *attr, char *buf)
|
|
+{
|
|
+ /* dump the items */
|
|
+ return __compare_regs_ex(cmp_group, buf, PAGE_SIZE);
|
|
+}
|
|
+
|
|
+static ssize_t
|
|
+compare_store(struct class *class, struct class_attribute *attr,
|
|
+ const char *buf, size_t count)
|
|
+{
|
|
+ /* free if struct not null */
|
|
+ if (cmp_group) {
|
|
+ __compare_item_deinit(cmp_group);
|
|
+ cmp_group = NULL;
|
|
+ }
|
|
+
|
|
+ /* parse input buf for items that will be dumped */
|
|
+ if (__compare_item_init(&cmp_group, buf, count) < 0)
|
|
+ return -EINVAL;
|
|
+
|
|
+ return count;
|
|
+}
|
|
+
|
|
+static ssize_t
|
|
+rw_byte_show(struct class *class, struct class_attribute *attr, char *buf)
|
|
+{
|
|
+ return sprintf(buf, "read/write mode: %u(%s)\n", rw_byte_mode,
|
|
+ rw_byte_mode ? "byte" : "word");
|
|
+}
|
|
+
|
|
+static ssize_t
|
|
+rw_byte_store(struct class *class, struct class_attribute *attr,
|
|
+ const char *buf, size_t count)
|
|
+{
|
|
+ unsigned long value;
|
|
+ int ret;
|
|
+
|
|
+ ret = kstrtoul(buf, 10, &value);
|
|
+ if (!ret && (value > 1)) {
|
|
+ pr_err("%s,%d err, invalid para!\n", __func__, __LINE__);
|
|
+ goto out;
|
|
+ }
|
|
+ rw_byte_mode = value;
|
|
+out:
|
|
+ return count;
|
|
+}
|
|
+
|
|
+static ssize_t
|
|
+test_show(struct class *class, struct class_attribute *attr, char *buf)
|
|
+{
|
|
+ return sprintf(buf, "addr:0x%08x\nsize:0x%08x\n", test_addr, test_size);
|
|
+}
|
|
+
|
|
+static ssize_t
|
|
+help_show(struct class *class, struct class_attribute *attr, char *buf)
|
|
+{
|
|
+ const char *info =
|
|
+ "dump single register: echo {addr} > dump; cat dump\n"
|
|
+ "dump multi registers: echo {start-addr},{end-addr} > dump; cat dump\n"
|
|
+ "write single register: echo {addr} {val} > write; cat write\n"
|
|
+ "write multi registers: echo {addr1} {val1},{addr2} {val2},... > write; cat write\n"
|
|
+ "compare single register: echo {addr} {expect-val} {mask} > compare; cat compare\n"
|
|
+ "compare multi registers: echo {addr1} {expect-val1} {mask1},{addr2} {expect-val2} {mask2},... > compare; cat compare\n"
|
|
+ "byte-access mode: echo 1 > rw_byte\n"
|
|
+ "word-access mode (default): echo 0 > rw_byte\n"
|
|
+ "show test address info: cat test\n";
|
|
+ return sprintf(buf, info);
|
|
+}
|
|
+
|
|
+static struct class_attribute dump_class_attrs[] = {
|
|
+ __ATTR(dump, S_IWUSR | S_IRUGO, dump_show, dump_store),
|
|
+ __ATTR(write, S_IWUSR | S_IRUGO, write_show, write_store),
|
|
+ __ATTR(compare, S_IWUSR | S_IRUGO, compare_show, compare_store),
|
|
+ __ATTR(rw_byte, S_IWUSR | S_IRUGO, rw_byte_show, rw_byte_store),
|
|
+ __ATTR(test, S_IRUGO, test_show, NULL),
|
|
+ __ATTR(help, S_IRUGO, help_show, NULL),
|
|
+};
|
|
+
|
|
+static const struct of_device_id sunxi_dump_reg_match[] = {
|
|
+ {.compatible = "allwinner,sunxi-dump-reg", },
|
|
+ {}
|
|
+};
|
|
+MODULE_DEVICE_TABLE(of, sunxi_dump_reg_match);
|
|
+
|
|
+static int sunxi_dump_reg_probe(struct platform_device *pdev)
|
|
+{
|
|
+ struct resource *res;
|
|
+ struct device *dev = &pdev->dev;
|
|
+
|
|
+ int err;
|
|
+ int i;
|
|
+
|
|
+ /* sys/class/sunxi_dump */
|
|
+ dump_class = class_create(THIS_MODULE, "sunxi_dump");
|
|
+ if (IS_ERR(dump_class)) {
|
|
+ pr_err("%s:%u class_create() failed\n", __func__, __LINE__);
|
|
+ return PTR_ERR(dump_class);
|
|
+ }
|
|
+
|
|
+ /* sys/class/sunxi_dump/xxx */
|
|
+ for (i = 0; i < ARRAY_SIZE(dump_class_attrs); i++) {
|
|
+ err = class_create_file(dump_class, &dump_class_attrs[i]);
|
|
+ if (err) {
|
|
+ pr_err("%s:%u class_create_file() failed. err=%d\n", __func__, __LINE__, err);
|
|
+ while (i--) {
|
|
+ class_remove_file(dump_class, &dump_class_attrs[i]);
|
|
+ }
|
|
+ class_destroy(dump_class);
|
|
+ dump_class = NULL;
|
|
+ return err;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
+ if (!res) {
|
|
+ dev_err(dev, "Fail to get IORESOURCE_MEM \n");
|
|
+ goto error;
|
|
+ }
|
|
+
|
|
+ test_addr = res->start;
|
|
+ test_size = resource_size(res);
|
|
+
|
|
+ return 0;
|
|
+error:
|
|
+ dev_err(dev, "sunxi_dump_reg probe error\n");
|
|
+ return -1;
|
|
+}
|
|
+
|
|
+static int sunxi_dump_reg_remove(struct platform_device *pdev)
|
|
+{
|
|
+ int i;
|
|
+
|
|
+ for (i = 0; i < ARRAY_SIZE(dump_class_attrs); i++) {
|
|
+ class_remove_file(dump_class, &dump_class_attrs[i]);
|
|
+ }
|
|
+
|
|
+ class_destroy(dump_class);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+static struct platform_driver sunxi_dump_reg_driver = {
|
|
+ .probe = sunxi_dump_reg_probe,
|
|
+ .remove = sunxi_dump_reg_remove,
|
|
+ .driver = {
|
|
+ .name = "dump_reg",
|
|
+ .owner = THIS_MODULE,
|
|
+ .of_match_table = sunxi_dump_reg_match,
|
|
+ },
|
|
+};
|
|
+
|
|
+module_platform_driver(sunxi_dump_reg_driver);
|
|
+
|
|
+MODULE_ALIAS("dump reg driver");
|
|
+MODULE_ALIAS("platform:dump reg");
|
|
+MODULE_LICENSE("GPL v2");
|
|
+MODULE_VERSION("1.0.3");
|
|
+MODULE_AUTHOR("xiafeng <xiafeng@allwinnertech.com>");
|
|
+MODULE_AUTHOR("Martin <wuyan@allwinnertech.com>");
|
|
+MODULE_AUTHOR("liuyu <SWCliuyus@allwinnertech.com>");
|
|
+MODULE_DESCRIPTION("dump registers driver");
|
|
diff --git a/drivers/char/dump_reg/dump_reg.h b/drivers/char/dump_reg/dump_reg.h
|
|
new file mode 100644
|
|
index 000000000..85af5c96e
|
|
--- /dev/null
|
|
+++ b/drivers/char/dump_reg/dump_reg.h
|
|
@@ -0,0 +1,132 @@
|
|
+/*
|
|
+ * dump registers head file
|
|
+ *
|
|
+ * (C) Copyright 2015-2018
|
|
+ * Reuuimlla Technology Co., Ltd. <www.reuuimllatech.com>
|
|
+ * Liugang <liugang@reuuimllatech.com>
|
|
+ * Xiafeng <xiafeng@allwinnertech.com>
|
|
+ * Martin <wuyan@allwinnertech.com>
|
|
+ *
|
|
+ * This program is free software; you can redistribute it and/or
|
|
+ * modify it under the terms of the GNU General Public License as
|
|
+ * published by the Free Software Foundation; either version 2 of
|
|
+ * the License, or (at your option) any later version.
|
|
+ *
|
|
+ */
|
|
+#ifndef _DUMP_REG_H_
|
|
+#define _DUMP_REG_H_
|
|
+
|
|
+/* BROM/SRAM/peripheral-registers space */
|
|
+#define SUNXI_IO_PHYS_START (0x01000000UL)
|
|
+#define SUNXI_IO_PHYS_END (SUNXI_IO_PHYS_START + SZ_128M + SZ_16M -1)
|
|
+
|
|
+/* DRAM space (Only map the first 1GB) */
|
|
+#define SUNXI_PLAT_PHYS_START (0x40000000UL)
|
|
+#define SUNXI_PLAT_PHYS_END (SUNXI_PLAT_PHYS_START + SZ_1G - 1)
|
|
+
|
|
+#if IS_ENABLED(CONFIG_ARM64)
|
|
+/* Virtual address space 1 */
|
|
+#define SUNXI_IOMEM_START (0xffffff8000000000UL)
|
|
+#define SUNXI_IOMEM_END (SUNXI_IOMEM_START + SZ_2G)
|
|
+/* Virtual address space 2 */
|
|
+#define SUNXI_MEM_PHYS_START (0xffffffc000000000UL)
|
|
+#define SUNXI_MEM_PHYS_END (SUNXI_MEM_PHYS_START + SZ_2G)
|
|
+/* Print format */
|
|
+#define PRINT_ADDR_FMT "0x%016lx"
|
|
+#define CMP_PRINT_FMT "reg expect actual mask result\n"
|
|
+#define WR_PRINT_FMT "reg to_write after_write\n"
|
|
+#else
|
|
+/* Virtual address space 2 */
|
|
+#define SUNXI_MEM_PHYS_START PAGE_OFFSET
|
|
+#define SUNXI_MEM_PHYS_END (SUNXI_MEM_PHYS_START + SZ_1G - 1)
|
|
+/* Print format */
|
|
+#define PRINT_ADDR_FMT "0x%08lx"
|
|
+#define CMP_PRINT_FMT "reg expect actual mask result\n"
|
|
+#define WR_PRINT_FMT "reg to_write after_write\n"
|
|
+#endif
|
|
+
|
|
+/* Item count */
|
|
+#define MAX_COMPARE_ITEM 64
|
|
+#define MAX_WRITE_ITEM 64
|
|
+
|
|
+struct dump_addr {
|
|
+ /* User specified address. Maybe physical or virtual address */
|
|
+ unsigned long uaddr_start;
|
|
+ unsigned long uaddr_end;
|
|
+ /* Virtual address */
|
|
+ void __iomem *vaddr_start;
|
|
+};
|
|
+
|
|
+struct dump_struct {
|
|
+ unsigned long addr_start;
|
|
+ unsigned long addr_end;
|
|
+ /* some registers' operate method maybe different */
|
|
+ void __iomem *(*remap)(unsigned long paddr, size_t size);
|
|
+ void (*unmap)(void __iomem *vaddr);
|
|
+ void __iomem *(*get_vaddr)(struct dump_addr *dump_addr, unsigned long uaddr);
|
|
+ u32 (*read)(void __iomem *vaddr);
|
|
+ void (*write)(u32 val, void __iomem *vaddr);
|
|
+};
|
|
+
|
|
+/**
|
|
+ * compare_item - reg compare item struct
|
|
+ * @reg_addr: reg address.
|
|
+ * @val_expect: expected value, provided by caller.
|
|
+ * @val_mask: mask value, provided by caller. only mask bits will be compared.
|
|
+ */
|
|
+struct compare_item {
|
|
+ unsigned long reg_addr;
|
|
+ u32 val_expect;
|
|
+ u32 val_mask;
|
|
+};
|
|
+
|
|
+/**
|
|
+ * compare_group - reg compare group struct
|
|
+ * @num: pitem element count. cannot exceed MAX_COMPARE_ITEM.
|
|
+ * @pitem: items that will be compared, provided by caller.
|
|
+ */
|
|
+struct compare_group {
|
|
+ u32 num;
|
|
+ u32 reserve;
|
|
+ struct compare_item *pitem;
|
|
+};
|
|
+
|
|
+/**
|
|
+ * write_item - reg write item struct
|
|
+ * @reg_addr: reg address.
|
|
+ * @val: value to write
|
|
+ */
|
|
+struct write_item {
|
|
+ unsigned long reg_addr;
|
|
+ u32 val;
|
|
+ u32 reserve;
|
|
+};
|
|
+
|
|
+/**
|
|
+ * write_group - reg write group struct
|
|
+ * @num: pitem element count. cannot exceed MAX_WRITE_ITEM.
|
|
+ * @pitem: items that will be write, provided by caller.
|
|
+ */
|
|
+struct write_group {
|
|
+ u32 num;
|
|
+ u32 reserve;
|
|
+ struct write_item *pitem;
|
|
+};
|
|
+
|
|
+extern const struct dump_struct dump_table[4];
|
|
+
|
|
+int __addr_valid(unsigned long addr);
|
|
+ssize_t __dump_regs_ex(struct dump_addr *reg, char *buf, ssize_t len);
|
|
+int __parse_dump_str(const char *buf, size_t size,
|
|
+ unsigned long *start, unsigned long *end);
|
|
+ssize_t __write_show(struct write_group *pgroup, char *buf, ssize_t len);
|
|
+int __write_item_init(struct write_group **ppgroup, const char *buf,
|
|
+ size_t size);
|
|
+void __write_item_deinit(struct write_group *pgroup);
|
|
+ssize_t __compare_regs_ex(struct compare_group *pgroup, char *buf,
|
|
+ ssize_t len);
|
|
+int __compare_item_init(struct compare_group **ppgroup,
|
|
+ const char *buf, size_t size);
|
|
+void __compare_item_deinit(struct compare_group *pgroup);
|
|
+
|
|
+#endif /* _DUMP_REG_H_ */
|
|
diff --git a/drivers/char/dump_reg/dump_reg_misc.c b/drivers/char/dump_reg/dump_reg_misc.c
|
|
new file mode 100644
|
|
index 000000000..238ddd147
|
|
--- /dev/null
|
|
+++ b/drivers/char/dump_reg/dump_reg_misc.c
|
|
@@ -0,0 +1,209 @@
|
|
+/*
|
|
+ * misc dump registers driver -
|
|
+ * User space application could use dump-reg functions through file operations
|
|
+ * (open/read/write/close) to the sysfs node created by this driver.
|
|
+ *
|
|
+ * Copyright(c) 2015-2018 Allwinnertech Co., Ltd.
|
|
+ * http://www.allwinnertech.com
|
|
+ *
|
|
+ * Author: Liugang <liugang@allwinnertech.com>
|
|
+ * Xiafeng <xiafeng@allwinnertech.com>
|
|
+ * Martin <wuyan@allwinnertech.com>
|
|
+ *
|
|
+ * This program is free software; you can redistribute it and/or modify
|
|
+ * it under the terms of the GNU General Public License as published by
|
|
+ * the Free Software Foundation; either version 2 of the License, or
|
|
+ * (at your option) any later version.
|
|
+ */
|
|
+
|
|
+#include <linux/kernel.h>
|
|
+#include <linux/module.h>
|
|
+#include <linux/device.h>
|
|
+#include <linux/err.h>
|
|
+#include <linux/kdev_t.h>
|
|
+#include <linux/clk.h>
|
|
+#include <linux/io.h>
|
|
+#include <linux/slab.h>
|
|
+#include <linux/miscdevice.h>
|
|
+#include <linux/seq_file.h>
|
|
+#include "dump_reg.h"
|
|
+
|
|
+/* for dump_reg misc driver */
|
|
+static struct dump_addr misc_dump_para;
|
|
+static struct write_group *misc_wt_group;
|
|
+static struct compare_group *misc_cmp_group;
|
|
+
|
|
+static ssize_t
|
|
+misc_dump_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
+{
|
|
+ return __dump_regs_ex(&misc_dump_para, buf, PAGE_SIZE);
|
|
+}
|
|
+
|
|
+static ssize_t
|
|
+misc_dump_store(struct device *dev, struct device_attribute *attr,
|
|
+ const char *buf, size_t size)
|
|
+{
|
|
+ int index;
|
|
+ unsigned long start_reg = 0;
|
|
+ unsigned long end_reg = 0;
|
|
+
|
|
+ if (__parse_dump_str(buf, size, &start_reg, &end_reg)) {
|
|
+ pr_err("%s,%d err, invalid para!\n", __func__, __LINE__);
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ index = __addr_valid(start_reg);
|
|
+ if ((index < 0) || (index != __addr_valid(end_reg))) {
|
|
+ pr_err("%s,%d err, invalid para!\n", __func__, __LINE__);
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ misc_dump_para.uaddr_start = start_reg;
|
|
+ misc_dump_para.uaddr_end = end_reg;
|
|
+ pr_debug("%s,%d, start_reg:" PRINT_ADDR_FMT ", end_reg:" PRINT_ADDR_FMT
|
|
+ "\n", __func__, __LINE__, start_reg, end_reg);
|
|
+
|
|
+ return size;
|
|
+
|
|
+err:
|
|
+ misc_dump_para.uaddr_start = 0;
|
|
+ misc_dump_para.uaddr_end = 0;
|
|
+
|
|
+ return -EINVAL;
|
|
+}
|
|
+
|
|
+static ssize_t
|
|
+misc_write_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
+{
|
|
+ /* display write result */
|
|
+ return __write_show(misc_wt_group, buf, PAGE_SIZE);
|
|
+}
|
|
+
|
|
+static ssize_t
|
|
+misc_write_store(struct device *dev, struct device_attribute *attr,
|
|
+ const char *buf, size_t size)
|
|
+{
|
|
+ int i;
|
|
+ int index;
|
|
+ unsigned long reg;
|
|
+ u32 val;
|
|
+ const struct dump_struct *dump;
|
|
+ struct dump_addr dump_addr;
|
|
+
|
|
+ /* free if not NULL */
|
|
+ if (misc_wt_group) {
|
|
+ __write_item_deinit(misc_wt_group);
|
|
+ misc_wt_group = NULL;
|
|
+ }
|
|
+
|
|
+ /* parse input buf for items that will be dumped */
|
|
+ if (__write_item_init(&misc_wt_group, buf, size) < 0)
|
|
+ return -EINVAL;
|
|
+
|
|
+ /**
|
|
+ * write reg
|
|
+ * it is better if the regs been remaped and unmaped only once,
|
|
+ * but we map everytime for the range between min and max address
|
|
+ * maybe too large.
|
|
+ */
|
|
+ for (i = 0; i < misc_wt_group->num; i++) {
|
|
+ reg = misc_wt_group->pitem[i].reg_addr;
|
|
+ dump_addr.uaddr_start = reg;
|
|
+ val = misc_wt_group->pitem[i].val;
|
|
+ index = __addr_valid(reg);
|
|
+ dump = &dump_table[index];
|
|
+ if (dump->remap)
|
|
+ dump_addr.vaddr_start = dump->remap(reg, 4);
|
|
+ else
|
|
+ dump_addr.vaddr_start = (void __iomem *)reg;
|
|
+ dump->write(val, dump->get_vaddr(&dump_addr, reg));
|
|
+ if (dump->unmap)
|
|
+ dump->unmap(dump_addr.vaddr_start);
|
|
+ }
|
|
+
|
|
+ return size;
|
|
+}
|
|
+
|
|
+static ssize_t
|
|
+misc_compare_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
+{
|
|
+ /* dump the items */
|
|
+ return __compare_regs_ex(misc_cmp_group, buf, PAGE_SIZE);
|
|
+}
|
|
+
|
|
+static ssize_t
|
|
+misc_compare_store(struct device *dev, struct device_attribute *attr,
|
|
+ const char *buf, size_t size)
|
|
+{
|
|
+ /* free if struct not null */
|
|
+ if (misc_cmp_group) {
|
|
+ __compare_item_deinit(misc_cmp_group);
|
|
+ misc_cmp_group = NULL;
|
|
+ }
|
|
+
|
|
+ /* parse input buf for items that will be dumped */
|
|
+ if (__compare_item_init(&misc_cmp_group, buf, size) < 0)
|
|
+ return -EINVAL;
|
|
+
|
|
+ return size;
|
|
+}
|
|
+
|
|
+static DEVICE_ATTR(dump, S_IWUSR | S_IRUGO, misc_dump_show, misc_dump_store);
|
|
+static DEVICE_ATTR(write, S_IWUSR | S_IRUGO, misc_write_show, misc_write_store);
|
|
+static DEVICE_ATTR(compare, S_IWUSR | S_IRUGO, misc_compare_show,
|
|
+ misc_compare_store);
|
|
+
|
|
+static struct attribute *misc_attributes[] = { /* files under '/sys/devices/virtual/misc/sunxi-reg/rw/' */
|
|
+ &dev_attr_dump.attr,
|
|
+ &dev_attr_write.attr,
|
|
+ &dev_attr_compare.attr,
|
|
+ NULL,
|
|
+};
|
|
+
|
|
+static struct attribute_group misc_attribute_group = {
|
|
+ .name = "rw", /* directory: '/sys/devices/virtual/misc/sunxi-reg/rw/' */
|
|
+ .attrs = misc_attributes,
|
|
+};
|
|
+
|
|
+static struct miscdevice dump_reg_dev = {
|
|
+ .minor = MISC_DYNAMIC_MINOR,
|
|
+ .name = "sunxi-reg", /* device node: '/dev/sunxi-reg' */
|
|
+};
|
|
+
|
|
+static int __init misc_dump_reg_init(void)
|
|
+{
|
|
+ int err;
|
|
+
|
|
+ pr_info("misc dump reg init\n");
|
|
+ err = misc_register(&dump_reg_dev);
|
|
+ if (err) {
|
|
+ pr_err("dump register driver as misc device error!\n");
|
|
+ goto exit;
|
|
+ }
|
|
+
|
|
+ err = sysfs_create_group(&dump_reg_dev.this_device->kobj,
|
|
+ &misc_attribute_group);
|
|
+ if (err)
|
|
+ pr_err("dump register sysfs create group failed!\n");
|
|
+
|
|
+exit:
|
|
+ return err;
|
|
+}
|
|
+
|
|
+static void __exit misc_dump_reg_exit(void)
|
|
+{
|
|
+ pr_info("misc dump reg exit\n");
|
|
+
|
|
+ sysfs_remove_group(&(dump_reg_dev.this_device->kobj),
|
|
+ &misc_attribute_group);
|
|
+ misc_deregister(&dump_reg_dev);
|
|
+}
|
|
+
|
|
+module_init(misc_dump_reg_init);
|
|
+module_exit(misc_dump_reg_exit);
|
|
+
|
|
+MODULE_ALIAS("misc dump reg driver");
|
|
+MODULE_LICENSE("GPL v2");
|
|
+MODULE_VERSION("1.0.1");
|
|
+MODULE_AUTHOR("xiafeng <xiafeng@allwinnertech.com>");
|
|
+MODULE_DESCRIPTION("misc dump registers driver");
|
|
diff --git a/drivers/char/sunxi-sysinfo/Kconfig b/drivers/char/sunxi-sysinfo/Kconfig
|
|
new file mode 100644
|
|
index 000000000..9b6e2f06d
|
|
--- /dev/null
|
|
+++ b/drivers/char/sunxi-sysinfo/Kconfig
|
|
@@ -0,0 +1,10 @@
|
|
+#
|
|
+# sunxi system information driver.
|
|
+#
|
|
+
|
|
+config SUNXI_SYS_INFO
|
|
+ tristate "sunxi system info driver"
|
|
+ default y
|
|
+ help
|
|
+ This driver is used for query system information.
|
|
+ If you don't know whether need it, please select y.
|
|
diff --git a/drivers/char/sunxi-sysinfo/Makefile b/drivers/char/sunxi-sysinfo/Makefile
|
|
new file mode 100644
|
|
index 000000000..188696592
|
|
--- /dev/null
|
|
+++ b/drivers/char/sunxi-sysinfo/Makefile
|
|
@@ -0,0 +1,5 @@
|
|
+#
|
|
+# Makefile for sunxi system information driver
|
|
+#
|
|
+
|
|
+obj-$(CONFIG_SUNXI_SYS_INFO) += sunxi-sysinfo.o
|
|
diff --git a/drivers/char/sunxi-sysinfo/sunxi-sysinfo.c b/drivers/char/sunxi-sysinfo/sunxi-sysinfo.c
|
|
new file mode 100644
|
|
index 000000000..349b92bf1
|
|
--- /dev/null
|
|
+++ b/drivers/char/sunxi-sysinfo/sunxi-sysinfo.c
|
|
@@ -0,0 +1,178 @@
|
|
+/*
|
|
+ * Based on drivers/char/sunxi-sysinfo/sunxi-sysinfo.c
|
|
+ *
|
|
+ * Copyright (C) 2015 Allwinnertech Ltd.
|
|
+ *
|
|
+ * This program is free software; you can redistribute it and/or modify
|
|
+ * it under the terms of the GNU General Public License 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.
|
|
+ *
|
|
+ * You should have received a copy of the GNU General Public License
|
|
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
+ */
|
|
+
|
|
+#include <linux/module.h>
|
|
+#include <linux/printk.h>
|
|
+#include <linux/kernel.h>
|
|
+#include <linux/device.h>
|
|
+#include <linux/vmalloc.h>
|
|
+#include <linux/uaccess.h>
|
|
+#include <linux/fs.h>
|
|
+#include <linux/miscdevice.h>
|
|
+#include <linux/compat.h>
|
|
+#include <linux/platform_device.h>
|
|
+#include <linux/of_platform.h>
|
|
+#include <linux/of.h>
|
|
+
|
|
+extern int sunxi_get_soc_chipid(unsigned char *chipid);
|
|
+extern int sunxi_get_serial(unsigned char *serial);
|
|
+
|
|
+struct sunxi_info_quirks {
|
|
+ char * platform_name;
|
|
+};
|
|
+
|
|
+static const struct sunxi_info_quirks sun5i_h6_info_quirks = {
|
|
+ .platform_name = "sun50i-h6",
|
|
+};
|
|
+
|
|
+static const struct sunxi_info_quirks sun5i_h616_info_quirks = {
|
|
+ .platform_name = "sun50i-h616",
|
|
+};
|
|
+
|
|
+struct sunxi_info_quirks *quirks;
|
|
+
|
|
+static int soc_info_open(struct inode *inode, struct file *file)
|
|
+{
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+static int soc_info_release(struct inode *inode, struct file *file)
|
|
+{
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+static const struct file_operations soc_info_ops = {
|
|
+ .owner = THIS_MODULE,
|
|
+ .open = soc_info_open,
|
|
+ .release = soc_info_release,
|
|
+};
|
|
+
|
|
+struct miscdevice soc_info_device = {
|
|
+ .minor = MISC_DYNAMIC_MINOR,
|
|
+ .name = "sunxi_soc_info",
|
|
+ .fops = &soc_info_ops,
|
|
+};
|
|
+
|
|
+static ssize_t sys_info_show(struct class *class,
|
|
+ struct class_attribute *attr, char *buf)
|
|
+{
|
|
+ int i;
|
|
+ int databuf[4] = {0};
|
|
+ char tmpbuf[129] = {0};
|
|
+ size_t size = 0;
|
|
+
|
|
+ /* platform */
|
|
+ size += sprintf(buf + size, "sunxi_platform : %s\n", quirks->platform_name);
|
|
+
|
|
+ /* chipid */
|
|
+ sunxi_get_soc_chipid((u8 *)databuf);
|
|
+
|
|
+ for (i = 0; i < 4; i++)
|
|
+ sprintf(tmpbuf + i*8, "%08x", databuf[i]);
|
|
+ tmpbuf[128] = 0;
|
|
+ size += sprintf(buf + size, "sunxi_chipid : %s\n", tmpbuf);
|
|
+
|
|
+ /* serial */
|
|
+ sunxi_get_serial((u8 *)databuf);
|
|
+ for (i = 0; i < 4; i++)
|
|
+ sprintf(tmpbuf + i*8, "%08x", databuf[i]);
|
|
+ tmpbuf[128] = 0;
|
|
+ size += sprintf(buf + size, "sunxi_serial : %s\n", tmpbuf);
|
|
+
|
|
+ return size;
|
|
+}
|
|
+
|
|
+static struct class_attribute info_class_attrs[] = {
|
|
+ __ATTR(sys_info, 0644, sys_info_show, NULL),
|
|
+};
|
|
+
|
|
+static struct class info_class = {
|
|
+ .name = "sunxi_info",
|
|
+ .owner = THIS_MODULE,
|
|
+};
|
|
+
|
|
+static const struct of_device_id sunxi_info_match[] = {
|
|
+ {
|
|
+ .compatible = "allwinner,sun50i-h6-sys-info",
|
|
+ .data = &sun5i_h6_info_quirks,
|
|
+ },
|
|
+ {
|
|
+ .compatible = "allwinner,sun50i-h616-sys-info",
|
|
+ .data = &sun5i_h616_info_quirks,
|
|
+ },
|
|
+ {}
|
|
+};
|
|
+
|
|
+static int sunxi_info_probe(struct platform_device *pdev)
|
|
+{
|
|
+ int i, ret = 0;
|
|
+
|
|
+ quirks = of_device_get_match_data(&pdev->dev);
|
|
+ if (quirks == NULL) {
|
|
+ dev_err(&pdev->dev, "Failed to determine the quirks to use\n");
|
|
+ return -ENODEV;
|
|
+ }
|
|
+
|
|
+ ret = class_register(&info_class);
|
|
+ if (ret != 0)
|
|
+ return ret;
|
|
+
|
|
+ /* need some class specific sysfs attributes */
|
|
+ for (i = 0; i < ARRAY_SIZE(info_class_attrs); i++) {
|
|
+ ret = class_create_file(&info_class, &info_class_attrs[i]);
|
|
+ if (ret)
|
|
+ goto out_class_create_file_failed;
|
|
+ }
|
|
+
|
|
+ ret = misc_register(&soc_info_device);
|
|
+ if (ret != 0) {
|
|
+ pr_err("%s: misc_register() failed!(%d)\n", __func__, ret);
|
|
+ class_unregister(&info_class);
|
|
+ return ret;
|
|
+ }
|
|
+
|
|
+ return ret;
|
|
+
|
|
+out_class_create_file_failed:
|
|
+ class_unregister(&info_class);
|
|
+
|
|
+ return ret;
|
|
+}
|
|
+
|
|
+static int sunxi_info_remove(struct platform_device *pdev)
|
|
+{
|
|
+ misc_deregister(&soc_info_device);
|
|
+ class_unregister(&info_class);
|
|
+
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+static struct platform_driver sunxi_info_driver = {
|
|
+ .probe = sunxi_info_probe,
|
|
+ .remove = sunxi_info_remove,
|
|
+ .driver = {
|
|
+ .name = "sunxi_info",
|
|
+ .owner = THIS_MODULE,
|
|
+ .of_match_table = sunxi_info_match,
|
|
+ },
|
|
+};
|
|
+module_platform_driver(sunxi_info_driver);
|
|
+
|
|
+MODULE_LICENSE("GPL v2");
|
|
+MODULE_AUTHOR("xiafeng<xiafeng@allwinnertech.com>");
|
|
+MODULE_DESCRIPTION("sunxi sys info.");
|
|
--
|
|
2.25.1
|
|
|