/*****************************************************************************/
/*
 *      auerisdn_b.c  --  Auerswald PBX/System Telephone ISDN B-channel interface.
 *
 *      Copyright (C) 2002  Wolfgang Mües (wolfgang@iksw-muees.de)
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License as published by
 *      the Free Software Foundation; either version 2 of the License, or
 *      (at your option) any later version.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 /*****************************************************************************/

#include <linux/isdnif.h>	/* ISDN constants */
#include <linux/netdevice.h>	/* skb functions */

#undef DEBUG			/* include debug macros until it's done */
#include <linux/usb.h>		/* standard usb header */

#include "auerisdn.h"
#include "auermain.h"

/*-------------------------------------------------------------------*/
/* ISDN B channel support defines                                    */
#define AUISDN_BC_1MS		8	/* Bytes per channel and ms */
#define AUISDN_BC_INC		4	/* change INT OUT size increment */
#define AUISDN_BCDATATHRESHOLD	48	/* for unsymmetric 2-B-channels */
#define AUISDN_TOGGLETIME	6	/* Timeout for unsymmetric serve */

/*-------------------------------------------------------------------*/
/* Debug support 						     */
#ifdef DEBUG
#define dump( desc, adr, len) \
do {			\
	unsigned int u;	\
	printk (KERN_DEBUG); \
	printk (desc); \
	for (u = 0; u < len; u++) \
		printk (" %02X", adr[u] & 0xFF); \
	printk ("\n"); \
} while (0)
#else
#define dump( desc, adr, len)
#endif

/*-------------------------------------------------------------------*/

/* Callback to L2 for HISAX */
/* This callback can be called from 3 sources:
   a) from hisax context (answer from a l2l1 function)
   b) from interrupt context (a B channel paket arrived, a B channel paket was sent)
   c) from kernel daemon context (probe/disconnecting)
*/
void auerisdn_b_l1l2(struct auerisdnbc *bc, int pr, void *arg)
{
	struct auerhisax *ahp;
	struct sk_buff *skb;

	/* do the callback */
	ahp = bc->cp->isdn.ahp;
	if (ahp) {
		ahp->hisax_b_if[bc->channel].ifc.l1l2(&ahp->
						      hisax_b_if[bc->
								 channel].
						      ifc, pr, arg);
	} else {
		dbg("auerisdn_b_l1l2 called without ahp");
		if (pr == (PH_DATA | INDICATION)) {
			skb = (struct sk_buff *) arg;
			if (skb) {
				skb_pull(skb, skb->len);
				dev_kfree_skb_any(skb);
			}
		}
	}
}

