gdb-stub.c 24.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 *  arch/mips/kernel/gdb-stub.c
 *
 *  Originally written by Glenn Engel, Lake Stevens Instrument Division
 *
 *  Contributed by HP Systems
 *
 *  Modified for SPARC by Stu Grossman, Cygnus Support.
 *
 *  Modified for Linux/MIPS (and MIPS in general) by Andreas Busse
 *  Send complaints, suggestions etc. to <andy@waldorf-gmbh.de>
 *
 *  Copyright (C) 1995 Andreas Busse
Ralf Bächle's avatar
Ralf Bächle committed
14 15 16
 *
 *  Copyright (C) 2003 MontaVista Software Inc.
 *  Author: Jun Sun, jsun@mvista.com or jsun@junsun.net
Linus Torvalds's avatar
Linus Torvalds committed
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
 */

/*
 *  To enable debugger support, two things need to happen.  One, a
 *  call to set_debug_traps() is necessary in order to allow any breakpoints
 *  or error conditions to be properly intercepted and reported to gdb.
 *  Two, a breakpoint needs to be generated to begin communication.  This
 *  is most easily accomplished by a call to breakpoint().  Breakpoint()
 *  simulates a breakpoint by executing a BREAK instruction.
 *
 *
 *    The following gdb commands are supported:
 *
 * command          function                               Return value
 *
 *    g             return the value of the CPU registers  hex data or ENN
 *    G             set the value of the CPU registers     OK or ENN
 *
 *    mAA..AA,LLLL  Read LLLL bytes at address AA..AA      hex data or ENN
 *    MAA..AA,LLLL: Write LLLL bytes at address AA.AA      OK or ENN
 *
 *    c             Resume at current address              SNN   ( signal NN)
 *    cAA..AA       Continue at address AA..AA             SNN
 *
 *    s             Step one instruction                   SNN
 *    sAA..AA       Step one instruction from AA..AA       SNN
 *
 *    k             kill
 *
 *    ?             What was the last sigval ?             SNN   (signal NN)
 *
 *    bBB..BB	    Set baud rate to BB..BB		   OK or BNN, then sets
 *							   baud rate
 *
 * All commands and responses are sent with a packet which includes a
 * checksum.  A packet consists of
 *
 * $<packet info>#<checksum>.
 *
 * where
 * <packet info> :: <characters representing the command or response>
 * <checksum>    :: < two hex digits computed as modulo 256 sum of <packetinfo>>
 *
 * When a packet is received, it is first acknowledged with either '+' or '-'.
 * '+' indicates a successful transfer.  '-' indicates a failed transfer.
 *
 * Example:
 *
 * Host:                  Reply:
 * $m0,10#2a               +$00010203040506070809101112131415#42
 *
68
 *
Linus Torvalds's avatar
Linus Torvalds committed
69 70 71 72 73 74 75 76 77
 *  ==============
 *  MORE EXAMPLES:
 *  ==============
 *
 *  For reference -- the following are the steps that one
 *  company took (RidgeRun Inc) to get remote gdb debugging
 *  going. In this scenario the host machine was a PC and the
 *  target platform was a Galileo EVB64120A MIPS evaluation
 *  board.
78
 *
Linus Torvalds's avatar
Linus Torvalds committed
79 80 81
 *  Step 1:
 *  First download gdb-5.0.tar.gz from the internet.
 *  and then build/install the package.
82
 *
Linus Torvalds's avatar
Linus Torvalds committed
83 84 85 86 87 88 89 90
 *  Example:
 *    $ tar zxf gdb-5.0.tar.gz
 *    $ cd gdb-5.0
 *    $ ./configure --target=mips-linux-elf
 *    $ make
 *    $ install
 *    $ which mips-linux-elf-gdb
 *    /usr/local/bin/mips-linux-elf-gdb
91
 *
Linus Torvalds's avatar
Linus Torvalds committed
92 93
 *  Step 2:
 *  Configure linux for remote debugging and build it.
94
 *
Linus Torvalds's avatar
Linus Torvalds committed
95 96 97
 *  Example:
 *    $ cd ~/linux
 *    $ make menuconfig <go to "Kernel Hacking" and turn on remote debugging>
98
 *    $ make
99
 *
Linus Torvalds's avatar
Linus Torvalds committed
100 101
 *  Step 3:
 *  Download the kernel to the remote target and start
102
 *  the kernel running. It will promptly halt and wait
Linus Torvalds's avatar
Linus Torvalds committed
103
 *  for the host gdb session to connect. It does this
104 105
 *  since the "Kernel Hacking" option has defined
 *  CONFIG_KGDB which in turn enables your calls
Linus Torvalds's avatar
Linus Torvalds committed
106 107 108
 *  to:
 *     set_debug_traps();
 *     breakpoint();
109
 *
Linus Torvalds's avatar
Linus Torvalds committed
110 111
 *  Step 4:
 *  Start the gdb session on the host.
112
 *
Linus Torvalds's avatar
Linus Torvalds committed
113 114 115 116
 *  Example:
 *    $ mips-linux-elf-gdb vmlinux
 *    (gdb) set remotebaud 115200
 *    (gdb) target remote /dev/ttyS1
117
 *    ...at this point you are connected to
Linus Torvalds's avatar
Linus Torvalds committed
118
 *       the remote target and can use gdb
119
 *       in the normal fasion. Setting
Linus Torvalds's avatar
Linus Torvalds committed
120 121
 *       breakpoints, single stepping,
 *       printing variables, etc.
Linus Torvalds's avatar
Linus Torvalds committed
122
 */
