[deliverable/linux.git] / drivers / staging / i4l / pcbit / layer2.c

/*
 * PCBIT-D low-layer interface
 *
 * Copyright (C) 1996 Universidade de Lisboa
 *
 * Written by Pedro Roque Marques (roque@di.fc.ul.pt)
 *
 * This software may be used and distributed according to the terms of
 * the GNU General Public License, incorporated herein by reference.
 */

/*
 * 19991203 - Fernando Carvalho - takion@superbofh.org
 * Hacked to compile with egcs and run with current version of isdn modules
 */

/*
 *        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
 */

#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/workqueue.h>
#include <linux/mm.h>
#include <linux/skbuff.h>

#include <linux/isdnif.h>

#include <asm/io.h>


#include "pcbit.h"
#include "layer2.h"
#include "edss1.h"

#undef DEBUG_FRAG


/*
 *  Prototypes
 */

static void pcbit_transmit(struct pcbit_dev *dev);

static void pcbit_recv_ack(struct pcbit_dev *dev, unsigned char ack);

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 __inline__ void
pcbit_sched_delivery(struct pcbit_dev *dev)
{
	schedule_work(&dev->qdelivery);
}


/*
 *  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);
		return -1;
	}
	if ((frame = kmalloc(sizeof(struct frame_buf),
			     GFP_ATOMIC)) == NULL) {
		dev_kfree_skb(skb);
		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;
	else
		frame->dt_len = 0;

	frame->skb = skb;

	frame->next = NULL;

	spin_lock_irqsave(&dev->lock, flags);

	if (dev->write_queue == NULL) {
		dev->write_queue = frame;
		spin_unlock_irqrestore(&dev->lock, flags);
		pcbit_transmit(dev);
	} else {
		for (ptr = dev->write_queue; ptr->next; ptr = ptr->next);
		ptr->next = frame;

		spin_unlock_irqrestore(&dev->lock, 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 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;

	spin_lock_irqsave(&dev->lock, flags);

	if (dev->free > 16 && dev->write_queue && unacked < 7) {

		if (!dev->w_busy)
			dev->w_busy = 1;
		else {
			spin_unlock_irqrestore(&dev->lock, flags);
			return;
		}


		frame = dev->write_queue;
		free = dev->free;

		spin_unlock_irqrestore(&dev->lock, flags);

		if (frame->copied == 0) {

			/* Type 0 frame */

			ulong	msg;

			if (frame->skb)
				flen = FRAME_HDR_LEN + PREHDR_LEN + frame->skb->len;
			else
				flen = FRAME_HDR_LEN + PREHDR_LEN;

			if (flen > free)
				flen = free;

			msg = frame->msg;

			/*
			 *  Board level 2 header
			 */

			pcbit_writew(dev, flen - FRAME_HDR_LEN);

			pcbit_writeb(dev, GET_MSG_CPU(msg));

			pcbit_writeb(dev, GET_MSG_PROC(msg));

			/* 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, GET_MSG_CMD(msg));
			pcbit_writeb(dev, GET_MSG_SCMD(msg));

			/* NUM */
			pcbit_writew(dev, frame->refnum);

			count = FRAME_HDR_LEN + PREHDR_LEN;
		} else {
			/* Type 1 frame */

			flen = 2 + (frame->skb->len - frame->copied);

			if (flen > free)
				flen = free;

			/* TT */
			tt = ((ushort) (flen - 2)) | 0x8000U;	/* Type 1 */
			pcbit_writew(dev, tt);

			count = 2;
		}

		if (frame->skb) {
			cp_len = frame->skb->len - frame->copied;
			if (cp_len > flen - count)
				cp_len = flen - count;

			memcpy_topcbit(dev, frame->skb->data + frame->copied,
				       cp_len);
			frame->copied += cp_len;
		}
		/* bookkeeping */
		dev->free -= flen;
		pcbit_tx_update(dev, flen);

		spin_lock_irqsave(&dev->lock, flags);

		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);
			}
			kfree(frame);
		}
		dev->w_busy = 0;
		spin_unlock_irqrestore(&dev->lock, flags);
	} else {
		spin_unlock_irqrestore(&dev->lock, flags);
#ifdef DEBUG
		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(struct work_struct *work)
{
	struct frame_buf *frame;
	unsigned long flags, msg;
	struct pcbit_dev *dev =
		container_of(work, struct pcbit_dev, qdelivery);

	spin_lock_irqsave(&dev->lock, flags);

	while ((frame = dev->read_queue)) {
		dev->read_queue = frame->next;
		spin_unlock_irqrestore(&dev->lock, flags);

		msg = 0;
		SET_MSG_CPU(msg, 0);
		SET_MSG_PROC(msg, 0);
		SET_MSG_CMD(msg, frame->skb->data[2]);
		SET_MSG_SCMD(msg, 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);

		spin_lock_irqsave(&dev->lock, flags);
	}

	spin_unlock_irqrestore(&dev->lock, flags);
}

/*
 * 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");
			/* discard previous queued frame */
			kfree_skb(dev->read_frame->skb);
			kfree(dev->read_frame);
			dev->read_frame = NULL;
		}
		frame = kzalloc(sizeof(struct frame_buf), GFP_ATOMIC);

		if (frame == NULL) {
			printk(KERN_WARNING "kmalloc failed\n");
			return;
		}

		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;
		}
		/* minimum 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 memory\n");
			kfree(frame);
			return;
		}
		/* 16 byte alignment 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");
			/* usually after an error: toss frame */
			dev->readptr += tt;
			if (dev->readptr > dev->sh_mem + BANK2 + BANKLEN)
				dev->readptr -= BANKLEN;
			return;

		}
	}

	memcpy_frompcbit(dev, skb_put(frame->skb, tt), tt);

	frame->copied += tt;
	spin_lock_irqsave(&dev->lock, flags);
	if (frame->copied == frame->hdr_len + frame->dt_len) {

		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;

	} else {
		dev->read_frame = frame;
	}
	spin_unlock_irqrestore(&dev->lock, flags);
}

