Loading Documentation/devicetree/bindings/arm/msm/msm_rtb.txt 0 → 100644 +22 −0 Original line number Diff line number Diff line Register Trace Buffer (RTB) The RTB is used to log discrete events in the system in an uncached buffer that can be post processed from RAM dumps. The RTB must reserve memory using the msm specific memory reservation bindings (see Documentation/devicetree/bindings/arm/msm/memory-reserve.txt). Required properties - compatible: "qcom,msm-rtb" - qcom,rtb-size: size of the RTB buffer in bytes Optional properties: - linux,contiguous-region: phandle reference to a CMA region Example: qcom,msm-rtb { compatible = "qcom,msm-rtb"; qcom,rtb-size = <0x100000>; }; include/linux/msm_rtb.h 0 → 100644 +81 −0 Original line number Diff line number Diff line /* SPDX-License-Identifier: GPL-2.0 */ /* * Copyright (c) 2012-2014, 2016, 2018, The Linux Foundation. All rights reserved. */ #ifndef __MSM_RTB_H__ #define __MSM_RTB_H__ /* * These numbers are used from the kernel command line and sysfs * to control filtering. Remove items from here with extreme caution. */ enum logk_event_type { LOGK_NONE = 0, LOGK_READL = 1, LOGK_WRITEL = 2, LOGK_LOGBUF = 3, LOGK_HOTPLUG = 4, LOGK_CTXID = 5, LOGK_TIMESTAMP = 6, LOGK_L2CPREAD = 7, LOGK_L2CPWRITE = 8, LOGK_IRQ = 9, }; #define LOGTYPE_NOPC 0x80 struct msm_rtb_platform_data { unsigned int size; }; #if defined(CONFIG_QCOM_RTB) /* * returns 1 if data was logged, 0 otherwise */ int uncached_logk_pc(enum logk_event_type log_type, void *caller, void *data); /* * returns 1 if data was logged, 0 otherwise */ int uncached_logk(enum logk_event_type log_type, void *data); #define ETB_WAYPOINT do { \ BRANCH_TO_NEXT_ISTR; \ nop(); \ BRANCH_TO_NEXT_ISTR; \ nop(); \ } while (0) #define BRANCH_TO_NEXT_ISTR \ do { \ asm volatile("b .+4\n" : : : "memory"); \ } while (0) /* * both the mb and the isb are needed to ensure enough waypoints for * etb tracing */ #define LOG_BARRIER do { \ mb(); \ isb(); \ } while (0) #else static inline int uncached_logk_pc(enum logk_event_type log_type, void *caller, void *data) { return 0; } static inline int uncached_logk(enum logk_event_type log_type, void *data) { return 0; } #define ETB_WAYPOINT #define BRANCH_TO_NEXT_ISTR /* * Due to a GCC bug, we need to have a nop here in order to prevent an extra * read from being generated after the write. */ #define LOG_BARRIER nop() #endif #endif kernel/trace/Kconfig +19 −0 Original line number Diff line number Diff line Loading @@ -82,6 +82,25 @@ config RING_BUFFER_ALLOW_SWAP Allow the use of ring_buffer_swap_cpu. Adds a very slight overhead to tracing when enabled. config QCOM_RTB bool "Register tracing" help Enable the kernel to trace every kernel function. This is done Add support for logging different events to a small uncached region. This is designed to aid in debugging reset cases where the caches may not be flushed before the target resets. config QCOM_RTB_SEPARATE_CPUS bool "Separate entries for each cpu" depends on QCOM_RTB depends on SMP help Under some circumstances, it may be beneficial to give dedicated space for each cpu to log accesses. Selecting this option will log each cpu separately. This will guarantee that the last acesses for each cpu will be logged but there will be fewer entries per cpu # All tracer options should select GENERIC_TRACER. For those options that are # enabled by all tracers (context switch and event tracer) they select TRACING. # This allows those options to appear when no other tracer is selected. But the Loading kernel/trace/Makefile +1 −0 Original line number Diff line number Diff line Loading @@ -71,5 +71,6 @@ obj-$(CONFIG_PROBE_EVENTS) += trace_probe.o obj-$(CONFIG_UPROBE_EVENTS) += trace_uprobe.o obj-$(CONFIG_TRACEPOINT_BENCHMARK) += trace_benchmark.o obj-$(CONFIG_QCOM_RTB) += msm_rtb.o libftrace-y := ftrace.o kernel/trace/msm_rtb.c 0 → 100644 +328 −0 Original line number Diff line number Diff line // SPDX-License-Identifier: GPL-2.0 /* * Copyright (c) 2013-2018, The Linux Foundation. All rights reserved. */ #include <linux/atomic.h> #include <linux/export.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/dma-mapping.h> #include <linux/mod_devicetable.h> #include <linux/platform_device.h> #include <linux/sched/clock.h> #include <linux/slab.h> #include <linux/string.h> #include <linux/atomic.h> #include <linux/of.h> #include <linux/of_address.h> #include <linux/io.h> #include <asm-generic/sizes.h> #include <linux/msm_rtb.h> #include <asm/timex.h> #include <soc/qcom/minidump.h> #define SENTINEL_BYTE_1 0xFF #define SENTINEL_BYTE_2 0xAA #define SENTINEL_BYTE_3 0xFF #define RTB_COMPAT_STR "qcom,msm-rtb" /* Write * 1) 3 bytes sentinel * 2) 1 bytes of log type * 3) 8 bytes of where the caller came from * 4) 4 bytes index * 4) 8 bytes extra data from the caller * 5) 8 bytes of timestamp * 6) 8 bytes of cyclecount * * Total = 40 bytes. */ struct msm_rtb_layout { unsigned char sentinel[3]; unsigned char log_type; uint32_t idx; uint64_t caller; uint64_t data; uint64_t timestamp; uint64_t cycle_count; } __attribute__ ((__packed__)); struct msm_rtb_state { struct msm_rtb_layout *rtb; phys_addr_t phys; int nentries; int size; int enabled; int initialized; uint32_t filter; int step_size; }; #if defined(CONFIG_QCOM_RTB_SEPARATE_CPUS) DEFINE_PER_CPU(atomic_t, msm_rtb_idx_cpu); #else static atomic_t msm_rtb_idx; #endif static struct msm_rtb_state msm_rtb = { .filter = 1 << LOGK_LOGBUF, .enabled = 1, }; module_param_named(filter, msm_rtb.filter, uint, 0644); module_param_named(enable, msm_rtb.enabled, int, 0644); static int msm_rtb_panic_notifier(struct notifier_block *this, unsigned long event, void *ptr) { msm_rtb.enabled = 0; return NOTIFY_DONE; } static struct notifier_block msm_rtb_panic_blk = { .notifier_call = msm_rtb_panic_notifier, .priority = INT_MAX, }; int notrace msm_rtb_event_should_log(enum logk_event_type log_type) { return msm_rtb.initialized && msm_rtb.enabled && ((1 << (log_type & ~LOGTYPE_NOPC)) & msm_rtb.filter); } EXPORT_SYMBOL(msm_rtb_event_should_log); static void msm_rtb_emit_sentinel(struct msm_rtb_layout *start) { start->sentinel[0] = SENTINEL_BYTE_1; start->sentinel[1] = SENTINEL_BYTE_2; start->sentinel[2] = SENTINEL_BYTE_3; } static void msm_rtb_write_type(enum logk_event_type log_type, struct msm_rtb_layout *start) { start->log_type = (char)log_type; } static void msm_rtb_write_caller(uint64_t caller, struct msm_rtb_layout *start) { start->caller = caller; } static void msm_rtb_write_idx(uint32_t idx, struct msm_rtb_layout *start) { start->idx = idx; } static void msm_rtb_write_data(uint64_t data, struct msm_rtb_layout *start) { start->data = data; } static void msm_rtb_write_timestamp(struct msm_rtb_layout *start) { start->timestamp = sched_clock(); } static void msm_rtb_write_cyclecount(struct msm_rtb_layout *start) { start->cycle_count = get_cycles(); } static void uncached_logk_pc_idx(enum logk_event_type log_type, uint64_t caller, uint64_t data, int idx) { struct msm_rtb_layout *start; start = &msm_rtb.rtb[idx & (msm_rtb.nentries - 1)]; msm_rtb_emit_sentinel(start); msm_rtb_write_type(log_type, start); msm_rtb_write_caller(caller, start); msm_rtb_write_idx(idx, start); msm_rtb_write_data(data, start); msm_rtb_write_timestamp(start); msm_rtb_write_cyclecount(start); mb(); } static void uncached_logk_timestamp(int idx) { unsigned long long timestamp; timestamp = sched_clock(); uncached_logk_pc_idx(LOGK_TIMESTAMP|LOGTYPE_NOPC, (uint64_t)lower_32_bits(timestamp), (uint64_t)upper_32_bits(timestamp), idx); } #if defined(CONFIG_QCOM_RTB_SEPARATE_CPUS) static int msm_rtb_get_idx(void) { int cpu, i, offset; atomic_t *index; /* * ideally we would use get_cpu but this is a close enough * approximation for our purposes. */ cpu = raw_smp_processor_id(); index = &per_cpu(msm_rtb_idx_cpu, cpu); i = atomic_add_return(msm_rtb.step_size, index); i -= msm_rtb.step_size; /* Check if index has wrapped around */ offset = (i & (msm_rtb.nentries - 1)) - ((i - msm_rtb.step_size) & (msm_rtb.nentries - 1)); if (offset < 0) { uncached_logk_timestamp(i); i = atomic_add_return(msm_rtb.step_size, index); i -= msm_rtb.step_size; } return i; } #else static int msm_rtb_get_idx(void) { int i, offset; i = atomic_inc_return(&msm_rtb_idx); i--; /* Check if index has wrapped around */ offset = (i & (msm_rtb.nentries - 1)) - ((i - 1) & (msm_rtb.nentries - 1)); if (offset < 0) { uncached_logk_timestamp(i); i = atomic_inc_return(&msm_rtb_idx); i--; } return i; } #endif int notrace uncached_logk_pc(enum logk_event_type log_type, void *caller, void *data) { int i; if (!msm_rtb_event_should_log(log_type)) return 0; i = msm_rtb_get_idx(); uncached_logk_pc_idx(log_type, (uint64_t)((unsigned long) caller), (uint64_t)((unsigned long) data), i); return 1; } EXPORT_SYMBOL(uncached_logk_pc); noinline int notrace uncached_logk(enum logk_event_type log_type, void *data) { return uncached_logk_pc(log_type, __builtin_return_address(0), data); } EXPORT_SYMBOL(uncached_logk); static int msm_rtb_probe(struct platform_device *pdev) { struct msm_rtb_platform_data *d = pdev->dev.platform_data; struct md_region md_entry; #if defined(CONFIG_QCOM_RTB_SEPARATE_CPUS) unsigned int cpu; #endif int ret; if (!pdev->dev.of_node) { msm_rtb.size = d->size; } else { u64 size; struct device_node *pnode; pnode = of_parse_phandle(pdev->dev.of_node, "linux,contiguous-region", 0); if (pnode != NULL) { const u32 *addr; addr = of_get_address(pnode, 0, &size, NULL); if (!addr) { of_node_put(pnode); return -EINVAL; } of_node_put(pnode); } else { ret = of_property_read_u32(pdev->dev.of_node, "qcom,rtb-size", (u32 *)&size); if (ret < 0) return ret; } msm_rtb.size = size; } if (msm_rtb.size <= 0 || msm_rtb.size > SZ_1M) return -EINVAL; msm_rtb.rtb = dma_alloc_coherent(&pdev->dev, msm_rtb.size, &msm_rtb.phys, GFP_KERNEL); if (!msm_rtb.rtb) return -ENOMEM; msm_rtb.nentries = msm_rtb.size / sizeof(struct msm_rtb_layout); /* Round this down to a power of 2 */ msm_rtb.nentries = __rounddown_pow_of_two(msm_rtb.nentries); memset(msm_rtb.rtb, 0, msm_rtb.size); strlcpy(md_entry.name, "KRTB_BUF", sizeof(md_entry.name)); md_entry.virt_addr = (uintptr_t)msm_rtb.rtb; md_entry.phys_addr = msm_rtb.phys; md_entry.size = msm_rtb.size; if (msm_minidump_add_region(&md_entry)) pr_info("Failed to add RTB in Minidump\n"); #if defined(CONFIG_QCOM_RTB_SEPARATE_CPUS) for_each_possible_cpu(cpu) { atomic_t *a = &per_cpu(msm_rtb_idx_cpu, cpu); atomic_set(a, cpu); } msm_rtb.step_size = num_possible_cpus(); #else atomic_set(&msm_rtb_idx, 0); msm_rtb.step_size = 1; #endif atomic_notifier_chain_register(&panic_notifier_list, &msm_rtb_panic_blk); msm_rtb.initialized = 1; return 0; } static const struct of_device_id msm_match_table[] = { {.compatible = RTB_COMPAT_STR}, {}, }; static struct platform_driver msm_rtb_driver = { .probe = msm_rtb_probe, .driver = { .name = "msm_rtb", .owner = THIS_MODULE, .of_match_table = msm_match_table }, }; module_platform_driver(msm_rtb_driver); Loading
Documentation/devicetree/bindings/arm/msm/msm_rtb.txt 0 → 100644 +22 −0 Original line number Diff line number Diff line Register Trace Buffer (RTB) The RTB is used to log discrete events in the system in an uncached buffer that can be post processed from RAM dumps. The RTB must reserve memory using the msm specific memory reservation bindings (see Documentation/devicetree/bindings/arm/msm/memory-reserve.txt). Required properties - compatible: "qcom,msm-rtb" - qcom,rtb-size: size of the RTB buffer in bytes Optional properties: - linux,contiguous-region: phandle reference to a CMA region Example: qcom,msm-rtb { compatible = "qcom,msm-rtb"; qcom,rtb-size = <0x100000>; };
include/linux/msm_rtb.h 0 → 100644 +81 −0 Original line number Diff line number Diff line /* SPDX-License-Identifier: GPL-2.0 */ /* * Copyright (c) 2012-2014, 2016, 2018, The Linux Foundation. All rights reserved. */ #ifndef __MSM_RTB_H__ #define __MSM_RTB_H__ /* * These numbers are used from the kernel command line and sysfs * to control filtering. Remove items from here with extreme caution. */ enum logk_event_type { LOGK_NONE = 0, LOGK_READL = 1, LOGK_WRITEL = 2, LOGK_LOGBUF = 3, LOGK_HOTPLUG = 4, LOGK_CTXID = 5, LOGK_TIMESTAMP = 6, LOGK_L2CPREAD = 7, LOGK_L2CPWRITE = 8, LOGK_IRQ = 9, }; #define LOGTYPE_NOPC 0x80 struct msm_rtb_platform_data { unsigned int size; }; #if defined(CONFIG_QCOM_RTB) /* * returns 1 if data was logged, 0 otherwise */ int uncached_logk_pc(enum logk_event_type log_type, void *caller, void *data); /* * returns 1 if data was logged, 0 otherwise */ int uncached_logk(enum logk_event_type log_type, void *data); #define ETB_WAYPOINT do { \ BRANCH_TO_NEXT_ISTR; \ nop(); \ BRANCH_TO_NEXT_ISTR; \ nop(); \ } while (0) #define BRANCH_TO_NEXT_ISTR \ do { \ asm volatile("b .+4\n" : : : "memory"); \ } while (0) /* * both the mb and the isb are needed to ensure enough waypoints for * etb tracing */ #define LOG_BARRIER do { \ mb(); \ isb(); \ } while (0) #else static inline int uncached_logk_pc(enum logk_event_type log_type, void *caller, void *data) { return 0; } static inline int uncached_logk(enum logk_event_type log_type, void *data) { return 0; } #define ETB_WAYPOINT #define BRANCH_TO_NEXT_ISTR /* * Due to a GCC bug, we need to have a nop here in order to prevent an extra * read from being generated after the write. */ #define LOG_BARRIER nop() #endif #endif
kernel/trace/Kconfig +19 −0 Original line number Diff line number Diff line Loading @@ -82,6 +82,25 @@ config RING_BUFFER_ALLOW_SWAP Allow the use of ring_buffer_swap_cpu. Adds a very slight overhead to tracing when enabled. config QCOM_RTB bool "Register tracing" help Enable the kernel to trace every kernel function. This is done Add support for logging different events to a small uncached region. This is designed to aid in debugging reset cases where the caches may not be flushed before the target resets. config QCOM_RTB_SEPARATE_CPUS bool "Separate entries for each cpu" depends on QCOM_RTB depends on SMP help Under some circumstances, it may be beneficial to give dedicated space for each cpu to log accesses. Selecting this option will log each cpu separately. This will guarantee that the last acesses for each cpu will be logged but there will be fewer entries per cpu # All tracer options should select GENERIC_TRACER. For those options that are # enabled by all tracers (context switch and event tracer) they select TRACING. # This allows those options to appear when no other tracer is selected. But the Loading
kernel/trace/Makefile +1 −0 Original line number Diff line number Diff line Loading @@ -71,5 +71,6 @@ obj-$(CONFIG_PROBE_EVENTS) += trace_probe.o obj-$(CONFIG_UPROBE_EVENTS) += trace_uprobe.o obj-$(CONFIG_TRACEPOINT_BENCHMARK) += trace_benchmark.o obj-$(CONFIG_QCOM_RTB) += msm_rtb.o libftrace-y := ftrace.o
kernel/trace/msm_rtb.c 0 → 100644 +328 −0 Original line number Diff line number Diff line // SPDX-License-Identifier: GPL-2.0 /* * Copyright (c) 2013-2018, The Linux Foundation. All rights reserved. */ #include <linux/atomic.h> #include <linux/export.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/dma-mapping.h> #include <linux/mod_devicetable.h> #include <linux/platform_device.h> #include <linux/sched/clock.h> #include <linux/slab.h> #include <linux/string.h> #include <linux/atomic.h> #include <linux/of.h> #include <linux/of_address.h> #include <linux/io.h> #include <asm-generic/sizes.h> #include <linux/msm_rtb.h> #include <asm/timex.h> #include <soc/qcom/minidump.h> #define SENTINEL_BYTE_1 0xFF #define SENTINEL_BYTE_2 0xAA #define SENTINEL_BYTE_3 0xFF #define RTB_COMPAT_STR "qcom,msm-rtb" /* Write * 1) 3 bytes sentinel * 2) 1 bytes of log type * 3) 8 bytes of where the caller came from * 4) 4 bytes index * 4) 8 bytes extra data from the caller * 5) 8 bytes of timestamp * 6) 8 bytes of cyclecount * * Total = 40 bytes. */ struct msm_rtb_layout { unsigned char sentinel[3]; unsigned char log_type; uint32_t idx; uint64_t caller; uint64_t data; uint64_t timestamp; uint64_t cycle_count; } __attribute__ ((__packed__)); struct msm_rtb_state { struct msm_rtb_layout *rtb; phys_addr_t phys; int nentries; int size; int enabled; int initialized; uint32_t filter; int step_size; }; #if defined(CONFIG_QCOM_RTB_SEPARATE_CPUS) DEFINE_PER_CPU(atomic_t, msm_rtb_idx_cpu); #else static atomic_t msm_rtb_idx; #endif static struct msm_rtb_state msm_rtb = { .filter = 1 << LOGK_LOGBUF, .enabled = 1, }; module_param_named(filter, msm_rtb.filter, uint, 0644); module_param_named(enable, msm_rtb.enabled, int, 0644); static int msm_rtb_panic_notifier(struct notifier_block *this, unsigned long event, void *ptr) { msm_rtb.enabled = 0; return NOTIFY_DONE; } static struct notifier_block msm_rtb_panic_blk = { .notifier_call = msm_rtb_panic_notifier, .priority = INT_MAX, }; int notrace msm_rtb_event_should_log(enum logk_event_type log_type) { return msm_rtb.initialized && msm_rtb.enabled && ((1 << (log_type & ~LOGTYPE_NOPC)) & msm_rtb.filter); } EXPORT_SYMBOL(msm_rtb_event_should_log); static void msm_rtb_emit_sentinel(struct msm_rtb_layout *start) { start->sentinel[0] = SENTINEL_BYTE_1; start->sentinel[1] = SENTINEL_BYTE_2; start->sentinel[2] = SENTINEL_BYTE_3; } static void msm_rtb_write_type(enum logk_event_type log_type, struct msm_rtb_layout *start) { start->log_type = (char)log_type; } static void msm_rtb_write_caller(uint64_t caller, struct msm_rtb_layout *start) { start->caller = caller; } static void msm_rtb_write_idx(uint32_t idx, struct msm_rtb_layout *start) { start->idx = idx; } static void msm_rtb_write_data(uint64_t data, struct msm_rtb_layout *start) { start->data = data; } static void msm_rtb_write_timestamp(struct msm_rtb_layout *start) { start->timestamp = sched_clock(); } static void msm_rtb_write_cyclecount(struct msm_rtb_layout *start) { start->cycle_count = get_cycles(); } static void uncached_logk_pc_idx(enum logk_event_type log_type, uint64_t caller, uint64_t data, int idx) { struct msm_rtb_layout *start; start = &msm_rtb.rtb[idx & (msm_rtb.nentries - 1)]; msm_rtb_emit_sentinel(start); msm_rtb_write_type(log_type, start); msm_rtb_write_caller(caller, start); msm_rtb_write_idx(idx, start); msm_rtb_write_data(data, start); msm_rtb_write_timestamp(start); msm_rtb_write_cyclecount(start); mb(); } static void uncached_logk_timestamp(int idx) { unsigned long long timestamp; timestamp = sched_clock(); uncached_logk_pc_idx(LOGK_TIMESTAMP|LOGTYPE_NOPC, (uint64_t)lower_32_bits(timestamp), (uint64_t)upper_32_bits(timestamp), idx); } #if defined(CONFIG_QCOM_RTB_SEPARATE_CPUS) static int msm_rtb_get_idx(void) { int cpu, i, offset; atomic_t *index; /* * ideally we would use get_cpu but this is a close enough * approximation for our purposes. */ cpu = raw_smp_processor_id(); index = &per_cpu(msm_rtb_idx_cpu, cpu); i = atomic_add_return(msm_rtb.step_size, index); i -= msm_rtb.step_size; /* Check if index has wrapped around */ offset = (i & (msm_rtb.nentries - 1)) - ((i - msm_rtb.step_size) & (msm_rtb.nentries - 1)); if (offset < 0) { uncached_logk_timestamp(i); i = atomic_add_return(msm_rtb.step_size, index); i -= msm_rtb.step_size; } return i; } #else static int msm_rtb_get_idx(void) { int i, offset; i = atomic_inc_return(&msm_rtb_idx); i--; /* Check if index has wrapped around */ offset = (i & (msm_rtb.nentries - 1)) - ((i - 1) & (msm_rtb.nentries - 1)); if (offset < 0) { uncached_logk_timestamp(i); i = atomic_inc_return(&msm_rtb_idx); i--; } return i; } #endif int notrace uncached_logk_pc(enum logk_event_type log_type, void *caller, void *data) { int i; if (!msm_rtb_event_should_log(log_type)) return 0; i = msm_rtb_get_idx(); uncached_logk_pc_idx(log_type, (uint64_t)((unsigned long) caller), (uint64_t)((unsigned long) data), i); return 1; } EXPORT_SYMBOL(uncached_logk_pc); noinline int notrace uncached_logk(enum logk_event_type log_type, void *data) { return uncached_logk_pc(log_type, __builtin_return_address(0), data); } EXPORT_SYMBOL(uncached_logk); static int msm_rtb_probe(struct platform_device *pdev) { struct msm_rtb_platform_data *d = pdev->dev.platform_data; struct md_region md_entry; #if defined(CONFIG_QCOM_RTB_SEPARATE_CPUS) unsigned int cpu; #endif int ret; if (!pdev->dev.of_node) { msm_rtb.size = d->size; } else { u64 size; struct device_node *pnode; pnode = of_parse_phandle(pdev->dev.of_node, "linux,contiguous-region", 0); if (pnode != NULL) { const u32 *addr; addr = of_get_address(pnode, 0, &size, NULL); if (!addr) { of_node_put(pnode); return -EINVAL; } of_node_put(pnode); } else { ret = of_property_read_u32(pdev->dev.of_node, "qcom,rtb-size", (u32 *)&size); if (ret < 0) return ret; } msm_rtb.size = size; } if (msm_rtb.size <= 0 || msm_rtb.size > SZ_1M) return -EINVAL; msm_rtb.rtb = dma_alloc_coherent(&pdev->dev, msm_rtb.size, &msm_rtb.phys, GFP_KERNEL); if (!msm_rtb.rtb) return -ENOMEM; msm_rtb.nentries = msm_rtb.size / sizeof(struct msm_rtb_layout); /* Round this down to a power of 2 */ msm_rtb.nentries = __rounddown_pow_of_two(msm_rtb.nentries); memset(msm_rtb.rtb, 0, msm_rtb.size); strlcpy(md_entry.name, "KRTB_BUF", sizeof(md_entry.name)); md_entry.virt_addr = (uintptr_t)msm_rtb.rtb; md_entry.phys_addr = msm_rtb.phys; md_entry.size = msm_rtb.size; if (msm_minidump_add_region(&md_entry)) pr_info("Failed to add RTB in Minidump\n"); #if defined(CONFIG_QCOM_RTB_SEPARATE_CPUS) for_each_possible_cpu(cpu) { atomic_t *a = &per_cpu(msm_rtb_idx_cpu, cpu); atomic_set(a, cpu); } msm_rtb.step_size = num_possible_cpus(); #else atomic_set(&msm_rtb_idx, 0); msm_rtb.step_size = 1; #endif atomic_notifier_chain_register(&panic_notifier_list, &msm_rtb_panic_blk); msm_rtb.initialized = 1; return 0; } static const struct of_device_id msm_match_table[] = { {.compatible = RTB_COMPAT_STR}, {}, }; static struct platform_driver msm_rtb_driver = { .probe = msm_rtb_probe, .driver = { .name = "msm_rtb", .owner = THIS_MODULE, .of_match_table = msm_match_table }, }; module_platform_driver(msm_rtb_driver);
