Release 4.7 drivers/isdn/hisax/isdnl2.c

Directory: drivers/isdn/hisax
/* $Id: isdnl2.c,v 2.30.2.4 2004/02/11 13:21:34 keil Exp $
 *
 * Author       Karsten Keil
 *              based on the teles driver from Jan den Ouden
 * Copyright    by Karsten Keil      <keil@isdn4linux.de>
 *
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 *
 * For changes and modifications please read
 * Documentation/isdn/HiSax.cert
 *
 * Thanks to    Jan den Ouden
 *              Fritz Elfert
 *
 */

#include <linux/init.h>
#include <linux/gfp.h>
#include "hisax.h"
#include "isdnl2.h"


const char *l2_revision = "$Revision: 2.30.2.4 $";

static void l2m_debug(struct FsmInst *fi, char *fmt, ...);


static struct Fsm l2fsm;

enum {
	
ST_L2_1,
	
ST_L2_2,
	
ST_L2_3,
	
ST_L2_4,
	
ST_L2_5,
	
ST_L2_6,
	
ST_L2_7,
	
ST_L2_8,
};


#define L2_STATE_COUNT (ST_L2_8 + 1)


static char *strL2State[] =
{
	"ST_L2_1",
	"ST_L2_2",
	"ST_L2_3",
	"ST_L2_4",
	"ST_L2_5",
	"ST_L2_6",
	"ST_L2_7",
	"ST_L2_8",
};

enum {
	
EV_L2_UI,
	
EV_L2_SABME,
	
EV_L2_DISC,
	
EV_L2_DM,
	
EV_L2_UA,
	
EV_L2_FRMR,
	
EV_L2_SUPER,
	
EV_L2_I,
	
EV_L2_DL_DATA,
	
EV_L2_ACK_PULL,
	
EV_L2_DL_UNIT_DATA,
	
EV_L2_DL_ESTABLISH_REQ,
	
EV_L2_DL_RELEASE_REQ,
	
EV_L2_MDL_ASSIGN,
	
EV_L2_MDL_REMOVE,
	
EV_L2_MDL_ERROR,
	
EV_L1_DEACTIVATE,
	
EV_L2_T200,
	
EV_L2_T203,
	
EV_L2_SET_OWN_BUSY,
	
EV_L2_CLEAR_OWN_BUSY,
	
EV_L2_FRAME_ERROR,
};


#define L2_EVENT_COUNT (EV_L2_FRAME_ERROR + 1)


static char *strL2Event[] =
{
	"EV_L2_UI",
	"EV_L2_SABME",
	"EV_L2_DISC",
	"EV_L2_DM",
	"EV_L2_UA",
	"EV_L2_FRMR",
	"EV_L2_SUPER",
	"EV_L2_I",
	"EV_L2_DL_DATA",
	"EV_L2_ACK_PULL",
	"EV_L2_DL_UNIT_DATA",
	"EV_L2_DL_ESTABLISH_REQ",
	"EV_L2_DL_RELEASE_REQ",
	"EV_L2_MDL_ASSIGN",
	"EV_L2_MDL_REMOVE",
	"EV_L2_MDL_ERROR",
	"EV_L1_DEACTIVATE",
	"EV_L2_T200",
	"EV_L2_T203",
	"EV_L2_SET_OWN_BUSY",
	"EV_L2_CLEAR_OWN_BUSY",
	"EV_L2_FRAME_ERROR",
};

static int l2addrsize(struct Layer2 *l2);


static void

