summaryrefstree
path: root/kernel/include/linux/sec_debug.h
blob: ed452cf799386c0bfd54267353d6230b1d6938b2 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
/*
* Samsung debugging features for Samsung's SoC's.
*
* Copyright (c) 2019 Samsung Electronics Co., Ltd.
*      http://www.samsung.com
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/

#ifndef SEC_DEBUG_H
#define SEC_DEBUG_H

#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/irq.h>

/*
 * SEC DEBUG RAMBASE HANDLING 
 */
extern void secdbg_base_clear_magic_rambase(void);

/*
 * SEC DEBUG PANIC HANDLING 
 */
extern void secdbg_base_panic_handler(void *buf, bool dump);
extern void secdbg_base_post_panic_handler(void);

/*
 * SEC DEBUG LAST KMSG
 */
#ifdef CONFIG_SEC_DEBUG_LAST_KMSG
#define SEC_LKMSG_MAGICKEY 0x0000000a6c6c7546

extern void secdbg_lkmg_store(unsigned char *head_ptr,
		unsigned char *curr_ptr, size_t buf_size);
#else
#define secdbg_lkmg_store(a, b, c)		do {} while(0)
#endif

/*
 * SEC DEBUG MODE
 */
extern int secdbg_mode_enter_upload(void);

/*
 * SEC DEBUG - DEBUG SNAPSHOT BASE HOOKING
 */
enum {
	DSS_KEVENT_TASK,
	DSS_KEVENT_WORK,
	DSS_KEVENT_IRQ,
	DSS_KEVENT_FREQ,
	DSS_KEVENT_IDLE,
	DSS_KEVENT_THRM,
	DSS_KEVENT_ACPM,
	DSS_KEVENT_MFRQ,
};

#define SD_ESSINFO_KEY_SIZE	(32)

struct ess_info_offset {
	char key[SD_ESSINFO_KEY_SIZE];
	unsigned long base;
	unsigned long last;
	unsigned int nr;
	unsigned int size;
	unsigned int per_core;
};

extern unsigned long secdbg_base_get_kevent_index_addr(int type);
extern void secdbg_base_get_kevent_info(struct ess_info_offset *p, int type);

/*
 * SEC DEBUG AUTO COMMENT
 */
#ifdef CONFIG_SEC_DEBUG_AUTO_COMMENT
extern void secdbg_comm_log_disable(int type);
extern void secdbg_comm_log_once(int type);
#endif /* CONFIG_SEC_DEBUG_AUTO_COMMENT */

/*
 * SEC DEBUG EXTRA INFO
 */
#ifdef CONFIG_SEC_DEBUG_EXTRA_INFO
enum secdbg_exin_fault_type {
	UNDEF_FAULT,
	BAD_MODE_FAULT,
	WATCHDOG_FAULT,
	KERNEL_FAULT,
	MEM_ABORT_FAULT,
	SP_PC_ABORT_FAULT,
	PAGE_FAULT,
	ACCESS_USER_FAULT,
	EXE_USER_FAULT,
	ACCESS_USER_OUTSIDE_FAULT,
	BUG_FAULT,
	SERROR_FAULT,
	SEABORT_FAULT,
	FAULT_MAX,
};

extern void secdbg_exin_set_finish(void);
extern void secdbg_exin_set_fault(enum secdbg_exin_fault_type,
				  unsigned long addr, struct pt_regs *regs);
