srloader.c

ADAM2 sources (modified by Oleg)

              return(SRLerrorout("Srecord Not valid for MIPS",scp));
              break;
    default:
              break;
    }

  return(TRUE);
  }

bit32u srloader(int argc,char *argv[])
  {
  int rlen,sts,gopc,lindex;
  FFS_FILE *fp;
  
  s1s2s3_total = 0;
  lindex=0;
  if(argc==0)
    {
    sys_printf("\nError: No parameters!");
    return(0);
    }
  fp = fopen(argv[0],"r");
  if (fp==NULL)
    {
    sys_printf("\nError: Opening input file.");
    return(0);
    }
  initreadline();
  inputline=0;
  sts=TRUE;
  while((sts)&&((rlen=readline(fp,buff,sizeof buff))!=-1))
    {
    inputline++;
    sts&=doline(buff,&gopc);
    if ((inputline%32)==0)
      {
      sys_printf("%c%c",iline[lindex++],8);
      lindex&=3;
      }
    }
  fclose(fp);
  if(!sts) 
    gopc=0;
  /*sys_printf("PC: %08x\n",gopc);*/
  return(gopc);
  }
#endif /* BATCH_SREC_SUPPORT */

int getf32(bit32u address, bit32u *dat, int fileflag)
{
	char sdat[4];
	int n = 0;
	int i;
	bit32u uitmp;

	if (fileflag == TRUE)
	{
#ifdef FFS_SUPPORT
		FFS_FILE *fp = (FFS_FILE *)address;
		n=fread(sdat,1,4,fp);
#endif
	}
	else
	{
		bit8 *srcptr;
		n = 0;

		srcptr = (bit8 *)address;
		while (n < 4)
			sdat[n++] = *srcptr++;
	}
	
	if (n!=4) 
		return(n);
	for(uitmp=0,i=0;i<4;i++)
		uitmp|=(((bit32u)sdat[i])&0x0ff)<<(i*8);
	*dat=uitmp;
	return(n);  
}

#ifdef FFS_SUPPORT
bit32u bleout(int eval,FFS_FILE *fp)
{
	char *cp;

	cp=UnknownError;
	if (fp) 
		fclose(fp);
	switch(eval)
    {
		case INVALID_FORMAT: 
			cp=InvalidFormat;
            break;

		case WRONG_ENDIAN:   
			cp=WrongEndian;
            break;

		case BAD_CHECKSUM:   
			cp=BadChecksum;
            break;
    }
	sys_printf("BIN Loader: %s\n",cp);
	return(0);
}

bit32u binloader(int argc,char *argv[])
{
	FFS_FILE *fp;
	bit32u len,adr,wlen,rlen,tag,newchecksum,pcadr,chksum;
	int i,done,lindex,lloop;
	char *cp;
	char *dcp;
  
	pcadr=0;
	lloop=0;
	lindex=0;

	fp=fopen(argv[0],"rb");
	if (!fp)
    {
		sys_printf("Error opening file %s!\n",argv[0]);
		return(0);
    }
	if (getf32((bit32u)fp,&tag,TRUE)!=4)
		return(bleout(INVALID_FORMAT,fp));
	if (tag!=TAG_WANTED)
		return(bleout(WRONG_ENDIAN,fp));
	done=FALSE;
	do
    {
		if (getf32((bit32u)fp,&len,TRUE)!=4)
			return(bleout(INVALID_FORMAT,fp));
		newchecksum=len;
		if (getf32((bit32u)fp,&adr,TRUE)!=4)
			return(bleout(INVALID_FORMAT,fp));
		newchecksum+=adr;
		dcp=(char *)(adr);
		if (len==0)
		{
			pcadr=adr;
			done=TRUE;
		}
		else
		{
			while(len)
			{
				if (((lloop++)%4)==0)
				{
					sys_printf("%c%c",iline[lindex++],8);
					lindex&=3;
				}
				wlen=MIN(sizeof buffer,len);
				rlen=fread(buffer,1,wlen,fp);
				if (wlen!=rlen)
					return(bleout(INVALID_FORMAT,fp));
				for(i=0,cp=buffer;i<rlen;i++,cp++,dcp++)
				{
					newchecksum+=((bit32u)*cp)&0x0ff;
					*dcp=*cp;
				}
				len-=rlen;
			}
		}
		if (getf32((bit32u)fp,&chksum,TRUE)!=4)
			return(bleout(INVALID_FORMAT,fp));
		newchecksum+=chksum;
		if (newchecksum)
			return(bleout(BAD_CHECKSUM,fp));
	}while(!done);

	fclose(fp);
	/*sys_printf("PC: %08x\n",pcadr);*/
	return(pcadr);
}