set_peer_busy(struct Layer2 *l2) {
	test_and_set_bit(FLG_PEER_BUSY, &l2->flag);
	if (!skb_queue_empty(&l2->i_queue) ||
	    !skb_queue_empty(&l2->ui_queue))
		test_and_set_bit(FLG_L2BLOCK, &l2->flag);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 47 92.16% 3 75.00%
david s. miller david s. miller 4 7.84% 1 25.00%
Total 51 100.00% 4 100.00%


static void

clear_peer_busy(struct Layer2 *l2) {
	if (test_and_clear_bit(FLG_PEER_BUSY, &l2->flag))
		test_and_clear_bit(FLG_L2BLOCK, &l2->flag);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 33 100.00% 1 100.00%
Total 33 100.00% 1 100.00%


static void

InitWin(struct Layer2 *l2)
{
	int i;

	for (i = 0; i < MAX_WINDOW; i++)
		l2->windowar[i] = NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 36 100.00% 2 100.00%
Total 36 100.00% 2 100.00%


static int

freewin1(struct Layer2 *l2)
{
	int i, cnt = 0;

	for (i = 0; i < MAX_WINDOW; i++) {
		if (l2->windowar[i]) {
			cnt++;
			dev_kfree_skb(l2->windowar[i]);
			l2->windowar[i] = NULL;
		}
	}
	return cnt;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 69 100.00% 3 100.00%
Total 69 100.00% 3 100.00%


static inline void

freewin(struct PStack *st)
{
	freewin1(&st->l2);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 19 95.00% 1 50.00%
adrian bunk adrian bunk 1 5.00% 1 50.00%
Total 20 100.00% 2 100.00%


static void

ReleaseWin(struct Layer2 *l2)
{
	int cnt;

	if ((cnt = freewin1(l2)))
		printk(KERN_WARNING "isdl2 freed %d skbuffs in release\n", cnt);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 33 100.00% 2 100.00%
Total 33 100.00% 2 100.00%


static inline unsigned int

cansend(struct PStack *st)
{
	unsigned int p1;

	if (test_bit(FLG_MOD128, &st->l2.flag))
		p1 = (st->l2.vs - st->l2.va) % 128;
	else
		p1 = (st->l2.vs - st->l2.va) % 8;
	return ((p1 < st->l2.window) && !test_bit(FLG_PEER_BUSY, &st->l2.flag));
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 93 98.94% 3 75.00%
adrian bunk adrian bunk 1 1.06% 1 25.00%
Total 94 100.00% 4 100.00%


static inline void

clear_exception(struct Layer2 *l2)
{
	test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
	test_and_clear_bit(FLG_REJEXC, &l2->flag);
	test_and_clear_bit(FLG_OWN_BUSY, &l2->flag);
	clear_peer_busy(l2);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 46 97.87% 2 66.67%
adrian bunk adrian bunk 1 2.13% 1 33.33%
Total 47 100.00% 3 100.00%


static inline int

l2headersize(struct Layer2 *l2, int ui)
{
	return (((test_bit(FLG_MOD128, &l2->flag) && (!ui)) ? 2 : 1) +
		(test_bit(FLG_LAPD, &l2->flag) ? 2 : 1));
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 55 96.49% 2 50.00%
adrian bunk adrian bunk 1 1.75% 1 25.00%
andrew morton andrew morton 1 1.75% 1 25.00%
Total 57 100.00% 4 100.00%


inline int

l2addrsize(struct Layer2 *l2)
{
	return (test_bit(FLG_LAPD, &l2->flag) ? 2 : 1);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 27 96.43% 2 66.67%
andrew morton andrew morton 1 3.57% 1 33.33%
Total 28 100.00% 3 100.00%


static int

sethdraddr(struct Layer2 *l2, u_char *header, int rsp)
{
	u_char *ptr = header;
	int crbit = rsp;

	if (test_bit(FLG_LAPD, &l2->flag)) {
		*ptr++ = (l2->sap << 2) | (rsp ? 2 : 0);
		*ptr++ = (l2->tei << 1) | 1;
		return (2);
	} else {
		if (test_bit(FLG_ORIG, &l2->flag))
			crbit = !crbit;
		if (crbit)
			*ptr++ = 1;
		else
			*ptr++ = 3;
		return (1);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 122 98.39% 3 75.00%
andrew morton andrew morton 2 1.61% 1 25.00%
Total 124 100.00% 4 100.00%


static inline void

enqueue_super(struct PStack *st,
	      struct sk_buff *skb)
{
	if (test_bit(FLG_LAPB, &st->l2.flag))
		st->l1.bcs->tx_cnt += skb->len;
	st->l2.l2l1(st, PH_DATA | REQUEST, skb);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 52 89.66% 3 60.00%
andrew morton andrew morton 5 8.62% 1 20.00%
jesper juhl jesper juhl 1 1.72% 1 20.00%
Total 58 100.00% 5 100.00%


#define enqueue_ui(a, b) enqueue_super(a, b)


static inline int

IsUI(u_char *data)
{
	return ((data[0] & 0xef) == UI);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 23 92.00% 2 50.00%
adrian bunk adrian bunk 1 4.00% 1 25.00%
andrew morton andrew morton 1 4.00% 1 25.00%
Total 25 100.00% 4 100.00%


static inline int

IsUA(u_char *data)
{
	return ((data[0] & 0xef) == UA);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 23 92.00% 2 50.00%
andrew morton andrew morton 1 4.00% 1 25.00%
adrian bunk adrian bunk 1 4.00% 1 25.00%
Total 25 100.00% 4 100.00%


static inline int

IsDM(u_char *data)
{
	return ((data[0] & 0xef) == DM);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 23 92.00% 3 60.00%
adrian bunk adrian bunk 1 4.00% 1 20.00%
andrew morton andrew morton 1 4.00% 1 20.00%
Total 25 100.00% 5 100.00%


static inline int

IsDISC(u_char *data)
{
	return ((data[0] & 0xef) == DISC);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 23 92.00% 2 50.00%
andrew morton andrew morton 1 4.00% 1 25.00%
adrian bunk adrian bunk 1 4.00% 1 25.00%
Total 25 100.00% 4 100.00%


static inline int

IsSFrame(u_char *data, struct PStack *st)
{
	register u_char d = *data;

	if (!test_bit(FLG_MOD128, &st->l2.flag))
		d &= 0xf;
	return (((d & 0xf3) == 1) && ((d & 0x0c) != 0x0c));
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 62 95.38% 3 60.00%
andrew morton andrew morton 2 3.08% 1 20.00%
adrian bunk adrian bunk 1 1.54% 1 20.00%
Total 65 100.00% 5 100.00%


static inline int

IsSABME(u_char *data, struct PStack *st)
{
	u_char d = data[0] & ~0x10;

	return (test_bit(FLG_MOD128, &st->l2.flag) ? d == SABME : d == SABM);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 47 94.00% 5 71.43%
andrew morton andrew morton 2 4.00% 1 14.29%
adrian bunk adrian bunk 1 2.00% 1 14.29%
Total 50 100.00% 7 100.00%


static inline int

IsREJ(u_char *data, struct PStack *st)
{
	return (test_bit(FLG_MOD128, &st->l2.flag) ? data[0] == REJ : (data[0] & 0xf) == REJ);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 47 95.92% 4 66.67%
adrian bunk adrian bunk 1 2.04% 1 16.67%
andrew morton andrew morton 1 2.04% 1 16.67%
Total 49 100.00% 6 100.00%


static inline int

IsFRMR(u_char *data)
{
	return ((data[0] & 0xef) == FRMR);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 23 92.00% 2 50.00%
andrew morton andrew morton 1 4.00% 1 25.00%
adrian bunk adrian bunk 1 4.00% 1 25.00%
Total 25 100.00% 4 100.00%


static inline int

IsRNR(u_char *data, struct PStack *st)
{
	return (test_bit(FLG_MOD128, &st->l2.flag) ? data[0] == RNR : (data[0] & 0xf) == RNR);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 47 95.92% 3 60.00%
adrian bunk adrian bunk 1 2.04% 1 20.00%
andrew morton andrew morton 1 2.04% 1 20.00%
Total 49 100.00% 5 100.00%


static int

iframe_error(struct PStack *st, struct sk_buff *skb)
{
	int i = l2addrsize(&st->l2) + (test_bit(FLG_MOD128, &st->l2.flag) ? 2 : 1);
	int rsp = *skb->data & 0x2;

	if (test_bit(FLG_ORIG, &st->l2.flag))
		rsp = !rsp;

	if (rsp)
		return 'L';


	if (skb->len < i)
		return 'N';

	if ((skb->len - i) > st->l2.maxlen)
		return 'O';


	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 112 98.25% 5 71.43%
adrian bunk adrian bunk 1 0.88% 1 14.29%
andrew morton andrew morton 1 0.88% 1 14.29%
Total 114 100.00% 7 100.00%


static int

super_error(struct PStack *st, struct sk_buff *skb)
{
	if (skb->len != l2addrsize(&st->l2) +
	    (test_bit(FLG_MOD128, &st->l2.flag) ? 2 : 1))
		return 'N';

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 53 98.15% 3 75.00%
adrian bunk adrian bunk 1 1.85% 1 25.00%
Total 54 100.00% 4 100.00%


static int

unnum_error(struct PStack *st, struct sk_buff *skb, int wantrsp)
{
	int rsp = (*skb->data & 0x2) >> 1;
	if (test_bit(FLG_ORIG, &st->l2.flag))
		rsp = !rsp;

	if (rsp != wantrsp)
		return 'L';

	if (skb->len != l2addrsize(&st->l2) + 1)
		return 'N';

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 82 98.80% 3 75.00%
adrian bunk adrian bunk 1 1.20% 1 25.00%
Total 83 100.00% 4 100.00%


static int

UI_error(struct PStack *st, struct sk_buff *skb)
{
	int rsp = *skb->data & 0x2;
	if (test_bit(FLG_ORIG, &st->l2.flag))
		rsp = !rsp;

	if (rsp)
		return 'L';

	if (skb->len > st->l2.maxlen + l2addrsize(&st->l2) + 1)
		return 'O';

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 79 98.75% 4 80.00%
adrian bunk adrian bunk 1 1.25% 1 20.00%
Total 80 100.00% 5 100.00%


static int

FRMR_error(struct PStack *st, struct sk_buff *skb)
{
	int headers = l2addrsize(&st->l2) + 1;
	u_char *datap = skb->data + headers;
	int rsp = *skb->data & 0x2;

	if (test_bit(FLG_ORIG, &st->l2.flag))
		rsp = !rsp;

	if (!rsp)
		return 'L';

	if (test_bit(FLG_MOD128, &st->l2.flag)) {
		if (skb->len < headers + 5)
			return 'N';
		else
			l2m_debug(&st->l2.l2m, "FRMR information %2x %2x %2x %2x %2x",
				  datap[0], datap[1], datap[2],
				  datap[3], datap[4]);
	} else {
		if (skb->len < headers + 3)
			return 'N';
		else
			l2m_debug(&st->l2.l2m, "FRMR information %2x %2x %2x",
				  datap[0], datap[1], datap[2]);
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 187 98.42% 4 66.67%
andrew morton andrew morton 2 1.05% 1 16.67%
adrian bunk adrian bunk 1 0.53% 1 16.67%
Total 190 100.00% 6 100.00%


static unsigned int

legalnr(struct PStack *st, unsigned int nr)
{
	struct Layer2 *l2 = &st->l2;

	if (test_bit(FLG_MOD128, &l2->flag))
		return ((nr - l2->va) % 128) <= ((l2->vs - l2->va) % 128);
	else
		return ((nr - l2->va) % 8) <= ((l2->vs - l2->va) % 8);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 93 100.00% 4 100.00%
Total 93 100.00% 4 100.00%


static void

setva(struct PStack *st, unsigned int nr)
{
	struct Layer2 *l2 = &st->l2;
	int len;
	u_long flags;

	spin_lock_irqsave(&l2->lock, flags);
	while (l2->va != nr) {
		(l2->va)++;
		if (test_bit(FLG_MOD128, &l2->flag))
			l2->va %= 128;
		else
			l2->va %= 8;
		len = l2->windowar[l2->sow]->len;
		if (PACKET_NOACK == l2->windowar[l2->sow]->pkt_type)
			len = -1;
		dev_kfree_skb(l2->windowar[l2->sow]);
		l2->windowar[l2->sow] = NULL;
		l2->sow = (l2->sow + 1) % l2->window;
		spin_unlock_irqrestore(&l2->lock, flags);
		if (test_bit(FLG_LLI_L2WAKEUP, &st->lli.flag) && (len >= 0))
			lli_writewakeup(st, len);
		spin_lock_irqsave(&l2->lock, flags);
	}
	spin_unlock_irqrestore(&l2->lock, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 110 51.89% 4 57.14%
andrew morton andrew morton 101 47.64% 2 28.57%
kai germaschewski kai germaschewski 1 0.47% 1 14.29%
Total 212 100.00% 7 100.00%


static void

send_uframe(struct PStack *st, u_char cmd, u_char cr)
{
	struct sk_buff *skb;
	u_char tmp[MAX_HEADER_LEN];
	int i;

	i = sethdraddr(&st->l2, tmp, cr);
	tmp[i++] = cmd;
	if (!(skb = alloc_skb(i, GFP_ATOMIC))) {
		printk(KERN_WARNING "isdl2 can't alloc sbbuff for send_uframe\n");
		return;
	}
	memcpy(skb_put(skb, i), tmp, i);
	enqueue_super(st, skb);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 94 96.91% 3 75.00%
andrew morton andrew morton 3 3.09% 1 25.00%
Total 97 100.00% 4 100.00%


static inline u_char

get_PollFlag(struct PStack *st, struct sk_buff *skb)
{
	return (skb->data[l2addrsize(&(st->l2))] & 0x10);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 35 94.59% 2 50.00%
adrian bunk adrian bunk 1 2.70% 1 25.00%
andrew morton andrew morton 1 2.70% 1 25.00%
Total 37 100.00% 4 100.00%


static inline u_char

get_PollFlagFree(struct PStack *st, struct sk_buff *skb)
{
	u_char PF;

	PF = get_PollFlag(st, skb);
	dev_kfree_skb(skb);
	return (PF);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 35 89.74% 4 66.67%
adrian bunk adrian bunk 2 5.13% 1 16.67%
andrew morton andrew morton 2 5.13% 1 16.67%
Total 39 100.00% 6 100.00%


static inline void

start_t200(struct PStack *st, int i)
{
	FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, i);
	test_and_set_bit(FLG_T200_RUN, &st->l2.flag);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 48 97.96% 3 75.00%
adrian bunk adrian bunk 1 2.04% 1 25.00%
Total 49 100.00% 4 100.00%


static inline void

restart_t200(struct PStack *st, int i)
{
	FsmRestartTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, i);
	test_and_set_bit(FLG_T200_RUN, &st->l2.flag);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 48 97.96% 3 75.00%
adrian bunk adrian bunk 1 2.04% 1 25.00%
Total 49 100.00% 4 100.00%


static inline void

stop_t200(struct PStack *st, int i)
{
	if (test_and_clear_bit(FLG_T200_RUN, &st->l2.flag))
		FsmDelTimer(&st->l2.t200, i);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 40 97.56% 4 80.00%
adrian bunk adrian bunk 1 2.44% 1 20.00%
Total 41 100.00% 5 100.00%


static inline void

st5_dl_release_l2l3(struct PStack *st)
{
	int pr;

	if (test_and_clear_bit(FLG_PEND_REL, &st->l2.flag))
		pr = DL_RELEASE | CONFIRM;
	else
		pr = DL_RELEASE | INDICATION;

	st->l2.l2l3(st, pr, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 49 89.09% 3 60.00%
andrew morton andrew morton 5 9.09% 1 20.00%
adrian bunk adrian bunk 1 1.82% 1 20.00%
Total 55 100.00% 5 100.00%


static inline void

lapb_dl_release_l2l3(struct PStack *st, int f)
{
	if (test_bit(FLG_LAPB, &st->l2.flag))
		st->l2.l2l1(st, PH_DEACTIVATE | REQUEST, NULL);
	st->l2.l2l3(st, DL_RELEASE | f, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 48 81.36% 3 60.00%
andrew morton andrew morton 10 16.95% 1 20.00%
adrian bunk adrian bunk 1 1.69% 1 20.00%
Total 59 100.00% 5 100.00%


static void

establishlink(struct FsmInst *fi)
{
	struct PStack *st = fi->userdata;
	u_char cmd;

	clear_exception(&st->l2);
	st->l2.rc = 0;
	cmd = (test_bit(FLG_MOD128, &st->l2.flag) ? SABME : SABM) | 0x10;
	send_uframe(st, cmd, CMD);
	FsmDelTimer(&st->l2.t203, 1);
	restart_t200(st, 1);
	test_and_clear_bit(FLG_PEND_REL, &st->l2.flag);
	freewin(st);
	FsmChangeState(fi, ST_L2_5);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 112 99.12% 3 75.00%
andrew morton andrew morton 1 0.88% 1 25.00%
Total 113 100.00% 4 100.00%


static void

l2_mdl_error_ua(struct FsmInst *fi, int event, void *arg)
{
	struct sk_buff *skb = arg;
	struct PStack *st = fi->userdata;

	if (get_PollFlagFree(st, skb))
		st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'C');
	else
		st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'D');
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 82 100.00% 5 100.00%
Total 82 100.00% 5 100.00%


static void

l2_mdl_error_dm(struct FsmInst *fi, int event, void *arg)
{
	struct sk_buff *skb = arg;
	struct PStack *st = fi->userdata;

	if (get_PollFlagFree(st, skb))
		st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'B');
	else {
		st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'E');
		establishlink(fi);
		test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 101 100.00% 5 100.00%
Total 101 100.00% 5 100.00%


static void

l2_st8_mdl_error_dm(struct FsmInst *fi, int event, void *arg)
{
	struct sk_buff *skb = arg;
	struct PStack *st = fi->userdata;

	if (get_PollFlagFree(st, skb))
		st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'B');
	else {
		st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'E');
	}
	establishlink(fi);
	test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 101 100.00% 5 100.00%
Total 101 100.00% 5 100.00%


static void

l2_go_st3(struct FsmInst *fi, int event, void *arg)
{
	FsmChangeState(fi, ST_L2_3);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 25 100.00% 2 100.00%
Total 25 100.00% 2 100.00%


static void

l2_mdl_assign(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	FsmChangeState(fi, ST_L2_3);
	st->l2.l2tei(st, MDL_ASSIGN | INDICATION, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 49 100.00% 5 100.00%
Total 49 100.00% 5 100.00%


static void

l2_queue_ui_assign(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;

	skb_queue_tail(&st->l2.ui_queue, skb);
	FsmChangeState(fi, ST_L2_2);
	st->l2.l2tei(st, MDL_ASSIGN | INDICATION, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 68 100.00% 4 100.00%
Total 68 100.00% 4 100.00%


static void

l2_queue_ui(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;

	skb_queue_tail(&st->l2.ui_queue, skb);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 46 100.00% 3 100.00%
Total 46 100.00% 3 100.00%


static void

tx_ui(struct PStack *st)
{
	struct sk_buff *skb;
	u_char header[MAX_HEADER_LEN];
	int i;

	i = sethdraddr(&(st->l2), header, CMD);
	header[i++] = UI;
	while ((skb = skb_dequeue(&st->l2.ui_queue))) {
		memcpy(skb_push(skb, i), header, i);
		enqueue_ui(st, skb);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 87 98.86% 4 80.00%
andrew morton andrew morton 1 1.14% 1 20.00%
Total 88 100.00% 5 100.00%


static void

l2_send_ui(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;

	skb_queue_tail(&st->l2.ui_queue, skb);
	tx_ui(st);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 51 100.00% 3 100.00%
Total 51 100.00% 3 100.00%


static void

l2_got_ui(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;

	skb_pull(skb, l2headersize(&st->l2, 1));
	st->l2.l2l3(st, DL_UNIT_DATA | INDICATION, skb);
/*      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 *              in states 1-3 for broadcast
 */


}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 60 92.31% 5 83.33%
andrew morton andrew morton 5 7.69% 1 16.67%
Total 65 100.00% 6 100.00%


static void

l2_establish(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	establishlink(fi);
	test_and_set_bit(FLG_L3_INIT, &st->l2.flag);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 44 100.00% 4 100.00%
Total 44 100.00% 4 100.00%


static void

l2_discard_i_setl3(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	skb_queue_purge(&st->l2.i_queue);
	test_and_set_bit(FLG_L3_INIT, &st->l2.flag);
	test_and_clear_bit(FLG_PEND_REL, &st->l2.flag);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 60 98.36% 2 66.67%
linus torvalds linus torvalds 1 1.64% 1 33.33%
Total 61 100.00% 3 100.00%


static void

l2_l3_reestablish(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	skb_queue_purge(&st->l2.i_queue);
	establishlink(fi);
	test_and_set_bit(FLG_L3_INIT, &st->l2.flag);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 53 98.15% 2 66.67%
linus torvalds linus torvalds 1 1.85% 1 33.33%
Total 54 100.00% 3 100.00%


static void

l2_release(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	st->l2.l2l3(st, DL_RELEASE | CONFIRM, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 37 88.10% 1 50.00%
andrew morton andrew morton 5 11.90% 1 50.00%
Total 42 100.00% 2 100.00%


static void

l2_pend_rel(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	test_and_set_bit(FLG_PEND_REL, &st->l2.flag);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 39 100.00% 1 100.00%
Total 39 100.00% 1 100.00%


static void

l2_disconnect(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	skb_queue_purge(&st->l2.i_queue);
	freewin(st);
	FsmChangeState(fi, ST_L2_6);
	st->l2.rc = 0;
	send_uframe(st, DISC | 0x10, CMD);
	FsmDelTimer(&st->l2.t203, 1);
	restart_t200(st, 2);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 86 98.85% 2 66.67%
linus torvalds linus torvalds 1 1.15% 1 33.33%
Total 87 100.00% 3 100.00%


static void

l2_start_multi(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;

	send_uframe(st, UA | get_PollFlagFree(st, skb), RSP);

	clear_exception(&st->l2);
	st->l2.vs = 0;
	st->l2.va = 0;
	st->l2.vr = 0;
	st->l2.sow = 0;
	FsmChangeState(fi, ST_L2_7);
	FsmAddTimer(&st->l2.t203, st->l2.T203, EV_L2_T203, NULL, 3);

	st->l2.l2l3(st, DL_ESTABLISH | INDICATION, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 129 96.27% 5 83.33%
andrew morton andrew morton 5 3.73% 1 16.67%
Total 134 100.00% 6 100.00%


static void

l2_send_UA(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;

	send_uframe(st, UA | get_PollFlagFree(st, skb), RSP);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 50 100.00% 4 100.00%
Total 50 100.00% 4 100.00%


static void

l2_send_DM(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;

	send_uframe(st, DM | get_PollFlagFree(st, skb), RSP);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 50 100.00% 4 100.00%
Total 50 100.00% 4 100.00%


static void

l2_restart_multi(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;
	int est = 0, state;

	state = fi->state;

	send_uframe(st, UA | get_PollFlagFree(st, skb), RSP);

	st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'F');

	if (st->l2.vs != st->l2.va) {
		skb_queue_purge(&st->l2.i_queue);
		est = 1;
	}

	clear_exception(&st->l2);
	st->l2.vs = 0;
	st->l2.va = 0;
	st->l2.vr = 0;
	st->l2.sow = 0;
	FsmChangeState(fi, ST_L2_7);
	stop_t200(st, 3);
	FsmRestartTimer(&st->l2.t203, st->l2.T203, EV_L2_T203, NULL, 3);

	if (est)
		st->l2.l2l3(st, DL_ESTABLISH | INDICATION, NULL);

	if ((ST_L2_7 == state) || (ST_L2_8 == state))
		if (!skb_queue_empty(&st->l2.i_queue) && cansend(st))
			st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 241 94.88% 5 62.50%
andrew morton andrew morton 10 3.94% 1 12.50%
david s. miller david s. miller 2 0.79% 1 12.50%
linus torvalds linus torvalds 1 0.39% 1 12.50%
Total 254 100.00% 8 100.00%


static void

l2_stop_multi(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;

	FsmChangeState(fi, ST_L2_4);
	FsmDelTimer(&st->l2.t203, 3);
	stop_t200(st, 4);

	send_uframe(st, UA | get_PollFlagFree(st, skb), RSP);

	skb_queue_purge(&st->l2.i_queue);
	freewin(st);
	lapb_dl_release_l2l3(st, INDICATION);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 97 98.98% 5 83.33%
linus torvalds linus torvalds 1 1.02% 1 16.67%
Total 98 100.00% 6 100.00%


static void

l2_connected(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;
	int pr = -1;

	if (!get_PollFlag(st, skb)) {
		l2_mdl_error_ua(fi, event, arg);
		return;
	}
	dev_kfree_skb(skb);

	if (test_and_clear_bit(FLG_PEND_REL, &st->l2.flag))
		l2_disconnect(fi, event, arg);

	if (test_and_clear_bit(FLG_L3_INIT, &st->l2.flag)) {
		pr = DL_ESTABLISH | CONFIRM;
	} else if (st->l2.vs != st->l2.va) {
		skb_queue_purge(&st->l2.i_queue);
		pr = DL_ESTABLISH | INDICATION;
	}

	stop_t200(st, 5);

	st->l2.vr = 0;
	st->l2.vs = 0;
	st->l2.va = 0;
	st->l2.sow = 0;
	FsmChangeState(fi, ST_L2_7);
	FsmAddTimer(&st->l2.t203, st->l2.T203, EV_L2_T203, NULL, 4);

	if (pr != -1)
		st->l2.l2l3(st, pr, NULL);

	if (!skb_queue_empty(&st->l2.i_queue) && cansend(st))
		st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 252 94.74% 6 60.00%
andrew morton andrew morton 10 3.76% 1 10.00%
david s. miller david s. miller 2 0.75% 1 10.00%
adrian bunk adrian bunk 1 0.38% 1 10.00%
linus torvalds linus torvalds 1 0.38% 1 10.00%
Total 266 100.00% 10 100.00%


static void

l2_released(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;

	if (!get_PollFlag(st, skb)) {
		l2_mdl_error_ua(fi, event, arg);
		return;
	}
	dev_kfree_skb(skb);

	stop_t200(st, 6);
	lapb_dl_release_l2l3(st, CONFIRM);
	FsmChangeState(fi, ST_L2_4);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 81 98.78% 4 80.00%
adrian bunk adrian bunk 1 1.22% 1 20.00%
Total 82 100.00% 5 100.00%


static void

l2_reestablish(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;

	if (!get_PollFlagFree(st, skb)) {
		establishlink(fi);
		test_and_set_bit(FLG_L3_INIT, &st->l2.flag);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 63 100.00% 5 100.00%
Total 63 100.00% 5 100.00%


static void

l2_st5_dm_release(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;

	if (get_PollFlagFree(st, skb)) {
		stop_t200(st, 7);
		if (!test_bit(FLG_L3_INIT, &st->l2.flag))
			skb_queue_purge(&st->l2.i_queue);
		if (test_bit(FLG_LAPB, &st->l2.flag))
			st->l2.l2l1(st, PH_DEACTIVATE | REQUEST, NULL);
		st5_dl_release_l2l3(st);
		FsmChangeState(fi, ST_L2_4);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 112 94.92% 4 66.67%
andrew morton andrew morton 5 4.24% 1 16.67%
linus torvalds linus torvalds 1 0.85% 1 16.67%
Total 118 100.00% 6 100.00%


static void

l2_st6_dm_release(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;

	if (get_PollFlagFree(st, skb)) {
		stop_t200(st, 8);
		lapb_dl_release_l2l3(st, CONFIRM);
		FsmChangeState(fi, ST_L2_4);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 66 100.00% 4 100.00%
Total 66 100.00% 4 100.00%


static inline void

enquiry_cr(struct PStack *st, u_char typ, u_char cr, u_char pf)
{
	struct sk_buff *skb;
	struct Layer2 *l2;
	u_char tmp[MAX_HEADER_LEN];
	int i;

	l2 = &st->l2;
	i = sethdraddr(l2, tmp, cr);
	if (test_bit(FLG_MOD128, &l2->flag)) {
		tmp[i++] = typ;
		tmp[i++] = (l2->vr << 1) | (pf ? 1 : 0);
	} else
		tmp[i++] = (l2->vr << 5) | typ | (pf ? 0x10 : 0);
	if (!(skb = alloc_skb(i, GFP_ATOMIC))) {
		printk(KERN_WARNING "isdl2 can't alloc sbbuff for enquiry_cr\n");
		return;
	}
	memcpy(skb_put(skb, i), tmp, i);
	enqueue_super(st, skb);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 166 97.08% 2 50.00%
andrew morton andrew morton 4 2.34% 1 25.00%
adrian bunk adrian bunk 1 0.58% 1 25.00%
Total 171 100.00% 4 100.00%


static inline void

enquiry_response(struct PStack *st)
{
	if (test_bit(FLG_OWN_BUSY, &st->l2.flag))
		enquiry_cr(st, RNR, RSP, 1);
	else
		enquiry_cr(st, RR, RSP, 1);
	test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 60 98.36% 3 75.00%
adrian bunk adrian bunk 1 1.64% 1 25.00%
Total 61 100.00% 4 100.00%


static inline void

transmit_enquiry(struct PStack *st)
{
	if (test_bit(FLG_OWN_BUSY, &st->l2.flag))
		enquiry_cr(st, RNR, CMD, 1);
	else
		enquiry_cr(st, RR, CMD, 1);
	test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag);
	start_t200(st, 9);
}


Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 67 98.53% 4 80.00%
adrian bunk adrian bunk 1 1.47% 1 20.00%
Total 68 100.00% 5 100.00%


static void

nrerrorrecovery(struct FsmInst *fi)
{
	struct PStack *st = fi->userdata;

	st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'J');
	establishlink(fi);
	test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 56 100.00% 4 100.00%
Total 56 100.00% 4 100.00%


static void

invoke_retransmission(struct PStack *st, unsigned int nr)
{
	struct Layer2 *l2 = &st->l2;
	u_int p1;
	u_long flags;

	spin_lock_irqsave(&l2->lock, flags);
	if (l2->vs != nr) {
		while (l2->vs != nr) {
			(l2->vs)--;
			if (test_bit(FLG_MOD128, &l2->flag)) {
				l2->vs %= 128;
				p1 = (l2->vs - l2->va) % 128;
			} else {
				l2->vs %= 8;
				p1 = (l2->vs - l2->va) % 8;
			}
			p1 = (p1 + l2->sow) % l2->window;
			if (test_bit(FLG_LAPB, &l2->flag))
				st->l1.bcs->tx_cnt += l2->windowar[p1]->len + l2headersize(l2, 0);
			skb_queue_head(&l2->i_queue, l2->windowar[p1]);
			l2->windowar[p1] = NULL;
		}
		spin_unlock_irqrestore(&l2->lock, flags);
		st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
		return;
	}
	spin_unlock_irqrestore(&l2->lock, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 195 82.98% 5 83.33%
andrew morton andrew morton 40 17.02% 1 16.67%
Total 235 100.00% 6 100.00%


static void

l2_st7_got_super(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;
	int PollFlag, rsp, typ = RR;
	unsigned int nr;
	struct Layer2 *l2 = &st->l2;

	rsp = *skb->data & 0x2;
	if (test_bit(FLG_ORIG, &l2->flag))
		rsp = !rsp;

	skb_pull(skb, l2addrsize(l2));
	if (IsRNR(skb->data, st)) {
		set_peer_busy(l2);
		typ = RNR;
	} else
		clear_peer_busy(l2);
	if (IsREJ(skb->data, st))
		typ = REJ;

	if (test_bit(FLG_MOD128, &l2->flag)) {
		PollFlag = (skb->data[1] & 0x1) == 0x1;
		nr = skb->data[1] >> 1;
	} else {
		PollFlag = (skb->data[0] & 0x10);
		nr = (skb->data[0] >> 5) & 0x7;
	}
	dev_kfree_skb(skb);

	if (PollFlag) {
		if (rsp)
			st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'A');
		else
			enquiry_response(st);
	}
	if (legalnr(st, nr)) {
		if (typ == REJ) {
			setva(st, nr);
			invoke_retransmission(st, nr);
			stop_t200(st, 10);
			if (FsmAddTimer(&st->l2.t203, st->l2.T203,
					EV_L2_T203, NULL, 6))
				l2m_debug(&st->l2.l2m, "Restart T203 ST7 REJ");
		} else if ((nr == l2->vs) && (typ == RR)) {
			setva(st, nr);
			stop_t200(st, 11);
			FsmRestartTimer(&st->l2.t203, st->l2.T203,
					EV_L2_T203, NULL, 7);
		} else if ((l2->va != nr) || (typ == RNR)) {
			setva(st, nr);
			if (typ != RR) FsmDelTimer(&st->l2.t203, 9);
			restart_t200(st, 12);
		}
		if (!skb_queue_empty(&st->l2.i_queue) && (typ == RR))
			st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
	} else
		nrerrorrecovery(fi);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 461 98.29% 5 62.50%
andrew morton andrew morton 5 1.07% 1 12.50%
david s. miller david s. miller 2 0.43% 1 12.50%
adrian bunk adrian bunk 1 0.21% 1 12.50%
Total 469 100.00% 8 100.00%


static void

l2_feed_i_if_reest(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;

	if (test_bit(FLG_LAPB, &st->l2.flag))
		st->l1.bcs->tx_cnt += skb->len + l2headersize(&st->l2, 0);
	if (!test_bit(FLG_L3_INIT, &st->l2.flag))
		skb_queue_tail(&st->l2.i_queue, skb);
	else
		dev_kfree_skb(skb);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 102 99.03% 3 75.00%
adrian bunk adrian bunk 1 0.97% 1 25.00%
Total 103 100.00% 4 100.00%


static void

l2_feed_i_pull(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;

	if (test_bit(FLG_LAPB, &st->l2.flag))
		st->l1.bcs->tx_cnt += skb->len + l2headersize(&st->l2, 0);
	skb_queue_tail(&st->l2.i_queue, skb);
	st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 92 94.85% 3 75.00%
andrew morton andrew morton 5 5.15% 1 25.00%
Total 97 100.00% 4 100.00%


static void

l2_feed_iqueue(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;

	if (test_bit(FLG_LAPB, &st->l2.flag))
		st->l1.bcs->tx_cnt += skb->len + l2headersize(&st->l2, 0);
	skb_queue_tail(&st->l2.i_queue, skb);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 82 100.00% 3 100.00%
Total 82 100.00% 3 100.00%


static void

l2_got_iframe(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;
	struct Layer2 *l2 = &(st->l2);
	int PollFlag, ns, i;
	unsigned int nr;

	i = l2addrsize(l2);
	if (test_bit(FLG_MOD128, &l2->flag)) {
		PollFlag = ((skb->data[i + 1] & 0x1) == 0x1);
		ns = skb->data[i] >> 1;
		nr = (skb->data[i + 1] >> 1) & 0x7f;
	} else {
		PollFlag = (skb->data[i] & 0x10);
		ns = (skb->data[i] >> 1) & 0x7;
		nr = (skb->data[i] >> 5) & 0x7;
	}
	if (test_bit(FLG_OWN_BUSY, &l2->flag)) {
		dev_kfree_skb(skb);
		if (PollFlag) enquiry_response(st);
	} else if (l2->vr == ns) {
		(l2->vr)++;
		if (test_bit(FLG_MOD128, &l2->flag))
			l2->vr %= 128;
		else
			l2->vr %= 8;
		test_and_clear_bit(FLG_REJEXC, &l2->flag);

		if (PollFlag)
			enquiry_response(st);
		else
			test_and_set_bit(FLG_ACK_PEND, &l2->flag);
		skb_pull(skb, l2headersize(l2, 0));
		st->l2.l2l3(st, DL_DATA | INDICATION, skb);
	} else {
		/* n(s)!=v(r) */
		dev_kfree_skb(skb);
		if (test_and_set_bit(FLG_REJEXC, &l2->flag)) {
			if (PollFlag)
				enquiry_response(st);
		} else {
			enquiry_cr(st, REJ, RSP, PollFlag);
			test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
		}
	}

	if (legalnr(st, nr)) {
		if (!test_bit(FLG_PEER_BUSY, &st->l2.flag) && (fi->state == ST_L2_7)) {
			if (nr == st->l2.vs) {
				stop_t200(st, 13);
				FsmRestartTimer(&st->l2.t203, st->l2.T203,
						EV_L2_T203, NULL, 7);
			} else if (nr != st->l2.va)
				restart_t200(st, 14);
		}
		setva(st, nr);
	} else {
		nrerrorrecovery(fi);
		return;
	}

	if (!skb_queue_empty(&st->l2.i_queue) && (fi->state == ST_L2_7))
		st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
	if (test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag))
		enquiry_cr(st, RR, RSP, 0);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 511 96.96% 5 62.50%
andrew morton andrew morton 12 2.28% 1 12.50%
adrian bunk adrian bunk 2 0.38% 1 12.50%
david s. miller david s. miller 2 0.38% 1 12.50%
Total 527 100.00% 8 100.00%


static void

l2_got_tei(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	st->l2.tei = (long) arg;

	if (fi->state == ST_L2_3) {
		establishlink(fi);
		test_and_set_bit(FLG_L3_INIT, &st->l2.flag);
	} else
		FsmChangeState(fi, ST_L2_4);
	if (!skb_queue_empty(&st->l2.ui_queue))
		tx_ui(st);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 89 97.80% 3 75.00%
david s. miller david s. miller 2 2.20% 1 25.00%
Total 91 100.00% 4 100.00%


static void

l2_st5_tout_200(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	if (test_bit(FLG_LAPD, &st->l2.flag) &&
	    test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) {
		FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9);
	} else if (st->l2.rc == st->l2.N200) {
		FsmChangeState(fi, ST_L2_4);
		test_and_clear_bit(FLG_T200_RUN, &st->l2.flag);
		skb_queue_purge(&st->l2.i_queue);
		st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'G');
		if (test_bit(FLG_LAPB, &st->l2.flag))
			st->l2.l2l1(st, PH_DEACTIVATE | REQUEST, NULL);
		st5_dl_release_l2l3(st);
	} else {
		st->l2.rc++;
		FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9);
		send_uframe(st, (test_bit(FLG_MOD128, &st->l2.flag) ? SABME : SABM)
			    | 0x10, CMD);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 229 97.45% 5 71.43%
andrew morton andrew morton 5 2.13% 1 14.29%
linus torvalds linus torvalds 1 0.43% 1 14.29%
Total 235 100.00% 7 100.00%


static void

l2_st6_tout_200(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	if (test_bit(FLG_LAPD, &st->l2.flag) &&
	    test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) {
		FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9);
	} else if (st->l2.rc == st->l2.N200) {
		FsmChangeState(fi, ST_L2_4);
		test_and_clear_bit(FLG_T200_RUN, &st->l2.flag);
		st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'H');
		lapb_dl_release_l2l3(st, CONFIRM);
	} else {
		st->l2.rc++;
		FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200,
			    NULL, 9);
		send_uframe(st, DISC | 0x10, CMD);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 182 100.00% 4 100.00%
Total 182 100.00% 4 100.00%


static void

l2_st7_tout_200(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	if (test_bit(FLG_LAPD, &st->l2.flag) &&
	    test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) {
		FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9);
		return;
	}
	test_and_clear_bit(FLG_T200_RUN, &st->l2.flag);
	st->l2.rc = 0;
	FsmChangeState(fi, ST_L2_8);

	transmit_enquiry(st);
	st->l2.rc++;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 117 100.00% 4 100.00%
Total 117 100.00% 4 100.00%


static void

l2_st8_tout_200(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	if (test_bit(FLG_LAPD, &st->l2.flag) &&
	    test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) {
		FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9);
		return;
	}
	test_and_clear_bit(FLG_T200_RUN, &st->l2.flag);
	if (st->l2.rc == st->l2.N200) {
		st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'I');
		establishlink(fi);
		test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
	} else {
		transmit_enquiry(st);
		st->l2.rc++;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 157 100.00% 4 100.00%
Total 157 100.00% 4 100.00%


static void

l2_st7_tout_203(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	if (test_bit(FLG_LAPD, &st->l2.flag) &&
	    test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) {
		FsmAddTimer(&st->l2.t203, st->l2.T203, EV_L2_T203, NULL, 9);
		return;
	}
	FsmChangeState(fi, ST_L2_8);
	transmit_enquiry(st);
	st->l2.rc = 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 98 100.00% 3 100.00%
Total 98 100.00% 3 100.00%


static void

l2_pull_iqueue(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb, *nskb;
	struct Layer2 *l2 = &st->l2;
	u_char header[MAX_HEADER_LEN];
	int i, hdr_space_needed;
	int unsigned p1;
	u_long flags;

	if (!cansend(st))
		return;

	skb = skb_dequeue(&l2->i_queue);
	if (!skb)
		return;

	hdr_space_needed = l2headersize(l2, 0);
	nskb = skb_realloc_headroom(skb, hdr_space_needed);
	if (!nskb) {
		skb_queue_head(&l2->i_queue, skb);
		return;
	}
	spin_lock_irqsave(&l2->lock, flags);
	if (test_bit(FLG_MOD128, &l2->flag))
		p1 = (l2->vs - l2->va) % 128;
	else
		p1 = (l2->vs - l2->va) % 8;
	p1 = (p1 + l2->sow) % l2->window;
	if (l2->windowar[p1]) {
		printk(KERN_WARNING "isdnl2 try overwrite ack queue entry %d\n",
		       p1);
		dev_kfree_skb(l2->windowar[p1]);
	}
	l2->windowar[p1] = skb;

	i = sethdraddr(&st->l2, header, CMD);

	if (test_bit(FLG_MOD128, &l2->flag)) {
		header[i++] = l2->vs << 1;
		header[i++] = l2->vr << 1;
		l2->vs = (l2->vs + 1) % 128;
	} else {
		header[i++] = (l2->vr << 5) | (l2->vs << 1);
		l2->vs = (l2->vs + 1) % 8;
	}
	spin_unlock_irqrestore(&l2->lock, flags);
	memcpy(skb_push(nskb, i), header, i);
	st->l2.l2l1(st, PH_PULL | INDICATION, nskb);
	test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag);
	if (!test_and_set_bit(FLG_T200_RUN, &st->l2.flag)) {
		FsmDelTimer(&st->l2.t203, 13);
		FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 11);
	}
	if (!skb_queue_empty(&l2->i_queue) && cansend(st))
		st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 391 84.09% 5 41.67%
david s. miller david s. miller 31 6.67% 3 25.00%
andrew morton andrew morton 21 4.52% 1 8.33%
karsten keil karsten keil 15 3.23% 2 16.67%
kai germaschewski kai germaschewski 7 1.51% 1 8.33%
Total 465 100.00% 12 100.00%


static void

l2_st8_got_super(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;
	int PollFlag, rsp, rnr = 0;
	unsigned int nr;
	struct Layer2 *l2 = &st->l2;

	rsp = *skb->data & 0x2;
	if (test_bit(FLG_ORIG, &l2->flag))
		rsp = !rsp;

	skb_pull(skb, l2addrsize(l2));

	if (IsRNR(skb->data, st)) {
		set_peer_busy(l2);
		rnr = 1;
	} else
		clear_peer_busy(l2);

	if (test_bit(FLG_MOD128, &l2->flag)) {
		PollFlag = (skb->data[1] & 0x1) == 0x1;
		nr = skb->data[1] >> 1;
	} else {
		PollFlag = (skb->data[0] & 0x10);
		nr = (skb->data[0] >> 5) & 0x7;
	}
	dev_kfree_skb(skb);

	if (rsp && PollFlag) {
		if (legalnr(st, nr)) {
			if (rnr) {
				restart_t200(st, 15);
			} else {
				stop_t200(st, 16);
				FsmAddTimer(&l2->t203, l2->T203,
					    EV_L2_T203, NULL, 5);
				setva(st, nr);
			}
			invoke_retransmission(st, nr);
			FsmChangeState(fi, ST_L2_7);
			if (!skb_queue_empty(&l2->i_queue) && cansend(st))
				st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
		} else
			nrerrorrecovery(fi);
	} else {
		if (!rsp && PollFlag)
			enquiry_response(st);
		if (legalnr(st, nr)) {
			setva(st, nr);
		} else
			nrerrorrecovery(fi);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 346 97.74% 5 62.50%
andrew morton andrew morton 5 1.41% 1 12.50%
david s. miller david s. miller 2 0.56% 1 12.50%
adrian bunk adrian bunk 1 0.28% 1 12.50%
Total 354 100.00% 8 100.00%


static void

l2_got_FRMR(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;
	struct sk_buff *skb = arg;

	skb_pull(skb, l2addrsize(&st->l2) + 1);

	if (!(skb->data[0] & 1) || ((skb->data[0] & 3) == 1) ||		/* I or S */
	    (IsUA(skb->data) && (fi->state == ST_L2_7))) {
		st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'K');
		establishlink(fi);
		test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
	}
	dev_kfree_skb(skb);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 138 99.28% 3 75.00%
adrian bunk adrian bunk 1 0.72% 1 25.00%
Total 139 100.00% 4 100.00%


static void

l2_st24_tei_remove(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	skb_queue_purge(&st->l2.ui_queue);
	st->l2.tei = -1;
	FsmChangeState(fi, ST_L2_1);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 52 98.11% 2 66.67%
linus torvalds linus torvalds 1 1.89% 1 33.33%
Total 53 100.00% 3 100.00%


static void

l2_st3_tei_remove(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	skb_queue_purge(&st->l2.ui_queue);
	st->l2.tei = -1;
	st->l2.l2l3(st, DL_RELEASE | INDICATION, NULL);
	FsmChangeState(fi, ST_L2_1);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 62 91.18% 3 60.00%
andrew morton andrew morton 5 7.35% 1 20.00%
linus torvalds linus torvalds 1 1.47% 1 20.00%
Total 68 100.00% 5 100.00%


static void

l2_st5_tei_remove(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	skb_queue_purge(&st->l2.i_queue);
	skb_queue_purge(&st->l2.ui_queue);
	freewin(st);
	st->l2.tei = -1;
	stop_t200(st, 17);
	st5_dl_release_l2l3(st);
	FsmChangeState(fi, ST_L2_1);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 78 97.50% 2 66.67%
linus torvalds linus torvalds 2 2.50% 1 33.33%
Total 80 100.00% 3 100.00%


static void

l2_st6_tei_remove(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	skb_queue_purge(&st->l2.ui_queue);
	st->l2.tei = -1;
	stop_t200(st, 18);
	st->l2.l2l3(st, DL_RELEASE | CONFIRM, NULL);
	FsmChangeState(fi, ST_L2_1);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 69 92.00% 3 60.00%
andrew morton andrew morton 5 6.67% 1 20.00%
linus torvalds linus torvalds 1 1.33% 1 20.00%
Total 75 100.00% 5 100.00%


static void

l2_tei_remove(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	skb_queue_purge(&st->l2.i_queue);
	skb_queue_purge(&st->l2.ui_queue);
	freewin(st);
	st->l2.tei = -1;
	stop_t200(st, 17);
	FsmDelTimer(&st->l2.t203, 19);
	st->l2.l2l3(st, DL_RELEASE | INDICATION, NULL);
	FsmChangeState(fi, ST_L2_1);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 95 93.14% 3 60.00%
andrew morton andrew morton 5 4.90% 1 20.00%
linus torvalds linus torvalds 2 1.96% 1 20.00%
Total 102 100.00% 5 100.00%


static void

l2_st14_persistent_da(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	skb_queue_purge(&st->l2.i_queue);
	skb_queue_purge(&st->l2.ui_queue);
	if (test_and_clear_bit(FLG_ESTAB_PEND, &st->l2.flag))
		st->l2.l2l3(st, DL_RELEASE | INDICATION, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 68 89.47% 2 40.00%
andrew morton andrew morton 5 6.58% 1 20.00%
linus torvalds linus torvalds 2 2.63% 1 20.00%
jan engelhardt jan engelhardt 1 1.32% 1 20.00%
Total 76 100.00% 5 100.00%


static void

l2_st5_persistent_da(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	skb_queue_purge(&st->l2.i_queue);
	skb_queue_purge(&st->l2.ui_queue);
	freewin(st);
	stop_t200(st, 19);
	st5_dl_release_l2l3(st);
	FsmChangeState(fi, ST_L2_4);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 68 95.77% 3 60.00%
linus torvalds linus torvalds 2 2.82% 1 20.00%
jan engelhardt jan engelhardt 1 1.41% 1 20.00%
Total 71 100.00% 5 100.00%


static void

l2_st6_persistent_da(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	skb_queue_purge(&st->l2.ui_queue);
	stop_t200(st, 20);
	st->l2.l2l3(st, DL_RELEASE | CONFIRM, NULL);
	FsmChangeState(fi, ST_L2_4);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 59 89.39% 3 50.00%
andrew morton andrew morton 5 7.58% 1 16.67%
linus torvalds linus torvalds 1 1.52% 1 16.67%
jan engelhardt jan engelhardt 1 1.52% 1 16.67%
Total 66 100.00% 6 100.00%


static void

l2_persistent_da(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	skb_queue_purge(&st->l2.i_queue);
	skb_queue_purge(&st->l2.ui_queue);
	freewin(st);
	stop_t200(st, 19);
	FsmDelTimer(&st->l2.t203, 19);
	st->l2.l2l3(st, DL_RELEASE | INDICATION, NULL);
	FsmChangeState(fi, ST_L2_4);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 85 91.40% 3 50.00%
andrew morton andrew morton 5 5.38% 1 16.67%
linus torvalds linus torvalds 2 2.15% 1 16.67%
jan engelhardt jan engelhardt 1 1.08% 1 16.67%
Total 93 100.00% 6 100.00%


static void

l2_set_own_busy(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	if (!test_and_set_bit(FLG_OWN_BUSY, &st->l2.flag)) {
		enquiry_cr(st, RNR, RSP, 0);
		test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 67 100.00% 3 100.00%
Total 67 100.00% 3 100.00%


static void

l2_clear_own_busy(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	if (!test_and_clear_bit(FLG_OWN_BUSY, &st->l2.flag)) {
		enquiry_cr(st, RR, RSP, 0);
		test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 67 100.00% 3 100.00%
Total 67 100.00% 3 100.00%


static void

l2_frame_error(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	st->ma.layer(st, MDL_ERROR | INDICATION, arg);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 42 100.00% 3 100.00%
Total 42 100.00% 3 100.00%


static void

l2_frame_error_reest(struct FsmInst *fi, int event, void *arg)
{
	struct PStack *st = fi->userdata;

	st->ma.layer(st, MDL_ERROR | INDICATION, arg);
	establishlink(fi);
	test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 59 100.00% 3 100.00%
Total 59 100.00% 3 100.00%


static struct FsmNode L2FnList[] __initdata =
{
	{ST_L2_1, EV_L2_DL_ESTABLISH_REQ, l2_mdl_assign},
	{ST_L2_2, EV_L2_DL_ESTABLISH_REQ, l2_go_st3},
	{ST_L2_4, EV_L2_DL_ESTABLISH_REQ, l2_establish},
	{ST_L2_5, EV_L2_DL_ESTABLISH_REQ, l2_discard_i_setl3},
	{ST_L2_7, EV_L2_DL_ESTABLISH_REQ, l2_l3_reestablish},
	{ST_L2_8, EV_L2_DL_ESTABLISH_REQ, l2_l3_reestablish},
	{ST_L2_4, EV_L2_DL_RELEASE_REQ, l2_release},
	{ST_L2_5, EV_L2_DL_RELEASE_REQ, l2_pend_rel},
	{ST_L2_7, EV_L2_DL_RELEASE_REQ, l2_disconnect},
	{ST_L2_8, EV_L2_DL_RELEASE_REQ, l2_disconnect},
	{ST_L2_5, EV_L2_DL_DATA, l2_feed_i_if_reest},
	{ST_L2_7, EV_L2_DL_DATA, l2_feed_i_pull},
	{ST_L2_8, EV_L2_DL_DATA, l2_feed_iqueue},
	{ST_L2_1, EV_L2_DL_UNIT_DATA, l2_queue_ui_assign},
	{ST_L2_2, EV_L2_DL_UNIT_DATA, l2_queue_ui},
	{ST_L2_3, EV_L2_DL_UNIT_DATA, l2_queue_ui},
	{ST_L2_4, EV_L2_DL_UNIT_DATA, l2_send_ui},
	{ST_L2_5, EV_L2_DL_UNIT_DATA, l2_send_ui},
	{ST_L2_6, EV_L2_DL_UNIT_DATA, l2_send_ui},
	{ST_L2_7, EV_L2_DL_UNIT_DATA, l2_send_ui},
	{ST_L2_8, EV_L2_DL_UNIT_DATA, l2_send_ui},
	{ST_L2_1, EV_L2_MDL_ASSIGN, l2_got_tei},
	{ST_L2_2, EV_L2_MDL_ASSIGN, l2_got_tei},
	{ST_L2_3, EV_L2_MDL_ASSIGN, l2_got_tei},
	{ST_L2_2, EV_L2_MDL_ERROR, l2_st24_tei_remove},
	{ST_L2_3, EV_L2_MDL_ERROR, l2_st3_tei_remove},
	{ST_L2_4, EV_L2_MDL_REMOVE, l2_st24_tei_remove},
	{ST_L2_5, EV_L2_MDL_REMOVE, l2_st5_tei_remove},
	{ST_L2_6, EV_L2_MDL_REMOVE, l2_st6_tei_remove},
	{ST_L2_7, EV_L2_MDL_REMOVE, l2_tei_remove},
	{ST_L2_8, EV_L2_MDL_REMOVE, l2_tei_remove},
	{ST_L2_4, EV_L2_SABME, l2_start_multi},
	{ST_L2_5, EV_L2_SABME, l2_send_UA},
	{ST_L2_6, EV_L2_SABME, l2_send_DM},
	{ST_L2_7, EV_L2_SABME, l2_restart_multi},
	{ST_L2_8, EV_L2_SABME, l2_restart_multi},
	{ST_L2_4, EV_L2_DISC, l2_send_DM},
	{ST_L2_5, EV_L2_DISC, l2_send_DM},
	{ST_L2_6, EV_L2_DISC, l2_send_UA},
	{ST_L2_7, EV_L2_DISC, l2_stop_multi},
	{ST_L2_8, EV_L2_DISC, l2_stop_multi},
	{ST_L2_4, EV_L2_UA, l2_mdl_error_ua},
	{ST_L2_5, EV_L2_UA, l2_connected},
	{ST_L2_6, EV_L2_UA, l2_released},
	{ST_L2_7, EV_L2_UA, l2_mdl_error_ua},
	{ST_L2_8, EV_L2_UA, l2_mdl_error_ua},
	{ST_L2_4, EV_L2_DM, l2_reestablish},
	{ST_L2_5, EV_L2_DM, l2_st5_dm_release},
	{ST_L2_6, EV_L2_DM, l2_st6_dm_release},
	{ST_L2_7, EV_L2_DM, l2_mdl_error_dm},
	{ST_L2_8, EV_L2_DM, l2_st8_mdl_error_dm},
	{ST_L2_1, EV_L2_UI, l2_got_ui},
	{ST_L2_2, EV_L2_UI, l2_got_ui},
	{ST_L2_3, EV_L2_UI, l2_got_ui},
	{ST_L2_4, EV_L2_UI, l2_got_ui},
	{ST_L2_5, EV_L2_UI, l2_got_ui},
	{ST_L2_6, EV_L2_UI, l2_got_ui},
	{ST_L2_7, EV_L2_UI, l2_got_ui},
	{ST_L2_8, EV_L2_UI, l2_got_ui},
	{ST_L2_7, EV_L2_FRMR, l2_got_FRMR},
	{ST_L2_8, EV_L2_FRMR, l2_got_FRMR},
	{ST_L2_7, EV_L2_SUPER, l2_st7_got_super},
	{ST_L2_8, EV_L2_SUPER, l2_st8_got_super},
	{ST_L2_7, EV_L2_I, l2_got_iframe},
	{ST_L2_8, EV_L2_I, l2_got_iframe},
	{ST_L2_5, EV_L2_T200, l2_st5_tout_200},
	{ST_L2_6, EV_L2_T200, l2_st6_tout_200},
	{ST_L2_7, EV_L2_T200, l2_st7_tout_200},
	{ST_L2_8, EV_L2_T200, l2_st8_tout_200},
	{ST_L2_7, EV_L2_T203, l2_st7_tout_203},
	{ST_L2_7, EV_L2_ACK_PULL, l2_pull_iqueue},
	{ST_L2_7, EV_L2_SET_OWN_BUSY, l2_set_own_busy},
	{ST_L2_8, EV_L2_SET_OWN_BUSY, l2_set_own_busy},
	{ST_L2_7, EV_L2_CLEAR_OWN_BUSY, l2_clear_own_busy},
	{ST_L2_8, EV_L2_CLEAR_OWN_BUSY, l2_clear_own_busy},
	{ST_L2_4, EV_L2_FRAME_ERROR, l2_frame_error},
	{ST_L2_5, EV_L2_FRAME_ERROR, l2_frame_error},
	{ST_L2_6, EV_L2_FRAME_ERROR, l2_frame_error},
	{ST_L2_7, EV_L2_FRAME_ERROR, l2_frame_error_reest},
	{ST_L2_8, EV_L2_FRAME_ERROR, l2_frame_error_reest},
	{ST_L2_1, EV_L1_DEACTIVATE, l2_st14_persistent_da},
	{ST_L2_2, EV_L1_DEACTIVATE, l2_st24_tei_remove},
	{ST_L2_3, EV_L1_DEACTIVATE, l2_st3_tei_remove},
	{ST_L2_4, EV_L1_DEACTIVATE, l2_st14_persistent_da},
	{ST_L2_5, EV_L1_DEACTIVATE, l2_st5_persistent_da},
	{ST_L2_6, EV_L1_DEACTIVATE, l2_st6_persistent_da},
	{ST_L2_7, EV_L1_DEACTIVATE, l2_persistent_da},
	{ST_L2_8, EV_L1_DEACTIVATE, l2_persistent_da},
};


static void

isdnl2_l1l2(struct PStack *st, int pr, void *arg)
{
	struct sk_buff *skb = arg;
	u_char *datap;
	int ret = 1, len;
	int c = 0;

	switch (pr) {
	case (PH_DATA | INDICATION):
		datap = skb->data;
		len = l2addrsize(&st->l2);
		if (skb->len > len)
			datap += len;
		else {
			FsmEvent(&st->l2.l2m, EV_L2_FRAME_ERROR, (void *) 'N');
			dev_kfree_skb(skb);
			return;
		}
		if (!(*datap & 1)) {	/* I-Frame */
			if (!(c = iframe_error(st, skb)))
				ret = FsmEvent(&st->l2.l2m, EV_L2_I, skb);
		} else if (IsSFrame(datap, st)) {	/* S-Frame */
			if (!(c = super_error(st, skb)))
				ret = FsmEvent(&st->l2.l2m, EV_L2_SUPER, skb);
		} else if (IsUI(datap)) {
			if (!(c = UI_error(st, skb)))
				ret = FsmEvent(&st->l2.l2m, EV_L2_UI, skb);
		} else if (IsSABME(datap, st)) {
			if (!(c = unnum_error(st, skb, CMD)))
				ret = FsmEvent(&st->l2.l2m, EV_L2_SABME, skb);
		} else if (IsUA(datap)) {
			if (!(c = unnum_error(st, skb, RSP)))
				ret = FsmEvent(&st->l2.l2m, EV_L2_UA, skb);
		} else if (IsDISC(datap)) {
			if (!(c = unnum_error(st, skb, CMD)))
				ret = FsmEvent(&st->l2.l2m, EV_L2_DISC, skb);
		} else if (IsDM(datap)) {
			if (!(c = unnum_error(st, skb, RSP)))
				ret = FsmEvent(&st->l2.l2m, EV_L2_DM, skb);
		} else if (IsFRMR(datap)) {
			if (!(c = FRMR_error(st, skb)))
				ret = FsmEvent(&st->l2.l2m, EV_L2_FRMR, skb);
		} else {
			FsmEvent(&st->l2.l2m, EV_L2_FRAME_ERROR, (void *) 'L');
			dev_kfree_skb(skb);
			ret = 0;
		}
		if (c) {
			dev_kfree_skb(skb);
			FsmEvent(&st->l2.l2m, EV_L2_FRAME_ERROR, (void *)(long)c);
			ret = 0;
		}
		if (ret)
			dev_kfree_skb(skb);
		break;
	case (PH_PULL | CONFIRM):
		FsmEvent(&st->l2.l2m, EV_L2_ACK_PULL, arg);
		break;
	case (PH_PAUSE | INDICATION):
		test_and_set_bit(FLG_DCHAN_BUSY, &st->l2.flag);
		break;
	case (PH_PAUSE | CONFIRM):
		test_and_clear_bit(FLG_DCHAN_BUSY, &st->l2.flag);
		break;
	case (PH_ACTIVATE | CONFIRM):
	case (PH_ACTIVATE | INDICATION):
		test_and_set_bit(FLG_L1_ACTIV, &st->l2.flag);
		if (test_and_clear_bit(FLG_ESTAB_PEND, &st->l2.flag))
			FsmEvent(&st->l2.l2m, EV_L2_DL_ESTABLISH_REQ, arg);
		break;
	case (PH_DEACTIVATE | INDICATION):
	case (PH_DEACTIVATE | CONFIRM):
		test_and_clear_bit(FLG_L1_ACTIV, &st->l2.flag);
		FsmEvent(&st->l2.l2m, EV_L1_DEACTIVATE, arg);
		break;
	default:
		l2m_debug(&st->l2.l2m, "l2 unknown pr %04x", pr);
		break;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 689 99.14% 6 75.00%
adrian bunk adrian bunk 4 0.58% 1 12.50%
andrew morton andrew morton 2 0.29% 1 12.50%
Total 695 100.00% 8 100.00%


static void

isdnl2_l3l2(struct PStack *st, int pr, void *arg)
{
	switch (pr) {
	case (DL_DATA | REQUEST):
		if (FsmEvent(&st->l2.l2m, EV_L2_DL_DATA, arg)) {
			dev_kfree_skb((struct sk_buff *) arg);
		}
		break;
	case (DL_UNIT_DATA | REQUEST):
		if (FsmEvent(&st->l2.l2m, EV_L2_DL_UNIT_DATA, arg)) {
			dev_kfree_skb((struct sk_buff *) arg);
		}
		break;
	case (DL_ESTABLISH | REQUEST):
		if (test_bit(FLG_L1_ACTIV, &st->l2.flag)) {
			if (test_bit(FLG_LAPD, &st->l2.flag) ||
			    test_bit(FLG_ORIG, &st->l2.flag)) {
				FsmEvent(&st->l2.l2m, EV_L2_DL_ESTABLISH_REQ, arg);
			}
		} else {
			if (test_bit(FLG_LAPD, &st->l2.flag) ||
			    test_bit(FLG_ORIG, &st->l2.flag)) {
				test_and_set_bit(FLG_ESTAB_PEND, &st->l2.flag);
			}
			st->l2.l2l1(st, PH_ACTIVATE, NULL);
		}
		break;
	case (DL_RELEASE | REQUEST):
		if (test_bit(FLG_LAPB, &st->l2.flag)) {
			st->l2.l2l1(st, PH_DEACTIVATE, NULL);
		}
		FsmEvent(&st->l2.l2m, EV_L2_DL_RELEASE_REQ, arg);
		break;
	case (MDL_ASSIGN | REQUEST):
		FsmEvent(&st->l2.l2m, EV_L2_MDL_ASSIGN, arg);
		break;
	case (MDL_REMOVE | REQUEST):
		FsmEvent(&st->l2.l2m, EV_L2_MDL_REMOVE, arg);
		break;
	case (MDL_ERROR | RESPONSE):
		FsmEvent(&st->l2.l2m, EV_L2_MDL_ERROR, arg);
		break;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 325 97.01% 5 83.33%
andrew morton andrew morton 10 2.99% 1 16.67%
Total 335 100.00% 6 100.00%


void

releasestack_isdnl2(struct PStack *st)
{
	FsmDelTimer(&st->l2.t200, 21);
	FsmDelTimer(&st->l2.t203, 16);
	skb_queue_purge(&st->l2.i_queue);
	skb_queue_purge(&st->l2.ui_queue);
	ReleaseWin(&st->l2);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 60 96.77% 5 83.33%
linus torvalds linus torvalds 2 3.23% 1 16.67%
Total 62 100.00% 6 100.00%


static void

l2m_debug(struct FsmInst *fi, char *fmt, ...)
{
	va_list args;
	struct PStack *st = fi->userdata;

	va_start(args, fmt);
	VHiSax_putstatus(st->l1.hardware, st->l2.debug_id, fmt, args);
	va_end(args);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 60 100.00% 2 100.00%
Total 60 100.00% 2 100.00%


void

setstack_isdnl2(struct PStack *st, char *debug_id)
{
	spin_lock_init(&st->l2.lock);
	st->l1.l1l2 = isdnl2_l1l2;
	st->l3.l3l2 = isdnl2_l3l2;

	skb_queue_head_init(&st->l2.i_queue);
	skb_queue_head_init(&st->l2.ui_queue);
	InitWin(&st->l2);
	st->l2.debug = 0;

	st->l2.l2m.fsm = &l2fsm;
	if (test_bit(FLG_LAPB, &st->l2.flag))
		st->l2.l2m.state = ST_L2_4;
	else
		st->l2.l2m.state = ST_L2_1;
	st->l2.l2m.debug = 0;
	st->l2.l2m.userdata = st;
	st->l2.l2m.userint = 0;
	st->l2.l2m.printdebug = l2m_debug;
	strcpy(st->l2.debug_id, debug_id);

	FsmInitTimer(&st->l2.l2m, &st->l2.t200);
	FsmInitTimer(&st->l2.l2m, &st->l2.t203);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 195 94.20% 4 66.67%
andrew morton andrew morton 11 5.31% 1 16.67%
linus torvalds linus torvalds 1 0.48% 1 16.67%
Total 207 100.00% 6 100.00%


static void

transl2_l3l2(struct PStack *st, int pr, void *arg)
{
	switch (pr) {
	case (DL_DATA | REQUEST):
	case (DL_UNIT_DATA | REQUEST):
		st->l2.l2l1(st, PH_DATA | REQUEST, arg);
		break;
	case (DL_ESTABLISH | REQUEST):
		st->l2.l2l1(st, PH_ACTIVATE | REQUEST, NULL);
		break;
	case (DL_RELEASE | REQUEST):
		st->l2.l2l1(st, PH_DEACTIVATE | REQUEST, NULL);
		break;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 85 85.00% 1 50.00%
andrew morton andrew morton 15 15.00% 1 50.00%
Total 100 100.00% 2 100.00%


void

setstack_transl2(struct PStack *st)
{
	st->l3.l3l2 = transl2_l3l2;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 17 94.44% 2 66.67%
andrew morton andrew morton 1 5.56% 1 33.33%
Total 18 100.00% 3 100.00%


void

releasestack_transl2(struct PStack *st)
{
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 9 100.00% 1 100.00%
Total 9 100.00% 1 100.00%


int __init

Isdnl2New(void)
{
	l2fsm.state_count = L2_STATE_COUNT;
	l2fsm.event_count = L2_EVENT_COUNT;
	l2fsm.strEvent = strL2Event;
	l2fsm.strState = strL2State;
	return FsmNew(&l2fsm, L2FnList, ARRAY_SIZE(L2FnList));
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 39 84.78% 2 50.00%
karsten keil karsten keil 4 8.70% 1 25.00%
linus torvalds linus torvalds 3 6.52% 1 25.00%
Total 46 100.00% 4 100.00%


void

Isdnl2Free(void)
{
	FsmFree(&l2fsm);
}
Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 13 100.00% 1 100.00%
Total 13 100.00% 1 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 11114 95.55% 10 35.71%
andrew morton andrew morton 356 3.06% 2 7.14%
david s. miller david s. miller 47 0.40% 3 10.71%
adrian bunk adrian bunk 41 0.35% 1 3.57%
linus torvalds linus torvalds 28 0.24% 3 10.71%
karsten keil karsten keil 19 0.16% 3 10.71%
jan engelhardt jan engelhardt 10 0.09% 1 3.57%
kai germaschewski kai germaschewski 9 0.08% 2 7.14%
joe perches joe perches 3 0.03% 1 3.57%
tejun heo tejun heo 3 0.03% 1 3.57%
jesper juhl jesper juhl 1 0.01% 1 3.57%
Total 11631 100.00% 28 100.00%
  Directory: drivers/isdn/hisax

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
pre-git	pre-git	47	92.16%	3	75.00%
david s. miller	david s. miller	4	7.84%	1	25.00%
	Total	51	100.00%	4	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/isdn/hisax/isdnl2.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors
