source: trunk/libs/newlib/src/libgloss/sparc/salib.c @ 480

/* Stand-alone library for SPARClite
 *
 * Copyright (c) 1995 Cygnus Support
 *
 * The authors hereby grant permission to use, copy, modify, distribute,
 * and license this software and its documentation for any purpose, provided
 * that existing copyright notices are retained in all copies and that this
 * notice is included verbatim in any distributions. No written agreement,
 * license, or royalty fee is required for any of the authorized uses.
 * Modifications to this software may be copyrighted by their authors
 * and need not follow the licensing terms described here, provided that
 * the new terms are clearly indicated on the first page of each file where
 * they apply.
 */

#include "sparclite.h"
#include "asm.h"

/* LED blinking pattern can be changed by modifying __led_algorithm. */

enum ledtype
{
  led_marching,         /* marching pattern, only one led on at a time */
  led_random,           /* pseudo-random pattern */
  led_blinking,         /* all leds blink on and off */
  led_none              /* leds off all the time */
};

enum ledtype __led_algorithm = led_marching;


/* Pointer to hook for outbyte, set by stub's exception handler.  */
void (*__outbyte_hook) (int c);

#ifdef SL931
#define SDTR_BASE 0x200
#define SDTR_ASI 1
#define SDTR_SHIFT 0
#else
#define SDTR_BASE 0x10000000
#define SDTR_ASI 4
#define SDTR_SHIFT 16
#endif

#define get_uart_status(PORT) \
  (read_asi (SDTR_ASI, SDTR_BASE + 0x24 + (PORT) * 0x10) >> SDTR_SHIFT)

#define xmt_char(PORT, C) \
  write_asi (SDTR_ASI, SDTR_BASE + 0x20 + (PORT) * 0x10, (C) << SDTR_SHIFT)

#define rcv_char(PORT) \
  (read_asi (SDTR_ASI, SDTR_BASE + 0x20 + (PORT) * 0x10) >> SDTR_SHIFT)

void putDebugChar();

#if 0
void
set_uart (cmd)
     int cmd;
{
  write_asi (SDTR_ASI, SDTR_BASE + 0x24, cmd << SDTR_SHIFT);
}

void
set_timer_3 (val)
     int val;
{
  write_asi (SDTR_ASI, SDTR_BASE + 0x78, val << SDTR_SHIFT);
}
#endif