/* fill the INT OUT data buffer with new data */
/* Transfer buffer size to fill is in urbp->transfer_buffer_length */
static void auerisdn_bintbo_newdata(struct auerisdn *ip)
{
	unsigned long flags;
	struct urb *urbp = ip->intbo_urbp;
	struct auerisdnbc *bc = &ip->bc[0];	/* start with B-channel 0 */
	struct sk_buff *skb;
	unsigned char *ucp;
	int buf_size;
	int len;
	int bytes_sent;
	int i;

	/* FIXME: this algorithm is fixed to 2 B-channels */
	/* Which B channel should we serve? */
	if (ip->bc[1].mode != L1_MODE_NULL) {
		/* B channel 1 is used */
		if (bc->mode != L1_MODE_NULL) {
			/* both B-channels are used */
			if (ip->intbo_toggletimer) {
				/* simply toggling */
				ip->intbo_toggletimer--;
				i = ip->intbo_index ^ 1;	/* serve both channels equal */
			} else {
				/* search the B channel with the most demand of data */
				i = bc->txfree - ip->bc[1].txfree;
				if (i < -AUISDN_BCDATATHRESHOLD)
					i = 1;	/* B channel 1 needs more data */
				else if (i > AUISDN_BCDATATHRESHOLD)
					i = 0;	/* B channel 0 needs more data */
				else
					i = ip->intbo_index ^ 1;	/* serve both channels equal */
				if (i == ip->intbo_index)
					ip->intbo_toggletimer =
					    AUISDN_TOGGLETIME;
			}
			bc = &ip->bc[i];
			ip->intbo_index = i;
		} else {
			bc = &ip->bc[1];
		}
	}
	dbg("INTBO: Fill B%d with %d Bytes, %d Bytes free",
	    bc->channel + 1, urbp->transfer_buffer_length - AUH_SIZE,
	    bc->txfree);

	/* Fill the buffer with data */
	ucp = ip->intbo_bufp;
	*ucp++ = AUH_B1CHANNEL + bc->channel;	/* First byte is channel nr. */
	buf_size = urbp->transfer_buffer_length - AUH_SIZE;
	len = 0;
	while (len < buf_size) {
		spin_lock_irqsave(&bc->txskb_lock, flags);
		if ((skb = bc->txskb)) {
			/* dump ("raw tx data:", skb->data, skb->len); */
			if (bc->mode == L1_MODE_TRANS) {
				bytes_sent = buf_size - len;
				if (skb->len < bytes_sent)
					bytes_sent = skb->len;
				{	/* swap tx bytes */
					register unsigned char *src =
					    skb->data;
					unsigned int count;
					for (count = 0; count < bytes_sent;
					     count++)
						*ucp++ =
						    isdnhdlc_bit_rev_tab
						    [*src++];
				}
				len += bytes_sent;
				bc->lastbyte = skb->data[bytes_sent - 1];
			} else {
				int bs =
				    isdnhdlc_encode(&bc->outp_hdlc_state,
						    skb->data, skb->len,
						    &bytes_sent,
						    ucp, buf_size - len);
				/* dump ("hdlc data:", ucp, bs); */
				len += bs;
				ucp += bs;
			}
			skb_pull(skb, bytes_sent);

			if (!skb->len) {
				// Frame sent
				bc->txskb = NULL;
				spin_unlock_irqrestore(&bc->txskb_lock,
						       flags);
				auerisdn_b_l1l2(bc, PH_DATA | CONFIRM,
						(void *) skb->truesize);
				dev_kfree_skb_any(skb);
				continue;	//while
			}
		} else {
			if (bc->mode == L1_MODE_TRANS) {
				memset(ucp, bc->lastbyte, buf_size - len);
				ucp += buf_size - len;
				len = buf_size;
				/* dbg ("fill = 0xFF"); */
			} else {
				// Send flags
				int bs =
				    isdnhdlc_encode(&bc->outp_hdlc_state,
						    NULL, 0, &bytes_sent,
						    ucp, buf_size - len);
				/* dbg ("fill = 0x%02X", (int)*ucp); */
				len += bs;
				ucp += bs;
			}
		}
		spin_unlock_irqrestore(&bc->txskb_lock, flags);
	}
	/* dbg ("%d Bytes to TX buffer", len); */
}


/* INT OUT completion handler */
static void auerisdn_bintbo_complete(struct urb *urbp)
{
	struct auerisdn *ip = urbp->context;

	/* unlink completion? */
	if ((urbp->status == -ENOENT) || (urbp->status == -ECONNRESET)) {
		/* should we restart with another size? */
		if (ip->intbo_state == INTBOS_CHANGE) {
			dbg("state => RESTART");
			ip->intbo_state = INTBOS_RESTART;
		} else {
			/* set up variables for later restart */
			dbg("INTBO stopped");
			ip->intbo_state = INTBOS_IDLE;
		}
		/* nothing more to do */
		return;
	}

	/* other state != 0? */
	if (urbp->status) {
		warn("auerisdn_bintbo_complete: status = %d",
		     urbp->status);
		return;
	}

	/* Should we fill in new data? */
	if (ip->intbo_state == INTBOS_CHANGE) {
		dbg("state == INTBOS_CHANGE, no new data");
		return;
	}

	/* fill in new data */
	auerisdn_bintbo_newdata(ip);
}