123
#include <linux/config.h>
Linus Torvalds's avatar
Linus Torvalds committed
124 125 126 127 128
#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/mm.h>
Linus Torvalds's avatar
Linus Torvalds committed
129 130
#include <linux/console.h>
#include <linux/init.h>
Ralf Bächle's avatar
Ralf Bächle committed
131 132
#include <linux/smp.h>
#include <linux/spinlock.h>
133 134
#include <linux/slab.h>
#include <linux/reboot.h>
Linus Torvalds's avatar
Linus Torvalds committed
135 136

#include <asm/asm.h>
Andrew Morton's avatar
Andrew Morton committed
137
#include <asm/cacheflush.h>
Linus Torvalds's avatar
Linus Torvalds committed
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
#include <asm/mipsregs.h>
#include <asm/pgtable.h>
#include <asm/system.h>
#include <asm/gdb-stub.h>
#include <asm/inst.h>

/*
 * external low-level support routines
 */

extern int putDebugChar(char c);    /* write a single character      */
extern char getDebugChar(void);     /* read and return a single char */
extern void trap_low(void);

/*
 * breakpoint and test functions
 */
extern void breakpoint(void);
extern void breakinst(void);
Ralf Bächle's avatar
Ralf Bächle committed
157 158
extern void async_breakpoint(void);
extern void async_breakinst(void);
Linus Torvalds's avatar
Linus Torvalds committed
159 160 161 162 163 164 165 166 167 168 169
extern void adel(void);

/*
 * local prototypes
 */

static void getpacket(char *buffer);
static void putpacket(char *buffer);
static int computeSignal(int tt);
static int hex(unsigned char ch);
static int hexToInt(char **ptr, int *intValue);
Ralf Bächle's avatar
Ralf Bächle committed
170
static int hexToLong(char **ptr, long *longValue);
Linus Torvalds's avatar
Linus Torvalds committed
171 172 173
static unsigned char *mem2hex(char *mem, char *buf, int count, int may_fault);
void handle_exception(struct gdb_regs *regs);

Ralf Bächle's avatar
Ralf Bächle committed
174 175
int kgdb_enabled;

Ralf Bächle's avatar
Ralf Bächle committed
176 177 178 179 180 181
/*
 * spin locks for smp case
 */
static spinlock_t kgdb_lock = SPIN_LOCK_UNLOCKED;
static spinlock_t kgdb_cpulock[NR_CPUS] = { [0 ... NR_CPUS-1] = SPIN_LOCK_UNLOCKED};

Linus Torvalds's avatar
Linus Torvalds committed
182 183 184 185 186 187 188 189 190
/*
 * BUFMAX defines the maximum number of characters in inbound/outbound buffers
 * at least NUMREGBYTES*2 are needed for register packets
 */
#define BUFMAX 2048

static char input_buffer[BUFMAX];
static char output_buffer[BUFMAX];
static int initialized;	/* !0 means we've been initialized */
Ralf Bächle's avatar
Ralf Bächle committed
191
static int kgdb_started;
Linus Torvalds's avatar
Linus Torvalds committed
192 193
static const char hexchars[]="0123456789abcdef";

Linus Torvalds's avatar
Linus Torvalds committed
194 195
/* Used to prevent crashes in memory access.  Note that they'll crash anyway if
   we haven't set up fault handlers yet... */
196 197
int kgdb_read_byte(unsigned char *address, unsigned char *dest);
int kgdb_write_byte(unsigned char val, unsigned char *dest);
Linus Torvalds's avatar
Linus Torvalds committed
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

/*
 * Convert ch from a hex digit to an int
 */
static int hex(unsigned char ch)
{
	if (ch >= 'a' && ch <= 'f')
		return ch-'a'+10;
	if (ch >= '0' && ch <= '9')
		return ch-'0';
	if (ch >= 'A' && ch <= 'F')
		return ch-'A'+10;
	return -1;
}

/*
 * scan for the sequence $<data>#<checksum>
 */
static void getpacket(char *buffer)
{
	unsigned char checksum;
	unsigned char xmitcsum;
	int i;
	int count;
	unsigned char ch;

	do {
		/*
		 * wait around for the start character,
		 * ignore all other characters
		 */
		while ((ch = (getDebugChar() & 0x7f)) != '$') ;

		checksum = 0;
		xmitcsum = -1;
		count = 0;
234

Linus Torvalds's avatar
Linus Torvalds committed
235 236 237 238
		/*
		 * now, read until a # or end of buffer is found
		 */
		while (count < BUFMAX) {
Andrew Morton's avatar
Andrew Morton committed
239
			ch = getDebugChar();
Linus Torvalds's avatar
Linus Torvalds committed
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 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
			if (ch == '#')
				break;
			checksum = checksum + ch;
			buffer[count] = ch;
			count = count + 1;
		}

		if (count >= BUFMAX)
			continue;

		buffer[count] = 0;

		if (ch == '#') {
			xmitcsum = hex(getDebugChar() & 0x7f) << 4;
			xmitcsum |= hex(getDebugChar() & 0x7f);

			if (checksum != xmitcsum)
				putDebugChar('-');	/* failed checksum */
			else {
				putDebugChar('+'); /* successful transfer */

				/*
				 * if a sequence char is present,
				 * reply the sequence ID
				 */
				if (buffer[2] == ':') {
					putDebugChar(buffer[0]);
					putDebugChar(buffer[1]);

					/*
					 * remove sequence chars from buffer
					 */
					count = strlen(buffer);
					for (i=3; i <= count; i++)
						buffer[i-3] = buffer[i];
				}
			}
		}
	}
	while (checksum != xmitcsum);
}

