messages.c

gdb for adsp develop

  *passcount =recv_msg_buffer->bkpt_set_ack_msg.pass_count;
  *bkpt_type =recv_msg_buffer->bkpt_set_ack_msg.bkpt_type;
}

void
Mini_unpack_bkpt_rm_ack_msg(mspace, address)
INT32	*mspace;
ADDR32	*address;
{
  *mspace = recv_msg_buffer->bkpt_rm_ack_msg.memory_space;
  *address = recv_msg_buffer->bkpt_rm_ack_msg.address;
}

void
Mini_unpack_bkpt_stat_ack_msg(mspace, address, pass_count, bkpt_type)
INT32	*mspace;
ADDR32	*address;
INT32	*pass_count;
INT32	*bkpt_type;
{
  *mspace = recv_msg_buffer->bkpt_stat_ack_msg.memory_space;
  *address = recv_msg_buffer->bkpt_stat_ack_msg.address;
  *pass_count = recv_msg_buffer->bkpt_stat_ack_msg.pass_count;
  *bkpt_type = recv_msg_buffer->bkpt_stat_ack_msg.bkpt_type;
}

void
Mini_unpack_copy_ack_msg(srcspace, srcaddr, dstspace, dstaddr, count)
INT32	*srcspace, *dstspace;
ADDR32	*srcaddr, *dstaddr;
INT32	*count;
{
  *srcspace = recv_msg_buffer->copy_ack_msg.source_space;
  if ((DebugCoreVersion >= (int) 0x13) && (*srcspace == (INT32) A_SPCL_REG))
   *srcspace = (INT32) SPECIAL_REG;
  *srcaddr = recv_msg_buffer->copy_ack_msg.source_addr;
  *dstspace = recv_msg_buffer->copy_ack_msg.dest_space;
  if ((DebugCoreVersion >= (int) 0x13) && (*dstspace == (INT32) A_SPCL_REG))
   *dstspace = (INT32) SPECIAL_REG;
  *dstaddr = recv_msg_buffer->copy_ack_msg.dest_addr;
  *count = recv_msg_buffer->copy_ack_msg.byte_count;
}

void
Mini_unpack_fill_ack_msg(mspace, startaddr, fillcount, pattern_cnt)
INT32	*mspace;
ADDR32	*startaddr;
INT32	*fillcount;
INT32	*pattern_cnt;
{
  *mspace = recv_msg_buffer->fill_ack_msg.memory_space;
  if ((DebugCoreVersion >= (int) 0x13) && (*mspace == (INT32) A_SPCL_REG))
    *mspace = (INT32) SPECIAL_REG;
  *startaddr = recv_msg_buffer->fill_ack_msg.start_addr;
  *fillcount = recv_msg_buffer->fill_ack_msg.fill_count;
  *pattern_cnt = recv_msg_buffer->fill_ack_msg.byte_count;
}

void
Mini_unpack_init_ack_msg()
{
 /* No data in this message */

}

void
Mini_unpack_halt_msg(mspace, pc0, pc1, trap_number)
INT32	*mspace;
ADDR32	*pc0;
ADDR32	*pc1;
INT32	*trap_number;
{
  *mspace = recv_msg_buffer->halt_msg.memory_space;
  *pc0 = recv_msg_buffer->halt_msg.pc0;
  *pc1 = recv_msg_buffer->halt_msg.pc1;
  *trap_number = recv_msg_buffer->halt_msg.trap_number;
}

void
Mini_unpack_error_msg(errcode, mspace, address)
INT32	*errcode;
INT32	*mspace;
ADDR32	*address;
{
  *errcode = recv_msg_buffer->error_msg.error_code;
  *mspace = recv_msg_buffer->error_msg.memory_space;
  *address = recv_msg_buffer->error_msg.address;
}

void
Mini_unpack_channel0_ack_msg()
{
 /* No data in this message */
}

void
Mini_unpack_channel2_msg(data, len)
BYTE	*data;
INT32	*len;
{
  INT32	i;
  BYTE	*s;

  *len = recv_msg_buffer->channel2_msg.length;
  s = &(recv_msg_buffer->channel2_msg.data);
  for (i = 0; i < *len; i++)
     *data++ = *s++;
}