/* set up the INT OUT URB the first time */
/* Don't start the URB */
static void auerisdn_bintbo_setup(struct auerisdn *ip, unsigned int len)
{
	ip->intbo_state = INTBOS_IDLE;
	FILL_INT_URB(ip->intbo_urbp, ip->usbdev,
		     usb_sndintpipe(ip->usbdev, ip->intbo_endp),
		     ip->intbo_bufp, len, auerisdn_bintbo_complete, ip,
		     ip->outInterval);
	ip->intbo_urbp->transfer_flags |= USB_ASYNC_UNLINK;
	ip->intbo_urbp->status = 0;
}

/* restart the INT OUT endpoint */
static void auerisdn_bintbo_restart(struct auerisdn *ip)
{
	struct urb *urbp = ip->intbo_urbp;
	int status;

	/* dbg ("auerisdn_intbo_restart"); */

	/* fresh restart */
	auerisdn_bintbo_setup(ip, ip->paketsize + AUH_SIZE);

	/* Fill in new data */
	auerisdn_bintbo_newdata(ip);

	/* restart the urb */
	ip->intbo_state = INTBOS_RUNNING;
	status = usb_submit_urb(urbp);
	if (status < 0) {
		err("can't submit INT OUT urb, status = %d", status);
		urbp->status = status;
		urbp->complete(urbp);
	}
}

/* change the size of the INT OUT endpoint */
static void auerisdn_bchange(struct auerisdn *ip, unsigned int paketsize)
{
	/* changing... */
	dbg("txfree[0] = %d, txfree[1] = %d, old size = %d, new size = %d",
	    ip->bc[0].txfree, ip->bc[1].txfree, ip->paketsize, paketsize);
	ip->paketsize = paketsize;

	if (paketsize == 0) {
		/* stop the INT OUT endpoint */
		dbg("stop unlinking INT out urb");
		ip->intbo_state = INTBOS_IDLE;
		usb_unlink_urb(ip->intbo_urbp);
		return;
	}
	if (ip->intbo_state != INTBOS_IDLE) {
		/* dbg ("unlinking INT out urb"); */
		ip->intbo_state = INTBOS_CHANGE;
		usb_unlink_urb(ip->intbo_urbp);
	} else {
		/* dbg ("restart immediately"); */
		auerisdn_bintbo_restart(ip);
	}
}

/* serve the outgoing B channel interrupt */
/* Called from the INT IN completion handler */
static void auerisdn_bserv(struct auerisdn *ip)
{
	struct auerisdnbc *bc;
	unsigned int u;
	unsigned int paketsize;

	/* should we start the INT OUT endpoint again? */
	if (ip->intbo_state == INTBOS_RESTART) {
		/* dbg ("Restart INT OUT from INT IN"); */
		auerisdn_bintbo_restart(ip);
		return;
	}
	/* no new calculation if change already in progress */
	if (ip->intbo_state == INTBOS_CHANGE)
		return;

	/* calculation of transfer parameters for INT OUT endpoint */
	paketsize = 0;
	for (u = 0; u < AUISDN_BCHANNELS; u++) {
		bc = &ip->bc[u];
		if (bc->mode != L1_MODE_NULL) {	/* B channel is active */
			unsigned int bpp = AUISDN_BC_1MS * ip->outInterval;
			if (bc->txfree < bpp) {	/* buffer is full, throttle */
				bc->txsize = bpp - AUISDN_BC_INC;
				paketsize += bpp - AUISDN_BC_INC;
			} else if (bc->txfree < bpp * 2) {
				paketsize += bc->txsize;	/* schmidt-trigger, continue */
			} else if (bc->txfree < bpp * 4) {	/* we are in synch */
				bc->txsize = bpp;
				paketsize += bpp;
			} else if (bc->txfree > bc->ofsize / 2) {/* we have to fill the buffer */
				bc->txsize = bpp + AUISDN_BC_INC;
				paketsize += bpp + AUISDN_BC_INC;
			} else {
				paketsize += bc->txsize;	/* schmidt-trigger, continue */
			}
		}
	}

	/* check if we have to change the paket size */
	if (paketsize != ip->paketsize)
		auerisdn_bchange(ip, paketsize);
}

