Subversion Repositories openrisc_2011-10-31

 
/*
 * Simplyfied version of original bin2boot
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
 
 
static unsigned char buf[512];
 
static void usage(void)
{
  printf("usage: bin2boot [-h][-v] <outFile> <headerAddr> \n");
  printf("<imFile1> <imAddr1> <imSize1> [<imFile2> <imAddr2> <imSize2>]\n");
  printf("this function makes image bootable by netboot\n");
  printf("from one or two binary images\n");
  printf("-h         - prints this message\n");
  printf("-v         - verbose output\n");
  printf("outFile    - output file\n");
  printf("headerAddr - address to place header in memory\n");
  printf("             it should be below or equal 0x97e00\n");
  printf("imFile1    - first image\n");
  printf("imAddr1    - its start address, image has to be placed whole\n");
  printf("             below 0x98000 and should not overlap with header\n");
  printf("imSize1    - actual size of compressed image, 0 for uncompressed\n");
  printf("imFile2    - second image\n");
  printf("imAddr2    - its start address\n");
  printf("imSize2    - actual size of compressed image, 0 for uncompressed\n");
 
  return;
}
 
 
int main(int argc, char* argv[])
{
  int      c, verbose;
  extern   int optind;
  FILE     *ofp, *ifp;
  unsigned long headerAddr, addr1, addr2;
  int      size1, size2, len1, len2, len, imageCnt, cnt;
  char     *ofile, *ifile, *end;
 
  verbose = 0;
 
  /* parse command line options */
  while ((c = getopt(argc, argv, "hv")) >= 0)
    {
      switch (c)
	{
	case 'v':
	  verbose = 1;
	  break;
	case 'h':
	  usage();
	  return 0;
	default:
	  usage();
	  return 1;
	}
    }
 
  if((argc - optind) != 8 && (argc - optind) != 5)
    {
      usage();
      return 1;
    }
 
  ofile = argv[optind];
  ofp   = fopen(ofile, "wb");
  if(ofp == NULL)
    {
      fprintf(stderr, "unable to open file %s\n", ofile);
      return 1;
    }
 
  /* 
   * Layout is very simple first 512 is header shared by all 
   * images, then images at 512 bytes border
   */
 
  /* Fill buffer with 0's */
  memset(buf, 0, sizeof(buf));
 
  fwrite(buf, 1, sizeof(buf), ofp);
 
  optind++;
  headerAddr = strtoul(argv[optind], &end, 0);
  if(end == argv[optind])
    {
      fprintf(stderr, "bad headerAddr %s\n", argv[optind]);
      fclose(ofp);
      return 1;
    }
 
  if(headerAddr > 0x97e00)
    {
      fprintf(stderr, "headerAddr is too high 0x%08lx\n", headerAddr);
      fclose(ofp);
      return 1;
    }
 
  /* Copy the first image */
  optind++;
  ifile = argv[optind];
  ifp   = fopen(ifile,"rb");
  if(ifp == NULL)
    {
      fprintf(stderr, "unable to open output file %s\n", ifile);
      fclose(ofp);
      return 1;
    }
 
  optind++;
  addr1 = strtoul(argv[optind], &end, 0);
  if(end == argv[optind])
    {
      fprintf(stderr, "bad image address %s\n", argv[optind]);
      fclose(ofp);
      return 1;
    }
 
  optind++;
  size1 = strtoul(argv[optind], &end, 0);
  if(end == argv[optind])
    {
      fprintf(stderr, "bad image size %s\n", argv[optind]);
      fclose(ofp);
      return 1;
    }
 
 
  /* Copy first image out and remember its length */
  cnt  = 0;
  for(;;)
    {
      len = fread(buf, 1, sizeof(buf), ifp);
 
      if(len != 0)
	{
	  fwrite(buf, 1, len, ofp);
	  cnt += sizeof(buf);
 
          if(len != sizeof(buf))
	    {
	      memset(buf, 0, sizeof(buf) - len);
	      fwrite(buf, 1, sizeof(buf) - len, ofp);
	      break;
	    }
 
	}
      else
	{
	  break;
	}
    }
 
  fclose(ifp);
 
  len1 = cnt;
 
  if(size1 == 0)
    {
      size1 = cnt;
    }
  else
    {
      memset(buf, 0, sizeof(buf));
 
      while(cnt < size1)
	{
	  fwrite(buf, 1, sizeof(buf), ofp);
	  cnt += sizeof(buf);
	}
 
      size1 = cnt;
    }
 
 
  /* Let us check agains overlapping */
  if(!(addr1 >= (headerAddr + sizeof(buf)) || (headerAddr >= addr1+size1)))
    {
      /* Areas overlapped */
      printf("area overlapping: \n");
      printf("header address      0x%08lx, its memory size 0x%08x\n", 
	     headerAddr, sizeof(buf));
      printf("first image address 0x%08lx, its memory size 0x%08x\n",
	     addr1, size1);
 
      fclose(ofp);
      return 1;
    }
 
  if((addr1 + size1) > 0x98000)
    {
      fprintf(stderr, "imAddr1 is too high 0x%08lx\n", addr1);
      fclose(ofp);
      return 1;
    }
 
 
  if(optind == (argc - 1))
    {
      imageCnt = 1;
      goto writeHeader;
    }
 
  imageCnt = 2;
 
  /* Copy Second Image */
  optind++;
  ifile = argv[optind];
  ifp   = fopen(ifile,"rb");
  if(ifp == NULL)
    {
      fprintf(stderr, "unable to open output file %s\n", ifile);
      fclose(ofp);
      return 1;
    }
 
  optind++;
  addr2 = strtoul(argv[optind], &end, 0);
  if(end == argv[optind])
    {
      fprintf(stderr, "bad image address %s\n", argv[optind]);
      fclose(ofp);
      return 1;
    }
 
  optind++;
  size2 = strtoul(argv[optind], &end, 0);
  if(end == argv[optind])
    {
      fprintf(stderr, "bad image size %s\n", argv[optind]);
      fclose(ofp);
      return 1;
    }
 
  /* Copy second image out and remember its length */
  cnt  = 0;
  for(;;)
    {
      len = fread(buf, 1, sizeof(buf), ifp);
 
      if(len != 0)
	{
	  fwrite(buf, len, 1, ofp);
	  cnt  += sizeof(buf);
 
	  if(len != sizeof(buf))
	    {
	      memset(buf, 0, sizeof(buf) - len);
	      fwrite(buf, 1, sizeof(buf) - len, ofp);
	      break;
	    }
	}
      else
	{
	  break;
	}
    }
 
  fclose(ifp);
 
  len2 = cnt;
 
  if(size2 == 0)
    {
      size2 = cnt;
    }
  else
    {
      memset(buf, 0, sizeof(buf));
 
      while(cnt < size2)
	{
	  fwrite(buf, 1, sizeof(buf), ofp);
	  cnt += sizeof(buf);
	}
 
      size2 = cnt;
    }
 
  /* Let us check against overlapping */
  if(!((addr2 >= (addr1 + size1) && addr2 >= (headerAddr + sizeof(buf))) ||
       (addr2 < addr1 && addr2 < headerAddr) ||
       (addr1 > headerAddr && addr2 > (headerAddr + sizeof(buf)) &&
	(addr2 + size2) <= addr1) ||
       (addr1 < headerAddr && addr2 > (addr1 + size1) && 
	(addr2 + size2) <= headerAddr)))
 
    {
      /* Areas overlapped */
      printf("area overlapping: \n");
      printf("header address       0x%08lx, its memory size 0x%08x\n", 
	     headerAddr, sizeof(buf));
      printf("first  image address 0x%08lx, its memory size 0x%08x\n",
	     addr1, size1);
      printf("second image address 0x%08lx, its memory size 0x%08x\n",
	     addr2, size2);
 
      fclose(ofp);
      return 1;
    }
 
