rdsrec.c

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

return(0);
}

/*************************************************************
*  srecSend(addr,v)
*/
srecSend(addr,v)
Ulong addr;
int v;
{
if (bytecnt >= datasize) {
	gensrec(bytebufadr,bytebuf,bytecnt);
	bytecnt = 0;
	}

if (bytecnt == 0) bytebufadr = addr;
bytebuf[bytecnt++] = v;
}

/*************************************************************
*  gethex(vp,p,n) 
*	convert n hex digits from p to binary, result in vp, 
*	rtn 1 on success 
*/
gethex(vp,p,n)
Ulong *vp;
char *p;
int n;
{
Ulong v;
int digit;

for (v=0;n>0;n--) {
	if (*p==0) return(0);
	v <<= 4;
	if (*p >= '0' && *p <= '9') digit = *p - '0';
	else if (*p >= 'a' && *p <= 'f') digit = *p - 'a' + 10;
	else if (*p >= 'A' && *p <= 'F') digit = *p - 'A' + 10;
	else return(0);
	v |= digit;
	p++;
	}
*vp = v;
return(1);
}

/*************************************************************
*  char *strccat(dst,c)  
*	concatinate char to dst string 
*/
char *strccat(dst,c)
char *dst,c;
{
int len;

if (!dst) return(dst);
len = strlen(dst);
dst[len] = c;
dst[len+1] = 0;
return(dst);
}

/*************************************************************
*  adr2symoff(dest,value,width)
*/
adr2symoff(dest,value,width)
char *dest;
unsigned long value;
int width;
{
SymRec *p;
char *nam,tmp[16];
long offset;

if (!symchn) return(0);
dest[0] = 0;
for (p=symchn;p;p=p->next) {
	if (value >= p->value) break;
	}
if (p == 0) return(0);
else {
	nam = p->name;

	if (width == 0) sprintf(dest,"%s",nam);
	else sprintf(dest,"%*.*s",width,width,nam);

	offset = value-(p->value);
	if (offset == 0) strcat(dest,"       ");
	else {
		sprintf(tmp,"+0x%-4x",offset);
		strcat(dest,tmp);
		}
	}
return(1);
}

/*************************************************************
*  word_swap(vp)
*/
word_swap(vp)
unsigned long *vp;
{
unsigned short v1,v2;

v1 = (*vp)>>16;
byte_swap(&v1);
v2 = (*vp)&0xffff;
byte_swap(&v2);
*vp = (((unsigned long)v2)<<16)+v1;
}

/*************************************************************
*  byte_swap(vp)
*/
byte_swap(vp)
unsigned short *vp;
{

*vp = ((*vp)<<8)+((*vp)>>8);
}

/*************************************************************
*  symrec(p)
*	handle S4 records, i.e., symbols
*/
symrec(p)
char *p;
{
char val;
unsigned long adr;
int len,csum;
char name[LINESZ],*t;

/* 
S4LLAAAAAAAANNNNNNNN,AAAAAAAANNNNNN,AAAAAAAANNNNNNNNNN,CC
LL=length AAAAAAAA=addr NNNN,=name CC=checksum 
*/

p += 2; /* skip past S4 */
if (!gethex(&len,p,2)) return(1);
p += 2; /* skip past length */
for (;len > 2;) {
	if (!gethex(&adr,p,8)) return(2);
	p += 8; /* skip past addr */
	len -= 8;

	t = strchr(p,',');
	if (t == 0) return(2);
	strNcpy(name,p,t-p);
	len -= t-p;

	if (fastmode) {
		txaddr(adr);
		strcat(name,",");
		for (;;) {
			len = strlen(name)+2;
			if ((len&3) == 0) break;
			strcat(name,"X");
			}
		if (blksz+len >= BLKSIZE) {
			putc('\n',ofp);
			blksz = 0;
			}
		fprintf(ofp,"/S%s",name);
		blksz += len;
		}
	else if (nodisasm) fprintf(ofp,"%08lx: %s\n",adr,name);
	else {
		if (!newsym(name,adr)) return(3);
		}

	p = t+1;
	}
if (!gethex(&csum,p,2)) return(4);
/* csum neither generated nor checked */
return(0);
}

/*************************************************************
*  newsym(name,value)
*/
newsym(name,value)
char *name;
unsigned long value;
{
SymRec *p,*q,*pr;

p = (SymRec *)malloc(sizeof(SymRec));
p->name = malloc(strlen(name)+1);
strcpy(p->name,name);
p->next = 0;
p->value = value;

/* empty chain */
if (!symchn) {
	symchn = p;
	return(1);
	}

/* insert before first item? */
if (symchn->value < p->value) {
	p->next = symchn;
	symchn = p;
	return(1);
	}

/* one item on chain */
if (symchn->next == 0) {
	symchn->next = p;
	return(1);
	}
		
/* n items on chain */
for (q=symchn->next,pr=symchn;q;q=q->next) {
	if (q->value < p->value) break;
	pr = q;
	}
p->next = pr->next;
pr->next = p;
return(1);
}

/*************************************************************
*  setTiny(Ulong adr,int *mode)
*/
setTiny(adr,mode)
Ulong adr;
int *mode;
{
SymRec *p;

for (p=symchn;p;p=p->next) {
	if (adr == (p->value&~1)) {
		if (p->value&1) *mode = 1;
		else *mode = 0;
		return;
		}
	}
}

/*************************************************************
*  prsyms()
*/
prsyms()
{
SymRec *p;

for (p=symchn;p;p=p->next) {
	fprintf(ofp,"%08lx %s\n",p->value,p->name);
	}
}