/*
 *  The board sends 0 sized frames
 *  They are TDATA_CONFs that get messed up somehow
 *  gotta send a fake acknowledgment 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);
	}
}

irqreturn_t
pcbit_irq_handler(int interrupt, void *devptr)
{
	struct pcbit_dev *dev;
	u_char info,
		ack_seq,
		read_seq;

	dev = (struct pcbit_dev *) devptr;

	if (!dev) {
		printk(KERN_WARNING "pcbit_irq_handler: wrong device\n");
		return IRQ_NONE;
	}
	if (dev->interrupt) {
		printk(KERN_DEBUG "pcbit: reentering interrupt handler\n");
		return IRQ_HANDLED;
	}
	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 IRQ_HANDLED;
	}
	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 IRQ_HANDLED;
	}
	if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING) {
		dev->interrupt = 0;
		return IRQ_HANDLED;
	}
	ack_seq = (info >> 3) & 0x07U;
	read_seq = (info & 0x07U);

	dev->interrupt = 0;

	if (read_seq != dev->rcv_seq) {
		while (read_seq != dev->rcv_seq) {
			pcbit_receive(dev);
			dev->rcv_seq = (dev->rcv_seq + 1) % 8;
		}
		pcbit_sched_delivery(dev);
	}
	if (ack_seq != dev->unack_seq) {
		pcbit_recv_ack(dev, ack_seq);
	}
	info = dev->rcv_seq << 3;
	info |= dev->send_seq;

	writeb(info, dev->sh_mem + BANK4);
	return IRQ_HANDLED;
}


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) {
		kfree_skb(dev->read_frame->skb);
		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);
		}
		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;

		setup_timer(&dev->error_recover_timer, &pcbit_l2_err_recover,
			    (ulong)dev);
		mod_timer(&dev->error_recover_timer, jiffies + ERRTIME);
	}
}

/*
 * 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(KERN_DEBUG
				       "layer 2 ack unacceptable - dev %d",
				       dev->id);

				pcbit_l2_error(dev);
			} else if (ack > dev->send_seq && ack <= dev->unack_seq) {
				printk(KERN_DEBUG
				       "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++;
		}
	} else
		printk(KERN_DEBUG "recv_ack: unacked = 0\n");
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* PCBIT-D low-layer interface
	3	*
	4	* Copyright (C) 1996 Universidade de Lisboa
	5	*
	6	* Written by Pedro Roque Marques (roque@di.fc.ul.pt)
	7	*
	8	* This software may be used and distributed according to the terms of
	9	* the GNU General Public License, incorporated herein by reference.
	10	*/
	11
	12	/*
	13	* 19991203 - Fernando Carvalho - takion@superbofh.org
	14	* Hacked to compile with egcs and run with current version of isdn modules
475be4d8	15	*/
1da177e4 LT	16
	17	/*
	18	* Based on documentation provided by Inesc:
	19	* - "Interface com bus do PC para o PCBIT e PCBIT-D", Inesc, Jan 93
	20	*/
	21
	22	/*
	23	* TODO: better handling of errors
	24	* re-write/remove debug printks
	25	*/
	26
