2 * arch/blackfin/kernel/kgdb.c - Blackfin kgdb pieces
4 * Copyright 2005-2008 Analog Devices Inc.
6 * Licensed under the GPL-2 or later.
9 #include <linux/string.h>
10 #include <linux/kernel.h>
11 #include <linux/sched.h>
12 #include <linux/smp.h>
13 #include <linux/spinlock.h>
14 #include <linux/delay.h>
15 #include <linux/ptrace.h> /* for linux pt_regs struct */
16 #include <linux/kgdb.h>
17 #include <linux/console.h>
18 #include <linux/init.h>
19 #include <linux/errno.h>
20 #include <linux/irq.h>
21 #include <linux/uaccess.h>
22 #include <asm/system.h>
23 #include <asm/traps.h>
24 #include <asm/blackfin.h>
27 /* Put the error code here just in case the user cares. */
29 /* Likewise, the vector number here (since GDB only gets the signal
30 number through the usual means, and that's not very specific). */
31 int gdb_bfin_vector = -1;
33 #if KGDB_MAX_NO_CPUS != 8
34 #error change the definition of slavecpulocks
37 #ifdef CONFIG_BFIN_WDT
38 # error "Please unselect blackfin watchdog driver before build KGDB."
41 void pt_regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs)
43 gdb_regs[BFIN_R0] = regs->r0;
44 gdb_regs[BFIN_R1] = regs->r1;
45 gdb_regs[BFIN_R2] = regs->r2;
46 gdb_regs[BFIN_R3] = regs->r3;
47 gdb_regs[BFIN_R4] = regs->r4;
48 gdb_regs[BFIN_R5] = regs->r5;
49 gdb_regs[BFIN_R6] = regs->r6;
50 gdb_regs[BFIN_R7] = regs->r7;
51 gdb_regs[BFIN_P0] = regs->p0;
52 gdb_regs[BFIN_P1] = regs->p1;
53 gdb_regs[BFIN_P2] = regs->p2;
54 gdb_regs[BFIN_P3] = regs->p3;
55 gdb_regs[BFIN_P4] = regs->p4;
56 gdb_regs[BFIN_P5] = regs->p5;
57 gdb_regs[BFIN_SP] = regs->reserved;
58 gdb_regs[BFIN_FP] = regs->fp;
59 gdb_regs[BFIN_I0] = regs->i0;
60 gdb_regs[BFIN_I1] = regs->i1;
61 gdb_regs[BFIN_I2] = regs->i2;
62 gdb_regs[BFIN_I3] = regs->i3;
63 gdb_regs[BFIN_M0] = regs->m0;
64 gdb_regs[BFIN_M1] = regs->m1;
65 gdb_regs[BFIN_M2] = regs->m2;
66 gdb_regs[BFIN_M3] = regs->m3;
67 gdb_regs[BFIN_B0] = regs->b0;
68 gdb_regs[BFIN_B1] = regs->b1;
69 gdb_regs[BFIN_B2] = regs->b2;
70 gdb_regs[BFIN_B3] = regs->b3;
71 gdb_regs[BFIN_L0] = regs->l0;
72 gdb_regs[BFIN_L1] = regs->l1;
73 gdb_regs[BFIN_L2] = regs->l2;
74 gdb_regs[BFIN_L3] = regs->l3;
75 gdb_regs[BFIN_A0_DOT_X] = regs->a0x;
76 gdb_regs[BFIN_A0_DOT_W] = regs->a0w;
77 gdb_regs[BFIN_A1_DOT_X] = regs->a1x;
78 gdb_regs[BFIN_A1_DOT_W] = regs->a1w;
79 gdb_regs[BFIN_ASTAT] = regs->astat;
80 gdb_regs[BFIN_RETS] = regs->rets;
81 gdb_regs[BFIN_LC0] = regs->lc0;
82 gdb_regs[BFIN_LT0] = regs->lt0;
83 gdb_regs[BFIN_LB0] = regs->lb0;
84 gdb_regs[BFIN_LC1] = regs->lc1;
85 gdb_regs[BFIN_LT1] = regs->lt1;
86 gdb_regs[BFIN_LB1] = regs->lb1;
87 gdb_regs[BFIN_CYCLES] = 0;
88 gdb_regs[BFIN_CYCLES2] = 0;
89 gdb_regs[BFIN_USP] = regs->usp;
90 gdb_regs[BFIN_SEQSTAT] = regs->seqstat;
91 gdb_regs[BFIN_SYSCFG] = regs->syscfg;
92 gdb_regs[BFIN_RETI] = regs->pc;
93 gdb_regs[BFIN_RETX] = regs->retx;
94 gdb_regs[BFIN_RETN] = regs->retn;
95 gdb_regs[BFIN_RETE] = regs->rete;
96 gdb_regs[BFIN_PC] = regs->pc;
97 gdb_regs[BFIN_CC] = 0;
98 gdb_regs[BFIN_EXTRA1] = 0;
99 gdb_regs[BFIN_EXTRA2] = 0;
100 gdb_regs[BFIN_EXTRA3] = 0;
101 gdb_regs[BFIN_IPEND] = regs->ipend;
105 * Extracts ebp, esp and eip values understandable by gdb from the values
106 * saved by switch_to.
107 * thread.esp points to ebp. flags and ebp are pushed in switch_to hence esp
108 * prior to entering switch_to is 8 greater then the value that is saved.
109 * If switch_to changes, change following code appropriately.
111 void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p)
113 gdb_regs[BFIN_SP] = p->thread.ksp;
114 gdb_regs[BFIN_PC] = p->thread.pc;
115 gdb_regs[BFIN_SEQSTAT] = p->thread.seqstat;
118 void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *regs)
120 regs->r0 = gdb_regs[BFIN_R0];
121 regs->r1 = gdb_regs[BFIN_R1];
122 regs->r2 = gdb_regs[BFIN_R2];
123 regs->r3 = gdb_regs[BFIN_R3];
124 regs->r4 = gdb_regs[BFIN_R4];
125 regs->r5 = gdb_regs[BFIN_R5];
126 regs->r6 = gdb_regs[BFIN_R6];
127 regs->r7 = gdb_regs[BFIN_R7];
128 regs->p0 = gdb_regs[BFIN_P0];
129 regs->p1 = gdb_regs[BFIN_P1];
130 regs->p2 = gdb_regs[BFIN_P2];
131 regs->p3 = gdb_regs[BFIN_P3];
132 regs->p4 = gdb_regs[BFIN_P4];
133 regs->p5 = gdb_regs[BFIN_P5];
134 regs->fp = gdb_regs[BFIN_FP];
135 regs->i0 = gdb_regs[BFIN_I0];
136 regs->i1 = gdb_regs[BFIN_I1];
137 regs->i2 = gdb_regs[BFIN_I2];
138 regs->i3 = gdb_regs[BFIN_I3];
139 regs->m0 = gdb_regs[BFIN_M0];
140 regs->m1 = gdb_regs[BFIN_M1];
141 regs->m2 = gdb_regs[BFIN_M2];
142 regs->m3 = gdb_regs[BFIN_M3];
143 regs->b0 = gdb_regs[BFIN_B0];
144 regs->b1 = gdb_regs[BFIN_B1];
145 regs->b2 = gdb_regs[BFIN_B2];
146 regs->b3 = gdb_regs[BFIN_B3];
147 regs->l0 = gdb_regs[BFIN_L0];
148 regs->l1 = gdb_regs[BFIN_L1];
149 regs->l2 = gdb_regs[BFIN_L2];
150 regs->l3 = gdb_regs[BFIN_L3];
151 regs->a0x = gdb_regs[BFIN_A0_DOT_X];
152 regs->a0w = gdb_regs[BFIN_A0_DOT_W];
153 regs->a1x = gdb_regs[BFIN_A1_DOT_X];
154 regs->a1w = gdb_regs[BFIN_A1_DOT_W];
155 regs->rets = gdb_regs[BFIN_RETS];
156 regs->lc0 = gdb_regs[BFIN_LC0];
157 regs->lt0 = gdb_regs[BFIN_LT0];
158 regs->lb0 = gdb_regs[BFIN_LB0];
159 regs->lc1 = gdb_regs[BFIN_LC1];
160 regs->lt1 = gdb_regs[BFIN_LT1];
161 regs->lb1 = gdb_regs[BFIN_LB1];
162 regs->usp = gdb_regs[BFIN_USP];
163 regs->syscfg = gdb_regs[BFIN_SYSCFG];
164 regs->retx = gdb_regs[BFIN_PC];
165 regs->retn = gdb_regs[BFIN_RETN];
166 regs->rete = gdb_regs[BFIN_RETE];
167 regs->pc = gdb_regs[BFIN_PC];
169 #if 0 /* can't change these */
170 regs->astat = gdb_regs[BFIN_ASTAT];
171 regs->seqstat = gdb_regs[BFIN_SEQSTAT];
172 regs->ipend = gdb_regs[BFIN_IPEND];
176 struct hw_breakpoint {
177 unsigned int occupied:1;
179 unsigned int enabled:1;
181 unsigned int dataacc:2;
182 unsigned short count;
184 } breakinfo[HW_WATCHPOINT_NUM];
186 int bfin_set_hw_break(unsigned long addr, int len, enum kgdb_bptype type)
193 case BP_HARDWARE_BREAKPOINT:
194 bfin_type = TYPE_INST_WATCHPOINT;
196 case BP_WRITE_WATCHPOINT:
198 bfin_type = TYPE_DATA_WATCHPOINT;
200 case BP_READ_WATCHPOINT:
202 bfin_type = TYPE_DATA_WATCHPOINT;
204 case BP_ACCESS_WATCHPOINT:
206 bfin_type = TYPE_DATA_WATCHPOINT;
212 /* Becasue hardware data watchpoint impelemented in current
213 * Blackfin can not trigger an exception event as the hardware
214 * instrction watchpoint does, we ignaore all data watch point here.
215 * They can be turned on easily after future blackfin design
216 * supports this feature.
218 for (breakno = 0; breakno < HW_INST_WATCHPOINT_NUM; breakno++)
219 if (bfin_type == breakinfo[breakno].type
220 && !breakinfo[breakno].occupied) {
221 breakinfo[breakno].occupied = 1;
222 breakinfo[breakno].skip = 0;
223 breakinfo[breakno].enabled = 1;
224 breakinfo[breakno].addr = addr;
225 breakinfo[breakno].dataacc = dataacc;
226 breakinfo[breakno].count = 0;
233 int bfin_remove_hw_break(unsigned long addr, int len, enum kgdb_bptype type)
239 case BP_HARDWARE_BREAKPOINT:
240 bfin_type = TYPE_INST_WATCHPOINT;
242 case BP_WRITE_WATCHPOINT:
243 case BP_READ_WATCHPOINT:
244 case BP_ACCESS_WATCHPOINT:
245 bfin_type = TYPE_DATA_WATCHPOINT;
250 for (breakno = 0; breakno < HW_WATCHPOINT_NUM; breakno++)
251 if (bfin_type == breakinfo[breakno].type
252 && breakinfo[breakno].occupied
253 && breakinfo[breakno].addr == addr) {
254 breakinfo[breakno].occupied = 0;
255 breakinfo[breakno].enabled = 0;
261 void bfin_remove_all_hw_break(void)
265 memset(breakinfo, 0, sizeof(struct hw_breakpoint)*HW_WATCHPOINT_NUM);
267 for (breakno = 0; breakno < HW_INST_WATCHPOINT_NUM; breakno++)
268 breakinfo[breakno].type = TYPE_INST_WATCHPOINT;
269 for (; breakno < HW_WATCHPOINT_NUM; breakno++)
270 breakinfo[breakno].type = TYPE_DATA_WATCHPOINT;
273 void bfin_correct_hw_break(void)
276 unsigned int wpiactl = 0;
277 unsigned int wpdactl = 0;
280 for (breakno = 0; breakno < HW_WATCHPOINT_NUM; breakno++)
281 if (breakinfo[breakno].enabled) {
286 wpiactl |= WPIAEN0|WPICNTEN0;
287 bfin_write_WPIA0(breakinfo[breakno].addr);
288 bfin_write_WPIACNT0(breakinfo[breakno].count
292 wpiactl |= WPIAEN1|WPICNTEN1;
293 bfin_write_WPIA1(breakinfo[breakno].addr);
294 bfin_write_WPIACNT1(breakinfo[breakno].count
298 wpiactl |= WPIAEN2|WPICNTEN2;
299 bfin_write_WPIA2(breakinfo[breakno].addr);
300 bfin_write_WPIACNT2(breakinfo[breakno].count
304 wpiactl |= WPIAEN3|WPICNTEN3;
305 bfin_write_WPIA3(breakinfo[breakno].addr);
306 bfin_write_WPIACNT3(breakinfo[breakno].count
310 wpiactl |= WPIAEN4|WPICNTEN4;
311 bfin_write_WPIA4(breakinfo[breakno].addr);
312 bfin_write_WPIACNT4(breakinfo[breakno].count
316 wpiactl |= WPIAEN5|WPICNTEN5;
317 bfin_write_WPIA5(breakinfo[breakno].addr);
318 bfin_write_WPIACNT5(breakinfo[breakno].count
322 wpdactl |= WPDAEN0|WPDCNTEN0|WPDSRC0;
323 wpdactl |= breakinfo[breakno].dataacc
325 bfin_write_WPDA0(breakinfo[breakno].addr);
326 bfin_write_WPDACNT0(breakinfo[breakno].count
330 wpdactl |= WPDAEN1|WPDCNTEN1|WPDSRC1;
331 wpdactl |= breakinfo[breakno].dataacc
333 bfin_write_WPDA1(breakinfo[breakno].addr);
334 bfin_write_WPDACNT1(breakinfo[breakno].count
340 /* Should enable WPPWR bit first before set any other
341 * WPIACTL and WPDACTL bits */
343 bfin_write_WPIACTL(WPPWR);
345 bfin_write_WPIACTL(wpiactl|WPPWR);
346 bfin_write_WPDACTL(wpdactl);
351 void kgdb_disable_hw_debug(struct pt_regs *regs)
353 /* Disable hardware debugging while we are in kgdb */
354 bfin_write_WPIACTL(0);
355 bfin_write_WPDACTL(0);
360 void kgdb_passive_cpu_callback(void *info)
362 kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs());
365 void kgdb_roundup_cpus(unsigned long flags)
367 smp_call_function(kgdb_passive_cpu_callback, NULL, 0);
370 void kgdb_roundup_cpu(int cpu, unsigned long flags)
372 smp_call_function_single(cpu, kgdb_passive_cpu_callback, NULL, 0);
376 void kgdb_post_primary_code(struct pt_regs *regs, int eVector, int err_code)
378 /* Master processor is completely in the debugger */
379 gdb_bfin_vector = eVector;
380 gdb_bfin_errcode = err_code;
383 int kgdb_arch_handle_exception(int vector, int signo,
384 int err_code, char *remcom_in_buffer,
385 char *remcom_out_buffer,
386 struct pt_regs *regs)
395 switch (remcom_in_buffer[0]) {
398 if (kgdb_contthread && kgdb_contthread != current) {
399 strcpy(remcom_out_buffer, "E00");
403 kgdb_contthread = NULL;
405 /* try to read optional parameter, pc unchanged if no parm */
406 ptr = &remcom_in_buffer[1];
407 if (kgdb_hex2long(&ptr, &addr)) {
412 /* clear the trace bit */
413 regs->syscfg &= 0xfffffffe;
415 /* set the trace bit if we're stepping */
416 if (remcom_in_buffer[0] == 's') {
418 kgdb_single_step = regs->ipend;
419 kgdb_single_step >>= 6;
420 for (i = 10; i > 0; i--, kgdb_single_step >>= 1)
421 if (kgdb_single_step & 1)
423 /* i indicate event priority of current stopped instruction
424 * user space instruction is 0, IVG15 is 1, IVTMR is 10.
425 * kgdb_single_step > 0 means in single step mode
427 kgdb_single_step = i + 1;
430 bfin_correct_hw_break();
434 return -1; /* this means that we do not want to exit from the handler */
437 struct kgdb_arch arch_kgdb_ops = {
438 .gdb_bpt_instr = {0xa1},
440 .flags = KGDB_HW_BREAKPOINT|KGDB_THR_PROC_SWAP,
442 .flags = KGDB_HW_BREAKPOINT,
444 .set_hw_breakpoint = bfin_set_hw_break,
445 .remove_hw_breakpoint = bfin_remove_hw_break,
446 .remove_all_hw_break = bfin_remove_all_hw_break,
447 .correct_hw_break = bfin_correct_hw_break,
450 static int hex(char ch)
452 if ((ch >= 'a') && (ch <= 'f'))
453 return ch - 'a' + 10;
454 if ((ch >= '0') && (ch <= '9'))
456 if ((ch >= 'A') && (ch <= 'F'))
457 return ch - 'A' + 10;
461 static int validate_memory_access_address(unsigned long addr, int size)
463 int cpu = raw_smp_processor_id();
467 if (addr >= 0x1000 && (addr + size) <= physical_mem_end)
469 if (addr >= SYSMMR_BASE)
471 if (addr >= ASYNC_BANK0_BASE
472 && addr + size <= ASYNC_BANK3_BASE + ASYNC_BANK3_SIZE)
475 if (addr >= L1_SCRATCH_START
476 && (addr + size <= L1_SCRATCH_START + L1_SCRATCH_LENGTH))
478 #if L1_CODE_LENGTH != 0
479 if (addr >= L1_CODE_START
480 && (addr + size <= L1_CODE_START + L1_CODE_LENGTH))
483 #if L1_DATA_A_LENGTH != 0
484 if (addr >= L1_DATA_A_START
485 && (addr + size <= L1_DATA_A_START + L1_DATA_A_LENGTH))
488 #if L1_DATA_B_LENGTH != 0
489 if (addr >= L1_DATA_B_START
490 && (addr + size <= L1_DATA_B_START + L1_DATA_B_LENGTH))
494 } else if (cpu == 1) {
495 if (addr >= COREB_L1_SCRATCH_START
496 && (addr + size <= COREB_L1_SCRATCH_START
497 + L1_SCRATCH_LENGTH))
499 # if L1_CODE_LENGTH != 0
500 if (addr >= COREB_L1_CODE_START
501 && (addr + size <= COREB_L1_CODE_START + L1_CODE_LENGTH))
504 # if L1_DATA_A_LENGTH != 0
505 if (addr >= COREB_L1_DATA_A_START
506 && (addr + size <= COREB_L1_DATA_A_START + L1_DATA_A_LENGTH))
509 # if L1_DATA_B_LENGTH != 0
510 if (addr >= COREB_L1_DATA_B_START
511 && (addr + size <= COREB_L1_DATA_B_START + L1_DATA_B_LENGTH))
519 && addr + size <= L2_START + L2_LENGTH)
527 * Convert the memory pointed to by mem into hex, placing result in buf.
528 * Return a pointer to the last char put in buf (null). May return an error.
530 int kgdb_mem2hex(char *mem, char *buf, int count)
535 unsigned short mmr16;
537 int cpu = raw_smp_processor_id();
539 if (validate_memory_access_address((unsigned long)mem, count))
543 * We use the upper half of buf as an intermediate buffer for the
544 * raw memory copy. Hex conversion will work against this one.
548 if ((unsigned int)mem >= SYSMMR_BASE) { /*access MMR registers*/
551 if ((unsigned int)mem % 2 == 0) {
552 mmr16 = *(unsigned short *)mem;
553 pch = (unsigned char *)&mmr16;
561 if ((unsigned int)mem % 4 == 0) {
562 mmr32 = *(unsigned long *)mem;
563 pch = (unsigned char *)&mmr32;
575 } else if (cpu == 0 && (unsigned int)mem >= L1_CODE_START &&
576 (unsigned int)(mem + count) <= L1_CODE_START + L1_CODE_LENGTH
578 || cpu == 1 && (unsigned int)mem >= COREB_L1_CODE_START &&
579 (unsigned int)(mem + count) <=
580 COREB_L1_CODE_START + L1_CODE_LENGTH
583 /* access L1 instruction SRAM*/
584 if (dma_memcpy(tmp, mem, count) == NULL)
587 err = probe_kernel_read(tmp, mem, count);
591 buf = pack_hex_byte(buf, *tmp);
603 * Copy the binary array pointed to by buf into mem. Fix $, #, and
604 * 0x7d escaped with 0x7d. Return a pointer to the character after
605 * the last byte written.
607 int kgdb_ebin2mem(char *buf, char *mem, int count)
611 unsigned short *mmr16;
612 unsigned long *mmr32;
615 int cpu = raw_smp_processor_id();
617 tmp_old = tmp_new = buf;
619 while (count-- > 0) {
620 if (*tmp_old == 0x7d)
621 *tmp_new = *(++tmp_old) ^ 0x20;
629 if (validate_memory_access_address((unsigned long)mem, size))
632 if ((unsigned int)mem >= SYSMMR_BASE) { /*access MMR registers*/
635 if ((unsigned int)mem % 2 == 0) {
636 mmr16 = (unsigned short *)buf;
637 *(unsigned short *)mem = *mmr16;
642 if ((unsigned int)mem % 4 == 0) {
643 mmr32 = (unsigned long *)buf;
644 *(unsigned long *)mem = *mmr32;
651 } else if (cpu == 0 && (unsigned int)mem >= L1_CODE_START &&
652 (unsigned int)(mem + count) < L1_CODE_START + L1_CODE_LENGTH
654 || cpu == 1 && (unsigned int)mem >= COREB_L1_CODE_START &&
655 (unsigned int)(mem + count) <=
656 COREB_L1_CODE_START + L1_CODE_LENGTH
659 /* access L1 instruction SRAM */
660 if (dma_memcpy(mem, buf, size) == NULL)
663 err = probe_kernel_write(mem, buf, size);
669 * Convert the hex array pointed to by buf into binary to be placed in mem.
670 * Return a pointer to the character AFTER the last byte written.
671 * May return an error.
673 int kgdb_hex2mem(char *buf, char *mem, int count)
677 unsigned short *mmr16;
678 unsigned long *mmr32;
679 int cpu = raw_smp_processor_id();
681 if (validate_memory_access_address((unsigned long)mem, count))
685 * We use the upper half of buf as an intermediate buffer for the
686 * raw memory that is converted from hex.
688 tmp_raw = buf + count * 2;
690 tmp_hex = tmp_raw - 1;
691 while (tmp_hex >= buf) {
693 *tmp_raw = hex(*tmp_hex--);
694 *tmp_raw |= hex(*tmp_hex--) << 4;
697 if ((unsigned int)mem >= SYSMMR_BASE) { /*access MMR registers*/
700 if ((unsigned int)mem % 2 == 0) {
701 mmr16 = (unsigned short *)tmp_raw;
702 *(unsigned short *)mem = *mmr16;
707 if ((unsigned int)mem % 4 == 0) {
708 mmr32 = (unsigned long *)tmp_raw;
709 *(unsigned long *)mem = *mmr32;
716 } else if (cpu == 0 && (unsigned int)mem >= L1_CODE_START &&
717 (unsigned int)(mem + count) <= L1_CODE_START + L1_CODE_LENGTH
719 || cpu == 1 && (unsigned int)mem >= COREB_L1_CODE_START &&
720 (unsigned int)(mem + count) <=
721 COREB_L1_CODE_START + L1_CODE_LENGTH
724 /* access L1 instruction SRAM */
725 if (dma_memcpy(mem, tmp_raw, count) == NULL)
728 return probe_kernel_write(mem, tmp_raw, count);
732 int kgdb_validate_break_address(unsigned long addr)
734 int cpu = raw_smp_processor_id();
736 if (addr >= 0x1000 && (addr + BREAK_INSTR_SIZE) <= physical_mem_end)
738 if (addr >= ASYNC_BANK0_BASE
739 && addr + BREAK_INSTR_SIZE <= ASYNC_BANK3_BASE + ASYNC_BANK3_BASE)
741 #if L1_CODE_LENGTH != 0
742 if (cpu == 0 && addr >= L1_CODE_START
743 && addr + BREAK_INSTR_SIZE <= L1_CODE_START + L1_CODE_LENGTH)
746 else if (cpu == 1 && addr >= COREB_L1_CODE_START
747 && addr + BREAK_INSTR_SIZE <= COREB_L1_CODE_START + L1_CODE_LENGTH)
753 && addr + BREAK_INSTR_SIZE <= L2_START + L2_LENGTH)
760 int kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr)
763 int cpu = raw_smp_processor_id();
765 if ((cpu == 0 && (unsigned int)addr >= L1_CODE_START
766 && (unsigned int)(addr + BREAK_INSTR_SIZE)
767 < L1_CODE_START + L1_CODE_LENGTH)
769 || (cpu == 1 && (unsigned int)addr >= COREB_L1_CODE_START
770 && (unsigned int)(addr + BREAK_INSTR_SIZE)
771 < COREB_L1_CODE_START + L1_CODE_LENGTH)
774 /* access L1 instruction SRAM */
775 if (dma_memcpy(saved_instr, (void *)addr, BREAK_INSTR_SIZE)
779 if (dma_memcpy((void *)addr, arch_kgdb_ops.gdb_bpt_instr,
780 BREAK_INSTR_SIZE) == NULL)
785 err = probe_kernel_read(saved_instr, (char *)addr,
790 return probe_kernel_write((char *)addr,
791 arch_kgdb_ops.gdb_bpt_instr, BREAK_INSTR_SIZE);
795 int kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle)
797 if ((unsigned int)addr >= L1_CODE_START &&
798 (unsigned int)(addr + BREAK_INSTR_SIZE) <
799 L1_CODE_START + L1_CODE_LENGTH) {
800 /* access L1 instruction SRAM */
801 if (dma_memcpy((void *)addr, bundle, BREAK_INSTR_SIZE) == NULL)
806 return probe_kernel_write((char *)addr,
807 (char *)bundle, BREAK_INSTR_SIZE);
810 int kgdb_arch_init(void)
812 kgdb_single_step = 0;
814 bfin_remove_all_hw_break();
818 void kgdb_arch_exit(void)