Subversion Repositories openrisc

/*

 * 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;

}