Subversion Repositories or1k

/* Program to load an image into the SPARClite monitor board

   Copyright 1993, 1994, 1995 Free Software Foundation, Inc.

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

/* Call with:

   aload PROG TTY

ie: aload hello /dev/ttya

*/

#include <stdio.h>

#include "ansidecl.h"

#ifdef ANSI_PROTOTYPES

#include <stdarg.h>

#else

#include <varargs.h>

#endif

#include "libiberty.h"

#include "bfd.h"

#include <errno.h>

#include <unistd.h>

#include <fcntl.h>

#ifndef HAVE_TERMIOS

you lose

#endif

#if defined(HAVE_TERMIOS)

#include <termios.h>

#elif defined(HAVE_TERMIO)

#include <termio.h>

#elif defined(HAVE_SGTTY)

#include <sgtty.h>

#endif

#define min(A, B) (((A) < (B)) ? (A) : (B))

/* Where the code goes by default. */

#ifndef LOAD_ADDRESS

#define LOAD_ADDRESS 0x40000000

#endif

int quiet = 0;

static void

usage ()

{

  fprintf (stderr, "usage: aload [-q] file device\n");

  exit (1);

}

static void

#ifdef ANSI_PROTOTYPES

sys_error (char *msg, ...)

#else

sys_error (va_alist)

     va_dcl

#endif

{

  int e = errno;

  va_list args;

#ifdef ANSI_PROTOTYPES

  va_start (args, msg);

#else

  va_start (args);

#endif

#ifdef ANSI_PROTOTYPES

  vfprintf (stderr, msg, args);

#else

  {

    char *msg1;

    msg1 = va_arg (args, char *);

    vfprintf (stderr, msg1, args);

  }

#endif

  va_end (args);

  fprintf (stderr, ": %s\n", strerror(e));

  exit (1);

}

static void

#ifdef ANSI_PROTOTYPES

error (char *msg, ...)

#else

error (va_alist)

     va_dcl

#endif

{

  va_list args;

#ifdef ANSI_PROTOTYPES

  va_start (args, msg);

#else

  va_start (args);

#endif

#ifdef ANSI_PROTOTYPES

  vfprintf (stderr, msg, args);

#else

  {

    char *msg1;

    msg1 = va_arg (args, char *);

    vfprintf (stderr, msg1, args);

  }

#endif

  va_end (args);

  fputc ('\n', stderr);

  exit (1);

}

static int ttyfd;

static void

sendex (outtxt, outlen, intxt, inlen, id)

     unsigned char *outtxt;

     int outlen;

     unsigned char *intxt;

     int inlen;

     char *id;

{

  char buf[100];

  int cc;

  if (outlen > 0)

    {

      cc = write (ttyfd, outtxt, outlen);

      if (cc != outlen)

        sys_error ("Write %s failed", id);

    }

  if (inlen > 0)

    {

      cc = read (ttyfd, buf, inlen);    /* Get reply */

      if (cc != inlen)

        sys_error ("Read %s reply failed", id);

      if (bcmp (buf, intxt, inlen) != 0)

        error ("Bad reply to %s", id);

    }

}

extern int optind;

int

main (argc, argv)

     int argc;

     char **argv;

{

  struct termios termios;

  asection *section;

  bfd *pbfd;

  unsigned long entry;

  int c;

  while ((c = getopt (argc, argv, "q")) != EOF)

    {

      switch (c)

        {

        case 'q':

          quiet = 1;

          break;

        default:

          usage();

        }

    }

  argc -= optind;

  argv += optind;

  if (argc != 2)

    usage();

  pbfd = bfd_openr (argv[0], 0);

  if (pbfd == NULL)

    sys_error ("Open of PROG failed");

/* setup the tty.  Must be raw, no flow control, 9600 baud */

  ttyfd = open (argv[1], O_RDWR);

  if (ttyfd == -1)

    sys_error ("Open of TTY failed");

  if (tcgetattr(ttyfd, &termios))

    sys_error ("tcgetattr failed");

  termios.c_iflag = 0;

  termios.c_oflag = 0;

  termios.c_cflag = CS8 | CREAD | CLOCAL;

  termios.c_lflag = 0;

  termios.c_cc[VMIN] = 1;

  termios.c_cc[VTIME] = 0;

  if (cfsetospeed (&termios, B9600)

      || cfsetispeed (&termios, B9600))

    sys_error ("cfset{i|o}speed failed");

  if (tcsetattr (ttyfd, TCSANOW, &termios))

    sys_error ("tcsetattr failed");

  /* The char is documented as 0xaa, \252 is portable octal form.   */

  sendex("", 1, "\252", 1, "alive?");

  sendex ("U", 1, "U", 1, "alive");

  if (!quiet)

    printf ("[SPARClite appears to be alive]\n");

  if (!bfd_check_format (pbfd, bfd_object))

    error ("It doesn't seem to be an object file");

  for (section = pbfd->sections; section; section = section->next)

    {

      if (bfd_get_section_flags (pbfd, section) & SEC_ALLOC)

        {

          bfd_vma section_address;

          unsigned long section_size;

          const char *section_name;

          section_name = bfd_get_section_name (pbfd, section);

          section_address = bfd_get_section_vma (pbfd, section);

          /* Adjust sections from a.out files, since they don't

             carry their addresses with.  */

          if (bfd_get_flavour (pbfd) == bfd_target_aout_flavour)

            section_address += LOAD_ADDRESS;

          section_size = bfd_section_size (pbfd, section);

          if (!quiet)

            printf ("[Loading section %s at %lx (%ld bytes)]\n",

                    section_name, section_address, section_size);

          /* Text, data or lit */

          if (bfd_get_section_flags (pbfd, section) & SEC_LOAD)

            {

              file_ptr fptr;

              fptr = 0;

              while (section_size > 0)

                {

                  char buffer[1024];

                  int count, i;

                  unsigned char checksum;

                  static char inds[] = "|/-\\";

                  static int k = 0;

                  count = min (section_size, 1024);

                  bfd_get_section_contents (pbfd, section, buffer, fptr,

                                            count);

                  checksum = 0;

                  for (i = 0; i < count; i++)

                    checksum += buffer[i];

                  if (!quiet)

                    {

                      printf ("\r%c", inds[k++ % 4]);

                      fflush (stdout);

                    }

                  sendex ("\001", 1, "Z", 1, "load command");

                  sendex (&section_address, 4, NULL, 0, "load address");

                  sendex (&count, 4, NULL, 0, "program size");

                  sendex (buffer, count, &checksum, 1, "program");

                  section_address += count;

                  fptr += count;

                  section_size -= count;

                }

            }

          else                  /* BSS */

            {

              if (!quiet)

                printf ("Not loading BSS \n");

            }

        }

    }

  entry = bfd_get_start_address (pbfd);

  if (!quiet)

    printf ("[Starting %s at 0x%lx]\n", argv[0], entry);

  sendex ("\003", 1, NULL, 0, "exec command");

  sendex (&entry, 4, "U", 1, "program start");

  exit (0);

}