| /* |
| * 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 defined(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; |
| } |
| |
| void Adp_SetLogEnable(int logEnableFlag) |
| { |
| DevSW_SetLogEnable(logEnableFlag); |
| } |
| |
| void Adp_SetLogfile(const char *filename) |
| { |
| DevSW_SetLogfile(filename); |
| } |
| |
| 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(__CYGWIN__) |
| 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 */ |