void
Mini_unpack_channel1_msg(data, len)
BYTE	*data;
INT32	*len;
{
  INT32	i;
  BYTE	*s;

  *len = recv_msg_buffer->channel1_msg.length;
  s = &(recv_msg_buffer->channel1_msg.data);
  for (i = 0; i < *len; i++)
     *data++ = *s++;
}

void	
Mini_unpack_hif_msg (gr121, lr2, lr3, lr4)
INT32 *gr121;
INT32 *lr2;
INT32 *lr3;
INT32 *lr4;
{  
  *gr121 = recv_msg_buffer->hif_call_msg.service_number;
  *lr2 = recv_msg_buffer->hif_call_msg.lr2;
  *lr3 = recv_msg_buffer->hif_call_msg.lr3;
  *lr4 = recv_msg_buffer->hif_call_msg.lr4;
}

void	Mini_unpack_stdin_needed_msg (nbytes)
INT32	*nbytes;
{
  *nbytes = recv_msg_buffer->stdin_needed_msg.nbytes;
}

void	Mini_unpack_stdin_mode_msg (mode)
INT32	*mode;
{
  *mode = recv_msg_buffer->stdin_mode_msg.mode;
}


/* miscellaneous */

static
INT32 match_name(name)
char	*name;
{
 int	i;

 i = 0;
 while (TDF[i].target_name) {
   if (strcmp(TDF[i].target_name, name))
     i++;
   else
     return((INT32) i);
 }
 return(FAILURE);
}

/*
** This function is used to print out a message which has
** been received from the target.
*/

