messages.c

gdb for adsp develop

}

void
Mini_build_status_req_msg()
{
send_msg_buffer->status_req_msg.code = STATUS_REQ;
send_msg_buffer->status_req_msg.length = (INT32) 0; /* Always zero */
}

void
Mini_build_read_req_msg(m_space, address, count, size)
INT32	m_space;
ADDR32	address;
INT32	count;
INT32	size;
{
send_msg_buffer->read_req_msg.code = READ_REQ;
send_msg_buffer->read_req_msg.length = msg_length(READ_REQ);
send_msg_buffer->read_req_msg.memory_space = m_space;
if ((DebugCoreVersion >= (int) 0x13) && (m_space == (INT32) SPECIAL_REG))
   send_msg_buffer->read_req_msg.memory_space = (INT32) A_SPCL_REG;
send_msg_buffer->read_req_msg.address = address;
/* if msg version >= 0x10 use new format, else old */
if (((tip_target_config.version >> 16) & 0xff) >= 0x10) { /* new version */
	send_msg_buffer->read_req_msg.count = count;
	send_msg_buffer->read_req_msg.size = size;
	} else {					/* old version */
	send_msg_buffer->read_req_msg.count = count * size;
	}
}

void
Mini_build_write_req_msg(m_space, address, count, size, data)
INT32	m_space;
ADDR32	address;
INT32	count;
INT32	size;
BYTE	*data;
{
  BYTE		*s;
  INT32		i;
  INT32		bcnt = count * size;

send_msg_buffer->write_req_msg.code = WRITE_REQ;
send_msg_buffer->write_req_msg.length = msg_length(WRITE_REQ) + (count * size);
send_msg_buffer->write_req_msg.memory_space = m_space;
if ((DebugCoreVersion >= (int) 0x13) && (m_space == (INT32) SPECIAL_REG))
   send_msg_buffer->write_req_msg.memory_space = (INT32) A_SPCL_REG;
send_msg_buffer->write_req_msg.address = address;

/* if msg version >= 0x10 use new format, else old */
if (((tip_target_config.version >> 16) & 0xff) >= 0x10) { /* new version */
	send_msg_buffer->write_req_msg.count = count;
	send_msg_buffer->write_req_msg.size = size;
	s = &(send_msg_buffer->write_req_msg.data);
	for (i = 0; i < bcnt; i++)
	  *s++ = *data++;
	} else { 					/* old version */
	send_msg_buffer->write_req_msg.count = bcnt;
	s = (BYTE *) &(send_msg_buffer->write_req_msg.size);
	for (i = 0; i < bcnt; i++)
	  *s++ = *data++;
	}
}

void
Mini_build_bkpt_set_msg(m_space, address, pass_count, type)
INT32	m_space, pass_count, type;
ADDR32	address;
{
send_msg_buffer->bkpt_set_msg.code = BKPT_SET;
send_msg_buffer->bkpt_set_msg.length = MSG_LENGTH (struct bkpt_set_msg_t);
send_msg_buffer->bkpt_set_msg.memory_space = m_space;
send_msg_buffer->bkpt_set_msg.bkpt_addr = address;
send_msg_buffer->bkpt_set_msg.pass_count = pass_count;
send_msg_buffer->bkpt_set_msg.bkpt_type = type;
}

void
Mini_build_bkpt_rm_msg(m_space, address)
INT32	m_space;
ADDR32	address;
{
send_msg_buffer->bkpt_rm_msg.code = BKPT_RM;
send_msg_buffer->bkpt_rm_msg.length = MSG_LENGTH (struct bkpt_rm_msg_t);
send_msg_buffer->bkpt_rm_msg.memory_space = m_space;
send_msg_buffer->bkpt_rm_msg.bkpt_addr = address;
}

void
Mini_build_bkpt_stat_msg(m_space, address)
INT32	m_space;
ADDR32	address;
{
send_msg_buffer->bkpt_stat_msg.code = BKPT_STAT;
send_msg_buffer->bkpt_stat_msg.length = MSG_LENGTH (struct bkpt_stat_msg_t);
send_msg_buffer->bkpt_stat_msg.memory_space = m_space;
send_msg_buffer->bkpt_stat_msg.bkpt_addr = address;
}

