patch-2.2.11 linux/drivers/isdn/hisax/netjet.c

Next file: linux/drivers/isdn/hisax/niccy.c
Previous file: linux/drivers/isdn/hisax/mic.c
Back to the patch index
Back to the overall index

diff -u --recursive --new-file v2.2.10/linux/drivers/isdn/hisax/netjet.c linux/drivers/isdn/hisax/netjet.c
@@ -1,13 +1,37 @@
-/* $Id: netjet.c,v 1.3 1998/02/12 23:08:05 keil Exp $
+/* $Id: netjet.c,v 1.10 1999/07/12 21:05:22 keil Exp $
 
  * netjet.c     low level stuff for Traverse Technologie NETJet ISDN cards
  *
- * Author     Karsten Keil (keil@temic-ech.spacenet.de)
+ * Author     Karsten Keil (keil@isdn4linux.de)
  *
  * Thanks to Traverse Technologie Australia for documents and informations
  *
  *
  * $Log: netjet.c,v $
+ * Revision 1.10  1999/07/12 21:05:22  keil
+ * fix race in IRQ handling
+ * added watchdog for lost IRQs
+ *
+ * Revision 1.9  1999/07/01 08:12:05  keil
+ * Common HiSax version for 2.0, 2.1, 2.2 and 2.3 kernel
+ *
+ * Revision 1.8  1998/11/15 23:55:14  keil
+ * changes from 2.0
+ *
+ * Revision 1.7  1998/09/30 22:24:48  keil
+ * Fix missing line in setstack*
+ *
+ * Revision 1.6  1998/08/13 23:36:54  keil
+ * HiSax 3.1 - don't work stable with current LinkLevel
+ *
+ * Revision 1.5  1998/05/25 12:58:21  keil
+ * HiSax golden code from certification, Don't use !!!
+ * No leased lines, no X75, but many changes.
+ *
+ * Revision 1.4  1998/04/15 16:42:35  keil
+ * new init code
+ * new PCI init (2.1.94)
+ *
  * Revision 1.3  1998/02/12 23:08:05  keil
  * change for 2.1.86 (removing FREE_READ/FREE_WRITE from [dev]_kfree_skb()
  *
@@ -25,15 +49,23 @@
 #include "hscx.h"
 #include "isdnl1.h"
 #include <linux/pci.h>
+#ifndef COMPAT_HAS_NEW_PCI
 #include <linux/bios32.h>
+#endif
 #include <linux/interrupt.h>
-#define fcstab  ppp_crc16_table
 #include <linux/ppp_defs.h>
-extern __u16 ppp_crc16_table[256]; /* from ppp code */
+
+#ifndef bus_to_virt
+#define bus_to_virt (u_int *)
+#endif
+
+#ifndef virt_to_bus
+#define virt_to_bus (u_int)
+#endif
 
 extern const char *CardType[];
 
-const char *NETjet_revision = "$Revision: 1.3 $";
+const char *NETjet_revision = "$Revision: 1.10 $";
 
 #define byteout(addr,val) outb(val,addr)
 #define bytein(addr) inb(addr)
@@ -62,6 +94,12 @@
 
 #define NETJET_ISAC_OFF	0xc0
 #define NETJET_ISACIRQ	0x10
+#define NETJET_IRQM0_READ	0x0c
+#define NETJET_IRQM0_READ_1	0x04
+#define NETJET_IRQM0_READ_2	0x08
+#define NETJET_IRQM0_WRITE	0x03
+#define NETJET_IRQM0_WRITE_1	0x01
+#define NETJET_IRQM0_WRITE_2	0x02
 
 #define NETJET_DMA_SIZE 512
 
@@ -115,6 +153,42 @@
 	insb(cs->hw.njet.isac, data, size);
 }
 