/*
 * send the packet in buffer.
 */
static void putpacket(char *buffer)
{
	unsigned char checksum;
	int count;
	unsigned char ch;

	/*
	 * $<packet info>#<checksum>.
	 */

	do {
		putDebugChar('$');
		checksum = 0;
		count = 0;

		while ((ch = buffer[count]) != 0) {
			if (!(putDebugChar(ch)))
				return;
			checksum += ch;
			count += 1;
		}

		putDebugChar('#');
		putDebugChar(hexchars[checksum >> 4]);
		putDebugChar(hexchars[checksum & 0xf]);

	}
	while ((getDebugChar() & 0x7f) != '+');
}


/*
 * Convert the memory pointed to by mem into hex, placing result in buf.
 * Return a pointer to the last char put in buf (null), in case of mem fault,
 * return 0.
Linus Torvalds's avatar
Linus Torvalds committed
320 321
 * may_fault is non-zero if we are reading from arbitrary memory, but is currently
 * not used.
Linus Torvalds's avatar
Linus Torvalds committed
322 323 324 325 326 327
 */
static unsigned char *mem2hex(char *mem, char *buf, int count, int may_fault)
{
	unsigned char ch;

	while (count-- > 0) {
Linus Torvalds's avatar
Linus Torvalds committed
328
		if (kgdb_read_byte(mem++, &ch) != 0)
Linus Torvalds's avatar
Linus Torvalds committed
329 330 331 332 333 334 335 336 337 338 339 340 341
			return 0;
		*buf++ = hexchars[ch >> 4];
		*buf++ = hexchars[ch & 0xf];
	}

	*buf = 0;

	return buf;
}

/*
 * convert the hex array pointed to by buf into binary to be placed in mem
 * return a pointer to the character AFTER the last byte written
Linus Torvalds's avatar
Linus Torvalds committed
342 343
 * may_fault is non-zero if we are reading from arbitrary memory, but is currently
 * not used.
Linus Torvalds's avatar
Linus Torvalds committed
344
 */
Andrew Morton's avatar
Andrew Morton committed
345
static char *hex2mem(char *buf, char *mem, int count, int binary, int may_fault)
Linus Torvalds's avatar
Linus Torvalds committed
346 347 348 349 350 351
{
	int i;
	unsigned char ch;

	for (i=0; i<count; i++)
	{
Andrew Morton's avatar
Andrew Morton committed
352 353 354 355 356 357 358 359 360
		if (binary) {
			ch = *buf++;
			if (ch == 0x7d)
				ch = 0x20 ^ *buf++;
		}
		else {
			ch = hex(*buf++) << 4;
			ch |= hex(*buf++);
		}
Linus Torvalds's avatar
Linus Torvalds committed
361
		if (kgdb_write_byte(ch, mem++) != 0)
Linus Torvalds's avatar
Linus Torvalds committed
362 363 364 365 366 367 368 369 370 371 372
			return 0;
	}

	return mem;
}

/*
 * This table contains the mapping between SPARC hardware trap types, and
 * signals, which are primarily what GDB understands.  It also indicates
 * which hardware traps we need to commandeer when initializing the stub.
 */
Linus Torvalds's avatar
Linus Torvalds committed
373
static struct hard_trap_info {
Linus Torvalds's avatar
Linus Torvalds committed
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390
	unsigned char tt;		/* Trap type code for MIPS R3xxx and R4xxx */
	unsigned char signo;		/* Signal that we map this trap into */
} hard_trap_info[] = {
	{ 6, SIGBUS },			/* instruction bus error */
	{ 7, SIGBUS },			/* data bus error */
	{ 9, SIGTRAP },			/* break */
	{ 10, SIGILL },			/* reserved instruction */
/*	{ 11, SIGILL },		*/	/* CPU unusable */
	{ 12, SIGFPE },			/* overflow */
	{ 13, SIGTRAP },		/* trap */
	{ 14, SIGSEGV },		/* virtual instruction cache coherency */
	{ 15, SIGFPE },			/* floating point exception */
	{ 23, SIGSEGV },		/* watch */
	{ 31, SIGSEGV },		/* virtual data cache coherency */
	{ 0, 0}				/* Must be last */
};

Linus Torvalds's avatar
Linus Torvalds committed
391 392
/* Save the normal trap handlers for user-mode traps. */
void *saved_vectors[32];
Linus Torvalds's avatar
Linus Torvalds committed
393 394 395 396 397 398 399 400 401 402

/*
 * Set up exception handlers for tracing and breakpoints
 */
