gdb/sparcl-tdep.c

   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 \f
 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 \f
 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 }