/* Send activation/deactivation state to L2 */
static void auerisdn_bconf(struct auerisdnbc *bc)
{
	unsigned long flags;
	struct sk_buff *skb;

	if (bc->mode == L1_MODE_NULL) {
		auerisdn_b_l1l2(bc, PH_DEACTIVATE | INDICATION, NULL);
		/* recycle old txskb */
		spin_lock_irqsave(&bc->txskb_lock, flags);
		skb = bc->txskb;
		bc->txskb = NULL;
		spin_unlock_irqrestore(&bc->txskb_lock, flags);
		if (skb) {
			skb_pull(skb, skb->len);
			auerisdn_b_l1l2(bc, PH_DATA | CONFIRM,
					(void *) skb->truesize);
			dev_kfree_skb_any(skb);
		}
	} else {
		auerisdn_b_l1l2(bc, PH_ACTIVATE | INDICATION, NULL);
	}
}

/* B channel setup completion handler */
static void auerisdn_bmode_complete(struct urb *urb)
{
	struct auerswald *cp;
	struct auerbuf *bp = (struct auerbuf *) urb->context;
	struct auerisdnbc *bc;
	int channel;

	dbg("auerisdn_bmode_complete called");
	cp = ((struct auerswald *) ((char *) (bp->list) -
				    (unsigned
				     long) (&((struct auerswald *) 0)->
					    bufctl)));

	/* select the B-channel */
	channel = le16_to_cpu(bp->dr->wIndex);
	channel -= AUH_B1CHANNEL;
	if (channel < 0)
		goto rel;
	if (channel >= AUISDN_BCHANNELS)
		goto rel;
	bc = &cp->isdn.bc[channel];

	/* Check for success */
	if (urb->status) {
		err("complete with non-zero status: %d", urb->status);
	} else {
		bc->mode = *bp->bufp;
	}
	/* Signal current mode to L2 */
	auerisdn_bconf(bc);

	/* reuse the buffer */
      rel:auerbuf_releasebuf(bp);

	/* Wake up all processes waiting for a buffer */
	wake_up(&cp->bufferwait);
}

/* Setup a B channel transfer mode */
static void auerisdn_bmode(struct auerisdnbc *bc, unsigned int mode)
{
	struct auerswald *cp = bc->cp;
	struct auerbuf *bp;
	int ret;

	/* don't allow activation on disconnect */
	if (cp->disconnecting) {
		mode = L1_MODE_NULL;

		/* Else check if something changed */
	} else if (bc->mode != mode) {
		if ((mode != L1_MODE_NULL) && (mode != L1_MODE_TRANS)) {
			/* init RX hdlc decoder */
			dbg("rcv init");
			isdnhdlc_rcv_init(&bc->inp_hdlc_state, 0);
			/* init TX hdlc decoder */
			dbg("out init");
			isdnhdlc_out_init(&bc->outp_hdlc_state, 0, 0);
		}
		/* stop ASAP */
		if (mode == L1_MODE_NULL)
			bc->mode = mode;
		if ((bc->mode == L1_MODE_NULL) || (mode == L1_MODE_NULL)) {
			/* Activation or deactivation required */

			/* get a buffer for the command */
			bp = auerbuf_getbuf(&cp->bufctl);
			/* if no buffer available: can't change the mode */
			if (!bp) {
				err("auerisdn_bmode: no data buffer available");
				return;
			}

			/* fill the control message */
			bp->dr->bRequestType = AUT_WREQ;
			bp->dr->bRequest = AUV_CHANNELCTL;
			if (mode != L1_MODE_NULL)
				bp->dr->wValue = cpu_to_le16(1);
			else
				bp->dr->wValue = cpu_to_le16(0);
			bp->dr->wIndex =
			    cpu_to_le16(AUH_B1CHANNEL + bc->channel);
			bp->dr->wLength = cpu_to_le16(0);
			*bp->bufp = mode;
			FILL_CONTROL_URB(bp->urbp, cp->usbdev,
					 usb_sndctrlpipe(cp->usbdev, 0),
					 (unsigned char *) bp->dr,
					 bp->bufp, 0,
					 (usb_complete_t)
					 auerisdn_bmode_complete, bp);

			/* submit the control msg */
			ret =
			    auerchain_submit_urb(&cp->controlchain,
						 bp->urbp);
			if (ret) {
				bp->urbp->status = ret;
				auerisdn_bmode_complete(bp->urbp);
			}
			return;
		}
	}
	/* new mode is set */
	bc->mode = mode;

	/* send confirmation to L2 */
	auerisdn_bconf(bc);
}

