Changes in [v2]:
- Use reserved memory regions instead of regs in DT
- Code cleanup suggested by Bjorn and Stephen
- Remove unused structures and functions.
- Update function names from _get_ to _read_
- Add documentation
These patches add support for reading a shared memory database in the newer
QCOM SoCs called Command DB. With the new architecture on SDM845, shared
resources like clocks, regulators etc., have dynamic properties. These
properties may change based on external components, board configurations or
available feature set. A remote processor detects these parameters and fills up
the database with the resource and available state information. Platform
drivers that need these shared resources will need to query this database to
get the address and properties and vote for the state.
The information in the database is static. The database is read-only memory
location that is available for Linux. A pre-defined string is used as a key into
an entry in the database. Generally, platform drivers query the database only
at init to get the information they need.
[v1]: https://www.spinics.net/lists/linux-arm-msm/msg32462.html
Lina Iyer (2):
drivers: qcom: add command DB driver
dt-bindings: introduce Command DB for QCOM SoCs
.../devicetree/bindings/arm/msm/cmd-db.txt | 38 +++
drivers/soc/qcom/Kconfig | 9 +
drivers/soc/qcom/Makefile | 1 +
drivers/soc/qcom/cmd-db.c | 321 +++++++++++++++++++++
include/soc/qcom/cmd-db.h | 50 ++++
5 files changed, 419 insertions(+)
create mode 100644 Documentation/devicetree/bindings/arm/msm/cmd-db.txt
create mode 100644 drivers/soc/qcom/cmd-db.c
create mode 100644 include/soc/qcom/cmd-db.h
--
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project
From: Mahesh Sivasubramanian <[email protected]>
Command DB is a simple database in the shared memory of QCOM SoCs, that
provides information regarding shared resources. Some shared resources
in the SoC have properties that are probed dynamically at boot by the
remote processor. The information pertaining to the SoC and the platform
are made available in the shared memory. Drivers can query this
information using predefined strings.
Signed-off-by: Mahesh Sivasubramanian <[email protected]>
Signed-off-by: Lina Iyer <[email protected]>
---
drivers/soc/qcom/Kconfig | 9 ++
drivers/soc/qcom/Makefile | 1 +
drivers/soc/qcom/cmd-db.c | 321 ++++++++++++++++++++++++++++++++++++++++++++++
include/soc/qcom/cmd-db.h | 50 ++++++++
4 files changed, 381 insertions(+)
create mode 100644 drivers/soc/qcom/cmd-db.c
create mode 100644 include/soc/qcom/cmd-db.h
diff --git a/drivers/soc/qcom/Kconfig b/drivers/soc/qcom/Kconfig
index b81374bb6713..7facac2cae23 100644
--- a/drivers/soc/qcom/Kconfig
+++ b/drivers/soc/qcom/Kconfig
@@ -3,6 +3,15 @@
#
menu "Qualcomm SoC drivers"
+config QCOM_COMMAND_DB
+ bool "Qualcomm Command DB"
+ depends on ARCH_QCOM || COMPILE_TEST
+ help
+ Command DB queries shared memory by key string for shared system
+ resources. Platform drivers that require to set state of a shared
+ resource on a RPM-hardened platform must use this database to get
+ SoC specific identifier and information for the shared resources.
+
config QCOM_GLINK_SSR
tristate "Qualcomm Glink SSR driver"
depends on RPMSG
diff --git a/drivers/soc/qcom/Makefile b/drivers/soc/qcom/Makefile
index 40c56f67e94a..fdec77c26b3f 100644
--- a/drivers/soc/qcom/Makefile
+++ b/drivers/soc/qcom/Makefile
@@ -1,4 +1,5 @@
# SPDX-License-Identifier: GPL-2.0
+obj-$(CONFIG_QCOM_COMMAND_DB) += cmd-db.o
obj-$(CONFIG_QCOM_GLINK_SSR) += glink_ssr.o
obj-$(CONFIG_QCOM_GSBI) += qcom_gsbi.o
obj-$(CONFIG_QCOM_MDT_LOADER) += mdt_loader.o
diff --git a/drivers/soc/qcom/cmd-db.c b/drivers/soc/qcom/cmd-db.c
new file mode 100644
index 000000000000..050a56da76c8
--- /dev/null
+++ b/drivers/soc/qcom/cmd-db.c
@@ -0,0 +1,321 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved. */
+
+#include <linux/kernel.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_platform.h>
+#include <linux/of_reserved_mem.h>
+#include <linux/platform_device.h>
+#include <linux/types.h>
+
+#include <soc/qcom/cmd-db.h>
+
+#define NUM_PRIORITY 2
+#define MAX_SLV_ID 8
+#define CMD_DB_MAGIC 0x0C0330DBUL
+#define SLAVE_ID_MASK 0x7
+#define SLAVE_ID_SHIFT 16
+
+#define ENTRY_HEADER(hdr) ((void *)cmd_db_header + \
+ sizeof(*cmd_db_header) + \
+ hdr->header_offset)
+
+#define RSC_OFFSET(hdr, ent) ((void *)cmd_db_header + \
+ sizeof(*cmd_db_header) + \
+ hdr.data_offset + ent.offset)
+
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+
+/**
+ * entry_header: header for each entry in cmddb
+ *
+ * @id: resource's identifier
+ * @priority: unused
+ * @addr: the address of the resource
+ * @len: length of the data
+ * @offset: offset at which data starts
+ */
+struct entry_header {
+ u64 id;
+ u32 priority[NUM_PRIORITY];
+ u32 addr;
+ u16 len;
+ u16 offset;
+};
+
+/**
+ * rsc_hdr: resource header information
+ *
+ * @slv_id: id for the resource
+ * @header_offset: Entry header offset from data
+ * @data_offset: Entry offset for data location
+ * @cnt: number of entries for HW type
+ * @version: MSB is major, LSB is minor
+ */
+struct rsc_hdr {
+ u16 slv_id;
+ u16 header_offset;
+ u16 data_offset;
+ u16 cnt;
+ u16 version;
+ u16 reserved[3];
+};
+
+/**
+ * cmd_db_header: The DB header information
+ *
+ * @version: The cmd db version
+ * @magic_number: constant expected in the database
+ * @header: array of resources
+ * @check_sum: check sum for the header. Unused.
+ * @reserved: reserved memory
+ * @data: driver specific data
+ */
+struct cmd_db_header {
+ u32 version;
+ u32 magic_num;
+ struct rsc_hdr header[MAX_SLV_ID];
+ u32 check_sum;
+ u32 reserved;
+ u8 data[];
+};
+
+/**
+ * DOC: Description of the Command DB database.
+ *
+ * At the start of the command DB memory is the cmd_db_header structure.
+ * The cmd_db_header holds the version, checksum, magic key as well as an
+ * array for header for each slave (depicted by the rsc_header). Each h/w
+ * based accelerator is a 'slave' (shared resource) and has slave id indicating
+ * the type of accelerator. The rsc_header is the header for such individual
+ * slaves of a given type. The entries for each of these slaves begin at the
+ * rsc_hdr.header_offset. In addition each slave could have auxiliary data
+ * that may be needed by the driver. The data for the slave starts at the
+ * entry_header.offset to the location pointed to by the rsc_hdr.data_offset.
+ *
+ * Drivers have a stringified key to a slave/resource. They can query the slave
+ * information and get the slave id and the auxiliary data and the length of the
+ * data. Using this information, they can format the request to be sent to the
+ * h/w accelerator and request a resource state.
+ */
+
+static struct cmd_db_header *cmd_db_header;
+
+/**
+ * cmd_db_ready - Indicates if command DB is available
+ *
+ * Return: 0 on success, errno otherwise
+ */
+int cmd_db_ready(void)
+{
+ if (cmd_db_header == NULL)
+ return -EPROBE_DEFER;
+ else if (cmd_db_header->magic_num != CMD_DB_MAGIC)
+ return -EINVAL;
+ else
+ return 0;
+}
+EXPORT_SYMBOL(cmd_db_ready);
+
+static u64 cmd_db_get_u64_id(const char *id)
+{
+ u64 rsc_id = 0;
+ u8 *ch = (u8 *)&rsc_id;
+ int i;
+
+ for (i = 0; i < sizeof(rsc_id) && id[i]; i++)
+ ch[i] = id[i];
+
+ return rsc_id;
+}
+
+static int cmd_db_get_header(u64 query, struct entry_header *eh,
+ struct rsc_hdr *rh)
+{
+ struct rsc_hdr *rsc_hdr;
+ struct entry_header *ent;
+ int ret, i, j;
+
+ ret = cmd_db_ready();
+ if (ret)
+ return ret;
+
+ if (!eh || !rh)
+ return -EINVAL;
+
+ for (i = 0; i < MAX_SLV_ID; i++) {
+ rsc_hdr = &cmd_db_header->header[i];
+ if (!rsc_hdr->slv_id)
+ break;
+
+ ent = ENTRY_HEADER(rsc_hdr);
+ for (j = 0; j < rsc_hdr->cnt; j++, ent++) {
+ if (ent->id == query)
+ break;
+ }
+
+ if (j < rsc_hdr->cnt) {
+ memcpy(eh, ent, sizeof(*ent));
+ memcpy(rh, rsc_hdr, sizeof(*rh));
+ return 0;
+ }
+ }
+
+ return -ENODEV;
+}
+
+static int cmd_db_get_header_by_rsc_id(const char *id,
+ struct entry_header *ent_hdr,
+ struct rsc_hdr *rsc_hdr)
+{
+ u64 rsc_id = cmd_db_get_u64_id(id);
+
+ return cmd_db_get_header(rsc_id, ent_hdr, rsc_hdr);
+}
+
+/**
+ * cmd_db_read_addr() - Query command db for resource id address.
+ *
+ * @id: resource id to query for address
+ *
+ * This is used to retrieve resource address based on resource
+ * id.
+ * Return: resource address on success, 0 on error
+ */
+u32 cmd_db_read_addr(const char *id)
+{
+ int ret;
+ struct entry_header ent;
+ struct rsc_hdr rsc_hdr;
+
+ ret = cmd_db_get_header_by_rsc_id(id, &ent, &rsc_hdr);
+
+ return ret < 0 ? 0 : ent.addr;
+}
+EXPORT_SYMBOL(cmd_db_read_addr);
+
+/**
+ * cmd_db_read_aux_data() - Query command db for aux data.
+ *
+ * @id : Resource to retrieve AUX Data on.
+ * @data : Data buffer to copy returned aux data to. Returns size on NULL
+ * @len : Caller provides size of data buffer passed in.
+ *
+ * Return: size of data on success, errno on error
+ */
+int cmd_db_read_aux_data(const char *id, u8 *data, int len)
+{
+ int ret;
+ struct entry_header ent;
+ struct rsc_hdr rsc_hdr;
+
+ if (!data)
+ return -EINVAL;
+
+ ret = cmd_db_get_header_by_rsc_id(id, &ent, &rsc_hdr);
+ if (ret)
+ return ret;
+
+ if (len < ent.len)
+ return -EINVAL;
+
+ len = MIN(ent.len, len);
+ memcpy(data, RSC_OFFSET(rsc_hdr, ent), len);
+
+ return len;
+}
+EXPORT_SYMBOL(cmd_db_read_aux_data);
+
+/**
+ * cmd_db_read_aux_data_len - Get the length of the auxllary data stored in DB.
+ *
+ * @id: Resource to retrieve AUX Data.
+ *
+ * Return: size on success, 0 on error
+ */
+size_t cmd_db_read_aux_data_len(const char *id)
+{
+ int ret;
+ struct entry_header ent;
+ struct rsc_hdr rsc_hdr;
+
+ ret = cmd_db_get_header_by_rsc_id(id, &ent, &rsc_hdr);
+
+ return ret < 0 ? 0 : ent.len;
+}
+EXPORT_SYMBOL(cmd_db_read_aux_data_len);
+
+/**
+ * cmd_db_read_slave_id - Get the slave ID for a given resource address
+ *
+ * @id: Resource id to query the DB for version
+ *
+ * Return: cmd_db_hw_type enum on success, CMD_DB_HW_INVALID on error
+ */
+enum cmd_db_hw_type cmd_db_read_slave_id(const char *id)
+{
+ int ret;
+ struct entry_header ent;
+ struct rsc_hdr rsc_hdr;
+
+ ret = cmd_db_get_header_by_rsc_id(id, &ent, &rsc_hdr);
+
+ return ret < 0 ? CMD_DB_HW_INVALID :
+ (ent.addr >> SLAVE_ID_SHIFT) & SLAVE_ID_MASK;
+}
+EXPORT_SYMBOL(cmd_db_read_slave_id);
+
+static int cmd_db_dev_probe(struct platform_device *pdev)
+{
+ struct reserved_mem *rmem;
+ void *dict, *start_addr;
+ int ret = 0;
+
+ rmem = of_reserved_mem_lookup(pdev->dev.of_node);
+ if (!rmem) {
+ dev_err(&pdev->dev, "failed to acquire memory region\n");
+ return -EINVAL;
+ }
+
+ dict = devm_memremap(&pdev->dev, rmem->base, rmem->size, MEMREMAP_WB);
+ if (IS_ERR(dict))
+ return -ENOMEM;
+
+ start_addr = memremap(readl_relaxed(dict), readl_relaxed(dict + 0x4),
+ MEMREMAP_WB);
+ if (IS_ERR_OR_NULL(start_addr)) {
+ ret = PTR_ERR(start_addr);
+ goto done;
+ }
+
+ cmd_db_header = start_addr;
+ if (cmd_db_header->magic_num != CMD_DB_MAGIC) {
+ ret = -EINVAL;
+ dev_err(&pdev->dev, "Invalid Command DB Magic\n");
+ goto done;
+ }
+
+done:
+ devm_iounmap(&pdev->dev, dict);
+ return ret;
+}
+
+static const struct of_device_id cmd_db_match_table[] = {
+ { .compatible = "qcom,cmd-db" },
+ { },
+};
+
+static struct platform_driver cmd_db_dev_driver = {
+ .probe = cmd_db_dev_probe,
+ .driver = {
+ .name = "cmd-db",
+ .of_match_table = cmd_db_match_table,
+ },
+};
+
+static int __init cmd_db_device_init(void)
+{
+ return platform_driver_register(&cmd_db_dev_driver);
+}
+arch_initcall(cmd_db_device_init);
diff --git a/include/soc/qcom/cmd-db.h b/include/soc/qcom/cmd-db.h
new file mode 100644
index 000000000000..483d09ea1689
--- /dev/null
+++ b/include/soc/qcom/cmd-db.h
@@ -0,0 +1,50 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved. */
+
+#ifndef __QCOM_COMMAND_DB_H__
+#define __QCOM_COMMAND_DB_H__
+
+
+enum cmd_db_hw_type {
+ CMD_DB_HW_INVALID = 0,
+ CMD_DB_HW_MIN = 3,
+ CMD_DB_HW_ARC = CMD_DB_HW_MIN,
+ CMD_DB_HW_VRM = 4,
+ CMD_DB_HW_BCM = 5,
+ CMD_DB_HW_MAX = CMD_DB_HW_BCM,
+ CMD_DB_HW_ALL = 0xff,
+};
+
+#if IS_ENABLED(CONFIG_QCOM_COMMAND_DB)
+u32 cmd_db_read_addr(const char *resource_id);
+int cmd_db_read_aux_data(const char *resource_id, u8 *data, int len);
+size_t cmd_db_read_aux_data_len(const char *resource_id);
+enum cmd_db_hw_type cmd_db_read_slave_id(const char *resource_id);
+int cmd_db_ready(void);
+#else
+
+static inline u32 cmd_db_read_addr(const char *resource_id)
+{
+ return 0;
+}
+static inline int cmd_db_read_aux_data(const char *resource_id, u8 *data,
+ int len)
+{
+ return -ENODEV;
+}
+static inline size_t cmd_db_read_aux_data_len(const char *resource_id)
+{
+ return -ENODEV;
+}
+
+static inline enum cmd_db_hw_type cmd_db_read_slave_id(const char *resource_id)
+{
+ return -ENODEV;
+}
+static inline int cmd_db_ready(void)
+{
+ return -ENODEV;
+}
+
+#endif /* CONFIG_QCOM_COMMAND_DB */
+#endif /* __QCOM_COMMAND_DB_H__ */
--
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project
From: Mahesh Sivasubramanian <[email protected]>
Command DB provides information on shared resources like clocks,
regulators etc., probed at boot by the remote subsytem and made
available in shared memory.
Cc: [email protected]
Signed-off-by: Mahesh Sivasubramanian <[email protected]>
Signed-off-by: Lina Iyer <[email protected]>
---
.../devicetree/bindings/arm/msm/cmd-db.txt | 38 ++++++++++++++++++++++
1 file changed, 38 insertions(+)
create mode 100644 Documentation/devicetree/bindings/arm/msm/cmd-db.txt
diff --git a/Documentation/devicetree/bindings/arm/msm/cmd-db.txt b/Documentation/devicetree/bindings/arm/msm/cmd-db.txt
new file mode 100644
index 000000000000..e21666e40ebf
--- /dev/null
+++ b/Documentation/devicetree/bindings/arm/msm/cmd-db.txt
@@ -0,0 +1,38 @@
+Command DB
+---------
+
+Command DB is a database that provides a mapping between resource key and the
+resource address for a system resource managed by a remote processor. The data
+is stored in a shared memory region and is loaded by the remote processor.
+
+Some of the Qualcomm Technologies Inc SoC's have hardware accelerators for
+controlling shared resources. Depending on the board configuration the shared
+resource properties may change. These properties are dynamically probed by the
+remote processor and made available in the shared memory.
+
+The devicetree representation of the command DB driver should be:
+
+PROPERTIES:
+- compatible:
+ Usage: required
+ Value type: <string>
+ Definition: Should be "qcom,cmd-db"
+
+- memory-region:
+ Usage: required
+ Value type: <phandle>
+ Definition: The phandle to the reserved memory region.
+
+Example:
+
+ reserved-memory {
+ [...]
+ cmd_db_mem: qcom,cmd-db@c3f000c {
+ reg = <0x0 0xc3f000c 0x0 0x8>;
+ };
+ };
+
+ qcom,cmd-db@c3f000c {
+ compatible = "qcom,cmd-db";
+ memory-region = <&cmd_db_mem>;
+ };
--
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project
On Thu, Feb 08, 2018 at 12:51:53PM -0700, Lina Iyer wrote:
> From: Mahesh Sivasubramanian <[email protected]>
>
> Command DB is a simple database in the shared memory of QCOM SoCs, that
> provides information regarding shared resources. Some shared resources
> in the SoC have properties that are probed dynamically at boot by the
> remote processor. The information pertaining to the SoC and the platform
> are made available in the shared memory. Drivers can query this
> information using predefined strings.
>
> Signed-off-by: Mahesh Sivasubramanian <[email protected]>
> Signed-off-by: Lina Iyer <[email protected]>
> ---
*snip*
> diff --git a/drivers/soc/qcom/cmd-db.c b/drivers/soc/qcom/cmd-db.c
> new file mode 100644
> index 000000000000..050a56da76c8
> --- /dev/null
> +++ b/drivers/soc/qcom/cmd-db.c
> @@ -0,0 +1,321 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved. */
> +
> +#include <linux/kernel.h>
> +#include <linux/of.h>
> +#include <linux/of_address.h>
> +#include <linux/of_platform.h>
> +#include <linux/of_reserved_mem.h>
> +#include <linux/platform_device.h>
> +#include <linux/types.h>
> +
> +#include <soc/qcom/cmd-db.h>
> +
> +#define NUM_PRIORITY 2
> +#define MAX_SLV_ID 8
> +#define CMD_DB_MAGIC 0x0C0330DBUL
> +#define SLAVE_ID_MASK 0x7
> +#define SLAVE_ID_SHIFT 16
> +
> +#define ENTRY_HEADER(hdr) ((void *)cmd_db_header + \
> + sizeof(*cmd_db_header) + \
> + hdr->header_offset)
> +
> +#define RSC_OFFSET(hdr, ent) ((void *)cmd_db_header + \
> + sizeof(*cmd_db_header) + \
> + hdr.data_offset + ent.offset)
> +
> +#define MIN(a, b) (((a) < (b)) ? (a) : (b))
I'm not sure if this was addressed before. Why use a custom macro and not min()
or min_t()?
Jordan
--
The Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum,
a Linux Foundation Collaborative Project
On Thu, Feb 08 2018 at 20:48 +0000, Jordan Crouse wrote:
>On Thu, Feb 08, 2018 at 12:51:53PM -0700, Lina Iyer wrote:
>> From: Mahesh Sivasubramanian <[email protected]>
>>
>> Command DB is a simple database in the shared memory of QCOM SoCs, that
>> provides information regarding shared resources. Some shared resources
>> in the SoC have properties that are probed dynamically at boot by the
>> remote processor. The information pertaining to the SoC and the platform
>> are made available in the shared memory. Drivers can query this
>> information using predefined strings.
>>
>> Signed-off-by: Mahesh Sivasubramanian <[email protected]>
>> Signed-off-by: Lina Iyer <[email protected]>
>> ---
>
>*snip*
>
>> diff --git a/drivers/soc/qcom/cmd-db.c b/drivers/soc/qcom/cmd-db.c
>> new file mode 100644
>> index 000000000000..050a56da76c8
>> --- /dev/null
>> +++ b/drivers/soc/qcom/cmd-db.c
>> @@ -0,0 +1,321 @@
>> +/* SPDX-License-Identifier: GPL-2.0 */
>> +/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved. */
>> +
>> +#include <linux/kernel.h>
>> +#include <linux/of.h>
>> +#include <linux/of_address.h>
>> +#include <linux/of_platform.h>
>> +#include <linux/of_reserved_mem.h>
>> +#include <linux/platform_device.h>
>> +#include <linux/types.h>
>> +
>> +#include <soc/qcom/cmd-db.h>
>> +
>> +#define NUM_PRIORITY 2
>> +#define MAX_SLV_ID 8
>> +#define CMD_DB_MAGIC 0x0C0330DBUL
>> +#define SLAVE_ID_MASK 0x7
>> +#define SLAVE_ID_SHIFT 16
>> +
>> +#define ENTRY_HEADER(hdr) ((void *)cmd_db_header + \
>> + sizeof(*cmd_db_header) + \
>> + hdr->header_offset)
>> +
>> +#define RSC_OFFSET(hdr, ent) ((void *)cmd_db_header + \
>> + sizeof(*cmd_db_header) + \
>> + hdr.data_offset + ent.offset)
>> +
>> +#define MIN(a, b) (((a) < (b)) ? (a) : (b))
>
>I'm not sure if this was addressed before. Why use a custom macro and not min()
>or min_t()?
>
I didn't realize the existance of this. cscope brought out a ton of 'min' defn.
Will fix in the next spin.
Thanks,
Lina
On Thu 08 Feb 11:51 PST 2018, Lina Iyer wrote:
> From: Mahesh Sivasubramanian <[email protected]>
>
> Command DB provides information on shared resources like clocks,
> regulators etc., probed at boot by the remote subsytem and made
> available in shared memory.
>
> Cc: [email protected]
> Signed-off-by: Mahesh Sivasubramanian <[email protected]>
> Signed-off-by: Lina Iyer <[email protected]>
> ---
> .../devicetree/bindings/arm/msm/cmd-db.txt | 38 ++++++++++++++++++++++
> 1 file changed, 38 insertions(+)
> create mode 100644 Documentation/devicetree/bindings/arm/msm/cmd-db.txt
>
> diff --git a/Documentation/devicetree/bindings/arm/msm/cmd-db.txt b/Documentation/devicetree/bindings/arm/msm/cmd-db.txt
> new file mode 100644
> index 000000000000..e21666e40ebf
> --- /dev/null
> +++ b/Documentation/devicetree/bindings/arm/msm/cmd-db.txt
> @@ -0,0 +1,38 @@
> +Command DB
> +---------
> +
> +Command DB is a database that provides a mapping between resource key and the
> +resource address for a system resource managed by a remote processor. The data
> +is stored in a shared memory region and is loaded by the remote processor.
> +
> +Some of the Qualcomm Technologies Inc SoC's have hardware accelerators for
> +controlling shared resources. Depending on the board configuration the shared
> +resource properties may change. These properties are dynamically probed by the
> +remote processor and made available in the shared memory.
> +
> +The devicetree representation of the command DB driver should be:
> +
> +PROPERTIES:
> +- compatible:
> + Usage: required
> + Value type: <string>
> + Definition: Should be "qcom,cmd-db"
> +
> +- memory-region:
> + Usage: required
> + Value type: <phandle>
> + Definition: The phandle to the reserved memory region.
> +
> +Example:
> +
> + reserved-memory {
> + [...]
> + cmd_db_mem: qcom,cmd-db@c3f000c {
> + reg = <0x0 0xc3f000c 0x0 0x8>;
I was hoping that we can describe the actual memory here, as I got the
impression that it will also be a chunk of memory carved out from System
RAM.
If not it would seem unlikely that there's a 8 byte carveout in the
middle of DDR, what else is here?
> + };
> + };
> +
> + qcom,cmd-db@c3f000c {
> + compatible = "qcom,cmd-db";
Add "qcom,cmd-db" to "reserved_mem_matches" in drivers/of/platform.c,
use of_reserved_mem_lookup(pdev->dev.of_node) to get the reserved_mem
and you can just put the compatible directly on the reserved-memory
node.
That way you don't need this separate node that doesn't really represent
anything.
> + memory-region = <&cmd_db_mem>;
> + };
Regards,
Bjorn
On Wed, Feb 14 2018 at 19:34 +0000, Bjorn Andersson wrote:
>On Thu 08 Feb 11:51 PST 2018, Lina Iyer wrote:
>
>> From: Mahesh Sivasubramanian <[email protected]>
>>
>> Command DB provides information on shared resources like clocks,
>> regulators etc., probed at boot by the remote subsytem and made
>> available in shared memory.
>>
>> Cc: [email protected]
>> Signed-off-by: Mahesh Sivasubramanian <[email protected]>
>> Signed-off-by: Lina Iyer <[email protected]>
>> ---
>> .../devicetree/bindings/arm/msm/cmd-db.txt | 38 ++++++++++++++++++++++
>> 1 file changed, 38 insertions(+)
>> create mode 100644 Documentation/devicetree/bindings/arm/msm/cmd-db.txt
>>
>> diff --git a/Documentation/devicetree/bindings/arm/msm/cmd-db.txt b/Documentation/devicetree/bindings/arm/msm/cmd-db.txt
>> new file mode 100644
>> index 000000000000..e21666e40ebf
>> --- /dev/null
>> +++ b/Documentation/devicetree/bindings/arm/msm/cmd-db.txt
>> @@ -0,0 +1,38 @@
>> +Command DB
>> +---------
>> +
>> +Command DB is a database that provides a mapping between resource key and the
>> +resource address for a system resource managed by a remote processor. The data
>> +is stored in a shared memory region and is loaded by the remote processor.
>> +
>> +Some of the Qualcomm Technologies Inc SoC's have hardware accelerators for
>> +controlling shared resources. Depending on the board configuration the shared
>> +resource properties may change. These properties are dynamically probed by the
>> +remote processor and made available in the shared memory.
>> +
>> +The devicetree representation of the command DB driver should be:
>> +
>> +PROPERTIES:
>> +- compatible:
>> + Usage: required
>> + Value type: <string>
>> + Definition: Should be "qcom,cmd-db"
>> +
>> +- memory-region:
>> + Usage: required
>> + Value type: <phandle>
>> + Definition: The phandle to the reserved memory region.
>> +
>> +Example:
>> +
>> + reserved-memory {
>> + [...]
>> + cmd_db_mem: qcom,cmd-db@c3f000c {
>> + reg = <0x0 0xc3f000c 0x0 0x8>;
>
>I was hoping that we can describe the actual memory here, as I got the
>impression that it will also be a chunk of memory carved out from System
>RAM.
>
Yes, it can be described. But, the location should always be read from
the address above. Generally, the CMD DB memory would not change, but it
is not always guaranteed.
>If not it would seem unlikely that there's a 8 byte carveout in the
>middle of DDR, what else is here?
>
>> + };
>> + };
>> +
>> + qcom,cmd-db@c3f000c {
>> + compatible = "qcom,cmd-db";
>
>Add "qcom,cmd-db" to "reserved_mem_matches" in drivers/of/platform.c,
>use of_reserved_mem_lookup(pdev->dev.of_node) to get the reserved_mem
>and you can just put the compatible directly on the reserved-memory
>node.
>
>That way you don't need this separate node that doesn't really represent
>anything.
>
Oh okay. I can take care of that.
Thanks,
Lina
>> + memory-region = <&cmd_db_mem>;
>> + };