home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gdb-4.16-base.tgz / gdb-4.16-base.tar / fsf / gdb / utils / amd-udi / montip / messages.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-23  |  30.4 KB  |  1,138 lines
  1. static char _[] = "@(#)messages.c    5.20 93/08/02 13:23:58, Srini, AMD.";
  2. /******************************************************************************
  3.  * Copyright 1991 Advanced Micro Devices, Inc.
  4.  *
  5.  * This software is the property of Advanced Micro Devices, Inc  (AMD)  which
  6.  * specifically  grants the user the right to modify, use and distribute this
  7.  * software provided this notice is not removed or altered.  All other rights
  8.  * are reserved by AMD.
  9.  *
  10.  * AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
  11.  * SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
  12.  * DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
  13.  * USE OF THIS SOFTWARE.
  14.  *
  15.  * So that all may benefit from your experience, please report  any  problems
  16.  * or  suggestions about this software to the 29K Technical Support Center at
  17.  * 800-29-29-AMD (800-292-9263) in the USA, or 0800-89-1131  in  the  UK,  or
  18.  * 0031-11-1129 in Japan, toll free.  The direct dial number is 512-462-4118.
  19.  *
  20.  * Advanced Micro Devices, Inc.
  21.  * 29K Support Products
  22.  * Mail Stop 573
  23.  * 5900 E. Ben White Blvd.
  24.  * Austin, TX 78741
  25.  * 800-292-9263
  26.  *****************************************************************************
  27.  *      Engineer: Srini Subramanian.
  28.  *****************************************************************************
  29.  * This module contains the functions to build and unpack MiniMON29K messages.
  30.  * It also defines the functions to send and receive messages from the
  31.  * 29K target. An array defining the appropriate functions to use for
  32.  * different targets is initialized.
  33.  *****************************************************************************
  34.  */
  35.  
  36. /* 
  37.  * Definitions of functions that 
  38.  * -initialize the Message System 
  39.  * -send messages to the target
  40.  * -receive messages from the target
  41.  */
  42.  
  43. #include <stdio.h>
  44. #include <ctype.h>
  45. #ifdef    MSDOS
  46. #include <stdlib.h>
  47. #endif
  48. #include <string.h>
  49. #include "messages.h"
  50. #include "memspcs.h"
  51. #include "tdfunc.h"
  52. #include "mtip.h"
  53.  
  54. extern    FILE    *MsgFile;
  55. static    int    DebugCoreVersion;
  56.  
  57. static     INT32    target_index = 0;    /* Default EB29K */
  58.  
  59. int    lpt_initialize=0;    /* global */
  60. int    use_parport=0;    /* global */
  61.  
  62. static    union msg_t    *send_msg_buffer;
  63. static    union msg_t    *recv_msg_buffer;
  64.  
  65. struct    target_dep_funcs {
  66.  char    target_name[15];
  67.  INT32    (*msg_send)PARAMS((union msg_t *, INT32));
  68.  INT32    (*msg_recv)PARAMS((union msg_t *, INT32, INT32));
  69.  INT32    (*init_comm)PARAMS((INT32, INT32));
  70.  INT32    (*reset_comm)PARAMS((INT32, INT32));
  71.  INT32    (*exit_comm)PARAMS((INT32, INT32));
  72.  INT32    (*read_memory)PARAMS((INT32, ADDR32, BYTE *, INT32, INT32, INT32));
  73.  INT32    (*write_memory)PARAMS((INT32, ADDR32, BYTE *, INT32, INT32, INT32));
  74.  INT32    (*fill_memory)PARAMS((void));
  75.  INT32    PC_port_base;
  76.  INT32    PC_mem_seg;
  77.  void    (*go)PARAMS((INT32, INT32));
  78. } TDF[] = {
  79. "pceb", msg_send_pceb, msg_recv_pceb, init_comm_pceb,
  80. reset_comm_pceb, exit_comm_pceb, read_memory_pceb, write_memory_pceb, 
  81. fill_memory_pceb, (INT32) 0x240, (INT32) 0xd000, go_pceb,
  82.  
  83. #ifndef    MSDOS
  84. "pcserver", msg_send_serial, msg_recv_serial, init_comm_serial,
  85. reset_comm_pcserver, exit_comm_serial, read_memory_serial, write_memory_serial,
  86. fill_memory_serial, (INT32) -1 , (INT32) -1, go_serial,
  87. #endif
  88.  
  89. #ifdef    MSDOS
  90. "paral_1", msg_send_parport, msg_recv_serial, init_comm_serial,
  91. reset_comm_serial, exit_comm_serial, read_memory_serial, write_memory_serial,
  92. fill_memory_serial, (INT32) -1 , (INT32) -1, go_serial,
  93. #endif
  94.  
  95. "serial", msg_send_serial, msg_recv_serial, init_comm_serial,
  96. reset_comm_serial, exit_comm_serial, read_memory_serial, write_memory_serial,
  97. fill_memory_serial, (INT32) -1 , (INT32) -1, go_serial,
  98.  
  99. "eb29030", msg_send_eb030, msg_recv_eb030, init_comm_eb030,
  100. reset_comm_eb030, exit_comm_eb030, read_memory_eb030, write_memory_eb030,
  101. fill_memory_eb030, (INT32) 0x208, (INT32) 0xd000, go_eb030,
  102.  
  103. "eb030", msg_send_eb030, msg_recv_eb030, init_comm_eb030,
  104. reset_comm_eb030, exit_comm_eb030, read_memory_eb030, write_memory_eb030,
  105. fill_memory_eb030, (INT32) 0x208, (INT32) 0xd000, go_eb030,
  106.  
  107. "eb29k", msg_send_eb29k, msg_recv_eb29k, init_comm_eb29k,
  108. reset_comm_eb29k, exit_comm_eb29k, read_memory_eb29k, write_memory_eb29k, 
  109. fill_memory_eb29k, (INT32) 0x208, (INT32) 0xd000, go_eb29k,
  110.  
  111. "yarcrev8", msg_send_eb29k, msg_recv_eb29k, init_comm_eb29k,
  112. reset_comm_eb29k, exit_comm_eb29k, read_memory_eb29k, write_memory_eb29k, 
  113. fill_memory_eb29k, (INT32) 0x208, (INT32) 0xd000, go_eb29k,
  114.  
  115. "lcb29k", msg_send_lcb29k, msg_recv_lcb29k, init_comm_lcb29k, 
  116. reset_comm_lcb29k, exit_comm_lcb29k, read_memory_lcb29k, write_memory_lcb29k,
  117. fill_memory_lcb29k, (INT32) 0x208, (INT32) 0xd000, go_lcb29k,
  118.  
  119. "\0"
  120. };
  121.  
  122. void    print_msg PARAMS((union msg_t *msgptr, FILE *file));
  123. static    INT32    match_name PARAMS((char *targ_name));
  124.  
  125.  
  126. #ifdef MSDOS
  127. void    set_lpt PARAMS((void));
  128. void    unset_lpt PARAMS((void));
  129.  
  130. void    set_lpt ()
  131. {
  132.   TDF[target_index].msg_send = msg_send_parport;
  133.   use_parport = 1;
  134. }
  135.  
  136. void    unset_lpt()
  137. {
  138.   TDF[target_index].msg_send = msg_send_serial;
  139.   use_parport = 0;
  140. }
  141.  
  142. #endif
  143. /*
  144. ** Miscellaneous 
  145. */
  146.  
  147. INT32 msg_length(code)
  148. INT32 code;
  149. {  /* for temporary compatibility between new and old r/w/copy msgs */
  150. INT32 rv;
  151.   if (code == WRITE_REQ) 
  152.       rv = MSG_LENGTH(struct write_req_msg_t);
  153.   else
  154.   if (code == READ_REQ) 
  155.       rv = MSG_LENGTH(struct read_req_msg_t);
  156.   else
  157.   if (code == COPY) 
  158.       rv = MSG_LENGTH(struct copy_msg_t);
  159.   else return(-1);
  160.  
  161.   /* if msg version < 0x10 use old format */
  162.   /* assumes config info this has been set up */
  163.   if (((tip_target_config.version >> 16) & 0xff) < 0x10) 
  164.     rv = rv - 4;         
  165.   return(rv);
  166. }
  167.  
  168. /*
  169. ** Target Dependent functions
  170. */
  171.  
  172. INT32
  173. Mini_msg_init(target_name)
  174. char    *target_name;
  175. {
  176.   INT32        temp;
  177.  
  178.   /* Allocate buffers */
  179.   if ((send_msg_buffer = (union msg_t *) malloc (BUFFER_SIZE)) == NULL)
  180.     return(FAILURE);
  181.   if ((recv_msg_buffer = (union msg_t *) malloc (BUFFER_SIZE)) == NULL)
  182.     return(FAILURE);
  183.  
  184.   /* Identify target */
  185.   if (strcmp (target_name, "paral_1") == 0) {
  186.     lpt_initialize = 1;
  187.     use_parport = 1;
  188.   }
  189.  
  190.   if ((temp = match_name(target_name)) == FAILURE)
  191.     return(FAILURE);  /* Unrecognized target */
  192.   else
  193.     target_index = temp;
  194.  
  195.   if (tip_config.PC_port_base == (INT32) -1) /* no -port opt given */
  196.      tip_config.PC_port_base = TDF[target_index].PC_port_base;
  197.  
  198.   if (tip_config.PC_mem_seg == (INT32) -1) /* no -seg opt given */
  199.      tip_config.PC_mem_seg = TDF[target_index].PC_mem_seg;
  200.  
  201.   /* Initialize communication with target */
  202.   return(Mini_init_comm());
  203.  
  204. }
  205.  
  206. int
  207. Mini_alloc_msgbuf(size)
  208. int    size;
  209. {
  210.   if (size > (int) BUFFER_SIZE) {
  211.      (void) free(send_msg_buffer);
  212.      (void) free(recv_msg_buffer);
  213.  
  214.      /* Re-Allocate buffers */
  215.      if ((send_msg_buffer = (union msg_t *) malloc (size)) == NULL)
  216.        return(FAILURE);
  217.      if ((recv_msg_buffer = (union msg_t *) malloc (size)) == NULL)
  218.        return(FAILURE);
  219.   }
  220.   return (SUCCESS);
  221. }
  222.  
  223. void
  224. Mini_msg_exit()
  225. {
  226.   if (send_msg_buffer)
  227.     (void) free ((char *) send_msg_buffer);
  228.   if (recv_msg_buffer)
  229.     (void) free ((char *) recv_msg_buffer);
  230.  
  231.   (void) Mini_reset_comm();
  232.   (void) Mini_exit_comm();
  233. }
  234.  
  235. INT32
  236. Mini_msg_send()
  237. {
  238.   INT32    retval;
  239.  
  240.   if (Msg_Logfile) {/* log the message */
  241.      fprintf(MsgFile, "\nSending:");
  242.      print_msg(send_msg_buffer, MsgFile);
  243.      fflush(MsgFile);
  244.   };
  245.   retval = (*TDF[target_index].msg_send)(send_msg_buffer,
  246.                        tip_config.PC_port_base);
  247.   /* retry once more */
  248.   if (retval == MSGRETRY)
  249.      retval = (*TDF[target_index].msg_send)(send_msg_buffer,
  250.                        tip_config.PC_port_base);
  251.  
  252.   return (retval);
  253. }
  254.  
  255. INT32
  256. Mini_msg_recv(RecvMode)
  257. INT32    RecvMode;    /* BLOCK or NONBLOCK */
  258. {
  259.   INT32    retval;
  260.  
  261.   retval = (INT32) (*TDF[target_index].msg_recv)(recv_msg_buffer,
  262.                        tip_config.PC_port_base, RecvMode);
  263.   if (RecvMode == BLOCK)  /* we are expecting a response */
  264.   {
  265.      if (retval == MSGRETRY) {
  266.     Mini_msg_send();
  267.         retval = (INT32) (*TDF[target_index].msg_recv)(recv_msg_buffer,
  268.                        tip_config.PC_port_base, RecvMode);
  269.      }
  270.      if (Msg_Logfile && (retval != (INT32) -1)) { /* log the message */
  271.        fprintf(MsgFile, "\nReceived:");
  272.        print_msg(recv_msg_buffer, MsgFile);
  273.        fflush (MsgFile);
  274.      };
  275.      if (retval == MSGRETRY)
  276.     return (FAILURE);
  277.      else 
  278.     return (retval);
  279.   }
  280.   else     /* non-block mode */
  281.   {
  282.      if (retval == MSGRETRY) {
  283.         retval = (INT32) (*TDF[target_index].msg_recv)(recv_msg_buffer,
  284.                        tip_config.PC_port_base, RecvMode);
  285.     if (retval == MSGRETRY)
  286.       return (FAILURE);
  287.     else
  288.       return (retval);
  289.      } else  {
  290.         if (Msg_Logfile && (retval != (INT32) -1)) { /* log the message */
  291.           fprintf(MsgFile, "\nReceived:");
  292.           print_msg(recv_msg_buffer, MsgFile);
  293.           fflush (MsgFile);
  294.         };
  295.         return (retval);
  296.      }
  297.   }
  298. }
  299.  
  300. INT32
  301. Mini_init_comm()
  302. {
  303.  return((*TDF[target_index].init_comm)(tip_config.PC_port_base,
  304.                        tip_config.PC_mem_seg));
  305. }
  306.  
  307. INT32
  308. Mini_reset_comm()
  309. {
  310.  return((*TDF[target_index].reset_comm)(tip_config.PC_port_base,
  311.                     tip_config.PC_mem_seg));
  312. }
  313.  
  314. INT32
  315. Mini_exit_comm()
  316. {
  317.  return((*TDF[target_index].exit_comm)(tip_config.PC_port_base,
  318.                     tip_config.PC_mem_seg));
  319. }
  320.  
  321.  
  322. void
  323. Mini_go_target()
  324. {
  325.  (*TDF[target_index].go)(tip_config.PC_port_base,
  326.                  tip_config.PC_mem_seg);
  327. }
  328.  
  329. INT32
  330. Mini_write_memory(m_space, address, byte_count, buffer)
  331. INT32    m_space;
  332. ADDR32    address;
  333. INT32    byte_count;
  334. BYTE    *buffer;
  335. {
  336.  return((*TDF[target_index].write_memory)(m_space, 
  337.                       address,
  338.                       buffer,
  339.                       byte_count,
  340.                       tip_config.PC_port_base,
  341.                       tip_config.PC_mem_seg));
  342. }
  343.  
  344. INT32
  345. Mini_read_memory(m_space, address, byte_count, buffer)
  346. INT32    m_space;
  347. ADDR32    address;
  348. INT32    byte_count;
  349. BYTE    *buffer;
  350. {
  351.  return((*TDF[target_index].read_memory)(m_space,
  352.                       address,
  353.                       buffer,
  354.                       byte_count,
  355.                       tip_config.PC_port_base,
  356.                       tip_config.PC_mem_seg));
  357. }
  358.  
  359. INT32
  360. Mini_fill_memory()
  361. {
  362.  return((*TDF[target_index].fill_memory)());
  363. }
  364.  
  365. /* 
  366. ** Functions to build msgs
  367. */
  368.  
  369. void
  370. Mini_build_reset_msg()
  371. {
  372.  send_msg_buffer->reset_msg.code = RESET;
  373.  send_msg_buffer->reset_msg.length = (INT32) 0;/* Length always is zero */
  374. }
  375.  
  376. void
  377. Mini_build_config_req_msg()
  378. {
  379.  send_msg_buffer->config_req_msg.code = CONFIG_REQ;
  380.  send_msg_buffer->config_req_msg.length = (INT32) 0; /* Always zero */
  381. }
  382.  
  383. void
  384. Mini_build_status_req_msg()
  385. {
  386. send_msg_buffer->status_req_msg.code = STATUS_REQ;
  387. send_msg_buffer->status_req_msg.length = (INT32) 0; /* Always zero */
  388. }
  389.  
  390. void
  391. Mini_build_read_req_msg(m_space, address, count, size)
  392. INT32    m_space;
  393. ADDR32    address;
  394. INT32    count;
  395. INT32    size;
  396. {
  397. send_msg_buffer->read_req_msg.code = READ_REQ;
  398. send_msg_buffer->read_req_msg.length = msg_length(READ_REQ);
  399. send_msg_buffer->read_req_msg.memory_space = m_space;
  400. if ((DebugCoreVersion >= (int) 0x13) && (m_space == (INT32) SPECIAL_REG))
  401.    send_msg_buffer->read_req_msg.memory_space = (INT32) A_SPCL_REG;
  402. send_msg_buffer->read_req_msg.address = address;
  403. /* if msg version >= 0x10 use new format, else old */
  404. if (((tip_target_config.version >> 16) & 0xff) >= 0x10) { /* new version */
  405.     send_msg_buffer->read_req_msg.count = count;
  406.     send_msg_buffer->read_req_msg.size = size;
  407.     } else {                    /* old version */
  408.     send_msg_buffer->read_req_msg.count = count * size;
  409.     }
  410. }
  411.  
  412. void
  413. Mini_build_write_req_msg(m_space, address, count, size, data)
  414. INT32    m_space;
  415. ADDR32    address;
  416. INT32    count;
  417. INT32    size;
  418. BYTE    *data;
  419. {
  420.   BYTE        *s;
  421.   INT32        i;
  422.   INT32        bcnt = count * size;
  423.  
  424. send_msg_buffer->write_req_msg.code = WRITE_REQ;
  425. send_msg_buffer->write_req_msg.length = msg_length(WRITE_REQ) + (count * size);
  426. send_msg_buffer->write_req_msg.memory_space = m_space;
  427. if ((DebugCoreVersion >= (int) 0x13) && (m_space == (INT32) SPECIAL_REG))
  428.    send_msg_buffer->write_req_msg.memory_space = (INT32) A_SPCL_REG;
  429. send_msg_buffer->write_req_msg.address = address;
  430.  
  431. /* if msg version >= 0x10 use new format, else old */
  432. if (((tip_target_config.version >> 16) & 0xff) >= 0x10) { /* new version */
  433.     send_msg_buffer->write_req_msg.count = count;
  434.     send_msg_buffer->write_req_msg.size = size;
  435.     s = &(send_msg_buffer->write_req_msg.data);
  436.     for (i = 0; i < bcnt; i++)
  437.       *s++ = *data++;
  438.     } else {                     /* old version */
  439.     send_msg_buffer->write_req_msg.count = bcnt;
  440.     s = (BYTE *) &(send_msg_buffer->write_req_msg.size);
  441.     for (i = 0; i < bcnt; i++)
  442.       *s++ = *data++;
  443.     }
  444. }
  445.  
  446. void
  447. Mini_build_bkpt_set_msg(m_space, address, pass_count, type)
  448. INT32    m_space, pass_count, type;
  449. ADDR32    address;
  450. {
  451. send_msg_buffer->bkpt_set_msg.code = BKPT_SET;
  452. send_msg_buffer->bkpt_set_msg.length = MSG_LENGTH (struct bkpt_set_msg_t);
  453. send_msg_buffer->bkpt_set_msg.memory_space = m_space;
  454. send_msg_buffer->bkpt_set_msg.bkpt_addr = address;
  455. send_msg_buffer->bkpt_set_msg.pass_count = pass_count;
  456. send_msg_buffer->bkpt_set_msg.bkpt_type = type;
  457. }
  458.  
  459. void
  460. Mini_build_bkpt_rm_msg(m_space, address)
  461. INT32    m_space;
  462. ADDR32    address;
  463. {
  464. send_msg_buffer->bkpt_rm_msg.code = BKPT_RM;
  465. send_msg_buffer->bkpt_rm_msg.length = MSG_LENGTH (struct bkpt_rm_msg_t);
  466. send_msg_buffer->bkpt_rm_msg.memory_space = m_space;
  467. send_msg_buffer->bkpt_rm_msg.bkpt_addr = address;
  468. }
  469.  
  470. void
  471. Mini_build_bkpt_stat_msg(m_space, address)
  472. INT32    m_space;
  473. ADDR32    address;
  474. {
  475. send_msg_buffer->bkpt_stat_msg.code = BKPT_STAT;
  476. send_msg_buffer->bkpt_stat_msg.length = MSG_LENGTH (struct bkpt_stat_msg_t);
  477. send_msg_buffer->bkpt_stat_msg.memory_space = m_space;
  478. send_msg_buffer->bkpt_stat_msg.bkpt_addr = address;
  479. }
  480.  
  481. void
  482. Mini_build_copy_msg(src_space, src_addr, dst_space, dst_addr, count, size)
  483. INT32    src_space, dst_space;
  484. ADDR32    src_addr, dst_addr;
  485. INT32    count;
  486. INT32    size;
  487. {
  488. send_msg_buffer->copy_msg.code = COPY;
  489. send_msg_buffer->copy_msg.length = msg_length(COPY);
  490. send_msg_buffer->copy_msg.source_space = src_space;
  491. if ((DebugCoreVersion >= (int) 0x13) && (src_space == (INT32) SPECIAL_REG))
  492.    send_msg_buffer->copy_msg.source_space = (INT32) A_SPCL_REG;
  493. send_msg_buffer->copy_msg.source_addr = src_addr;
  494. send_msg_buffer->copy_msg.dest_space = dst_space;
  495. if ((DebugCoreVersion >= (int) 0x13) && (dst_space == (INT32) SPECIAL_REG))
  496.    send_msg_buffer->copy_msg.dest_space = (INT32) A_SPCL_REG;
  497. send_msg_buffer->copy_msg.dest_addr = dst_addr;
  498.  
  499. /* if msg version >= 0x10 use new format, else old */
  500. if (((tip_target_config.version >> 16) & 0xff) >= 0x10) { /* new version */
  501.     send_msg_buffer->copy_msg.count = count;
  502.     send_msg_buffer->copy_msg.size = size;
  503.     } else {                    /* old version */
  504.     send_msg_buffer->copy_msg.count = count * size;
  505.     }
  506. }
  507.  
  508. void
  509. Mini_build_fill_msg(m_space, start, fill_count, byte_count, pattern)
  510. INT32    m_space;
  511. ADDR32    start;
  512. INT32    fill_count, byte_count;
  513. BYTE    *pattern;
  514. {
  515. send_msg_buffer->fill_msg.code = FILL;
  516. send_msg_buffer->fill_msg.length = MSG_LENGTH (struct fill_msg_t) +
  517.                     byte_count; 
  518. send_msg_buffer->fill_msg.memory_space = m_space;
  519. if ((DebugCoreVersion >= (int) 0x13) && (m_space == (INT32) SPECIAL_REG))
  520.    send_msg_buffer->fill_msg.memory_space = (INT32) A_SPCL_REG;
  521. send_msg_buffer->fill_msg.start_addr = start;
  522. send_msg_buffer->fill_msg.fill_count = fill_count;
  523. send_msg_buffer->fill_msg.byte_count = byte_count;
  524. (void) strcpy ( &(send_msg_buffer->fill_msg.fill_data),pattern);
  525. }
  526.  
  527. void
  528. Mini_build_init_msg(t_start, t_end, d_start, d_end, 
  529.             entry, m_stack, r_stack, 
  530.             highmem, arg_start, os_ctrl)
  531. ADDR32    t_start, t_end, d_start, d_end;
  532. ADDR32    entry, highmem, arg_start;
  533. INT32    m_stack, r_stack;
  534. INT32    os_ctrl;
  535. {
  536. send_msg_buffer->init_msg.code = INIT;
  537. /* subtract 4 to hide highmem value */
  538. send_msg_buffer->init_msg.length = MSG_LENGTH (struct init_msg_t) - 4;
  539. send_msg_buffer->init_msg.text_start = t_start;
  540. send_msg_buffer->init_msg.text_end = t_end;
  541. send_msg_buffer->init_msg.data_start = d_start;
  542. send_msg_buffer->init_msg.data_end = d_end;
  543. send_msg_buffer->init_msg.entry_point = entry;
  544. send_msg_buffer->init_msg.mem_stack_size = m_stack;
  545. send_msg_buffer->init_msg.reg_stack_size = r_stack;
  546. send_msg_buffer->init_msg.arg_start = arg_start;
  547. send_msg_buffer->init_msg.os_control = os_ctrl;
  548. send_msg_buffer->init_msg.highmem = highmem;
  549. }
  550.  
  551. void
  552. Mini_build_go_msg()
  553. {
  554. send_msg_buffer->go_msg.code = GO;
  555. send_msg_buffer->go_msg.length = (INT32) 0; /* Always zero */
  556. }
  557.  
  558. void
  559. Mini_build_step_msg(count)
  560. INT32    count;
  561. {
  562. send_msg_buffer->step_msg.code = STEP;
  563. send_msg_buffer->step_msg.length = sizeof(INT32);
  564. send_msg_buffer->step_msg.count = count;
  565. }
  566.  
  567. void
  568. Mini_build_break_msg()
  569. {
  570. send_msg_buffer->break_msg.code = BREAK;
  571. send_msg_buffer->break_msg.length = (INT32) 0; /* Always zero */
  572. }
  573.  
  574. void
  575. Mini_build_hif_rtn_msg(snum, gr121, gr96, gr97)
  576. INT32    snum, gr121, gr96, gr97;
  577. {
  578. send_msg_buffer->hif_call_rtn_msg.code = HIF_CALL_RTN;
  579. send_msg_buffer->hif_call_rtn_msg.length = MSG_LENGTH (struct hif_call_rtn_msg_t);
  580. send_msg_buffer->hif_call_rtn_msg.service_number = snum;
  581. send_msg_buffer->hif_call_rtn_msg.gr121 = gr121;
  582. send_msg_buffer->hif_call_rtn_msg.gr96 = gr96;
  583. send_msg_buffer->hif_call_rtn_msg.gr97 = gr97;
  584. }
  585.  
  586. void
  587. Mini_build_channel0_msg(input, count)
  588. INT32    count;
  589. BYTE    *input;
  590. {
  591. send_msg_buffer->channel0_msg.code = CHANNEL0;
  592. send_msg_buffer->channel0_msg.length = count;    /* bytes to follow */
  593. (void ) memcpy (&(send_msg_buffer->channel0_msg.data), input, (int) count);
  594. }
  595.  
  596. void
  597. Mini_build_channel1_ack_msg(gr96)
  598. INT32    gr96;
  599. {
  600. send_msg_buffer->channel1_ack_msg.code = CHANNEL1_ACK;
  601.     /*
  602.      * The HIF kernel from MiniMON29K release 2.1 expects MONTIP
  603.      * to send a HIF_CALL_RTN response for a HIF_CALL message, and
  604.      * a CHANNEL1_ACK response for a CHANNEL1 message, and 
  605.      * a CHANNEL2_ACK response for a CHANNEL2 message, and
  606.      * a CHANNEL0 message for a asynchronous input.
  607.      * The HIF kernel version numbers 0x05 and above support these
  608.      * features.
  609.      */
  610.      if ((tip_target_config.os_version & 0xf) > 4) { /* new HIF kernel */
  611.     /*
  612.      * The CHANNEL1_ACK for new HIF kernel includes the gr96 value
  613.      * which is the number of characters succesfully printed out.
  614.      */
  615.        send_msg_buffer->channel1_ack_msg.length = (INT32) 4; /* return gr96 */
  616.        send_msg_buffer->channel1_ack_msg.gr96 = gr96;
  617.      } else { /* old HIF kernel */
  618.        send_msg_buffer->channel1_ack_msg.length = (INT32) 0; 
  619.      }
  620. }
  621.  
  622. void
  623. Mini_build_channel2_ack_msg(gr96)
  624. INT32    gr96;
  625. {
  626. send_msg_buffer->channel2_ack_msg.code = CHANNEL2_ACK;
  627.     /*
  628.      * The HIF kernel from MiniMON29K release 2.1 expects MONTIP
  629.      * to send a HIF_CALL_RTN response for a HIF_CALL message, and
  630.      * a CHANNEL1_ACK response for a CHANNEL1 message, and 
  631.      * a CHANNEL2_ACK response for a CHANNEL2 message, and
  632.      * a CHANNEL0 message for a asynchronous input.
  633.      * The HIF kernel version numbers 0x05 and above support these
  634.      * features.
  635.      */
  636.      if ((tip_target_config.os_version & 0xf) > 4) { /* new HIF kernel */
  637.     /*
  638.      * The CHANNEL1_ACK for new HIF kernel includes the gr96 value
  639.      * which is the number of characters succesfully printed out.
  640.      */
  641.        send_msg_buffer->channel2_ack_msg.length = (INT32) 4; /* return gr96 */
  642.        send_msg_buffer->channel2_ack_msg.gr96 = gr96;
  643.      } else { /* old HIF kernel */
  644.        /* 
  645.     * The old kernels did not support this feature. They invoked the
  646.     * debugger on target to get the information.
  647.     */
  648.      }
  649. }
  650.  
  651. void    Mini_build_stdin_needed_ack_msg (count, data)
  652. UINT32    count;
  653. BYTE    *data;
  654. {
  655.   BYTE    *s;
  656.  
  657. send_msg_buffer->stdin_needed_ack_msg.code = STDIN_NEEDED_ACK;
  658. send_msg_buffer->stdin_needed_ack_msg.length = (INT32) count;
  659. s = &(send_msg_buffer->stdin_needed_ack_msg.data);
  660. for (; count > 0; count--)
  661.   *s++ = *data++;
  662. }
  663.  
  664. void    Mini_build_stdin_mode_ack_msg (mode)
  665. INT32    mode;
  666. {
  667. send_msg_buffer->stdin_mode_ack_msg.code = STDIN_MODE_ACK;
  668. send_msg_buffer->stdin_mode_ack_msg.length = MSG_LENGTH(struct stdin_mode_ack_msg_t);
  669. send_msg_buffer->stdin_mode_ack_msg.mode = mode;
  670. }
  671.  
  672. /*
  673. ** Functions to unpack messages.
  674. */
  675.  
  676. void
  677. Mini_unpack_reset_ack_msg()
  678. {
  679.  /* No data in this message */
  680. }
  681.  
  682. void
  683. Mini_unpack_config_msg(target_config)
  684. TIP_TARGET_CONFIG    *target_config;
  685. {
  686.   /* received a CONFIG message */
  687.   target_config->processor_id = recv_msg_buffer->config_msg.processor_id;
  688.   target_config->version =  recv_msg_buffer->config_msg.version;
  689.   DebugCoreVersion = (int) (target_config->version & 0xFF);
  690.   target_config->I_mem_start =  recv_msg_buffer->config_msg.I_mem_start;
  691.   target_config->I_mem_size =  recv_msg_buffer->config_msg.I_mem_size;
  692.   target_config->D_mem_start =  recv_msg_buffer->config_msg.D_mem_start;
  693.   target_config->D_mem_size =  recv_msg_buffer->config_msg.D_mem_size;
  694.   target_config->ROM_start =  recv_msg_buffer->config_msg.ROM_start;
  695.   target_config->ROM_size =  recv_msg_buffer->config_msg.ROM_size;
  696.   target_config->max_msg_size =  recv_msg_buffer->config_msg.max_msg_size;
  697.   target_config->max_bkpts =  recv_msg_buffer->config_msg.max_bkpts;
  698.   target_config->coprocessor =  recv_msg_buffer->config_msg.coprocessor;
  699.   target_config->os_version =  recv_msg_buffer->config_msg.os_version;
  700. }
  701.  
  702. void
  703. Mini_unpack_status_msg(target_status)
  704. TIP_TARGET_STATUS    *target_status;
  705. {
  706.   /* received a STATUS mesages */
  707.   target_status->msgs_sent = recv_msg_buffer->status_msg.msgs_sent;
  708.   target_status->msgs_received = recv_msg_buffer->status_msg.msgs_received;
  709.   target_status->errors = recv_msg_buffer->status_msg.errors;
  710.   target_status->bkpts_hit = recv_msg_buffer->status_msg.bkpts_hit;
  711.   target_status->bkpts_free = recv_msg_buffer->status_msg.bkpts_free;
  712.   target_status->traps = recv_msg_buffer->status_msg.traps;
  713.   target_status->fills = recv_msg_buffer->status_msg.fills;
  714.   target_status->spills = recv_msg_buffer->status_msg.spills;
  715.   target_status->cycles = recv_msg_buffer->status_msg.cycles;
  716. }
  717.  
  718. void
  719. Mini_unpack_read_ack_msg(mspace, address, bytecount, buffer)
  720. INT32    *mspace;
  721. ADDR32    *address;
  722. INT32    *bytecount;
  723. BYTE    *buffer;
  724. {
  725.  INT32        i;
  726.  BYTE        *s;
  727.  
  728.  /* READ_ACK received */
  729.  *mspace = recv_msg_buffer->read_ack_msg.memory_space;
  730.  if ((DebugCoreVersion >= (int) 0x13) && (*mspace == (INT32) A_SPCL_REG))
  731.    *mspace = (INT32) SPECIAL_REG;
  732.  *address = recv_msg_buffer->read_ack_msg.address;
  733.  *bytecount = recv_msg_buffer->read_ack_msg.byte_count;
  734.   s = &(recv_msg_buffer->read_ack_msg.data);
  735.   for (i = 0; i < *bytecount; i++)
  736.      *buffer++ = *s++;
  737. }
  738.  
  739. void
  740. Mini_unpack_write_ack_msg(mspace, address, bytecount)
  741. INT32    *mspace;
  742. ADDR32    *address;
  743. INT32    *bytecount;
  744. {
  745.   *mspace =recv_msg_buffer->write_ack_msg.memory_space;
  746.   if ((DebugCoreVersion >= (int) 0x13) && (*mspace == (INT32) A_SPCL_REG))
  747.      *mspace = (INT32) SPECIAL_REG;
  748.   *address =recv_msg_buffer->write_ack_msg.address;
  749.   *bytecount =recv_msg_buffer->write_ack_msg.byte_count;
  750. }
  751.  
  752. void
  753. Mini_unpack_bkpt_set_ack_msg(mspace, address, passcount, bkpt_type)
  754. INT32    *mspace;
  755. ADDR32    *address;
  756. INT32    *passcount;
  757. INT32    *bkpt_type;
  758. {
  759.   *mspace =recv_msg_buffer->bkpt_set_ack_msg.memory_space;
  760.   *address =recv_msg_buffer->bkpt_set_ack_msg.address;
  761.   *passcount =recv_msg_buffer->bkpt_set_ack_msg.pass_count;
  762.   *bkpt_type =recv_msg_buffer->bkpt_set_ack_msg.bkpt_type;
  763. }
  764.  
  765. void
  766. Mini_unpack_bkpt_rm_ack_msg(mspace, address)
  767. INT32    *mspace;
  768. ADDR32    *address;
  769. {
  770.   *mspace = recv_msg_buffer->bkpt_rm_ack_msg.memory_space;
  771.   *address = recv_msg_buffer->bkpt_rm_ack_msg.address;
  772. }
  773.  
  774. void
  775. Mini_unpack_bkpt_stat_ack_msg(mspace, address, pass_count, bkpt_type)
  776. INT32    *mspace;
  777. ADDR32    *address;
  778. INT32    *pass_count;
  779. INT32    *bkpt_type;
  780. {
  781.   *mspace = recv_msg_buffer->bkpt_stat_ack_msg.memory_space;
  782.   *address = recv_msg_buffer->bkpt_stat_ack_msg.address;
  783.   *pass_count = recv_msg_buffer->bkpt_stat_ack_msg.pass_count;
  784.   *bkpt_type = recv_msg_buffer->bkpt_stat_ack_msg.bkpt_type;
  785. }
  786.  
  787. void
  788. Mini_unpack_copy_ack_msg(srcspace, srcaddr, dstspace, dstaddr, count)
  789. INT32    *srcspace, *dstspace;
  790. ADDR32    *srcaddr, *dstaddr;
  791. INT32    *count;
  792. {
  793.   *srcspace = recv_msg_buffer->copy_ack_msg.source_space;
  794.   if ((DebugCoreVersion >= (int) 0x13) && (*srcspace == (INT32) A_SPCL_REG))
  795.    *srcspace = (INT32) SPECIAL_REG;
  796.   *srcaddr = recv_msg_buffer->copy_ack_msg.source_addr;
  797.   *dstspace = recv_msg_buffer->copy_ack_msg.dest_space;
  798.   if ((DebugCoreVersion >= (int) 0x13) && (*dstspace == (INT32) A_SPCL_REG))
  799.    *dstspace = (INT32) SPECIAL_REG;
  800.   *dstaddr = recv_msg_buffer->copy_ack_msg.dest_addr;
  801.   *count = recv_msg_buffer->copy_ack_msg.byte_count;
  802. }
  803.  
  804. void
  805. Mini_unpack_fill_ack_msg(mspace, startaddr, fillcount, pattern_cnt)
  806. INT32    *mspace;
  807. ADDR32    *startaddr;
  808. INT32    *fillcount;
  809. INT32    *pattern_cnt;
  810. {
  811.   *mspace = recv_msg_buffer->fill_ack_msg.memory_space;
  812.   if ((DebugCoreVersion >= (int) 0x13) && (*mspace == (INT32) A_SPCL_REG))
  813.     *mspace = (INT32) SPECIAL_REG;
  814.   *startaddr = recv_msg_buffer->fill_ack_msg.start_addr;
  815.   *fillcount = recv_msg_buffer->fill_ack_msg.fill_count;
  816.   *pattern_cnt = recv_msg_buffer->fill_ack_msg.byte_count;
  817. }
  818.  
  819. void
  820. Mini_unpack_init_ack_msg()
  821. {
  822.  /* No data in this message */
  823.  
  824. }
  825.  
  826. void
  827. Mini_unpack_halt_msg(mspace, pc0, pc1, trap_number)
  828. INT32    *mspace;
  829. ADDR32    *pc0;
  830. ADDR32    *pc1;
  831. INT32    *trap_number;
  832. {
  833.   *mspace = recv_msg_buffer->halt_msg.memory_space;
  834.   *pc0 = recv_msg_buffer->halt_msg.pc0;
  835.   *pc1 = recv_msg_buffer->halt_msg.pc1;
  836.   *trap_number = recv_msg_buffer->halt_msg.trap_number;
  837. }
  838.  
  839. void
  840. Mini_unpack_error_msg(errcode, mspace, address)
  841. INT32    *errcode;
  842. INT32    *mspace;
  843. ADDR32    *address;
  844. {
  845.   *errcode = recv_msg_buffer->error_msg.error_code;
  846.   *mspace = recv_msg_buffer->error_msg.memory_space;
  847.   *address = recv_msg_buffer->error_msg.address;
  848. }
  849.  
  850. void
  851. Mini_unpack_channel0_ack_msg()
  852. {
  853.  /* No data in this message */
  854. }
  855.  
  856. void
  857. Mini_unpack_channel2_msg(data, len)
  858. BYTE    *data;
  859. INT32    *len;
  860. {
  861.   INT32    i;
  862.   BYTE    *s;
  863.  
  864.   *len = recv_msg_buffer->channel2_msg.length;
  865.   s = &(recv_msg_buffer->channel2_msg.data);
  866.   for (i = 0; i < *len; i++)
  867.      *data++ = *s++;
  868. }
  869.  
  870. void
  871. Mini_unpack_channel1_msg(data, len)
  872. BYTE    *data;
  873. INT32    *len;
  874. {
  875.   INT32    i;
  876.   BYTE    *s;
  877.  
  878.   *len = recv_msg_buffer->channel1_msg.length;
  879.   s = &(recv_msg_buffer->channel1_msg.data);
  880.   for (i = 0; i < *len; i++)
  881.      *data++ = *s++;
  882. }
  883.  
  884. void    
  885. Mini_unpack_hif_msg (gr121, lr2, lr3, lr4)
  886. INT32 *gr121;
  887. INT32 *lr2;
  888. INT32 *lr3;
  889. INT32 *lr4;
  890. {  
  891.   *gr121 = recv_msg_buffer->hif_call_msg.service_number;
  892.   *lr2 = recv_msg_buffer->hif_call_msg.lr2;
  893.   *lr3 = recv_msg_buffer->hif_call_msg.lr3;
  894.   *lr4 = recv_msg_buffer->hif_call_msg.lr4;
  895. }
  896.  
  897. void    Mini_unpack_stdin_needed_msg (nbytes)
  898. INT32    *nbytes;
  899. {
  900.   *nbytes = recv_msg_buffer->stdin_needed_msg.nbytes;
  901. }
  902.  
  903. void    Mini_unpack_stdin_mode_msg (mode)
  904. INT32    *mode;
  905. {
  906.   *mode = recv_msg_buffer->stdin_mode_msg.mode;
  907. }
  908.  
  909.  
  910. /* miscellaneous */
  911.  
  912. static
  913. INT32 match_name(name)
  914. char    *name;
  915. {
  916.  int    i;
  917.  
  918.  i = 0;
  919.  while (TDF[i].target_name) {
  920.    if (strcmp(TDF[i].target_name, name))
  921.      i++;
  922.    else
  923.      return((INT32) i);
  924.  }
  925.  return(FAILURE);
  926. }
  927.  
  928. /*
  929. ** This function is used to print out a message which has
  930. ** been received from the target.
  931. */
  932.  
  933. void
  934. print_msg(msg, MsgFile)
  935.    union msg_t *msg;
  936.    FILE        *MsgFile;
  937.    {
  938.    INT32  i, j;
  939.    INT32  length;
  940.    BYTE        *s;
  941.    INT32    *hex;
  942.    INT32    code;
  943.  
  944.    hex = &(msg->generic_int32_msg.int32);
  945.    s = &(msg->generic_msg.byte);
  946.    length = msg->generic_msg.length;
  947.  
  948.    fprintf(MsgFile, "\n");
  949.    code = msg->generic_msg.code;
  950.    fprintf(MsgFile, "Code:    %ld ", code);
  951.    switch (code) {
  952.      case    RESET:
  953.     fprintf(MsgFile,"(RESET)\t");
  954.     break;
  955.      case    CONFIG_REQ:
  956.     fprintf(MsgFile,"(CONFIG_REQ)\t");
  957.     break;
  958.      case    STATUS_REQ:
  959.     fprintf(MsgFile,"(STATUS_REQ)\t");
  960.     break;
  961.      case    READ_REQ:
  962.     fprintf(MsgFile,"(READ_REQ)\t");
  963.     break;
  964.      case    WRITE_REQ:
  965.     fprintf(MsgFile,"(WRITE_REQ)\t");
  966.     break;
  967.      case    BKPT_SET:
  968.     fprintf(MsgFile,"(BKPT_SET)\t");
  969.     break;
  970.      case    BKPT_RM:
  971.     fprintf(MsgFile,"(BKPT_RM)\t");
  972.     break;
  973.      case    BKPT_STAT:
  974.     fprintf(MsgFile,"(BKPT_STAT)\t");
  975.     break;
  976.      case    COPY:
  977.     fprintf(MsgFile,"(COPY)\t");
  978.     break;
  979.      case    FILL:
  980.     fprintf(MsgFile,"(FILL)\t");
  981.     break;
  982.      case    INIT:
  983.     fprintf(MsgFile,"(INIT)\t");
  984.     break;
  985.      case    GO:
  986.     fprintf(MsgFile,"(GO)\t");
  987.     break;
  988.      case    STEP:
  989.     fprintf(MsgFile,"(STEP)\t");
  990.     break;
  991.      case    BREAK:
  992.     fprintf(MsgFile,"(BREAK)\t");
  993.     break;
  994.      case    HIF_CALL_RTN:
  995.     fprintf(MsgFile,"(HIF_CALL_RTN)\t");
  996.     break;
  997.      case    CHANNEL0:
  998.     fprintf(MsgFile,"(CHANNEL0)\t");
  999.     break;
  1000.      case    CHANNEL1_ACK:
  1001.     fprintf(MsgFile,"(CHANNEL1_ACK)\t");
  1002.     break;
  1003.      case    CHANNEL2_ACK:
  1004.     fprintf(MsgFile,"(CHANNEL2_ACK)\t");
  1005.     break;
  1006.      case    STDIN_NEEDED_ACK:
  1007.     fprintf(MsgFile,"(STDIN_NEEDED_ACK)\t");
  1008.     break;
  1009.      case    STDIN_MODE_ACK:
  1010.     fprintf(MsgFile,"(STDIN_MODE_ACK)\t");
  1011.     break;
  1012.      case    RESET_ACK:
  1013.     fprintf(MsgFile,"(RESET_ACK)\t");
  1014.     break;
  1015.      case    CONFIG:
  1016.     fprintf(MsgFile,"(CONFIG)\t");
  1017.     break;
  1018.      case    STATUS:
  1019.     fprintf(MsgFile,"(STATUS)\t");
  1020.     break;
  1021.      case    READ_ACK:
  1022.     fprintf(MsgFile,"(READ_ACK)\t");
  1023.     break;
  1024.      case    WRITE_ACK:
  1025.     fprintf(MsgFile,"(WRITE_ACK)\t");
  1026.     break;
  1027.      case    BKPT_SET_ACK:
  1028.     fprintf(MsgFile,"(BKPT_SET_ACK)\t");
  1029.     break;
  1030.      case    BKPT_RM_ACK:
  1031.     fprintf(MsgFile,"(BKPT_RM_ACK)\t");
  1032.     break;
  1033.      case    BKPT_STAT_ACK:
  1034.     fprintf(MsgFile,"(BKPT_STAT_ACK)\t");
  1035.     break;
  1036.      case    COPY_ACK:
  1037.     fprintf(MsgFile,"(COPY_ACK)\t");
  1038.     break;
  1039.      case    FILL_ACK:
  1040.     fprintf(MsgFile,"(FILL_ACK)\t");
  1041.     break;
  1042.      case    INIT_ACK:
  1043.     fprintf(MsgFile,"(INIT_ACK)\t");
  1044.     break;
  1045.      case    HALT:
  1046.     fprintf(MsgFile,"(HALT)\t");
  1047.     break;
  1048.      case    ERROR:
  1049.     fprintf(MsgFile,"(ERROR)\t");
  1050.     break;
  1051.      case    HIF_CALL:
  1052.     fprintf(MsgFile,"(HIF_CALL)\t");
  1053.     break;
  1054.      case    CHANNEL0_ACK:
  1055.     fprintf(MsgFile,"(CHANNEL0_ACK)\t");
  1056.     break;
  1057.      case    CHANNEL1:
  1058.     fprintf(MsgFile,"(CHANNEL1)\t");
  1059.     break;
  1060.      case    CHANNEL2:
  1061.     fprintf(MsgFile,"(CHANNEL2)\t");
  1062.     break;
  1063.      case    STDIN_NEEDED_REQ:
  1064.     fprintf(MsgFile,"(STDIN_NEEDED_REQ)\t");
  1065.     break;
  1066.      case    STDIN_MODE_REQ:
  1067.     fprintf(MsgFile,"(STDIN_MODE_REQ)\t");
  1068.     break;
  1069.      default:
  1070.     fprintf(MsgFile,"(unknown)\t");
  1071.     break;
  1072.    }
  1073.    fprintf(MsgFile, "Length:  %ld\n", msg->generic_msg.length);
  1074.    if ((code == CHANNEL1) || (code == CHANNEL2))
  1075.        return;
  1076.    if ((code == WRITE_REQ) || (code == FILL)) length = 20;
  1077.    if (code == READ_ACK) length = 16;
  1078.    if (code == STDIN_NEEDED_ACK) length = 16;
  1079.    for (i=0; i<((length+sizeof(INT32)-1)/sizeof(INT32)); i=i+1) {
  1080.       fprintf(MsgFile, "%08lx  (",  *hex++);
  1081.       for (j=0; j<sizeof(INT32); j=j+1)
  1082.          if (isprint(*s))
  1083.             fprintf(MsgFile, "%d", *s++);
  1084.                else
  1085.                   s++, fprintf(MsgFile, ".");
  1086.       fprintf(MsgFile, ")\n");
  1087.       }
  1088.  
  1089.    }  /* end print_msg() */
  1090.  
  1091.  
  1092.  
  1093.  
  1094. void
  1095. CopyMsgToTarg(source)
  1096. union msg_t    *source;
  1097. {
  1098.   INT32        msglen;
  1099.   INT32        count;
  1100.   char        *to, *from;
  1101.  
  1102.   send_msg_buffer->generic_msg.code = source->generic_msg.code;
  1103.   send_msg_buffer->generic_msg.length = source->generic_msg.length;
  1104.   msglen = source->generic_msg.length;
  1105.   to = (char *) &(send_msg_buffer->generic_msg.byte);
  1106.   from = (char *) &(source->generic_msg.byte);
  1107.   for (count = (INT32) 0; count < msglen; count++)
  1108.      *to++ = *from++;
  1109.  
  1110. }
  1111.  
  1112. void
  1113. CopyMsgFromTarg(dest)
  1114. union msg_t    *dest;
  1115. {
  1116.   INT32        msglen;
  1117.   INT32        count;
  1118.   char        *to, *from;
  1119.  
  1120.   dest->generic_msg.code = recv_msg_buffer->generic_msg.code;
  1121.   dest->generic_msg.length = recv_msg_buffer->generic_msg.length;
  1122.   msglen = recv_msg_buffer->generic_msg.length;
  1123.   to = (char *) &(dest->generic_msg.byte);
  1124.   from = (char *) &(recv_msg_buffer->generic_msg.byte);
  1125.   for (count = (INT32) 0; count < msglen; count++)
  1126.      *to++ = *from++;
  1127.  
  1128. }
  1129.  
  1130. void
  1131. print_recv_bytes()
  1132. {
  1133.   printf("Bytes received: \n");
  1134.   printf("0x%lx \n", (long) recv_msg_buffer->generic_msg.code);
  1135.   printf("0x%lx \n", (long) recv_msg_buffer->generic_msg.length);
  1136. }
  1137.  
  1138.