bit32u progloader(int argc, char *argv[])
{
	char ftype[2];
	FFS_FILE *FilePtr;
	int len;
	bit32u gopc;

	FilePtr=fopen(argv[0],"r");  /* Is it executable? "x" */

	if (!FilePtr)
	{
		return(0);
    }

	len=fread(&ftype,1,1,FilePtr);
	fclose(FilePtr);  

	if (len!=1)
    {
		return(0);
    }

	switch(ftype[0])
    {
		case 'B': 
			gopc=binloader(argc,argv);
            break;

#ifdef BATCH_SREC_SUPPORT
    	case 'S': 
			gopc=srloader(argc,argv);
            break;
    	case '#': 
			batch(argv[0]);
            return(0);
            break;
#endif /* BATCH_SREC_SUPPORT */
			
		default:  
            return(0);
            break;
    }
	FlushICache();
	return(gopc);
}
#endif /* FFS_SUPPORT */

bit32u imageloader(bit32u address)
{
	bit32u len,adr,wlen,tag,newchecksum,pcadr,chksum;
	int i,done,lindex,lloop;
	char *cp;
	char *dcp;
  
	pcadr=0;
	lloop=0;
	lindex=0;

	address &= 0x1fffffff;
	address |= 0xa0000000;

	if (getf32(address, &tag, FALSE) !=4 )
	{
		sys_printf("%s\n", InvalidFormat);
		return(0);
	}

	if (tag != TAG_WANTED)
	{
		sys_printf("%s\n", WrongEndian);
		return(0);
	}

	done=FALSE;
	address += 4;

	do
    {
		if (getf32(address,&len,FALSE)!=4)
		{
			sys_printf("%s\n", UnknownError);
			return(0);
		}
	
		newchecksum=len;		
		address += 4;	
		
		if (getf32(address,&adr,FALSE)!=4)
		{
			sys_printf("%s\n", UnknownError);
			return(0);
		}

		newchecksum+=adr;
		address += 4;

		/*sys_printf("addr = %x, len = %x\n", adr, len);*/

		dcp=(char *)(adr);
		if (len==0)
		{
			pcadr=adr;
			done=TRUE;
		}
		else
		{
			while(len)
			{
				if (((lloop++)%4)==0)
				{
					sys_printf("%c%c",iline[lindex++],8);
					lindex&=3;
				}
				wlen = MIN((sizeof(buffer)), len);
				sys_memcpy((void *)buffer, (void *)address, wlen);
				
				for(i=0,cp=buffer;i<wlen;i++,cp++,dcp++)
				{
					newchecksum+=((bit32u)*cp)&0x0ff;
					*dcp=*cp;
				}
				len-=wlen;
				address += wlen;
			}
		}
		if (getf32(address, &chksum, FALSE) !=4 )
		{
			sys_printf("%s\n", BadChecksum);
			return(0);
		}
		address += 4;

		newchecksum+=chksum;
		if (newchecksum)
		{
			sys_printf("%s\n", BadChecksum);
			return(0);
		}

    }while(!done);

	/*sys_printf("PC: %08x\n",pcadr);*/
	FlushICache();
	return(pcadr);
}