extern void secdbg_exin_set_bug(const char *file, unsigned int line);
extern void secdbg_exin_set_panic(char *str);
extern void secdbg_exin_set_backtrace(struct pt_regs *regs);
extern void secdbg_exin_set_backtrace_cpu(struct pt_regs *regs, int cpu);
extern void secdbg_exin_set_backtrace_task(struct task_struct *tsk);
extern void secdbg_exin_set_sysmmu(char *str);
extern void secdbg_exin_set_busmon(char *str);
extern void secdbg_exin_set_dpm_timeout(char *devname);
extern void secdbg_exin_set_smpl(unsigned long count);
extern void secdbg_exin_set_esr(unsigned int esr);
extern void secdbg_exin_set_merr(char *merr);
extern void secdbg_exin_set_hint(unsigned long hint);
extern void secdbg_exin_set_decon(unsigned int err);
extern void secdbg_exin_set_batt(int cap, int volt, int temp, int curr);
extern void secdbg_exin_set_ufs_error(char *str);
extern void secdbg_exin_set_zswap(char *str);
extern void secdbg_exin_set_mfc_error(char *str);
extern void secdbg_exin_set_aud(char *str);
extern void secdbg_exin_set_epd(char *str);
extern void secdbg_exin_set_unfz(const char *tmp, int pid);
extern char *secdbg_exin_get_unfz(void);
extern void secdbg_exin_set_master_ocp(void);
extern void secdbg_exin_set_slave_ocp(void);
#else /* !CONFIG_SEC_DEBUG_EXTRA_INFO */
#define secdbg_exin_set_finish(a)	do { } while (0)
#define secdbg_exin_set_fault(a, b, c)	do { } while (0)
#define secdbg_exin_set_bug(a, b)	do { } while (0)
#define secdbg_exin_set_panic(a)	do { } while (0)
#define secdbg_exin_set_backtrace(a)	do { } while (0)
#define secdbg_exin_set_backtrace_cpu(a, b)	do { } while (0)
#define secdbg_exin_set_backtrace_task(a)	do { } while (0)
#define secdbg_exin_set_sysmmu(a)	do { } while (0)
#define secdbg_exin_set_busmon(a)	do { } while (0)
#define secdbg_exin_set_dpm_timeout(a)	do { } while (0)
#define secdbg_exin_set_smpl(a)		do { } while (0)
#define secdbg_exin_set_esr(a)		do { } while (0)
#define secdbg_exin_set_merr(a)		do { } while (0)
#define secdbg_exin_set_hint(a)		do { } while (0)
#define secdbg_exin_set_decon(a)	do { } while (0)
#define secdbg_exin_set_batt(a, b, c, d)	do { } while (0)
#define secdbg_exin_set_ufs_error(a)	do { } while (0)
#define secdbg_exin_set_zswap(a)	do { } while (0)
#define secdbg_exin_set_mfc_error(a)	do { } while (0)
#define secdbg_exin_set_aud(a)		do { } while (0)
#define secdbg_exin_set_epd(a)		do { } while (0)
#define secdbg_exin_set_unfz(a)		do { } while (0)
#define secdbg_exin_get_unfz(a)		do { } while (0)
#define secdbg_exin_set_master_ocp()		do { } while (0)
#define secdbg_exin_set_slave_ocp()		do { } while (0)
#endif /* CONFIG_SEC_DEBUG_EXTRA_INFO */

#ifdef CONFIG_SEC_DEBUG_WATCHDOGD_FOOTPRINT
extern void secdbg_wdd_set_keepalive(void);
extern void secdbg_wdd_set_start(void);
extern void secdbg_wdd_set_emerg_addr(unsigned long addr);
#else
#define secdbg_wdd_set_keepalive(a)	do { } while (0)
#define secdbg_wdd_set_start(a)		do { } while (0)
#define secdbg_wdd_set_emerg_addr(a)	do { } while (0)
#endif

#ifdef CONFIG_SEC_DEBUG_FREQ
extern void secdbg_freq_check(int type, unsigned long index, unsigned long freq, int en);
#endif

#ifdef CONFIG_SEC_DEBUG_SYSRQ_KMSG
extern size_t secdbg_hook_get_curr_init_ptr(void);
extern size_t dbg_snapshot_get_curr_ptr_for_sysrq(void);
#endif

/* SEC_LOCKUP_INFO */
extern void secdbg_base_set_task_in_soft_lockup(uint64_t task);
extern void secdbg_base_set_cpu_in_soft_lockup(uint64_t cpu);
extern void secdbg_base_set_task_in_hard_lockup(uint64_t task);
extern void secdbg_base_set_cpu_in_hard_lockup(uint64_t cpu);

/* unfrozen task */
#ifdef CONFIG_SEC_DEBUG_UNFROZEN_TASK
extern void secdbg_base_set_unfrozen_task(uint64_t task);
extern void secdbg_base_set_unfrozen_task_count(uint64_t count);
#else
static inline void secdbg_base_set_unfrozen_task(uint64_t task) {}
static inline void secdbg_base_set_unfrozen_task_count(uint64_t count) {}
#endif /* CONFIG_SEC_DEBUG_UNFROZEN_TASK */

