trace: rtb: add msm_rtb register tracing feature snapshot

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>;

	};

/*

 * Copyright (c) 2012-2014, 2016 The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */

#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

	 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

obj-$(CONFIG_TRACEPOINT_BENCHMARK) += trace_benchmark.o

obj-$(CONFIG_QCOM_RTB) += msm_rtb.o

libftrace-y := ftrace.o

/*

 * Copyright (c) 2013-2016, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */

#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>

#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

 *

 * Total = 32 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;

} __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 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);

	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;

#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);

#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

	},

};

static int __init msm_rtb_init(void)

{

	return platform_driver_register(&msm_rtb_driver);

}

static void __exit msm_rtb_exit(void)

{

	platform_driver_unregister(&msm_rtb_driver);

}

module_init(msm_rtb_init)

module_exit(msm_rtb_exit)