writeHeader:
 
  /* We know everything so it is time to write buffer */
  memset(buf, 0, 0x30);
 
  buf[0x0]  = 0x36;
  buf[0x1]  = 0x13;
  buf[0x2]  = 0x03;
  buf[0x3]  = 0x1b;
 
  buf[0x4]  = 4;
 
  /* Header address in ds:bx format */
  buf[0x8]  = headerAddr & 0xf;
  buf[0x9]  = 0;
  buf[0xa]  = (headerAddr >> 4) & 0xff;
  buf[0xb]  = (headerAddr >> 12) & 0xff;
 
  /* 
   * Execute address in cs:ip format, which addr1 
   */
  buf[0xc] = addr1 & 0xf;
  buf[0xd] = 0;
  buf[0xe] = (addr1 >> 4) & 0xff;
  buf[0xf] = (addr1 >> 12) & 0xff;
 
  /* Flags, tags and lengths */
  buf[0x10] = 4;
 
  if(imageCnt == 1)
    {
      buf[0x13] = 4;
    }
 
  /* Load address */
  buf[0x14] = addr1 & 0xff;
  buf[0x15] = (addr1 >> 8) & 0xff;
  buf[0x16] = (addr1 >> 16) & 0xff;
  buf[0x17] = (addr1 >> 24) & 0xff;
 
  /* Image Length */
  buf[0x18] = len1 & 0xff;
  buf[0x19] = (len1 >> 8) & 0xff;
  buf[0x1a] = (len1 >> 16) & 0xff;
  buf[0x1b] = (len1 >> 24) & 0xff;
 
  /* Memory Size */
  buf[0x1c] = size1 & 0xff;
  buf[0x1d] = (size1 >> 8) & 0xff;
  buf[0x1e] = (size1 >> 16) & 0xff;
  buf[0x1f] = (size1 >> 24) & 0xff;
 
  if(imageCnt != 1)
    {
 
      /* Flags, tags and lengths */
      buf[0x20] = 4;
 
      buf[0x23] = 4;
 
 
      /* Load address */
      buf[0x24] = addr2 & 0xff;
      buf[0x25] = (addr2 >> 8) & 0xff;
      buf[0x26] = (addr2 >> 16) & 0xff;
      buf[0x27] = (addr2 >> 24) & 0xff;
 
      /* Image Length */
      buf[0x28] = len2 & 0xff;
      buf[0x29] = (len2 >> 8) & 0xff;
      buf[0x2a] = (len2 >> 16) & 0xff;
      buf[0x2b] = (len2 >> 24) & 0xff;
 
      /* Memory Size */
      buf[0x2c] = size2 & 0xff;
      buf[0x2d] = (size2 >> 8) & 0xff;
      buf[0x2e] = (size2 >> 16) & 0xff;
      buf[0x2f] = (size2 >> 24) & 0xff;
    }
 
  rewind(ofp);
 
  fwrite(buf, 1, 0x30, ofp);
 
  fclose(ofp);
 
  if(verbose)
    {
      printf("header address       0x%08lx, its memory size 0x%08x\n", 
	     headerAddr, sizeof(buf));
      printf("first  image address 0x%08lx, its memory size 0x%08x\n",
	     addr1, size1);
      printf("second image address 0x%08lx, its memory size 0x%08x\n",
	     addr2, size2);
    }
 
  return 0;
}