main.c

mips架构的bootloader,99左右的版本 但源代码现在没人更新了

	}

brkInstall(1); /* regular */
_go();
}
#endif

/*************************************************************
*  RegVal read_target(type,adr,sz)
*	Read from the target address space
*	All reads from target memory should come through here
*	adr	The address you want to read from
*	sz	The size of the read operation (1, 2, or 4 bytes)
*/
RegVal read_target(type,adr,sz)
Ulong adr;
int sz,type;
{
Ulong v,save,cur;
int reg;
Ushort h0,h1;

reg = adr;
switch (type) {
	case XT_MEM :
#if 0
		if (read_target_mem_ptr && (* read_target_mem_ptr)(adr,sz,&v))
			return(v);
		switch (sz) {
			case 1 : return (*(Uchar *)(adr));
			case 2 : return (*(Ushort *)(adr));
			case 4 : return (*(Ulong *)(adr));
			}
#endif
#ifdef LR64360
	if (adr < (Ulong)M_DMACR) {
		/* special code for reading the IRAM */
		switch (sz) {
		case 1 :
			cur = *((Ulong *)(adr&~3));
			return (Uchar)((cur >> (24 - (adr&3)*8 ) ) &0xff);
		case 2 :
			cur = *((Ulong *)(adr&~3));
			return (Ushort)((cur >> (16 - (adr&3)*8 ) ) &0xffff);
		case 4 :
			save = BIU;
			BIU = (save&~BIU_DS1) | BIU_IS1;
			v = read_Disolated(adr);
			BIU = save;
			return(v);
			}
		}
#endif
	switch (sz) {
		case 1 : return (*(Uchar *)(adr));
		case 2 : return (*(Ushort *)(adr));
		case 4 : 
			adr &= ~1; /* clear the LS bit */
			if (adr&2) {
				h0 = read_target(type,adr,2);
				h1 = read_target(type,adr+2,2);
#ifdef MIPSEB
				return((h0<<16) | h1);
#else
				return((h1<<16) | h0);
#endif
				}
			return (*(Ulong *)(adr));
		}
	case XT_GPR : return Gpr[reg];
	case XT_PC : return pcReg;
	case XT_CP0 : 
		if (reg == C0_CAUSE) return DBGREG[R_CAUSE];
		if (reg == C0_EPC) return DBGREG[R_PC];
		if (reg == C0_SR) return DBGREG[R_STATUS];
		return mfc0(reg);
	case XT_DBX : return mfdbx(reg);
	default : printf("%d: read_target: bad type\n",type);
	}
return(0);
}

/*************************************************************
*  write_target(type,adr,v,sz)
*	write to the target address space
*	All writes to target memory should come through here
*	adr	The address you want to write to
*	v	The value you want to write
*	sz	The size of the write operation (1, 2, or 4 bytes)
*/
write_target(type,adr,v,sz)
Ulong adr;
RegVal v;
int sz,type;
{
Ulong save,cur;
int reg;

reg = adr;
switch (type) {
	case XT_MEM :
#ifdef LR64360
	if (adr < (Ulong)M_DMACR) {
		/* special code for writing the IRAM */
		switch (sz) {
			case 1 : 
				cur = *((Ulong *)(adr&~3));
				cur &= ~((Ulong)0xff << (24 - ((adr&3)*8)) );
				cur |= (v << (24 - ((adr&3)*8)) );
				*((Ulong *)(adr&~3)) = cur;
				return;
			case 2 : 
				cur = *((Ulong *)(adr&~3));
				cur &= ~((Ulong)0xffff << (16 - ((adr&3)*8)) );
				cur |= (v << (16 - ((adr&3)*8)) );
				*((Ulong *)(adr&~3)) = cur;
				return;
			case 4 : 
				save = BIU;
				BIU = (save&~BIU_DS1) | BIU_IS1;
				write_Disolated(adr,v);
				BIU = save;
				return;
			}
		}
#endif
	switch (sz) {
		case 1 : *(Uchar *)adr = v; break;
		case 2 : *(Ushort *)adr = v; break;
		case 4 : 
			if (bptReq(adr,v)) break;
			*(Ulong *)adr = v; 
			break;
		}
		break;
	case XT_GPR : Gpr[reg] = v; break;
	case XT_PC : pcReg = v; break;
	case XT_CP0 : 
		if (reg == C0_SR) DBGREG[R_STATUS] = v;
		else mtc0(reg,v); 
		break;
	case XT_DBX : mtdbx(reg,v); break;
	default : printf("%d: write_target: bad type\n",type);
	}
}

