Ultrasoc trace module is a system level solution for both core tracing and SoC tracing. This patch brings in a documentation for ultrasoc framework and drivers. It simply introduces function of ultrasoc, a typical Ultrasoc system, and a driver framework for ultrasoc.

Signed-off-by: Jonathan Zhou jonathan.zhouwen@huawei.com Signed-off-by: Qi Liu liuqi115@huawei.com --- Documentation/trace/ultrasoc-trace.rst | 209 +++++++++++++++++++++++++++++++++ 1 file changed, 209 insertions(+) create mode 100644 Documentation/trace/ultrasoc-trace.rst

diff --git a/Documentation/trace/ultrasoc-trace.rst b/Documentation/trace/ultrasoc-trace.rst new file mode 100644 index 0000000..36d2df2 --- /dev/null +++ b/Documentation/trace/ultrasoc-trace.rst @@ -0,0 +1,209 @@ +======================================================= +Siemens Embedded Analytics - HW Assisted Tracing on SoC +======================================================= + :Author: Jonathan Zhou Jonathan.zhouwen@huawei.com + Qi Liu liuqi115@huawei.com + :Date: January 16th, 2021 + +Introduction +------------ + +The Siemens Embedded Analytics Framework is system level solution for tracing +of multiple type SoC, this document is concerned with trace module. This module +has two main components: AXI Bus Communicator and System Memory Buffer. + +The AXI Communicator has upstream and downstream channels, the upstream channel +is used to transmit user configuration, and downstream channel to carry response +and trace data to the users. + +The System Memory Buffer provides a way to buffer and store messages in system +memory. It provides a capability to store messages received on its input message +interface to an area of system memory. + +A typical Siemens trace system would look like the following diagram: + @@@@@@@@@@@@@ + @ CPU @ + @@@@@@@@@@@@@ + ############# + # Coresight # + # ETM # + ####### + ### + # + | + * + ******************************* + *** AMBA Advanced Trace Bus (ATB) *** + ***************^*************** + =============== | + === FUNNEL ==<--- | + ======= + | + * + @@@@@@@ + @ TRC @ + @@@@@ + @@@ + @ + | + * + ************************************** ******************* + ************************ Message BUS *************************** + ******************^************************^**************** + | | + @@@@@@@@@@@@@@@@@@ | @@@@@@@@@@@@ + @ Message Engine @ | @ JTAG COM @ + @@@@@@@@@@@@@@@@@@ | @@@@@@@@@@ + | * |---> @@@@@@@@ + | | @@@@@@ + @@@@@@@ | @@@@@@@@@@@ | + @ SMB @ | @ AXI COM @ JTAG + @@@@@ |--> @@@@@@@@@ + @@@--| @@@@@@@ + @ | @@@@@ + | | + | | + * * + *************************************************************** + **************************** AMBA AXI **************************** + ***************************************************************** + +Acronyms +--------------------------- + +Acronyms: + +AXI-COM: AXI Communicator +SMB: System Memory Buffer +TRC: Trace receiver + +Framework and implementation +------------------------------ + +Siemens Embedded Analytics Framework is implemented as a platform device. The +platform device provides a global point to configure the Embedded Analytics +subsystem, and also provides a ``struct ultrasoc_com`` to manage AXI-COM and +SMB. + +AXI-COM and SMB are implemented as platform devices, each SCCL has one AXI-COM +device and one SMB device. AXI-COM and SMB can use the following API to register +into Embedded Analytics framework: +.. c:function:: struct ultrasoc_com *ultrasoc_register_com(struct device *root_dev, struct ultrasoc_com_descp *com_descp) +.. c:function:: void ultrasoc_unregister_com(struct ultrasoc_com *com); + +As TRC receives data from coresight ETM device, SMB can use the following API +to register into coresight framework as a sink device: +.. c:function:: struct coresight_device *coresight_register(struct coresight_desc *desc); +.. c:function:: void coresight_unregister(struct coresight_device *csdev); + +Then users can get trace data by this path: ETM->funnel->SMB->System Memory. +More information about coresight framework can be found in +Documention/trace/coresight/coresight.rst. + +If everything goes well, the relationship of Embedded Analytics devices will be +described under the sysfs:: + + $# ls /sys/bus/platform/devices/ + <HID.Embedded Analytics>:00 <HID.axi-com>:00 <HID.smb>:00 + $# ls /sys/bus/platform/devices/<HID.Embedded Analytics>:00 + com_mux firmware_node power <HID.axi-com>:00 + driver message subsystem <HID.smb>:00 + driver_override modalias uevent + $# ls /sys/bus/coresight/devices/ + etm0 etm14 etm2 etm25 etm30 etm8 funnel4 + etm1 etm15 etm20 etm26 etm31 etm9 funnel5 + etm10 etm16 etm21 etm27 etm4 funnel0 funnel6 + etm11 etm17 etm22 etm28 etm5 funnel1 funnel7 + etm12 etm18 etm23 etm29 etm6 funnel2 sink_smb0 + etm13 etm19 etm24 etm3 etm7 funnel3 + $# ls -l /sys/bus/coresight/devices/funnel0/connections/ + <file details> in:0 -> ../../../../system/cpu/cpu0/ARMHC500:00/etm0 + <file details> in:1 -> ../../../../system/cpu/cpu1/ARMHC500:01/etm1 + <file details> in:2 -> ../../../../system/cpu/cpu2/ARMHC500:02/etm2 + <file details> in:3 -> ../../../../system/cpu/cpu3/ARMHC500:03/etm3 + <file details> nr_links + <file details> out:0 -> ../../../HISI0391:00/HISI03A1:00/sink_smb0 + $# ls -l /sys/bus/coresight/devices/sink_smb0/connections/ + <file details> in:101 -> ../../../../ARMHC9FE:05/funnel5 + <file details> in:114 -> ../../../../ARMHC9FE:07/funnel7 + <file details> in:121 -> ../../../../ARMHC9FE:03/funnel3 + <file details> in:39 -> ../../../../ARMHC9FE:00/funnel0 + <file details> in:51 -> ../../../../ARMHC9FE:04/funnel4 + <file details> in:61 -> ../../../../ARMHC9FE:06/funnel6 + <file details> in:68 -> ../../../../ARMHC9FE:02/funnel2 + <file details> in:89 -> ../../../../ARMHC9FE:01/funnel1 + <file details> nr_links + +How to use the Embedded Analytics trace module +----------------------------------------------- + +There are two ways to use the Embedded Analytics trace module: + +1. interacting directly with the devices using the sysFS interface. +2. using the perf cmd line tools. + +1) Using the sysFS interface: + +Before trace collection can start, a coresight sink needs to be identified. +There is no limit on the amount of sinks (nor sources) that can be enabled at +any given moment. As a generic operation, all device pertaining to the sink +class will have an "active" entry in sysfs:: + + $# ls /sys/bus/coresight/devices/ + etm0 etm14 etm2 etm25 etm30 etm8 funnel4 + etm1 etm15 etm20 etm26 etm31 etm9 funnel5 + etm10 etm16 etm21 etm27 etm4 funnel0 funnel6 + etm11 etm17 etm22 etm28 etm5 funnel1 funnel7 + etm12 etm18 etm23 etm29 etm6 funnel2 sink_smb0 + etm13 etm19 etm24 etm3 etm7 funnel3 + $# ls /sys/bus/coresight/devices/sink_smb0 + connections enable_sink firmware_node power subsystem uevent + $# echo 1 > /sys/bus/coresight/devices/sink_smb0/enable_sink + $# cat /sys/bus/coresight/devices/sink_smb0/enable_sink + 1 + +When start trace collection, etm devices corresponding to the enabled sink +should be selected:: + + $# echo 1 > /sys/bus/coresight/devices/etm0/enable_source + $# cat /sys/bus/coresight/devices/etm0/enable_source + 1 + $# cat /sys/bus/platform/devices/<HID.smb>:00/com_status + com-type : DOWN-ONLY + service status : stopped + interrupt status : 0x00000003 + write point : 0x5437f400 <----- The write pointer is moving + +Trace collection is stopped the same way:: + + $# echo 0 > /sys/bus/coresight/devices/etm0/enable_source + $# echo 0 > /sys/bus/coresight/devices/sink_smb0/enable_sink + +The content of the SMB buffer can be harvested directly from /dev:: + + $# dd if=/dev/sink_smb0 of=~/cstrace.bin + 5233+0 records in + 5233+0 records out + 2679296 bytes (2.7 MB) copied, 0.0131708 s, 203 MB/s + + root:/sys/bus/coresight/devices# + +The file cstrace.bin can be decompressed using "ptm2human". + +2) Using perf framework: + +As SMB device has been registered with coresight framework, perf tool can be +used to control Embedded Analytics trace collection, and the method is similar +to using perf to do coresight trace collection. + +The only thing to note is, list of cpus should be correspond to the specified +sink device. + +Example usage of perf:: + + $# ./perf list pmu + cs_etm// [Kernel PMU event] + $# ./perf record -e cs_etm/@sink_smb0/ -C 0 --per-thread sleep 2s + [ perf record: Woken up 2 times to write data ] + [ perf record: Captured and wrote 0.288 MB perf.data ] + $# ./perf report