void
Mini_build_copy_msg(src_space, src_addr, dst_space, dst_addr, count, size)
INT32	src_space, dst_space;
ADDR32	src_addr, dst_addr;
INT32	count;
INT32	size;
{
send_msg_buffer->copy_msg.code = COPY;
send_msg_buffer->copy_msg.length = msg_length(COPY);
send_msg_buffer->copy_msg.source_space = src_space;
if ((DebugCoreVersion >= (int) 0x13) && (src_space == (INT32) SPECIAL_REG))
   send_msg_buffer->copy_msg.source_space = (INT32) A_SPCL_REG;
send_msg_buffer->copy_msg.source_addr = src_addr;
send_msg_buffer->copy_msg.dest_space = dst_space;
if ((DebugCoreVersion >= (int) 0x13) && (dst_space == (INT32) SPECIAL_REG))
   send_msg_buffer->copy_msg.dest_space = (INT32) A_SPCL_REG;
send_msg_buffer->copy_msg.dest_addr = dst_addr;

/* if msg version >= 0x10 use new format, else old */
if (((tip_target_config.version >> 16) & 0xff) >= 0x10) { /* new version */
	send_msg_buffer->copy_msg.count = count;
	send_msg_buffer->copy_msg.size = size;
	} else {					/* old version */
	send_msg_buffer->copy_msg.count = count * size;
	}
}

void
Mini_build_fill_msg(m_space, start, fill_count, byte_count, pattern)
INT32	m_space;
ADDR32	start;
INT32	fill_count, byte_count;
BYTE	*pattern;
{
send_msg_buffer->fill_msg.code = FILL;
send_msg_buffer->fill_msg.length = MSG_LENGTH (struct fill_msg_t) +
					byte_count; 
send_msg_buffer->fill_msg.memory_space = m_space;
if ((DebugCoreVersion >= (int) 0x13) && (m_space == (INT32) SPECIAL_REG))
   send_msg_buffer->fill_msg.memory_space = (INT32) A_SPCL_REG;
send_msg_buffer->fill_msg.start_addr = start;
send_msg_buffer->fill_msg.fill_count = fill_count;
send_msg_buffer->fill_msg.byte_count = byte_count;
(void) strcpy ( &(send_msg_buffer->fill_msg.fill_data),pattern);
}

void
Mini_build_init_msg(t_start, t_end, d_start, d_end, 
		    entry, m_stack, r_stack, 
		    highmem, arg_start, os_ctrl)
ADDR32	t_start, t_end, d_start, d_end;
ADDR32	entry, highmem, arg_start;
INT32	m_stack, r_stack;
INT32	os_ctrl;
{
send_msg_buffer->init_msg.code = INIT;
/* subtract 4 to hide highmem value */
send_msg_buffer->init_msg.length = MSG_LENGTH (struct init_msg_t) - 4;
send_msg_buffer->init_msg.text_start = t_start;
send_msg_buffer->init_msg.text_end = t_end;
send_msg_buffer->init_msg.data_start = d_start;
send_msg_buffer->init_msg.data_end = d_end;
send_msg_buffer->init_msg.entry_point = entry;
send_msg_buffer->init_msg.mem_stack_size = m_stack;
send_msg_buffer->init_msg.reg_stack_size = r_stack;
send_msg_buffer->init_msg.arg_start = arg_start;
send_msg_buffer->init_msg.os_control = os_ctrl;
send_msg_buffer->init_msg.highmem = highmem;
}

void
Mini_build_go_msg()
{
send_msg_buffer->go_msg.code = GO;
send_msg_buffer->go_msg.length = (INT32) 0; /* Always zero */
}

void
Mini_build_step_msg(count)
INT32	count;
{
send_msg_buffer->step_msg.code = STEP;
send_msg_buffer->step_msg.length = sizeof(INT32);
send_msg_buffer->step_msg.count = count;
}

void
Mini_build_break_msg()
{
send_msg_buffer->break_msg.code = BREAK;
send_msg_buffer->break_msg.length = (INT32) 0; /* Always zero */
}