/* CONFIG_SEC_DEBUG_BAD_STACK_INFO */
extern void secdbg_base_set_bs_info_phase(int phase);

#ifdef CONFIG_SEC_DEBUG_DTASK
extern void secdbg_dtsk_print_info(struct task_struct *task, bool raw);
extern void secdbg_dtsk_set_data(int type, void *data);
static inline void secdbg_dtsk_clear_data(void)
{
	secdbg_dtsk_set_data(DTYPE_NONE, NULL);
}
#else
#define secdbg_dtsk_print_info(a, b)		do { } while (0)
#define secdbg_dtsk_set_data(a, b)		do { } while (0)
#define secdbg_dtsk_clear_data()		do { } while (0)
#endif /* CONFIG_SEC_DEBUG_DTASK */

#ifdef CONFIG_SEC_DEBUG_PM_DEVICE_INFO
extern void secdbg_base_set_device_shutdown_timeinfo(uint64_t start, uint64_t end, uint64_t duration, uint64_t func);
extern void secdbg_base_clr_device_shutdown_timeinfo(void);
extern void secdbg_base_set_shutdown_device(const char *fname, const char *dname);
extern void secdbg_base_set_suspend_device(const char *fname, const char *dname);
#else
#define secdbg_base_set_device_shutdown_timeinfo(a, b, c, d)	do { } while (0)
#define secdbg_base_clr_device_shutdown_timeinfo()	do { } while (0)
#define secdbg_base_set_shutdown_device(a, b)		do { } while (0)
#define secdbg_base_set_suspend_device(a, b)		do { } while (0)
#endif /* CONFIG_SEC_DEBUG_PM_DEVICE_INFO */

#ifdef CONFIG_SEC_DEBUG_TASK_IN_STATE_INFO
extern void secdbg_base_set_task_in_pm_suspend(uint64_t task);
extern void secdbg_base_set_task_in_sys_reboot(uint64_t task);
extern void secdbg_base_set_task_in_sys_shutdown(uint64_t task);
extern void secdbg_base_set_task_in_dev_shutdown(uint64_t task);
extern void secdbg_base_set_task_in_sync_irq(uint64_t task, unsigned int irq, const char *name, struct irq_desc *desc);
#else
#define secdbg_base_set_task_in_pm_suspend(a)		do { } while (0)
#define secdbg_base_set_task_in_sys_reboot(a)		do { } while (0)
#define secdbg_base_set_task_in_sys_shutdown(a)		do { } while (0)
#define secdbg_base_set_task_in_dev_shutdown(a)		do { } while (0)
#define secdbg_base_set_task_in_sync_irq(a, b, c, d)	do { } while (0)
#endif /* CONFIG_SEC_DEBUG_PM_DEVICE_INFO */

#ifdef CONFIG_SEC_DEBUG_SHOW_USER_STACK
extern void secdbg_send_sig_debuggerd(struct task_struct *p, int opt);
#else
#define secdbg_send_sig_debuggerd(a, b)		do { } while (0)
#endif

#ifdef CONFIG_SEC_DEBUG
#define SDBG_KNAME_LEN	64

struct secdbg_member_type {
	char member[SDBG_KNAME_LEN];
	uint16_t size;
	uint16_t offset;
	uint16_t unused[2];
};

#define SECDBG_DEFINE_MEMBER_TYPE(key, st, mem)					\
	const struct secdbg_member_type sdbg_##key				\
		__attribute__((__section__(".secdbg_mbtab." #key))) = {		\
		.member = #key,							\
		.size = FIELD_SIZEOF(struct st, mem),				\
		.offset = offsetof(struct st, mem),				\
	}
#else
#define SECDBG_DEFINE_MEMBER_TYPE(a, b, c)
#endif /* CONFIG_SEC_DEBUG */

#ifdef CONFIG_SEC_DEBUG_SOFTDOG
extern void secdbg_softdog_show_info(void);
#else
#define secdbg_softdog_show_info()		do { } while (0)
#endif

#endif /* SEC_DEBUG_H */