/*************************************************************
*  swlst(lst)
*/
swlst(lst)
int lst;
{

switch (lst) {
	case 1 : curlst = &pmlst; break;
	case 2 : curlst = &clilst; break;
	}
}

/*************************************************************
*  pmexception(epc,cause)
*	An exception has been generated within PMON
*/
pmexception(epc,cause)
unsigned long epc,cause;
{
if (c_exception_ptr) (* c_exception_ptr)();

printf("\nException Epc=%08x Cause=%08x (%s)\n", epc,cause,
	getexcname(cause&CAUSE_EXCMASK));
monmain();
}

/*************************************************************
*  disp_Gprs(n)
*/
disp_Gprs(n)
int n;
{
int i;

if (n==1) {
	printf("    ");
	for (i=0;i<8;i++) printf(" %~8s",regs_sw[i]);
	printf("\n");
	}
printf(" $0-");
for(i = 0; i < 8; i++) printf(" %08x",getGpr(i));

if (n==1) {
	printf("\n    ");
	for (i=8;i<16;i++) printf(" %~8s",regs_sw[i]);
	}
printf("\n $8-");
for(i = 8; i < 16; i++) printf(" %08x",getGpr(i));

if (n==1) {
	printf("\n    ");
	for (i=16;i<24;i++) printf(" %~8s",regs_sw[i]);
	}
printf("\n$16-");
for(i = 16; i < 24; i++) printf(" %08x",getGpr(i));

if (n==1) {
	printf("\n    ");
	for (i=24;i<32;i++) printf(" %~8s",regs_sw[i]);
	}
printf("\n$24-");
for(i = 24; i < 32; i++) printf(" %08x",getGpr(i));
printf("\n");
}


/*************************************************************
*  onesCount(x)
*	return the number of ones set
*/
onesCount(x)
Ulong x;
{
int n,i;

for (i=n=0;i<32;i++) {
	if (x&1) n++;
	x >>= 1;
	}
return(n);
}

/*************************************************************
*  Note: For Processors that have copy-back Dcaches, it's not ok
*  to DCACHEI once the sw is running from kseg0, because the the
*  Dcache will contain info that *must* be copied back to ram for
*  the program to execute correctly after the flush.
*/
Optdesc flush_opts[] = {
	{"","flush caches"},
	{"-i","flush Icache only"},
	{"-d","flush Dcache only"},
	{0}};

flush_cmd(ac,av)
int ac;
char *av[];
{

if (ac == 1) {
	flush_target(ICACHEI);
	flush_target(DCACHE);
	}
else if (strequ(av[1],"-i")) flush_target(ICACHEI);
else if (strequ(av[1],"-d")) flush_target(DCACHE);
}

#if 0 /* not working yet */
/*************************************************************
* This an experimental command that would be used to allow the user to
* explictly set hw data breakpoints. At present this is only available
* via the 'when' command.
*/
Optdesc hdb_opts[] = {
	{"[-r|-w] addr[..addr] [value]","set hardware data breakpoint"},
	{"-r","only break on reads"},
	{"-w","only break on writes"},
	{0}};