void
Mini_build_hif_rtn_msg(snum, gr121, gr96, gr97)
INT32	snum, gr121, gr96, gr97;
{
send_msg_buffer->hif_call_rtn_msg.code = HIF_CALL_RTN;
send_msg_buffer->hif_call_rtn_msg.length = MSG_LENGTH (struct hif_call_rtn_msg_t);
send_msg_buffer->hif_call_rtn_msg.service_number = snum;
send_msg_buffer->hif_call_rtn_msg.gr121 = gr121;
send_msg_buffer->hif_call_rtn_msg.gr96 = gr96;
send_msg_buffer->hif_call_rtn_msg.gr97 = gr97;
}

void
Mini_build_channel0_msg(input, count)
INT32	count;
BYTE	*input;
{
send_msg_buffer->channel0_msg.code = CHANNEL0;
send_msg_buffer->channel0_msg.length = count;	/* bytes to follow */
(void ) memcpy (&(send_msg_buffer->channel0_msg.data), input, (int) count);
}

void
Mini_build_channel1_ack_msg(gr96)
INT32	gr96;
{
send_msg_buffer->channel1_ack_msg.code = CHANNEL1_ACK;
	/*
	 * The HIF kernel from MiniMON29K release 2.1 expects MONTIP
	 * to send a HIF_CALL_RTN response for a HIF_CALL message, and
	 * a CHANNEL1_ACK response for a CHANNEL1 message, and 
	 * a CHANNEL2_ACK response for a CHANNEL2 message, and
	 * a CHANNEL0 message for a asynchronous input.
	 * The HIF kernel version numbers 0x05 and above support these
	 * features.
	 */
     if ((tip_target_config.os_version & 0xf) > 4) { /* new HIF kernel */
	/*
	 * The CHANNEL1_ACK for new HIF kernel includes the gr96 value
	 * which is the number of characters succesfully printed out.
	 */
       send_msg_buffer->channel1_ack_msg.length = (INT32) 4; /* return gr96 */
       send_msg_buffer->channel1_ack_msg.gr96 = gr96;
     } else { /* old HIF kernel */
       send_msg_buffer->channel1_ack_msg.length = (INT32) 0; 
     }
}

void
Mini_build_channel2_ack_msg(gr96)
INT32	gr96;
{
send_msg_buffer->channel2_ack_msg.code = CHANNEL2_ACK;
	/*
	 * The HIF kernel from MiniMON29K release 2.1 expects MONTIP
	 * to send a HIF_CALL_RTN response for a HIF_CALL message, and
	 * a CHANNEL1_ACK response for a CHANNEL1 message, and 
	 * a CHANNEL2_ACK response for a CHANNEL2 message, and
	 * a CHANNEL0 message for a asynchronous input.
	 * The HIF kernel version numbers 0x05 and above support these
	 * features.
	 */
     if ((tip_target_config.os_version & 0xf) > 4) { /* new HIF kernel */
	/*
	 * The CHANNEL1_ACK for new HIF kernel includes the gr96 value
	 * which is the number of characters succesfully printed out.
	 */
       send_msg_buffer->channel2_ack_msg.length = (INT32) 4; /* return gr96 */
       send_msg_buffer->channel2_ack_msg.gr96 = gr96;
     } else { /* old HIF kernel */
       /* 
	* The old kernels did not support this feature. They invoked the
	* debugger on target to get the information.
	*/
     }
}

void	Mini_build_stdin_needed_ack_msg (count, data)
UINT32	count;
BYTE	*data;
{
  BYTE	*s;

send_msg_buffer->stdin_needed_ack_msg.code = STDIN_NEEDED_ACK;
send_msg_buffer->stdin_needed_ack_msg.length = (INT32) count;
s = &(send_msg_buffer->stdin_needed_ack_msg.data);
for (; count > 0; count--)
  *s++ = *data++;
}

