patch-1.3.93 linux/drivers/isdn/pcbit/layer2.c

• Lines: 860
• Date: Sun Apr 21 11:56:14 1996
• Orig file: v1.3.92/linux/drivers/isdn/pcbit/layer2.c
• Orig date: Thu Jan 1 02:00:00 1970

diff -u --recursive --new-file v1.3.92/linux/drivers/isdn/pcbit/layer2.c linux/drivers/isdn/pcbit/layer2.c
@@ -0,0 +1,859 @@
+/*
+ * Copyright (C) 1996 Universidade de Lisboa
+ * 
+ * Writen by Pedro Roque Marques (roque@di.fc.ul.pt)
+ *
+ * This software may be used and distributed according to the terms of 
+ * the GNU Public License, incorporated herein by reference.
+ */
+
+/*        
+ *        PCBIT-D low-layer interface
+ */
+
+/*
+ *        Based on documentation provided by Inesc:
+ *        - "Interface com bus do PC para o PCBIT e PCBIT-D", Inesc, Jan 93
+ */
+
+/*
+ *        TODO: better handling of errors
+ *              re-write/remove debug printks
+ */ 
+
+#define __NO_VERSION__
+
+
+#ifdef MODULE
+#define INCLUDE_INLINE_FUNCS
+#endif
+
+
+#include <linux/module.h>
+
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/malloc.h>
+#include <linux/interrupt.h>
+#include <linux/tqueue.h>
+#include <linux/mm.h>
+#include <linux/skbuff.h>
+
+#include <linux/isdnif.h>
+
+#include <asm/system.h>
+#include <asm/io.h>
+
+
+#include "pcbit.h"
+#include "layer2.h"
+#include "edss1.h"
+
+#undef DEBUG_FRAG
+
+
+
+/*
+ *  task queue struct
+ */ 
+struct tq_struct *tq_delivery=NULL;
+
+static void do_pcbit_bh(task_queue *list)
+{
+	run_task_queue(list);
+}
+
+struct tq_struct run_delivery= {
+        0, 0, (void *)(void *) do_pcbit_bh, &tq_delivery,
+};
+
+
+/*
+ *  Layer 3 packet demultiplexer
+ *  drv.c
+ */
+
+extern void pcbit_l3_receive(struct pcbit_dev * dev, ulong msg, 
+			     struct sk_buff * skb,
+			     ushort hdr_len, ushort refnum);
+
+/*
+ *  Prototypes
+ */
+
+void pcbit_deliver(void * data);
+static void pcbit_transmit(struct pcbit_dev * dev);
+
+static void pcbit_recv_ack(struct pcbit_dev *dev, unsigned char ack);
+static void pcbit_frame_read(struct pcbit_dev * dev, unsigned char read_seq);
+
+static void pcbit_l2_error(struct pcbit_dev *dev);
+static void pcbit_l2_active_conf(struct pcbit_dev *dev, u_char info);
+static void pcbit_l2_err_recover(unsigned long data);
+
+static void pcbit_firmware_bug(struct pcbit_dev * dev);
+
+static void pcbit_sched_delivery(struct pcbit_dev *dev)
+{
+  queue_task_irq_off(&dev->qdelivery, &tq_delivery);
+  queue_task_irq_off(&run_delivery, &tq_immediate);
+  mark_bh(IMMEDIATE_BH);
+}
+
+
+/*
+ *  Called from layer3
+ */
+
+int pcbit_l2_write(struct pcbit_dev * dev, ulong msg, ushort refnum, 
+		   struct sk_buff *skb, unsigned short hdr_len)
+        
+{
+        struct frame_buf * frame, * ptr;
+        unsigned long flags;
+
+        if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING) {
+                dev_kfree_skb(skb, FREE_WRITE);
+                return -1;
+        }
+
+        if ( (frame = (struct frame_buf *) kmalloc(sizeof(struct frame_buf), 
+						   GFP_ATOMIC)) == NULL ) {
+                printk(KERN_WARNING "pcbit_2_write: kmalloc failed\n");
+		dev_kfree_skb(skb, FREE_WRITE);
+                return -1;
+        }
+
+        frame->msg = msg;
+        frame->refnum = refnum;
+        frame->copied = 0;        
+        frame->hdr_len = hdr_len;
+
+        if (skb) {
+                frame->dt_len = skb->len - hdr_len;
+		if (frame->dt_len == 0)
+                        skb->lock++;
+        }
+        else
+                frame->dt_len = 0;
+
+        frame->skb = skb;
+
+        frame->next = NULL;
+
+        save_flags(flags);
+        cli();
+
+        if (dev->write_queue == NULL) {
+                dev->write_queue = frame;
+		restore_flags(flags);
+                pcbit_transmit(dev);
+        }
+        else {        
+                for(ptr=dev->write_queue; ptr->next; ptr=ptr->next);
+                ptr->next = frame;
+                
+                restore_flags(flags);
+        }
+        return 0;
+}
+
+static __inline__ void pcbit_tx_update(struct pcbit_dev *dev, ushort len)
+{
+        u_char info;
+
+        dev->send_seq = (dev->send_seq + 1) % 8;
+
+        dev->fsize[dev->send_seq] = len;
+        info = 0;
+        info |= dev->rcv_seq  << 3;
+        info |= dev->send_seq;
+
+        writeb(info, dev->sh_mem + BANK4);
+
+}
+
+/*
+ * called by interrupt service routine or by write_2
+ */
+
+static void pcbit_transmit(struct pcbit_dev * dev)
+{
+        struct frame_buf * frame = NULL;
+        unsigned char unacked;
+        int flen;           /* fragment frame length including all headers */
+	int totlen;         /* non-fragmented frame length */
+        int free;
+	int count, cp_len;
+        unsigned long flags;
+	unsigned short tt;
+
+        if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING)
+                return;
+
+        unacked = (dev->send_seq + (8 - dev->unack_seq) ) & 0x07;
+
+        if (dev->free > 16 && dev->write_queue && unacked < 7) {
+
+                save_flags(flags);
+                cli();
+
+
+                if (!dev->w_busy)
+                        dev->w_busy = 1;
+                else
+                {
+                        restore_flags(flags);
+                        return;
+                }
+
+                restore_flags(flags);
+
+                frame = dev->write_queue;
+                free = dev->free;
+
+		if (frame->copied == 0) {
+
+                        /* Type 0 frame */
+
+                        struct msg_fmt * msg;
+
+			if (frame->skb)
+				totlen = FRAME_HDR_LEN + PREHDR_LEN + frame->skb->len;
+			else
+				totlen = FRAME_HDR_LEN + PREHDR_LEN;
+
+			flen = MIN(totlen, free);
+
+                        msg = (struct msg_fmt *) &(frame->msg);
+
+                        /*
+                         *  Board level 2 header 
+                         */
+
+                        pcbit_writew(dev, flen - FRAME_HDR_LEN);
+
+                        pcbit_writeb(dev, msg->cpu);
+
+                        pcbit_writeb(dev, msg->proc);
+
+                        /* TH */
+                        pcbit_writew(dev, frame->hdr_len + PREHDR_LEN);
+
+                        /* TD */
+                        pcbit_writew(dev, frame->dt_len);
+
+
+                        /*
+                         *  Board level 3 fixed-header 
+                         */
+	
+                        /* LEN = TH */
+                        pcbit_writew(dev, frame->hdr_len + PREHDR_LEN);
+	
+                        /* XX */
+                        pcbit_writew(dev, 0);
+
+                        /* C + S */
+                        pcbit_writeb(dev, msg->cmd);
+                        pcbit_writeb(dev, msg->scmd);
+
+                        /* NUM */
+                        pcbit_writew(dev, frame->refnum);
+			
+			count = FRAME_HDR_LEN + PREHDR_LEN;
+		}
+		else {
+			/* Type 1 frame */
+
+                        totlen = 2 + (frame->skb->len - frame->copied);
+	  
+			flen = MIN(totlen, free);
+
+                        /* TT */
+                        tt = ((ushort) (flen - 2)) | 0x8000U; /* Type 1 */
+                        pcbit_writew(dev, tt);
+
+			count = 2;
+		}
+
+		if (frame->skb) {
+			cp_len = MIN(frame->skb->len - frame->copied, 
+                                     flen - count);
+		
+			memcpy_topcbit(dev, frame->skb->data + frame->copied, 
+                                       cp_len);
+			frame->copied += cp_len;
+		}
+
+		/* bookeeping */
+		dev->free -= flen;
+		pcbit_tx_update(dev, flen);
+
+		save_flags(flags);
+		cli();
+
+
+                if (frame->skb == NULL || frame->copied == frame->skb->len) {
+
+                        dev->write_queue = frame->next;
+
+                        if (frame->skb != NULL) {
+                                /* free frame */
+                                dev_kfree_skb(frame->skb, FREE_WRITE);
+                        }
+
+                        kfree(frame);
+                }
+
+		dev->w_busy = 0;
+		restore_flags(flags);				
+        }
+#ifdef DEBUG
+        else
+                printk(KERN_DEBUG "unacked %d free %d write_queue %s\n",
+                       unacked, dev->free, dev->write_queue ? "not empty" : 
+		       "empty");
+#endif
+}
+
+
+/*
+ *  deliver a queued frame to the upper layer
+ */
+
+void pcbit_deliver(void * data)
+{ 
+        struct frame_buf *frame;
+        unsigned long flags;
+	struct msg_fmt msg;
+        struct pcbit_dev *dev = (struct pcbit_dev *) data;
+
+	save_flags(flags);
+        cli();
+
+        /* get frame from queue */
+        if (!(frame=dev->read_queue)) {
+		restore_flags(flags);
+                return;
+	}
+
+        dev->read_queue = frame->next;
+        restore_flags(flags);
+
+	msg.cpu = 0;
+	msg.proc = 0;
+	msg.cmd = frame->skb->data[2];
+	msg.scmd = frame->skb->data[3];
+
+	frame->refnum = *((ushort*) frame->skb->data + 4);
+	frame->msg = *((ulong*) &msg);
+	
+	skb_pull(frame->skb, 6);
+
+        pcbit_l3_receive(dev, frame->msg, frame->skb, frame->hdr_len, 
+			 frame->refnum);
+
+        kfree(frame);
+}
+
+/*
+ * Reads BANK 2 & Reassembles 
+ */
+
+static void pcbit_receive(struct pcbit_dev * dev)
+{
+        unsigned short tt;
+	u_char cpu, proc;
+        struct frame_buf * frame = NULL;
+        unsigned long flags;
+        u_char type1;
+
+        if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING)
+                return;
+
+        tt = pcbit_readw(dev);
+
+        if ((tt & 0x7fffU) > 511) {
+                printk(KERN_INFO "pcbit: invalid frame length -> TT=%04x\n", 
+		       tt);
+                pcbit_l2_error(dev);
+                return;
+        }
+
+        if (!(tt & 0x8000U))
+        {                       /* Type 0 */
+                type1 = 0;
+
+                if (dev->read_frame) {
+                        printk(KERN_DEBUG "pcbit_receive: Type 0 frame and read_frame != NULL\n");
+#if 0
+                        pcbit_l2_error(dev);
+                        return;
+#else
+			/* discard previous queued frame */
+			if (dev->read_frame->skb) {
+				dev->read_frame->skb->free = 1;
+				kfree_skb(dev->read_frame->skb, FREE_READ);
+			}
+			kfree(dev->read_frame);
+			dev->read_frame = NULL;
+#endif
+                }
+
+                frame = kmalloc(sizeof(struct frame_buf), GFP_ATOMIC);
+      
+                if (frame == NULL) {
+                        printk(KERN_WARNING "kmalloc failed\n");
+                        return;
+                }
+                memset(frame, 0, sizeof(struct frame_buf));
+      
+                cpu = pcbit_readb(dev);
+                proc = pcbit_readb(dev);
+
+
+                if (cpu != 0x06 && cpu != 0x02)
+                {
+                        printk (KERN_DEBUG "pcbit: invalid cpu value\n");
+			kfree(frame);
+			pcbit_l2_error(dev);
+                        return;
+                }
+
+                /*
+                 * we discard cpu & proc on receiving
+                 * but we read it to update the pointer
+                 */
+      
+                frame->hdr_len = pcbit_readw(dev);
+                frame->dt_len = pcbit_readw(dev);
+
+		/* 
+                 * 0 sized packet 
+                 * I don't know if they are an error or not...
+                 * But they are very frequent
+                 * Not documented
+                 */
+
+		if (frame->hdr_len == 0) {
+                        kfree(frame);
+#ifdef DEBUG
+                        printk(KERN_DEBUG "0 sized frame\n");
+#endif
+			pcbit_firmware_bug(dev);
+                        return;
+		}
+		
+                /* sanity check the length values */
+                if (frame->hdr_len > 1024 || frame->dt_len > 2048)
+                {
+#ifdef DEBUG
+                        printk(KERN_DEBUG "length problem: ");
+                        printk(KERN_DEBUG "TH=%04x TD=%04x\n", 
+			       frame->hdr_len, 
+                               frame->dt_len);
+#endif
+			pcbit_l2_error(dev);
+			kfree(frame);
+                        return;
+                }
+
+                /* miminum frame read */
+
+		frame->skb = dev_alloc_skb(frame->hdr_len + frame->dt_len + 
+					   ((frame->hdr_len + 15) & ~15));
+
+		if (!frame->skb) {
+			printk(KERN_DEBUG "pcbit_receive: out of memmory\n");
+			kfree(frame);
+			return;
+		}
+
+                /* 16 byte aligment for IP */		       
+		if (frame->dt_len)
+                        skb_reserve(frame->skb, (frame->hdr_len + 15) & ~15);
+
+        }
+        else {
+		/* Type 1 */
+                type1 = 1;
+                tt &= 0x7fffU;
+
+                if (!(frame = dev->read_frame)) {                
+                        printk("Type 1 frame and no frame queued\n");
+#if 1
+			/* usualy after an error: toss frame */
+			dev->readptr += tt;
+			if (dev->readptr > dev->sh_mem + BANK2 + BANKLEN)
+				dev->readptr -= BANKLEN;
+#else
+                        pcbit_l2_error(dev);
+#endif
+                        return;
+
+                }
+        }
+
+	memcpy_frompcbit(dev, skb_put(frame->skb, tt), tt);
+
+	frame->copied += tt;
+
+        if (frame->copied == frame->hdr_len + frame->dt_len) {
+           
+                save_flags(flags);
+                cli();
+      
+                if (type1) {
+                        dev->read_frame = NULL;
+                }
+      
+                if (dev->read_queue) {
+                        struct frame_buf *ptr;
+                        for(ptr=dev->read_queue;ptr->next;ptr=ptr->next);
+                        ptr->next = frame;
+                }
+                else
+                        dev->read_queue = frame;
+
+                pcbit_sched_delivery(dev);
+                restore_flags(flags);
+
+        }
+        else {        
+                save_flags(flags);
+                cli();
+                dev->read_frame = frame;
+                restore_flags(flags);
+        }
+}
+
+/*
+ *  The board sends 0 sized frames
+ *  They are TDATA_CONFs that get messed up somehow
+ *  gotta send a fake acknowledment to the upper layer somehow
+ */
+
+static __inline__ void pcbit_fake_conf(struct pcbit_dev *dev, struct pcbit_chan * chan)
+{
+     isdn_ctrl ictl;
+
+     if (chan->queued) {
+	     chan->queued--;
+	     
+	     ictl.driver = dev->id;
+	     ictl.command = ISDN_STAT_BSENT;
+	     ictl.arg = chan->id;
+	     dev->dev_if->statcallb(&ictl);     
+     }
+}
+
+static void pcbit_firmware_bug(struct pcbit_dev * dev) 
+{
+        struct pcbit_chan *chan;
+        
+        chan = dev->b1;
+
+        if (chan->fsm_state == ST_ACTIVE) {
+	    pcbit_fake_conf(dev, chan);
+        }
+
+        chan = dev->b2;
+
+        if (chan->fsm_state == ST_ACTIVE) {
+	    pcbit_fake_conf(dev, chan);
+        }
+ 
+}
+
+void pcbit_irq_handler(int interrupt, void * devptr, struct pt_regs *regs)
+{
+        struct pcbit_dev * dev;
+        u_char info, ack_seq, read_seq;
+        u_char ack_int = 1;
+
+	dev = (struct pcbit_dev *) devptr;
+
+        if (!dev)
+        {
+                printk(KERN_WARNING "pcbit_irq_handler: wrong device\n");
+                return;
+        }
+
+	if (dev->interrupt) {
+	        printk(KERN_DEBUG "pcbit: reentering interrupt hander\n");
+		return;
+	}
+
+	dev->interrupt = 1;
+
+        info = readb(dev->sh_mem + BANK3);
+
+        if (dev->l2_state == L2_STARTING || dev->l2_state == L2_ERROR)
+        {
+                pcbit_l2_active_conf(dev, info);
+		dev->interrupt = 0;
+                return;
+        }
+
+        if (info & 0x40U)       /* E bit set */
+        {
+#ifdef DEBUG
+		printk(KERN_DEBUG "pcbit_irq_handler: E bit on\n");
+#endif
+                pcbit_l2_error(dev);
+		dev->interrupt = 0;
+                return;
+        }
+
+        if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING) 
+	{
+	        dev->interrupt = 0;
+                return;
+	}
+
+        ack_seq =  (info >> 3) & 0x07U;
+        read_seq = (info & 0x07U); 
+        
+	dev->interrupt = 0;
+	sti();
+
+	/*
+	 *	Bottom Half
+	 *	Runs with ints enabled
+	 */
+
+        if (read_seq != dev->rcv_seq)
+        {
+                pcbit_frame_read(dev, read_seq);
+                ack_int = 0;
+        }
+
+	if (ack_seq != dev->unack_seq)
+        {
+                pcbit_recv_ack(dev, ack_seq);
+                ack_int = 0;
+        }
+
+        if (ack_int) 
+	{
+                info = 0;
+                info |= dev->rcv_seq << 3;
+                info |= dev->send_seq;
+    
+                writeb(info, dev->sh_mem + BANK4);  
+        }	
+}
+
+
+static void pcbit_l2_active_conf(struct pcbit_dev *dev, u_char info)
+{
+        u_char state;
+
+        state = dev->l2_state;
+
+#ifdef DEBUG
+        printk(KERN_DEBUG "layer2_active_confirm\n");
+#endif
+        
+
+        if (info & 0x80U ) {
+                dev->rcv_seq = info & 0x07U;
+                dev->l2_state = L2_RUNNING;
+        }
+        else
+                dev->l2_state = L2_DOWN;
+                
+	if (state == L2_STARTING)
+                wake_up_interruptible(&dev->set_running_wq);
+
+        if (state == L2_ERROR && dev->l2_state == L2_RUNNING) {
+                pcbit_transmit(dev);
+        }
+
+}
+
+static void pcbit_l2_err_recover(unsigned long data) 
+{
+
+        struct pcbit_dev * dev;
+        struct frame_buf *frame;
+
+        dev = (struct pcbit_dev *) data;
+
+        del_timer(&dev->error_recover_timer);
+	if (dev->w_busy || dev->r_busy)
+	  {
+	    init_timer(&dev->error_recover_timer);
+	    dev->error_recover_timer.expires = jiffies + ERRTIME;
+	    add_timer(&dev->error_recover_timer);
+	    return;
+	  }
+
+	dev->w_busy = dev->r_busy = 1;
+
+        if (dev->read_frame) {
+                if (dev->read_frame->skb) {
+			dev->read_frame->skb->free = 1; 
+                        kfree_skb(dev->read_frame->skb, FREE_READ);
+		}
+                kfree(dev->read_frame);
+                dev->read_frame = NULL;
+        }
+
+
+        if (dev->write_queue) {
+                frame = dev->write_queue;
+#ifdef FREE_ON_ERROR
+                dev->write_queue = dev->write_queue->next;
+
+		if (frame->skb) {
+                        dev_kfree_skb(frame->skb, FREE_WRITE);
+		}
+		
+                kfree(frame);
+#else		
+                frame->copied = 0;
+#endif
+        }
+
+        dev->rcv_seq = dev->send_seq = dev->unack_seq = 0;
+        dev->free = 511;
+        dev->l2_state = L2_ERROR;
+
+	/* this is an hack... */
+	pcbit_firmware_bug(dev);
+
+        dev->writeptr = dev->sh_mem;
+        dev->readptr = dev->sh_mem + BANK2;
+
+	writeb((0x80U | ((dev->rcv_seq & 0x07) << 3) | (dev->send_seq & 0x07)),
+	       dev->sh_mem + BANK4);
+	dev->w_busy = dev->r_busy = 0;
+
+}
+
+static void pcbit_l2_error(struct pcbit_dev *dev)
+{
+        if (dev->l2_state == L2_RUNNING) {
+
+                printk(KERN_INFO "pcbit: layer 2 error\n");
+
+#ifdef DEBUG
+                log_state(dev);
+#endif
+                
+                dev->l2_state = L2_DOWN;
+
+                init_timer(&dev->error_recover_timer);
+                dev->error_recover_timer.function = &pcbit_l2_err_recover;
+                dev->error_recover_timer.data = (ulong) dev;
+                dev->error_recover_timer.expires = jiffies + ERRTIME;
+                add_timer(&dev->error_recover_timer);
+        }
+}
+
+/*
+ * Description:
+ * if board acks frames
+ *   update dev->free
+ *   call pcbit_transmit to write possible queued frames
+ */
+
+static void  pcbit_recv_ack(struct pcbit_dev *dev, unsigned char ack)
+{
+        int i, count;
+        int unacked;
+
+        unacked = (dev->send_seq + (8 - dev->unack_seq) ) & 0x07;
+
+        /* dev->unack_seq < ack <= dev->send_seq; */
+
+        if (unacked) 
+	{
+
+		if (dev->send_seq > dev->unack_seq)
+                        if (ack <= dev->unack_seq || ack > dev->send_seq) 
+			{
+                                printk("layer 2 ack unacceptable - dev %d", dev->id);
+                                pcbit_l2_error(dev);
+                        }
+                        else
+                                if (ack > dev->send_seq && ack <= dev->unack_seq) {
+					printk("layer 2 ack unacceptable - dev %d", dev->id);
+                                        pcbit_l2_error(dev);
+                                }
+
+                /* ack is acceptable */
+
+
+                i = dev->unack_seq;
+
+                do {
+                        dev->unack_seq = i = (i + 1) % 8;
+                        dev->free += dev->fsize[i];
+                } while (i != ack);
+
+                count = 0;
+                while (count < 7 && dev->write_queue) 
+		{
+			u8 lsend_seq = dev->send_seq;
+
+                        pcbit_transmit(dev);
+
+			if (dev->send_seq == lsend_seq)
+				break;
+                        count++;			
+                }
+    
+                if (!count) {
+                        u_char info;
+
+                        info = 0;
+                        info |= dev->rcv_seq << 3;
+                        info |= dev->send_seq;
+	
+                        writeb(info, dev->sh_mem + BANK4);  
+                }
+        }
+        else
+                printk(KERN_DEBUG "recv_ack: unacked = 0\n");
+}
+
+static void pcbit_frame_read(struct pcbit_dev * dev, unsigned char read_seq)
+{
+        unsigned long flags;
+        int busy;
+        u_char info;
+
+        save_flags(flags);
+        cli();
+        if (!(busy=dev->r_busy))
+                dev->r_busy = 1;
+        restore_flags(flags);
+
+        if (busy)
+                return;
+        
+
+        while (read_seq != dev->rcv_seq) {
+                pcbit_receive(dev);
+                dev->rcv_seq = (dev->rcv_seq + 1) % 8;  
+        }
+
+        dev->r_busy = 0;
+
+        info = 0;
+        info |= dev->rcv_seq << 3;
+        info |= dev->send_seq;
+  
+        writeb(info, dev->sh_mem + BANK4);  
+}
+
+
+
+
+
+