void set_debug_traps(void)
{
	struct hard_trap_info *ht;
	unsigned long flags;
	unsigned char c;

403
	local_irq_save(flags);
Linus Torvalds's avatar
Linus Torvalds committed
404
	for (ht = hard_trap_info; ht->tt && ht->signo; ht++)
Linus Torvalds's avatar
Linus Torvalds committed
405
		saved_vectors[ht->tt] = set_except_vector(ht->tt, trap_low);
406

Linus Torvalds's avatar
Linus Torvalds committed
407
	putDebugChar('+'); /* 'hello world' */
Linus Torvalds's avatar
Linus Torvalds committed
408 409 410 411 412 413 414 415 416 417 418
	/*
	 * In case GDB is started before us, ack any packets
	 * (presumably "$?#xx") sitting there.
	 */
	while((c = getDebugChar()) != '$');
	while((c = getDebugChar()) != '#');
	c = getDebugChar(); /* eat first csum byte */
	c = getDebugChar(); /* eat second csum byte */
	putDebugChar('+'); /* ack it */

	initialized = 1;
419
	local_irq_restore(flags);
Linus Torvalds's avatar
Linus Torvalds committed
420 421
}

Ralf Bächle's avatar
Ralf Bächle committed
422 423 424 425 426
void restore_debug_traps(void)
{
	struct hard_trap_info *ht;
	unsigned long flags;

Andrew Morton's avatar
Andrew Morton committed
427
	local_irq_save(flags);
Ralf Bächle's avatar
Ralf Bächle committed
428 429
	for (ht = hard_trap_info; ht->tt && ht->signo; ht++)
		set_except_vector(ht->tt, saved_vectors[ht->tt]);
Andrew Morton's avatar
Andrew Morton committed
430
	local_irq_restore(flags);
Ralf Bächle's avatar
Ralf Bächle committed
431 432
}

Linus Torvalds's avatar
Linus Torvalds committed
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457
/*
 * Convert the MIPS hardware trap type code to a Unix signal number.
 */
static int computeSignal(int tt)
{
	struct hard_trap_info *ht;

	for (ht = hard_trap_info; ht->tt && ht->signo; ht++)
		if (ht->tt == tt)
			return ht->signo;

	return SIGHUP;		/* default for things we don't know about */
}

/*
 * While we find nice hex chars, build an int.
 * Return number of chars processed.
 */
static int hexToInt(char **ptr, int *intValue)
{
	int numChars = 0;
	int hexValue;

	*intValue = 0;

Linus Torvalds's avatar
Linus Torvalds committed
458
	while (**ptr) {
Linus Torvalds's avatar
Linus Torvalds committed
459 460 461 462 463 464 465 466 467 468 469 470 471
		hexValue = hex(**ptr);
		if (hexValue < 0)
			break;

		*intValue = (*intValue << 4) | hexValue;
		numChars ++;

		(*ptr)++;
	}

	return (numChars);
}

Ralf Bächle's avatar
Ralf Bächle committed
472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492
static int hexToLong(char **ptr, long *longValue)
{
	int numChars = 0;
	int hexValue;

	*longValue = 0;

	while (**ptr) {
		hexValue = hex(**ptr);
		if (hexValue < 0)
			break;

		*longValue = (*longValue << 4) | hexValue;
		numChars ++;

		(*ptr)++;
	}

	return numChars;
}

Linus Torvalds's avatar
Linus Torvalds committed
493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532

#if 0
/*
 * Print registers (on target console)
 * Used only to debug the stub...
 */
void show_gdbregs(struct gdb_regs * regs)
{
	/*
	 * Saved main processor registers
	 */
	printk("$0 : %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
	       regs->reg0, regs->reg1, regs->reg2, regs->reg3,
               regs->reg4, regs->reg5, regs->reg6, regs->reg7);
	printk("$8 : %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
	       regs->reg8, regs->reg9, regs->reg10, regs->reg11,
               regs->reg12, regs->reg13, regs->reg14, regs->reg15);
	printk("$16: %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
	       regs->reg16, regs->reg17, regs->reg18, regs->reg19,
               regs->reg20, regs->reg21, regs->reg22, regs->reg23);
	printk("$24: %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
	       regs->reg24, regs->reg25, regs->reg26, regs->reg27,
	       regs->reg28, regs->reg29, regs->reg30, regs->reg31);

	/*
	 * Saved cp0 registers
	 */
	printk("epc  : %08lx\nStatus: %08lx\nCause : %08lx\n",
	       regs->cp0_epc, regs->cp0_status, regs->cp0_cause);
}
#endif /* dead code */

/*
 * We single-step by setting breakpoints. When an exception
 * is handled, we need to restore the instructions hoisted
 * when the breakpoints were set.
 *
 * This is where we save the original instructions.
 */
static struct gdb_bp_save {
Ralf Bächle's avatar
Ralf Bächle committed
533 534
	unsigned long addr;
	unsigned int val;
Linus Torvalds's avatar
Linus Torvalds committed
535 536 537 538 539 540 541 542 543 544
} step_bp[2];

#define BP 0x0000000d  /* break opcode */

/*
 * Set breakpoint instructions for single stepping.
 */
