/*  parent.c -- ARMulator RDP comms code:  ARM6 Instruction Emulator.
    Copyright (C) 1994 Advanced RISC Machines Ltd.
 
    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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */

/*****************************************************************/
/* The Parent process continues here...                          */
/* It waits on the socket and passes on RDP messages down a pipe */
/* to the ARMulator RDP to RDI interpreter.                      */
/*****************************************************************/

#include <stdio.h>
#include <sys/types.h>
#include <signal.h>
#include "time.h"
#include "armdefs.h"
#include "dbg_rdi.h"
#include "communicate.h"

/* The socket to the debugger */
extern int debugsock;

/* The pipes between the two processes */
extern int mumkid[2];
extern int kidmum[2];

/* A pipe for handling SWI return values that goes straight from the */
/* parent to the ARMulator host interface, bypassing the child's RDP */
/* to RDI interpreter */
extern int DebuggerARMul[2];

/* The maximum number of file descriptors */
extern int nfds;

/* The child process id. */
extern pid_t child;

void
parent ()
{
  int i, j, k;
  unsigned char message, CPnum, exreturn;
  ARMword mask, nbytes, messagetype;
  unsigned char c, d;
  ARMword x, y;
  int virgin = 1;
  struct fd_set readfds;

#ifdef DEBUG
  fprintf (stderr, "parent ()...\n");
#endif
  
 panic_error:

  if (!virgin)
    {
#ifdef DEBUG
      fprintf(stderr, "Arghh! What is going on?\n");
#endif
      kill (child, SIGHUP);
      MYwrite_char(debugsock, RDP_Reset);
    }
  
  virgin = 0;

  while (1)
    {
    
    /* Wait either for the ARMulator or the debugger */
    
    FD_ZERO (&readfds);
    FD_SET (kidmum[0], &readfds); /* Wait for messages from ARMulator */
    FD_SET (debugsock, &readfds); /* Wait for messages from debugger */

#ifdef DEBUG
    fprintf (stderr, "Waiting for ARMulator or debugger... ");
#endif    

    while ((i = select (nfds, &readfds, (fd_set *) 0, (fd_set *) 0, 0)) < 0)
      {
	perror ("select");
      }

#ifdef DEBUG
    fprintf(stderr, "(%d/2)", i);
#endif
    
    if (FD_ISSET (debugsock, &readfds)) {
#ifdef DEBUG
      fprintf (stderr, "->debugger\n");
#endif      
      
      /* Inside this rather large if statement with simply pass on a complete 
	 message to the ARMulator.  The reason we need to pass messages on one
	 at a time is that we have to know whether the message is an OSOpReply
	 or an info(stop), so that we can take different action in those
	 cases. */

      if (MYread_char (debugsock, &message))
	goto panic_error;
      
      switch (message)
	{
	case RDP_Start:
	  /* Open and/or Initialise */
#ifdef DEBUG
	  fprintf (stderr, "RDP Open\n");
#endif
	  if (MYread_char(debugsock, &c)) /* type */
	    goto panic_error;

	  if (MYread_word(debugsock, &x))  /* memory size */
	    goto panic_error;

	  MYwrite_char (mumkid[1], message);
	  MYwrite_char (mumkid[1], c);
	  MYwrite_word (mumkid[1], x);
	  if (c & 0x2)
	    {
	      passon (debugsock, mumkid[1], 1); /* speed */
	    }
	  break;
	
	case RDP_End:
	  /* Close and Finalise */
#ifdef DEBUG
	  fprintf(stderr, "RDP Close\n");
#endif
	  MYwrite_char (mumkid[1], message);
	  break;
	
	case RDP_Read:
	  /* Read Memory Address */   
#ifdef DEBUG
	  fprintf (stderr, "RDP Read Memory\n");
#endif
	  MYwrite_char (mumkid[1], message);
	  if (passon (debugsock, mumkid[1], 4))
	    goto panic_error; /* address */
	  if (MYread_word(debugsock, &nbytes))
	    goto panic_error; /* nbytes */
	  MYwrite_word (mumkid[1], nbytes);
	  break;
	
	case RDP_Write :
	  /* Write Memory Address */
#ifdef DEBUG
	  fprintf (stderr, "RDP Write Memory\n");
#endif
	  if (MYread_word (debugsock, &x))
	    goto panic_error; /* address */

	  if (MYread_word (debugsock, &y))
	    goto panic_error; /* nbytes */

	  MYwrite_char (mumkid[1], message);
	  MYwrite_word (mumkid[1], x);
	  MYwrite_word (mumkid[1], y);
	  passon (debugsock, mumkid[1], y);  /* actual data */
	  break;
	
	case RDP_CPUread:
	  /* Read CPU State */
#ifdef DEBUG
	  fprintf (stderr, "RDP Read CPU\n");
#endif
	  if (MYread_char(debugsock, &c))
	    goto panic_error; /* mode */

	  if (MYread_word (debugsock, &mask))
	    goto panic_error; /* mask */

	  MYwrite_char (mumkid[1], message);
	  MYwrite_char (mumkid[1], c);
	  MYwrite_word (mumkid[1], mask);
	  break;

	case RDP_CPUwrite :
	  /* Write CPU State */
#ifdef DEBUG
	  fprintf (stderr, "RDP Write CPU\n");
#endif
	  if (MYread_char (debugsock, &c))
	    goto panic_error; /* mode */

	  if (MYread_word (debugsock, &x))
	    goto panic_error; /* mask */

	  MYwrite_char (mumkid[1], message);
	  MYwrite_char (mumkid[1], c);
	  MYwrite_word (mumkid[1], x);
	  for (k = 1, j = 0; k != 0x80000000; k *= 2, j++)
	    if ((k & x) 
		&& passon(debugsock, mumkid[1], 4))
	      goto panic_error;
	  break;

	case RDP_CPread:
	  /* Read Co-Processor State */
#ifdef DEBUG
	  fprintf (stderr, "RDP Read CP state\n");
#endif
	  if (MYread_char (debugsock, &CPnum))
	    goto panic_error;

	  if (MYread_word (debugsock, &mask))
	    goto panic_error;

	  MYwrite_char (mumkid[1], message);
	  MYwrite_char (mumkid[1], CPnum);
	  MYwrite_word (mumkid[1], mask);
	  break;
	
	case RDP_CPwrite:
	  /* Write Co-Processor State */
#ifdef DEBUG
	  fprintf(stderr, "RDP Write CP state\n");
#endif
	  if (MYread_char (debugsock, &CPnum))
	    goto panic_error;

	  if (MYread_word (debugsock, &mask))
	    goto panic_error;

	  MYwrite_char (mumkid[1], message);
	  MYwrite_char (mumkid[1], c);
	  MYwrite_char (mumkid[1], x);
	  for (k = 1, j = 0; k != 0x80000000; k *= 2, j++)
	    if (k & x)
	      {
		if ((c == 1 || c == 2) && k <= 128)
		  {
		    /* FP register = 12 bytes + 4 bytes format */
		    if (passon(debugsock, mumkid[1], 16))
		      goto panic_error;
		  }
		else
		  {
		    /* Normal register = 4 bytes */
		    if (passon(debugsock, mumkid[1], 4))
		      goto panic_error; 
		  }
	      }
	  break;
	
	case RDP_SetBreak:
	  /* Set Breakpoint */
#ifdef DEBUG
	  fprintf (stderr, "RDP Set Breakpoint\n");
#endif
	  if (MYread_word (debugsock, &x))
	    goto panic_error; /* address */

	  if (MYread_char (debugsock, &c))
	    goto panic_error; /* type */

	  MYwrite_char (mumkid[1], message);
	  MYwrite_word (mumkid[1], x);
	  MYwrite_char (mumkid[1], c);
	  if (((c & 0xf) >= 5)
	      && passon(debugsock, mumkid[1], 4))
	    goto panic_error; /* bound */
	  break;

	case RDP_ClearBreak:
	  /* Clear Breakpoint */
#ifdef DEBUG
	  fprintf (stderr, "RDP Clear Breakpoint\n");
#endif
	  MYwrite_char (mumkid[1], message);
	  if (passon (debugsock, mumkid[1], 4))
	    goto panic_error; /* point */
	  break;
	
	case RDP_SetWatch:
	  /* Set Watchpoint */
#ifdef DEBUG
	  fprintf (stderr, "RDP Set Watchpoint\n");
#endif
	  if (MYread_word (debugsock, &x))
	    goto panic_error; /* address */

	  if (MYread_char(debugsock, &c))
	    goto panic_error; /* type */

	  if (MYread_char (debugsock, &d))
	    goto panic_error; /* datatype */

	  MYwrite_char (mumkid[1], message);
	  MYwrite_word (mumkid[1], x);
	  MYwrite_char (mumkid[1], c);
	  MYwrite_char (mumkid[1], d);
	  if (((c & 0xf) >= 5)
	      && passon(debugsock, mumkid[1], 4))
	    goto panic_error; /* bound */
	  break;
	
	case RDP_ClearWatch:
	  /* Clear Watchpoint */
#ifdef DEBUG
	  fprintf (stderr, "RDP Clear Watchpoint\n");
#endif
	  MYwrite_char (mumkid[1], message);
	  if (passon (debugsock, mumkid[1], 4))
	    goto panic_error; /* point */
	  break;

	case RDP_Execute:
	  /* Excecute */
#ifdef DEBUG
	  fprintf (stderr, "RDP Execute\n");
#endif
	
	  /* LEAVE THIS ONE 'TIL LATER... */
	  /* NEED TO WORK THINGS OUT */
	
	  /* NO ASCYNCHROUS RUNNING */
	
	  if (MYread_char(debugsock, &c))
	    goto panic_error; /* return */

	  /* Remember incase bit 7 is set and we have to send back a word */
	  exreturn = c;
	
	  MYwrite_char(mumkid[1], message);
	  MYwrite_char(mumkid[1], c);
	  break;
	
	case RDP_Step:
	  /* Step */
#ifdef DEBUG
	  fprintf (stderr, "RDP Step\n");
#endif

	  if (MYread_char(debugsock, &c))
	    goto panic_error; /* return */

	  if (MYread_word(debugsock, &x))
	    goto panic_error; /* ninstr */

	  MYwrite_char (mumkid[1], message);
	  MYwrite_char (mumkid[1], c);
	  MYwrite_word (mumkid[1], x);
	  break;
	
	case RDP_Info:
	  /* Info */
#ifdef DEBUG
	  fprintf (stderr, "RDP Info\n");
#endif
	  /* INFO TARGET, SET RDI LEVEL */
	  if (MYread_word (debugsock, &messagetype))
	    goto panic_error; /* info */

	  switch (messagetype)
	    {
	    case RDIInfo_Target:
	      MYwrite_char (mumkid[1], message);
	      MYwrite_word (mumkid[1], messagetype);
	      break;
	    
	    case RDISet_RDILevel:
	      MYwrite_char (mumkid[1], message);
	      MYwrite_word (mumkid[1], messagetype);
	      if (passon (debugsock, mumkid[1], 1))
		goto panic_error; /* argument */
	      break;

	    case RDISet_Cmdline:
	      /* Got to pass on a string argument */
	      MYwrite_char (mumkid[1], message);
	      MYwrite_word (mumkid[1], messagetype);
	      do
		{
		  if (MYread_char (debugsock, &c))
		    goto panic_error;

		  MYwrite_char (mumkid[1], c);
		} while (c);
	      break;

	    case RDISignal_Stop:
	      kill (child, SIGUSR1);
	      MYwrite_char (debugsock, RDP_Return);
	      MYwrite_char (debugsock, RDIError_UserInterrupt);
	      break;

	    case RDIVector_Catch:
	      MYread_word (debugsock, &x);
	      MYwrite_char (mumkid[1], message);
	      MYwrite_word (mumkid[1], messagetype);
	      MYwrite_word (mumkid[1], x);
	      break;

	    case RDIInfo_Step:
	      MYwrite_char (mumkid[1], message);
	      MYwrite_word (mumkid[1], messagetype);
	      break;

	    case RDIInfo_Points:
	      MYwrite_char (mumkid[1], message);
	      MYwrite_word (mumkid[1], messagetype);
	      break;

	    default:
	      fprintf (stderr, "Unrecognized RDIInfo request %d\n",
		       messagetype);
	      goto panic_error;
	    }
	  break;
	
	case RDP_OSOpReply:
	  /* OS Operation Reply */
#ifdef DEBUG
	  fprintf (stderr, "RDP OS Reply\n");
#endif
	  MYwrite_char (mumkid[1], message);
	  if (MYread_char (debugsock, &message))
	    goto panic_error;
	  MYwrite_char (mumkid[1], message);
	  switch(message)
	    {
	    case 0: /* return value i.e. nothing else.*/
	      break;

	    case 1: /* returns a byte... */
	      if (MYread_char(debugsock, &c))
		goto panic_error;

	      MYwrite_char (mumkid[1], c);
	      break;	  

	    case 2: /* returns a word... */
	      if (MYread_word(debugsock, &x))
		goto panic_error;

	      MYwrite_word (mumkid[1], x);
	      break;
	    }
	  break;
	
	case RDP_Reset:
	  /* Reset */
#ifdef DEBUG
	  fprintf (stderr, "RDP Reset\n");
#endif
	  MYwrite_char (mumkid[1], message);
	  break;

	default:
	  /* Hmm.. bad RDP operation */
	  fprintf (stderr, "RDP Bad RDP request (%d)\n", message);
	  MYwrite_char (debugsock, RDP_Return);
	  MYwrite_char (debugsock, RDIError_UnimplementedMessage);
	  break;
	}
    }
    
    if (FD_ISSET (kidmum[0], &readfds))
      {
#ifdef DEBUG
	fprintf (stderr, "->ARMulator\n");
#endif      
	/* Anything we get from the ARMulator has to go to the debugger... */
	/* It is that simple! */
      
	passon (kidmum[0], debugsock, 1);
      }
  }
}

