--- /dev/null
+/* Remote debugging with the XLNT Designs, Inc (XDI) NetROM.
+ Copyright 1990, 1991, 1992, 1995 Free Software Foundation, Inc.
+ Contributed by:
+ Roger Moyers
+ XLNT Designs, Inc.
+ 15050 Avenue of Science, Suite 106
+ San Diego, CA 92128
+ (619)487-9320
+ roger@xlnt.com
+ Adapted from work done at Cygnus Support in remote-nindy.c,
+ later merged in by Stan Shebs at Cygnus.
+
+This file is part of GDB.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include "defs.h"
+#include "gdbcmd.h"
+#include <string.h>
+#include "inferior.h"
+#include "wait.h"
+#include "value.h"
+#include <ctype.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <errno.h>
+#include <stropts.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <unistd.h>
+#include "terminal.h"
+#include "target.h"
+#include "gdbcore.h"
+
+/* Packet header found on every packet sent to/from GDB. */
+
+typedef struct gpkthdr {
+ unsigned char csum; /* Check sum */
+ unsigned char seq_num; /* Sequence number */
+ unsigned short len; /* Number of bytes in packet */
+ unsigned char cmd; /* GDB command */
+ unsigned char pad[3];
+ unsigned long addr; /* Address if needed */
+ unsigned long datalen; /* # of bytes to read/write */
+} GPKTHDR;
+
+#define GDB_START_DELIMITER '['
+#define GDB_END_DELIMITER ']'
+
+/* GDB requests. */
+
+#define GDB_QUERY_CMD 0x01
+#define GDB_STATUS 0x02
+#define GDB_READ_REGS 0x03
+#define GDB_WRITE_REGS 0x04
+#define GDB_READ_MEM 0x05
+#define GDB_WRITE_MEM 0x06
+#define GDB_CONTINUE 0x07
+#define GDB_STEP 0x08
+
+/* Responses. */
+
+#define GDB_ACK 0x11
+#define GDB_NACK 0x12
+#define GDB_READ_REG_RESP 0x13
+#define GDB_READ_MEM_RESP 0x14
+#define GDB_WRITE_REG_RESP 0x15
+#define GDB_WRITE_MEM_RESP 0x16
+
+#define GDB_BP_TRAP "05"
+#define GDB_BUSERR_TRAP "10"
+#define GDB_ILLOP_TRAP "40"
+
+#define GDB_ACK_VALUE "OK"
+
+/* Default ports used to talk with the NetROM. */
+
+#define DEFAULT_NETROM_TARGET_PORT 1235
+#define DEFAULT_NETROM_LOAD_PORT 1236
+#define DEFAULT_NETROM_CONTROL_PORT 1237
+
+#define UC(b) (((long)b)&0xff)
+
+#define NROM_BUF_SIZE 2048
+#define MAX_SEND_ATTEMPTS 10
+#define READ_BUF_SIZE 2048
+
+/* Definitions for filetype. */
+
+#define BINARY_FTYPE 0
+#define MOTO_SREC 1
+#define INTEL_HEX 2
+
+#if 0 /* for debugging, if anyone cares */
+static char *GCMDTYPE[] = {
+ "ZERO",
+ "GDB_QUERY",
+ "GDB_STATUS",
+ "GDB_READ_REGS",
+ "GDB_WRITE_REGS",
+ "GDB_READ_MEM",
+ "GDB_WRITE_MEM",
+ "GDB_CONTINUE",
+ "GDB_STEP",
+ "CMD9",
+ "CMDA",
+ "CMDB",
+ "CMDC",
+ "CMDD",
+ "CMDE",
+ "CMDF",
+ "RESP0",
+ "GDB_ACK",
+ "GDB_NACK",
+ "GDB_READ_REG_RESP",
+ "GDB_READ_MEM_RESP",
+ "GDB_WRITE_REG_RESP",
+ "GDB_WRITE_MEM_RESP"
+};
+#endif
+
+static void nrom_attach PARAMS ((char *, int));
+
+static int nrom_can_run PARAMS ((void));
+
+static void nrom_close PARAMS ((int));
+
+static void nrom_create_inferior PARAMS ((char *, char *, char **));
+
+static void nrom_detach PARAMS ((char *, int));
+
+static void nrom_fetch_registers PARAMS ((int));
+
+static void nrom_files_info PARAMS ((struct target_ops *));
+
+static void nrom_kill PARAMS ((void));
+
+static void nrom_load PARAMS ((char *, int));
+
+static void nrom_mourn PARAMS ((void));
+
+static void nrom_open PARAMS ((char *,int));
+
+static void nrom_resume PARAMS ((int, int, enum target_signal));
+
+static void nrom_prepare_to_store PARAMS ((void));
+
+static void nrom_store_registers PARAMS ((int));
+
+static int nrom_wait PARAMS ((int pid, struct target_waitstatus *status));
+
+static int nrom_xfer_inferior_memory PARAMS ((CORE_ADDR, char *, int, int,
+ struct target_ops *));
+
+static int nrom_write_inferior_memory PARAMS ((CORE_ADDR, char *, int));
+
+static int nrom_read_inferior_memory PARAMS ((CORE_ADDR, char *, int));
+
+/* New commands. */
+
+static void nrom_set_target_port PARAMS ((char *, int));
+
+static void nrom_set_control_port PARAMS ((char *, int));
+
+static void nrom_set_load_port PARAMS ((char *, int));
+
+static void nrom_set_ipaddr PARAMS ((char *, int));
+
+static void nrom_set_filetype PARAMS ((char *, int));
+
+static void nrom_show_status PARAMS ((char *, int));
+
+static void nrom_passthru PARAMS ((char *, int));
+
+/* Packet functions. */
+
+static void build_pkt PARAMS ((int, unsigned char *, long,
+ unsigned char *, unsigned long, unsigned long,
+ int));
+
+static int compute_csum PARAMS ((unsigned char *, int));
+
+#if 0
+static void dump_pkt PARAMS ((GPKTHDR *, unsigned char *));
+#endif
+
+static int get_seq_number PARAMS ((void));
+
+static char *hex2mem PARAMS ((char *, char *, int));
+
+static char *mem2hex PARAMS ((char *, char *, int));
+
+static void nrom_send PARAMS ((int, char *, int, long, long, char *));
+
+static void send_query_cmd PARAMS ((void));
+
+static int send_pkt PARAMS ((int, char *, int, long, int));
+
+static int read_pkt PARAMS ((char *));
+
+static void send_query_cmd PARAMS ((void));
+
+static int tohex PARAMS ((int));
+
+static int parse_pkt PARAMS ((unsigned char *, GPKTHDR *, char *));
+
+static int writen PARAMS ((int, char *, int));
+
+/* Private globals. */
+
+/* We talk to the NetROM over these sockets. */
+
+static int nrom_load_sock = -1;
+static int nrom_targ_sock = -1;
+static int nrom_ctrl_sock = -1;
+
+/* For binding to the socket we ned a sockaddr_in structure. */
+
+static struct sockaddr_in nrom_sin;
+
+/* The IP Address of the NetROM is needed so we know who to talk to. */
+
+static unsigned long nrom_ipaddr = 0;
+
+static int load_port = DEFAULT_NETROM_LOAD_PORT;
+static int target_port = DEFAULT_NETROM_TARGET_PORT;
+static int control_port = DEFAULT_NETROM_CONTROL_PORT;
+
+static int nrom_filetype = BINARY_FTYPE;
+
+static unsigned char host_seq_num = 0;
+
+static char hexchars[] = "0123456789abcdef";
+
+static char freadbuf[READ_BUF_SIZE];
+
+static char readbuf[NROM_BUF_SIZE];
+static int bufdata = 0;
+static int bufindex = 0;
+
+static char workbuf[NROM_BUF_SIZE];
+static char sendbuf[NROM_BUF_SIZE];
+
+/* Forward data declaration. */
+
+extern struct target_ops nrom_ops;
+
+/* This routine builds a packet to send to gdb running on the host. */
+
+static void
+build_pkt (cmd, data, datalen, pkt, addr, len, seq)
+ int cmd;
+ unsigned char *data;
+ long datalen;
+ unsigned char *pkt;
+ unsigned long addr;
+ unsigned long len;
+ int seq;
+{
+ GPKTHDR phdr;
+ char *dptr;
+ char *pktptr;
+ unsigned char csum;
+ int plen;
+
+ phdr.csum = 0;
+ phdr.len = sizeof(GPKTHDR) + datalen;
+ phdr.seq_num = seq;
+ phdr.cmd = cmd;
+ phdr.pad[0] = phdr.pad[1] = phdr.pad[2] = 0;
+ phdr.addr = addr;
+ phdr.datalen = len;
+ /* Convert packet header to ASCII. */
+ dptr = mem2hex ((char *) &phdr, pkt, sizeof(GPKTHDR));
+
+ /* Calculate pkt length now that it is converted. */
+ plen = (int) ((unsigned long)dptr - (unsigned long)pkt) + datalen;
+ /* Put data in packet. */
+ if (datalen > 0)
+ memcpy (dptr, data, datalen);
+
+ /* Compute checksum. For computing checksum we skip first two bytes
+ since this is where the checksum will go. */
+ pktptr = pkt + 2;
+ csum = compute_csum (pktptr, plen - 2);
+ *pkt++ = hexchars[csum >> 4];
+ *pkt++ = hexchars[csum % 16];
+ dptr += datalen;
+ *dptr = '\0';
+}
+
+static int
+compute_csum (data, len)
+ unsigned char *data;
+ int len;
+{
+ unsigned char csum;
+
+ csum = 0;
+ while (len > 0)
+ {
+ csum += *data++;
+ --len;
+ }
+ return csum;
+}
+
+#if 0 /* for debugging, if anyone cares */
+static void
+dump_pkt (hdr, data)
+ GPKTHDR *hdr;
+ unsigned char *data;
+{
+ int i;
+
+ printf_filtered ("PACKET: csum = %x,seq = %d,len = %d\n",hdr->csum,hdr->seq_num,
+ hdr->len);
+
+ printf_filtered ("cmd = %s,addr = %x, datalen = %d\n", GCMDTYPE[hdr->cmd],
+ hdr->addr,hdr->datalen);
+ if (hdr->datalen)
+ {
+ for (i = 0; i < hdr->datalen * 2; i++)
+ printf_filtered ("%x",data[i]);
+ printf_filtered ("\n");
+ }
+}
+#endif
+
+static int
+get_seq_number()
+{
+ return host_seq_num++;
+}
+
+int
+hex (ch)
+ int ch;
+{
+ if ((ch >= 'a') && (ch <= 'f'))
+ return (ch - 'a' + 10);
+ if((ch >= 'A') && (ch <= 'F'))
+ return ((ch - 'A') + 10);
+ if ((ch >= '0') && (ch <= '9'))
+ return (ch - '0');
+ return 0;
+}
+
+/* Convert the hex array pointed to by buf into binary to be placed in mem
+ return a pointer to the character AFTER the last byte written. */
+
+static char*
+hex2mem(buf, mem, count)
+ char* buf;
+ char* mem;
+ int count;
+{
+ int i;
+ unsigned char ch;
+
+ for (i = 0; i < count; i++)
+ {
+ ch = hex(*buf++) << 4;
+ ch = ch + hex(*buf++);
+ *mem++ = ch;
+ }
+ return mem;
+}
+
+/* Convert the memory pointed to by mem into hex, placing result in buf
+ return a pointer to the last char put in buf (null) */
+
+static char *
+mem2hex (mem, buf, count)
+ char* mem;
+ char* buf;
+ int count;
+{
+ int i;
+ unsigned char ch;
+
+ for (i = 0; i < count; i++)
+ {
+ ch = *mem++;
+ *buf++ = hexchars[ch >> 4];
+ *buf++ = hexchars[ch % 16];
+ }
+ *buf = 0;
+ return buf;
+}
+
+static int
+nrom_control_send (s, nbytes)
+ char *s;
+ int nbytes;
+{
+ long len;
+ char buf[10];
+
+ /* clear leading characters */
+ /* FIXME: The ioctl uses here seem bogus to me. -sts */
+ len = 1;
+ while (len > 0)
+ {
+ if (ioctl (nrom_ctrl_sock, FIONREAD, &len) < 0)
+ {
+ perror ("nrom_control_send ioctl");
+ return (-1);
+ }
+ if (len > 0)
+ {
+ if (read (nrom_ctrl_sock, buf, 1) < 0)
+ {
+ perror ("nrom_control_send read");
+ return (-1);
+ }
+ }
+ }
+
+ if (remote_debug)
+ printf_filtered ("nrom_control_send: sending '%s' (%d bytes) to NetROM\n",
+ s, nbytes);
+
+ if (writen (nrom_ctrl_sock, s, nbytes) < 0)
+ {
+ perror ("nrom_control_send");
+ return (-1);
+ }
+
+ /* clear trailing characters */
+ len = 1;
+ while (len > 0)
+ {
+ if (ioctl (nrom_ctrl_sock, FIONREAD, &len) < 0)
+ {
+ perror ("nrom_control_send ioctl");
+ return (-1);
+ }
+ if (len > 0)
+ {
+ if (read (nrom_ctrl_sock, buf, 1) < 0)
+ {
+ perror ("nrom_control_send read");
+ return (-1);
+ }
+ }
+ }
+ return 0;
+}
+
+static void
+nrom_kill ()
+{
+}
+
+/* Download a file specified in ARGS to the netROM. */
+
+static void
+nrom_load (args, fromtty)
+ char *args;
+ int fromtty;
+{
+ int fd, rd_amt, fsize;
+ struct sockaddr_in sin;
+ bfd *pbfd;
+ asection *section;
+ char *downloadstring = "download 0\n";
+
+ /* Tell the netrom to get ready to download. */
+ if (nrom_control_send (downloadstring, strlen (downloadstring)) < 0)
+ error ("nrom_load: control_send() of `%s' failed", downloadstring);
+
+ /* Wait for the download daemon to start up. */
+ sleep (1);
+
+ nrom_load_sock = socket (AF_INET, SOCK_STREAM, 0);
+ if (nrom_load_sock == -1)
+ error ("Could not create download socket, error %d", errno);
+
+ memset (&sin, 0, sizeof(struct sockaddr_in));
+ sin.sin_family = AF_INET;
+ sin.sin_port = htons (load_port);
+ sin.sin_addr.s_addr = htonl (nrom_ipaddr);
+
+ if (connect (nrom_load_sock, &sin, sizeof(sin)) == -1)
+ error ("Connect failed, error %d", errno);
+
+ pbfd = bfd_openr (args, 0);
+
+ if (pbfd)
+ {
+ if (!bfd_check_format (pbfd, bfd_object))
+ error ("\"%s\": not in executable format: %s",
+ args, bfd_errmsg (bfd_get_error ()));
+
+ for (section = pbfd->sections; section; section = section->next)
+ {
+ if (bfd_get_section_flags (pbfd, section) & SEC_ALLOC)
+ {
+ bfd_vma section_address;
+ unsigned long section_size;
+ const char *section_name;
+
+ section_name = bfd_get_section_name (pbfd, section);
+ section_address = bfd_get_section_vma (pbfd, section);
+ section_size = bfd_section_size (pbfd, section);
+
+ if (bfd_get_section_flags (pbfd, section) & SEC_LOAD)
+ {
+ file_ptr fptr;
+
+ printf_filtered ("[Loading section %s at %x (%d bytes)]\n",
+ section_name, section_address,
+ section_size);
+
+ fptr = 0;
+
+ while (section_size > 0)
+ {
+ char buffer[1024];
+ int count;
+
+ count = min (section_size, 1024);
+
+ bfd_get_section_contents (pbfd, section, buffer, fptr,
+ count);
+
+ writen (nrom_load_sock, buffer, count);
+ section_address += count;
+ fptr += count;
+ section_size -= count;
+ }
+ }
+ else /* BSS and such */
+ {
+ printf_filtered ("[section %s: not loading]\n",
+ section_name);
+ }
+ }
+ }
+ }
+ else
+ error ("\"%s\": Could not open", args);
+
+ close (nrom_load_sock);
+}
+
+/* This is called not only when we first attach, but also when the
+ user types "run" after having attached. */
+
+static void
+nrom_create_inferior (execfile, args, env)
+ char *execfile;
+ char *args;
+ char **env;
+{
+}
+
+/* Open a connection to the remote NetROM devices. */
+
+static void
+nrom_open (name, from_tty)
+ char *name;
+ int from_tty;
+{
+ int errn;
+
+ if (name)
+ nrom_set_ipaddr (name, from_tty);
+ else if (nrom_ipaddr == 0)
+ error (
+"To open a NetROM connection, you must specify the hostname\n\
+or IP address of the NetROM device you wish to use.");
+
+ push_target (&nrom_ops);
+
+ /* Create the socket used for talking with the target. */
+ nrom_targ_sock = socket (AF_INET, SOCK_STREAM, 0);
+
+ /* Bind the socket. */
+ nrom_sin.sin_family = AF_INET;
+ nrom_sin.sin_port = htons (target_port);
+ nrom_sin.sin_addr.S_un.S_addr = htonl (nrom_ipaddr);
+
+ /* Connect to the remote host. */
+ if (connect (nrom_targ_sock, &nrom_sin, sizeof(nrom_sin)) == -1)
+ error ("Connect failed, error %d", errno);
+
+ /* Create the socket used for talking with the debugger services. */
+ nrom_ctrl_sock = socket (AF_INET, SOCK_STREAM, 0);
+
+ /* Bind the socket. */
+ nrom_sin.sin_family = AF_INET;
+ nrom_sin.sin_port = htons (control_port);
+ nrom_sin.sin_addr.S_un.S_addr = htonl (nrom_ipaddr);
+
+ /* Connect to the remote host. */
+ if (connect (nrom_ctrl_sock, &nrom_sin, sizeof(nrom_sin)) == -1)
+ {
+ errn = errno;
+ close (nrom_targ_sock);
+ error ("Connect control_socket failed, error %d", errn);
+ }
+
+ if (from_tty)
+ {
+ unsigned char *i;
+
+ printf_filtered ("Connected to NetROM device \"%s\"", name);
+ i = (unsigned char *) &nrom_ipaddr;
+ printf_filtered (" (%d.%d.%d.%d)\n",
+ UC(i[0]), UC(i[1]), UC(i[2]), UC(i[3]));
+ }
+}
+
+static int
+nrom_can_run ()
+{
+ return 1;
+}
+
+/* Close out all files and local state before this target loses control. */
+
+static void
+nrom_close (quitting)
+ int quitting;
+{
+}
+
+/* Attach to the target that is already loaded and possibly running */
+
+static void
+nrom_attach (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ int nwaiting;
+ char buf[10];
+
+ if (from_tty)
+ printf_filtered ("Attaching to NetROM\n");
+
+ /* clear any pending data on the socket */
+ printf_filtered ("Waiting for pending data to arrive... ");
+ fflush(stdout);
+ sleep(1);
+ printf_filtered ("that's long enough!\n");
+ while (1)
+ {
+ if (ioctl(nrom_targ_sock, FIONREAD, &nwaiting) != 0)
+ {
+ /* couldn't determine data left */
+ perror("nrom_attach: ioctl FIONREAD");
+ break;
+ }
+ else if (nwaiting > 0)
+ {
+ /* flush incoming data */
+ while (nwaiting != 0)
+ {
+ if (read (nrom_targ_sock, buf, 1) < 0)
+ {
+ perror("nrom_attach: read");
+ exit(1);
+ }
+ if (remote_debug > 2)
+ putc(buf[0], stdout);
+ nwaiting--;
+ }
+ }
+ else
+ {
+ /* no more data */
+ break;
+ }
+ }
+ printf_filtered ("Pending data removed\n");
+
+ /* We will get a task spawn event immediately. */
+ send_query_cmd ();
+ target_has_execution = 1;
+/*
+ start_remote();
+*/
+}
+
+/* Terminate the open connection to the remote debugger. Use this
+ when you want to detach and do something else with your gdb. */
+
+static void
+nrom_detach (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ pop_target ();
+ if (from_tty)
+ printf_filtered ("Ending remote debugging\n");
+}
+
+/* Tell the remote machine to resume. */
+
+static void
+nrom_prepare_to_store()
+{
+}
+
+static void
+nrom_resume (pid, step, siggnal)
+ int pid, step;
+ enum target_signal siggnal;
+{
+ if (step)
+ send_pkt (GDB_STEP, NULL, 0, 0, 0);
+ else
+ send_pkt (GDB_CONTINUE, NULL, 0, 0, 0);
+}
+
+/* Wait until the remote machine stops, then return,
+ storing status in STATUS just as `wait' would. */
+
+static int
+nrom_wait (pid, status)
+ int pid;
+ struct target_waitstatus *status;
+{
+ static char pkt[NROM_BUF_SIZE], inbuf[NROM_BUF_SIZE];
+ GPKTHDR phdr;
+
+ status->kind = TARGET_WAITKIND_EXITED;
+ status->value.integer = 0;
+
+ while (1)
+ {
+ if (read_pkt (pkt) == -1)
+ continue;
+
+ if (parse_pkt (pkt, &phdr, inbuf) < 0)
+ {
+ if (remote_debug)
+ printf_filtered ("Bad packet in nrom_wait\n");
+ send_query_cmd ();
+ continue;
+ }
+
+ /* Got good packet. Verify command is right. */
+ if (phdr.cmd != GDB_STATUS)
+ {
+ /* Wrong response. Resend command. */
+ send_query_cmd ();
+ continue;
+ }
+ /* Packet is fine. Exit loop. */
+ return inferior_pid;
+ }
+}
+
+/* Read the remote registers. */
+
+static void
+nrom_fetch_registers (regno)
+ int regno;
+{
+ char buf[NROM_BUF_SIZE];
+ char regs[REGISTER_BYTES];
+ int i;
+
+#ifdef DEBUG
+ printf_filtered ("reg no is %d\n",regno);
+#endif
+
+ nrom_send (GDB_READ_REGS, NULL, 0, -1, 0, buf);
+ memcpy (regs, buf, REGISTER_BYTES);
+ for (i = 0; i < NUM_REGS; i++)
+ supply_register (i, ®s[REGISTER_BYTE(i)]);
+#ifdef NO_SINGLE_REG
+ nrom_send (GDB_READ_REGS, NULL, 0, regno, 0, buf);
+ if (regno != -1)
+ supply_register(regno,buf);
+ else
+ {
+ memcpy (regs, buf, REGISTER_BYTES);
+ for (i = 0; i < NUM_REGS; i++)
+ supply_register (i, ®s[REGISTER_BYTE(i)]);
+ }
+#endif
+}
+
+static void
+nrom_send (cmd, data, datalen, addr, len, resp)
+ int cmd;
+ char *data;
+ int datalen;
+ long addr;
+ long len;
+ char *resp;
+{
+ GPKTHDR phdr;
+ char inbuf[NROM_BUF_SIZE];
+
+ while (1)
+ {
+ while (send_pkt (cmd, data, datalen, addr, len) < 0)
+ ;
+ if (read_pkt (inbuf) != -1)
+ {
+ if (parse_pkt (inbuf, &phdr, resp) < 0)
+ continue;
+ if (phdr.cmd != GDB_NACK)
+ return;
+ }
+ }
+}
+
+static void
+nrom_set_filetype (args, fromtty)
+ char *args;
+ int fromtty;
+{
+ if (args[0] == 'b')
+ nrom_filetype = BINARY_FTYPE;
+ else if (args[0] == 'm')
+ nrom_filetype = MOTO_SREC;
+ else if (args[0] == 'i')
+ nrom_filetype = INTEL_HEX;
+ else
+ printf_filtered ("Unknown file type\n");
+}
+
+static void
+nrom_set_ipaddr (args, fromtty)
+ char *args;
+ int fromtty;
+{
+ struct hostent *h;
+ char buf[10];
+ int i,j,val;
+ unsigned long newip = 0;
+
+ /* First do a check to see if they typed in a hostname. */
+ if (!(*args))
+ error ("Please enter a hostname or IP address");
+
+ h = gethostbyname (args);
+ if (h)
+ {
+ /* It is a hostname. We just need the ipaddress. */
+ memcpy (&nrom_ipaddr, h->h_addr, h->h_length);
+ }
+ else
+ {
+ /* Better be in decimal dot notation,ie. xx.xx.xx.xx */
+ if (isdigit (args[0]) && strchr (args, '.'))
+ {
+ j = 4;
+ while (j)
+ {
+ memset (buf, 0, 10);
+ i = 0;
+ while((*args) && (*args != '.'))
+ {
+ buf[i] = *args++;
+ i++;
+ }
+ if (i)
+ {
+ val = (int) strtol (buf, NULL, 10);
+
+ if (val > 255)
+ error ("Invalid IP address");
+
+ j--;
+ newip |= val << (8 * j);
+ args++;
+ }
+ }
+ }
+ else
+ {
+ error ("Invalid host name/address");
+ }
+ nrom_ipaddr = newip;
+ }
+}
+
+static void
+nrom_set_load_port (args, fromtty)
+ char *args;
+ int fromtty;
+{
+ load_port = (int) strtol (args, NULL, 10);
+}
+
+static void
+nrom_set_target_port (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ target_port = (int) strtol (args, NULL, 10);
+}
+
+static void
+nrom_set_control_port (args, fromtty)
+ char *args;
+ int fromtty;
+{
+ control_port = (int) strtol (args, NULL, 10);
+}
+
+static void
+nrom_show_status (args,from_tty)
+ char *args;
+ int from_tty;
+{
+ unsigned char *i;
+
+ i = (unsigned char *)&nrom_ipaddr;
+
+ printf_filtered ("NetROM target port is %d\n", target_port);
+ printf_filtered ("NetROM download port is %d\n", load_port);
+ printf_filtered ("NetROM debug control port is %d\n", control_port);
+
+ printf_filtered ("NetROM IP Address is %d.%d.%d.%d\n",
+ UC(i[0]), UC(i[1]), UC(i[2]), UC(i[3]));
+ if (nrom_filetype == BINARY_FTYPE)
+ printf_filtered ("download filetype is binary\n");
+ else if (nrom_filetype == MOTO_SREC)
+ printf_filtered ("download filetype is moto-srec\n");
+ else if (nrom_filetype == INTEL_HEX)
+ printf_filtered ("download filetype is intel-hex\n");
+}
+
+/* Pass arguments directly to the NetROM. */
+
+static void
+nrom_passthru (args, fromtty)
+ char *args;
+ int fromtty;
+{
+ char buf[1024];
+
+ sprintf(buf, "%s\n", args);
+ if (nrom_control_send (buf, strlen (buf)) < 0)
+ error ("nrom_reset: control_send() of `%s'failed", args);
+}
+
+static void
+nrom_store_registers (regno)
+int regno;
+{
+ char buf[NROM_BUF_SIZE];
+ int i;
+ char *p;
+
+ p = buf;
+ for (i = 0; i < REGISTER_BYTES; i++)
+ {
+ *p++ = tohex ((registers[i] >> 4) & 0xf);
+ *p++ = tohex (registers[i] & 0xf);
+ }
+ *p = '\0';
+ nrom_send (GDB_WRITE_REGS, buf, REGISTER_BYTES * 2, 0, REGISTER_BYTES * 2,
+ buf);
+}
+
+static int
+nrom_xfer_inferior_memory (memaddr, myaddr, len, write, target)
+ CORE_ADDR memaddr;
+ char *myaddr;
+ int len;
+ int write;
+ struct target_ops *target;
+{
+ if (write)
+ return nrom_write_inferior_memory (memaddr, myaddr, len);
+ else
+ return nrom_read_inferior_memory (memaddr, myaddr, len);
+}
+
+/* Copy LEN bytes of data from debugger memory at MYADDR
+ to inferior's memory at MEMADDR. Returns errno value. */
+
+static int
+nrom_write_inferior_memory (memaddr, myaddr, len)
+ CORE_ADDR memaddr;
+ char *myaddr;
+ int len;
+{
+ char buf[NROM_BUF_SIZE],obuf[NROM_BUF_SIZE];
+ int i;
+ char *p;
+
+ p = obuf;
+ for (i = 0; i < len; i++)
+ {
+ *p++ = tohex ((myaddr[i] >> 4) & 0xf);
+ *p++ = tohex (myaddr[i] & 0xf);
+ }
+ *p = '\0';
+ nrom_send (GDB_WRITE_MEM, obuf, len * 2, memaddr, len, buf);
+
+ return len;
+}
+
+/* Read LEN bytes from inferior memory at MEMADDR. Put the result
+ at debugger address MYADDR. Returns errno value. */
+
+static int
+nrom_read_inferior_memory (memaddr, myaddr, len)
+ CORE_ADDR memaddr;
+ char *myaddr;
+ int len;
+{
+ char buf[NROM_BUF_SIZE];
+
+ nrom_send (GDB_READ_MEM, NULL, 0, memaddr, len, buf);
+ memcpy (myaddr, buf, len);
+ return len;
+}
+
+static void
+nrom_files_info (ignore)
+ struct target_ops *ignore;
+{
+}
+
+static void
+nrom_mourn()
+{
+ unpush_target (&nrom_ops);
+ generic_mourn_inferior ();
+}
+
+/* Convert a packet into its parts and verify check sum. */
+
+static int
+parse_pkt (pkt, hdr, data)
+ unsigned char *pkt;
+ GPKTHDR *hdr;
+ char *data;
+{
+ unsigned char xcsum;
+ unsigned char *dptr;
+
+ /* Build packet header from received data. */
+ hex2mem (pkt, (char *) hdr, sizeof(GPKTHDR));
+ if (remote_debug > 1)
+ {
+ printf_filtered ("Packet received: csum = %x,seq number = %x,len = %d\n",
+ hdr->csum,hdr->seq_num,hdr->len);
+ printf_filtered ("cmd = %x,addr = %x,datalen = %d\n",
+ hdr->cmd,hdr->addr,hdr->datalen);
+ }
+ /* Skip first two bytes of packet when computing checksum. */
+ dptr = (sizeof(GPKTHDR) * 2) + pkt;
+ pkt += 2;
+ if (remote_debug > 1)
+ {
+ printf_filtered ("Computing checksum over pkt %s\n",pkt);
+ printf_filtered ("Of length %d\n",strlen(pkt));
+ }
+ xcsum = compute_csum (pkt, strlen (pkt));
+ if (xcsum != hdr->csum)
+ {
+ if (remote_debug)
+ printf_filtered ("Checksum failure: computed %x, received %x\n",xcsum,
+ hdr->csum);
+ return (-1);
+ }
+
+ /* Copy data portion to callers data buffer converting from ASCII
+ to data as we go. */
+ hex2mem (dptr, data, hdr->datalen);
+ return 0;
+}
+
+static int
+read_pkt (pkt)
+ char *pkt;
+{
+ int n, tries;
+ struct sockaddr_in from;
+ int from_len = sizeof(from);
+ int gotstart;
+ int total_len;
+ char *p;
+
+ p = pkt;
+ total_len = 0;
+ gotstart = 0;
+
+ while (1)
+ {
+ /* Don't let us get wedged if the target is losing. */
+ QUIT;
+
+ if (bufdata == 0)
+ {
+ bufindex = 0;
+ n = NROM_BUF_SIZE;
+ /* Perform read on socket. This will wait. */
+ bufdata = recvfrom (nrom_targ_sock, readbuf, n, 0, &from, &from_len);
+ if (bufdata < 0)
+ {
+ printf_filtered ("Error on socket read of %d\n",errno);
+ return (-1);
+ }
+ if (remote_debug > 2)
+ {
+ readbuf[bufdata] = '\0';
+ printf_filtered ("Received %d bytes. Data is %s\n",
+ bufdata, readbuf);
+ }
+ }
+
+ /* skip stuff between packets */
+ while (gotstart == 0 && bufdata != 0
+ && readbuf[bufindex] != GDB_START_DELIMITER)
+ {
+ bufdata--;
+ bufindex++;
+ }
+
+ /* look for a start if we haven't seen one */
+ if (gotstart == 0 && bufdata != 0
+ && readbuf[bufindex] == GDB_START_DELIMITER)
+ {
+ gotstart = 1;
+ bufindex++;
+ bufdata--;
+ }
+
+ /* copy packet data */
+ if (gotstart != 0)
+ {
+ while (bufdata && readbuf[bufindex] != GDB_END_DELIMITER)
+ {
+ *p = readbuf[bufindex];
+ p++;
+ bufdata--;
+ bufindex++;
+ total_len++;
+ if (total_len > NROM_BUF_SIZE)
+ {
+ error ("read_pkt: packet length exceeds %d\n",
+ NROM_BUF_SIZE);
+ return (-1);
+ }
+ }
+ *p = '\0';
+ if (remote_debug > 2)
+ printf_filtered ("Packet is '%s'\n", pkt);
+ }
+
+ /* Make sure this is the end of the packet. */
+ if (gotstart != 0 && bufdata != 0
+ && readbuf[bufindex] == GDB_END_DELIMITER)
+ {
+ gotstart = 0;
+ bufindex++;
+ bufdata--;
+ /* Ensure that the packet is terminated. */
+ *p = '\0';
+ if (remote_debug > 2)
+ printf_filtered ("Returning '%s'\n", pkt);
+ return 0;
+ }
+ }
+}
+
+static void
+send_query_cmd ()
+{
+ while (send_pkt (GDB_QUERY_CMD, NULL, 0, 0, 0) < 0)
+ ;
+}
+
+static int
+send_pkt (cmd, data, datalen, addr, len)
+ int cmd;
+ char *data;
+ int datalen;
+ long addr;
+ int len;
+{
+ char c[2];
+ unsigned char seq;
+ struct sockaddr_in mysin;
+ int send_cnt;
+
+ while (1)
+ {
+ /* Get a sequence number for this packet. */
+ seq = get_seq_number ();
+ /* Build the packet. */
+ build_pkt (cmd, data, datalen, workbuf, addr, len, seq);
+ /* Put delimiters around the pkt. */
+ memset (sendbuf, 0, NROM_BUF_SIZE);
+ sendbuf[0] = GDB_START_DELIMITER;
+ strcat (sendbuf, workbuf);
+ c[0] = GDB_END_DELIMITER;
+ c[1] = '\0';
+ strcat (sendbuf, c);
+
+ /* Send the packet out on our socket. */
+ if (remote_debug > 1)
+ printf_filtered ("Sending pkt: %s\n", sendbuf);
+ mysin.sin_family = AF_INET;
+ mysin.sin_port = target_port;
+ mysin.sin_addr.S_un.S_addr = nrom_ipaddr;
+
+ send_cnt = 0;
+ while (send_cnt < MAX_SEND_ATTEMPTS)
+ {
+ if (sendto (nrom_targ_sock, sendbuf, strlen(sendbuf), 0, &mysin,
+ sizeof(struct sockaddr_in)) < 0)
+ {
+ printf_filtered ("sendto error of %d\n", errno);
+ send_cnt++;
+ }
+ else
+ break;
+ }
+ if (send_cnt >= MAX_SEND_ATTEMPTS)
+ {
+ printf_filtered ("Socket send failed after %d tries\n",
+ MAX_SEND_ATTEMPTS);
+ return (-1);
+ }
+ return 1;
+ }
+}
+
+/* Convert number NIB to a hex digit. */
+
+static int
+tohex (nib)
+ int nib;
+{
+ if (nib < 10)
+ return '0' + nib;
+ else
+ return 'a' + nib - 10;
+}
+
+/* snatched from Stevens, pp279+ */
+
+int
+writen (sock, ptr, nbytes)
+ int sock;
+ char *ptr;
+ int nbytes;
+{
+ int nleft, nwritten;
+ char *buf = ptr;
+
+ nleft = nbytes;
+ while (nleft > 0)
+ {
+ nwritten = write (sock, buf, nleft);
+ if (nwritten <= 0)
+ return nwritten;
+ nleft -= nwritten;
+ buf += nwritten;
+ }
+ return (nbytes - nleft);
+}
+
+/* Define the target vector. */
+
+struct target_ops nrom_ops = {
+ "nrom", /* to_shortname */
+ "Remote XDI `NetROM' target", /* to_longname */
+ "Remote debug using a NetROM over Ethernet",
+ nrom_open, /* to_open */
+ nrom_close,
+ nrom_attach,
+ nrom_detach,
+ nrom_resume,
+ nrom_wait, /* to_wait */
+ nrom_fetch_registers, /* to_fetch_registers */
+ nrom_store_registers, /* to_store_registers */
+ nrom_prepare_to_store, /* to_prepare_to_store */
+ nrom_xfer_inferior_memory, /* to_xfer_memory */
+ nrom_files_info, /* to_files_info */
+ NULL, /* to_insert_breakpoint */
+ NULL, /* to_remove_breakpoint */
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ nrom_kill,
+ nrom_load,
+ NULL,
+ nrom_create_inferior, /* to_create_inferior */
+ nrom_mourn,
+ nrom_can_run,
+ 0, /* to_notice_signals */
+ 0,
+ process_stratum, /* to_stratum */
+ NULL, /* to_next */
+ 1,
+ 1,
+ 1,
+ 1,
+ 0, /* to_has_execution */
+ NULL, /* sections */
+ NULL, /* sections_end */
+ OPS_MAGIC /* to_magic */
+};
+
+void
+_initialize_remote_nrom ()
+{
+ add_target (&nrom_ops);
+
+ /* Add some commands for helpers. */
+ add_cmd ("nrom_ipaddr", no_class, nrom_set_ipaddr,
+ "Set the IP Address of the NetROM\n",
+ &setlist);
+ add_cmd ("target_port", no_class, nrom_set_target_port,
+ "Set the Port to use for NetROM target communication\n",
+ &setlist);
+ add_cmd ("load_port", no_class, nrom_set_load_port,
+ "Set the Port to use for NetROM downloads\n",
+ &setlist);
+ add_cmd ("control_port", no_class, nrom_set_control_port,
+ "Set the Port to use for NetROM debugger services\n",
+ &setlist);
+ add_cmd ("nrom_filetype", no_class, nrom_set_filetype,
+ "Set the filetype to use on NetROM downloads",
+ &setlist);
+
+ add_cmd ("nrom", no_class, nrom_show_status,
+ "Show the current NetROM status\n",
+ &showlist);
+
+ add_cmd ("nrom", no_class, nrom_passthru,
+ "Pass arguments as command to NetROM",
+ &cmdlist);
+}
projects / binutils-gdb.git / commitdiff