static void single_step(struct gdb_regs *regs)
{
	union mips_instruction insn;
Ralf Bächle's avatar
Ralf Bächle committed
545
	unsigned long targ;
Linus Torvalds's avatar
Linus Torvalds committed
546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606
	int is_branch, is_cond, i;

	targ = regs->cp0_epc;
	insn.word = *(unsigned int *)targ;
	is_branch = is_cond = 0;

	switch (insn.i_format.opcode) {
	/*
	 * jr and jalr are in r_format format.
	 */
	case spec_op:
		switch (insn.r_format.func) {
		case jalr_op:
		case jr_op:
			targ = *(&regs->reg0 + insn.r_format.rs);
			is_branch = 1;
			break;
		}
		break;

	/*
	 * This group contains:
	 * bltz_op, bgez_op, bltzl_op, bgezl_op,
	 * bltzal_op, bgezal_op, bltzall_op, bgezall_op.
	 */
	case bcond_op:
		is_branch = is_cond = 1;
		targ += 4 + (insn.i_format.simmediate << 2);
		break;

	/*
	 * These are unconditional and in j_format.
	 */
	case jal_op:
	case j_op:
		is_branch = 1;
		targ += 4;
		targ >>= 28;
		targ <<= 28;
		targ |= (insn.j_format.target << 2);
		break;

	/*
	 * These are conditional.
	 */
	case beq_op:
	case beql_op:
	case bne_op:
	case bnel_op:
	case blez_op:
	case blezl_op:
	case bgtz_op:
	case bgtzl_op:
	case cop0_op:
	case cop1_op:
	case cop2_op:
	case cop1x_op:
		is_branch = is_cond = 1;
		targ += 4 + (insn.i_format.simmediate << 2);
		break;
	}
607

Linus Torvalds's avatar
Linus Torvalds committed
608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626
	if (is_branch) {
		i = 0;
		if (is_cond && targ != (regs->cp0_epc + 8)) {
			step_bp[i].addr = regs->cp0_epc + 8;
			step_bp[i++].val = *(unsigned *)(regs->cp0_epc + 8);
			*(unsigned *)(regs->cp0_epc + 8) = BP;
		}
		step_bp[i].addr = targ;
		step_bp[i].val  = *(unsigned *)targ;
		*(unsigned *)targ = BP;
	} else {
		step_bp[0].addr = regs->cp0_epc + 4;
		step_bp[0].val  = *(unsigned *)(regs->cp0_epc + 4);
		*(unsigned *)(regs->cp0_epc + 4) = BP;
	}
}

/*
 *  If asynchronously interrupted by gdb, then we need to set a breakpoint
627
 *  at the interrupted instruction so that we wind up stopped with a
Linus Torvalds's avatar
Linus Torvalds committed
628 629 630 631
 *  reasonable stack frame.
 */
static struct gdb_bp_save async_bp;

Ralf Bächle's avatar
Ralf Bächle committed
632 633 634 635 636 637 638 639 640
/*
 * Swap the interrupted EPC with our asynchronous breakpoint routine.
 * This is safer than stuffing the breakpoint in-place, since no cache
 * flushes (or resulting smp_call_functions) are required.  The
 * assumption is that only one CPU will be handling asynchronous bp's,
 * and only one can be active at a time.
 */
extern spinlock_t smp_call_lock;
void set_async_breakpoint(unsigned long *epc)
Linus Torvalds's avatar
Linus Torvalds committed
641
{
Ralf Bächle's avatar
Ralf Bächle committed
642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664
	/* skip breaking into userland */
	if ((*epc & 0x80000000) == 0)
		return;

	/* avoid deadlock if someone is make IPC */
	if (spin_is_locked(&smp_call_lock))
		return;

	async_bp.addr = *epc;
	*epc = (unsigned long)async_breakpoint;
}

void kgdb_wait(void *arg)
{
	unsigned flags;
	int cpu = smp_processor_id();

	local_irq_save(flags);

	spin_lock(&kgdb_cpulock[cpu]);
	spin_unlock(&kgdb_cpulock[cpu]);

	local_irq_restore(flags);
Linus Torvalds's avatar
Linus Torvalds committed
665 666 667 668 669 670 671 672 673 674 675 676
}


/*
 * This function does all command processing for interfacing to gdb.  It
 * returns 1 if you should skip the instruction at the trap address, 0
 * otherwise.
 */