1da177e4 LT	27	#include <linux/string.h>
	28	#include <linux/kernel.h>
	29	#include <linux/types.h>
d43c36dc	30	#include <linux/sched.h>
1da177e4 LT	31	#include <linux/slab.h>
	32	#include <linux/interrupt.h>
	33	#include <linux/workqueue.h>
	34	#include <linux/mm.h>
	35	#include <linux/skbuff.h>
	36
	37	#include <linux/isdnif.h>
	38
1da177e4 LT	39	#include <asm/io.h>
	40
	41
	42	#include "pcbit.h"
	43	#include "layer2.h"
	44	#include "edss1.h"
	45
	46	#undef DEBUG_FRAG
	47
	48
1da177e4 LT	49	/*
	50	* Prototypes
	51	*/
	52
1da177e4 LT	53	static void pcbit_transmit(struct pcbit_dev *dev);
	54
	55	static void pcbit_recv_ack(struct pcbit_dev *dev, unsigned char ack);
	56
	57	static void pcbit_l2_error(struct pcbit_dev *dev);
	58	static void pcbit_l2_active_conf(struct pcbit_dev *dev, u_char info);
	59	static void pcbit_l2_err_recover(unsigned long data);
	60
	61	static void pcbit_firmware_bug(struct pcbit_dev *dev);
	62
	63	static __inline__ void
	64	pcbit_sched_delivery(struct pcbit_dev *dev)
	65	{
	66	schedule_work(&dev->qdelivery);
	67	}
	68
	69
	70	/*
	71	* Called from layer3
	72	*/
	73
	74	int
	75	pcbit_l2_write(struct pcbit_dev *dev, ulong msg, ushort refnum,
	76	struct sk_buff *skb, unsigned short hdr_len)
	77	{
	78	struct frame_buf *frame,
475be4d8	79	*ptr;
1da177e4 LT	80	unsigned long flags;
	81
	82	if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING) {
	83	dev_kfree_skb(skb);
	84	return -1;
	85	}