/*************************************************************
*  fastSend(val)
*	send one byte
*/
fastSend(val)
int val;
{

bdat <<= 8;
bdat |= val;
bdat_cnt++;
if (bdat_cnt < 3) return;

if (bdat == 0) { /* compress if the data is zero */
	bdat_cnt = 0;
	zcnt++;
	if (zcnt < 4096) return;
	zcnt--;
	}
if (zcnt > 0) { /* send a special record for zeros */
	send12(ZEROS,zcnt);
	if (DEBUG) fprintf(ofp," %03x\n",zcnt);
	zcnt = 0;
	}
send24(bdat); /* send the data */
if (DEBUG) fprintf(ofp," %06x\n",bdat);
bdat = 0;
bdat_cnt = 0;
}

/*************************************************************
*  fastFlush()
*/
fastFlush()
{
int shamt;

if (zcnt > 0) { /* make sure we didn't end with zeros outstanding */
	send12(ZEROS,zcnt);
	if (DEBUG) fprintf(ofp," %03x\n",zcnt);
	zcnt = 0;
	}

if (bdat_cnt > 0) {
	shamt = (bdat_cnt-1)*8;
	for (;bdat_cnt > 0;shamt -= 8,bdat_cnt--) {
		send12(BYTE,(bdat>>shamt)&0xff);
		if (DEBUG) fprintf(ofp," %02x\n",(bdat>>shamt)&0xff);
		}
	bdat = 0;
	}

if (DEBUG) fprintf(ofp,"\n");
}

/*************************************************************
*  send12(type,val)
*/
send12(type,val)
char *type;
int val;
{
char adat[4];

val &= 0xfff;
chksum += val;
adat[0] = type[0];
adat[1] = type[1];
adat[2] = b2a(val>>6);
adat[3] = b2a(val);
send(adat,4);
}

/*************************************************************
*  send24(val)
*/
send24(val)
unsigned long val;
{
char adat[4];
int i;

val &= 0xffffff;
chksum += val>>12;
chksum += val&0xfff;
for (i=3;i>=0;i--) {
	adat[i] = b2a(val);
	val>>=6;
	}
send(adat,4);
}

/*************************************************************
*  send(p,n)
*/
send(p,n)
char *p;
int n;
{

if (blksz+n >= BLKSIZE) {
	putc('\n',ofp);
	blksz = 0;
	}
fwrite(p,sizeof(p[0]),n,ofp);
blksz += n;
}

/*************************************************************
*  txchksum()
*/
txchksum()
{

send12(CHKSUM,chksum);
chksum = 0;
}

/*************************************************************
*  txeof(addr)
*/
txeof(addr)
unsigned long addr;
{

fastFlush();
if (cflag) txchksum();
txaddr(addr);
send12(END,0);
putc('\n',ofp);
blksz = 0;
}

/*************************************************************
*  txaddr(addr)
*/
txaddr(addr)
unsigned long addr;
{

fastFlush();
if (blksz+8 >= BLKSIZE) {
	putc('\n',ofp);
	blksz = 0;
	}

send12(ADDR,addr>>24);
send24(addr);
if (DEBUG) fprintf(ofp," %08lx ",addr);
}

/*************************************************************
*  b2a(c)
*/
b2a(c)
int c;
{
/* translate binary to base64 (tx form) 
0..25		A-Z
26..51		a-z
52..61		0-9
62
63
*/

c &= 0x3f;
if (c <= 25)  return('A'+c);
if (c <= 51) return('a'+c-26);
if (c <= 61) return('0'+c-52); 
if (c == 62) return(exta);
if (c == 63) return(extb);
fprintf(ofp,"b2a: bad input value\n");
return(0);
}

/*************************************************************
*  gensrec(addr,buf,n)
*/
gensrec(addr,buf,n)
unsigned long addr;
unsigned char *buf;
int n;
{
int j,chksum;
unsigned char byte;

chksum = 0;
printf("S%1d%02X",ADDRSIZE-1,n+ADDRSIZE+1);
chksum += n+ADDRSIZE+1;
for (j=ADDRSIZE-1;j>=0;j--) {
	byte = (addr>>(j*8)) & 0xff;
	printf("%02X",byte);
	chksum += byte;
	}
for (j=0;j<n;j++) {
	printf("%02X",buf[j]);
	chksum += buf[j];
	}
printf("%02X\n",(~chksum)&0xff);
addr += n;
}

/*************************************************************
*  putw(pVal,fp)
*/
putw(pVal,fp)
unsigned long *pVal;
FILE *fp;
{
int i,c;
unsigned long val;

val = *pVal;
for (i=3;i>=0;i--) {
	c = (val>>(i*8))&0xff;
	putc(c,fp);
	}
}

/*************************************************************
*  col2only(str)
*	resulting string will only contain column 2.
*/
col2only(str)
char *str;
{
char *p;

for (p=str;isspace(*p);p++) ;
/* start of 1st field */
for (;!isspace(*p);p++) ;
/* end of 1st field */
for (;isspace(*p);p++) ;
/* start of 2nd field */
strcpy(str,p); /* delete prefix */
for (p=str;!isspace(*p);p++) ;
/* end of 2nd field */
*p = 0;
}


/*************************************************************
*  do_erec(entry)
*/
do_erec(entry)
unsigned long entry;
{
int j,chksum;
unsigned char byte;

chksum = 0;
printf("S%1d%02X",7,5);
chksum += 5;
for (j=ADDRSIZE-1;j>=0;j--) {
	byte = (entry>>(j*8)) & 0xff;
	printf("%02X",byte);
	chksum += byte;
	}
printf("%02X\n",(~chksum)&0xff);
}

/* stubs */
getGpr() {return(0);} 
write_target() {}
read_target() {return(0);}
flushDcache() {}
matchenv() {}
flush_target() {}