void handle_exception (struct gdb_regs *regs)
{
	int trap;			/* Trap type */
	int sigval;
Ralf Bächle's avatar
Ralf Bächle committed
677
	long addr;
Linus Torvalds's avatar
Linus Torvalds committed
678 679 680
	int length;
	char *ptr;
	unsigned long *stack;
Ralf Bächle's avatar
Ralf Bächle committed
681
	int i;
Andrew Morton's avatar
Andrew Morton committed
682
	int bflag = 0;
Ralf Bächle's avatar
Ralf Bächle committed
683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708

	kgdb_started = 1;

	/*
	 * acquire the big kgdb spinlock
	 */
	if (!spin_trylock(&kgdb_lock)) {
		/* 
		 * some other CPU has the lock, we should go back to 
		 * receive the gdb_wait IPC
		 */
		return;
	}

	/*
	 * If we're in async_breakpoint(), restore the real EPC from
	 * the breakpoint.
	 */
	if (regs->cp0_epc == (unsigned long)async_breakinst) {
		regs->cp0_epc = async_bp.addr;
		async_bp.addr = 0;
	}

	/* 
	 * acquire the CPU spinlocks
	 */
Andrew Morton's avatar
Andrew Morton committed
709
	for (i = num_online_cpus()-1; i >= 0; i--)
Ralf Bächle's avatar
Ralf Bächle committed
710 711 712 713 714 715 716
		if (spin_trylock(&kgdb_cpulock[i]) == 0)
			panic("kgdb: couldn't get cpulock %d\n", i);

	/*
	 * force other cpus to enter kgdb
	 */
	smp_call_function(kgdb_wait, NULL, 0, 0);
Linus Torvalds's avatar
Linus Torvalds committed
717 718 719 720

	/*
	 * If we're in breakpoint() increment the PC
	 */
721 722
	trap = (regs->cp0_cause & 0x7c) >> 2;
	if (trap == 9 && regs->cp0_epc == (unsigned long)breakinst)
Linus Torvalds's avatar
Linus Torvalds committed
723 724 725 726 727 728 729 730 731
		regs->cp0_epc += 4;

	/*
	 * If we were single_stepping, restore the opcodes hoisted
	 * for the breakpoint[s].
	 */
	if (step_bp[0].addr) {
		*(unsigned *)step_bp[0].addr = step_bp[0].val;
		step_bp[0].addr = 0;
732

Linus Torvalds's avatar
Linus Torvalds committed
733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759
		if (step_bp[1].addr) {
			*(unsigned *)step_bp[1].addr = step_bp[1].val;
			step_bp[1].addr = 0;
		}
	}

	stack = (long *)regs->reg29;			/* stack ptr */
	sigval = computeSignal(trap);

	/*
	 * reply to host that an exception has occurred
	 */
	ptr = output_buffer;

	/*
	 * Send trap type (converted to signal)
	 */
	*ptr++ = 'T';
	*ptr++ = hexchars[sigval >> 4];
	*ptr++ = hexchars[sigval & 0xf];

	/*
	 * Send Error PC
	 */
	*ptr++ = hexchars[REG_EPC >> 4];
	*ptr++ = hexchars[REG_EPC & 0xf];
	*ptr++ = ':';
Ralf Bächle's avatar
Ralf Bächle committed
760
	ptr = mem2hex((char *)&regs->cp0_epc, ptr, sizeof(long), 0);
Linus Torvalds's avatar
Linus Torvalds committed
761 762 763 764 765 766 767 768
	*ptr++ = ';';

	/*
	 * Send frame pointer
	 */
	*ptr++ = hexchars[REG_FP >> 4];
	*ptr++ = hexchars[REG_FP & 0xf];
	*ptr++ = ':';
Ralf Bächle's avatar
Ralf Bächle committed
769
	ptr = mem2hex((char *)&regs->reg30, ptr, sizeof(long), 0);
Linus Torvalds's avatar
Linus Torvalds committed
770 771 772 773 774 775 776 777
	*ptr++ = ';';

	/*
	 * Send stack pointer
	 */
	*ptr++ = hexchars[REG_SP >> 4];
	*ptr++ = hexchars[REG_SP & 0xf];
	*ptr++ = ':';
Ralf Bächle's avatar
Ralf Bächle committed
778
	ptr = mem2hex((char *)&regs->reg29, ptr, sizeof(long), 0);
Linus Torvalds's avatar
Linus Torvalds committed
779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799
	*ptr++ = ';';

	*ptr++ = 0;
	putpacket(output_buffer);	/* send it off... */

	/*
	 * Wait for input from remote GDB
	 */
	while (1) {
		output_buffer[0] = 0;
		getpacket(input_buffer);

		switch (input_buffer[0])
		{
		case '?':
			output_buffer[0] = 'S';
			output_buffer[1] = hexchars[sigval >> 4];
			output_buffer[2] = hexchars[sigval & 0xf];
			output_buffer[3] = 0;
			break;

Ralf Bächle's avatar
Ralf Bächle committed
800 801 802
		/*
		 * Detach debugger; let CPU run
		 */
803 804
		case 'D':
			putpacket(output_buffer);
Ralf Bächle's avatar
Ralf Bächle committed
805 806
			goto finish_kgdb;
			break;
807

Linus Torvalds's avatar
Linus Torvalds committed
808 809 810 811 812 813 814 815 816
		case 'd':
			/* toggle debug flag */
			break;

		/*
		 * Return the value of the CPU registers
		 */
		case 'g':
			ptr = output_buffer;
Ralf Bächle's avatar
Ralf Bächle committed
817 818 819 820 821 822
			ptr = mem2hex((char *)&regs->reg0, ptr, 32*sizeof(long), 0); /* r0...r31 */
			ptr = mem2hex((char *)&regs->cp0_status, ptr, 6*sizeof(long), 0); /* cp0 */
			ptr = mem2hex((char *)&regs->fpr0, ptr, 32*sizeof(long), 0); /* f0...31 */
			ptr = mem2hex((char *)&regs->cp1_fsr, ptr, 2*sizeof(long), 0); /* cp1 */
			ptr = mem2hex((char *)&regs->frame_ptr, ptr, 2*sizeof(long), 0); /* frp */
			ptr = mem2hex((char *)&regs->cp0_index, ptr, 16*sizeof(long), 0); /* cp0 */
Linus Torvalds's avatar
Linus Torvalds committed
823
			break;
824

Linus Torvalds's avatar
Linus Torvalds committed
825 826 827 828 829 830
		/*
		 * set the value of the CPU registers - return OK
		 */
		case 'G':
		{
			ptr = &input_buffer[1];
Andrew Morton's avatar
Andrew Morton committed
831
			hex2mem(ptr, (char *)&regs->reg0, 32*sizeof(long), 0, 0);
Ralf Bächle's avatar
Ralf Bächle committed
832
			ptr += 32*(2*sizeof(long));
Andrew Morton's avatar
Andrew Morton committed
833
			hex2mem(ptr, (char *)&regs->cp0_status, 6*sizeof(long), 0, 0);
Ralf Bächle's avatar
Ralf Bächle committed
834
			ptr += 6*(2*sizeof(long));
Andrew Morton's avatar
Andrew Morton committed
835
			hex2mem(ptr, (char *)&regs->fpr0, 32*sizeof(long), 0, 0);
Ralf Bächle's avatar
Ralf Bächle committed
836
			ptr += 32*(2*sizeof(long));
Andrew Morton's avatar
Andrew Morton committed
837
			hex2mem(ptr, (char *)&regs->cp1_fsr, 2*sizeof(long), 0, 0);
Ralf Bächle's avatar
Ralf Bächle committed
838
			ptr += 2*(2*sizeof(long));
Andrew Morton's avatar
Andrew Morton committed
839
			hex2mem(ptr, (char *)&regs->frame_ptr, 2*sizeof(long), 0, 0);
Ralf Bächle's avatar
Ralf Bächle committed
840
			ptr += 2*(2*sizeof(long));
Andrew Morton's avatar
Andrew Morton committed
841
			hex2mem(ptr, (char *)&regs->cp0_index, 16*sizeof(long), 0, 0);
Linus Torvalds's avatar
Linus Torvalds committed
842 843 844 845 846 847 848 849 850 851
			strcpy(output_buffer,"OK");
		 }
		break;

		/*
		 * mAA..AA,LLLL  Read LLLL bytes at address AA..AA
		 */
		case 'm':
			ptr = &input_buffer[1];

Ralf Bächle's avatar
Ralf Bächle committed
852
			if (hexToLong(&ptr, &addr)
Linus Torvalds's avatar
Linus Torvalds committed
853 854 855 856 857 858 859 860 861
				&& *ptr++ == ','
				&& hexToInt(&ptr, &length)) {
				if (mem2hex((char *)addr, output_buffer, length, 1))
					break;
				strcpy (output_buffer, "E03");
			} else
				strcpy(output_buffer,"E01");
			break;

Andrew Morton's avatar
Andrew Morton committed
862 863 864 865 866 867 868
		/*
		 * XAA..AA,LLLL: Write LLLL escaped binary bytes at address AA.AA
		 */
		case 'X':
			bflag = 1;
			/* fall through */

Linus Torvalds's avatar
Linus Torvalds committed
869 870 871
		/*
		 * MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK
		 */
872
		case 'M':
Linus Torvalds's avatar
Linus Torvalds committed
873 874
			ptr = &input_buffer[1];

Ralf Bächle's avatar
Ralf Bächle committed
875
			if (hexToLong(&ptr, &addr)
Linus Torvalds's avatar
Linus Torvalds committed
876 877 878
				&& *ptr++ == ','
				&& hexToInt(&ptr, &length)
				&& *ptr++ == ':') {
Andrew Morton's avatar
Andrew Morton committed
879
				if (hex2mem(ptr, (char *)addr, length, bflag, 1))
Linus Torvalds's avatar
Linus Torvalds committed
880 881 882 883 884 885 886 887 888 889 890
					strcpy(output_buffer, "OK");
				else
					strcpy(output_buffer, "E03");
			}
			else
				strcpy(output_buffer, "E02");
			break;

		/*
		 * cAA..AA    Continue at address AA..AA(optional)
		 */
891
		case 'c':
Linus Torvalds's avatar
Linus Torvalds committed
892 893 894
			/* try to read optional parameter, pc unchanged if no parm */

			ptr = &input_buffer[1];
Ralf Bächle's avatar
Ralf Bächle committed
895
			if (hexToLong(&ptr, &addr))
Linus Torvalds's avatar
Linus Torvalds committed
896
				regs->cp0_epc = addr;
Ralf Bächle's avatar
Ralf Bächle committed
897 898
	  
			goto exit_kgdb_exception;
Linus Torvalds's avatar
Linus Torvalds committed
899 900 901
			break;

		/*
902 903
		 * kill the program; let us try to restart the machine
		 * Reset the whole machine.
Linus Torvalds's avatar
Linus Torvalds committed
904
		 */
905
		case 'k':
Linus Torvalds's avatar
Linus Torvalds committed
906
		case 'r':
907
			machine_restart("kgdb restarts machine");
Linus Torvalds's avatar
Linus Torvalds committed
908 909 910 911 912 913 914 915 916 917 918
			break;

		/*
		 * Step to next instruction
		 */
		case 's':
			/*
			 * There is no single step insn in the MIPS ISA, so we
			 * use breakpoints and continue, instead.
			 */
			single_step(regs);
Ralf Bächle's avatar
Ralf Bächle committed
919
			goto exit_kgdb_exception;
Linus Torvalds's avatar
Linus Torvalds committed
920
			/* NOTREACHED */
Ralf Bächle's avatar
Ralf Bächle committed
921
			break;
Linus Torvalds's avatar
Linus Torvalds committed
922 923 924 925 926 927 928

		/*
		 * Set baud rate (bBB)
		 * FIXME: Needs to be written
		 */
		case 'b':
		{
929
#if 0
Linus Torvalds's avatar
Linus Torvalds committed
930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975
			int baudrate;
			extern void set_timer_3();

			ptr = &input_buffer[1];
			if (!hexToInt(&ptr, &baudrate))
			{
				strcpy(output_buffer,"B01");
				break;
			}

			/* Convert baud rate to uart clock divider */

			switch (baudrate)
			{
				case 38400:
					baudrate = 16;
					break;
				case 19200:
					baudrate = 33;
					break;
				case 9600:
					baudrate = 65;
					break;
				default:
					baudrate = 0;
					strcpy(output_buffer,"B02");
					goto x1;
			}

			if (baudrate) {
				putpacket("OK");	/* Ack before changing speed */
				set_timer_3(baudrate); /* Set it */
			}
#endif
		}
		break;

		}			/* switch */

		/*
		 * reply to the request
		 */

		putpacket(output_buffer);

	} /* while */
Ralf Bächle's avatar
Ralf Bächle committed
976 977 978 979 980 981 982 983

	return;

finish_kgdb:
	restore_debug_traps();

exit_kgdb_exception:
	/* release locks so other CPUs can go */
Andrew Morton's avatar
Andrew Morton committed
984
	for (i = num_online_cpus()-1; i >= 0; i--)
Ralf Bächle's avatar
Ralf Bächle committed
985 986 987 988 989
		spin_unlock(&kgdb_cpulock[i]);
	spin_unlock(&kgdb_lock);

	__flush_cache_all();
	return;
Linus Torvalds's avatar
Linus Torvalds committed
990 991 992 993 994 995 996 997 998 999 1000 1001 1002
}