5cbded58	86	if ((frame = kmalloc(sizeof(struct frame_buf),
475be4d8	87	GFP_ATOMIC)) == NULL) {
1da177e4 LT	88	dev_kfree_skb(skb);
	89	return -1;
	90	}
	91	frame->msg = msg;
	92	frame->refnum = refnum;
	93	frame->copied = 0;
	94	frame->hdr_len = hdr_len;
	95
	96	if (skb)
	97	frame->dt_len = skb->len - hdr_len;
	98	else
	99	frame->dt_len = 0;
	100
	101	frame->skb = skb;
	102
	103	frame->next = NULL;
	104
	105	spin_lock_irqsave(&dev->lock, flags);
	106
	107	if (dev->write_queue == NULL) {
	108	dev->write_queue = frame;
	109	spin_unlock_irqrestore(&dev->lock, flags);
	110	pcbit_transmit(dev);
	111	} else {
	112	for (ptr = dev->write_queue; ptr->next; ptr = ptr->next);
	113	ptr->next = frame;
	114
	115	spin_unlock_irqrestore(&dev->lock, flags);
	116	}
	117	return 0;
	118	}
	119
	120	static __inline__ void
	121	pcbit_tx_update(struct pcbit_dev *dev, ushort len)
	122	{
	123	u_char info;
	124
	125	dev->send_seq = (dev->send_seq + 1) % 8;
	126
	127	dev->fsize[dev->send_seq] = len;
	128	info = 0;
	129	info \|= dev->rcv_seq << 3;
	130	info \|= dev->send_seq;
	131
	132	writeb(info, dev->sh_mem + BANK4);
	133
	134	}
	135
	136	/*
	137	* called by interrupt service routine or by write_2
	138	*/
	139
	140	static void
	141	pcbit_transmit(struct pcbit_dev *dev)
	142	{
	143	struct frame_buf *frame = NULL;
	144	unsigned char unacked;
	145	int flen; /* fragment frame length including all headers */
	146	int free;
	147	int count,
475be4d8	148	cp_len;
1da177e4 LT	149	unsigned long flags;
	150	unsigned short tt;
	151
	152	if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING)
	153	return;
	154
	155	unacked = (dev->send_seq + (8 - dev->unack_seq)) & 0x07;
	156
	157	spin_lock_irqsave(&dev->lock, flags);
	158
	159	if (dev->free > 16 && dev->write_queue && unacked < 7) {
	160
	161	if (!dev->w_busy)
	162	dev->w_busy = 1;
	163	else {
	164	spin_unlock_irqrestore(&dev->lock, flags);
	165	return;
	166	}
	167
	168
	169	frame = dev->write_queue;
	170	free = dev->free;
	171
	172	spin_unlock_irqrestore(&dev->lock, flags);
	173
	174	if (frame->copied == 0) {
	175
	176	/* Type 0 frame */
	177
475be4d8	178	ulong msg;
1da177e4 LT	179
	180	if (frame->skb)
	181	flen = FRAME_HDR_LEN + PREHDR_LEN + frame->skb->len;
	182	else
	183	flen = FRAME_HDR_LEN + PREHDR_LEN;
	184
	185	if (flen > free)
	186	flen = free;
	187
	188	msg = frame->msg;
	189
	190	/*
	191	* Board level 2 header
	192	*/
	193
	194	pcbit_writew(dev, flen - FRAME_HDR_LEN);
	195
	196	pcbit_writeb(dev, GET_MSG_CPU(msg));
	197
	198	pcbit_writeb(dev, GET_MSG_PROC(msg));
	199
	200	/* TH */
	201	pcbit_writew(dev, frame->hdr_len + PREHDR_LEN);
	202
	203	/* TD */
	204	pcbit_writew(dev, frame->dt_len);
	205
	206
	207	/*
	208	* Board level 3 fixed-header
	209	*/
	210
	211	/* LEN = TH */
	212	pcbit_writew(dev, frame->hdr_len + PREHDR_LEN);
	213
	214	/* XX */
	215	pcbit_writew(dev, 0);
	216
	217	/* C + S */
	218	pcbit_writeb(dev, GET_MSG_CMD(msg));
	219	pcbit_writeb(dev, GET_MSG_SCMD(msg));
	220
	221	/* NUM */
	222	pcbit_writew(dev, frame->refnum);
	223
	224	count = FRAME_HDR_LEN + PREHDR_LEN;
	225	} else {
	226	/* Type 1 frame */
	227
	228	flen = 2 + (frame->skb->len - frame->copied);
	229
	230	if (flen > free)
	231	flen = free;
	232
	233	/* TT */
	234	tt = ((ushort) (flen - 2)) \| 0x8000U; /* Type 1 */
	235	pcbit_writew(dev, tt);
	236
	237	count = 2;
	238	}
	239
	240	if (frame->skb) {
	241	cp_len = frame->skb->len - frame->copied;
	242	if (cp_len > flen - count)
243	cp_len = flen - count;
244
245	memcpy_topcbit(dev, frame->skb->data + frame->copied,
246	cp_len);
247	frame->copied += cp_len;
248	}
249	/* bookkeeping */
250	dev->free -= flen;
251	pcbit_tx_update(dev, flen);
252
253	spin_lock_irqsave(&dev->lock, flags);
254
255	if (frame->skb == NULL \|\| frame->copied == frame->skb->len) {
256
257	dev->write_queue = frame->next;
258
259	if (frame->skb != NULL) {
260	/* free frame */
261	dev_kfree_skb(frame->skb);
262	}
263	kfree(frame);
264	}
265	dev->w_busy = 0;
266	spin_unlock_irqrestore(&dev->lock, flags);
267	} else {
268	spin_unlock_irqrestore(&dev->lock, flags);
269	#ifdef DEBUG
270	printk(KERN_DEBUG "unacked %d free %d write_queue %s\n",
475be4d8	271	unacked, dev->free, dev->write_queue ? "not empty" :
1da177e4 LT	272	"empty");
	273	#endif
	274	}
	275	}
	276
	277
	278	/*
	279	* deliver a queued frame to the upper layer
	280	*/
	281
	282	void
