Initial source

1 files changed, 1377 insertions, 0 deletions

diff --git a/chips/tca100_if.c b/chips/tca100_if.c
new file mode 100644
index 0000000..5eeec10
--- /dev/null
+++ b/chips/tca100_if.c
@@ -0,0 +1,1377 @@
+/* 
+ * Mach Operating System
+ * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
+ * All Rights Reserved.
+ * 
+ * Permission to use, copy, modify and distribute this software and its
+ * documentation is hereby granted, provided that both the copyright
+ * notice and this permission notice appear in all copies of the
+ * software, derivative works or modified versions, and any portions
+ * thereof, and that both notices appear in supporting documentation.
+ * 
+ * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
+ * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ * 
+ * Carnegie Mellon requests users of this software to return to
+ * 
+ *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
+ *  School of Computer Science
+ *  Carnegie Mellon University
+ *  Pittsburgh PA 15213-3890
+ * 
+ * any improvements or extensions that they make and grant Carnegie Mellon
+ * the rights to redistribute these changes.
+ */
+
+/*** TCA 100 ATM NETWORK INTERFACE  ***/
+
+#ifndef STUB
+#include <chips/tca100_if.h>
+# else
+#include "tca100_if.h"
+#endif
+
+#define SMALL_WINDOW_SIZE (BOM_DATA_SIZE + EOM_DATA_SIZE)
+#define INITIAL_WINDOW_SIZE BOM_DATA_SIZE
+#define CONTINUATION_WINDOW_SIZE (71 * COM_DATA_SIZE)
+#define FINAL_WINDOW_SIZE (70 * COM_DATA_SIZE + EOM_DATA_SIZE)
+#define MAX_LONG_RX 2
+#define MAX_LONG_TX 5
+#define BASE_TIME_OUT 5
+#define DELAYED_TIME_OUT 15
+#define MAX_RETRY 3
+#define POLL_LIMIT 100000
+#define POLL_IDLE_TIME 1
+#define POLL_CELL_TIME 8
+
+#define TCA_SYNCH  0xfc00
+#define TCA_ACK  (NW_SUCCESS << 10)
+#define TCA_NAK  (NW_FAILURE << 10)
+#define TCA_OVR  (NW_OVERRUN << 10)
+#define TCA_SEQ  (NW_INCONSISTENCY << 10)
+
+int tca100_verbose = 0;
+
+int tick[MAX_DEV];
+
+nw_control_s nw_tx_control[MAX_DEV][MAX_LONG_TX];
+nw_control_s nw_rx_control[MAX_DEV][MAX_LONG_RX];
+
+int long_tx_count[MAX_DEV], long_rx_count[MAX_DEV];
+
+nw_tx_header_t delayed_tx_first[MAX_DEV], delayed_tx_last[MAX_DEV];
+nw_rx_header_t delayed_rx_first[MAX_DEV], delayed_rx_last[MAX_DEV];
+
+nw_tcb tct[MAX_EP];
+
+u_int MTU[] = {9244, 65528, 65532, 65528};
+u_int MTU_URGENT[] = {32, 28, 32, 28};
+
+nw_dev_entry_s tca100_entry_table = {
+  tca100_initialize, tca100_status, spans_timer_sweep, tca100_timer_sweep,
+  tca100_poll, tca100_send, tca100_rpc, spans_input, spans_open, spans_accept,
+  spans_close, spans_add, spans_drop};
+
+typedef enum {
+  ATM_HEADER,
+  SAR_HEADER,
+  SAR_TRAILER,
+  CS_HEADER,
+  CS_TRAILER,
+  FRAME_ERROR,
+  DELIVERY_ERROR,
+  SYNCH_ERROR,
+  SEQ_ERROR,
+  OVERRUN_ERROR,
+  RX_RETRANSMISSION,
+  TX_RETRANSMISSION
+} tca_error;
+
+int tca_ec[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+nw_result tca100_initialize(int dev) {
+  nw_result rc;
+  int i;
+
+  rc = spans_initialize(dev);
+  if (rc = NW_SUCCESS) {
+    tick[dev] = 0;
+    for (i = 0; i < MAX_LONG_TX; i++)
+      nw_tx_control[dev][i].ep = 0;
+    long_tx_count[dev] = 0;
+    delayed_tx_first[dev] = delayed_tx_last[dev] = NULL;
+    for (i = 0; i < MAX_LONG_RX; i++)
+      nw_rx_control[dev][i].ep = 0;
+    long_rx_count[dev] = 0;
+    delayed_rx_first[dev] = delayed_rx_last[dev] = NULL;
+    for (i = 0; i < MAX_EP; i++) {
+      tct[i].rx_sar_header = 0;
+      tct[i].rx_control = NULL;
+      tct[i].tx_queued_count = 0;
+      tct[i].tx_control = NULL;
+    }
+    rc = NW_SUCCESS;
+  }
+  return rc;
+}
+
+nw_result tca100_status(int dev) {
+  nw_result rc;
+  atm_device_t atmp;
+  u_int status;
+
+  atmp = (atm_device_t) devct[dev].addr;
+  status = atmp->sreg;
+  if (status & RX_NO_CARRIER) {
+    atmp->creg_set = CR_RX_RESET;
+    atmp->creg_clr = ~CR_RX_RESET;
+    atmp->creg_set = CR_RX_ENABLE;
+    atmp->sreg = 0;
+    rc = NW_NO_CARRIER;
+  } else if (status & RX_CELL_LOST) {
+    atmp->sreg = RX_COUNT_INTR;
+    rc = NW_OVERRUN;
+  } else {
+    rc = NW_SUCCESS;
+  }
+  return rc;
+}
+
+
+void tca100_synch_send(int dev, nw_tcb_t tcb, u_int reply) {
+  vol_u_int *tx_fifo = &((atm_device_t) devct[dev].addr)->txfifo[0];
+  
+#ifdef TRACING
+  printf("Synch sent %x\n", reply);
+#endif
+
+  tx_fifo[0] = tcb->tx_atm_header;
+  tx_fifo[1] = SSM;
+  tx_fifo[2] = HTONL(8);
+  tx_fifo[3] = HTONL(NW_SYNCHRONIZATION);
+  tx_fifo[4] = htonl(reply);
+  tx_fifo[5] = HTONL(8);
+  tx_fifo[6] = 0;
+  tx_fifo[7] = 0;
+  tx_fifo[8] = 0;
+  tx_fifo[9] = 0;
+  tx_fifo[10] = 0;
+  tx_fifo[11] = 0;
+  tx_fifo[12] = 0;
+  tx_fifo[13] = SYNCH_SEGMENT_TRAILER;
+}
+
+#define broken_cell_mend(length) {    \
+  missing = length;                                         \
+  while (missing != 0) {                                    \
+    if (missing > block_count) {                            \
+      limit = 0;                                            \
+      missing -= block_count;                               \
+    } else {                                                \
+      limit = block_count - missing;                        \
+      missing = 0;                                          \
+    }                                                       \
+    while (block_count > limit) {                           \
+      t1 = block[0];                                        \
+      block++;                                              \
+      tx_fifo[1] = t1;                                      \
+      block_count -= 4;                                     \
+    }                                                       \
+    if (block_count == 0) {                                 \
+      ecb->tx_current = tx_header = ecb->tx_current->next;  \
+      if (tx_header != NULL) {                              \
+        block_count = tx_header->block_length;              \
+        block = (vol_u_int *) tx_header->block;             \
+      }                                                     \
+    }                                                       \
+  }                                                         \
+}  
+
+
+nw_result tca100_window_send(int dev, nw_ecb_t ecb, nw_tcb_t tcb,
+			     boolean_t initial) {
+  nw_result rc;
+  register vol_u_int *tx_fifo = &((atm_device_t) devct[dev].addr)->txfifo[0];
+  register vol_u_int *block;
+  register u_int block_count, msg_count;
+  register int com_count;
+  int eom_count;
+  register u_int atm_header, sar_header, sar_trailer;
+  u_int cs_header, end_count;
+  int limit, missing;
+  register u_int t1, t2;
+  nw_tx_header_t tx_header;
+  nw_options options;
+
+  atm_header = tcb->tx_atm_header;
+  if (initial) {
+    sar_header = tcb->tx_sar_header & MID;
+    tx_header = ecb->tx_initial;
+    block = (vol_u_int *) tx_header->block;
+    block_count = tx_header->block_length;
+    options = tx_header->options;
+    msg_count = tx_header->msg_length;
+    if (ecb->protocol == NW_LINE)
+      msg_count += 4;
+    if (options == NW_URGENT)
+      msg_count += 4;
+    cs_header = ecb->protocol | (sar_header & 0xff) << 8 |
+      (msg_count & 0xff00) << 8 | msg_count << 24;
+    tcb->tx_cs_header = cs_header;
+
+    if (msg_count <= SSM_DATA_SIZE) {      /*Single segment message*/
+      tx_fifo[0] = atm_header;
+      sar_trailer = (msg_count + 8) << 26;
+      tx_fifo[1] = SSM | sar_header;      /*Sequence number 0 is implicit*/
+      end_count = msg_count + 4;
+      tx_fifo[1] = cs_header;
+      if (options == NW_URGENT) {
+	tx_fifo[1] = HTONL(NW_URGENT);
+	msg_count -= 4;
+      }
+      if (ecb->protocol == NW_LINE) {
+	tx_fifo[1] = tx_header->peer.local_ep >> 8 |
+	             (tx_header->peer.local_ep & 0x00ff) << 8 |
+	             (tx_header->peer.remote_ep & 0xff00) << 8 |
+		     tx_header->peer.remote_ep << 24;
+	msg_count -= 4;
+      }
+      if (ecb->protocol == NW_SEQ_PACKET) {
+	tcb->tx_synch = 0;
+      } else {
+	tcb->tx_synch = -1;
+      }
+      goto EOM_payload;
+      
+    } else {	                          /*Beginning of message*/
+      tx_fifo[0] = atm_header;
+      sar_trailer = FULL_SEGMENT_TRAILER;
+      tx_fifo[1] = BOM | sar_header;      /*Sequence number 0 is implicit*/
+      tx_fifo[2] = cs_header;
+      if (block_count < BOM_DATA_SIZE) {
+	if (ecb->protocol == NW_LINE) {
+	  t1 = tx_header->peer.local_ep >> 8 |
+	       (tx_header->peer.local_ep & 0x00ff) << 8 |
+	       (tx_header->peer.remote_ep & 0xff00) << 8 |
+	       tx_header->peer.remote_ep << 24;
+	  missing = BOM_DATA_SIZE - 4;
+	  tx_fifo[3] = t1;
+	} else {
+	  missing = BOM_DATA_SIZE;
+	}
+	broken_cell_mend(missing);
+      } else {
+	if (ecb->protocol == NW_LINE) {
+	  t1 = tx_header->peer.local_ep >> 8 |
+	       (tx_header->peer.local_ep & 0x00ff) << 8 |
+	       (tx_header->peer.remote_ep & 0xff00) << 8 |
+	       tx_header->peer.remote_ep << 24;
+	} else {
+	  t1 = block[0];
+	  block_count -= 4;
+	  block++;
+	}
+	t2 = block[0];
+	tx_fifo[3] = t1;
+	tx_fifo[4] = t2;
+	t1 = block[1];
+	t2 = block[2];
+	tx_fifo[5] = t1;
+	tx_fifo[6] = t2;
+	t1 = block[3];
+	t2 = block[4];
+	tx_fifo[7] = t1;
+	tx_fifo[8] = t2;
+	t1 = block[5];
+	t2 = block[6];
+	tx_fifo[9] = t1;
+	tx_fifo[10] = t2;
+	t1 = block[7];
+	t2 = block[8];
+	tx_fifo[11] = t1;
+	tx_fifo[12] = t2;
+	block_count -= (BOM_DATA_SIZE - 4);
+	block += 9;
+      }
+      if (ecb->protocol == NW_RAW) {
+	msg_count -= BOM_DATA_SIZE;
+	com_count = msg_count / COM_DATA_SIZE;
+	msg_count = msg_count % COM_DATA_SIZE;
+	eom_count = 1;
+	tcb->tx_synch = -1;
+      } else if (msg_count > SMALL_WINDOW_SIZE) {
+	com_count = eom_count = 0;
+	tcb->tx_synch = msg_count;
+	msg_count -= BOM_DATA_SIZE;       
+      } else {
+	com_count = 0;
+	eom_count = 1;
+	if (ecb->protocol == NW_SEQ_PACKET) {
+	  tcb->tx_synch = 0;
+	} else {
+	  tcb->tx_synch = -1;
+	}
+	msg_count -= BOM_DATA_SIZE;       
+      }
+      tx_fifo[13] = sar_trailer;
+      sar_header += SEQ_INC;
+    }
+
+  } else {
+    sar_header = tcb->tx_sar_header;
+    sar_trailer = FULL_SEGMENT_TRAILER;
+    block = (vol_u_int *) tcb->tx_p;
+    block_count = tcb->tx_block_count;
+    msg_count = tcb->tx_msg_count;
+    if (msg_count > FINAL_WINDOW_SIZE) {
+      com_count = (CONTINUATION_WINDOW_SIZE / COM_DATA_SIZE);
+      eom_count = 0;
+      tcb->tx_synch = msg_count;
+      msg_count -= CONTINUATION_WINDOW_SIZE;
+    } else {
+      com_count = msg_count / COM_DATA_SIZE;
+      msg_count = msg_count % COM_DATA_SIZE;
+      eom_count = 1;
+      if (ecb->protocol == NW_SEQ_PACKET) {
+	tcb->tx_synch = 0;
+      } else {
+	tcb->tx_synch = -1;
+      }
+    }
+  }
+
+  while (com_count-- > 0) {                 /*Continuation of message*/
+    tx_fifo[0] = atm_header;
+    tx_fifo[1] = sar_header;               /*COM is 0 and is implicit*/
+    if (block_count >= COM_DATA_SIZE) {
+      t1 = block[0];
+      t2 = block[1];
+      tx_fifo[2] = t1;
+      tx_fifo[3] = t2;
+      t1 = block[2];
+      t2 = block[3];
+      tx_fifo[4] = t1;
+      tx_fifo[5] = t2;
+      t1 = block[4];
+      t2 = block[5];
+      tx_fifo[6] = t1;
+      tx_fifo[7] = t2;
+      t1 = block[6];
+      t2 = block[7];
+      tx_fifo[8] = t1;
+      tx_fifo[9] = t2;
+      t1 = block[8];
+      t2 = block[9];
+      tx_fifo[10] = t1;
+      tx_fifo[11] = t2;
+      t1 = block[10];
+      block_count -= COM_DATA_SIZE;
+      tx_fifo[12] = t1;
+      tx_fifo[13] = sar_trailer;
+      block += 11;
+      sar_header = (sar_header + SEQ_INC) & (SEQ_NO | MID);
+    } else {
+      broken_cell_mend(COM_DATA_SIZE);
+      tx_fifo[13] = sar_trailer;
+      sar_header = (sar_header + SEQ_INC) & (SEQ_NO | MID);
+    }
+  }
+
+  if (eom_count != 0) {                               /*End of message*/
+    tx_fifo[0] = atm_header;
+    tx_fifo[1] = EOM | sar_header;
+    end_count = msg_count;
+    sar_trailer = (msg_count + 4) << 26;
+
+ EOM_payload:
+    if (block_count >= msg_count) {
+      if (msg_count & 0x4) {
+	t1 = block[0];
+	tx_fifo[1] = t1;
+      }
+      block = (vol_u_int *) ((char *) block + msg_count);
+      switch (msg_count >> 3) {
+      case 5:
+	t1 = block[-10];
+	t2 = block[-9];
+	tx_fifo[1] = t1;
+	tx_fifo[1] = t2;
+      case 4:
+	t1 = block[-8];
+	t2 = block[-7];
+	tx_fifo[1] = t1;
+	tx_fifo[1] = t2;
+      case 3:
+	t1 = block[-6];
+	t2 = block[-5];
+	tx_fifo[1] = t1;
+	tx_fifo[1] = t2;
+      case 2:
+	t1 = block[-4];
+	t2 = block[-3];
+	tx_fifo[1] = t1;
+	tx_fifo[1] = t2;
+      case 1:
+	t1 = block[-2];
+	t2 = block[-1];
+	tx_fifo[1] = t1;
+	tx_fifo[1] = t2;
+      }
+      msg_count = 0;
+    } else {
+      broken_cell_mend(msg_count);
+      msg_count = 0;
+    }
+
+  EOM_cs_trailer:
+    tx_fifo[1] = tcb->tx_cs_header;
+    switch (end_count) {
+    case 0: tx_fifo[1] = 0;
+    case 4: tx_fifo[1] = 0;
+    case 8: tx_fifo[1] = 0;
+    case 12: tx_fifo[1] = 0;
+    case 16: tx_fifo[1] = 0;
+    case 20: tx_fifo[1] = 0;
+    case 24: tx_fifo[1] = 0;
+    case 28: tx_fifo[1] = 0;
+    case 32: tx_fifo[1] = 0;
+    case 36: tx_fifo[1] = 0;
+    }
+    tx_fifo[13] = sar_trailer;
+  }
+
+  if (tcb->tx_synch == -1) { 
+
+#ifdef TRACING
+    printf("Final window sent\n");
+#endif
+
+    sar_header = (sar_header + MID_INC) & MID;
+    if (sar_header == 0)
+      sar_header = 1;
+    tcb->tx_sar_header = sar_header;
+    rc = NW_SUCCESS;
+  } else {
+
+#ifdef TRACING
+    printf("Window synch at %x\n", msg_count);
+#endif
+
+    tcb->tx_sar_header = sar_header;
+    tcb->tx_p = (u_int *) block;
+    tcb->tx_block_count = block_count;
+    tcb->tx_msg_count = msg_count;
+    rc = NW_SYNCH;
+  }
+  return rc;
+}
+
+nw_result tca100_send(nw_ep ep, nw_tx_header_t header, nw_options options) {
+  nw_result rc;
+  int i, dev;
+  nw_ecb_t ecb;
+  nw_tcb_t tcb;
+  nw_control_t control;
+  nw_tx_header_t tx_header, tx_previous;
+
+  dev = NW_DEVICE(header->peer.rem_addr_1);
+  ecb = &ect[ep];
+  tcb = &tct[ep];
+  if ((options == NW_URGENT && header->msg_length >
+       MTU_URGENT[ecb->protocol]) || header->msg_length > MTU[ecb->protocol]) {
+    rc = NW_BAD_LENGTH;
+  } else if (tcb->tx_queued_count != 0 ||
+	     (ecb->protocol != NW_RAW &&
+	      long_tx_count[dev] >= MAX_LONG_TX &&
+	      (header->msg_length > SMALL_WINDOW_SIZE ||
+	       ecb->protocol == NW_SEQ_PACKET))) {
+    if (options == NW_URGENT && tcb->tx_queued_count != 0) {
+      tx_header = delayed_tx_first[dev];
+      tx_previous = NULL;
+      while (tx_header != NULL && tx_header->sender != ep) {
+	tx_previous = tx_header;
+	tx_header = tx_header->next;
+      }
+      if (tx_previous == NULL) 
+	delayed_tx_first[dev] = header;
+      else 
+	tx_previous->next = header;
+      while (header->next != NULL)
+	header = header->next;
+      header->next = tx_header;
+    } else {
+      if (delayed_tx_first[dev] == NULL)
+	delayed_tx_first[dev] = header;
+      else
+	delayed_tx_last[dev]->next = header;
+      delayed_tx_last[dev] = header;
+    }
+    tcb->tx_queued_count++;
+    rc = NW_QUEUED;
+
+#ifdef TRACING
+    printf("Send enqueued ep %d\n", ep);
+#endif
+    
+  } else {
+
+
+#ifdef TRACING
+    printf("Send ep %d\n", ep);
+#endif
+
+    ecb->tx_initial = ecb->tx_current = header;
+    rc = tca100_window_send(dev, ecb, tcb, TRUE);
+    if (rc == NW_SUCCESS) {
+      while (header != NULL) {
+	if (header->buffer != NULL)
+	  nc_buffer_deallocate(ep, header->buffer);
+	header = header->next;
+      }
+      nc_tx_header_deallocate(ecb->tx_initial);
+      ecb->tx_initial = ecb->tx_current = NULL;
+    } else {
+      control = &nw_tx_control[dev][0];
+      while (control->ep != 0) 
+	control++; 
+      control->ep = ep;
+      control->time_out = tick[dev] + BASE_TIME_OUT;
+      control->retry = 0;
+      tcb->reply = TCA_SYNCH;
+      tcb->tx_control = control;
+      tcb->tx_queued_count++;
+      if (long_tx_count[dev] + long_rx_count[dev] == 0)
+	nc_fast_timer_set(dev);
+      long_tx_count[dev]++;
+    }
+  }
+  return rc;
+}
+
+
+nw_result tx_slot_free(int dev, nw_control_t control) {
+  nw_result rc;
+  nw_tcb_t tcb;
+  nw_ecb_t ecb;
+  nw_tx_header_t tx_header;
+  nw_ep ep;
+
+  tcb = &tct[control->ep];
+  tcb->tx_control = NULL;                               
+  tcb->tx_queued_count--;                             
+  do {                                                            
+    tx_header = delayed_tx_first[dev];                            
+    if (tx_header == NULL) {                                      
+      control->ep = 0;                                            
+      long_tx_count[dev]--;                                       
+      rc = NW_FAILURE;                                            
+    } else {
+      ep = tx_header->sender;
+
+#ifdef TRACING
+    printf("Send dequeued ep %d\n", ep);
+#endif
+
+      ecb = &ect[ep];
+      tcb = &tct[ep];
+      ecb->tx_initial = ecb->tx_current =  tx_header;
+      while (tx_header->next != NULL &&                           
+	     tx_header->next->msg_length == 0) {                  
+	tx_header = tx_header->next;                              
+      }                                                         
+      delayed_tx_first[dev] = tx_header->next;                    
+      if (tx_header->next == NULL)                                
+	delayed_tx_last[dev] = NULL;                              
+      tx_header->next = NULL;                                     
+      rc = tca100_window_send(dev, ecb, tcb, TRUE); 
+      if (rc == NW_SYNCH) {                                         
+	control->ep = ep;                            
+	tcb->tx_control = control;                
+	tcb->reply = TCA_SYNCH;                                 
+	control->time_out = tick[dev] + BASE_TIME_OUT;              
+	control->retry = 0;                                         
+      }                                                             
+    }                                                               
+  } while (rc == NW_SUCCESS);                                       
+  return rc;
+}
+
+nw_result rx_slot_free(int dev, nw_control_t control) {
+  nw_result rc;
+  nw_rx_header_t rx_header;
+  nw_ep ep;
+  nw_tcb_t tcb;
+
+  if (control == NULL) {   
+    rc = NW_SUCCESS;
+  } else {
+    tct[control->ep].rx_control = NULL;                               
+    while ((rx_header = delayed_rx_first[dev]) != NULL &&             
+	   tick[dev] >= rx_header->time_stamp) {                      
+      delayed_rx_first[dev] = rx_header->next;                        
+      nc_buffer_deallocate(rx_header->buffer->peer.local_ep,          
+			   rx_header->buffer);                        
+      ep = rx_header->receiver;
+      tcb = &tct[ep];
+      tcb->rx_sar_header = SSM | (tcb->rx_sar_header & MID);         
+      nc_rx_header_deallocate(rx_header);                             
+    }                                                                 
+    if (rx_header == NULL) {                                          
+      delayed_rx_last[dev] = NULL;                                    
+      control->ep = 0;                                                
+      long_rx_count[dev]--;                                           
+      rc = NW_FAILURE;
+    } else {                                                          
+      delayed_rx_first[dev] = rx_header->next;                        
+      if (rx_header->next == NULL)                                    
+	delayed_rx_last[dev] = NULL;                                  
+      ep = rx_header->receiver;
+      tcb = &tct[ep];
+      tca100_synch_send(dev, tcb, rx_header->reply);
+      control->ep = ep;
+      control->time_out = tick[dev] + BASE_TIME_OUT;                  
+      tcb->rx_control = control;                  
+      nc_rx_header_deallocate(rx_header);                             
+    }                                                                 
+  }
+}
+
+
+int tca100_poll(int dev) {
+  vol_u_int *status = &((atm_device_t) devct[dev].addr)->sreg;
+  vol_u_int *ctl_set = &((atm_device_t) devct[dev].addr)->creg_set;
+  vol_u_int *rx_counter = &((atm_device_t) devct[dev].addr)->rxcount;
+  register vol_u_int *rx_fifo = &((atm_device_t) devct[dev].addr)->rxfifo[0];
+  register u_int rx_cell_count;
+  register u_int predicted_atm_header = 0;
+  register u_int predicted_sar_header;
+  u_int atm_header, sar_header, predicted_sar_trailer,
+        cs_header, end_count, cs_pad, rx_cell_total, reply,
+        block_length, initial_offset;
+  register vol_u_int *msg;
+  register int msg_count;
+  register int next_synch;
+  register u_int t1, t2;
+  nw_ecb_t ecb, tx_ecb;
+  nw_tcb_t new_tcb, tx_tcb;
+  nw_tcb dummy_tcb_s;
+  nw_tcb_t tcb = &dummy_tcb_s;
+  nw_control_t control;
+  nw_buffer_t buffer;
+  nw_protocol protocol;
+  nw_ep lep, rep;
+  nw_delivery delivery_type = NW_RECEIVE;
+  nw_rx_header_t rx_header;
+  nw_tx_header_t tx_header;
+  int i;
+  u_int tx_seqno, rx_seqno, tx_count, rx_count;
+
+  rx_cell_total = 0;
+  while ((rx_cell_count = *rx_counter & RX_COUNTER_MASK) != 0) {
+    rx_cell_total += rx_cell_count;
+    while (rx_cell_count-- > 0) {
+      atm_header = rx_fifo[0];         /*Check ATM header and SAR header*/
+      sar_header = (rx_fifo[1] & SAR_HEADER_MASK);
+      if (atm_header != predicted_atm_header) {
+	                      /*Must be cell from a different connection*/
+	if (atm_header & ~(ATM_VPVC_MASK | ATM_HEADER_RSV_BITS)) {
+ atm_header_error:
+	  tca_ec[ATM_HEADER]++;
+	  if (tca100_verbose)
+		  printf("ATM header error %x\n", atm_header);
+ discard_cell:
+	  *((char *) rx_fifo) = 0; 
+	  delivery_type = NW_RECEIVE;
+	  continue;
+	} else {
+	  t1 = (atm_header & ATM_VPVC_MASK) >> ATM_VPVC_SHIFT;
+	  new_tcb = &tct[t1];
+	  ecb = &ect[t1];
+
+	  /*Switch cached connection*/
+	  if (new_tcb->rx_sar_header == 0)
+	    goto atm_header_error;
+	  tcb->rx_sar_header = predicted_sar_header;
+	  tcb->rx_p = (u_int *) msg;
+	  tcb->rx_count = msg_count;
+	  tcb->rx_next_synch = next_synch;
+	  predicted_atm_header = atm_header;
+	  tcb = new_tcb;
+	  predicted_sar_header = tcb->rx_sar_header;
+	  msg = tcb->rx_p;
+	  msg_count = tcb->rx_count;
+	  next_synch = tcb->rx_next_synch;
+	}
+      }
+      
+      if (sar_header != predicted_sar_header) {
+	if ((sar_header ^ predicted_sar_header) == EOM &&
+	    ((predicted_sar_header & BOM) || msg_count <= EOM_DATA_SIZE)) {
+                                    /*Difference on end of message bit only*/
+	  predicted_sar_header = sar_header;
+	} else if (sar_header == SSM) {                             /*MID 0*/
+	  cs_header = rx_fifo[2];
+	  t1 = rx_fifo[3];
+	  if (cs_header == HTONL(8) && t1 == HTONL(NW_SYNCHRONIZATION)) {
+	    reply = rx_fifo[4];                                /*Synch cell*/
+	    if (rx_fifo[5] != cs_header)
+	      goto cs_header_error;
+	    cs_pad = rx_fifo[6];
+	    t1 = rx_fifo[7];
+	    t2 = rx_fifo[8];
+	    cs_pad |= t1;
+	    cs_pad |= t2;
+	    t1 = rx_fifo[9];
+	    t2 = rx_fifo[10];
+	    cs_pad |= t1;
+	    cs_pad |= t2;
+	    t1 = rx_fifo[11];
+	    t2 = rx_fifo[12];
+	    cs_pad |= t1;
+	    cs_pad |= t2;
+	    t1 = rx_fifo[13];
+	    if (cs_pad)
+	      goto cs_trailer_error;
+	    if ((t1 & SAR_TRAILER_MASK) != SYNCH_SEGMENT_TRAILER)
+	      goto sar_trailer_error;
+	    if (tcb->tx_control == NULL) {
+	      tca_ec[SYNCH_ERROR]++;
+	      if (tca100_verbose)
+		      printf("Synch error %x\n", ntohl(reply));
+	    } else {
+	      tcb->reply = ntohl(reply);
+
+#ifdef TRACING
+	      printf("Received synch ep %d %x\n", ecb->id, tcb->reply);
+#endif
+
+	    }
+	    continue;
+	  } else if (t1 == HTONL(NW_URGENT)) {              /*Urgent cell*/
+	    delivery_type = NW_RECEIVE_URGENT;
+	    goto cs_header_check;
+	  } else {                                          /*Bad segment*/
+	    goto sar_header_error;
+	  }
+	} else if (!(sar_header & ATM_HEADER_CRC_SYNDROME) &&
+		   (sar_header & BOM) && (sar_header & SEQ_NO) == 0) {
+	  if ((sar_header & MID) == (predicted_sar_header & MID)) {
+	                                                 /*Retransmission*/
+	    if (tcb->rx_control != NULL) {
+	      tcb->rx_control->ep = 0;
+	      long_rx_count[dev]--;
+	    }
+	    nc_buffer_deallocate(tcb->rx_buffer->peer.local_ep,
+				 tcb->rx_buffer);
+	    predicted_sar_header = sar_header;
+	    tca_ec[RX_RETRANSMISSION]++;
+	    if (tca100_verbose)
+		    printf("Receiving retransmission ep %d sar %x\n",
+			   ecb->id, sar_header); 
+	  } else if (predicted_sar_header & BOM) {
+                                                    /*Sequence number error*/
+	    if (tca100_verbose)
+		    printf("Sequence error ep %d pred %x real %x\n", ecb->id,
+			   predicted_sar_header, sar_header);
+	    if (ecb->protocol == NW_SEQ_PACKET) {
+	      reply = 0xffff0000 | TCA_SEQ | (predicted_sar_header & MID);
+	      tca100_synch_send(dev, tcb, reply);
+	      tca_ec[SEQ_ERROR]++;
+	      goto discard_cell;
+	    } else {
+	      predicted_sar_header = sar_header;
+	    }
+	  } else {
+	    goto sar_header_error;                     /*Badly out of synch*/
+	  }
+	} else {                                                /*Cell loss*/
+
+ sar_header_error:
+	  if (!(predicted_sar_header & BOM)) {
+	    rx_slot_free(dev, tcb->rx_control);
+	    nc_buffer_deallocate(tcb->rx_buffer->peer.local_ep,
+				 tcb->rx_buffer);
+	    predicted_sar_header = SSM | (predicted_sar_header & MID);
+	  }
+	  tca_ec[SAR_HEADER]++;
+	  if (tca100_verbose)
+		  printf("SAR header error ep %d pred %x real %x\n", ecb->id,
+			 predicted_sar_header, sar_header);
+	  goto discard_cell;
+	}  
+      }
+
+      if ((predicted_sar_header & SEG_TYPE) == COM) { 
+	                                           /*Continuation of message*/
+	if (msg_count <= next_synch) {
+	  if (msg_count == next_synch &&
+	      msg_count >= CONTINUATION_WINDOW_SIZE) {
+	    reply = (msg_count << 16) | TCA_ACK | (predicted_sar_header & MID);
+	    tca100_synch_send(dev, tcb, reply);
+	    if (msg_count > (CONTINUATION_WINDOW_SIZE + FINAL_WINDOW_SIZE)) {
+	      next_synch = msg_count - CONTINUATION_WINDOW_SIZE;
+	    } else if (ecb->protocol == NW_SEQ_PACKET) {
+	      next_synch = 0;
+	    } else {
+	      next_synch = -1;
+	    }
+	    tcb->rx_control->time_out = tick[dev] + BASE_TIME_OUT;
+	  } else {
+	    rx_slot_free(dev, tcb->rx_control);
+	    nc_buffer_deallocate(tcb->rx_buffer->peer.local_ep,
+				 tcb->rx_buffer);
+	    predicted_sar_header = SSM | (predicted_sar_header & MID);
+	    tca_ec[FRAME_ERROR]++;
+	    if (tca100_verbose)
+		    printf("Frame error ep %d\n", ecb->id);
+	    goto discard_cell;
+	  }
+	}
+	t1 = rx_fifo[2];
+	t2 = rx_fifo[3];
+	msg[0] = t1;
+	msg[1] = t2;
+	t1 = rx_fifo[4];
+	t2 = rx_fifo[5];
+	msg[2] = t1;
+	msg[3] = t2;
+	t1 = rx_fifo[6];
+	t2 = rx_fifo[7];
+	msg[4] = t1;
+	msg[5] = t2;
+	t1 = rx_fifo[8];
+	t2 = rx_fifo[9];
+	msg[6] = t1;
+	msg[7] = t2;
+	t1 = rx_fifo[10];
+	t2 = rx_fifo[11];
+	msg[8] = t1;
+	msg[9] = t2;
+	t1 = rx_fifo[12];
+	t2 = rx_fifo[13];
+	msg[10] = t1;
+	if ((t2 & SAR_TRAILER_MASK) != FULL_SEGMENT_TRAILER) {
+	  t1 = t2;
+	  goto sar_trailer_error;
+	}
+	predicted_sar_header = (predicted_sar_header + SEQ_INC) &
+	                                                    (SEQ_NO | MID);
+	msg_count -= COM_DATA_SIZE;
+	msg += 11;
+
+      } else if ((predicted_sar_header & BOM) != 0) {
+	cs_header = rx_fifo[2];
+
+ cs_header_check:
+	block_length = msg_count = (((cs_header >> 8) & 0xff00) |
+				    (cs_header >> 24));
+	protocol = cs_header & 0x00ff;
+	if (protocol == NW_RAW || protocol == NW_SEQ_PACKET) {
+	  lep = ecb->conn->peer.local_ep;
+	  rep = ecb->conn->peer.remote_ep;
+	  if (delivery_type == NW_RECEIVE)
+	    initial_offset = 0;
+	  else
+	    initial_offset = 4;
+	} else {
+	  t1 = rx_fifo[3];
+	  block_length -= 4;
+	  lep = (t1 >> 8) & 0xff00 | t1 >> 24;
+	  rep = (t1 & 0xff00) >> 8 | (t1 & 0x00ff) << 8;
+	  if (delivery_type == NW_RECEIVE)
+	    initial_offset = 4;
+	  else
+	    initial_offset = 8;
+	} 
+	if (protocol != ecb->protocol || (protocol == NW_DATAGRAM) ||
+	    (protocol == NW_LINE && ect[lep].protocol != NW_DATAGRAM) ||
+	    ((predicted_sar_header & 0x00ff) << 8) != (cs_header & 0xff00) ||
+	    ((delivery_type != NW_RECEIVE) &&
+	     msg_count - initial_offset > MTU_URGENT[protocol]) ||
+	    msg_count > MTU[protocol] || (msg_count & 0x3)) {
+
+ cs_header_error:
+	  if ((protocol != NW_RAW && msg_count > SMALL_WINDOW_SIZE) ||
+	      protocol == NW_SEQ_PACKET) {
+	    reply = 0xffff0000 | TCA_NAK | (predicted_sar_header & MID);
+	    tca100_synch_send(dev, tcb, reply);
+	  }
+	  tca_ec[CS_HEADER]++;
+	  if (tca100_verbose)
+		  printf("CS header error ep %d sar %x cs %x\n", ecb->id,
+			 predicted_sar_header, cs_header);
+	  goto discard_cell;
+	}
+	buffer = nc_buffer_allocate(lep, sizeof(nw_buffer_s) + block_length);
+	if (buffer == NULL) {
+	  if ((protocol != NW_RAW && msg_count > SMALL_WINDOW_SIZE) ||
+	      protocol == NW_SEQ_PACKET) {
+	    reply = 0xffff0000 | TCA_OVR | (predicted_sar_header & MID);
+	    tca100_synch_send(dev, tcb, reply);
+	  }
+	  tca_ec[OVERRUN_ERROR]++;
+	  if (tca100_verbose)
+		  printf("Overrun error ep %d\n", ecb->id);
+	  goto discard_cell;
+	}
+	if (protocol == NW_RAW) {
+	  next_synch = -1;
+	} else if (msg_count > SMALL_WINDOW_SIZE) {
+	  reply = (msg_count << 16) | TCA_ACK | (predicted_sar_header & MID);
+	  if (long_rx_count[dev] >= MAX_LONG_RX) {
+	    rx_header = nc_rx_header_allocate();
+	    if (rx_header == NULL) {
+	      nc_buffer_deallocate(lep, buffer);
+	      tca_ec[OVERRUN_ERROR]++;
+	      goto discard_cell;
+	    }
+	    rx_header->buffer = buffer;
+	    rx_header->receiver = ecb->id;
+	    rx_header->reply = reply;
+	    rx_header->time_stamp = tick[dev] + DELAYED_TIME_OUT;
+	    rx_header->next = NULL;
+	    if (delayed_rx_last[dev] == NULL)
+	      delayed_rx_first[dev] = rx_header;
+	    else
+	      delayed_rx_last[dev]->next = rx_header;
+	    delayed_rx_last[dev] = rx_header;
+	  } else {
+	    tca100_synch_send(dev, tcb, reply);
+	    control = &nw_rx_control[dev][0];
+	    while (control->ep != 0)
+	      control++;
+	    control->ep = ecb->id;
+	    control->time_out = tick[dev] + BASE_TIME_OUT;
+	    tcb->rx_control = control;
+	    if (long_rx_count[dev] + long_tx_count[dev] == 0)
+	      nc_fast_timer_set(dev);
+	    long_rx_count[dev]++;
+	  }
+	  if (msg_count > INITIAL_WINDOW_SIZE + FINAL_WINDOW_SIZE)
+	    next_synch = msg_count - INITIAL_WINDOW_SIZE;
+	  else if (protocol == NW_SEQ_PACKET)
+	    next_synch = 0;
+	  else
+	    next_synch = -1;
+	} else if (protocol == NW_SEQ_PACKET) {
+	  next_synch = 0;
+	} else {
+	  next_synch = -1;
+	}
+	msg = (vol_u_int *) ((char *) buffer + sizeof(nw_buffer_s));
+	tcb->rx_cs_header = cs_header;
+	tcb->rx_buffer = buffer;
+	buffer->buf_next = NULL;
+	buffer->msg_seqno = sar_header & MID;
+	buffer->block_offset = sizeof(nw_buffer_s);
+	buffer->block_length = block_length;
+	buffer->peer.rem_addr_1 = ecb->conn->peer.rem_addr_1;
+	buffer->peer.rem_addr_2 = ecb->conn->peer.rem_addr_2;
+	buffer->peer.local_ep = lep;
+	buffer->peer.remote_ep = rep;
+
+	if ((predicted_sar_header & EOM) == 0) {                  /*BOM*/
+	  if (initial_offset == 0) {
+	    t1 = rx_fifo[3];
+	    t2 = rx_fifo[4];
+	    msg[0] = t1;
+	    msg[1] = t2;
+	    msg += 2;
+	  } else {
+	    msg[0] = rx_fifo[4];
+	    msg++;
+	  }
+	  t1 = rx_fifo[5];
+	  t2 = rx_fifo[6];
+	  msg[0] = t1;
+	  msg[1] = t2;
+	  t1 = rx_fifo[7];
+	  t2 = rx_fifo[8];
+	  msg[2] = t1;
+	  msg[3] = t2;
+	  t1 = rx_fifo[9];
+	  t2 = rx_fifo[10];
+	  msg[4] = t1;
+	  msg[5] = t2;
+	  t1 = rx_fifo[11];
+	  t2 = rx_fifo[12];
+	  msg[6] = t1;
+	  t1 = rx_fifo[13];
+	  msg[7] = t2;
+	  if ((t1 & SAR_TRAILER_MASK) != FULL_SEGMENT_TRAILER)
+	    goto sar_trailer_error;
+	  msg_count -= BOM_DATA_SIZE;
+	  msg += 8;
+	  predicted_sar_header = (predicted_sar_header + SEQ_INC) &
+	                                                  (SEQ_NO | MID);
+
+	} else {                                                  /*SSM*/
+	  end_count = msg_count + 4;
+	  predicted_sar_trailer = (msg_count + 8) << 26;
+	  if (delivery_type != NW_RECEIVE) {
+	    msg[0] = NW_URGENT;
+	    msg++;
+	  }
+	  msg_count -= initial_offset;
+	  goto EOM_payload;
+	}
+      } else {                                                    /*EOM*/
+	end_count = msg_count;
+	predicted_sar_trailer = (msg_count + 4) << 26;
+	
+ EOM_payload:
+	if (msg_count & 0x4) {
+	  msg[0] = rx_fifo[2];
+	}
+	msg = (vol_u_int *) ((char *) msg + msg_count);
+	/*Fall-through the cases is intentional*/
+	switch (msg_count >> 3) {
+	case 5:
+	  t1 = rx_fifo[2];
+	  t2 = rx_fifo[2];
+	  msg[-10] = t1;
+	  msg[-9] = t2;
+	case 4:
+	  t1 = rx_fifo[2];
+	  t2 = rx_fifo[2];
+	  msg[-8] = t1;
+	  msg[-7] = t2;
+	case 3:
+	  t1 = rx_fifo[2];
+	  t2 = rx_fifo[2];
+	  msg[-6] = t1;
+	  msg[-5] = t2;
+	case 2:
+	  t1 = rx_fifo[2];
+	  t2 = rx_fifo[2];
+	  msg[-4] = t1;
+	  msg[-3] = t2;
+	case 1:
+	  t1 = rx_fifo[2];
+	  t2 = rx_fifo[2];
+	  msg[-2] = t1;
+	  msg[-1] = t2;
+	}
+
+	/*CS trailer should be equal to the CS header, followed by
+	  padding zeros*/
+	cs_pad = (rx_fifo[2] != tcb->rx_cs_header);
+	/*Fall-through the cases is intentional*/
+	t1 = t2 = 0;
+	switch (end_count) {
+	case 0:
+	  t1 = rx_fifo[2];
+	case 4:
+	  t2 = rx_fifo[2];
+	  cs_pad |= t1;
+	case 8:
+	  t1 = rx_fifo[2];
+	  cs_pad |= t2;
+	case 12:
+	  t2 = rx_fifo[2];
+	  cs_pad |= t1;
+	case 16:
+	  t1 = rx_fifo[2];
+	  cs_pad |= t2;
+	case 20:
+	  t2 = rx_fifo[2];
+	  cs_pad |= t1;
+	case 24:
+	  t1 = rx_fifo[2];
+	  cs_pad |= t2;
+	case 28:
+	  t2 = rx_fifo[2];
+	  cs_pad |= t1;
+	case 32:
+	  t1 = rx_fifo[2];
+	  cs_pad |= t2;
+	case 36:
+	  t2 = rx_fifo[2];
+	  cs_pad |= t1;
+	  cs_pad |= t2;
+	}
+	t1 = rx_fifo[13];
+	if (cs_pad != 0) {
+                                 	     /*Errors in CS trailer or pad*/
+ cs_trailer_error:
+	  tca_ec[CS_TRAILER]++;
+	  if (tca100_verbose)
+		  printf("CS trailer error ep %d hd %x pad %x\n", ecb->id,
+			 tcb->rx_cs_header, cs_pad);
+	  goto trailer_error;
+
+	} else if ((t1 & SAR_TRAILER_MASK) != predicted_sar_trailer) {
+                                         /*Error in SAR trailer or framing*/
+ sar_trailer_error:
+	  tca_ec[SAR_TRAILER]++;
+	  if (tca100_verbose)
+		  printf("SAR trailer error ep %d pred %x real %x\n", ecb->id,
+			 predicted_sar_trailer, t1);
+	  goto trailer_error;
+
+	} else if (!nc_deliver_result(tcb->rx_buffer->peer.local_ep,
+				      delivery_type, (int) tcb->rx_buffer)) {
+	  tca_ec[DELIVERY_ERROR]++;
+	  if (tca100_verbose)
+		  printf("Delivery error ep %d\n", ecb->id);
+
+ trailer_error:
+	  if (next_synch >= 0 && !(t1 & HEADER_CRC_ERROR)) {
+	    reply = (msg_count << 16) | TCA_NAK | (predicted_sar_header & MID);
+	    tca100_synch_send(dev, tcb, reply);
+	  }
+	  rx_slot_free(dev, tcb->rx_control);
+	  nc_buffer_deallocate(tcb->rx_buffer->peer.local_ep,
+			       tcb->rx_buffer);
+	  predicted_sar_header = SSM | (predicted_sar_header & MID);
+	  delivery_type = NW_RECEIVE;
+	} else {
+
+#ifdef TRACING
+	  printf("Received correctly ep %d\n", ecb->id);
+#endif
+
+	  if (next_synch == 0) {
+	    reply = TCA_ACK | (predicted_sar_header & MID);
+	    tca100_synch_send(dev, tcb, reply);
+	  }
+	  rx_slot_free(dev, tcb->rx_control);
+	  if (delivery_type != NW_RECEIVE) {
+	    delivery_type = NW_RECEIVE;
+	    predicted_sar_header = SSM | (predicted_sar_header & MID);
+	  } else {
+	    predicted_sar_header = (predicted_sar_header + MID_INC) & MID;
+	    if (predicted_sar_header == 0)
+	      predicted_sar_header = 1;
+	    predicted_sar_header |= SSM;
+	  }
+	}
+      }
+    }
+
+    control = &nw_tx_control[dev][0];
+    for (i = 0; i < MAX_LONG_TX; i++) {
+      if (control->ep != 0 && tct[control->ep].reply != TCA_SYNCH) {
+	tx_ecb = &ect[control->ep];
+	tx_tcb = &tct[control->ep];
+	rx_seqno = tx_tcb->reply & MID;
+	tx_seqno = tx_tcb->tx_sar_header & MID;
+	rx_count = tx_tcb->reply >> 16;
+	tx_count = tx_tcb->tx_synch;
+	reply = tx_tcb->reply & TCA_SYNCH;
+	if (reply == TCA_ACK) {
+	  if (rx_seqno == tx_seqno && rx_count == tx_count) {
+	    if (rx_count == 0) {
+#ifdef TRACING
+	      printf("Received final ack ep %d\n", tx_ecb->id);
+#endif
+
+	      tx_seqno = (tx_seqno + MID_INC) & MID;
+	      if (tx_seqno == 0)
+		tx_seqno = 1;
+	      tx_tcb->tx_sar_header = tx_seqno;
+	      tx_slot_free(dev, control);
+	      tx_tcb->reply = NW_SUCCESS;
+	      nc_deliver_result(tx_ecb->id, NW_SEND, NW_SUCCESS);
+	    } else {
+	      if (tca100_window_send(dev, tx_ecb, tx_tcb,
+				     FALSE) == NW_SUCCESS) {
+		nc_deliver_result(control->ep, NW_SEND, NW_SUCCESS);
+		tx_tcb->reply = NW_SUCCESS;
+		tx_slot_free(dev, control);
+	      } else {
+		control->time_out = tick[dev] + BASE_TIME_OUT;
+		tx_tcb->reply = TCA_SYNCH;
+	      }
+	    }
+	  } else {
+	    goto synch_error;
+	  }
+	} else if (reply == TCA_OVR) {
+	  if (rx_seqno == tx_seqno && rx_count == 0xffff &&
+	      ((int) tx_ecb->tx_initial->msg_length -
+	       (int) tx_tcb->tx_synch) <= (int) SMALL_WINDOW_SIZE) {
+	    nc_deliver_result(control->ep, NW_SEND, NW_OVERRUN);
+	    tx_tcb->reply = NW_OVERRUN;
+	    tx_slot_free(dev, control);
+	  } else {
+	    goto synch_error;
+	  }
+	} else if (reply == TCA_NAK) {
+	  if (rx_seqno == tx_seqno &&
+	      (rx_count == tx_count || (rx_count == 0xffff &&
+                 ((int) tx_ecb->tx_initial->msg_length -
+		  (int) tx_tcb->tx_synch) <= (int) SMALL_WINDOW_SIZE))) {
+	    if (++control->retry < MAX_RETRY) {
+	      if (tca100_verbose)
+		      printf("Sending retransmission ep %d\n", tx_ecb->id);
+	      if (tca100_window_send(dev, tx_ecb, tx_tcb,
+				     TRUE) == NW_SUCCESS) {
+		nc_deliver_result(control->ep, NW_SEND, NW_SUCCESS);
+		tx_tcb->reply = NW_SUCCESS;
+		tx_slot_free(dev, control);
+	      } else {
+		control->time_out = tick[dev] + BASE_TIME_OUT;
+		tx_tcb->reply = TCA_SYNCH;
+	      }
+	      tca_ec[TX_RETRANSMISSION]++;
+	    } else {
+	      nc_deliver_result(control->ep, NW_SEND, NW_FAILURE);
+	      tx_tcb->reply = NW_FAILURE;
+	      tx_slot_free(dev, control);
+	    }
+	  } else {
+	    goto synch_error;
+	  }
+	} else if (reply == TCA_SEQ) {
+	  if (rx_count == 0xffff && tx_ecb->protocol == NW_SEQ_PACKET &&
+	      ((int) tx_ecb->tx_initial->msg_length -
+	       (int) tx_tcb->tx_synch) <= (int) SMALL_WINDOW_SIZE &&
+	      rx_seqno == ((((tx_seqno + MID_INC) & MID) == 0) ?
+			   1 : tx_seqno + MID_INC)) {
+	    tx_tcb->tx_sar_header = rx_seqno;
+	    if (tca100_window_send(dev, tx_ecb, tx_tcb, 
+				   TRUE) == NW_SUCCESS) {
+	      nc_deliver_result(control->ep, NW_SEND, NW_SUCCESS);
+	      tx_tcb->reply = NW_SUCCESS;
+	      tx_slot_free(dev, control);
+	    } else {
+	      control->time_out = tick[dev] + BASE_TIME_OUT;
+	      tx_tcb->reply = TCA_SYNCH;
+	    }
+	    tca_ec[TX_RETRANSMISSION]++;
+	    if (tca100_verbose)
+		    printf("Sending seq retransmission ep %d\n", tx_ecb->id);
+	  } else {
+	    goto synch_error;
+	  }
+	} else {
+ synch_error:
+	  tca_ec[SYNCH_ERROR]++;
+	  tx_tcb->reply = NW_FAILURE;
+	  if (tca100_verbose)
+		  printf("Synch error\n");
+	}
+      }
+      control++;
+    }
+  }
+  *status = ~(RX_COUNT_INTR | RX_EOM_INTR | RX_TIME_INTR);
+  tcb->rx_sar_header = predicted_sar_header;
+  tcb->rx_p = (u_int *) msg;
+  tcb->rx_count = msg_count;
+  tcb->rx_next_synch = next_synch;
+  *ctl_set = RX_COUNT_INTR;
+  return rx_cell_total;
+}
+
+
+
+void tca100_timer_sweep(int dev) {
+  int i, rt;
+  u_int reply;
+  nw_control_t control;
+  nw_ecb_t ecb;
+  nw_tcb_t tcb;
+  nw_tx_header_t tx_header;
+  nw_rx_header_t rx_header;
+
+  tick[dev]++;
+  control = &nw_rx_control[dev][0];
+  for (i = 0; i < MAX_LONG_RX; i++) {
+    if (control->ep != 0 && control->time_out < tick[dev]) {
+      rx_slot_free(dev, control);
+      tcb = &tct[control->ep];
+      nc_buffer_deallocate(tcb->rx_buffer->peer.local_ep, tcb->rx_buffer);
+      tcb->rx_sar_header = SSM | (tcb->rx_sar_header & MID);
+    }
+    control++;
+  }
+  control = &nw_tx_control[dev][0];
+  for (i = 0; i < MAX_LONG_TX; i++) {
+    if (control->ep != 0 && control->time_out < tick[dev]) {
+      ecb = &ect[control->ep];
+      tcb = &tct[control->ep];
+      if (++control->retry < MAX_RETRY) {
+	if (control->retry == 1) 
+	  rt = ( /* random() */ + devct[dev].local_addr_2) & 0x000f;
+	else
+	  rt = ( /* random() */ + devct[dev].local_addr_1
+		+ devct[dev].local_addr_2) & 0x00ff;
+	control->time_out = tick[dev] + BASE_TIME_OUT + rt;
+	tca100_window_send(dev, ecb, tcb, TRUE);
+	tca_ec[TX_RETRANSMISSION]++;
+      } else {
+	nc_deliver_result(control->ep, NW_SEND, NW_TIME_OUT);
+	tx_slot_free(dev, control);
+      }
+    }
+    control++;
+  }
+  if (long_tx_count[dev] + long_rx_count[dev] > 0)
+    nc_fast_timer_set(dev);
+  else
+    tick[dev] = 0;
+}
+
+nw_buffer_t tca100_rpc(nw_ep ep, nw_tx_header_t header, nw_options options) {
+  nw_result rc;
+  nw_buffer_t buf;
+  nw_ecb_t ecb;
+  nw_tcb_t tcb;
+  nw_rx_header_t rx_header;
+  int dev, poll_time, ncells;
+
+  tcb = &tct[ep];
+  ecb = &ect[header->peer.local_ep];
+  dev = NW_DEVICE(header->peer.rem_addr_1);
+  if ((rc = tca100_send(ep, header, options)) == NW_BAD_LENGTH) {
+    buf = NW_BUFFER_ERROR;
+  } else if (rc == NW_QUEUED) {
+    buf = NULL;
+  } else {
+    poll_time = 0;
+    if (rc == NW_SYNCH) {
+      while (tcb->reply == TCA_SYNCH && poll_time < POLL_LIMIT) {
+	ncells = tca100_poll(dev);
+	if (ncells == 0)
+	  poll_time += POLL_IDLE_TIME;
+	else
+	  poll_time += ncells * POLL_CELL_TIME;
+      }
+    }
+    if (tcb->reply != NW_SUCCESS) {
+      buf = NW_BUFFER_ERROR;
+    } else {
+      while (ecb->rx_first == NULL && poll_time < POLL_LIMIT) {
+	ncells = tca100_poll(dev);
+	if (ncells == 0)
+	  poll_time += POLL_IDLE_TIME;
+	else
+	  poll_time += ncells * POLL_CELL_TIME;
+      }
+      if (ecb->rx_first == NULL) {
+	buf = NULL;
+      } else {
+	rx_header = ecb->rx_first;
+	buf = rx_header->buffer;
+	ecb->rx_first = rx_header->next;
+	if (ecb->rx_first == NULL)
+	  ecb->rx_last = NULL;
+	nc_rx_header_deallocate(rx_header);
+      }
+    }
+  }
+
+  return buf;
+}
+
+
+
+
+
+
+
+
+