/*
 * This function will generate a breakpoint exception.  It is used at the
 * beginning of a program to sync up with a debugger and can be used
 * otherwise as a quick means to stop program execution and "break" into
 * the debugger.
 */
void breakpoint(void)
{
	if (!initialized)
		return;

1003 1004 1005
	__asm__ __volatile__(
			".globl	breakinst\n\t" 
			".set\tnoreorder\n\t"
Andrew Morton's avatar
Andrew Morton committed
1006
			"nop\n"
1007 1008 1009 1010
			"breakinst:\tbreak\n\t"
			"nop\n\t"
			".set\treorder"
			);
Linus Torvalds's avatar
Linus Torvalds committed
1011 1012
}

Ralf Bächle's avatar
Ralf Bächle committed
1013 1014 1015 1016 1017 1018
/* Nothing but the break; don't pollute any registers */
void async_breakpoint(void)
{
	__asm__ __volatile__(
			".globl	async_breakinst\n\t" 
			".set\tnoreorder\n\t"
Andrew Morton's avatar
Andrew Morton committed
1019
			"nop\n"
Ralf Bächle's avatar
Ralf Bächle committed
1020 1021 1022 1023 1024 1025
			"async_breakinst:\tbreak\n\t"
			"nop\n\t"
			".set\treorder"
			);
}