This patch introduces a platform driver for the top device of Ultrasoc SubSystem. It also provides a framework to manage Ultrasoc communictors, and a set of standard attributes of communicators to access the service data and to configure the communictor drivers. Once a Ultrasoc Communictor driver register itself into the framework, these attributes will be added into communicator devices.

Signed-off-by: Jonathan Zhou jonathan.zhouwen@huawei.com Signed-off-by: Qi Liu liuqi115@huawei.com --- MAINTAINERS | 7 + drivers/Makefile | 1 + drivers/hwtracing/Kconfig | 2 + drivers/hwtracing/ultrasoc/Kconfig | 16 ++ drivers/hwtracing/ultrasoc/Makefile | 7 + drivers/hwtracing/ultrasoc/ultrasoc.c | 518 ++++++++++++++++++++++++++++++++++ drivers/hwtracing/ultrasoc/ultrasoc.h | 168 +++++++++++ 7 files changed, 719 insertions(+) create mode 100644 drivers/hwtracing/ultrasoc/Kconfig create mode 100644 drivers/hwtracing/ultrasoc/Makefile create mode 100644 drivers/hwtracing/ultrasoc/ultrasoc.c create mode 100644 drivers/hwtracing/ultrasoc/ultrasoc.h

diff --git a/MAINTAINERS b/MAINTAINERS index 88c2c4d..d799f6e 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -8324,6 +8324,13 @@ S: Maintained F: drivers/misc/hisi_hikey_usb.c F: Documentation/devicetree/bindings/misc/hisilicon-hikey-usb.yaml

+SIEMENS EMBEDDED ANALYTICS DRIVER +M: Jonathan Zhou Jonathan.zhouwen@huawei.com +M: Qi Liu liuqi115@huawei.com +S: Supported +F: Documentation/trace/ultrasoc-trace.rst +F: drivers/hwtracing/ultrasoc/ + HISILICON PMU DRIVER M: Shaokun Zhang zhangshaokun@hisilicon.com S: Supported diff --git a/drivers/Makefile b/drivers/Makefile index 5a6d613..4c132a7 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -176,6 +176,7 @@ obj-$(CONFIG_PERF_EVENTS) += perf/ obj-$(CONFIG_RAS) += ras/ obj-$(CONFIG_USB4) += thunderbolt/ obj-$(CONFIG_CORESIGHT) += hwtracing/coresight/ +obj-y += hwtracing/ultrasoc/ obj-y += hwtracing/intel_th/ obj-$(CONFIG_STM) += hwtracing/stm/ obj-$(CONFIG_ANDROID) += android/ diff --git a/drivers/hwtracing/Kconfig b/drivers/hwtracing/Kconfig index 1308583..3829030 100644 --- a/drivers/hwtracing/Kconfig +++ b/drivers/hwtracing/Kconfig @@ -5,4 +5,6 @@ source "drivers/hwtracing/stm/Kconfig"

source "drivers/hwtracing/intel_th/Kconfig"