/* B-channel transfer function L2->L1 */
void auerisdn_b_l2l1(struct hisax_if *ifc, int pr, void *arg,
		     unsigned int channel)
{
	struct auerhisax *ahp;
	struct auerisdnbc *bc;
	struct auerswald *cp;
	struct sk_buff *skb;
	unsigned long flags;
	int mode;

	cp = NULL;
	ahp = (struct auerhisax *) ifc->priv;
	if (ahp)
		cp = ahp->cp;
	if (cp && !cp->disconnecting) {
		/* normal execution */
		bc = &cp->isdn.bc[channel];
		switch (pr) {
		case PH_ACTIVATE | REQUEST:	/* activation request */
			mode = (int) arg;	/* one of the L1_MODE constants */
			dbg("B%d, PH_ACTIVATE_REQUEST Mode = %d",
			    bc->channel + 1, mode);
			auerisdn_bmode(bc, mode);
			break;
		case PH_DEACTIVATE | REQUEST:	/* deactivation request */
			dbg("B%d, PH_DEACTIVATE_REQUEST", bc->channel + 1);
			auerisdn_bmode(bc, L1_MODE_NULL);
			break;
		case PH_DATA | REQUEST:	/* Transmit data request */
			skb = (struct sk_buff *) arg;
			spin_lock_irqsave(&bc->txskb_lock, flags);
			if (bc->txskb) {
				err("Overflow in B channel TX");
				skb_pull(skb, skb->len);
				dev_kfree_skb_any(skb);
			} else {
				if (cp->disconnecting
				    || (bc->mode == L1_MODE_NULL)) {
					skb_pull(skb, skb->len);
					spin_unlock_irqrestore(&bc->
							       txskb_lock,
							       flags);
					auerisdn_b_l1l2(bc,
							PH_DATA | CONFIRM,
							(void *) skb->
							truesize);
					dev_kfree_skb_any(skb);
					goto next;
				} else
					bc->txskb = skb;
			}
			spin_unlock_irqrestore(&bc->txskb_lock, flags);
		      next:break;
		default:
			warn("pr %#x\n", pr);
			break;
		}
	} else {
		/* hisax interface is down */
		switch (pr) {
		case PH_ACTIVATE | REQUEST:	/* activation request */
			dbg("B channel: PH_ACTIVATE | REQUEST with interface down");
			/* don't answer this request! Endless... */
			break;
		case PH_DEACTIVATE | REQUEST:	/* deactivation request */
			dbg("B channel: PH_DEACTIVATE | REQUEST with interface down");
			ifc->l1l2(ifc, PH_DEACTIVATE | INDICATION, NULL);
			break;
		case PH_DATA | REQUEST:	/* Transmit data request */
			dbg("B channel: PH_DATA | REQUEST with interface down");
			skb = (struct sk_buff *) arg;
			/* free data buffer */
			if (skb) {
				skb_pull(skb, skb->len);
				dev_kfree_skb_any(skb);
			}
			/* send confirmation back to layer 2 */
			ifc->l1l2(ifc, PH_DATA | CONFIRM, NULL);
			break;
		default:
			warn("pr %#x\n", pr);
			break;
		}
	}
}

