home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 9 / FreshFishVol9-CD2.bin / bbs / gnu / gdb-4.14-src.lha / gdb-4.14 / gdb / sparcl-tdep.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-31  |  19.1 KB  |  847 lines
  1. /* Target dependent code for the Fujitsu SPARClite for GDB, the GNU debugger.
  2.    Copyright 1994, 1995  Free Software Foundation, Inc.
  3.  
  4. This file is part of GDB.
  5.  
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #include "defs.h"
  21. #include "gdbcore.h"
  22. #include "breakpoint.h"
  23. #include "target.h"
  24. #include "serial.h"
  25. #include <sys/types.h>
  26. #include <sys/time.h>
  27. #include <sys/socket.h>
  28. #include <netinet/in.h>
  29. #include <netdb.h>
  30. #include <unistd.h>
  31.  
  32. extern struct target_ops sparclite_ops;    /* Forward decl */
  33. extern struct target_ops remote_ops;
  34.  
  35. static char *remote_target_name = NULL;
  36. static serial_t remote_desc = NULL;
  37. static int udp_fd = -1;
  38. static int serial_flag;
  39.  
  40. static serial_t open_tty PARAMS ((char *name));
  41. static int send_resp PARAMS ((serial_t desc, char c));
  42. static void close_tty PARAMS ((int ignore));
  43. static int recv_udp_buf PARAMS ((int fd, unsigned char *buf, int len, int timeout));
  44. static int send_udp_buf PARAMS ((int fd, unsigned char *buf, int len));
  45. static void sparclite_open PARAMS ((char *name, int from_tty));
  46. static void sparclite_close PARAMS ((int quitting));
  47. static void download PARAMS ((char *target_name, char *args, int from_tty,
  48.                   void (*write_routine) (bfd *from_bfd,
  49.                              asection *from_sec,
  50.                              file_ptr from_addr,
  51.                              bfd_vma to_addr, int len),
  52.                   void (*start_routine) (bfd_vma entry)));
  53. static void sparclite_serial_start PARAMS ((bfd_vma entry));
  54. static void sparclite_serial_write PARAMS ((bfd *from_bfd, asection *from_sec,
  55.                         file_ptr from_addr,
  56.                         bfd_vma to_addr, int len));
  57. static unsigned short calc_checksum PARAMS ((unsigned char *buffer,
  58.                          int count));
  59. static void sparclite_udp_start PARAMS ((bfd_vma entry));
  60. static void sparclite_udp_write PARAMS ((bfd *from_bfd, asection *from_sec,
  61.                      file_ptr from_addr, bfd_vma to_addr,
  62.                      int len));
  63. static void sparclite_download PARAMS ((char *filename, int from_tty));
  64.  
  65. #define DDA2_SUP_ASI        0xb000000
  66. #define DDA1_SUP_ASI        0xb0000
  67.  
  68. #define DDA2_ASI_MASK         0xff000000
  69. #define DDA1_ASI_MASK         0xff0000 
  70. #define DIA2_SUP_MODE         0x8000
  71. #define DIA1_SUP_MODE         0x4000
  72. #define DDA2_ENABLE         0x100
  73. #define DDA1_ENABLE         0x80
  74. #define DIA2_ENABLE         0x40
  75. #define DIA1_ENABLE         0x20
  76. #define DSINGLE_STEP         0x10
  77. #define DDV_TYPE_MASK         0xc
  78. #define DDV_TYPE_LOAD         0x0
  79. #define DDV_TYPE_STORE         0x4
  80. #define DDV_TYPE_ACCESS     0x8
  81. #define DDV_TYPE_ALWAYS        0xc
  82. #define DDV_COND        0x2
  83. #define DDV_MASK        0x1
  84.  
  85. int
  86. sparclite_insert_watchpoint (addr, len, type)
  87.      CORE_ADDR addr;
  88.      int len;
  89.      int type;
  90. {
  91.   CORE_ADDR dcr;
  92.  
  93.   dcr = read_register (DCR_REGNUM);
  94.  
  95.   if (!(dcr & DDA1_ENABLE))
  96.     {
  97.       write_register (DDA1_REGNUM, addr);
  98.       dcr &= ~(DDA1_ASI_MASK | DDV_TYPE_MASK);
  99.       dcr |= (DDA1_SUP_ASI | DDA1_ENABLE);
  100.       if (type == 1)
  101.     {
  102.       write_register (DDV1_REGNUM, 0);
  103.       write_register (DDV2_REGNUM, 0xffffffff);
  104.       dcr |= (DDV_TYPE_LOAD & (~DDV_COND & ~DDV_MASK));
  105.     }   
  106.       else if (type == 0)
  107.     {
  108.       write_register (DDV1_REGNUM, 0);
  109.       write_register (DDV2_REGNUM, 0xffffffff);
  110.       dcr |= (DDV_TYPE_STORE & (~DDV_COND & ~DDV_MASK));
  111.     }
  112.       else
  113.     {
  114.       write_register (DDV1_REGNUM, 0);
  115.       write_register (DDV2_REGNUM, 0xffffffff);
  116.       dcr |= (DDV_TYPE_ACCESS);
  117.     }
  118.       write_register (DCR_REGNUM, dcr);
  119.     }
  120.   else if (!(dcr & DDA2_ENABLE))
  121.     {
  122.       write_register (DDA2_REGNUM, addr);
  123.       dcr &= ~(DDA2_ASI_MASK & DDV_TYPE_MASK);
  124.       dcr |= (DDA2_SUP_ASI | DDA2_ENABLE);
  125.       if (type == 1)
  126.     {
  127.       write_register (DDV1_REGNUM, 0);
  128.       write_register (DDV2_REGNUM, 0xffffffff);
  129.       dcr |= (DDV_TYPE_LOAD & ~DDV_COND & ~DDV_MASK);
  130.     }
  131.       else if (type == 0)
  132.     {
  133.       write_register (DDV1_REGNUM, 0);
  134.       write_register (DDV2_REGNUM, 0xffffffff);
  135.       dcr |= (DDV_TYPE_STORE & ~DDV_COND & ~DDV_MASK);
  136.     }
  137.       else
  138.     {
  139.       write_register (DDV1_REGNUM, 0);
  140.       write_register (DDV2_REGNUM, 0xffffffff);
  141.       dcr |= (DDV_TYPE_ACCESS);
  142.     }
  143.       write_register (DCR_REGNUM, dcr);
  144.     }
  145.   else
  146.     return -1;
  147.  
  148.   return 0;
  149. } 
  150.  
  151. int
  152. sparclite_remove_watchpoint (addr, len, type)
  153.      CORE_ADDR addr;
  154.      int len;
  155.      int type;
  156. {
  157.   CORE_ADDR dcr, dda1, dda2;
  158.  
  159.   dcr = read_register (DCR_REGNUM);
  160.   dda1 = read_register (DDA1_REGNUM);
  161.   dda2 = read_register (DDA2_REGNUM);
  162.  
  163.   if ((dcr & DDA1_ENABLE) && addr == dda1)
  164.     write_register (DCR_REGNUM, (dcr & ~DDA1_ENABLE));
  165.   else if ((dcr & DDA2_ENABLE) && addr == dda2)
  166.     write_register (DCR_REGNUM, (dcr & ~DDA2_ENABLE));
  167.   else
  168.     return -1;
  169.  
  170.   return 0;
  171. }
  172.  
  173. int
  174. sparclite_insert_hw_breakpoint (addr, len)
  175.      CORE_ADDR addr;
  176.      int len;
  177. {
  178.   CORE_ADDR dcr;
  179.  
  180.   dcr = read_register (DCR_REGNUM);
  181.   
  182.   if (!(dcr & DIA1_ENABLE))
  183.     {
  184.       write_register (DIA1_REGNUM, addr);
  185.       write_register (DCR_REGNUM, (dcr | DIA1_ENABLE | DIA1_SUP_MODE));
  186.     }
  187.   else if (!(dcr & DIA2_ENABLE))
  188.     {
  189.       write_register (DIA2_REGNUM, addr);
  190.       write_register (DCR_REGNUM, (dcr | DIA2_ENABLE | DIA2_SUP_MODE));
  191.     }
  192.   else
  193.     return -1;
  194.  
  195.   return 0;
  196. }
  197.  
  198. int
  199. sparclite_remove_hw_breakpoint (addr, shadow)
  200.      CORE_ADDR addr;
  201.      int shadow;
  202. {
  203.   CORE_ADDR dcr, dia1, dia2;
  204.  
  205.   dcr = read_register (DCR_REGNUM);
  206.   dia1 = read_register (DIA1_REGNUM);
  207.   dia2 = read_register (DIA2_REGNUM);
  208.   
  209.   if ((dcr & DIA1_ENABLE) && addr == dia1)
  210.     write_register (DCR_REGNUM, (dcr & ~DIA1_ENABLE));
  211.   else if ((dcr & DIA2_ENABLE) && addr == dia2)
  212.     write_register (DCR_REGNUM, (dcr & ~DIA2_ENABLE));
  213.   else
  214.     return -1;
  215.  
  216.   return 0;
  217. }
  218.  
  219. int
  220. sparclite_check_watch_resources (type, cnt, ot)
  221.      int type;
  222.      int cnt;
  223.      int ot;
  224. {
  225.   if (type == bp_hardware_breakpoint)
  226.     if (TARGET_HW_BREAK_LIMIT == 0)
  227.       return 0;
  228.     else if (cnt <= TARGET_HW_BREAK_LIMIT)
  229.       return 1;
  230.   else
  231.     if (TARGET_HW_WATCH_LIMIT == 0)
  232.       return 0;
  233.     else if (ot)
  234.       return -1;
  235.     else if (cnt <= TARGET_HW_WATCH_LIMIT)
  236.       return 1;
  237.   return -1;
  238. }
  239.  
  240. CORE_ADDR
  241. sparclite_stopped_data_address ()
  242. {
  243.   CORE_ADDR dsr, dda1, dda2;
  244.  
  245.   dsr = read_register (DSR_REGNUM);
  246.   dda1 = read_register (DDA1_REGNUM);
  247.   dda2 = read_register (DDA2_REGNUM);
  248.  
  249.   if (dsr & 0x10)
  250.     return dda1;
  251.   else if (dsr & 0x20)
  252.     return dda2;
  253.   else
  254.     return 0;
  255. }
  256.  
  257. static serial_t
  258. open_tty (name)
  259.      char *name;
  260. {
  261.   serial_t desc;
  262.  
  263.   desc = SERIAL_OPEN (name);
  264.   if (!desc)
  265.     perror_with_name (name);
  266.  
  267.   if (baud_rate != -1)
  268.     {
  269.       if (SERIAL_SETBAUDRATE (desc, baud_rate))
  270.     {
  271.       SERIAL_CLOSE (desc);
  272.       perror_with_name (name);
  273.     }
  274.     }
  275.  
  276.   SERIAL_RAW (desc);
  277.  
  278.   SERIAL_FLUSH_INPUT (desc);
  279.  
  280.   return desc;
  281. }
  282.  
  283. static int
  284. send_resp (desc, c)
  285.      serial_t desc;
  286.      char c;
  287. {
  288.   int i;
  289.  
  290.   SERIAL_WRITE (desc, &c, 1);
  291.   i = SERIAL_READCHAR (desc, 2);
  292.  
  293.   if (i >= 0)
  294.     return i;
  295.  
  296.   switch (i)
  297.     {
  298.     case SERIAL_ERROR:
  299.       perror_with_name ("Remote communication error");
  300.     case SERIAL_TIMEOUT:
  301.       error ("Remote timeout");
  302.     case SERIAL_EOF:
  303.       error ("Remote connection closed");
  304.     }
  305. }
  306.  
  307. static void
  308. close_tty (ignore)
  309.      int ignore;
  310. {
  311.   if (!remote_desc)
  312.     return;
  313.  
  314.   SERIAL_CLOSE (remote_desc);
  315.  
  316.   remote_desc = NULL;
  317. }
  318.  
  319. static int
  320. recv_udp_buf (fd, buf, len, timeout)
  321.      int fd, len;
  322.      unsigned char *buf;
  323.      int timeout;
  324. {
  325.   int cc;
  326.   fd_set readfds;
  327.  
  328.   FD_ZERO (&readfds);
  329.   FD_SET (fd, &readfds);
  330.  
  331.   if (timeout >= 0)
  332.     {
  333.       struct timeval timebuf;
  334.  
  335.       timebuf.tv_sec = timeout;
  336.       timebuf.tv_usec = 0;
  337.       cc = select (fd + 1, &readfds, 0, 0, &timebuf);
  338.     }
  339.   else
  340.     cc = select (fd + 1, &readfds, 0, 0, 0);
  341.  
  342.   if (cc == 0)
  343.     return 0;
  344.  
  345.   if (cc != 1)
  346.     perror_with_name ("recv_udp_buf: Bad return value from select:");
  347.  
  348.   cc = recv (fd, buf, len, 0);
  349.  
  350.   if (cc < 0)
  351.     perror_with_name ("Got an error from recv: ");
  352. }
  353.  
  354. static int
  355. send_udp_buf (fd, buf, len)
  356.      int fd, len;
  357.      unsigned char *buf;
  358. {
  359.   int cc;
  360.  
  361.   cc = send (fd, buf, len, 0);
  362.  
  363.   if (cc == len)
  364.     return;
  365.  
  366.   if (cc < 0)
  367.     perror_with_name ("Got an error from send: ");
  368.  
  369.   error ("Short count in send: tried %d, sent %d\n", len, cc);
  370. }
  371.  
  372. static void
  373. sparclite_open (name, from_tty)
  374.      char *name;
  375.      int from_tty;
  376. {
  377.   struct cleanup *old_chain;
  378.   int c;
  379.   char *p;
  380.  
  381.   if (!name)
  382.     error ("You need to specify what device or hostname is associated with the SparcLite board.");
  383.  
  384.   target_preopen (from_tty);
  385.  
  386.   unpush_target (&sparclite_ops);
  387.  
  388.   if (remote_target_name)
  389.     free (remote_target_name);
  390.  
  391.   remote_target_name = strsave (name);
  392.  
  393.   /* We need a 'serial' or 'udp' keyword to disambiguate host:port, which can
  394.      mean either a serial port on a terminal server, or the IP address of a
  395.      SPARClite demo board.  If there's no colon, then it pretty much has to be
  396.      a local device (except for DOS... grrmble) */
  397.  
  398.   p = strchr (name, ' ');
  399.  
  400.   if (p)
  401.     {
  402.       *p++ = '\000';
  403.       while ((*p != '\000') && isspace (*p)) p++;
  404.  
  405.       if (strncmp (name, "serial", strlen (name)) == 0)
  406.     serial_flag = 1;
  407.       else if (strncmp (name, "udp", strlen (name)) == 0)
  408.     serial_flag = 0;
  409.       else
  410.     error ("Must specify either `serial' or `udp'.");
  411.     }
  412.   else
  413.     {
  414.       p = name;
  415.  
  416.       if (!strchr (name, ':'))
  417.     serial_flag = 1;    /* No colon is unambiguous (local device) */
  418.       else
  419.     error ("Usage: target sparclite serial /dev/ttyb\n\
  420. or: target sparclite udp host");
  421.     }
  422.  
  423.   if (serial_flag)
  424.     {
  425.       remote_desc = open_tty (p);
  426.  
  427.       old_chain = make_cleanup (close_tty, 0);
  428.  
  429.       c = send_resp (remote_desc, 0x00);
  430.  
  431.       if (c != 0xaa)
  432.     error ("Unknown response (0x%x) from SparcLite.  Try resetting the board.",
  433.            c);
  434.  
  435.       c = send_resp (remote_desc, 0x55);
  436.  
  437.       if (c != 0x55)
  438.     error ("Sparclite appears to be ill.");
  439.     }
  440.   else
  441.     {
  442.       struct hostent *he;
  443.       struct sockaddr_in sockaddr;
  444.       unsigned char buffer[100];
  445.       int cc;
  446.  
  447.       /* Setup the socket.  Must be raw UDP. */
  448.  
  449.       he = gethostbyname (p);
  450.  
  451.       if (!he)
  452.     error ("No such host %s.", p);
  453.  
  454.       udp_fd = socket (PF_INET, SOCK_DGRAM, 0);
  455.  
  456.       old_chain = make_cleanup (close, udp_fd);
  457.  
  458.       sockaddr.sin_family = PF_INET;
  459.       sockaddr.sin_port = htons(7000);
  460.       memcpy (&sockaddr.sin_addr.s_addr, he->h_addr, sizeof (struct in_addr));
  461.  
  462.       if (connect (udp_fd, &sockaddr, sizeof(sockaddr)))
  463.     perror_with_name ("Connect failed");
  464.  
  465.       buffer[0] = 0x5;
  466.       buffer[1] = 0;
  467.  
  468.       send_udp_buf (udp_fd, buffer, 2);    /* Request version */
  469.       cc = recv_udp_buf (udp_fd, buffer, sizeof(buffer), 5); /* Get response */
  470.       if (cc == 0)
  471.     error ("SPARClite isn't responding.");
  472.  
  473.       if (cc < 3)
  474.     error ("SPARClite appears to be ill.");
  475.     }
  476.  
  477.   printf_unfiltered ("[SPARClite appears to be alive]\n");
  478.  
  479.   push_target (&sparclite_ops);
  480.  
  481.   discard_cleanups (old_chain);
  482.  
  483.   return;
  484. }
  485.  
  486. static void
  487. sparclite_close (quitting)
  488.      int quitting;
  489. {
  490.   if (serial_flag)
  491.     close_tty (0);
  492.   else
  493.     if (udp_fd != -1)
  494.       close (udp_fd);
  495. }
  496.  
  497. #define LOAD_ADDRESS 0x40000000
  498.  
  499. static void
  500. download (target_name, args, from_tty, write_routine, start_routine)
  501.      char *target_name;
  502.      char *args;
  503.      int from_tty;
  504.      void (*write_routine)();
  505.      void (*start_routine)();
  506. {
  507.   struct cleanup *old_chain;
  508.   asection *section;
  509.   bfd *pbfd;
  510.   bfd_vma entry;
  511.   int i;
  512. #define WRITESIZE 1024
  513.   char *filename;
  514.   int quiet;
  515.   int nostart;
  516.  
  517.   quiet = 0;
  518.   nostart = 0;
  519.   filename = NULL;
  520.  
  521.   while (*args != '\000')
  522.     {
  523.       char *arg;
  524.  
  525.       while (isspace (*args)) args++;
  526.  
  527.       arg = args;
  528.  
  529.       while ((*args != '\000') && !isspace (*args)) args++;
  530.  
  531.       if (*args != '\000')
  532.     *args++ = '\000';
  533.  
  534.       if (*arg != '-')
  535.     filename = arg;
  536.       else if (strncmp (arg, "-quiet", strlen (arg)) == 0)
  537.     quiet = 1;
  538.       else if (strncmp (arg, "-nostart", strlen (arg)) == 0)
  539.     nostart = 1;
  540.       else
  541.     error ("unknown option `%s'", arg);
  542.     }
  543.  
  544.   if (!filename)
  545.     filename = get_exec_file (1);
  546.  
  547.   pbfd = bfd_openr (filename, gnutarget);
  548.   if (pbfd == NULL)
  549.     {
  550.       perror_with_name (filename);
  551.       return;
  552.     }
  553.   old_chain = make_cleanup (bfd_close, pbfd);
  554.  
  555.   if (!bfd_check_format (pbfd, bfd_object)) 
  556.     error ("\"%s\" is not an object file: %s", filename,
  557.        bfd_errmsg (bfd_get_error ()));
  558.  
  559.   for (section = pbfd->sections; section; section = section->next) 
  560.     {
  561.       if (bfd_get_section_flags (pbfd, section) & SEC_LOAD)
  562.     {
  563.       bfd_vma section_address;
  564.       bfd_size_type section_size;
  565.       file_ptr fptr;
  566.  
  567.       section_address = bfd_get_section_vma (pbfd, section);
  568.       /* Adjust sections from a.out files, since they don't
  569.          carry their addresses with.  */
  570.       if (bfd_get_flavour (pbfd) == bfd_target_aout_flavour)
  571.         section_address += LOAD_ADDRESS;
  572.  
  573.       section_size = bfd_get_section_size_before_reloc (section);
  574.  
  575.       if (!quiet)
  576.         printf_filtered ("[Loading section %s at 0x%x (%d bytes)]\n",
  577.                  bfd_get_section_name (pbfd, section),
  578.                  section_address,
  579.                  section_size);
  580.  
  581.       fptr = 0;
  582.       while (section_size > 0)
  583.         {
  584.           int count;
  585.           static char inds[] = "|/-\\";
  586.           static int k = 0;
  587.  
  588.           QUIT;
  589.  
  590.           count = min (section_size, WRITESIZE);
  591.  
  592.           write_routine (pbfd, section, fptr, section_address, count);
  593.  
  594.           if (!quiet)
  595.         {
  596.           printf_unfiltered ("\r%c", inds[k++ % 4]);
  597.           gdb_flush (gdb_stdout);
  598.         }
  599.  
  600.           section_address += count;
  601.           fptr += count;
  602.           section_size -= count;
  603.         }
  604.     }
  605.     }
  606.  
  607.   if (!nostart)
  608.     {
  609.       entry = bfd_get_start_address (pbfd);
  610.  
  611.       if (!quiet)
  612.     printf_unfiltered ("[Starting %s at 0x%x]\n", filename, entry);
  613.  
  614.       start_routine (entry);
  615.     }
  616.  
  617.   do_cleanups (old_chain);
  618. }
  619.  
  620. static void
  621. sparclite_serial_start (entry)
  622.      bfd_vma entry;
  623. {
  624.   char buffer[5];
  625.   int i;
  626.  
  627.   buffer[0] = 0x03;
  628.   store_unsigned_integer (buffer + 1, 4, entry);
  629.  
  630.   SERIAL_WRITE (remote_desc, buffer, 1 + 4);
  631.   i = SERIAL_READCHAR (remote_desc, 2);
  632.   if (i != 0x55)
  633.     error ("Can't start SparcLite.  Error code %d\n", i);
  634. }
  635.  
  636. static void
  637. sparclite_serial_write (from_bfd, from_sec, from_addr, to_addr, len)
  638.      bfd *from_bfd;
  639.      asection *from_sec;
  640.      file_ptr from_addr;
  641.      bfd_vma to_addr;
  642.      int len;
  643. {
  644.   char buffer[4 + 4 + WRITESIZE]; /* addr + len + data */
  645.   unsigned char checksum;
  646.   int i;
  647.  
  648.   store_unsigned_integer (buffer, 4, to_addr); /* Address */
  649.   store_unsigned_integer (buffer + 4, 4, len); /* Length */
  650.  
  651.   bfd_get_section_contents (from_bfd, from_sec, buffer + 8, from_addr, len);
  652.  
  653.   checksum = 0;
  654.   for (i = 0; i < len; i++)
  655.     checksum += buffer[8 + i];
  656.  
  657.   i = send_resp (remote_desc, 0x01);
  658.  
  659.   if (i != 0x5a)
  660.     error ("Bad response from load command (0x%x)", i);
  661.  
  662.   SERIAL_WRITE (remote_desc, buffer, 4 + 4 + len);
  663.   i = SERIAL_READCHAR (remote_desc, 2);
  664.   if (i < 0)
  665.     error ("I/O error in serial code.  Return code %d\n", i);
  666.  
  667.   if (i != checksum)
  668.     error ("Bad checksum from load command (0x%x)", i);
  669. }
  670.  
  671. static unsigned short
  672. calc_checksum (buffer, count)
  673.      unsigned char *buffer;
  674.      int count;
  675. {
  676.   unsigned short checksum;
  677.  
  678.   checksum = 0;
  679.   for (; count > 0; count -= 2, buffer += 2)
  680.     checksum += (*buffer << 8) | *(buffer + 1);
  681.  
  682.   if (count != 0)
  683.     checksum += *buffer << 8;
  684.  
  685.   return checksum;
  686. }
  687.  
  688. static void
  689. sparclite_udp_start (entry)
  690.      bfd_vma entry;
  691. {
  692.   unsigned char buffer[6];
  693.   int i;
  694.  
  695.   buffer[0] = 0x3;
  696.   buffer[1] = 0;
  697.   buffer[2] = entry >> 24;
  698.   buffer[3] = entry >> 16;
  699.   buffer[4] = entry >> 8;
  700.   buffer[5] = entry;
  701.  
  702.   send_udp_buf (udp_fd, buffer, 6); /* Send start addr */
  703.   i = recv_udp_buf (udp_fd, buffer, sizeof(buffer), -1); /* Get response */
  704.  
  705.   if (i < 1 || buffer[0] != 0x55)
  706.     error ("Failed to take start address.");
  707. }
  708.  
  709. static void
  710. sparclite_udp_write (from_bfd, from_sec, from_addr, to_addr, len)
  711.      bfd *from_bfd;
  712.      asection *from_sec;
  713.      file_ptr from_addr;
  714.      bfd_vma to_addr;
  715.      int len;
  716. {
  717.   unsigned char buffer[2000];
  718.   unsigned short checksum;
  719.   static int pkt_num = 0;
  720.   static unsigned long old_addr = -1;
  721.   int i;
  722.  
  723.   while (1)
  724.     {
  725.       if (to_addr != old_addr)
  726.     {
  727.       buffer[0] = 0x1;    /* Load command */
  728.       buffer[1] = 0x1;    /* Loading address */
  729.       buffer[2] = to_addr >> 24;
  730.       buffer[3] = to_addr >> 16;
  731.       buffer[4] = to_addr >> 8;
  732.       buffer[5] = to_addr;
  733.  
  734.       checksum = 0;
  735.       for (i = 0; i < 6; i++)
  736.         checksum += buffer[i];
  737.       checksum &= 0xff;
  738.  
  739.       send_udp_buf (udp_fd, buffer, 6);
  740.       i = recv_udp_buf (udp_fd, buffer, sizeof buffer, -1);
  741.  
  742.       if (i < 1)
  743.         error ("Got back short checksum for load addr.");
  744.  
  745.       if (checksum != buffer[0])
  746.         error ("Got back bad checksum for load addr.");
  747.  
  748.       pkt_num = 0;        /* Load addr resets packet seq # */
  749.       old_addr = to_addr;
  750.     }
  751.  
  752.       bfd_get_section_contents (from_bfd, from_sec, buffer + 6, from_addr,
  753.                 len);
  754.  
  755.       checksum = calc_checksum (buffer + 6, len);
  756.  
  757.       buffer[0] = 0x1;        /* Load command */
  758.       buffer[1] = 0x2;        /* Loading data */
  759.       buffer[2] = pkt_num >> 8;
  760.       buffer[3] = pkt_num;
  761.       buffer[4] = checksum >> 8;
  762.       buffer[5] = checksum;
  763.  
  764.       send_udp_buf (udp_fd, buffer, len + 6);
  765.       i = recv_udp_buf (udp_fd, buffer, sizeof buffer, 3);
  766.  
  767.       if (i == 0)
  768.     {
  769.       fprintf_unfiltered (gdb_stderr, "send_data: timeout sending %d bytes to address 0x%x retrying\n", len, to_addr);
  770.       continue;
  771.     }
  772.  
  773.       if (buffer[0] != 0xff)
  774.     error ("Got back bad response for load data.");
  775.  
  776.       old_addr += len;
  777.       pkt_num++;
  778.  
  779.       return;
  780.     }
  781. }
  782.  
  783. static void
  784. sparclite_download (filename, from_tty)
  785.      char *filename;
  786.      int from_tty;
  787. {
  788.   if (!serial_flag)
  789.     download (remote_target_name, filename, from_tty, sparclite_udp_write,
  790.           sparclite_udp_start);
  791.   else
  792.     download (remote_target_name, filename, from_tty, sparclite_serial_write,
  793.           sparclite_serial_start);
  794. }
  795.  
  796. /* Define the target subroutine names */
  797.  
  798. static struct target_ops sparclite_ops =
  799. {
  800.   "sparclite",            /* to_shortname */
  801.   "SPARClite remote target",    /* to_longname */
  802.   "Use a remote SPARClite target board via a serial line, using a gdb-specific protocol.\n\
  803. Specify the serial device it is connected to (e.g. /dev/ttya).",  /* to_doc */
  804.   sparclite_open,        /* to_open */
  805.   sparclite_close,        /* to_close */
  806.   0,                /* to_attach */
  807.   0,                /* to_detach */
  808.   0,                /* to_resume */
  809.   0,                /* to_wait */
  810.   0,                /* to_fetch_registers */
  811.   0,                /* to_store_registers */
  812.   0,                /* to_prepare_to_store */
  813.   0,                /* to_xfer_memory */
  814.   0,                /* to_files_info */
  815.   0,                /* to_insert_breakpoint */
  816.   0,                /* to_remove_breakpoint */
  817.   0,                /* to_terminal_init */
  818.   0,                /* to_terminal_inferior */
  819.   0,                /* to_terminal_ours_for_output */
  820.   0,                /* to_terminal_ours */
  821.   0,                /* to_terminal_info */
  822.   0,                /* to_kill */
  823.   sparclite_download,        /* to_load */
  824.   0,                /* to_lookup_symbol */
  825.   0,                /* to_create_inferior */
  826.   0,                /* to_mourn_inferior */
  827.   0,                /* to_can_run */
  828.   0,                /* to_notice_signals */
  829.   0,                /* to_stop */
  830.   process_stratum,        /* to_stratum */
  831.   0,                /* to_next */
  832.   0,                /* to_has_all_memory */
  833.   0,                /* to_has_memory */
  834.   0,                /* to_has_stack */
  835.   0,                /* to_has_registers */
  836.   0,                /* to_has_execution */
  837.   0,                /* sections */
  838.   0,                /* sections_end */
  839.   OPS_MAGIC            /* to_magic */
  840.   };
  841.  
  842. void
  843. _initialize_sparcl_tdep ()
  844. {
  845.   add_target (&sparclite_ops);
  846. }
  847.