Linus Torvalds's avatar
Linus Torvalds committed
1026 1027
void adel(void)
{
1028 1029
	__asm__ __volatile__(
			".globl\tadel\n\t"
Ralf Bächle's avatar
Ralf Bächle committed
1030 1031
			"lui\t$8,0x8000\n\t"
			"lw\t$9,1($8)\n\t"
1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046
			);
}

/*
 * malloc is needed by gdb client in "call func()", even a private one
 * will make gdb happy
 */
static void *malloc(size_t size)
{
	return kmalloc(size, GFP_ATOMIC);
}

static void free(void *where)
{
	kfree(where);
Linus Torvalds's avatar
Linus Torvalds committed
1047
}
Linus Torvalds's avatar
Linus Torvalds committed
1048 1049 1050

#ifdef CONFIG_GDB_CONSOLE

1051
void gdb_putsn(const char *str, int l)
Linus Torvalds's avatar
Linus Torvalds committed
1052 1053 1054
{
	char outbuf[18];

Ralf Bächle's avatar
Ralf Bächle committed
1055 1056 1057
	if (!kgdb_started)
		return;

Linus Torvalds's avatar
Linus Torvalds committed
1058 1059 1060 1061 1062 1063
	outbuf[0]='O';

	while(l) {
		int i = (l>8)?8:l;
		mem2hex((char *)str, &outbuf[1], i, 0);
		outbuf[(i*2)+1]=0;
1064
		putpacket(outbuf);
Linus Torvalds's avatar
Linus Torvalds committed
1065 1066 1067 1068 1069 1070 1071
		str += i;
		l -= i;
	}
}

static void gdb_console_write(struct console *con, const char *s, unsigned n)
{
1072
	gdb_putsn(s, n);
Linus Torvalds's avatar
Linus Torvalds committed
1073 1074 1075
}

static struct console gdb_console = {
1076 1077 1078 1079
	.name	= "gdb",
	.write	= gdb_console_write,
	.flags	= CON_PRINTBUFFER,
	.index	= -1
Linus Torvalds's avatar
Linus Torvalds committed
1080 1081
};

Andrew Morton's avatar
Andrew Morton committed
1082
static int __init register_gdb_console(void)
Linus Torvalds's avatar
Linus Torvalds committed
1083 1084
{
	register_console(&gdb_console);
Andrew Morton's avatar
Andrew Morton committed
1085 1086

	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1087
}
1088

Andrew Morton's avatar
Andrew Morton committed
1089 1090
console_initcall(register_gdb_console);

Linus Torvalds's avatar
Linus Torvalds committed
1091
#endif