/* Completion handler for B channel input endpoint */
void auerisdn_intbi_complete(struct urb *urb)
{
	unsigned int bytecount;
	unsigned char *ucp;
	int channel;
	unsigned int syncbit;
	unsigned int syncdata;
	struct auerisdnbc *bc;
	struct sk_buff *skb;
	int count;
	int status;
	struct auerswald *cp = (struct auerswald *) urb->context;
	/* do not respond to an error condition */
	if (urb->status != 0) {
		dbg("nonzero URB status = %d", urb->status);
		return;
	}
	if (cp->disconnecting)
		return;

	/* Parse and extract the header information */
	bytecount = urb->actual_length;
	ucp = cp->isdn.intbi_bufp;
	if (!bytecount)
		return;		/* no data */
	channel = *ucp & AUH_TYPEMASK;
	syncbit = *ucp & AUH_SYNC;
	ucp++;
	bytecount--;
	channel -= AUH_B1CHANNEL;
	if (channel < 0)
		return;		/* unknown data channel, no B1,B2 */
	if (channel >= AUISDN_BCHANNELS)
		return;		/* unknown data channel, no B1,B2 */
	bc = &cp->isdn.bc[channel];
	if (!bytecount)
		return;
	/* Calculate amount of bytes which are free in tx device buffer */
	bc->txfree = ((255 - *ucp++) * bc->ofsize) / 256;
	/* dbg ("%d Bytes free in TX buffer", bc->txfree); */
	bytecount--;

	/* Next Byte: TX sync information */
	if (syncbit) {
		if (!bytecount)
			goto int_tx;
		syncdata = *ucp++;
		dbg("Sync data = %d", syncdata);
		bytecount--;
	}
	/* The rest of the paket is plain data */
	if (!bytecount)
		goto int_tx;
	/* dump ("RX Data is:", ucp, bytecount); */

	/* Send B channel data to upper layers */
	while (bytecount > 0) {
		if (bc->mode == L1_MODE_NULL) {
			/* skip the data. Nobody needs them */
			status = 0;
			bytecount = 0;
		} else if (bc->mode == L1_MODE_TRANS) {
			{	/* swap rx bytes */
				register unsigned char *dest = bc->rxbuf;
				status = bytecount;
				for (; bytecount; bytecount--)
					*dest++ =
					    isdnhdlc_bit_rev_tab[*ucp++];
			}

		} else {
			status = isdnhdlc_decode(&bc->inp_hdlc_state, ucp,
						 bytecount, &count,
						 bc->rxbuf, AUISDN_RXSIZE);
			ucp += count;
			bytecount -= count;
		}
		if (status > 0) {
			/* Good frame received */
			if (!(skb = dev_alloc_skb(status))) {
				warn("receive out of memory");
				break;
			}
			memcpy(skb_put(skb, status), bc->rxbuf, status);
			/* dump ("HDLC Paket", bc->rxbuf, status); */
			auerisdn_b_l1l2(bc, PH_DATA | INDICATION, skb);
			/* these errors may actually happen at the start of a connection! */
		} else if (status == -HDLC_CRC_ERROR) {
			dbg("CRC error");
		} else if (status == -HDLC_FRAMING_ERROR) {
			dbg("framing error");
		} else if (status == -HDLC_LENGTH_ERROR) {
			dbg("length error");
		}
	}

      int_tx:			/* serve the outgoing B channel */
	auerisdn_bserv(&cp->isdn);
}

/* Stop the B channel activity. The device is disconnecting */
/* This function is called after cp->disconnecting is true */
unsigned int auerisdn_b_disconnect(struct auerswald *cp)
{
	unsigned int u;
	struct auerisdnbc *bc;
	unsigned int result = 0;

	/* Close the B channels */
	for (u = 0; u < AUISDN_BCHANNELS; u++) {
		bc = &cp->isdn.bc[u];
		if (bc->mode != L1_MODE_NULL) {	/* B channel is active */
			auerisdn_bmode(bc, L1_MODE_NULL);
			result = 1;
		}
	}
	/* return 1 if there is B channel traffic */
	return result;
}