Initial creation of sourceware repositorygdb-4_18-branchpoint

1 files changed, 1057 insertions, 0 deletions

diff --git a/gdb/rdi-share/hostchan.c b/gdb/rdi-share/hostchan.c
new file mode 100644
index 0000000..8e41da4
--- /dev/null
+++ b/gdb/rdi-share/hostchan.c
@@ -0,0 +1,1057 @@
+/* 
+ * Copyright (C) 1995 Advanced RISC Machines Limited. All rights reserved.
+ * 
+ * This software may be freely used, copied, modified, and distributed
+ * provided that the above copyright notice is preserved in all copies of the
+ * software.
+ */
+
+/* -*-C-*-
+ *
+ * $Revision$
+ *     $Date$
+ *
+ *
+ * hostchan.c - Semi Synchronous Host side channel interface for Angel.
+ */
+
+#include <stdio.h>
+
+#ifdef HAVE_SYS_TIME_H
+#  include <sys/time.h>
+#else
+#  include "winsock.h"
+#  include "time.h"
+#endif
+#include "hsys.h"
+#include "host.h"
+#include "logging.h"
+#include "chandefs.h"
+#include "chanpriv.h"
+#include "devclnt.h"
+#include "buffers.h"
+#include "drivers.h"
+#include "adperr.h"
+#include "devsw.h"
+#include "hostchan.h"
+
+#ifndef UNUSED
+#define UNUSED(x) (x = x)  /* Silence compiler warnings for unused arguments */
+#endif
+
+#define HEARTRATE 5000000
+
+/*
+ * list of available drivers, declared in drivers.c
+ */
+extern DeviceDescr *devices[];
+
+static DeviceDescr *deviceToUse = NULL;
+
+static struct Channel {
+    ChannelCallback callback;
+    void *callback_state;
+} channels[CI_NUM_CHANNELS];
+
+static unsigned char HomeSeq;
+static unsigned char OppoSeq;
+
+/*
+ * Handler for DC_APPL packets
+ */
+static DC_Appl_Handler dc_appl_handler = NULL;
+
+/*
+ * slots for registered asynchronous processing callback procedures
+ */
+#define MAX_ASYNC_CALLBACKS 8
+static unsigned int             num_async_callbacks = 0;
+static Adp_Async_Callback       async_callbacks[MAX_ASYNC_CALLBACKS];
+
+/*
+ * writeQueueRoot is the queue of write requests pending acknowledgement
+ * writeQueueSend is the queue of pending write requests which will
+ * be a subset of the list writeQueueRoot
+ */
+static Packet *writeQueueRoot = NULL;
+static Packet *writeQueueSend = NULL;
+static Packet *resend_pkt = NULL;
+static int resending = FALSE;
+
+/* heartbeat_enabled is a flag used to indicate whether the heartbeat is
+ * currently turned on, heartbeat_enabled will be false in situations
+ * where even though a heartbeat is being used it is problematical or
+ * dis-advantageous to have it turned on, for instance during the 
+ * initial stages of boot up
+ */
+unsigned int heartbeat_enabled = FALSE;
+/* heartbeat_configured is set up by the device driver to indicate whether
+ * the heartbeat is being used during this debug session.  In contrast to
+ * heartbeat_enabled it must not be changed during a session.  The logic for
+ * deciding whether to send a heartbeat is: Is heartbeat_configured for this
+ * session? if and only if it is then if heartbeat[is currently]_enabled and
+ * we are due to send a pulse then send it 
+ */
+unsigned int heartbeat_configured = TRUE;
+
+void Adp_initSeq( void ) {
+  Packet *tmp_pkt = writeQueueSend;
+
+  HomeSeq = 0;
+  OppoSeq = 0;
+  if ( writeQueueSend != NULL) {
+    while (writeQueueSend->pk_next !=NULL) {
+      tmp_pkt = writeQueueSend;
+      writeQueueSend = tmp_pkt->pk_next;
+      DevSW_FreePacket(tmp_pkt);
+    }
+  }
+  tmp_pkt = writeQueueRoot;
+  if ( writeQueueRoot == NULL)
+    return;
+
+  while (writeQueueRoot->pk_next !=NULL) {
+    tmp_pkt = writeQueueRoot;
+    writeQueueRoot = tmp_pkt->pk_next;
+    DevSW_FreePacket(tmp_pkt);
+  }
+  return;
+}
+
+/**********************************************************************/
+
+/*
+ *  Function: DummyCallback
+ *   Purpose: Default callback routine to handle unexpected input
+ *              on a channel
+ *
+ *    Params:
+ *       Input: packet  The received packet
+ *
+ *              state   Contains nothing of significance
+ *
+ *   Returns: Nothing
+ */
+static void DummyCallback(Packet *packet, void *state)
+{
+    ChannelID chan;
+    const char fmt[] = "Unexpected read on channel %u, length %d\n";
+    char fmtbuf[sizeof(fmt) + 24];
+
+    UNUSED(state);
+
+    chan = *(packet->pk_buffer);
+    sprintf(fmtbuf, fmt, chan, packet->pk_length);
+    printf(fmtbuf);
+
+    /*
+     * junk this packet
+     */
+    DevSW_FreePacket(packet);
+}
+
+/*
+ *  Function: BlockingCallback
+ *   Purpose: Callback routine used to implement a blocking read call
+ *
+ *    Params:
+ *       Input: packet  The received packet.
+ *
+ *      Output: state   Address of higher level's pointer to the received
+ *                      packet.
+ *
+ *   Returns: Nothing
+ */
+static void BlockingCallback(Packet *packet, void *state)
+{
+    /*
+     * Pass the packet back to the caller which requested a packet
+     * from this channel.  This also flags the completion of the I/O
+     * request to the blocking read call.
+     */
+    *((Packet **)state) = packet;
+}
+
+/*
+ *  Function: FireCallback
+ *   Purpose: Pass received packet along to the callback routine for
+ *              the appropriate channel
+ *
+ *    Params:
+ *       Input: packet  The received packet.
+ *
+ *   Returns: Nothing
+ *
+ * Post-conditions: The Target-to-Host sequence number for the channel
+ *                      will have been incremented.
+ */
+static void FireCallback(Packet *packet)
+{
+    ChannelID chan;
+    struct Channel *ch;
+
+    /*
+     * is this a sensible channel number?
+     */
+    chan = *(packet->pk_buffer);
+    if (invalidChannelID(chan))
+    {
+        printf("ERROR: invalid ChannelID received from target\n");
+
+        /*
+         * free the packet's resources, 'cause no-one else will
+         */
+        DevSW_FreePacket(packet);
+        return;
+    }
+
+    /*
+     * looks OK - increment sequence number, and pass packet to callback
+     */
+    ch = channels + chan;
+    (ch->callback)(packet, ch->callback_state);
+}
+
+/**********************************************************************/
+
+/*
+ * These are the externally visible functions.  They are documented
+ * in hostchan.h
+ */
+void Adp_addToQueue(Packet **head, Packet *newpkt)
+{
+    /*
+     * this is a bit of a hack
+     */
+    Packet *pk;
+
+    /*
+     * make sure that the hack we are about to use will work as expected
+     */
+    ASSERT(&(((Packet *)0)->pk_next) == 0, "bad struct Packet layout");
+
+#if DEBUG && 0
+    printf("Adp_addToQueue(%p, %p)\n", head, newpkt);
+#endif
+
+    /*
+     * here's the hack - it relies upon the next
+     * pointer being at the start of Packet.
+     */
+    pk = (Packet *)(head);
+
+    /*
+     * skip to the end of the queue
+     */
+    while (pk->pk_next != NULL)
+        pk = pk->pk_next;
+
+    /*
+     * now add the new element
+     */
+    newpkt->pk_next = NULL;
+    pk->pk_next = newpkt;
+}
+
+Packet *Adp_removeFromQueue(Packet **head)
+{
+    struct Packet *pk;
+
+    pk = *head;
+
+    if (pk != NULL)
+        *head = pk->pk_next;
+
+    return pk;
+}
+
+AdpErrs Adp_OpenDevice(const char *name, const char *arg,
+                       unsigned int heartbeat_on)
+{
+    int i;
+    AdpErrs retc;
+    ChannelID chan;
+
+#ifdef DEBUG
+    printf("Adp_OpenDevice(%s, %s)\n", name, arg ? arg : "<NULL>");
+#endif
+
+    heartbeat_configured = heartbeat_on;
+    if (deviceToUse != NULL)
+        return adp_device_already_open;
+
+    for (i = 0; (deviceToUse = devices[i]) != NULL; ++i)
+        if (DevSW_Match(deviceToUse, name, arg) == adp_ok)
+            break;
+
+    if (deviceToUse == NULL)
+        return adp_device_not_found;
+
+    /*
+     * we seem to have found a suitable device driver, so try to open it
+     */
+    if ((retc = DevSW_Open(deviceToUse, name, arg, DC_DBUG)) != adp_ok)
+    {
+        /* we don't have a device to use */
+        deviceToUse = NULL;
+        return retc;
+    }
+
+    /*
+     * there is no explicit open on channels any more, so
+     * initialise state for all channels.
+     */
+    for (chan = 0; chan < CI_NUM_CHANNELS; ++chan)
+    {
+        struct Channel *ch = channels + chan;
+
+        ch->callback = DummyCallback;
+        ch->callback_state = NULL;
+        OppoSeq = 0;
+        HomeSeq = 0;
+    }
+
+    return adp_ok;
+}
+
+AdpErrs Adp_CloseDevice(void)
+{
+    AdpErrs retc;
+
+#ifdef DEBUG
+    printf("Adp_CloseDevice\n");
+#endif
+
+    if (deviceToUse == NULL)
+        return adp_device_not_open;
+
+    heartbeat_enabled = FALSE;
+
+    retc = DevSW_Close(deviceToUse, DC_DBUG);
+
+    /*
+     * we have to clear deviceToUse, even when the lower layers
+     * faulted the close, otherwise the condition will never clear
+     */
+    if (retc != adp_ok)
+        WARN("DevSW_Close faulted the call");
+
+    deviceToUse = NULL;
+    return retc;
+}
+
+AdpErrs Adp_Ioctl(int opcode, void *args)
+{
+#ifdef DEBUG
+    printf("Adp_Ioctl\n");
+#endif
+
+    if (deviceToUse == NULL)
+        return adp_device_not_open;
+
+    return DevSW_Ioctl(deviceToUse, opcode, args);
+}
+
+AdpErrs Adp_ChannelRegisterRead(const ChannelID chan,
+                                const ChannelCallback cbfunc,
+                                void *cbstate)
+{
+#ifdef DEBUG
+    printf("Adp_ChannelRegisterRead(%d, %p, %x)\n", chan, cbfunc, cbstate);
+#endif
+
+    if (deviceToUse == NULL)
+        return adp_device_not_open;
+
+    if (invalidChannelID(chan))
+        return adp_bad_channel_id;
+
+    if (cbfunc == NULL)
+    {
+        channels[chan].callback = DummyCallback;
+        channels[chan].callback_state = NULL;
+    }
+    else
+    {
+        channels[chan].callback = cbfunc;
+        channels[chan].callback_state = cbstate;
+    }
+
+    return adp_ok;
+}
+
+AdpErrs Adp_ChannelRead(const ChannelID chan, Packet **packet)
+{
+    struct Channel *ch;
+
+#ifdef DEBUG
+    printf("Adp_ChannelRead(%d, %x)\n", chan, *packet);
+#endif
+
+    if (deviceToUse == NULL)
+        return adp_device_not_open;
+
+    if (invalidChannelID(chan))
+        return adp_bad_channel_id;
+
+    /*
+     * if a callback has already been registered for this
+     * channel, then we do not allow this blocking read.
+     */
+    ch = channels + chan;
+    if (ch->callback != DummyCallback)
+        return adp_callback_already_registered;
+
+    /*
+     * OK, use our own callback to wait for a packet to arrive
+     * on this channel
+     */
+    ch->callback = BlockingCallback;
+    ch->callback_state = packet;
+    *packet = NULL;
+
+    /*
+     * keep polling until a packet appears for this channel
+     */
+    while (((volatile Packet *)(*packet)) == NULL)
+        /*
+         * this call will block until a packet is read on any channel
+         */
+        Adp_AsynchronousProcessing(async_block_on_read);
+
+    /*
+     * OK, the packet has arrived: clear the callback
+     */
+    ch->callback = DummyCallback;
+    ch->callback_state = NULL;
+
+    return adp_ok;
+}
+
+static AdpErrs ChannelWrite(
+    const ChannelID chan, Packet *packet, AsyncMode mode)
+{
+    struct Channel *ch;
+    unsigned char *cptr;
+
+#ifdef DEBUG
+    printf( "Adp_ChannelWrite(%d, %x)\n", chan, packet );
+#endif
+
+    if (deviceToUse == NULL)
+        return adp_device_not_open;
+
+    if (invalidChannelID(chan))
+        return adp_bad_channel_id;
+
+    /*
+     * fill in the channels header at the start of this buffer
+     */
+    ch = channels + chan;
+    cptr = packet->pk_buffer;
+    *cptr++ = chan;
+    *cptr = 0;
+    packet->pk_length += CHAN_HEADER_SIZE;
+
+    /*
+     * OK, add this packet to the write queue, and try to flush it out
+     */
+
+    Adp_addToQueue(&writeQueueSend, packet);
+    Adp_AsynchronousProcessing(mode);
+
+    return adp_ok;
+}
+
+AdpErrs Adp_ChannelWrite(const ChannelID chan, Packet *packet) {
+  return ChannelWrite(chan, packet, async_block_on_write);
+}
+
+AdpErrs Adp_ChannelWriteAsync(const ChannelID chan, Packet *packet) {
+  return ChannelWrite(chan, packet, async_block_on_nothing);
+}
+
+static AdpErrs send_resend_msg(DeviceID devid) {
+
+  /*
+   * Send a resend message, usually in response to a bad packet or
+   * a resend request */
+  Packet * packet;
+  packet = DevSW_AllocatePacket(CF_DATA_BYTE_POS);
+  packet->pk_buffer[CF_CHANNEL_BYTE_POS] = CI_PRIVATE;
+  packet->pk_buffer[CF_HOME_SEQ_BYTE_POS] = HomeSeq;
+  packet->pk_buffer[CF_OPPO_SEQ_BYTE_POS] = OppoSeq;
+  packet->pk_buffer[CF_FLAGS_BYTE_POS] = CF_RELIABLE | CF_RESEND;
+  packet->pk_length = CF_DATA_BYTE_POS;
+  return DevSW_Write(deviceToUse, packet, devid);
+}
+
+static AdpErrs check_seq(unsigned char msg_home, unsigned char msg_oppo) {
+  Packet *tmp_pkt;
+
+  UNUSED(msg_oppo);
+  /* 
+   * check if we have got an ack for anything and if so remove it from the
+   * queue
+   */
+  if (msg_home == (unsigned char)(OppoSeq+1)) {
+    /*
+     * arrived in sequence can increment our opposing seq number and remove
+     * the relevant packet from our queue
+     * check that the packet we're going to remove really is the right one
+     */
+    tmp_pkt = writeQueueRoot;
+    while ((tmp_pkt->pk_next != NULL) &&
+           (tmp_pkt->pk_next->pk_buffer[CF_HOME_SEQ_BYTE_POS]
+            != OppoSeq)){
+      tmp_pkt = tmp_pkt->pk_next;
+    }
+    OppoSeq++;
+    if (tmp_pkt->pk_next == NULL) {
+#ifdef DEBUG
+      printf("trying to remove a non existant packet\n");
+#endif
+      return adp_bad_packet;
+    }
+    else {
+      Packet *tmp = tmp_pkt->pk_next;
+#ifdef RET_DEBUG
+      printf("removing a packet from the root queue\n");
+#endif
+      tmp_pkt->pk_next = tmp_pkt->pk_next->pk_next;
+      /* remove the appropriate packet */
+      DevSW_FreePacket(tmp);
+    return adp_ok;
+    }
+  }
+  else if (msg_home < (unsigned char) (OppoSeq+1)){
+    /* already received this message */
+#ifdef RET_DEBUG
+    printf("sequence numbers low\n");
+#endif   
+    return adp_seq_low;
+  }
+  else {  /* we've missed something */
+#ifdef RET_DEBUG
+    printf("sequence numbers high\n");
+#endif   
+    return adp_seq_high;
+  }
+}
+
+static unsigned long tv_diff(const struct timeval *time_now, 
+                             const struct timeval *time_was)
+{
+    return (  ((time_now->tv_sec * 1000000) + time_now->tv_usec)
+            - ((time_was->tv_sec * 1000000) + time_was->tv_usec) );
+}
+
+#if !defined(__unix) && !defined(__CYGWIN32__)
+static void gettimeofday( struct timeval *time_now, void *dummy )
+{
+    time_t t = clock();
+    UNUSED(dummy);
+    time_now->tv_sec = t/CLOCKS_PER_SEC;
+    time_now->tv_usec = (t%CLOCKS_PER_SEC)*(1000000/CLOCKS_PER_SEC);
+}
+#endif
+
+static AdpErrs pacemaker(void)
+{
+  Packet *packet;
+
+  packet = DevSW_AllocatePacket(CF_DATA_BYTE_POS);
+  if (packet == NULL) {
+    printf("ERROR: could not allocate a packet in pacemaker()\n");
+    return adp_malloc_failure;
+  }
+  packet->pk_buffer[CF_CHANNEL_BYTE_POS] = CI_PRIVATE;
+  packet->pk_buffer[CF_HOME_SEQ_BYTE_POS] = HomeSeq;
+  packet->pk_buffer[CF_OPPO_SEQ_BYTE_POS] = OppoSeq;
+  packet->pk_buffer[CF_FLAGS_BYTE_POS] = CF_RELIABLE | CF_HEARTBEAT;
+  packet->pk_length = CF_DATA_BYTE_POS;
+  return DevSW_Write(deviceToUse, packet, DC_DBUG);
+}  
+
+#ifdef FAKE_BAD_LINE_RX
+static AdpErrs fake_bad_line_rx( const Packet *const packet, AdpErrs adp_err )
+{
+    static unsigned int bl_num = 0;
+
+    if (     (packet != NULL)
+          && (bl_num++ >= 20 )
+          && ((bl_num % FAKE_BAD_LINE_RX) == 0))
+    {
+        printf("DEBUG: faking a bad packet\n");
+        return adp_bad_packet;
+    }
+    return adp_err;
+}
+#endif /* def FAKE_BAD_LINE_RX */
+
+#ifdef FAKE_BAD_LINE_TX
+static unsigned char tmp_ch;
+
+static void fake_bad_line_tx( void )
+{
+    static unsigned int bl_num = 0;
+
+    /* give the thing a chance to boot then try corrupting stuff */
+    if ( (bl_num++ >= 20) && ((bl_num % FAKE_BAD_LINE_TX) == 0)) 
+    {
+        printf("DEBUG: faking a bad packet for tx\n");
+        tmp_ch = writeQueueSend->pk_buffer[CF_FLAGS_BYTE_POS];
+        writeQueueSend->pk_buffer[CF_FLAGS_BYTE_POS] = 77;
+    }
+}
+
+static void unfake_bad_line_tx( void )
+{
+    static unsigned int bl_num = 0;
+
+    /*
+     * must reset the packet so that its not corrupted when we
+     *  resend it 
+     */   
+    if ( (bl_num >= 20) && ((bl_num % FAKE_BAD_LINE_TX) != 0))
+    {
+        writeQueueSend->pk_buffer[CF_FLAGS_BYTE_POS] = tmp_ch;
+    }
+}
+#endif /* def FAKE_BAD_LINE_TX */
+
+/*
+ * NOTE: we are assuming that a resolution of microseconds will
+ * be good enough for the purporses of the heartbeat.  If this proves
+ * not to be the case then we may need a rethink, possibly using
+ * [get,set]itimer
+ */
+static struct timeval time_now;
+static struct timeval time_lastalive;
+
+static void async_process_dbug_read( const AsyncMode mode,
+                                     bool *const finished  )
+{
+    Packet *packet;
+    unsigned int msg_home, msg_oppo;
+    AdpErrs adp_err;
+
+    adp_err = DevSW_Read(deviceToUse, DC_DBUG, &packet,
+                         mode == async_block_on_read    );
+
+#ifdef FAKE_BAD_LINE_RX
+    adp_err = fake_bad_line_rx( packet, adp_err );
+#endif
+
+    if (adp_err == adp_bad_packet) {
+        /* We got a bad packet, ask for a resend, send a resend message */
+#ifdef DEBUG
+        printf("received a bad packet\n");
+#endif
+        send_resend_msg(DC_DBUG);
+    }
+    else if (packet != NULL)
+    {
+        /* update the heartbeat clock */
+        gettimeofday(&time_lastalive, NULL);
+
+            /*
+             * we got a live one here - were we waiting for it?
+             */
+        if (mode == async_block_on_read)
+           /* not any more */
+           *finished = TRUE;
+#ifdef RETRANS
+
+        if (packet->pk_length < CF_DATA_BYTE_POS) {
+            /* we've got a packet with no header information! */
+            printf("ERROR: packet with no transport header\n");
+            send_resend_msg(DC_DBUG);
+        }
+        else {
+#ifdef RET_DEBUG
+            unsigned int c;
+#endif
+            /*
+             * TODO: Check to see if its acknowledgeing anything, remove
+             * those packets it is from the queue.  If its a retrans add the
+             * packets to the queue
+             */
+            msg_home = packet->pk_buffer[CF_HOME_SEQ_BYTE_POS];
+            msg_oppo = packet->pk_buffer[CF_OPPO_SEQ_BYTE_POS];
+#ifdef RET_DEBUG
+            printf("msg seq numbers are hseq 0x%x oseq 0x%x\n",
+                   msg_home, msg_oppo);
+            for (c=0;c<packet->pk_length;c++)
+               printf("%02.2x", packet->pk_buffer[c]);
+            printf("\n");
+#endif
+            /* now was it a resend request? */
+            if ((packet->pk_buffer[CF_FLAGS_BYTE_POS]) 
+                & CF_RESEND) {
+                /* we've been asked for a resend so we had better resend */
+                /*
+                 * I don't think we can use a resend as acknowledgement for
+                 * anything so lets not do this for the moment
+                 * check_seq(msg_home, msg_oppo);
+                 */
+#ifdef RET_DEBUG
+                printf("received a resend request\n");
+#endif
+                if (HomeSeq != msg_oppo) {
+                    int found = FALSE;
+                    /* need to resend from msg_oppo +1 upwards */
+                    DevSW_FreePacket(packet);
+                    resending = TRUE;
+                    /* find the correct packet to resend from */
+                    packet = writeQueueRoot;
+                    while (((packet->pk_next) != NULL) && !found) {
+                        if ((packet->pk_buffer[CF_OPPO_SEQ_BYTE_POS])
+                            != msg_oppo+1) {
+                            resend_pkt = packet;
+                            found = TRUE;
+                        }
+                        packet = packet->pk_next;
+                    }
+                    if (!found) {
+                        panic("trying to resend non-existent packets\n");
+                    }
+                }
+                else if (OppoSeq != msg_home) {
+                    /* 
+                     * send a resend request telling the target where we think
+                     * the world is at 
+                     */
+                    DevSW_FreePacket(packet);
+                    send_resend_msg(DC_DBUG);
+                }
+            }
+            else {
+                /* not a resend request, lets check the sequence numbers */
+                
+                if ((packet->pk_buffer[CF_CHANNEL_BYTE_POS] != CI_HBOOT) &&
+                    (packet->pk_buffer[CF_CHANNEL_BYTE_POS] != CI_TBOOT)) {
+                    adp_err = check_seq(msg_home, msg_oppo);
+                    if (adp_err == adp_seq_low) {
+                        /* we have already received this packet so discard */
+                        DevSW_FreePacket(packet);
+                    }
+                    else if (adp_err == adp_seq_high) {
+                        /*
+                         * we must have missed a packet somewhere, discard this 
+                         * packet and tell the target where we are
+                         */
+                        DevSW_FreePacket(packet);
+                        send_resend_msg(DC_DBUG);
+                    }
+                    else
+                       /*
+                        * now pass the packet to whoever is waiting for it
+                        */
+                       FireCallback(packet);
+                }
+                else
+                   FireCallback(packet);
+            }
+        }
+#else
+        /*
+             * now pass the packet to whoever is waiting for it
+             */
+        FireCallback(packet);
+#endif
+    }
+}
+
+static void async_process_appl_read(void)
+{
+    Packet *packet;
+    AdpErrs adp_err;
+
+    /* see if there is anything for the DC_APPL channel */
+    adp_err = DevSW_Read(deviceToUse, DC_APPL, &packet, FALSE);
+
+    if (adp_err == adp_ok && packet != NULL)
+    {
+        /* got an application packet on a shared device */
+
+#ifdef DEBUG
+        printf("GOT DC_APPL PACKET: len %d\nData: ", packet->pk_length);
+        {
+            unsigned int c;
+            for ( c = 0; c < packet->pk_length; ++c )
+               printf( "%02X ", packet->pk_buffer[c] );
+        }
+        printf("\n");
+#endif
+
+        if (dc_appl_handler != NULL)
+        {
+            dc_appl_handler( deviceToUse, packet );
+        }
+        else
+        {
+            /* for now, just free it!! */
+#ifdef DEBUG
+            printf("no handler - dropping DC_APPL packet\n");
+#endif
+            DevSW_FreePacket( packet );
+        }
+    }
+}
+
+static void async_process_write( const AsyncMode mode,
+                                 bool *const finished  )
+{
+    Packet *packet;
+
+#ifdef DEBUG
+    static unsigned int num_written = 0;
+#endif
+
+    /*
+     * NOTE: here we rely in the fact that any packet in the writeQueueSend
+     * section of the queue will need its sequence number setting up while
+     * and packet in the writeQueueRoot section will have its sequence
+     * numbers set up from when it was first sent so we can easily look
+     * up the packet numbers when(if) we want to resend the packet.
+     */
+
+#ifdef DEBUG
+    if (writeQueueSend!=NULL)
+       printf("written 0x%x\n",num_written += writeQueueSend->pk_length);
+#endif
+    /*
+     * give the switcher a chance to complete any partial writes
+     */
+    if (DevSW_FlushPendingWrite(deviceToUse) == adp_write_busy)
+    {
+        /* no point trying a new write */
+        return;
+    }
+      
+    /*
+     * now see whether there is anything to write
+     */
+    packet = NULL;
+    if (resending) {
+        packet = resend_pkt;
+#ifdef RET_DEBUG
+        printf("resending hseq 0x%x oseq 0x%x\n", 
+               packet->pk_buffer[CF_HOME_SEQ_BYTE_POS],
+               packet->pk_buffer[CF_OPPO_SEQ_BYTE_POS]);
+#endif
+    }
+    else if (writeQueueSend != NULL) {
+#ifdef RETRANS
+        /* set up the sequence number on the packet */
+        packet = writeQueueSend;
+        HomeSeq++;
+        (writeQueueSend->pk_buffer[CF_OPPO_SEQ_BYTE_POS])
+            = OppoSeq;
+        (writeQueueSend->pk_buffer[CF_HOME_SEQ_BYTE_POS])
+            = HomeSeq;
+        (writeQueueSend->pk_buffer[CF_FLAGS_BYTE_POS])
+            = CF_RELIABLE;
+# ifdef RET_DEBUG
+        printf("sending packet with hseq 0x%x oseq 0x%x\n",
+               writeQueueSend->pk_buffer[CF_HOME_SEQ_BYTE_POS],
+               writeQueueSend->pk_buffer[CF_OPPO_SEQ_BYTE_POS]);
+# endif
+#endif /* RETRANS */
+    }
+
+    if (packet != NULL) {
+        AdpErrs dev_err;
+
+#ifdef FAKE_BAD_LINE_TX
+        fake_bad_line_tx();
+#endif
+
+        dev_err = DevSW_Write(deviceToUse, packet, DC_DBUG);
+        if (dev_err == adp_ok) {
+#ifdef RETRANS
+            if (resending) {
+                /* check to see if we've recovered yet */
+                if ((packet->pk_next) == NULL){
+# ifdef RET_DEBUG
+                    printf("we have recovered\n");
+# endif
+                    resending = FALSE;
+                }
+                else {
+                    resend_pkt = resend_pkt->pk_next;
+                }
+            }
+            else {
+                /* 
+                 * move the packet we just sent from the send queue to the root
+                 */
+                Packet *tmp_pkt, *tmp;
+
+# ifdef FAKE_BAD_LINE_TX
+                unfake_bad_line_tx();
+# endif
+
+                tmp_pkt = writeQueueSend;
+                writeQueueSend = writeQueueSend->pk_next;
+                tmp_pkt->pk_next = NULL;
+                if (writeQueueRoot == NULL)
+                   writeQueueRoot = tmp_pkt;
+                else {
+                    tmp = writeQueueRoot;
+                    while (tmp->pk_next != NULL) {
+                        tmp = tmp->pk_next;
+                    }
+                    tmp->pk_next = tmp_pkt;
+                }
+            }
+#else  /* not RETRANS */
+            /*
+             * switcher has taken the write, so remove it from the
+             * queue, and free its resources
+             */
+            DevSW_FreePacket(Adp_removeFromQueue(&writeQueueSend));
+#endif /* if RETRANS ... else ... */
+
+            if (mode == async_block_on_write)
+               *finished = DevSW_WriteFinished(deviceToUse);
+
+        } /* endif write ok */
+    }
+    else /* packet == NULL */
+    {
+        if (mode == async_block_on_write)
+           *finished = DevSW_WriteFinished(deviceToUse);
+    }
+}
+
+static void async_process_heartbeat( void )
+{
+    /* check to see whether we need to send a heartbeat */
+    gettimeofday(&time_now, NULL);
+
+    if (tv_diff(&time_now, &time_lastalive) >= HEARTRATE)
+    {
+        /*
+         * if we've not booted then don't do send a heartrate the link
+         * must be reliable enough for us to boot without any clever stuff,
+         * if we can't do this then theres little chance of the link staying
+         * together even with the resends etc
+         */
+        if (heartbeat_enabled) {
+            gettimeofday(&time_lastalive, NULL);
+            pacemaker();
+        }
+    }
+}
+
+static void async_process_callbacks( void )
+{
+    /* call any registered asynchronous callbacks */
+    unsigned int i;
+    for ( i = 0; i < num_async_callbacks; ++i )
+       async_callbacks[i]( deviceToUse, &time_now );
+}
+
+void Adp_AsynchronousProcessing(const AsyncMode mode)
+{
+    bool finished = FALSE;
+#ifdef DEBUG
+    unsigned int wc = 0, dc = 0, ac = 0, hc = 0;
+# define INC_COUNT(x) ((x)++)
+#else
+# define INC_COUNT(x)
+#endif
+
+    if ((time_lastalive.tv_sec == 0) && (time_lastalive.tv_usec == 0)) {
+      /* first time through, needs initing */
+      gettimeofday(&time_lastalive, NULL);
+    }
+
+    /* main loop */
+    do
+    {
+        async_process_write( mode, &finished );
+        INC_COUNT(wc);
+
+        if ( ! finished && mode != async_block_on_write )
+        {
+            async_process_dbug_read( mode, &finished );
+            INC_COUNT(dc);
+        }
+
+        if ( ! finished && mode != async_block_on_write )
+        {
+           async_process_appl_read();
+           INC_COUNT(ac);
+        }
+
+        if ( ! finished )
+        {
+          if (heartbeat_configured)
+            async_process_heartbeat();
+          async_process_callbacks();
+          INC_COUNT(hc);
+        }
+
+    } while (!finished && mode != async_block_on_nothing);
+
+#ifdef DEBUG
+    if ( mode != async_block_on_nothing )
+       printf( "Async: %s - w %d, d %d, a %d, h %d\n",
+               mode == async_block_on_write ? "blk_write" : "blk_read",
+               wc, dc, ac, hc );
+#endif
+}
+
+/*
+ * install a handler for DC_APPL packets (can be NULL), returning old one.
+ */
+DC_Appl_Handler Adp_Install_DC_Appl_Handler(const DC_Appl_Handler handler)
+{
+    DC_Appl_Handler old_handler = dc_appl_handler;
+
+#ifdef DEBUG
+    printf( "Installing DC_APPL handler %x (old %x)\n", handler, old_handler );
+#endif
+
+    dc_appl_handler = handler;
+    return old_handler;
+}
+
+
+/*
+ * add an asynchronous processing callback to the list
+ * TRUE == okay, FALSE == no more async processing slots
+ */
+bool Adp_Install_Async_Callback( const Adp_Async_Callback callback_proc )
+{
+    if ( num_async_callbacks < MAX_ASYNC_CALLBACKS && callback_proc != NULL )
+    {
+        async_callbacks[num_async_callbacks] = callback_proc;
+        ++num_async_callbacks;
+        return TRUE;
+    }
+    else
+       return FALSE;
+}
+
+
+/*
+ * delay for a given period (in microseconds)
+ */
+void Adp_delay(unsigned int period)
+{
+    struct timeval tv;
+
+#ifdef DEBUG
+    printf("delaying for %d microseconds\n", period);
+#endif
+    tv.tv_sec = (period / 1000000);
+    tv.tv_usec = (period % 1000000);
+
+    (void)select(0, NULL, NULL, NULL, &tv);
+}
+
+/* EOF hostchan.c */