2 * arch/hexagon/kernel/kgdb.c - Hexagon KGDB Support
4 * Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 and
8 * only version 2 as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21 #include <linux/irq.h>
22 #include <linux/sched.h>
23 #include <linux/sched/task_stack.h>
24 #include <linux/kdebug.h>
25 #include <linux/kgdb.h>
27 /* All registers are 4 bytes, for now */
28 #define GDB_SIZEOF_REG 4
30 /* The register names are used during printing of the regs;
31 * Keep these at three letters to pretty-print. */
32 struct dbg_reg_def_t dbg_reg_def
[DBG_MAX_REG_NUM
] = {
33 { " r0", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r00
)},
34 { " r1", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r01
)},
35 { " r2", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r02
)},
36 { " r3", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r03
)},
37 { " r4", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r04
)},
38 { " r5", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r05
)},
39 { " r6", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r06
)},
40 { " r7", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r07
)},
41 { " r8", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r08
)},
42 { " r9", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r09
)},
43 { "r10", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r10
)},
44 { "r11", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r11
)},
45 { "r12", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r12
)},
46 { "r13", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r13
)},
47 { "r14", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r14
)},
48 { "r15", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r15
)},
49 { "r16", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r16
)},
50 { "r17", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r17
)},
51 { "r18", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r18
)},
52 { "r19", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r19
)},
53 { "r20", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r20
)},
54 { "r21", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r21
)},
55 { "r22", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r22
)},
56 { "r23", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r23
)},
57 { "r24", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r24
)},
58 { "r25", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r25
)},
59 { "r26", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r26
)},
60 { "r27", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r27
)},
61 { "r28", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r28
)},
62 { "r29", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r29
)},
63 { "r30", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r30
)},
64 { "r31", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, r31
)},
66 { "usr", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, usr
)},
67 { "preds", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, preds
)},
68 { " m0", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, m0
)},
69 { " m1", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, m1
)},
70 { "sa0", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, sa0
)},
71 { "sa1", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, sa1
)},
72 { "lc0", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, lc0
)},
73 { "lc1", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, lc1
)},
74 { " gp", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, gp
)},
75 { "ugp", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, ugp
)},
76 { "cs0", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, cs0
)},
77 { "cs1", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, cs1
)},
78 { "psp", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, hvmer
.vmpsp
)},
79 { "elr", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, hvmer
.vmel
)},
80 { "est", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, hvmer
.vmest
)},
81 { "badva", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, hvmer
.vmbadva
)},
82 { "restart_r0", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, restart_r0
)},
83 { "syscall_nr", GDB_SIZEOF_REG
, offsetof(struct pt_regs
, syscall_nr
)},
86 struct kgdb_arch arch_kgdb_ops
= {
87 /* trap0(#0xDB) 0x0cdb0054 */
88 .gdb_bpt_instr
= {0x54, 0x00, 0xdb, 0x0c},
91 char *dbg_get_reg(int regno
, void *mem
, struct pt_regs
*regs
)
93 if (regno
>= DBG_MAX_REG_NUM
|| regno
< 0)
96 *((unsigned long *) mem
) = *((unsigned long *) ((void *)regs
+
97 dbg_reg_def
[regno
].offset
));
99 return dbg_reg_def
[regno
].name
;
102 int dbg_set_reg(int regno
, void *mem
, struct pt_regs
*regs
)
104 if (regno
>= DBG_MAX_REG_NUM
|| regno
< 0)
107 *((unsigned long *) ((void *)regs
+ dbg_reg_def
[regno
].offset
)) =
108 *((unsigned long *) mem
);
113 void kgdb_arch_set_pc(struct pt_regs
*regs
, unsigned long pc
)
115 instruction_pointer(regs
) = pc
;
121 * kgdb_roundup_cpus - Get other CPUs into a holding pattern
122 * @flags: Current IRQ state
124 * On SMP systems, we need to get the attention of the other CPUs
125 * and get them be in a known state. This should do what is needed
126 * to get the other CPUs to call kgdb_wait(). Note that on some arches,
127 * the NMI approach is not used for rounding up all the CPUs. For example,
128 * in case of MIPS, smp_call_function() is used to roundup CPUs. In
129 * this case, we have to make sure that interrupts are enabled before
130 * calling smp_call_function(). The argument to this function is
131 * the flags that will be used when restoring the interrupts. There is
132 * local_irq_save() call before kgdb_roundup_cpus().
134 * On non-SMP systems, this is not called.
137 static void hexagon_kgdb_nmi_hook(void *ignored
)
139 kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs());
142 void kgdb_roundup_cpus(unsigned long flags
)
145 smp_call_function(hexagon_kgdb_nmi_hook
, NULL
, 0);
151 /* Not yet working */
152 void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs
,
153 struct task_struct
*task
)
155 struct pt_regs
*thread_regs
;
160 /* Initialize to zero */
161 memset(gdb_regs
, 0, NUMREGBYTES
);
163 /* Otherwise, we have only some registers from switch_to() */
164 thread_regs
= task_pt_regs(task
);
165 gdb_regs
[0] = thread_regs
->r00
;
169 * kgdb_arch_handle_exception - Handle architecture specific GDB packets.
170 * @vector: The error vector of the exception that happened.
171 * @signo: The signal number of the exception that happened.
172 * @err_code: The error code of the exception that happened.
173 * @remcom_in_buffer: The buffer of the packet we have read.
174 * @remcom_out_buffer: The buffer of %BUFMAX bytes to write a packet into.
175 * @regs: The &struct pt_regs of the current process.
177 * This function MUST handle the 'c' and 's' command packets,
178 * as well packets to set / remove a hardware breakpoint, if used.
179 * If there are additional packets which the hardware needs to handle,
180 * they are handled here. The code should return -1 if it wants to
181 * process more packets, and a %0 or %1 if it wants to exit from the
186 int kgdb_arch_handle_exception(int vector
, int signo
, int err_code
,
187 char *remcom_in_buffer
, char *remcom_out_buffer
,
188 struct pt_regs
*linux_regs
)
190 switch (remcom_in_buffer
[0]) {
195 /* Stay in the debugger. */
199 static int __kgdb_notify(struct die_args
*args
, unsigned long cmd
)
202 if (atomic_read(&kgdb_active
) != -1) {
203 kgdb_nmicallback(smp_processor_id(), args
->regs
);
207 if (user_mode(args
->regs
))
210 if (kgdb_handle_exception(args
->trapnr
& 0xff, args
->signr
, args
->err
,
218 kgdb_notify(struct notifier_block
*self
, unsigned long cmd
, void *ptr
)
223 local_irq_save(flags
);
224 ret
= __kgdb_notify(ptr
, cmd
);
225 local_irq_restore(flags
);
230 static struct notifier_block kgdb_notifier
= {
231 .notifier_call
= kgdb_notify
,
234 * Lowest-prio notifier priority, we want to be notified last:
236 .priority
= -INT_MAX
,
240 * kgdb_arch_init - Perform any architecture specific initialization.
242 * This function will handle the initialization of any architecture
243 * specific callbacks.
245 int kgdb_arch_init(void)
247 return register_die_notifier(&kgdb_notifier
);
251 * kgdb_arch_exit - Perform any architecture specific uninitalization.
253 * This function will handle the uninitalization of any architecture
254 * specific callbacks, for dynamic registration and unregistration.
256 void kgdb_arch_exit(void)
258 unregister_die_notifier(&kgdb_notifier
);