asm("
        .text
        .align 4

! Register window overflow handler.  Come here when save would move us
! into the invalid window.  This routine runs with traps disabled, and
! must be careful not to touch the condition codes, as PSR is never
! restored.
!
! We are called with %l0 = wim, %l1 = pc, %l2 = npc

        .globl " STRINGSYM(win_ovf) "
" STRINGSYM(win_ovf) ":
        mov     %g1, %l3                ! Save g1, we use it to hold the wim
        srl     %l0, 1, %g1             ! Rotate wim right
        sll     %l0, __WINSIZE-1, %l0
        or      %l0, %g1, %g1

        save    %g0, %g0, %g0           ! Slip into next window
        mov     %g1, %wim               ! Install the new wim

        std     %l0, [%sp + 0 * 4]      ! save L & I registers
        std     %l2, [%sp + 2 * 4]
        std     %l4, [%sp + 4 * 4]
        std     %l6, [%sp + 6 * 4]

        std     %i0, [%sp + 8 * 4]
        std     %i2, [%sp + 10 * 4]
        std     %i4, [%sp + 12 * 4]
        std     %i6, [%sp + 14 * 4]

        restore                         ! Go back to trap window.
        mov     %l3, %g1                ! Restore %g1

        jmpl    %l1,  %g0
        rett    %l2

! Register window underflow handler.  Come here when restore would move us
! into the invalid window.  This routine runs with traps disabled, and
! must be careful not to touch the condition codes, as PSR is never
! restored.
!
! We are called with %l0 = wim, %l1 = pc, %l2 = npc

        .globl " STRINGSYM(win_unf) "
" STRINGSYM(win_unf) ":
        sll     %l0, 1, %l3             ! Rotate wim left
        srl     %l0, __WINSIZE-1, %l0
        or      %l0, %l3, %l0

        mov     %l0, %wim               ! Install the new wim

        restore                         ! User's window
        restore                         ! His caller's window

        ldd     [%sp + 0 * 4], %l0      ! restore L & I registers
        ldd     [%sp + 2 * 4], %l2
        ldd     [%sp + 4 * 4], %l4
        ldd     [%sp + 6 * 4], %l6

        ldd     [%sp + 8 * 4], %i0
        ldd     [%sp + 10 * 4], %i2
        ldd     [%sp + 12 * 4], %i4
        ldd     [%sp + 14 * 4], %i6

        save    %g0, %g0, %g0           ! Back to trap window
        save    %g0, %g0, %g0

        jmpl    %l1,  %g0
        rett    %l2

! Read the TBR.

        .globl " STRINGSYM(rdtbr) "
" STRINGSYM(rdtbr) ":
        retl
        mov     %tbr, %o0

");

extern unsigned long rdtbr();

void
die(val)
     int val;
{
  static unsigned char *leds = (unsigned char *)0x02000003;

  *leds = val;

  while (1) ;
}

/* Each entry in the trap vector occupies four words. */

struct trap_entry
{
  unsigned sethi_filler:10;
  unsigned sethi_imm22:22;
  unsigned jmpl_filler:19;
  unsigned jmpl_simm13:13;
  unsigned long filler[2];
};

extern struct trap_entry fltr_proto;
asm ("
        .data
        .globl " STRINGSYM(fltr_proto) "
        .align 4
" STRINGSYM(fltr_proto) ":                      ! First level trap routine prototype
        sethi 0, %l0
        jmpl 0+%l0, %g0
        nop
        nop

        .text
        .align 4
");

/* Setup trap TT to go to ROUTINE.  If TT is between 0 and 255 inclusive, the
   normal trap vector will be used.  If TT is 256, then it's for the SPARClite
   DSU, and that always vectors off to 255 unrelocated.
*/

void
exceptionHandler (tt, routine)
     int tt;
     unsigned long routine;
{
  struct trap_entry *tb;        /* Trap vector base address */

  if (tt != 256)
    tb = (struct trap_entry *) (rdtbr() & ~0xfff);
  else
    {
      tt = 255;
      tb = (struct trap_entry *) 0;
    }

  tb[tt] = fltr_proto;

  tb[tt].sethi_imm22 = routine >> 10;
  tb[tt].jmpl_simm13 = routine & 0x3ff;
}

void
update_leds()
{
  static unsigned char *leds = (unsigned char *)0x02000003;
  static enum ledtype prev_algorithm = led_none;

  if (prev_algorithm != __led_algorithm)
    {
       *leds = 0xff;    /* turn the LEDs off */
       prev_algorithm = __led_algorithm;
    }

  switch (__led_algorithm)
    {
    case led_marching:
      {
        static unsigned char curled = 1;
        static unsigned char dir = 0;

        *leds = ~curled;

        if (dir)
          curled <<= 1;
        else
          curled >>= 1;

        if (curled == 0)
          {
            if (dir)
              curled = 0x80;
            else
              curled = 1;
            dir = ~dir;
          }
        break;
      }

    case led_random:
      {
        static unsigned int next = 0;
        *leds = next & 0xff;
        next = (next * 1103515245 + 12345) & 0x7fff;
        break;
      }

    case led_blinking:
      {
        static unsigned char next = 0;
        *leds = next;
        next = ~next;
        break;
      }

    default:
      break;
    }
}

 /* 1/5th of a second? */

#define LEDTIME (20000000 / 500)

unsigned long ledtime = LEDTIME;

int
inbyte()
{
        return (getDebugChar());
}

int
getDebugChar()
{
  unsigned long countdown = ledtime;

  update_leds();

  while (1)
    {
      if ((get_uart_status(0) & 2) != 0) break;

      if (countdown-- == 0)
        {
          countdown = ledtime;
          update_leds();
        }
    }

  return rcv_char(0);
}

/* Output one character to the serial port */
void
outbyte(c)
    int c;
{
  if (__outbyte_hook)
    __outbyte_hook (c);
  else
    putDebugChar(c);
}

void
putDebugChar(c)
     int c;
{
  update_leds();

  while ((get_uart_status(0) & 1) == 0) ;

  xmt_char(0, c);
}

#if 0
int
write(fd, data, length)
     int fd;
     unsigned char *data;
     int length;
{
  int olength = length;

  while (length--)
    putDebugChar(*data++);

  return olength;
}

int
read(fd, data, length)
     int fd;
     unsigned char *data;
     int length;
{
  int olength = length;
  int c;

  while (length--)
    *data++ = getDebugChar();

  return olength;
}
#endif

/* Set the baud rate for the serial port, returns 0 for success,
   -1 otherwise */

#if 0
int
set_baud_rate(baudrate)
     int baudrate;
{
  /* Convert baud rate to uart clock divider */
  switch (baudrate)
    {
    case 38400:
      baudrate = 16;
      break;
    case 19200:
      baudrate = 33;
      break;
    case 9600:
      baudrate = 65;
      break;
    default:
      return -1;
    }

  set_timer_3(baudrate);        /* Set it */
}
#endif