+source "drivers/hwtracing/ultrasoc/Kconfig" + endmenu diff --git a/drivers/hwtracing/ultrasoc/Kconfig b/drivers/hwtracing/ultrasoc/Kconfig new file mode 100644 index 0000000..90a3934 --- /dev/null +++ b/drivers/hwtracing/ultrasoc/Kconfig @@ -0,0 +1,16 @@ +# SPDX-License-Identifier: MIT +# +# ultrasoc configuration +# + +menuconfig ULTRASOC + tristate "Ultrasoc Tracing Support" + select CORESIGHT + help + This framework provides a kernel interface for the Ultrasoc trace + drivers to register themselves with. It's intended to build + a topological view of the Ultrasoc components based on ACPI + specification and configure the right series of components when a + trace source gets enabled. + +endif diff --git a/drivers/hwtracing/ultrasoc/Makefile b/drivers/hwtracing/ultrasoc/Makefile new file mode 100644 index 0000000..a747171 --- /dev/null +++ b/drivers/hwtracing/ultrasoc/Makefile @@ -0,0 +1,7 @@ +# # SPDX-License-Identifier: MIT +# +# Makefile for ultrasoc drivers. +# + +obj-$(CONFIG_ULTRASOC) += ultrasoc-drv.o +ultrasoc-drv-objs := ultrasoc.o diff --git a/drivers/hwtracing/ultrasoc/ultrasoc.c b/drivers/hwtracing/ultrasoc/ultrasoc.c new file mode 100644 index 0000000..191c3ec --- /dev/null +++ b/drivers/hwtracing/ultrasoc/ultrasoc.c @@ -0,0 +1,518 @@ +// SPDX-License-Identifier: MIT +/* + * Copyright (C) 2021 Hisilicon Limited Permission is hereby granted, free of + * charge, to any person obtaining a copy of this software and associated + * documentation files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, modify, + * merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject + * to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * Code herein communicates with and accesses proprietary hardware which is + * licensed intellectual property (IP) belonging to Siemens Digital Industries + * Software Ltd. + * + * Siemens Digital Industries Software Ltd. asserts and reserves all rights to + * their intellectual property. This paragraph may not be removed or modified + * in any way without permission from Siemens Digital Industries Software Ltd. + */ +#include <linux/delay.h> +#include <linux/err.h> +#include <linux/io.h> +#include <linux/kthread.h> +#include <linux/module.h> +#include <linux/mod_devicetable.h> +#include <linux/platform_device.h> + +#include "ultrasoc.h" + +static ssize_t com_mux_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t size) +{ + struct ultrasoc_drv_data *drvdata = dev_get_drvdata(dev); + long val; + int ret; + + ret = kstrtol(buf, 0, &val); + if (ret) + return -EINVAL; + + writel(val & 0xffffffff, drvdata->com_mux); + return size; +} + +static ssize_t com_mux_show(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct ultrasoc_drv_data *drvdata = dev_get_drvdata(dev); + + return sysfs_emit(buf, "0x%x\n", readl(drvdata->com_mux)); +} +static DEVICE_ATTR_RW(com_mux); + +static umode_t ultrasoc_com_mux_is_visible(struct kobject *kobj, + struct attribute *attr, int unused) +{ + struct device *dev = kobj_to_dev(kobj); + struct ultrasoc_drv_data *drvdata = dev_get_drvdata(dev); + + if (IS_ERR(drvdata->com_mux)) + return 0; + + return attr->mode; +} + +static struct attribute *ultrasoc_com_mux_attr[] = { + &dev_attr_com_mux.attr, + NULL, +}; + +static const struct attribute_group ultrasoc_com_mux_group = { + .attrs = ultrasoc_com_mux_attr, + .is_visible = ultrasoc_com_mux_is_visible, +}; + +static const struct attribute_group *ultrasoc_global_groups[] = { + &ultrasoc_com_mux_group, + NULL, +}; + +static int ultrasoc_probe(struct platform_device *pdev) +{ + struct ultrasoc_drv_data *drvdata; + + drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL); + if (!drvdata) + return -ENOMEM; + drvdata->dev = &pdev->dev; + INIT_LIST_HEAD(&drvdata->ultrasoc_com_head); + + drvdata->com_mux = devm_platform_ioremap_resource(pdev, 0); + if (IS_ERR(drvdata->com_mux)) { + dev_err(&pdev->dev, "Failed to ioremap for com_mux resource.\n"); + return PTR_ERR(drvdata->com_mux); + } + /* switch ultrasoc commucator mux for on-chip drivers. */ + writel(US_SELECT_ONCHIP, drvdata->com_mux); + platform_set_drvdata(pdev, drvdata); + + return 0; +} + +static int ultrasoc_remove(struct platform_device *pdev) +{ + struct ultrasoc_drv_data *pdata = platform_get_drvdata(pdev); + + /* switch back to external debuger users if necessary.*/ + if (!IS_ERR(pdata->com_mux)) + writel(0, pdata->com_mux); + + return 0; +} + +static struct acpi_device_id ultrasoc_acpi_match[] = { + {"HISI0391", }, + {}, +}; +MODULE_DEVICE_TABLE(acpi, ultrasoc_acpi_match); + +static struct platform_driver ultrasoc_driver = { + .driver = { + .name = "ultrasoc", + .acpi_match_table = ultrasoc_acpi_match, + .dev_groups = ultrasoc_global_groups, + }, + .probe = ultrasoc_probe, + .remove = ultrasoc_remove, +}; +module_platform_driver(ultrasoc_driver); + +static const char * const ultrasoc_com_type_string[] = { + "UNKNOWN", + "UP-DOWN-BOTH", + "DOWN-ONLY", +}; + +static const char * const ultrasoc_com_service_status_string[] = { + "stopped", + "sleeping", + "running normal", +}; + +/* + * To avoid communicator buffer overflow, we create a service thread + * to do the communicator work. This is the service thread entry. + */ +static int ultrasoc_com_service(void *arg) +{ + unsigned int deep_sleep = 0; + struct ultrasoc_com *com; + int ud_flag = 0; + int core; + + core = smp_processor_id(); + com = (struct ultrasoc_com *)arg; + if (!com->com_work) { + dev_err(com->dev, + "This communicator do not have a work entry.\n"); + com->service_status = ULTRASOC_COM_SERVICE_STOPPED; + return -EINVAL; + } + dev_dbg(com->dev, "ultrasoc com service %s run on core %d.\n", + com->name, core); + + while (true) { + set_current_state(TASK_INTERRUPTIBLE); + spin_lock(&com->service_lock); + if (com->service_status == ULTRASOC_COM_SERVICE_SLEEPING) { + spin_unlock(&com->service_lock); + schedule(); + spin_lock(&com->service_lock); + } + + /* + * Since this thread service might be woken up with a status + * of STOP, we check the status again to avoid setting an error + * status + */ + if (com->service_status == ULTRASOC_COM_SERVICE_SLEEPING) { + com->service_status = + ULTRASOC_COM_SERVICE_RUNNING_NORMAL; + deep_sleep = 0; + } + spin_unlock(&com->service_lock); + __set_current_state(TASK_RUNNING); + + if (com->service_status == ULTRASOC_COM_SERVICE_STOPPED) + break; + + ud_flag = com->com_work(com); + if (!ud_flag) { + usleep_range(10, 100); + deep_sleep++; + } else { + deep_sleep = 0; + usleep_range(1, 4); + } + if (deep_sleep > com->timeout) + com->service_status = ULTRASOC_COM_SERVICE_SLEEPING; + if (kthread_should_stop()) + break; + } + com->service_status = ULTRASOC_COM_SERVICE_STOPPED; + + return 0; +} + +static void com_try_stop_service(struct ultrasoc_com *com) +{ + if (com->service_status != ULTRASOC_COM_SERVICE_STOPPED) { + spin_lock(&com->service_lock); + com->service_status = ULTRASOC_COM_SERVICE_STOPPED; + spin_unlock(&com->service_lock); + kthread_stop(com->service); + com->service = NULL; + } +} + +static void com_try_start_service(struct ultrasoc_com *com) +{ + if (com->service && + com->service_status != ULTRASOC_COM_SERVICE_STOPPED) { + dev_notice(com->dev, "Service is already running on %ld.\n", + com->core_bind); + wake_up_process(com->service); + return; + } + + dev_dbg(com->dev, "Starting service %s on core %ld.\n", com->name, + com->core_bind); + com->service = kthread_create(ultrasoc_com_service, com, "%s_service", + com->name); + if (IS_ERR(com->service)) { + spin_lock(&com->service_lock); + com->service_status = ULTRASOC_COM_SERVICE_STOPPED; + spin_unlock(&com->service_lock); + dev_err(com->dev, "Failed to start service.\n"); + } + + if (com->core_bind != -1) + kthread_bind(com->service, com->core_bind); + + spin_lock(&com->service_lock); + com->service_status = ULTRASOC_COM_SERVICE_RUNNING_NORMAL; + spin_unlock(&com->service_lock); + wake_up_process(com->service); +} + +static void com_service_restart(struct ultrasoc_com *com) +{ + com_try_stop_service(com); + com_try_start_service(com); +} + +static ssize_t ultrasoc_com_status(struct ultrasoc_com *com, char *buf) +{ + enum ultrasoc_com_service_status status = com->service_status; + enum ultrasoc_com_type type = com->com_type; + ssize_t wr_size; + + wr_size = sysfs_emit(buf, "%-20s: %s\n", "com-type", + ultrasoc_com_type_string[type]); + wr_size += sysfs_emit_at(buf, wr_size, "%-20s: %s\n", "service status", + ultrasoc_com_service_status_string[status]); + wr_size += uscom_ops_com_status(com, buf, wr_size); + + return wr_size; +} + +ULTRASOC_COM_ATTR_WO_OPS(start, com_try_start_service); +ULTRASOC_COM_ATTR_WO_OPS(stop, com_try_stop_service); +ULTRASOC_COM_ATTR_WO_OPS(restart, com_service_restart); +ULTRASOC_COM_ATTR_RO_OPS(com_status, ultrasoc_com_status); + +struct ultrasoc_com *ultrasoc_find_com_by_dev(struct device *com_dev) +{ + struct ultrasoc_drv_data *pdata = dev_get_drvdata(com_dev->parent); + struct list_head *com_head = &pdata->ultrasoc_com_head; + struct ultrasoc_com *com; + struct list_head *cur; + + list_for_each(cur, com_head) { + com = list_entry(cur, struct ultrasoc_com, node); + if (com->dev == com_dev) + return com; + } + + dev_err(com_dev, "Unable to find com associated with this device!\n"); + return NULL; +} + +static ssize_t core_bind_store(struct device *dev, + struct device_attribute *attr, const char *buf, + size_t size) +{ + struct ultrasoc_com *com = ultrasoc_find_com_by_dev(dev); + long core_bind; + int ret; + + if (!com) + return 0; + + ret = kstrtol(buf, 0, &core_bind); + if (!ret) + com->core_bind = core_bind; + + return size; +} + +static ssize_t core_bind_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct ultrasoc_com *com = ultrasoc_find_com_by_dev(dev); + + if (!com) + return 0; + + return sysfs_emit(buf, "%#lx", com->core_bind); +} +static DEVICE_ATTR_RW(core_bind); + +static ssize_t message_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t size) +{ + struct ultrasoc_com *com = ultrasoc_find_com_by_dev(dev); + u64 msg, msg_len; + int elements; + + elements = sscanf(buf, "%llx %llx", &msg, &msg_len); + if (elements < 2) + return -EINVAL; + + com->com_ops->put_raw_msg(com, msg_len, msg); + dev_dbg(dev, "Set message %#llx, length is %#llx.\n", msg, msg_len); + + return size; +} +static DEVICE_ATTR_WO(message); + +static umode_t ultrasoc_com_message_is_visible(struct kobject *kobj, + struct attribute *attr, int unused) +{ + struct device *dev = kobj_to_dev(kobj); + struct ultrasoc_com *com = ultrasoc_find_com_by_dev(dev); + + if (com->com_type != ULTRASOC_COM_TYPE_BOTH) + return 0; + + return attr->mode; +} + +static struct attribute *ultrasoc_com_global_attrs[] = { + &dev_attr_com_status.attr, + NULL, +}; + +static struct attribute *ultrasoc_com_service_attrs[] = { + &dev_attr_core_bind.attr, + &dev_attr_start.attr, + &dev_attr_stop.attr, + &dev_attr_restart.attr, + NULL, +}; + +static struct attribute *ultrasoc_com_message_attrs[] = { + &dev_attr_message.attr, + NULL, +}; + +static const struct attribute_group ultrasoc_com_global_group = { + .attrs = ultrasoc_com_global_attrs, +}; + +static const struct attribute_group ultrasoc_com_service_group = { + .attrs = ultrasoc_com_service_attrs, + .name = "service", +}; + +static const struct attribute_group ultrasoc_com_message_group = { + .attrs = ultrasoc_com_message_attrs, + .is_visible = ultrasoc_com_message_is_visible, +}; + +static const struct attribute_group *ultrasoc_com_attr[] = { + &ultrasoc_com_global_group, + &ultrasoc_com_service_group, + &ultrasoc_com_message_group, + NULL, +}; + +static int ultrasoc_validate_com_descp(struct ultrasoc_com_descp *com_descp) +{ + if (!com_descp->uscom_ops) + return -EINVAL; + + if (com_descp->com_type == ULTRASOC_COM_TYPE_BOTH) { + if (!com_descp->uscom_ops->put_raw_msg || + !com_descp->default_route_msg) + return -EINVAL; + } + + return 0; +} + +static int wait_com_service_stop(struct ultrasoc_com *com) +{ + u32 timeout = 0; + + if (com->service_status != ULTRASOC_COM_SERVICE_STOPPED) + com_try_stop_service(com); + while (com->service_status != ULTRASOC_COM_SERVICE_STOPPED) { + usleep_range(10, 100); + timeout++; + if (timeout > com->timeout) + return -ETIMEDOUT; + } + + return 0; +} + +/** + * ultrasoc_register_com - register a ultrasoc communicator for communication + * between usmsg bus devices and platform bus devices. + * + * @top_dev: the ultrasoc top platform device to manage all communicator. + * @com_descp: the communicator description to be registered. + * Return: the pointer to a new communicator if register ok, NULL if failure. + */ +struct ultrasoc_com *ultrasoc_register_com(struct device *top_dev, + struct ultrasoc_com_descp *com_descp) +{ + struct ultrasoc_drv_data *drv_data = dev_get_drvdata(top_dev); + struct ultrasoc_com *com; + int ret; + + if (!drv_data) + return ERR_PTR(-EBUSY); + + ret = ultrasoc_validate_com_descp(com_descp); + if (ret) + return ERR_PTR(-EINVAL); + + com = devm_kzalloc(top_dev, sizeof(*com), GFP_KERNEL); + if (!com) + return ERR_PTR(-ENOMEM); + + com->name = com_descp->name; + com->com_type = com_descp->com_type; + com->com_ops = com_descp->uscom_ops; + com->com_work = com_descp->com_work; + com->timeout = US_SERVICE_TIMEOUT; + com->core_bind = -1; + com->root = top_dev; + com->dev = com_descp->com_dev; + spin_lock_init(&com->service_lock); + + device_lock(top_dev); + list_add_tail(&com->node, &drv_data->ultrasoc_com_head); + device_unlock(top_dev); + + if (com->com_type == ULTRASOC_COM_TYPE_BOTH && !drv_data->def_up_com) { + /* + * There is one ULTRASOC_COM_TYPE_BOTH device per ultrasoc + * system, so race will not happen. + */ + drv_data->def_up_com = com; + /* start the default communicator service. */ + com_try_start_service(com); + /* set ultrasoc route all msgs to port 1 as default*/ + com->com_ops->put_raw_msg(com, US_ROUTE_LENGTH, + com_descp->default_route_msg); + } + + ret = device_add_groups(com->dev, ultrasoc_com_attr); + if (ret) + return ERR_PTR(ret); + + return com; +} +EXPORT_SYMBOL_GPL(ultrasoc_register_com); + +int ultrasoc_unregister_com(struct ultrasoc_com *com) +{ + struct ultrasoc_drv_data *pdata = dev_get_drvdata(com->root); + struct device *com_dev = com->dev; + struct device *dev = com->root; + + if (wait_com_service_stop(com)) { + dev_err(com_dev, "Com service is still running.\n"); + return -EBUSY; + } + + if (pdata->def_up_com == com) + pdata->def_up_com = NULL; + + device_lock(dev); + list_del(&com->node); + device_unlock(dev); + device_remove_groups(com_dev, ultrasoc_com_attr); + + return 0; +} +EXPORT_SYMBOL_GPL(ultrasoc_unregister_com); + +MODULE_DESCRIPTION("Ultrasoc driver"); +MODULE_LICENSE("Dual MIT/GPL"); +MODULE_AUTHOR("Jonathan Zhou jonathan.zhouwen@huawei.com"); +MODULE_AUTHOR("Qi Liu liuqi115@huawei.com"); diff --git a/drivers/hwtracing/ultrasoc/ultrasoc.h b/drivers/hwtracing/ultrasoc/ultrasoc.h new file mode 100644 index 0000000..2831e14 --- /dev/null +++ b/drivers/hwtracing/ultrasoc/ultrasoc.h @@ -0,0 +1,168 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright (C) 2021 Hisilicon Limited Permission is hereby granted, free of + * charge, to any person obtaining a copy of this software and associated + * documentation files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, modify, + * merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject + * to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * Code herein communicates with and accesses proprietary hardware which is + * licensed intellectual property (IP) belonging to Siemens Digital Industries + * Software Ltd. + * + * Siemens Digital Industries Software Ltd. asserts and reserves all rights to + * their intellectual property. This paragraph may not be removed or modified + * in any way without permission from Siemens Digital Industries Software Ltd. + */ + +#ifndef _LINUX_ULTRASOC_H +#define _LINUX_ULTRASOC_H + +#include <linux/device.h> +#include <linux/list.h> +#include <linux/slab.h> + +struct ultrasoc_drv_data { + struct device *dev; + void __iomem *com_mux; + struct list_head ultrasoc_com_head; + struct ultrasoc_com *def_up_com; + const char *dev_data_path; + spinlock_t spinlock; +}; + +enum ultrasoc_com_type { + ULTRASOC_COM_TYPE_BOTH, + ULTRASOC_COM_TYPE_DOWN, +}; + +struct ultrasoc_com_descp { + const char *name; + enum ultrasoc_com_type com_type; + struct device *com_dev; + struct uscom_ops *uscom_ops; + int (*com_work)(struct ultrasoc_com *com); + u64 default_route_msg; +}; + +enum ultrasoc_com_service_status { + ULTRASOC_COM_SERVICE_STOPPED, + ULTRASOC_COM_SERVICE_SLEEPING, + ULTRASOC_COM_SERVICE_RUNNING_NORMAL, +}; + +#define USMSG_MAX_IDX 9 +struct msg_descp { + unsigned int msg_len; + __le32 msg_buf[USMSG_MAX_IDX]; + struct list_head node; +}; + +static inline void usmsg_list_realse_all(struct list_head *msg_head) +{ + struct msg_descp *msgd, *next; + + list_for_each_entry_safe(msgd, next, msg_head, node) { + list_del(&msgd->node); + kfree(msgd); + } +} + +struct ultrasoc_com { + const char *name; + enum ultrasoc_com_type com_type; + struct device *root; + struct device *dev; + + long core_bind; + int (*com_work)(struct ultrasoc_com *com); + spinlock_t service_lock; + struct task_struct *service; + int service_status; + unsigned int timeout; + + char *data_path; + struct uscom_ops *com_ops; + + struct list_head node; +}; + +struct uscom_ops { + ssize_t (*com_status)(struct ultrasoc_com *com, char *buf, + ssize_t size); + void (*put_raw_msg)(struct ultrasoc_com *com, int msg_size, + unsigned long long msg); +}; + +#define uscom_ops_com_status(uscom, buf, size) \ + (((uscom)->com_ops && (uscom)->com_ops->com_status) ? \ + (uscom)->com_ops->com_status(uscom, buf, size) : 0) + +static inline void *ultrasoc_com_get_drvdata(struct ultrasoc_com *uscom) +{ + return dev_get_drvdata(uscom->dev); +} + +struct ultrasoc_com * +ultrasoc_register_com(struct device *root_dev, + struct ultrasoc_com_descp *com_descp); +int ultrasoc_unregister_com(struct ultrasoc_com *com); +int ultrasoc_com_del_usmsg_device(struct ultrasoc_com *com, int index); + +struct ultrasoc_com *ultrasoc_find_com_by_dev(struct device *com_dev); + +#define ULTRASOC_COM_ATTR_WO_OPS(attr_name, com_ops) \ + static ssize_t attr_name##_store(struct device *dev, \ + struct device_attribute *attr, \ + const char *buf, size_t size) \ + { \ + struct ultrasoc_com *com = ultrasoc_find_com_by_dev(dev); \ + long attr_name; \ + int ret; \ + if (!com) \ + return 0; \ + ret = kstrtol(buf, 0, &attr_name); \ + if (ret) { \ + return size; \ + } \ + if (attr_name == 1) { \ + com_ops(com); \ + } \ + return size; \ + } \ + static DEVICE_ATTR_WO(attr_name) + +#define ULTRASOC_COM_ATTR_RO_OPS(attr_name, com_ops) \ + static ssize_t attr_name##_show(struct device *dev, \ + struct device_attribute *attr, \ + char *buf) \ + { \ + struct ultrasoc_com *com = ultrasoc_find_com_by_dev(dev); \ + if (!com) \ + return 0; \ + return com_ops(com, buf); \ + } \ + static DEVICE_ATTR_RO(attr_name) + +/* 1000 * (10us ~ 100us) */ +#define US_SERVICE_TIMEOUT 1000 +/* communicator service work status */ +#define US_SERVICE_ONWORK 1 +#define US_SERVICE_IDLE 0 +#define US_ROUTE_LENGTH 11 +#define US_SELECT_ONCHIP 0x3 + +#endif