c4028958	283	pcbit_deliver(struct work_struct *work)
1da177e4 LT	284	{
	285	struct frame_buf *frame;
	286	unsigned long flags, msg;
c4028958 DH	287	struct pcbit_dev *dev =
c4028958 DH	288	container_of(work, struct pcbit_dev, qdelivery);
1da177e4 LT	289
	290	spin_lock_irqsave(&dev->lock, flags);
	291
	292	while ((frame = dev->read_queue)) {
	293	dev->read_queue = frame->next;
	294	spin_unlock_irqrestore(&dev->lock, flags);
	295
76fd0209	296	msg = 0;
1da177e4 LT	297	SET_MSG_CPU(msg, 0);
	298	SET_MSG_PROC(msg, 0);
	299	SET_MSG_CMD(msg, frame->skb->data[2]);
	300	SET_MSG_SCMD(msg, frame->skb->data[3]);
	301
475be4d8 JP	302	frame->refnum = ((ushort )frame->skb->data + 4);
475be4d8 JP	303	frame->msg = ((ulong )&msg);
1da177e4 LT	304
	305	skb_pull(frame->skb, 6);
	306
	307	pcbit_l3_receive(dev, frame->msg, frame->skb, frame->hdr_len,
	308	frame->refnum);
	309
	310	kfree(frame);
	311
	312	spin_lock_irqsave(&dev->lock, flags);
	313	}
	314
	315	spin_unlock_irqrestore(&dev->lock, flags);
	316	}
	317
	318	/*
	319	* Reads BANK 2 & Reassembles
	320	*/
	321
	322	static void
	323	pcbit_receive(struct pcbit_dev *dev)
	324	{
	325	unsigned short tt;
	326	u_char cpu,
475be4d8	327	proc;
1da177e4 LT	328	struct frame_buf *frame = NULL;
	329	unsigned long flags;
	330	u_char type1;
	331
	332	if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING)
	333	return;
	334
	335	tt = pcbit_readw(dev);
	336
	337	if ((tt & 0x7fffU) > 511) {
	338	printk(KERN_INFO "pcbit: invalid frame length -> TT=%04x\n",
	339	tt);
	340	pcbit_l2_error(dev);
	341	return;
	342	}
	343	if (!(tt & 0x8000U)) { /* Type 0 */
	344	type1 = 0;
	345
	346	if (dev->read_frame) {
	347	printk(KERN_DEBUG "pcbit_receive: Type 0 frame and read_frame != NULL\n");
	348	/* discard previous queued frame */
d46604e1	349	kfree_skb(dev->read_frame->skb);
1da177e4 LT	350	kfree(dev->read_frame);
	351	dev->read_frame = NULL;
	352	}
41f96935	353	frame = kzalloc(sizeof(struct frame_buf), GFP_ATOMIC);
1da177e4 LT	354
	355	if (frame == NULL) {
	356	printk(KERN_WARNING "kmalloc failed\n");
	357	return;
	358	}
1da177e4 LT	359
	360	cpu = pcbit_readb(dev);
	361	proc = pcbit_readb(dev);
	362
	363
	364	if (cpu != 0x06 && cpu != 0x02) {
	365	printk(KERN_DEBUG "pcbit: invalid cpu value\n");
	366	kfree(frame);
	367	pcbit_l2_error(dev);
	368	return;
	369	}
	370	/*
	371	* we discard cpu & proc on receiving
	372	* but we read it to update the pointer
	373	*/
	374
	375	frame->hdr_len = pcbit_readw(dev);
	376	frame->dt_len = pcbit_readw(dev);
	377
	378	/*
475be4d8 JP	379	* 0 sized packet
	380	* I don't know if they are an error or not...
	381	* But they are very frequent
	382	* Not documented
1da177e4 LT	383	*/
	384
	385	if (frame->hdr_len == 0) {
	386	kfree(frame);
	387	#ifdef DEBUG
	388	printk(KERN_DEBUG "0 sized frame\n");
	389	#endif
	390	pcbit_firmware_bug(dev);
	391	return;
	392	}
	393	/* sanity check the length values */
	394	if (frame->hdr_len > 1024 \|\| frame->dt_len > 2048) {
	395	#ifdef DEBUG
	396	printk(KERN_DEBUG "length problem: ");
	397	printk(KERN_DEBUG "TH=%04x TD=%04x\n",
	398	frame->hdr_len,
	399	frame->dt_len);
	400	#endif
	401	pcbit_l2_error(dev);
	402	kfree(frame);
	403	return;
	404	}
	405	/* minimum frame read */
	406
	407	frame->skb = dev_alloc_skb(frame->hdr_len + frame->dt_len +
	408	((frame->hdr_len + 15) & ~15));
	409
	410	if (!frame->skb) {
	411	printk(KERN_DEBUG "pcbit_receive: out of memory\n");
	412	kfree(frame);
	413	return;
	414	}
	415	/* 16 byte alignment for IP */
	416	if (frame->dt_len)
	417	skb_reserve(frame->skb, (frame->hdr_len + 15) & ~15);
	418
	419	} else {
	420	/* Type 1 */
	421	type1 = 1;
	422	tt &= 0x7fffU;
	423
	424	if (!(frame = dev->read_frame)) {
	425	printk("Type 1 frame and no frame queued\n");
	426	/* usually after an error: toss frame */
	427	dev->readptr += tt;
	428	if (dev->readptr > dev->sh_mem + BANK2 + BANKLEN)
	429	dev->readptr -= BANKLEN;
	430	return;
	431
	432	}
	433	}
	434
	435	memcpy_frompcbit(dev, skb_put(frame->skb, tt), tt);
	436
	437	frame->copied += tt;
	438	spin_lock_irqsave(&dev->lock, flags);
	439	if (frame->copied == frame->hdr_len + frame->dt_len) {
	440
	441	if (type1) {
	442	dev->read_frame = NULL;
	443	}
	444	if (dev->read_queue) {
	445	struct frame_buf *ptr;
	446	for (ptr = dev->read_queue; ptr->next; ptr = ptr->next);
447	ptr->next = frame;
448	} else
449	dev->read_queue = frame;
450
451	} else {
452	dev->read_frame = frame;
453	}
454	spin_unlock_irqrestore(&dev->lock, flags);
455	}
456
457	/*
458	* The board sends 0 sized frames
459	* They are TDATA_CONFs that get messed up somehow
460	* gotta send a fake acknowledgment to the upper layer somehow
461	*/
462
463	static __inline__ void
464	pcbit_fake_conf(struct pcbit_dev dev, struct pcbit_chan chan)
465	{
466	isdn_ctrl ictl;
467
468	if (chan->queued) {
469	chan->queued--;
470
471	ictl.driver = dev->id;
472	ictl.command = ISDN_STAT_BSENT;
473	ictl.arg = chan->id;
474	dev->dev_if->statcallb(&ictl);
475	}
476	}
477
478	static void
479	pcbit_firmware_bug(struct pcbit_dev *dev)
480	{
481	struct pcbit_chan *chan;
482
483	chan = dev->b1;
484
485	if (chan->fsm_state == ST_ACTIVE) {
486	pcbit_fake_conf(dev, chan);
487	}
488	chan = dev->b2;
489
490	if (chan->fsm_state == ST_ACTIVE) {
491	pcbit_fake_conf(dev, chan);
492	}
493	}
494
495	irqreturn_t
7d12e780	496	pcbit_irq_handler(int interrupt, void *devptr)
1da177e4 LT	497	{
	498	struct pcbit_dev *dev;
	499	u_char info,
475be4d8 JP	500	ack_seq,
475be4d8 JP	501	read_seq;
1da177e4 LT	502
	503	dev = (struct pcbit_dev *) devptr;
	504
	505	if (!dev) {
	506	printk(KERN_WARNING "pcbit_irq_handler: wrong device\n");
	507	return IRQ_NONE;
	508	}
	509	if (dev->interrupt) {
465b1678	510	printk(KERN_DEBUG "pcbit: reentering interrupt handler\n");
1da177e4 LT	511	return IRQ_HANDLED;
	512	}
	513	dev->interrupt = 1;
	514
	515	info = readb(dev->sh_mem + BANK3);
	516
	517	if (dev->l2_state == L2_STARTING \|\| dev->l2_state == L2_ERROR) {
	518	pcbit_l2_active_conf(dev, info);
	519	dev->interrupt = 0;
	520	return IRQ_HANDLED;
	521	}
	522	if (info & 0x40U) { /* E bit set */
	523	#ifdef DEBUG
	524	printk(KERN_DEBUG "pcbit_irq_handler: E bit on\n");
	525	#endif
	526	pcbit_l2_error(dev);
	527	dev->interrupt = 0;
	528	return IRQ_HANDLED;
	529	}
	530	if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING) {
	531	dev->interrupt = 0;
	532	return IRQ_HANDLED;
	533	}
	534	ack_seq = (info >> 3) & 0x07U;
	535	read_seq = (info & 0x07U);
	536
	537	dev->interrupt = 0;
	538
	539	if (read_seq != dev->rcv_seq) {
	540	while (read_seq != dev->rcv_seq) {
	541	pcbit_receive(dev);
	542	dev->rcv_seq = (dev->rcv_seq + 1) % 8;
	543	}
	544	pcbit_sched_delivery(dev);
	545	}
	546	if (ack_seq != dev->unack_seq) {
	547	pcbit_recv_ack(dev, ack_seq);
	548	}
	549	info = dev->rcv_seq << 3;
	550	info \|= dev->send_seq;
	551
	552	writeb(info, dev->sh_mem + BANK4);
	553	return IRQ_HANDLED;
	554	}
	555
	556
	557	static void
	558	pcbit_l2_active_conf(struct pcbit_dev *dev, u_char info)
	559	{
	560	u_char state;
	561
	562	state = dev->l2_state;
	563
	564	#ifdef DEBUG
	565	printk(KERN_DEBUG "layer2_active_confirm\n");
	566	#endif
	567
	568
	569	if (info & 0x80U) {
	570	dev->rcv_seq = info & 0x07U;
	571	dev->l2_state = L2_RUNNING;
	572	} else
	573	dev->l2_state = L2_DOWN;
	574
575	if (state == L2_STARTING)
576	wake_up_interruptible(&dev->set_running_wq);
577
578	if (state == L2_ERROR && dev->l2_state == L2_RUNNING) {
579	pcbit_transmit(dev);
580	}
581	}
582
583	static void
584	pcbit_l2_err_recover(unsigned long data)
585	{
586
587	struct pcbit_dev *dev;
588	struct frame_buf *frame;
589
590	dev = (struct pcbit_dev *) data;
591
592	del_timer(&dev->error_recover_timer);
593	if (dev->w_busy \|\| dev->r_busy) {
594	init_timer(&dev->error_recover_timer);
595	dev->error_recover_timer.expires = jiffies + ERRTIME;
596	add_timer(&dev->error_recover_timer);
597	return;
598	}
599	dev->w_busy = dev->r_busy = 1;
600
601	if (dev->read_frame) {
d46604e1	602	kfree_skb(dev->read_frame->skb);
1da177e4 LT	603	kfree(dev->read_frame);
	604	dev->read_frame = NULL;
	605	}
	606	if (dev->write_queue) {
	607	frame = dev->write_queue;
	608	#ifdef FREE_ON_ERROR
	609	dev->write_queue = dev->write_queue->next;
	610
	611	if (frame->skb) {
	612	dev_kfree_skb(frame->skb);
	613	}
	614	kfree(frame);
	615	#else
	616	frame->copied = 0;
	617	#endif
	618	}
	619	dev->rcv_seq = dev->send_seq = dev->unack_seq = 0;
	620	dev->free = 511;
	621	dev->l2_state = L2_ERROR;
	622
	623	/* this is an hack... */
	624	pcbit_firmware_bug(dev);
	625
	626	dev->writeptr = dev->sh_mem;
	627	dev->readptr = dev->sh_mem + BANK2;
	628
	629	writeb((0x80U \| ((dev->rcv_seq & 0x07) << 3) \| (dev->send_seq & 0x07)),
	630	dev->sh_mem + BANK4);
	631	dev->w_busy = dev->r_busy = 0;
	632
	633	}
	634
	635	static void
	636	pcbit_l2_error(struct pcbit_dev *dev)
	637	{
	638	if (dev->l2_state == L2_RUNNING) {
	639
	640	printk(KERN_INFO "pcbit: layer 2 error\n");
	641
	642	#ifdef DEBUG
	643	log_state(dev);
	644	#endif
	645
	646	dev->l2_state = L2_DOWN;
	647
1735d9e9 MFW	648	setup_timer(&dev->error_recover_timer, &pcbit_l2_err_recover,
	649	(ulong)dev);
	650	mod_timer(&dev->error_recover_timer, jiffies + ERRTIME);
1da177e4 LT	651	}
	652	}
	653
	654	/*
	655	* Description:
	656	* if board acks frames
	657	* update dev->free
	658	* call pcbit_transmit to write possible queued frames
	659	*/
	660
	661	static void
	662	pcbit_recv_ack(struct pcbit_dev *dev, unsigned char ack)
	663	{
	664	int i,
475be4d8	665	count;
1da177e4 LT	666	int unacked;
	667
	668	unacked = (dev->send_seq + (8 - dev->unack_seq)) & 0x07;
	669
	670	/* dev->unack_seq < ack <= dev->send_seq; */
	671
	672	if (unacked) {
	673
	674	if (dev->send_seq > dev->unack_seq) {
	675	if (ack <= dev->unack_seq \|\| ack > dev->send_seq) {
	676	printk(KERN_DEBUG
475be4d8	677	"layer 2 ack unacceptable - dev %d",
1da177e4 LT	678	dev->id);
	679
	680	pcbit_l2_error(dev);
	681	} else if (ack > dev->send_seq && ack <= dev->unack_seq) {
	682	printk(KERN_DEBUG
475be4d8	683	"layer 2 ack unacceptable - dev %d",
1da177e4 LT	684	dev->id);
	685	pcbit_l2_error(dev);
	686	}
	687	}
	688	/* ack is acceptable */
	689
	690
	691	i = dev->unack_seq;
	692
	693	do {
	694	dev->unack_seq = i = (i + 1) % 8;
	695	dev->free += dev->fsize[i];
	696	} while (i != ack);
	697
	698	count = 0;
	699	while (count < 7 && dev->write_queue) {
	700	u8 lsend_seq = dev->send_seq;
	701
	702	pcbit_transmit(dev);
	703
	704	if (dev->send_seq == lsend_seq)
	705	break;
	706	count++;
	707	}
	708	} else
	709	printk(KERN_DEBUG "recv_ack: unacked = 0\n");
	710	}