void
print_msg(msg, MsgFile)
   union msg_t *msg;
   FILE		*MsgFile;
   {
   INT32  i, j;
   INT32  length;
   BYTE		*s;
   INT32	*hex;
   INT32	code;

   hex = &(msg->generic_int32_msg.int32);
   s = &(msg->generic_msg.byte);
   length = msg->generic_msg.length;

   fprintf(MsgFile, "\n");
   code = msg->generic_msg.code;
   fprintf(MsgFile, "Code:    %ld ", code);
   switch (code) {
     case	RESET:
	fprintf(MsgFile,"(RESET)\t");
	break;
     case	CONFIG_REQ:
	fprintf(MsgFile,"(CONFIG_REQ)\t");
	break;
     case	STATUS_REQ:
	fprintf(MsgFile,"(STATUS_REQ)\t");
	break;
     case	READ_REQ:
	fprintf(MsgFile,"(READ_REQ)\t");
	break;
     case	WRITE_REQ:
	fprintf(MsgFile,"(WRITE_REQ)\t");
	break;
     case	BKPT_SET:
	fprintf(MsgFile,"(BKPT_SET)\t");
	break;
     case	BKPT_RM:
	fprintf(MsgFile,"(BKPT_RM)\t");
	break;
     case	BKPT_STAT:
	fprintf(MsgFile,"(BKPT_STAT)\t");
	break;
     case	COPY:
	fprintf(MsgFile,"(COPY)\t");
	break;
     case	FILL:
	fprintf(MsgFile,"(FILL)\t");
	break;
     case	INIT:
	fprintf(MsgFile,"(INIT)\t");
	break;
     case	GO:
	fprintf(MsgFile,"(GO)\t");
	break;
     case	STEP:
	fprintf(MsgFile,"(STEP)\t");
	break;
     case	BREAK:
	fprintf(MsgFile,"(BREAK)\t");
	break;
     case	HIF_CALL_RTN:
	fprintf(MsgFile,"(HIF_CALL_RTN)\t");
	break;
     case	CHANNEL0:
	fprintf(MsgFile,"(CHANNEL0)\t");
	break;
     case	CHANNEL1_ACK:
	fprintf(MsgFile,"(CHANNEL1_ACK)\t");
	break;
     case	CHANNEL2_ACK:
	fprintf(MsgFile,"(CHANNEL2_ACK)\t");
	break;
     case	STDIN_NEEDED_ACK:
	fprintf(MsgFile,"(STDIN_NEEDED_ACK)\t");
	break;
     case	STDIN_MODE_ACK:
	fprintf(MsgFile,"(STDIN_MODE_ACK)\t");
	break;
     case	RESET_ACK:
	fprintf(MsgFile,"(RESET_ACK)\t");
	break;
     case	CONFIG:
	fprintf(MsgFile,"(CONFIG)\t");
	break;
     case	STATUS:
	fprintf(MsgFile,"(STATUS)\t");
	break;
     case	READ_ACK:
	fprintf(MsgFile,"(READ_ACK)\t");
	break;
     case	WRITE_ACK:
	fprintf(MsgFile,"(WRITE_ACK)\t");
	break;
     case	BKPT_SET_ACK:
	fprintf(MsgFile,"(BKPT_SET_ACK)\t");
	break;
     case	BKPT_RM_ACK:
	fprintf(MsgFile,"(BKPT_RM_ACK)\t");
	break;
     case	BKPT_STAT_ACK:
	fprintf(MsgFile,"(BKPT_STAT_ACK)\t");
	break;
     case	COPY_ACK:
	fprintf(MsgFile,"(COPY_ACK)\t");
	break;
     case	FILL_ACK:
	fprintf(MsgFile,"(FILL_ACK)\t");
	break;
     case	INIT_ACK:
	fprintf(MsgFile,"(INIT_ACK)\t");
	break;
     case	HALT:
	fprintf(MsgFile,"(HALT)\t");
	break;
     case	ERROR:
	fprintf(MsgFile,"(ERROR)\t");
	break;
     case	HIF_CALL:
	fprintf(MsgFile,"(HIF_CALL)\t");
	break;
     case	CHANNEL0_ACK:
	fprintf(MsgFile,"(CHANNEL0_ACK)\t");
	break;
     case	CHANNEL1:
	fprintf(MsgFile,"(CHANNEL1)\t");
	break;
     case	CHANNEL2:
	fprintf(MsgFile,"(CHANNEL2)\t");
	break;
     case	STDIN_NEEDED_REQ:
	fprintf(MsgFile,"(STDIN_NEEDED_REQ)\t");
	break;
     case	STDIN_MODE_REQ:
	fprintf(MsgFile,"(STDIN_MODE_REQ)\t");
	break;
     default:
	fprintf(MsgFile,"(unknown)\t");
	break;
   }
   fprintf(MsgFile, "Length:  %ld\n", msg->generic_msg.length);
   if ((code == CHANNEL1) || (code == CHANNEL2))
       return;
   if ((code == WRITE_REQ) || (code == FILL)) length = 20;
   if (code == READ_ACK) length = 16;
   if (code == STDIN_NEEDED_ACK) length = 16;
   for (i=0; i<((length+sizeof(INT32)-1)/sizeof(INT32)); i=i+1) {
      fprintf(MsgFile, "%08lx  (",  *hex++);
      for (j=0; j<sizeof(INT32); j=j+1)
         if (isprint(*s))
            fprintf(MsgFile, "%d", *s++);
               else
                  s++, fprintf(MsgFile, ".");
      fprintf(MsgFile, ")\n");
      }

   }  /* end print_msg() */




void
CopyMsgToTarg(source)
union msg_t	*source;
{
  INT32		msglen;
  INT32		count;
  char		*to, *from;

  send_msg_buffer->generic_msg.code = source->generic_msg.code;
  send_msg_buffer->generic_msg.length = source->generic_msg.length;
  msglen = source->generic_msg.length;
  to = (char *) &(send_msg_buffer->generic_msg.byte);
  from = (char *) &(source->generic_msg.byte);
  for (count = (INT32) 0; count < msglen; count++)
     *to++ = *from++;

}

void
CopyMsgFromTarg(dest)
union msg_t	*dest;
{
  INT32		msglen;
  INT32		count;
  char		*to, *from;

  dest->generic_msg.code = recv_msg_buffer->generic_msg.code;
  dest->generic_msg.length = recv_msg_buffer->generic_msg.length;
  msglen = recv_msg_buffer->generic_msg.length;
  to = (char *) &(dest->generic_msg.byte);
  from = (char *) &(recv_msg_buffer->generic_msg.byte);
  for (count = (INT32) 0; count < msglen; count++)
     *to++ = *from++;

}

void
print_recv_bytes()
{
  printf("Bytes received: \n");
  printf("0x%lx \n", (long) recv_msg_buffer->generic_msg.code);
  printf("0x%lx \n", (long) recv_msg_buffer->generic_msg.length);
}