This patch adds driver for System Memory Buffer. It includes a platform driver for the SMB device.

Signed-off-by: Jonathan Zhou jonathan.zhouwen@huawei.com Signed-off-by: Qi Liu liuqi115@huawei.com --- drivers/hwtracing/ultrasoc/Kconfig | 9 + drivers/hwtracing/ultrasoc/Makefile | 3 + drivers/hwtracing/ultrasoc/ultrasoc-smb.c | 663 ++++++++++++++++++++++++++++++ drivers/hwtracing/ultrasoc/ultrasoc-smb.h | 182 ++++++++ 4 files changed, 857 insertions(+) create mode 100644 drivers/hwtracing/ultrasoc/ultrasoc-smb.c create mode 100644 drivers/hwtracing/ultrasoc/ultrasoc-smb.h

diff --git a/drivers/hwtracing/ultrasoc/Kconfig b/drivers/hwtracing/ultrasoc/Kconfig index 77429f3..8899949 100644 --- a/drivers/hwtracing/ultrasoc/Kconfig +++ b/drivers/hwtracing/ultrasoc/Kconfig @@ -22,4 +22,13 @@ config ULTRASOC_AXI_COM the upstream channel is used to transmit user configuration, and downstream channel to carry response and trace data to the users.

+config ULTRASOC_SMB + tristate "Ultrasoc System memory buffer drivers" + help + This config enables support for Ultrasoc System Memory Buffer + drivers. The System Memory Buffer provides a way to buffer and + store messages in system memory. It provides a capability to + store messages received on its input message interface to an + area of system memory. + endif diff --git a/drivers/hwtracing/ultrasoc/Makefile b/drivers/hwtracing/ultrasoc/Makefile index 54711a7b..b174ca8 100644 --- a/drivers/hwtracing/ultrasoc/Makefile +++ b/drivers/hwtracing/ultrasoc/Makefile @@ -8,3 +8,6 @@ ultrasoc-drv-objs := ultrasoc.o

