/*
   *
   * Author	Karsten Keil <kkeil@novell.com>
   *
   * Copyright 2008  by Karsten Keil <kkeil@novell.com>
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License version 2 as
   * published by the Free Software Foundation.
   *
   * 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.
   *
   */
  
  #include <linux/gfp.h>
  #include <linux/module.h>
  #include <linux/mISDNhw.h>
  
  static void
  dchannel_bh(struct work_struct *ws)
  {
  	struct dchannel	*dch  = container_of(ws, struct dchannel, workq);
  	struct sk_buff	*skb;
  	int		err;
  
  	if (test_and_clear_bit(FLG_RECVQUEUE, &dch->Flags)) {
  		while ((skb = skb_dequeue(&dch->rqueue))) {
  			if (likely(dch->dev.D.peer)) {
  				err = dch->dev.D.recv(dch->dev.D.peer, skb);
  				if (err)
  					dev_kfree_skb(skb);
  			} else
  				dev_kfree_skb(skb);
  		}
  	}
  	if (test_and_clear_bit(FLG_PHCHANGE, &dch->Flags)) {
  		if (dch->phfunc)
  			dch->phfunc(dch);
  	}
  }
  
  static void
  bchannel_bh(struct work_struct *ws)
  {
  	struct bchannel	*bch  = container_of(ws, struct bchannel, workq);
  	struct sk_buff	*skb;
  	int		err;
  
  	if (test_and_clear_bit(FLG_RECVQUEUE, &bch->Flags)) {
  		while ((skb = skb_dequeue(&bch->rqueue))) {
  			bch->rcount--;
  			if (likely(bch->ch.peer)) {
  				err = bch->ch.recv(bch->ch.peer, skb);
  				if (err)
  					dev_kfree_skb(skb);
  			} else
  				dev_kfree_skb(skb);
  		}
  	}
  }
  
  int
  mISDN_initdchannel(struct dchannel *ch, int maxlen, void *phf)
  {
  	test_and_set_bit(FLG_HDLC, &ch->Flags);
  	ch->maxlen = maxlen;
  	ch->hw = NULL;
  	ch->rx_skb = NULL;
  	ch->tx_skb = NULL;
  	ch->tx_idx = 0;
  	ch->phfunc = phf;
  	skb_queue_head_init(&ch->squeue);
  	skb_queue_head_init(&ch->rqueue);
  	INIT_LIST_HEAD(&ch->dev.bchannels);
  	INIT_WORK(&ch->workq, dchannel_bh);
  	return 0;
  }
  EXPORT_SYMBOL(mISDN_initdchannel);
  
  int
  mISDN_initbchannel(struct bchannel *ch, unsigned short maxlen,
  		   unsigned short minlen)
  {
  	ch->Flags = 0;
  	ch->minlen = minlen;
  	ch->next_minlen = minlen;
  	ch->init_minlen = minlen;
  	ch->maxlen = maxlen;
  	ch->next_maxlen = maxlen;
  	ch->init_maxlen = maxlen;
  	ch->hw = NULL;
  	ch->rx_skb = NULL;
  	ch->tx_skb = NULL;
  	ch->tx_idx = 0;
  	skb_queue_head_init(&ch->rqueue);
  	ch->rcount = 0;
  	ch->next_skb = NULL;
  	INIT_WORK(&ch->workq, bchannel_bh);
  	return 0;
  }
  EXPORT_SYMBOL(mISDN_initbchannel);
  
  int
  mISDN_freedchannel(struct dchannel *ch)
  {
  	if (ch->tx_skb) {
  		dev_kfree_skb(ch->tx_skb);
  		ch->tx_skb = NULL;
  	}
  	if (ch->rx_skb) {
  		dev_kfree_skb(ch->rx_skb);
  		ch->rx_skb = NULL;
  	}
  	skb_queue_purge(&ch->squeue);
  	skb_queue_purge(&ch->rqueue);
  	flush_work(&ch->workq);
  	return 0;
  }
  EXPORT_SYMBOL(mISDN_freedchannel);
  
  void
  mISDN_clear_bchannel(struct bchannel *ch)
  {
  	if (ch->tx_skb) {
  		dev_kfree_skb(ch->tx_skb);
  		ch->tx_skb = NULL;
  	}
  	ch->tx_idx = 0;
  	if (ch->rx_skb) {
  		dev_kfree_skb(ch->rx_skb);
  		ch->rx_skb = NULL;
  	}
  	if (ch->next_skb) {
  		dev_kfree_skb(ch->next_skb);
  		ch->next_skb = NULL;
  	}
  	test_and_clear_bit(FLG_TX_BUSY, &ch->Flags);
  	test_and_clear_bit(FLG_TX_NEXT, &ch->Flags);
  	test_and_clear_bit(FLG_ACTIVE, &ch->Flags);
  	test_and_clear_bit(FLG_FILLEMPTY, &ch->Flags);
  	test_and_clear_bit(FLG_TX_EMPTY, &ch->Flags);
  	test_and_clear_bit(FLG_RX_OFF, &ch->Flags);
  	ch->dropcnt = 0;
  	ch->minlen = ch->init_minlen;
  	ch->next_minlen = ch->init_minlen;
  	ch->maxlen = ch->init_maxlen;
  	ch->next_maxlen = ch->init_maxlen;
  	skb_queue_purge(&ch->rqueue);
  	ch->rcount = 0;
  }
  EXPORT_SYMBOL(mISDN_clear_bchannel);
  
  void
  mISDN_freebchannel(struct bchannel *ch)
  {
  	cancel_work_sync(&ch->workq);
  	mISDN_clear_bchannel(ch);
  }
  EXPORT_SYMBOL(mISDN_freebchannel);
  
  int
  mISDN_ctrl_bchannel(struct bchannel *bch, struct mISDN_ctrl_req *cq)
  {
  	int ret = 0;
  
  	switch (cq->op) {
  	case MISDN_CTRL_GETOP:
  		cq->op = MISDN_CTRL_RX_BUFFER | MISDN_CTRL_FILL_EMPTY |
  			 MISDN_CTRL_RX_OFF;
  		break;
  	case MISDN_CTRL_FILL_EMPTY:
  		if (cq->p1) {
  			memset(bch->fill, cq->p2 & 0xff, MISDN_BCH_FILL_SIZE);
  			test_and_set_bit(FLG_FILLEMPTY, &bch->Flags);
  		} else {
  			test_and_clear_bit(FLG_FILLEMPTY, &bch->Flags);
  		}
  		break;
  	case MISDN_CTRL_RX_OFF:
  		/* read back dropped byte count */
  		cq->p2 = bch->dropcnt;
  		if (cq->p1)
  			test_and_set_bit(FLG_RX_OFF, &bch->Flags);
  		else
  			test_and_clear_bit(FLG_RX_OFF, &bch->Flags);
  		bch->dropcnt = 0;
  		break;
  	case MISDN_CTRL_RX_BUFFER:
  		if (cq->p2 > MISDN_CTRL_RX_SIZE_IGNORE)
  			bch->next_maxlen = cq->p2;
  		if (cq->p1 > MISDN_CTRL_RX_SIZE_IGNORE)
  			bch->next_minlen = cq->p1;
  		/* we return the old values */
  		cq->p1 = bch->minlen;
  		cq->p2 = bch->maxlen;
  		break;
  	default:
  		pr_info("mISDN unhandled control %x operation
  ", cq->op);
  		ret = -EINVAL;
  		break;
  	}
  	return ret;
  }
  EXPORT_SYMBOL(mISDN_ctrl_bchannel);
  
  static inline u_int
  get_sapi_tei(u_char *p)
  {
  	u_int	sapi, tei;
  
  	sapi = *p >> 2;
  	tei = p[1] >> 1;
  	return sapi | (tei << 8);
  }
  
  void
  recv_Dchannel(struct dchannel *dch)
  {
  	struct mISDNhead *hh;
  
  	if (dch->rx_skb->len < 2) { /* at least 2 for sapi / tei */
  		dev_kfree_skb(dch->rx_skb);
  		dch->rx_skb = NULL;
  		return;
  	}
  	hh = mISDN_HEAD_P(dch->rx_skb);
  	hh->prim = PH_DATA_IND;
  	hh->id = get_sapi_tei(dch->rx_skb->data);
  	skb_queue_tail(&dch->rqueue, dch->rx_skb);
  	dch->rx_skb = NULL;
  	schedule_event(dch, FLG_RECVQUEUE);
  }
  EXPORT_SYMBOL(recv_Dchannel);
  
  void
  recv_Echannel(struct dchannel *ech, struct dchannel *dch)
  {
  	struct mISDNhead *hh;
  
  	if (ech->rx_skb->len < 2) { /* at least 2 for sapi / tei */
  		dev_kfree_skb(ech->rx_skb);
  		ech->rx_skb = NULL;
  		return;
  	}
  	hh = mISDN_HEAD_P(ech->rx_skb);
  	hh->prim = PH_DATA_E_IND;
  	hh->id = get_sapi_tei(ech->rx_skb->data);
  	skb_queue_tail(&dch->rqueue, ech->rx_skb);
  	ech->rx_skb = NULL;
  	schedule_event(dch, FLG_RECVQUEUE);
  }
  EXPORT_SYMBOL(recv_Echannel);
  
  void
  recv_Bchannel(struct bchannel *bch, unsigned int id, bool force)
  {
  	struct mISDNhead *hh;
  
  	/* if allocation did fail upper functions still may call us */
  	if (unlikely(!bch->rx_skb))
  		return;
  	if (unlikely(!bch->rx_skb->len)) {
  		/* we have no data to send - this may happen after recovery
  		 * from overflow or too small allocation.
  		 * We need to free the buffer here */
  		dev_kfree_skb(bch->rx_skb);
  		bch->rx_skb = NULL;
  	} else {
  		if (test_bit(FLG_TRANSPARENT, &bch->Flags) &&
  		    (bch->rx_skb->len < bch->minlen) && !force)
  				return;
  		hh = mISDN_HEAD_P(bch->rx_skb);
  		hh->prim = PH_DATA_IND;
  		hh->id = id;
  		if (bch->rcount >= 64) {
  			printk(KERN_WARNING
  			       "B%d receive queue overflow - flushing!
  ",
  			       bch->nr);
  			skb_queue_purge(&bch->rqueue);
  		}
  		bch->rcount++;
  		skb_queue_tail(&bch->rqueue, bch->rx_skb);
  		bch->rx_skb = NULL;
  		schedule_event(bch, FLG_RECVQUEUE);
  	}
  }
  EXPORT_SYMBOL(recv_Bchannel);
  
  void
  recv_Dchannel_skb(struct dchannel *dch, struct sk_buff *skb)
  {
  	skb_queue_tail(&dch->rqueue, skb);
  	schedule_event(dch, FLG_RECVQUEUE);
  }
  EXPORT_SYMBOL(recv_Dchannel_skb);
  
  void
  recv_Bchannel_skb(struct bchannel *bch, struct sk_buff *skb)
  {
  	if (bch->rcount >= 64) {
  		printk(KERN_WARNING "B-channel %p receive queue overflow, "
  		       "flushing!
  ", bch);
  		skb_queue_purge(&bch->rqueue);
  		bch->rcount = 0;
  	}
  	bch->rcount++;
  	skb_queue_tail(&bch->rqueue, skb);
  	schedule_event(bch, FLG_RECVQUEUE);
  }
  EXPORT_SYMBOL(recv_Bchannel_skb);
  
  static void
  confirm_Dsend(struct dchannel *dch)
  {
  	struct sk_buff	*skb;
  
  	skb = _alloc_mISDN_skb(PH_DATA_CNF, mISDN_HEAD_ID(dch->tx_skb),
  			       0, NULL, GFP_ATOMIC);
  	if (!skb) {
  		printk(KERN_ERR "%s: no skb id %x
  ", __func__,
  		       mISDN_HEAD_ID(dch->tx_skb));
  		return;
  	}
  	skb_queue_tail(&dch->rqueue, skb);
  	schedule_event(dch, FLG_RECVQUEUE);
  }
  
  int
  get_next_dframe(struct dchannel *dch)
  {
  	dch->tx_idx = 0;
  	dch->tx_skb = skb_dequeue(&dch->squeue);
  	if (dch->tx_skb) {
  		confirm_Dsend(dch);
  		return 1;
  	}
  	dch->tx_skb = NULL;
  	test_and_clear_bit(FLG_TX_BUSY, &dch->Flags);
  	return 0;
  }
  EXPORT_SYMBOL(get_next_dframe);
  
  static void
  confirm_Bsend(struct bchannel *bch)
  {
  	struct sk_buff	*skb;
  
  	if (bch->rcount >= 64) {
  		printk(KERN_WARNING "B-channel %p receive queue overflow, "
  		       "flushing!
  ", bch);
  		skb_queue_purge(&bch->rqueue);
  		bch->rcount = 0;
  	}
  	skb = _alloc_mISDN_skb(PH_DATA_CNF, mISDN_HEAD_ID(bch->tx_skb),
  			       0, NULL, GFP_ATOMIC);
  	if (!skb) {
  		printk(KERN_ERR "%s: no skb id %x
  ", __func__,
  		       mISDN_HEAD_ID(bch->tx_skb));
  		return;
  	}
  	bch->rcount++;
  	skb_queue_tail(&bch->rqueue, skb);
  	schedule_event(bch, FLG_RECVQUEUE);
  }
  
  int
  get_next_bframe(struct bchannel *bch)
  {
  	bch->tx_idx = 0;
  	if (test_bit(FLG_TX_NEXT, &bch->Flags)) {
  		bch->tx_skb = bch->next_skb;
  		if (bch->tx_skb) {
  			bch->next_skb = NULL;
  			test_and_clear_bit(FLG_TX_NEXT, &bch->Flags);
  			/* confirm imediately to allow next data */
  			confirm_Bsend(bch);
  			return 1;
  		} else {
  			test_and_clear_bit(FLG_TX_NEXT, &bch->Flags);
  			printk(KERN_WARNING "B TX_NEXT without skb
  ");
  		}
  	}
  	bch->tx_skb = NULL;
  	test_and_clear_bit(FLG_TX_BUSY, &bch->Flags);
  	return 0;
  }
  EXPORT_SYMBOL(get_next_bframe);
  
  void
  queue_ch_frame(struct mISDNchannel *ch, u_int pr, int id, struct sk_buff *skb)
  {
  	struct mISDNhead *hh;
  
  	if (!skb) {
  		_queue_data(ch, pr, id, 0, NULL, GFP_ATOMIC);
  	} else {
  		if (ch->peer) {
  			hh = mISDN_HEAD_P(skb);
  			hh->prim = pr;
  			hh->id = id;
  			if (!ch->recv(ch->peer, skb))
  				return;
  		}
  		dev_kfree_skb(skb);
  	}
  }
  EXPORT_SYMBOL(queue_ch_frame);
  
  int
  dchannel_senddata(struct dchannel *ch, struct sk_buff *skb)
  {
  	/* check oversize */
  	if (skb->len <= 0) {
  		printk(KERN_WARNING "%s: skb too small
  ", __func__);
  		return -EINVAL;
  	}
  	if (skb->len > ch->maxlen) {
  		printk(KERN_WARNING "%s: skb too large(%d/%d)
  ",
  		       __func__, skb->len, ch->maxlen);
  		return -EINVAL;
  	}
  	/* HW lock must be obtained */
  	if (test_and_set_bit(FLG_TX_BUSY, &ch->Flags)) {
  		skb_queue_tail(&ch->squeue, skb);
  		return 0;
  	} else {
  		/* write to fifo */
  		ch->tx_skb = skb;
  		ch->tx_idx = 0;
  		return 1;
  	}
  }
  EXPORT_SYMBOL(dchannel_senddata);
  
  int
  bchannel_senddata(struct bchannel *ch, struct sk_buff *skb)
  {
  
  	/* check oversize */
  	if (skb->len <= 0) {
  		printk(KERN_WARNING "%s: skb too small
  ", __func__);
  		return -EINVAL;
  	}
  	if (skb->len > ch->maxlen) {
  		printk(KERN_WARNING "%s: skb too large(%d/%d)
  ",
  		       __func__, skb->len, ch->maxlen);
  		return -EINVAL;
  	}
  	/* HW lock must be obtained */
  	/* check for pending next_skb */
  	if (ch->next_skb) {
  		printk(KERN_WARNING
  		       "%s: next_skb exist ERROR (skb->len=%d next_skb->len=%d)
  ",
  		       __func__, skb->len, ch->next_skb->len);
  		return -EBUSY;
  	}
  	if (test_and_set_bit(FLG_TX_BUSY, &ch->Flags)) {
  		test_and_set_bit(FLG_TX_NEXT, &ch->Flags);
  		ch->next_skb = skb;
  		return 0;
  	} else {
  		/* write to fifo */
  		ch->tx_skb = skb;
  		ch->tx_idx = 0;
  		confirm_Bsend(ch);
  		return 1;
  	}
  }
  EXPORT_SYMBOL(bchannel_senddata);
  
  /* The function allocates a new receive skb on demand with a size for the
   * requirements of the current protocol. It returns the tailroom of the
   * receive skb or an error.
   */
  int
  bchannel_get_rxbuf(struct bchannel *bch, int reqlen)
  {
  	int len;
  
  	if (bch->rx_skb) {
  		len = skb_tailroom(bch->rx_skb);
  		if (len < reqlen) {
  			pr_warning("B%d no space for %d (only %d) bytes
  ",
  				   bch->nr, reqlen, len);
  			if (test_bit(FLG_TRANSPARENT, &bch->Flags)) {
  				/* send what we have now and try a new buffer */
  				recv_Bchannel(bch, 0, true);
  			} else {
  				/* on HDLC we have to drop too big frames */
  				return -EMSGSIZE;
  			}
  		} else {
  			return len;
  		}
  	}
  	/* update current min/max length first */
  	if (unlikely(bch->maxlen != bch->next_maxlen))
  		bch->maxlen = bch->next_maxlen;
  	if (unlikely(bch->minlen != bch->next_minlen))
  		bch->minlen = bch->next_minlen;
  	if (unlikely(reqlen > bch->maxlen))
  		return -EMSGSIZE;
  	if (test_bit(FLG_TRANSPARENT, &bch->Flags)) {
  		if (reqlen >= bch->minlen) {
  			len = reqlen;
  		} else {
  			len = 2 * bch->minlen;
  			if (len > bch->maxlen)
  				len = bch->maxlen;
  		}
  	} else {
  		/* with HDLC we do not know the length yet */
  		len = bch->maxlen;
  	}
  	bch->rx_skb = mI_alloc_skb(len, GFP_ATOMIC);
  	if (!bch->rx_skb) {
  		pr_warning("B%d receive no memory for %d bytes
  ",
  			   bch->nr, len);
  		len = -ENOMEM;
  	}
  	return len;
  }
  EXPORT_SYMBOL(bchannel_get_rxbuf);