+__u16 fcstab[256] =
+{
+	0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
+	0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
+	0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
+	0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
+	0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
+	0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
+	0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
+	0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
+	0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
+	0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
+	0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
+	0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
+	0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
+	0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
+	0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
+	0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
+	0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
+	0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
+	0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
+	0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
+	0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
+	0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
+	0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
+	0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
+	0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
+	0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
+	0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
+	0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
+	0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
+	0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
+	0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
+	0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
+};
+
 static void 
 WriteISACfifo(struct IsdnCardState *cs, u_char *data, int size)
 {
@@ -146,25 +220,20 @@
 mode_tiger(struct BCState *bcs, int mode, int bc)
 {
 	struct IsdnCardState *cs = bcs->cs;
-	char tmp[64];
 
-	if (cs->debug & L1_DEB_HSCX) {
-		sprintf(tmp, "Tiger mode %d bchan %d/%d",
+	if (cs->debug & L1_DEB_HSCX)
+		debugl1(cs, "Tiger mode %d bchan %d/%d",
 			mode, bc, bcs->channel);
-		debugl1(cs, tmp);
-	}
 	bcs->mode = mode;
 	bcs->channel = bc;
 	switch (mode) {
 		case (L1_MODE_NULL):
 			fill_mem(bcs, bcs->hw.tiger.send,
 				NETJET_DMA_SIZE, bc, 0xff);
-			if (cs->debug & L1_DEB_HSCX) {
-				sprintf(tmp, "Tiger stat rec %d/%d send %d",
+			if (cs->debug & L1_DEB_HSCX)
+				debugl1(cs, "Tiger stat rec %d/%d send %d",
 					bcs->hw.tiger.r_tot, bcs->hw.tiger.r_err,
 					bcs->hw.tiger.s_tot); 
-				debugl1(cs, tmp);
-			}
 			if ((cs->bcs[0].mode == L1_MODE_NULL) &&
 				(cs->bcs[1].mode == L1_MODE_NULL)) {
 				cs->hw.njet.dmactrl = 0;
@@ -197,16 +266,14 @@
 			test_and_set_bit(BC_FLG_EMPTY, &bcs->Flag);
 			break;
 	}
-	if (cs->debug & L1_DEB_HSCX) {
-		sprintf(tmp, "tiger: set %x %x %x  %x/%x  pulse=%d",
+	if (cs->debug & L1_DEB_HSCX)
+		debugl1(cs, "tiger: set %x %x %x  %x/%x  pulse=%d",
 			bytein(cs->hw.njet.base + NETJET_DMACTRL),
 			bytein(cs->hw.njet.base + NETJET_IRQMASK0),
 			bytein(cs->hw.njet.base + NETJET_IRQSTAT0),
 			inl(cs->hw.njet.base + NETJET_DMA_READ_ADR),
 			inl(cs->hw.njet.base + NETJET_DMA_WRITE_ADR),
 			bytein(cs->hw.njet.base + NETJET_PULSE_CNT));
-		debugl1(cs, tmp);
-	}
 }
 
 static u_char dummyrr(struct IsdnCardState *cs, int chan, u_char off)
@@ -266,7 +333,7 @@
 			val >>= 1;\
 		}
 
-static void make_raw_data(struct BCState *bcs) {
+static int make_raw_data(struct BCState *bcs) {
 	register u_int i,s_cnt=0;
 	register u_char j;
 	register u_char val;
@@ -274,13 +341,15 @@
 	register u_char s_val = 0;
 	register u_char bitcnt = 0;
 	u_int fcs;
-	char tmp[64];
-	
 	
+	if (!bcs->tx_skb) {
+		debugl1(bcs->cs, "tiger make_raw: NULL skb");
+		return(1);
+	}
 	bcs->hw.tiger.sendbuf[s_cnt++] = HDLC_FLAG_VALUE;
 	fcs = PPP_INITFCS;
-	for (i=0; i<bcs->hw.tiger.tx_skb->len; i++) {
-		val = bcs->hw.tiger.tx_skb->data[i];
+	for (i=0; i<bcs->tx_skb->len; i++) {
+		val = bcs->tx_skb->data[i];
 		fcs = PPP_FCS (fcs, val);
 		MAKE_RAW_BYTE;
 	}
@@ -303,11 +372,9 @@
 		}
 		val >>= 1;
 	}
-	if (bcs->cs->debug & L1_DEB_HSCX) {
-		sprintf(tmp,"tiger make_raw: in %d out %d.%d",
-			bcs->hw.tiger.tx_skb->len, s_cnt, bitcnt);
-		debugl1(bcs->cs,tmp);
-	}
+	if (bcs->cs->debug & L1_DEB_HSCX)
+		debugl1(bcs->cs,"tiger make_raw: in %ld out %d.%d",
+			bcs->tx_skb->len, s_cnt, bitcnt);
 	if (bitcnt) {
 		while (8>bitcnt++) {
 			s_val >>= 1;
@@ -316,8 +383,9 @@
 		bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
 	}
 	bcs->hw.tiger.sendcnt = s_cnt;
-	bcs->tx_cnt -= bcs->hw.tiger.tx_skb->len;
+	bcs->tx_cnt -= bcs->tx_skb->len;
 	bcs->hw.tiger.sp = bcs->hw.tiger.sendbuf;
+	return(0);
 }
 
 static void got_frame(struct BCState *bcs, int count) {
@@ -326,6 +394,7 @@
 	if (!(skb = dev_alloc_skb(count)))
 		printk(KERN_WARNING "TIGER: receive out of memory\n");
 	else {
+		SET_SKB_FREE(skb);
 		memcpy(skb_put(skb, count), bcs->hw.tiger.rcvbuf, count);
 		skb_queue_tail(&bcs->rqueue, skb);
 	}
@@ -349,7 +418,6 @@
 	register u_char r_val = bcs->hw.tiger.r_val;
 	register u_int bitcnt = bcs->hw.tiger.r_bitcnt;
 	u_int *p = buf;
-	char tmp[64];
         
 	for (i=0;i<cnt;i++) {
 		val = bcs->channel ? ((*p>>8) & 0xff) : (*p & 0xff);
@@ -370,11 +438,9 @@
 				} else {
 					r_one=0;
 					state= HDLC_FLAG_SEARCH;
-					if (bcs->cs->debug & L1_DEB_HSCX) {
-						sprintf(tmp,"tiger read_raw: zBit(%d,%d,%d) %x",
+					if (bcs->cs->debug & L1_DEB_HSCX)
+						debugl1(bcs->cs,"tiger read_raw: zBit(%d,%d,%d) %x",
 							bcs->hw.tiger.r_tot,i,j,val);
-						debugl1(bcs->cs,tmp);
-					}
 				}
 			} else if (state == HDLC_FLAG_SEARCH) { 
 				if (val & 1) {
@@ -387,11 +453,9 @@
 						bitcnt=0;
 						r_val=0;
 						state=HDLC_FLAG_FOUND;
-						if (bcs->cs->debug & L1_DEB_HSCX) {
-							sprintf(tmp,"tiger read_raw: flag(%d,%d,%d) %x",
+						if (bcs->cs->debug & L1_DEB_HSCX)
+							debugl1(bcs->cs,"tiger read_raw: flag(%d,%d,%d) %x",
 								bcs->hw.tiger.r_tot,i,j,val);
-							debugl1(bcs->cs,tmp);
-						}
 					}
 					r_one=0;
 				}
@@ -425,12 +489,10 @@
 					bcs->hw.tiger.r_fcs = PPP_INITFCS;
 					bcs->hw.tiger.rcvbuf[0] = r_val;
 					bcs->hw.tiger.r_fcs = PPP_FCS (bcs->hw.tiger.r_fcs, r_val);
-					if (bcs->cs->debug & L1_DEB_HSCX) {
-						sprintf(tmp,"tiger read_raw: byte1(%d,%d,%d) rval %x val %x i %x",
+					if (bcs->cs->debug & L1_DEB_HSCX)
+						debugl1(bcs->cs,"tiger read_raw: byte1(%d,%d,%d) rval %x val %x i %x",
 							bcs->hw.tiger.r_tot,i,j,r_val,val,
 							bcs->cs->hw.njet.irqstat0);
-						debugl1(bcs->cs,tmp);
-					}
 				}
 			} else if (state ==  HDLC_FRAME_FOUND) {
 				if (val & 1) {
@@ -453,11 +515,9 @@
 							state=HDLC_FLAG_SEARCH;
 							bcs->hw.tiger.r_err++;
 						} else {
-							if (bcs->cs->debug & L1_DEB_HSCX) {
-								sprintf(tmp,"tiger frame end(%d,%d): fcs(%x) i %x",
+							if (bcs->cs->debug & L1_DEB_HSCX)
+								debugl1(bcs->cs,"tiger frame end(%d,%d): fcs(%x) i %x",
 									i,j,bcs->hw.tiger.r_fcs, bcs->cs->hw.njet.irqstat0);
-								debugl1(bcs->cs, tmp);
-							}
 							if (bcs->hw.tiger.r_fcs == PPP_GOODFCS) {
 								got_frame(bcs, (bitcnt>>3)-3);
 							} else
@@ -509,7 +569,15 @@
 	u_int *p;
 	int cnt = NETJET_DMA_SIZE/2;
 	
-	if (cs->hw.njet.irqstat0 & 4)
+	if ((cs->hw.njet.irqstat0 & cs->hw.njet.last_is0) & NETJET_IRQM0_READ) {
+		debugl1(cs,"tiger warn read double dma %x/%x",
+			cs->hw.njet.irqstat0, cs->hw.njet.last_is0);
+		return;
+	} else {
+		cs->hw.njet.last_is0 &= ~NETJET_IRQM0_READ;
+		cs->hw.njet.last_is0 |= (cs->hw.njet.irqstat0 & NETJET_IRQM0_READ);
+	}	
+	if (cs->hw.njet.irqstat0 & NETJET_IRQM0_READ_1)
 		p = cs->bcs[0].hw.tiger.rec + NETJET_DMA_SIZE - 1;
 	else
 		p = cs->bcs[0].hw.tiger.rec + cnt - 1;
@@ -517,32 +585,28 @@
 		read_raw(cs->bcs, p, cnt);
 	if (cs->bcs[1].mode == L1_MODE_HDLC)
 		read_raw(cs->bcs + 1, p, cnt);
-	cs->hw.njet.irqstat0 &= 0xf3;
+	cs->hw.njet.irqstat0 &= ~NETJET_IRQM0_READ;
 }
 
 static void write_raw(struct BCState *bcs, u_int *buf, int cnt);
 
 static void fill_dma(struct BCState *bcs)
 {
-	char tmp[64];
 	register u_int *p, *sp;
 	register int cnt;
 
-	if (!bcs->hw.tiger.tx_skb)
+	if (!bcs->tx_skb)
 		return;
-	if (bcs->cs->debug & L1_DEB_HSCX) {
-		sprintf(tmp,"tiger fill_dma1: c%d %4x", bcs->channel,
+	if (bcs->cs->debug & L1_DEB_HSCX)
+		debugl1(bcs->cs,"tiger fill_dma1: c%d %4x", bcs->channel,
 			bcs->Flag);
-			debugl1(bcs->cs,tmp);
-	}
 	if (test_and_set_bit(BC_FLG_BUSY, &bcs->Flag))
 		return;
-	make_raw_data(bcs);
-	if (bcs->cs->debug & L1_DEB_HSCX) {
-		sprintf(tmp,"tiger fill_dma2: c%d %4x", bcs->channel,
+	if (make_raw_data(bcs))
+		return;		
+	if (bcs->cs->debug & L1_DEB_HSCX)
+		debugl1(bcs->cs,"tiger fill_dma2: c%d %4x", bcs->channel,
 			bcs->Flag);
-			debugl1(bcs->cs,tmp);
-	}
 	if (test_and_clear_bit(BC_FLG_NOFRAME, &bcs->Flag)) {
 		write_raw(bcs, bcs->hw.tiger.sendp, bcs->hw.tiger.free);
 	} else if (test_and_clear_bit(BC_FLG_HALF, &bcs->Flag)) {
@@ -582,17 +646,14 @@
 		}
 		write_raw(bcs, p, cnt);
 	}
-	if (bcs->cs->debug & L1_DEB_HSCX) {
-		sprintf(tmp,"tiger fill_dma3: c%d %4x", bcs->channel,
+	if (bcs->cs->debug & L1_DEB_HSCX)
+		debugl1(bcs->cs,"tiger fill_dma3: c%d %4x", bcs->channel,
 			bcs->Flag);
-		debugl1(bcs->cs,tmp);
-	}
 }
 
 static void write_raw(struct BCState *bcs, u_int *buf, int cnt) {
 	u_int mask, val, *p=buf;
 	u_int i, s_cnt;
-	char tmp[64];
         
         if (cnt <= 0)
         	return;
@@ -617,26 +678,23 @@
 				p = bcs->hw.tiger.send;
 		}
 		bcs->hw.tiger.s_tot += s_cnt;
-		if (bcs->cs->debug & L1_DEB_HSCX) {
-			sprintf(tmp,"tiger write_raw: c%d %x-%x %d/%d %d %x", bcs->channel,
-			(u_int)buf, (u_int)p, s_cnt, cnt, bcs->hw.tiger.sendcnt,
-			bcs->cs->hw.njet.irqstat0);
-			debugl1(bcs->cs,tmp);
-		}
+		if (bcs->cs->debug & L1_DEB_HSCX)
+			debugl1(bcs->cs,"tiger write_raw: c%d %x-%x %d/%d %d %x", bcs->channel,
+				(u_int)buf, (u_int)p, s_cnt, cnt,
+				bcs->hw.tiger.sendcnt, bcs->cs->hw.njet.irqstat0);
 		if (bcs->cs->debug & L1_DEB_HSCX_FIFO)
 			printframe(bcs->cs, bcs->hw.tiger.sp, s_cnt, "snd");
 		bcs->hw.tiger.sp += s_cnt;
 		bcs->hw.tiger.sendp = p;
 		if (!bcs->hw.tiger.sendcnt) {
-			if (!bcs->hw.tiger.tx_skb) {
-				sprintf(tmp,"tiger write_raw: NULL skb s_cnt %d", s_cnt);
-				debugl1(bcs->cs, tmp);
+			if (!bcs->tx_skb) {
+				debugl1(bcs->cs,"tiger write_raw: NULL skb s_cnt %d", s_cnt);
 			} else {
 				if (bcs->st->lli.l1writewakeup &&
-					(PACKET_NOACK != bcs->hw.tiger.tx_skb->pkt_type))
-					bcs->st->lli.l1writewakeup(bcs->st, bcs->hw.tiger.tx_skb->len);
-				dev_kfree_skb(bcs->hw.tiger.tx_skb);
-				bcs->hw.tiger.tx_skb = NULL;
+					(PACKET_NOACK != bcs->tx_skb->pkt_type))
+					bcs->st->lli.l1writewakeup(bcs->st, bcs->tx_skb->len);
+				idev_kfree_skb(bcs->tx_skb, FREE_WRITE);
+				bcs->tx_skb = NULL;
 			}
 			test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
 			bcs->hw.tiger.free = cnt - s_cnt;
@@ -646,7 +704,7 @@
 				test_and_clear_bit(BC_FLG_HALF, &bcs->Flag);
 				test_and_set_bit(BC_FLG_NOFRAME, &bcs->Flag);
 			}
-			if ((bcs->hw.tiger.tx_skb = skb_dequeue(&bcs->squeue))) {
+			if ((bcs->tx_skb = skb_dequeue(&bcs->squeue))) {
 				fill_dma(bcs);
 			} else {
 				mask ^= 0xffffffff;
@@ -656,11 +714,9 @@
 						if (p>bcs->hw.tiger.s_end)
 							p = bcs->hw.tiger.send;
 					}
-					if (bcs->cs->debug & L1_DEB_HSCX) {
-						sprintf(tmp, "tiger write_raw: fill rest %d",
+					if (bcs->cs->debug & L1_DEB_HSCX)
+						debugl1(bcs->cs, "tiger write_raw: fill rest %d",
 							cnt - s_cnt);
-						debugl1(bcs->cs,tmp);
-					}
 				}
 				bcs->event |= 1 << B_XMTBUFREADY;
 				queue_task(&bcs->tqueue, &tq_immediate);
@@ -671,24 +727,28 @@
 		test_and_set_bit(BC_FLG_HALF, &bcs->Flag);
 		fill_mem(bcs, buf, cnt, bcs->channel, 0xff);
 		bcs->hw.tiger.free += cnt;
-		if (bcs->cs->debug & L1_DEB_HSCX) {
-			sprintf(tmp,"tiger write_raw: fill half");
-			debugl1(bcs->cs,tmp);
-		}
+		if (bcs->cs->debug & L1_DEB_HSCX)
+			debugl1(bcs->cs,"tiger write_raw: fill half");
 	} else if (test_and_clear_bit(BC_FLG_HALF, &bcs->Flag)) {
 		test_and_set_bit(BC_FLG_EMPTY, &bcs->Flag);
 		fill_mem(bcs, buf, cnt, bcs->channel, 0xff);
-		if (bcs->cs->debug & L1_DEB_HSCX) {
-			sprintf(tmp,"tiger write_raw: fill full");
-			debugl1(bcs->cs,tmp);
-		}
+		if (bcs->cs->debug & L1_DEB_HSCX)
+			debugl1(bcs->cs,"tiger write_raw: fill full");
 	}
 }
 
 static void write_tiger(struct IsdnCardState *cs) {
 	u_int *p, cnt = NETJET_DMA_SIZE/2;
 	
-	if (cs->hw.njet.irqstat0  & 1)
+	if ((cs->hw.njet.irqstat0 & cs->hw.njet.last_is0) & NETJET_IRQM0_WRITE) {
+		debugl1(cs,"tiger warn write double dma %x/%x",
+			cs->hw.njet.irqstat0, cs->hw.njet.last_is0);
+		return;
+	} else {
+		cs->hw.njet.last_is0 &= ~NETJET_IRQM0_WRITE;
+		cs->hw.njet.last_is0 |= (cs->hw.njet.irqstat0 & NETJET_IRQM0_WRITE);
+	}	
+	if (cs->hw.njet.irqstat0  & NETJET_IRQM0_WRITE_1)
 		p = cs->bcs[0].hw.tiger.send + NETJET_DMA_SIZE - 1;
 	else
 		p = cs->bcs[0].hw.tiger.send + cnt - 1;
@@ -696,7 +756,7 @@
 		write_raw(cs->bcs, p, cnt);
 	if (cs->bcs[1].mode == L1_MODE_HDLC)
 		write_raw(cs->bcs + 1, p, cnt);
-	cs->hw.njet.irqstat0 &= 0xfc;
+	cs->hw.njet.irqstat0 &= ~NETJET_IRQM0_WRITE;
 }
 
 static void
@@ -706,45 +766,58 @@
 	long flags;
 
 	switch (pr) {
-		case (PH_DATA_REQ):
+		case (PH_DATA | REQUEST):
 			save_flags(flags);
 			cli();
-			if (st->l1.bcs->hw.tiger.tx_skb) {
+			if (st->l1.bcs->tx_skb) {
 				skb_queue_tail(&st->l1.bcs->squeue, skb);
 				restore_flags(flags);
 			} else {
-				st->l1.bcs->hw.tiger.tx_skb = skb;
+				st->l1.bcs->tx_skb = skb;
 				st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
 				restore_flags(flags);
 			}
 			break;
-		case (PH_PULL_IND):
-			if (st->l1.bcs->hw.tiger.tx_skb) {
+		case (PH_PULL | INDICATION):
+			if (st->l1.bcs->tx_skb) {
 				printk(KERN_WARNING "tiger_l2l1: this shouldn't happen\n");
 				break;
 			}
 			save_flags(flags);
 			cli();
-			st->l1.bcs->hw.tiger.tx_skb = skb;
+			st->l1.bcs->tx_skb = skb;
 			st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
 			restore_flags(flags);
 			break;
-		case (PH_PULL_REQ):
-			if (!st->l1.bcs->hw.tiger.tx_skb) {
+		case (PH_PULL | REQUEST):
+			if (!st->l1.bcs->tx_skb) {
 				test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
-				st->l1.l1l2(st, PH_PULL_CNF, NULL);
+				st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
 			} else
 				test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
 			break;
+		case (PH_ACTIVATE | REQUEST):
+			test_and_set_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
+			mode_tiger(st->l1.bcs, st->l1.mode, st->l1.bc);
+			l1_msg_b(st, pr, arg);
+			break;
+		case (PH_DEACTIVATE | REQUEST):
+			l1_msg_b(st, pr, arg);
+			break;
+		case (PH_DEACTIVATE | CONFIRM):
+			test_and_clear_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
+			test_and_clear_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
+			mode_tiger(st->l1.bcs, 0, st->l1.bc);
+			st->l1.l1l2(st, PH_DEACTIVATE | CONFIRM, NULL);
+			break;
 	}
 }
 
+
 void
 close_tigerstate(struct BCState *bcs)
 {
-	struct sk_buff *skb;
-
-	mode_tiger(bcs, 0, 0);
+	mode_tiger(bcs, 0, bcs->channel);
 	if (test_and_clear_bit(BC_FLG_INIT, &bcs->Flag)) {
 		if (bcs->hw.tiger.rcvbuf) {
 			kfree(bcs->hw.tiger.rcvbuf);
@@ -754,32 +827,26 @@
 			kfree(bcs->hw.tiger.sendbuf);
 			bcs->hw.tiger.sendbuf = NULL;
 		}
-		while ((skb = skb_dequeue(&bcs->rqueue))) {
-			dev_kfree_skb(skb);
-		}
-		while ((skb = skb_dequeue(&bcs->squeue))) {
-			dev_kfree_skb(skb);
-		}
-		if (bcs->hw.tiger.tx_skb) {
-			dev_kfree_skb(bcs->hw.tiger.tx_skb);
-			bcs->hw.tiger.tx_skb = NULL;
+		discard_queue(&bcs->rqueue);
+		discard_queue(&bcs->squeue);
+		if (bcs->tx_skb) {
+			idev_kfree_skb(bcs->tx_skb, FREE_WRITE);
+			bcs->tx_skb = NULL;
 			test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
 		}
 	}
 }
 
 static int
-open_tigerstate(struct IsdnCardState *cs, int bc)
+open_tigerstate(struct IsdnCardState *cs, struct BCState *bcs)
 {
-	struct BCState *bcs = cs->bcs + bc;
-
 	if (!test_and_set_bit(BC_FLG_INIT, &bcs->Flag)) {
-		if (!(bcs->hw.tiger.rcvbuf = kmalloc(HSCX_BUFMAX, GFP_KERNEL))) {
+		if (!(bcs->hw.tiger.rcvbuf = kmalloc(HSCX_BUFMAX, GFP_ATOMIC))) {
 			printk(KERN_WARNING
 			       "HiSax: No memory for tiger.rcvbuf\n");
 			return (1);
 		}
-		if (!(bcs->hw.tiger.sendbuf = kmalloc(RAW_BUFMAX, GFP_KERNEL))) {
+		if (!(bcs->hw.tiger.sendbuf = kmalloc(RAW_BUFMAX, GFP_ATOMIC))) {
 			printk(KERN_WARNING
 			       "HiSax: No memory for tiger.sendbuf\n");
 			return (1);
@@ -787,7 +854,7 @@
 		skb_queue_head_init(&bcs->rqueue);
 		skb_queue_head_init(&bcs->squeue);
 	}
-	bcs->hw.tiger.tx_skb = NULL;
+	bcs->tx_skb = NULL;
 	bcs->hw.tiger.sendcnt = 0;
 	test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
 	bcs->event = 0;
@@ -795,34 +862,17 @@
 	return (0);
 }
 
-static void
-tiger_manl1(struct PStack *st, int pr,
-	  void *arg)
-{
-	switch (pr) {
-		case (PH_ACTIVATE_REQ):
-			test_and_set_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
-			mode_tiger(st->l1.bcs, st->l1.mode, st->l1.bc);
-			st->l1.l1man(st, PH_ACTIVATE_CNF, NULL);
-			break;
-		case (PH_DEACTIVATE_REQ):
-			if (!test_bit(BC_FLG_BUSY, &st->l1.bcs->Flag))
-				mode_tiger(st->l1.bcs, 0, 0);
-			test_and_clear_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
-			break;
-	}
-}
-
 int
 setstack_tiger(struct PStack *st, struct BCState *bcs)
 {
-	if (open_tigerstate(st->l1.hardware, bcs->channel))
+	bcs->channel = st->l1.bc;
+	if (open_tigerstate(st->l1.hardware, bcs))
 		return (-1);
 	st->l1.bcs = bcs;
 	st->l2.l2l1 = tiger_l2l1;
-	st->ma.manl1 = tiger_manl1;
 	setstack_manager(st);
 	bcs->st = st;
+	setstack_l1_B(st);
 	return (0);
 }
 
@@ -830,8 +880,6 @@
 __initfunc(void
 inittiger(struct IsdnCardState *cs))
 {
-	char tmp[128];
-
 	if (!(cs->bcs[0].hw.tiger.send = kmalloc(NETJET_DMA_SIZE * sizeof(unsigned int),
 		GFP_KERNEL | GFP_DMA))) {
 		printk(KERN_WARNING
@@ -845,9 +893,8 @@
 	cs->bcs[1].hw.tiger.s_end = cs->bcs[0].hw.tiger.s_end;
 	
 	memset(cs->bcs[0].hw.tiger.send, 0xff, NETJET_DMA_SIZE * sizeof(unsigned int));
-	sprintf(tmp, "tiger: send buf %x - %x", (u_int)cs->bcs[0].hw.tiger.send,
+	debugl1(cs, "tiger: send buf %x - %x", (u_int)cs->bcs[0].hw.tiger.send,
 		(u_int)(cs->bcs[0].hw.tiger.send + NETJET_DMA_SIZE - 1));
-	debugl1(cs, tmp);
 	outl(virt_to_bus(cs->bcs[0].hw.tiger.send),
 		cs->hw.njet.base + NETJET_DMA_READ_START);
 	outl(virt_to_bus(cs->bcs[0].hw.tiger.s_irq),
@@ -860,9 +907,8 @@
 		       "HiSax: No memory for tiger.rec\n");
 		return;
 	}
-	sprintf(tmp, "tiger: rec buf %x - %x", (u_int)cs->bcs[0].hw.tiger.rec,
+	debugl1(cs, "tiger: rec buf %x - %x", (u_int)cs->bcs[0].hw.tiger.rec,
 		(u_int)(cs->bcs[0].hw.tiger.rec + NETJET_DMA_SIZE - 1));
-	debugl1(cs, tmp);
 	cs->bcs[1].hw.tiger.rec = cs->bcs[0].hw.tiger.rec;
 	memset(cs->bcs[0].hw.tiger.rec, 0xff, NETJET_DMA_SIZE * sizeof(unsigned int));
 	outl(virt_to_bus(cs->bcs[0].hw.tiger.rec),
@@ -871,11 +917,10 @@
 		cs->hw.njet.base + NETJET_DMA_WRITE_IRQ);
 	outl(virt_to_bus(cs->bcs[0].hw.tiger.rec + NETJET_DMA_SIZE - 1),
 		cs->hw.njet.base + NETJET_DMA_WRITE_END);
-	sprintf(tmp, "tiger: dmacfg  %x/%x  pulse=%d",
+	debugl1(cs, "tiger: dmacfg  %x/%x  pulse=%d",
 		inl(cs->hw.njet.base + NETJET_DMA_WRITE_ADR),
 		inl(cs->hw.njet.base + NETJET_DMA_READ_ADR),
 		bytein(cs->hw.njet.base + NETJET_PULSE_CNT));
-	debugl1(cs, tmp);
 	cs->hw.njet.last_is0 = 0;
 	cs->bcs[0].BC_SetStack = setstack_tiger;
 	cs->bcs[1].BC_SetStack = setstack_tiger;
@@ -906,8 +951,8 @@
 netjet_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 {
 	struct IsdnCardState *cs = dev_id;
-	u_char val, sval, stat = 1;
-	char tmp[128];
+	u_char val, sval;
+	long flags;
 
 	if (!cs) {
 		printk(KERN_WARNING "NETjet: Spurious interrupt!\n");
@@ -916,49 +961,49 @@
 	if (!((sval = bytein(cs->hw.njet.base + NETJET_IRQSTAT1)) &
 		NETJET_ISACIRQ)) {
 		val = ReadISAC(cs, ISAC_ISTA);
-		if (cs->debug & L1_DEB_ISAC) {
-			sprintf(tmp, "tiger: i1 %x %x", sval, val);
-			debugl1(cs, tmp);
-		}
+		if (cs->debug & L1_DEB_ISAC)
+			debugl1(cs, "tiger: i1 %x %x", sval, val);
 		if (val) {
 			isac_interrupt(cs, val);
-			stat |= 2;
+			WriteISAC(cs, ISAC_MASK, 0xFF);
+			WriteISAC(cs, ISAC_MASK, 0x0);
 		}
 	}
-	if ((cs->hw.njet.irqstat0 = bytein(cs->hw.njet.base + NETJET_IRQSTAT0))) {
-/*		sprintf(tmp, "tiger: ist0 %x  %x %x  %x/%x  pulse=%d",
+	save_flags(flags);
+	cli();
+	if ((sval = bytein(cs->hw.njet.base + NETJET_IRQSTAT0))) {
+		if (test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
+			restore_flags(flags);
+			return;
+		}
+		cs->hw.njet.irqstat0 = sval;
+		restore_flags(flags);
+/*		debugl1(cs, "tiger: ist0 %x  %x %x  %x/%x  pulse=%d",
 			sval, 
 			bytein(cs->hw.njet.base + NETJET_DMACTRL),
 			bytein(cs->hw.njet.base + NETJET_IRQMASK0),
 			inl(cs->hw.njet.base + NETJET_DMA_READ_ADR),
 			inl(cs->hw.njet.base + NETJET_DMA_WRITE_ADR),
 			bytein(cs->hw.njet.base + NETJET_PULSE_CNT));
-		debugl1(cs, tmp);
 */
-		if (cs->hw.njet.last_is0 & cs->hw.njet.irqstat0 & 0xf) {
-			sprintf(tmp, "tiger: ist0 %x->%x irq lost",
-				cs->hw.njet.last_is0, cs->hw.njet.irqstat0);
-			debugl1(cs, tmp);
-		}
-		cs->hw.njet.last_is0 = cs->hw.njet.irqstat0;
 /*		cs->hw.njet.irqmask0 = ((0x0f & cs->hw.njet.irqstat0) ^ 0x0f) | 0x30;
 */		byteout(cs->hw.njet.base + NETJET_IRQSTAT0, cs->hw.njet.irqstat0);
 /*		byteout(cs->hw.njet.base + NETJET_IRQMASK0, cs->hw.njet.irqmask0);
-*/		if (cs->hw.njet.irqstat0 & 0x0c)
+*/		if (cs->hw.njet.irqstat0 & NETJET_IRQM0_READ)
 			read_tiger(cs);
-		if (cs->hw.njet.irqstat0 & 0x03)
+		if (cs->hw.njet.irqstat0 & NETJET_IRQM0_WRITE)
 			write_tiger(cs);
-	}
+		test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
+	} else
+		restore_flags(flags);
+
 /*	if (!testcnt--) {
 		cs->hw.njet.dmactrl = 0;
 		byteout(cs->hw.njet.base + NETJET_DMACTRL,
 			cs->hw.njet.dmactrl);
 		byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0);
 	}
-*/	if (stat & 2) {
-		WriteISAC(cs, ISAC_MASK, 0xFF);
-		WriteISAC(cs, ISAC_MASK, 0x0);
-	}
+*/
 }
 
 static void
@@ -1004,13 +1049,12 @@
 		case CARD_RELEASE:
 			release_io_netjet(cs);
 			return(0);
-		case CARD_SETIRQ:
-			return(request_irq(cs->irq, &netjet_interrupt,
-					I4L_IRQ_FLAG, "HiSax", cs));
 		case CARD_INIT:
 			inittiger(cs);
 			clear_pending_isac_ints(cs);
 			initisac(cs);
+			/* Reenable all IRQ */
+			cs->writeisac(cs, ISAC_MASK, 0);
 			return(0);
 		case CARD_TEST:
 			return(0);
@@ -1018,9 +1062,11 @@
 	return(0);
 }
 
-
-
-static 	int pci_index __initdata = 0;
+#ifdef COMPAT_HAS_NEW_PCI
+static 	struct pci_dev *dev_netjet __initdata = NULL;
+#else
+static  int pci_index __initdata = 0;
+#endif
 
 __initfunc(int
 setup_netjet(struct IsdnCard *card))
@@ -1029,15 +1075,40 @@
 	struct IsdnCardState *cs = card->cs;
 	char tmp[64];
 #if CONFIG_PCI
+#ifndef COMPAT_HAS_NEW_PCI
 	u_char pci_bus, pci_device_fn, pci_irq;
 	u_int pci_ioaddr, found;
 #endif
-
+#endif
 	strcpy(tmp, NETjet_revision);
 	printk(KERN_INFO "HiSax: Traverse Tech. NETjet driver Rev. %s\n", HiSax_getrev(tmp));
 	if (cs->typ != ISDN_CTYPE_NETJET)
 		return(0);
+	test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
 #if CONFIG_PCI
+#ifdef COMPAT_HAS_NEW_PCI
+	if (!pci_present()) {
+		printk(KERN_ERR "Netjet: no PCI bus present\n");
+		return(0);
+	}
+	if ((dev_netjet = pci_find_device(PCI_VENDOR_TRAVERSE_TECH,
+		PCI_NETJET_ID,  dev_netjet))) {
+		cs->irq = dev_netjet->irq;
+		if (!cs->irq) {
+			printk(KERN_WARNING "NETjet: No IRQ for PCI card found\n");
+			return(0);
+		}
+		cs->hw.njet.base = dev_netjet->base_address[0]
+			& PCI_BASE_ADDRESS_IO_MASK; 
+		if (!cs->hw.njet.base) {
+			printk(KERN_WARNING "NETjet: No IO-Adr for PCI card found\n");
+			return(0);
+		}
+	} else {
+		printk(KERN_WARNING "NETjet: No PCI card found\n");
+		return(0);
+	}
+#else
 	found = 0;
 	for (; pci_index < 0xff; pci_index++) {
 		if (pcibios_find_device(PCI_VENDOR_TRAVERSE_TECH,
@@ -1045,7 +1116,7 @@
 			== PCIBIOS_SUCCESSFUL)
 			found = 1;
 		else
-			break;
+			continue;
 		/* get IRQ */
 		pcibios_read_config_byte(pci_bus, pci_device_fn,
 			PCI_INTERRUPT_LINE, &pci_irq);
@@ -1060,6 +1131,7 @@
 		printk(KERN_WARNING "NETjet: No PCI card found\n");
 		return(0);
 	}
+	pci_index++;
 	if (!pci_irq) {
 		printk(KERN_WARNING "NETjet: No IRQ for PCI card found\n");
 		return(0);
@@ -1068,11 +1140,11 @@
 		printk(KERN_WARNING "NETjet: No IO-Adr for PCI card found\n");
 		return(0);
 	}
-	pci_ioaddr &= ~3; /* remove io/mem flag */
-	cs->hw.njet.base = pci_ioaddr; 
-	cs->hw.njet.auxa = pci_ioaddr + NETJET_AUXDATA;
-	cs->hw.njet.isac = pci_ioaddr | NETJET_ISAC_OFF;
+	cs->hw.njet.base = pci_ioaddr & PCI_BASE_ADDRESS_IO_MASK; 
 	cs->irq = pci_irq;
+#endif /* COMPAT_HAS_NEW_PCI */
+	cs->hw.njet.auxa = cs->hw.njet.base + NETJET_AUXDATA;
+	cs->hw.njet.isac = cs->hw.njet.base | NETJET_ISAC_OFF;
 	bytecnt = 256;
 #else
 	printk(KERN_WARNING "NETjet: NO_PCI_BIOS\n");
@@ -1101,6 +1173,8 @@
 	cs->BC_Write_Reg = &dummywr;
 	cs->BC_Send_Data = &fill_dma;
 	cs->cardmsg = &NETjet_card_msg;
+	cs->irq_func = &netjet_interrupt;
+	cs->irq_flags |= SA_SHIRQ;
 	ISACVersion(cs, "NETjet:");
 	return (1);
 }

FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)