hdb_cmd(ac,av)
int ac;
char *av[];
{
int type,cnt,n,i;
Ulong addr1,addr2,value;
char *p,tmp[80];
char *strstr();

if (ac == 1) {
usage:
        printf("usage: hdb [-r|-w] addr[..addr] [value]\n");
        return;
        }

type = 0x30;
for (cnt=0,i=1;i<ac;i++) {
        if (strequ(av[i],"-r")) type = 0x10;
        else if (strequ(av[i],"-w")) type = 0x20;
        else if (cnt==0) {
                if (p=strstr(av[i],"..")) {
                        strncpy(tmp,av[i],p-av[i]);
			if (!get_rsa(&addr1,tmp)) return;
			if (!get_rsa(&addr2,p+2)) return;
                        }
                else {
			if (!get_rsa(&addr1,av[i])) return;
			addr2 = 0;
                        }
                cnt++;
                }
        else if (cnt==1) {
		if (!get_rsa(&value,av[i])) return;
                cnt++;
                }
        else goto usage;
        }

if (cnt == 2) {
	printf("value not currently supported\n");
	return;
	}
setbp_target(-1,type|BPTYPE_DATA,addr1,addr2,value);
}
#endif

/*************************************************************
*/
clrbp_target(n)
int n;  
{

if (verbose) fprintf(dfp,"clrbp_target(%d)\n",n);
if (n < 0 || n >= MAX_BPT) {
        printf("%d: bad bpt number\n",n);
        return(0);
        }
if (brkList[n].type==0) {
        printf("%d: bpt is not set\n",n);
        return(0);
        }
brkList[n].type = 0;
return(1);
}

/*************************************************************
*/
int which_bpt(addr)
Ulong addr;
{
int i;

for (i=0;i<MAX_BPT;i++) {
        if (brkList[i].type==0) continue;
        if (brkList[i].addr == addr) return(i);
        }
return(-1);
}

/*************************************************************
*  int is_bpt(adr)
*/
int is_bpt(adr)
Ulong adr;
{
int i;

for (i=0;i<MAX_BPT;i++) {
	if (brkList[i].type==0) continue;
	if (brkList[i].addr == adr) return(brkList[i].type);
	}
return(0);
}

/*************************************************************
*  brkTypes(n)
*/
brkTypes(n)
int n;
{
int i,j;

for (i=j=0;i<MAX_BPT;i++) {
	if (brkList[i].type == n) j++;
	}
return(j);
}

/*************************************************************
*  int brkDelete(type)
*	returns type: 0=none 1=bpc 2=bda 3=itemp 4=sstep
*/
int brkDelete(type)
Ulong type;
{
int i;

for (i=0;i<MAX_BPT;i++) {
	if (type == brkList[i].type) brkList[i].type = 0;
	}
}

#if 0
/*************************************************************
*  printBrkList()
*/
printBrkList()
{
int i;

for (i=0;i<MAX_BPT;i++) {
	if (brkList[i].type==0) continue;
	printf("brk%d: adr=%08x type=%d\n",i,brkList[i].adr,brkList[i].type);
	}
}
#endif

/*************************************************************
*  load_byte(adr)
*/
load_byte(adr)
Ulong adr;
{
read_target(XT_MEM,adr,1);
}

/*************************************************************
*  store_byte(adr,v)
*/
store_byte(adr,v)
Ulong adr,v;
{
write_target(XT_MEM,adr,v,1);
}

/*************************************************************
*  getCpuType()
*/
getCpuType()
{
if (hostType) return(hostType);
hostType = getHostType();
return(hostType);
}