obj-$(CONFIG_ULTRASOC_AXI_COM) += ultrasoc-axi-com-drv.o ultrasoc-axi-com-drv-objs := ultrasoc-axi-com.o + +obj-$(CONFIG_ULTRASOC_SMB) += ultrasoc-smb-drv.o +ultrasoc-smb-drv-objs := ultrasoc-smb.o diff --git a/drivers/hwtracing/ultrasoc/ultrasoc-smb.c b/drivers/hwtracing/ultrasoc/ultrasoc-smb.c new file mode 100644 index 0000000..ce03f5e --- /dev/null +++ b/drivers/hwtracing/ultrasoc/ultrasoc-smb.c @@ -0,0 +1,663 @@ +// SPDX-License-Identifier: MIT +/* + * Copyright (C) 2021 Hisilicon Limited Permission is hereby granted, free of + * charge, to any person obtaining a copy of this software and associated + * documentation files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, modify, + * merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject + * to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * Code herein communicates with and accesses proprietary hardware which is + * licensed intellectual property (IP) belonging to Siemens Digital Industries + * Software Ltd. + * + * Siemens Digital Industries Software Ltd. asserts and reserves all rights to + * their intellectual property. This paragraph may not be removed or modified + * in any way without permission from Siemens Digital Industries Software Ltd. + */ + +#include <linux/circ_buf.h> +#include <linux/err.h> +#include <linux/module.h> +#include <linux/mod_devicetable.h> +#include <linux/platform_device.h> + +#include "ultrasoc-smb.h" + +static inline int smb_hw_buffer_empty(struct smb_drv_data *drvdata) +{ + u32 buf_status = readl(drvdata->base + SMB_LB_INT_STS); + + return buf_status & BIT(0) ? 0 : 1; +} + +static inline int smb_buffer_pointer_pos(struct smb_drv_data *drvdata) +{ + u32 wr_offset, rd_offset; + + wr_offset = readl(drvdata->base + SMB_LB_WR_ADDR); + rd_offset = readl(drvdata->base + SMB_LB_RD_ADDR); + return wr_offset == rd_offset; +} + +static inline int smb_hw_buffer_full(struct smb_drv_data *drvdata) +{ + return smb_buffer_pointer_pos(drvdata) && !smb_hw_buffer_empty(drvdata); +} + +static inline void smb_clear_buf_status(struct smb_drv_data *drvdata) +{ + struct smb_data_buffer *sdb = &drvdata->smb_db; + + if (smb_buffer_pointer_pos(drvdata) && !sdb->to_copy) + writel(0xf, drvdata->base + SMB_LB_INT_STS); +} + +static void smb_update_hw_write_size(struct smb_drv_data *drvdata) +{ + struct smb_data_buffer *sdb = &drvdata->smb_db; + u32 write_offset, write_base; + + sdb->lost = false; + writel(0x1, drvdata->base + SMB_LB_PURGE); + if (smb_hw_buffer_empty(drvdata)) { + sdb->to_copy = 0; + return; + } + + if (smb_hw_buffer_full(drvdata)) { + sdb->to_copy = sdb->buf_size; + return; + } + + write_base = sdb->buf_base_phys & SMB_BUF_WRITE_BASE; + write_offset = readl(drvdata->base + SMB_LB_WR_ADDR) - write_base; + sdb->to_copy = CIRC_CNT(write_offset, sdb->rd_offset, sdb->buf_size); +} + +static int smb_open(struct inode *inode, struct file *file) +{ + struct smb_drv_data *drvdata = container_of(file->private_data, + struct smb_drv_data, miscdev); + + if (local_cmpxchg(&drvdata->reading, 0, 1)) + return -EBUSY; + + smb_update_hw_write_size(drvdata); + return 0; +} + +static ssize_t smb_read(struct file *file, char __user *data, + size_t len, loff_t *ppos) +{ + struct smb_drv_data *drvdata = container_of(file->private_data, + struct smb_drv_data, miscdev); + struct smb_data_buffer *sdb = &drvdata->smb_db; + struct device *dev = &drvdata->csdev->dev; + unsigned long to_copy = sdb->to_copy; + + if (!to_copy) { + smb_update_hw_write_size(drvdata); + to_copy = sdb->to_copy; + if (!to_copy) + return to_copy; + } + + to_copy = min(to_copy, len); + /* + * if the read needs to cross the boundary of the data buffer, copy + * last datas of the buffer to user + */ + if (sdb->rd_offset + to_copy > sdb->buf_size) + to_copy = sdb->buf_size - sdb->rd_offset; + + if (copy_to_user(data, (void *)sdb->buf_base + sdb->rd_offset, to_copy)) { + dev_dbg(dev, "Failed to copy data to user.\n"); + return -EFAULT; + } + + *ppos += to_copy; + sdb->rd_offset += to_copy; + sdb->rd_offset %= sdb->buf_size; + sdb->to_copy -= to_copy; + + /* update the read point */ + writel(sdb->buf_base_phys + sdb->rd_offset, + drvdata->base + SMB_LB_RD_ADDR); + smb_clear_buf_status(drvdata); + dev_dbg(dev, "%lu bytes copied.\n", to_copy); + + return to_copy; +} + +static int smb_release(struct inode *inode, struct file *file) +{ + struct smb_drv_data *drvdata = container_of(file->private_data, + struct smb_drv_data, miscdev); + local_set(&drvdata->reading, 0); + return 0; +} + +static const struct file_operations smb_fops = { + .owner = THIS_MODULE, + .open = smb_open, + .read = smb_read, + .release = smb_release, + .llseek = no_llseek, +}; + +static ssize_t smb_show_status(struct ultrasoc_com *com, char *buf, + ssize_t wr_size) +{ + struct smb_drv_data *drvdata; + u32 value; + + drvdata = dev_get_drvdata(com->dev); + value = readl(drvdata->base + SMB_LB_INT_STS); + wr_size += sysfs_emit_at(buf, wr_size, "%-20s: 0x%08x\n", + "interrupt status", value); + value = readl(drvdata->base + SMB_LB_WR_ADDR); + wr_size += sysfs_emit_at(buf, wr_size, "%-20s: %#x\n", "write point", + value); + value = readl(drvdata->base + SMB_LB_RD_ADDR); + wr_size += sysfs_emit_at(buf, wr_size, "%-20s: %#x\n", "read point", + value); + + return wr_size; +} + +static int smb_init_data_buffer(struct platform_device *pdev, + struct smb_data_buffer *sdb) +{ + struct resource *res; + + res = platform_get_resource(pdev, IORESOURCE_MEM, 1); + if (IS_ERR(res)) { + dev_err(&pdev->dev, "SMB device without data buffer.\n"); + return -EINVAL; + } + + sdb->buf_base_phys = res->start; + sdb->buf_size = resource_size(res); + if (sdb->buf_size == 0) + return -EINVAL; + + sdb->buf_base = ioremap_cache(sdb->buf_base_phys, sdb->buf_size); + if (sdb->buf_base == NULL) + return -ENOMEM; + + sdb->buf_cfg_mode = SMB_BUF_CFG_STREAMING; + return 0; +} + +static void smb_release_data_buffer(struct smb_drv_data *drvdata) +{ + struct smb_data_buffer *sdb = &drvdata->smb_db; + + if (sdb->buf_base) + iounmap(sdb->buf_base); +} + +static struct uscom_ops smb_ops = { + .com_status = smb_show_status, + .put_raw_msg = NULL, +}; + +static int smb_set_buffer(struct coresight_device *csdev, + struct perf_output_handle *handle); + +static void smb_enable_hw(struct smb_drv_data *drvdata) +{ + writel(0x1, drvdata->base + SMB_GLOBAL_EN); +} + +static void smb_disable_hw(struct smb_drv_data *drvdata) +{ + writel(0x1, drvdata->base + SMB_LB_PURGE); + writel(0x0, drvdata->base + SMB_GLOBAL_EN); +} + +static int smb_enable_sysfs(struct coresight_device *csdev) +{ + struct smb_drv_data *drvdata = dev_get_drvdata(csdev->dev.parent); + unsigned long flags; + int ret = 0; + + WARN_ON_ONCE(drvdata == NULL); + + spin_lock_irqsave(&drvdata->spinlock, flags); + + /* Don't messup with perf sessions. */ + if (drvdata->mode == CS_MODE_PERF) { + ret = -EBUSY; + goto out; + } + + if (drvdata->mode == CS_MODE_DISABLED) { + smb_enable_hw(drvdata); + drvdata->mode = CS_MODE_SYSFS; + } + atomic_inc(csdev->refcnt); +out: + spin_unlock_irqrestore(&drvdata->spinlock, flags); + return ret; +} + +static int smb_enable_perf(struct coresight_device *csdev, void *data) +{ + struct smb_drv_data *drvdata = dev_get_drvdata(csdev->dev.parent); + struct device *dev = &drvdata->csdev->dev; + struct perf_output_handle *handle = data; + unsigned long flags; + int ret = 0; + pid_t pid; + + spin_lock_irqsave(&drvdata->spinlock, flags); + if (drvdata->mode == CS_MODE_SYSFS) { + dev_err(dev, "Device is already in used by sysfs.\n"); + ret = -EBUSY; + goto out; + } + + /* Get a handle on the pid of the target process*/ + pid = task_pid_nr(handle->event->owner); + if (drvdata->pid != -1 && drvdata->pid != pid) { + ret = -EBUSY; + goto out; + } + + /* + * No HW configuration is needed if the sink is already in + * use for this session. + */ + if (drvdata->pid == pid) { + atomic_inc(csdev->refcnt); + goto out; + } + + /* + * We don't have an internal state to clean up if we fail to setup + * the perf buffer. So we can perform the step before we turn the + * ETB on and leave without cleaning up. + */ + ret = smb_set_buffer(csdev, handle); + if (ret) + goto out; + + smb_enable_hw(drvdata); + drvdata->pid = pid; + drvdata->mode = CS_MODE_PERF; + atomic_inc(csdev->refcnt); +out: + spin_unlock_irqrestore(&drvdata->spinlock, flags); + return ret; +} + +static int smb_enable(struct coresight_device *csdev, u32 mode, void *data) +{ + int ret; + + switch (mode) { + case CS_MODE_SYSFS: + ret = smb_enable_sysfs(csdev); + break; + case CS_MODE_PERF: + ret = smb_enable_perf(csdev, data); + break; + default: + ret = -EINVAL; + break; + } + + if (ret) + return ret; + + dev_dbg(&csdev->dev, "Ultrasoc smb enabled.\n"); + + return 0; +} + +static int smb_disable(struct coresight_device *csdev) +{ + struct smb_drv_data *drvdata = dev_get_drvdata(csdev->dev.parent); + unsigned long flags; + + spin_lock_irqsave(&drvdata->spinlock, flags); + + if (atomic_dec_return(csdev->refcnt)) { + spin_unlock_irqrestore(&drvdata->spinlock, flags); + return -EBUSY; + } + + /* Complain if we (somehow) got out of sync */ + WARN_ON_ONCE(drvdata->mode == CS_MODE_DISABLED); + smb_disable_hw(drvdata); + + /* Dissociate from the target process. */ + drvdata->pid = -1; + drvdata->mode = CS_MODE_DISABLED; + spin_unlock_irqrestore(&drvdata->spinlock, flags); + + dev_dbg(&csdev->dev, "Ultrasoc smb disabled.\n"); + return 0; +} + +static void smb_set_default_hw(struct smb_drv_data *drvdata) +{ + struct smb_data_buffer *sdb = &drvdata->smb_db; + u32 value, base_hi, base_lo, limit_lo; + + /* first disable smb and clear the status of SMB buffer */ + smb_disable_hw(drvdata); + smb_clear_buf_status(drvdata); + + /* using smb in single-end mode, and set other configures default */ + value = sdb->buf_cfg_mode | SMB_BUF_SINGLE_END | SMB_BUF_ENABLE; + writel(value, drvdata->base + SMB_LB_CFG_LO); + value = SMB_MSG_FILTER(0x0, 0xff); + writel(value, drvdata->base + SMB_LB_CFG_HI); + + writel(HISI_SMB_GLOBAL_CFG, drvdata->base + SMB_GLOBAL_CFG); + writel(HISI_SMB_GLB_INT_CFG, drvdata->base + SMB_GLOBAL_INT); + writel(HISI_SMB_BUF_INT_CFG, drvdata->base + SMB_LB_INT_CTRL); + + /* config hardware registers according to physical base of SMB buffer */ + base_hi = sdb->buf_base_phys >> 32; + base_lo = sdb->buf_base_phys & SMB_BUF_WRITE_BASE; + limit_lo = base_lo + sdb->buf_size; + writel(base_lo, drvdata->base + SMB_LB_BASE_LO); + writel(base_hi, drvdata->base + SMB_LB_BASE_HI); + writel(limit_lo, drvdata->base + SMB_LB_LIMIT); + + /* initial hardware read-ptr address*/ + writel(base_lo, drvdata->base + SMB_LB_RD_ADDR); +} + +static void *smb_alloc_buffer(struct coresight_device *csdev, + struct perf_event *event, void **pages, + int nr_pages, bool overwrite) +{ + struct cs_buffers *buf; + int node; + + node = (event->cpu == -1) ? NUMA_NO_NODE : cpu_to_node(event->cpu); + buf = kzalloc_node(sizeof(struct cs_buffers), GFP_KERNEL, node); + if (!buf) + return NULL; + + buf->snapshot = overwrite; + buf->nr_pages = nr_pages; + buf->data_pages = pages; + + return buf; +} + +static void smb_free_buffer(void *config) +{ + struct cs_buffers *buf = config; + + kfree(buf); +} + +static int smb_set_buffer(struct coresight_device *csdev, + struct perf_output_handle *handle) +{ + struct cs_buffers *buf = etm_perf_sink_config(handle); + u32 head; + + if (!buf) + return -EINVAL; + + /* wrap head around to the amount of space we have */ + head = handle->head & ((buf->nr_pages << PAGE_SHIFT) - 1); + + /* find the page to write to and offset within that page */ + buf->cur = head / PAGE_SIZE; + buf->offset = head % PAGE_SIZE; + + local_set(&buf->data_size, 0); + + return 0; +} + +static void smb_sync_perf_buffer(struct smb_drv_data *drvdata, + struct cs_buffers *buf, unsigned long to_copy) +{ + struct smb_data_buffer *sdb = &drvdata->smb_db; + char **dst_pages = (char **)buf->data_pages; + u32 buf_offset = buf->offset; + u32 cur = buf->cur; + u32 bytes; + + while (to_copy > 0) { + /* + * if the read needs to cross the boundary of the data buffer, + * copy last datas of the buffer to user + */ + if (sdb->rd_offset + PAGE_SIZE - buf_offset > sdb->buf_size) + bytes = sdb->buf_size - sdb->rd_offset; + else + bytes = min(to_copy, PAGE_SIZE - buf_offset); + + memcpy_fromio(dst_pages[cur] + buf_offset, + sdb->buf_base + sdb->rd_offset, bytes); + + buf_offset += bytes; + if (buf_offset >= PAGE_SIZE) { + buf_offset = 0; + cur++; + cur %= buf->nr_pages; + } + to_copy -= bytes; + /* ensure memcpy finished before update the read pointer */ + sdb->rd_offset += bytes; + sdb->rd_offset %= sdb->buf_size; + } + + writel(sdb->buf_base_phys + sdb->rd_offset, + drvdata->base + SMB_LB_RD_ADDR); + sdb->to_copy = to_copy; +} + +static unsigned long smb_update_buffer(struct coresight_device *csdev, + struct perf_output_handle *handle, void *sink_config) +{ + struct smb_drv_data *drvdata = dev_get_drvdata(csdev->dev.parent); + struct smb_data_buffer *sdb = &drvdata->smb_db; + struct cs_buffers *buf = sink_config; + u64 to_copy; + + if (!buf) + return 0; + + smb_update_hw_write_size(drvdata); + to_copy = sdb->to_copy; + if (to_copy > handle->size) { + sdb->rd_offset += (to_copy - handle->size); + sdb->rd_offset %= sdb->buf_size; + to_copy = handle->size; + sdb->lost = true; + } + + smb_sync_perf_buffer(drvdata, buf, to_copy); + smb_clear_buf_status(drvdata); + if (!buf->snapshot && sdb->lost) + perf_aux_output_flag(handle, PERF_AUX_FLAG_TRUNCATED); + + return to_copy; +} + +static const struct coresight_ops_sink smb_cs_ops = { + .enable = smb_enable, + .disable = smb_disable, + .alloc_buffer = smb_alloc_buffer, + .free_buffer = smb_free_buffer, + .update_buffer = smb_update_buffer, +}; + +static const struct coresight_ops cs_ops = { + .sink_ops = &smb_cs_ops, +}; + +static int smb_init_res(struct platform_device *pdev, + struct smb_drv_data *drvdata) +{ + struct smb_data_buffer *sdb; + int ret; + + sdb = &drvdata->smb_db; + drvdata->base = devm_platform_ioremap_resource(pdev, 0); + if (IS_ERR(drvdata->base)) { + dev_err(&pdev->dev, "Failed to ioremap resource.\n"); + return PTR_ERR(drvdata->base); + } + + ret = smb_init_data_buffer(pdev, sdb); + if (ret) + dev_err(&pdev->dev, "Failed to init buffer, ret = %d.\n", ret); + + return ret; +} + +DEFINE_CORESIGHT_DEVLIST(sink_devs, "sink_smb"); +static int smb_register_sink(struct platform_device *pdev, + struct smb_drv_data *drvdata) +{ + struct coresight_platform_data *pdata = NULL; + struct coresight_desc desc = { 0 }; + int ret; + + pdata = coresight_get_platform_data(&pdev->dev); + if (IS_ERR(pdata)) + return PTR_ERR(pdata); + + drvdata->dev->platform_data = pdata; + desc.type = CORESIGHT_DEV_TYPE_SINK; + desc.subtype.sink_subtype = CORESIGHT_DEV_SUBTYPE_SINK_BUFFER; + desc.ops = &cs_ops; + desc.pdata = pdata; + desc.dev = &pdev->dev; + desc.name = coresight_alloc_device_name(&sink_devs, &pdev->dev); + if (!desc.name) { + dev_err(&pdev->dev, "Failed to alloc coresight device name."); + return -ENOMEM; + } + + drvdata->csdev = coresight_register(&desc); + if (IS_ERR(drvdata->csdev)) + return PTR_ERR(drvdata->csdev); + + drvdata->miscdev.name = desc.name; + drvdata->miscdev.minor = MISC_DYNAMIC_MINOR; + drvdata->miscdev.fops = &smb_fops; + ret = misc_register(&drvdata->miscdev); + if (ret) { + coresight_unregister(drvdata->csdev); + dev_err(&pdev->dev, "Failed to register misc, ret=%d\n", ret); + } + + return ret; +} + +static void smb_unregister_sink(struct smb_drv_data *drvdata) +{ + misc_deregister(&drvdata->miscdev); + coresight_unregister(drvdata->csdev); +} + +static int smb_config_com_descp(struct platform_device *pdev, + struct smb_drv_data *drvdata) +{ + struct device *parent = pdev->dev.parent; + struct ultrasoc_com_descp com_descp = {0}; + struct device *dev = &pdev->dev; + struct ultrasoc_com *com; + + com_descp.name = pdev->name; + com_descp.com_type = ULTRASOC_COM_TYPE_DOWN; + com_descp.com_dev = dev; + com_descp.uscom_ops = &smb_ops; + com = ultrasoc_register_com(parent, &com_descp); + if (IS_ERR(com)) { + dev_err(dev, "Failed to register smb com.\n"); + return PTR_ERR(com); + } + + drvdata->com = com; + return 0; +} + +static int smb_probe(struct platform_device *pdev) +{ + struct smb_drv_data *drvdata; + int ret; + + drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL); + if (!drvdata) + return -ENOMEM; + + ret = smb_init_res(pdev, drvdata); + if (ret) + return ret; + + smb_set_default_hw(drvdata); + spin_lock_init(&drvdata->spinlock); + drvdata->dev = &pdev->dev; + drvdata->pid = -1; + + ret = smb_config_com_descp(pdev, drvdata); + if (ret) + return ret; + + ret = smb_register_sink(pdev, drvdata); + if (ret) { + dev_err(&pdev->dev, "failed to register smb sink.\n"); + ultrasoc_unregister_com(drvdata->com); + return ret; + } + + platform_set_drvdata(pdev, drvdata); + return 0; +} + +static int smb_remove(struct platform_device *pdev) +{ + struct smb_drv_data *drvdata = platform_get_drvdata(pdev); + + smb_unregister_sink(drvdata); + ultrasoc_unregister_com(drvdata->com); + smb_release_data_buffer(drvdata); + return 0; +} + +static const struct acpi_device_id ultrasoc_smb_acpi_match[] = { + {"HISI03A1", }, + {}, +}; + +static struct platform_driver smb_driver = { + .driver = { + .name = "ultrasoc,smb", + .acpi_match_table = ultrasoc_smb_acpi_match, + }, + .probe = smb_probe, + .remove = smb_remove, +}; +module_platform_driver(smb_driver); + +MODULE_DESCRIPTION("Ultrasoc smb driver"); +MODULE_LICENSE("Dual MIT/GPL"); +MODULE_AUTHOR("Jonathan Zhou jonathan.zhouwen@huawei.com"); +MODULE_AUTHOR("Qi Liu liuqi115@huawei.com"); diff --git a/drivers/hwtracing/ultrasoc/ultrasoc-smb.h b/drivers/hwtracing/ultrasoc/ultrasoc-smb.h new file mode 100644 index 0000000..e37d510 --- /dev/null +++ b/drivers/hwtracing/ultrasoc/ultrasoc-smb.h @@ -0,0 +1,182 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright (C) 2021 Hisilicon Limited Permission is hereby granted, free of + * charge, to any person obtaining a copy of this software and associated + * documentation files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, modify, + * merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject + * to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * Code herein communicates with and accesses proprietary hardware which is + * licensed intellectual property (IP) belonging to Siemens Digital Industries + * Software Ltd. + * + * Siemens Digital Industries Software Ltd. asserts and reserves all rights to + * their intellectual property. This paragraph may not be removed or modified + * in any way without permission from Siemens Digital Industries Software Ltd. + */ + +#ifndef _ULTRASOC_SMB_H +#define _ULTRASOC_SMB_H + +#include <linux/coresight.h> +#include <linux/list.h> +#include <linux/miscdevice.h> + +#include "ultrasoc.h" + +#define SMB_GLOBAL_CFG 0X0 +#define SMB_GLOBAL_EN 0X4 +#define SMB_GLOBAL_INT 0X8 +#define SMB_LB_CFG_LO 0X40 +#define SMB_LB_CFG_HI 0X44 +#define SMB_LB_INT_CTRL 0X48 +#define SMB_LB_INT_STS 0X4C +#define SMB_LB_BASE_LO 0X50 +#define SMB_LB_BASE_HI 0X54 +#define SMB_LB_LIMIT 0X58 +#define SMB_LB_RD_ADDR 0X5C +#define SMB_LB_WR_ADDR 0X60 +#define SMB_LB_PURGE 0X64 + +#define SMB_MSG_LC(lc) ((lc & 0x3) << 2) +#define SMB_BST_LEN(len) (((len - 1) & 0xff) << 4) +/* idle message injection timer period */ +#define SMB_IDLE_PRD(period) (((period - 216) & 0xf) << 12) +#define SMB_MEM_WR(credit, rate) (((credit & 0x3) << 16) | ((rate & 0xf) << 18)) +#define SMB_MEM_RD(credit, rate) (((credit & 0x3) << 22) | ((rate & 0xf) << 24)) +#define HISI_SMB_GLOBAL_CFG \ + (SMB_MSG_LC(0) | SMB_IDLE_PRD(231) | SMB_MEM_WR(0x3, 0x0) | \ + SMB_MEM_RD(0x3, 0x6) | SMB_BST_LEN(16)) + +#define SMB_INT_ENABLE BIT(0) +#define SMB_INT_TYPE_PULSE BIT(1) +#define SMB_INT_POLARITY_HIGH BIT(2) +#define HISI_SMB_GLB_INT_CFG (SMB_INT_ENABLE | SMB_INT_TYPE_PULSE | \ + SMB_INT_POLARITY_HIGH) + +/* logic buffer config register low 32b */ +#define SMB_BUF_ENABLE BIT(0) +#define SMB_BUF_SINGLE_END BIT(1) +#define SMB_BUF_INIT BIT(8) +#define SMB_BUF_CONTINUOUS BIT(11) +#define SMB_FLOW_MASK GENMASK(19, 16) +#define SMB_BUF_CFG_STREAMING \ + (SMB_BUF_INIT | SMB_BUF_CONTINUOUS | SMB_FLOW_MASK) +#define SMB_BUF_WRITE_BASE GENMASK(31, 0) + +/* logic buffer config register high 32b */ +#define SMB_MSG_FILTER(lower, upper) ((lower & 0xff) | ((upper & 0xff) << 8)) +#define SMB_BUF_INT_ENABLE BIT(0) +#define SMB_BUF_NOTE_NOT_EMPTY BIT(8) +#define SMB_BUF_NOTE_BLOCK_AVAIL BIT(9) +#define SMB_BUF_NOTE_TRIGGERED BIT(10) +#define SMB_BUF_NOTE_FULL BIT(11) +#define HISI_SMB_BUF_INT_CFG \ + (SMB_BUF_INT_ENABLE | SMB_BUF_NOTE_NOT_EMPTY | \ + SMB_BUF_NOTE_BLOCK_AVAIL | SMB_BUF_NOTE_TRIGGERED | \ + SMB_BUF_NOTE_FULL) + +struct smb_data_buffer { + /* memory buffer for hardware write */ + u32 buf_cfg_mode; + bool lost; + void __iomem *buf_base; + u64 buf_base_phys; + u64 buf_size; + u64 to_copy; + u32 rd_offset; +}; + +struct smb_drv_data { + void __iomem *base; + struct device *dev; + struct ultrasoc_com *com; + struct smb_data_buffer smb_db; + /* to register ultrasoc smb as a coresight sink device. */ + struct coresight_device *csdev; + spinlock_t spinlock; + local_t reading; + pid_t pid; + u32 mode; + struct miscdevice miscdev; +}; + +#define SMB_MSG_ALIGH_SIZE 0x400 + +static inline struct smb_data_buffer * + dev_get_smb_data_buffer(struct device *dev) +{ + struct smb_drv_data *drvdata = dev_get_drvdata(dev); + + if (drvdata) + return &drvdata->smb_db; + + return NULL; +} + +/* + * Coresight doesn't export the following + * structures(cs_mode,cs_buffers,etm_event_data), + * so we redefine a copy here. + */ +enum cs_mode { + CS_MODE_DISABLED, + CS_MODE_SYSFS, + CS_MODE_PERF, +}; + +struct cs_buffers { + unsigned int cur; + unsigned int nr_pages; + unsigned long offset; + local_t data_size; + bool snapshot; + void **data_pages; +}; + +struct etm_event_data { + struct work_struct work; + cpumask_t mask; + void *snk_config; + struct list_head * __percpu *path; +}; + +#if IS_ENABLED(CONFIG_CORESIGHT) +int etm_perf_symlink(struct coresight_device *csdev, bool link); +int etm_perf_add_symlink_sink(struct coresight_device *csdev); +void etm_perf_del_symlink_sink(struct coresight_device *csdev); +static inline void *etm_perf_sink_config(struct perf_output_handle *handle) +{ + struct etm_event_data *data = perf_get_aux(handle); + + if (data) + return data->snk_config; + return NULL; +} +#else +static inline int etm_perf_symlink(struct coresight_device *csdev, bool link) +{ return -EINVAL; } +int etm_perf_add_symlink_sink(struct coresight_device *csdev) +{ return -EINVAL; } +void etm_perf_del_symlink_sink(struct coresight_device *csdev) {} +static inline void *etm_perf_sink_config(struct perf_output_handle *handle) +{ + return NULL; +} + +#endif /* CONFIG_CORESIGHT */ + +#endif