20000317 sourceware import

1 files changed, 338 insertions, 0 deletions

diff --git a/libgloss/hp74x/io.c b/libgloss/hp74x/io.c
new file mode 100644
index 000000000..054d90ce4
--- /dev/null
+++ b/libgloss/hp74x/io.c
@@ -0,0 +1,338 @@
+/*
+ * io.c -- all the code to make GCC and the libraries run on
+ *         a bare target board.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+#include "hppa-defs.h"
+
+extern char *_end;                /* _end is set in the linker command file */
+
+/* just in case, most boards have at least some memory */
+#ifndef RAMSIZE
+#  define RAMSIZE             (char *)0x100000
+#endif
+
+int
+print(ptr)
+char *ptr;
+{
+  while (*ptr)
+    outbyte (*ptr++);
+}
+
+int
+putnum (Num)
+unsigned int Num;
+{
+  char	Buffer[9];
+  int	Count;
+  char	*BufPtr = Buffer;
+  int	Digit;
+  
+  for (Count = 7 ; Count >= 0 ; Count--) {
+    Digit = (Num >> (Count * 4)) & 0xf;
+    
+    if (Digit <= 9)
+      *BufPtr++ = (char) ('0' + Digit);
+    else
+      *BufPtr++ = (char) ('a' - 10 + Digit);
+  }
+
+  *BufPtr = (char) 0;
+  print (Buffer);
+  return;
+}
+
+int
+delay (x)
+     int x;
+{
+  int  y = 17;
+  while (x-- !=0)
+    y = y^2;
+}
+
+/*
+ * strobe -- do a zylons thing, toggling each led in sequence forever...
+ */
+int
+zylons()
+{
+  while (1) {
+    strobe();
+  }
+}
+
+/*
+ * strobe -- toggle each led in sequence up and back once.
+ */
+int
+strobe()
+{
+  static unsigned char curled = 1;
+  static unsigned char dir = 0;
+
+  curled = 1;
+  dir = 0;
+  while (curled != 0) {
+    led_putnum (curled);
+    delay (70000);
+    if (dir)
+      curled >>= 1;
+    else
+      curled <<= 1;
+    
+    if (curled == 128) {
+      dir = ~dir;
+    }
+  }
+  curled = 1;
+  dir = 0;
+}
+
+/*
+ * iodc_io_call -- this makes a call into the IODC routine
+ */
+int
+iodc_io_call(ep_address,arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11)
+int ep_address, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11;
+{ 
+  int         (*iodc_entry_point)();
+  
+  iodc_entry_point = (int (*)())ep_address;
+
+  return ((*iodc_entry_point)(arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11));
+}
+
+/*
+ * pdc_call -- this makes a call into the PDC routine
+ */
+int
+pdc_call(arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11)
+     int arg0, arg1, arg2, arg3,  arg4, arg5;
+     int arg6, arg7, arg9, arg10, arg11;
+{
+   return ( CALL_PDC(arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11));
+}
+
+/*
+ * put_led -- put a bit pattern on the LED's. 
+ */
+int
+led_putnum (byte)
+     unsigned short byte;
+{
+  return (pdc_call(OPT_PDC_CHASSIS,0,byte));
+}
+
+
+/*
+ * outbyte -- shove a byte out the serial port
+ */
+int
+outbyte(byte)
+     unsigned char byte;
+{
+  int status;
+  int R_addr[32];
+  struct _dev *console = (struct _dev *)PGZ_CONSOLE_STRUCT;
+
+  status = iodc_io_call(console->iodc_io, console->hpa, IO_CONSOLE_OUTPUT, console->spa,
+			console->layer[0], R_addr, 0, &byte, 1,	0);
+
+  switch(status)
+    {
+    case 0:  return(1);
+    default: return (-1);
+    }
+}
+
+/*
+ * inbyte -- get a byte from the serial port
+ */
+unsigned char
+inbyte()
+{
+  int status;
+  int R_addr[32];
+  char inbuf;
+  struct _dev *console = (struct _dev *)PGZ_CONSOLE_STRUCT;
+
+  while (status == 0) {
+    status = iodc_io_call(console->iodc_io, console->hpa, IO_CONSOLE_INPUT, console->spa,
+			  console->layer[0], R_addr, 0, &inbuf, 1, 0);
+    
+    switch (status) {
+    case 0:
+    case 2:  					/* recoverable error */
+      if (R_addr[0] != 0) {			/* found a character */
+	return(inbuf);
+      }
+      else
+	break; 					/* error, no character */
+    default: 					/* error, no character */
+      return(0);	
+    }
+  }
+}
+
+/*
+ * read  -- read bytes from the serial port. Ignore fd, since
+ *          we only have stdin.
+ */
+int
+read(fd, buf, nbytes)
+     int fd;
+     char *buf;
+     int nbytes;
+{
+  int i = 0;
+  
+  for (i = 0; i < nbytes; i++) {
+    *(buf + i) = inbyte();
+    if ((*(buf + i) == '\n') || (*(buf + i) == '\r')) {
+      (*(buf + i)) = 0;
+      break;
+    }
+  }
+  return (i);
+}
+
+/*
+ * write -- write bytes to the serial port. Ignore fd, since
+ *          stdout and stderr are the same. Since we have no filesystem,
+ *          open will only return an error.
+ */
+int
+write(fd, buf, nbytes)
+     int fd;
+     char *buf;
+     int nbytes;
+{
+  int i;
+
+  for (i = 0; i < nbytes; i++) {
+    if (*(buf + i) == '\n') {
+      outbyte ('\r');
+    }
+    outbyte (*(buf + i));
+  }
+  return (nbytes);
+}
+
+/*
+ * open -- open a file descriptor. We don't have a filesystem, so
+ *         we return an error.
+ */
+int
+open(buf, flags, mode)
+     char *buf;
+     int flags;
+     int mode;
+{
+  errno = EIO;
+  return (-1);
+}
+
+/*
+ * close -- close a file descriptor. We don't need
+ *          to do anything, but pretend we did.
+ */
+int
+close(fd)
+     int fd;
+{
+  return (0);
+}
+
+/*
+ * sbrk -- changes heap size size. Get nbytes more
+ *         RAM. We just increment a pointer in what's
+ *         left of memory on the board.
+ */
+char *
+sbrk(nbytes)
+     int nbytes;
+{
+  static char * heap_ptr = NULL;
+  char *        base;
+
+  if (heap_ptr == NULL) {
+    heap_ptr = (char *)&_end;
+  }
+
+  if ((RAMSIZE - heap_ptr) >= 0) {
+    base = heap_ptr;
+    heap_ptr += nbytes;
+    return (heap_ptr);
+  } else {
+    errno = ENOMEM;
+    return ((char *)-1);
+  }
+}
+
+/*
+ * isatty -- returns 1 if connected to a terminal device,
+ *           returns 0 if not. Since we're hooked up to a
+ *           serial port, we'll say yes return a 1.
+ */
+int
+isatty(fd)
+     int fd;
+{
+  return (1);
+}
+
+/*
+ * lseek -- move read/write pointer. Since a serial port
+ *          is non-seekable, we return an error.
+ */
+off_t
+lseek(fd,  offset, whence)
+     int fd;
+     off_t offset;
+     int whence;
+{
+  errno = ESPIPE;
+  return ((off_t)-1);
+}
+
+/*
+ * fstat -- get status of a file. Since we have no file
+ *          system, we just return an error.
+ */
+int
+fstat(fd, buf)
+     int fd;
+     struct stat *buf;
+{
+  errno = EIO;
+  return (-1);
+}
+
+/*
+ * getpid -- only one process, so just return 1.
+ */
+#define __MYPID 1
+int
+getpid()
+{
+  return __MYPID;
+}
+
+/*
+ * kill -- assume mvme.S, and go out via exit...
+ */
+int
+kill(pid, sig)
+     int pid;
+     int sig;
+{
+  if(pid == __MYPID)
+    _exit(sig);
+  return 0;
+}