/*************************************************************
*  setTrcbp(adr,stepover)
*	creates the breakpoints required to perform one step
*	returns 1 on success, 0 on failure.
*	A type4 breakpoint is 'trace'.
*/
setTrcbp(adr,stepover)
Ulong adr;
int stepover;
{
Ulong target,inst;
int sz,dsz;

if (verbose) fprintf(dfp,"setTrcbp adr=%08x stepover=%d\n",adr,stepover);
inst = read_target(XT_MEM,adr,4);
sz = instr_size(adr,inst);
if (is_branch(adr,inst)) {
	target = actual_branch_target_address(adr,inst);
	if (verbose) fprintf(dfp,"inst=%08x target=%08x\n",inst,target);
	if (target == adr) target = adr+((sz==2)?2:8); /* skip self branches */
	if (is_jal(adr,inst) && stepover) {
		dsz = instr_size(adr+4,read_target(XT_MEM,adr+4,4));
		if (setbp_target(-1,BPTYPE_TRACE,adr+4+dsz) < 0) return(0);
		}
#if 1 /* this was for calls to PMON entry-points */
	else if (is_jr(adr,inst) && !is_writeable_target(target)) {
		setbp_target(-1,BPTYPE_TRACE,getGpr(31));
		}
#endif
	else if (setbp_target(-1,BPTYPE_TRACE,target) < 0) return(0);
	}
else if (setbp_target(-1,BPTYPE_TRACE,adr+sz) < 0) return(0); /* trace */
return(1);
}

/*************************************************************
*  is_writeable_target(adr)
*/
is_writeable_target(adr)
unsigned long adr;
{
Uchar x,y;

adr |= K1BASE;
x = read_target(XT_MEM,adr,1);
y = ~x;
write_target(XT_MEM,adr,y,1);
if (read_target(XT_MEM,adr,1) != y) return(0);
write_target(XT_MEM,adr,x,1);
return(1);
}

/*************************************************************
*  bptReq(addr,v)
*       Changes a write_target into a setbp or clrbp
*/
bptReq(addr,v)
Ulong addr,v;
{
int n;

if (!(xvwmode || gdbmode)) return(0);

if ((xvwmode && v == XVWBREAKCODE) ||
    (gdbmode && (v == DBXBREAKCODE || v == GDBBREAKCODE || v == 0xa0d))
    ) setbp_target(-1,BPTYPE_PC,addr);
else if ((n=which_bpt(addr)) != -1) clrbp_target(n);
else return(0);
return(1);
}

Func *setbp_target_ptr;
Func *brkInstall_ptr;
Func *brkRemove_ptr;

/*************************************************************
*  int setbp_target(n,type,addr,addr2,value)
*/
int setbp_target(n,type,addr,addr2,value)
int n,type;
Ulong addr,addr2,value;
{
if (!setbp_target_ptr) return(-1);
if (verbose>1) fprintf(dfp,"setbp_target(%d,%d,%08x,%08x,%08x)\n",
			n,type,addr,addr2,value);
return (* setbp_target_ptr)(n,type,addr,addr2,value);
}

/*************************************************************
*/
int brkInstall(type)
int type;
{
if (!brkInstall_ptr) return(-1);
return (* brkInstall_ptr)(type);
}

/*************************************************************
*/
int brkRemove(epc)
Ulong epc;
{
if (!brkRemove_ptr) return(0);
return (* brkRemove_ptr)(epc);
}


/*************************************************************
*  stubs
*/
niceExit() { /* should never be called */ }

#define outw(a,v)	(*((volatile Ulong *)(a))=(v))
#define LED_BASE	0xbe000020

int ledval[] = {
	(1|2|4|8|0x10|0x20),		/* 0 */
	(2|4),				/* 1 */
	(1|2|0x40|8|0x10),		/* 2 */
	(1|2|4|8|0x40),			/* 3 */
	(2|4|0x40|0x20),		/* 4 */
	(1|4|8|0x40|0x20),		/* 5 */
	(1|4|8|0x10|0x20|0x40),		/* 6 */
	(1|2|4),			/* 7 */
	(1|2|4|8|0x10|0x20|0x40),	/* 8 */
	(1|2|4|8|0x20|0x40),		/* 9 */
	(1|2|4|0x10|0x20|0x40),		/* A */
	(4|8|0x10|0x20|0x40),		/* B */
	(1|8|0x10|0x20),		/* C */
	(2|4|8|0x10|0x40),		/* D */
	(1|8|0x10|0x20|0x40),		/* E */
	(1|0x10|0x20|0x40)		/* F */
	};