void	Mini_build_stdin_mode_ack_msg (mode)
INT32	mode;
{
send_msg_buffer->stdin_mode_ack_msg.code = STDIN_MODE_ACK;
send_msg_buffer->stdin_mode_ack_msg.length = MSG_LENGTH(struct stdin_mode_ack_msg_t);
send_msg_buffer->stdin_mode_ack_msg.mode = mode;
}

/*
** Functions to unpack messages.
*/

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

void
Mini_unpack_config_msg(target_config)
TIP_TARGET_CONFIG	*target_config;
{
  /* received a CONFIG message */
  target_config->processor_id = recv_msg_buffer->config_msg.processor_id;
  target_config->version =  recv_msg_buffer->config_msg.version;
  DebugCoreVersion = (int) (target_config->version & 0xFF);
  target_config->I_mem_start =  recv_msg_buffer->config_msg.I_mem_start;
  target_config->I_mem_size =  recv_msg_buffer->config_msg.I_mem_size;
  target_config->D_mem_start =  recv_msg_buffer->config_msg.D_mem_start;
  target_config->D_mem_size =  recv_msg_buffer->config_msg.D_mem_size;
  target_config->ROM_start =  recv_msg_buffer->config_msg.ROM_start;
  target_config->ROM_size =  recv_msg_buffer->config_msg.ROM_size;
  target_config->max_msg_size =  recv_msg_buffer->config_msg.max_msg_size;
  target_config->max_bkpts =  recv_msg_buffer->config_msg.max_bkpts;
  target_config->coprocessor =  recv_msg_buffer->config_msg.coprocessor;
  target_config->os_version =  recv_msg_buffer->config_msg.os_version;
}

void
Mini_unpack_status_msg(target_status)
TIP_TARGET_STATUS	*target_status;
{
  /* received a STATUS mesages */
  target_status->msgs_sent = recv_msg_buffer->status_msg.msgs_sent;
  target_status->msgs_received = recv_msg_buffer->status_msg.msgs_received;
  target_status->errors = recv_msg_buffer->status_msg.errors;
  target_status->bkpts_hit = recv_msg_buffer->status_msg.bkpts_hit;
  target_status->bkpts_free = recv_msg_buffer->status_msg.bkpts_free;
  target_status->traps = recv_msg_buffer->status_msg.traps;
  target_status->fills = recv_msg_buffer->status_msg.fills;
  target_status->spills = recv_msg_buffer->status_msg.spills;
  target_status->cycles = recv_msg_buffer->status_msg.cycles;
}

void
Mini_unpack_read_ack_msg(mspace, address, bytecount, buffer)
INT32	*mspace;
ADDR32	*address;
INT32	*bytecount;
BYTE	*buffer;
{
 INT32		i;
 BYTE		*s;

 /* READ_ACK received */
 *mspace = recv_msg_buffer->read_ack_msg.memory_space;
 if ((DebugCoreVersion >= (int) 0x13) && (*mspace == (INT32) A_SPCL_REG))
   *mspace = (INT32) SPECIAL_REG;
 *address = recv_msg_buffer->read_ack_msg.address;
 *bytecount = recv_msg_buffer->read_ack_msg.byte_count;
  s = &(recv_msg_buffer->read_ack_msg.data);
  for (i = 0; i < *bytecount; i++)
     *buffer++ = *s++;
}

void
Mini_unpack_write_ack_msg(mspace, address, bytecount)
INT32	*mspace;
ADDR32	*address;
INT32	*bytecount;
{
  *mspace =recv_msg_buffer->write_ack_msg.memory_space;
  if ((DebugCoreVersion >= (int) 0x13) && (*mspace == (INT32) A_SPCL_REG))
     *mspace = (INT32) SPECIAL_REG;
  *address =recv_msg_buffer->write_ack_msg.address;
  *bytecount =recv_msg_buffer->write_ack_msg.byte_count;
}

void
Mini_unpack_bkpt_set_ack_msg(mspace, address, passcount, bkpt_type)
INT32	*mspace;
ADDR32	*address;
INT32	*passcount;
INT32	*bkpt_type;
{
  *mspace =recv_msg_buffer->bkpt_set_ack_msg.memory_space;
  *address =recv_msg_buffer->bkpt_set_ack_msg.address;