cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

ctcm_mpc.c (58738B)


      1// SPDX-License-Identifier: GPL-2.0
      2/*
      3 *	Copyright IBM Corp. 2004, 2007
      4 *	Authors:	Belinda Thompson (belindat@us.ibm.com)
      5 *			Andy Richter (richtera@us.ibm.com)
      6 *			Peter Tiedemann (ptiedem@de.ibm.com)
      7 */
      8
      9/*
     10	This module exports functions to be used by CCS:
     11	EXPORT_SYMBOL(ctc_mpc_alloc_channel);
     12	EXPORT_SYMBOL(ctc_mpc_establish_connectivity);
     13	EXPORT_SYMBOL(ctc_mpc_dealloc_ch);
     14	EXPORT_SYMBOL(ctc_mpc_flow_control);
     15*/
     16
     17#undef DEBUG
     18#undef DEBUGDATA
     19#undef DEBUGCCW
     20
     21#define KMSG_COMPONENT "ctcm"
     22#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
     23
     24#include <linux/module.h>
     25#include <linux/init.h>
     26#include <linux/kernel.h>
     27#include <linux/slab.h>
     28#include <linux/errno.h>
     29#include <linux/types.h>
     30#include <linux/interrupt.h>
     31#include <linux/timer.h>
     32#include <linux/sched.h>
     33
     34#include <linux/signal.h>
     35#include <linux/string.h>
     36#include <linux/proc_fs.h>
     37
     38#include <linux/ip.h>
     39#include <linux/if_arp.h>
     40#include <linux/tcp.h>
     41#include <linux/skbuff.h>
     42#include <linux/ctype.h>
     43#include <linux/netdevice.h>
     44#include <net/dst.h>
     45
     46#include <linux/io.h>		/* instead of <asm/io.h> ok ? */
     47#include <asm/ccwdev.h>
     48#include <asm/ccwgroup.h>
     49#include <linux/bitops.h>	/* instead of <asm/bitops.h> ok ? */
     50#include <linux/uaccess.h>	/* instead of <asm/uaccess.h> ok ? */
     51#include <linux/wait.h>
     52#include <linux/moduleparam.h>
     53#include <asm/idals.h>
     54
     55#include "ctcm_main.h"
     56#include "ctcm_mpc.h"
     57#include "ctcm_fsms.h"
     58
     59static const struct xid2 init_xid = {
     60	.xid2_type_id	=	XID_FM2,
     61	.xid2_len	=	0x45,
     62	.xid2_adj_id	=	0,
     63	.xid2_rlen	=	0x31,
     64	.xid2_resv1	=	0,
     65	.xid2_flag1	=	0,
     66	.xid2_fmtt	=	0,
     67	.xid2_flag4	=	0x80,
     68	.xid2_resv2	=	0,
     69	.xid2_tgnum	=	0,
     70	.xid2_sender_id	=	0,
     71	.xid2_flag2	=	0,
     72	.xid2_option	=	XID2_0,
     73	.xid2_resv3	=	"\x00",
     74	.xid2_resv4	=	0,
     75	.xid2_dlc_type	=	XID2_READ_SIDE,
     76	.xid2_resv5	=	0,
     77	.xid2_mpc_flag	=	0,
     78	.xid2_resv6	=	0,
     79	.xid2_buf_len	=	(MPC_BUFSIZE_DEFAULT - 35),
     80};
     81
     82static const struct th_header thnorm = {
     83	.th_seg		=	0x00,
     84	.th_ch_flag	=	TH_IS_XID,
     85	.th_blk_flag	=	TH_DATA_IS_XID,
     86	.th_is_xid	=	0x01,
     87	.th_seq_num	=	0x00000000,
     88};
     89
     90static const struct th_header thdummy = {
     91	.th_seg		=	0x00,
     92	.th_ch_flag	=	0x00,
     93	.th_blk_flag	=	TH_DATA_IS_XID,
     94	.th_is_xid	=	0x01,
     95	.th_seq_num	=	0x00000000,
     96};
     97
     98/*
     99 * Definition of one MPC group
    100 */
    101
    102/*
    103 * Compatibility macros for busy handling
    104 * of network devices.
    105 */
    106
    107static void ctcmpc_unpack_skb(struct channel *ch, struct sk_buff *pskb);
    108
    109/*
    110 * MPC Group state machine actions (static prototypes)
    111 */
    112static void mpc_action_nop(fsm_instance *fsm, int event, void *arg);
    113static void mpc_action_go_ready(fsm_instance *fsm, int event, void *arg);
    114static void mpc_action_go_inop(fsm_instance *fi, int event, void *arg);
    115static void mpc_action_timeout(fsm_instance *fi, int event, void *arg);
    116static int  mpc_validate_xid(struct mpcg_info *mpcginfo);
    117static void mpc_action_yside_xid(fsm_instance *fsm, int event, void *arg);
    118static void mpc_action_doxid0(fsm_instance *fsm, int event, void *arg);
    119static void mpc_action_doxid7(fsm_instance *fsm, int event, void *arg);
    120static void mpc_action_xside_xid(fsm_instance *fsm, int event, void *arg);
    121static void mpc_action_rcvd_xid0(fsm_instance *fsm, int event, void *arg);
    122static void mpc_action_rcvd_xid7(fsm_instance *fsm, int event, void *arg);
    123
    124#ifdef DEBUGDATA
    125/*-------------------------------------------------------------------*
    126* Dump buffer format						     *
    127*								     *
    128*--------------------------------------------------------------------*/
    129void ctcmpc_dumpit(char *buf, int len)
    130{
    131	__u32	ct, sw, rm, dup;
    132	char	*ptr, *rptr;
    133	char	tbuf[82], tdup[82];
    134	char	addr[22];
    135	char	boff[12];
    136	char	bhex[82], duphex[82];
    137	char	basc[40];
    138
    139	sw  = 0;
    140	rptr = ptr = buf;
    141	rm  = 16;
    142	duphex[0] = 0x00;
    143	dup = 0;
    144
    145	for (ct = 0; ct < len; ct++, ptr++, rptr++) {
    146		if (sw == 0) {
    147			sprintf(addr, "%16.16llx", (__u64)rptr);
    148
    149			sprintf(boff, "%4.4X", (__u32)ct);
    150			bhex[0] = '\0';
    151			basc[0] = '\0';
    152		}
    153		if ((sw == 4) || (sw == 12))
    154			strcat(bhex, " ");
    155		if (sw == 8)
    156			strcat(bhex, "	");
    157
    158		sprintf(tbuf, "%2.2llX", (__u64)*ptr);
    159
    160		tbuf[2] = '\0';
    161		strcat(bhex, tbuf);
    162		if ((0 != isprint(*ptr)) && (*ptr >= 0x20))
    163			basc[sw] = *ptr;
    164		else
    165			basc[sw] = '.';
    166
    167		basc[sw+1] = '\0';
    168		sw++;
    169		rm--;
    170		if (sw != 16)
    171			continue;
    172		if ((strcmp(duphex, bhex)) != 0) {
    173			if (dup != 0) {
    174				sprintf(tdup,
    175					"Duplicate as above to %s", addr);
    176				ctcm_pr_debug("		       --- %s ---\n",
    177						tdup);
    178			}
    179			ctcm_pr_debug("   %s (+%s) : %s  [%s]\n",
    180					addr, boff, bhex, basc);
    181			dup = 0;
    182			strcpy(duphex, bhex);
    183		} else
    184			dup++;
    185
    186		sw = 0;
    187		rm = 16;
    188	}  /* endfor */
    189
    190	if (sw != 0) {
    191		for ( ; rm > 0; rm--, sw++) {
    192			if ((sw == 4) || (sw == 12))
    193				strcat(bhex, " ");
    194			if (sw == 8)
    195				strcat(bhex, "	");
    196			strcat(bhex, "	");
    197			strcat(basc, " ");
    198		}
    199		if (dup != 0) {
    200			sprintf(tdup, "Duplicate as above to %s", addr);
    201			ctcm_pr_debug("		       --- %s ---\n", tdup);
    202		}
    203		ctcm_pr_debug("   %s (+%s) : %s  [%s]\n",
    204					addr, boff, bhex, basc);
    205	} else {
    206		if (dup >= 1) {
    207			sprintf(tdup, "Duplicate as above to %s", addr);
    208			ctcm_pr_debug("		       --- %s ---\n", tdup);
    209		}
    210		if (dup != 0) {
    211			ctcm_pr_debug("   %s (+%s) : %s  [%s]\n",
    212				addr, boff, bhex, basc);
    213		}
    214	}
    215
    216	return;
    217
    218}   /*	 end of ctcmpc_dumpit  */
    219#endif
    220
    221#ifdef DEBUGDATA
    222/*
    223 * Dump header and first 16 bytes of an sk_buff for debugging purposes.
    224 *
    225 * skb		The sk_buff to dump.
    226 * offset	Offset relative to skb-data, where to start the dump.
    227 */
    228void ctcmpc_dump_skb(struct sk_buff *skb, int offset)
    229{
    230	__u8 *p = skb->data;
    231	struct th_header *header;
    232	struct pdu *pheader;
    233	int bl = skb->len;
    234	int i;
    235
    236	if (p == NULL)
    237		return;
    238
    239	p += offset;
    240	header = (struct th_header *)p;
    241
    242	ctcm_pr_debug("dump:\n");
    243	ctcm_pr_debug("skb len=%d \n", skb->len);
    244	if (skb->len > 2) {
    245		switch (header->th_ch_flag) {
    246		case TH_HAS_PDU:
    247			break;
    248		case 0x00:
    249		case TH_IS_XID:
    250			if ((header->th_blk_flag == TH_DATA_IS_XID) &&
    251			   (header->th_is_xid == 0x01))
    252				goto dumpth;
    253		case TH_SWEEP_REQ:
    254				goto dumpth;
    255		case TH_SWEEP_RESP:
    256				goto dumpth;
    257		default:
    258			break;
    259		}
    260
    261		pheader = (struct pdu *)p;
    262		ctcm_pr_debug("pdu->offset: %d hex: %04x\n",
    263			       pheader->pdu_offset, pheader->pdu_offset);
    264		ctcm_pr_debug("pdu->flag  : %02x\n", pheader->pdu_flag);
    265		ctcm_pr_debug("pdu->proto : %02x\n", pheader->pdu_proto);
    266		ctcm_pr_debug("pdu->seq   : %02x\n", pheader->pdu_seq);
    267					goto dumpdata;
    268
    269dumpth:
    270		ctcm_pr_debug("th->seg     : %02x\n", header->th_seg);
    271		ctcm_pr_debug("th->ch      : %02x\n", header->th_ch_flag);
    272		ctcm_pr_debug("th->blk_flag: %02x\n", header->th_blk_flag);
    273		ctcm_pr_debug("th->type    : %s\n",
    274			       (header->th_is_xid) ? "DATA" : "XID");
    275		ctcm_pr_debug("th->seqnum  : %04x\n", header->th_seq_num);
    276
    277	}
    278dumpdata:
    279	if (bl > 32)
    280		bl = 32;
    281	ctcm_pr_debug("data: ");
    282	for (i = 0; i < bl; i++)
    283		ctcm_pr_debug("%02x%s", *p++, (i % 16) ? " " : "\n");
    284	ctcm_pr_debug("\n");
    285}
    286#endif
    287
    288static struct net_device *ctcmpc_get_dev(int port_num)
    289{
    290	char device[20];
    291	struct net_device *dev;
    292	struct ctcm_priv *priv;
    293
    294	sprintf(device, "%s%i", MPC_DEVICE_NAME, port_num);
    295
    296	dev = __dev_get_by_name(&init_net, device);
    297
    298	if (dev == NULL) {
    299		CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
    300			"%s: Device not found by name: %s",
    301					CTCM_FUNTAIL, device);
    302		return NULL;
    303	}
    304	priv = dev->ml_priv;
    305	if (priv == NULL) {
    306		CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
    307			"%s(%s): dev->ml_priv is NULL",
    308					CTCM_FUNTAIL, device);
    309		return NULL;
    310	}
    311	if (priv->mpcg == NULL) {
    312		CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
    313			"%s(%s): priv->mpcg is NULL",
    314					CTCM_FUNTAIL, device);
    315		return NULL;
    316	}
    317	return dev;
    318}
    319
    320/*
    321 * ctc_mpc_alloc_channel
    322 *	(exported interface)
    323 *
    324 * Device Initialization :
    325 *	ACTPATH  driven IO operations
    326 */
    327int ctc_mpc_alloc_channel(int port_num, void (*callback)(int, int))
    328{
    329	struct net_device *dev;
    330	struct mpc_group *grp;
    331	struct ctcm_priv *priv;
    332
    333	dev = ctcmpc_get_dev(port_num);
    334	if (dev == NULL)
    335		return 1;
    336	priv = dev->ml_priv;
    337	grp = priv->mpcg;
    338
    339	grp->allochanfunc = callback;
    340	grp->port_num = port_num;
    341	grp->port_persist = 1;
    342
    343	CTCM_DBF_TEXT_(MPC_SETUP, CTC_DBF_INFO,
    344			"%s(%s): state=%s",
    345			CTCM_FUNTAIL, dev->name, fsm_getstate_str(grp->fsm));
    346
    347	switch (fsm_getstate(grp->fsm)) {
    348	case MPCG_STATE_INOP:
    349		/* Group is in the process of terminating */
    350		grp->alloc_called = 1;
    351		break;
    352	case MPCG_STATE_RESET:
    353		/* MPC Group will transition to state		  */
    354		/* MPCG_STATE_XID2INITW iff the minimum number	  */
    355		/* of 1 read and 1 write channel have successfully*/
    356		/* activated					  */
    357		/*fsm_newstate(grp->fsm, MPCG_STATE_XID2INITW);*/
    358		if (callback)
    359			grp->send_qllc_disc = 1;
    360		fallthrough;
    361	case MPCG_STATE_XID0IOWAIT:
    362		fsm_deltimer(&grp->timer);
    363		grp->outstanding_xid2 = 0;
    364		grp->outstanding_xid7 = 0;
    365		grp->outstanding_xid7_p2 = 0;
    366		grp->saved_xid2 = NULL;
    367		if (callback)
    368			ctcm_open(dev);
    369		fsm_event(priv->fsm, DEV_EVENT_START, dev);
    370		break;
    371	case MPCG_STATE_READY:
    372		/* XID exchanges completed after PORT was activated */
    373		/* Link station already active			    */
    374		/* Maybe timing issue...retry callback		    */
    375		grp->allocchan_callback_retries++;
    376		if (grp->allocchan_callback_retries < 4) {
    377			if (grp->allochanfunc)
    378				grp->allochanfunc(grp->port_num,
    379						  grp->group_max_buflen);
    380		} else {
    381			/* there are problems...bail out	    */
    382			/* there may be a state mismatch so restart */
    383			fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
    384			grp->allocchan_callback_retries = 0;
    385		}
    386		break;
    387	}
    388
    389	return 0;
    390}
    391EXPORT_SYMBOL(ctc_mpc_alloc_channel);
    392
    393/*
    394 * ctc_mpc_establish_connectivity
    395 *	(exported interface)
    396 */
    397void ctc_mpc_establish_connectivity(int port_num,
    398				void (*callback)(int, int, int))
    399{
    400	struct net_device *dev;
    401	struct mpc_group *grp;
    402	struct ctcm_priv *priv;
    403	struct channel *rch, *wch;
    404
    405	dev = ctcmpc_get_dev(port_num);
    406	if (dev == NULL)
    407		return;
    408	priv = dev->ml_priv;
    409	grp = priv->mpcg;
    410	rch = priv->channel[CTCM_READ];
    411	wch = priv->channel[CTCM_WRITE];
    412
    413	CTCM_DBF_TEXT_(MPC_SETUP, CTC_DBF_INFO,
    414			"%s(%s): state=%s",
    415			CTCM_FUNTAIL, dev->name, fsm_getstate_str(grp->fsm));
    416
    417	grp->estconnfunc = callback;
    418	grp->port_num = port_num;
    419
    420	switch (fsm_getstate(grp->fsm)) {
    421	case MPCG_STATE_READY:
    422		/* XID exchanges completed after PORT was activated */
    423		/* Link station already active			    */
    424		/* Maybe timing issue...retry callback		    */
    425		fsm_deltimer(&grp->timer);
    426		grp->estconn_callback_retries++;
    427		if (grp->estconn_callback_retries < 4) {
    428			if (grp->estconnfunc) {
    429				grp->estconnfunc(grp->port_num, 0,
    430						grp->group_max_buflen);
    431				grp->estconnfunc = NULL;
    432			}
    433		} else {
    434			/* there are problems...bail out	 */
    435			fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
    436			grp->estconn_callback_retries = 0;
    437		}
    438		break;
    439	case MPCG_STATE_INOP:
    440	case MPCG_STATE_RESET:
    441		/* MPC Group is not ready to start XID - min num of */
    442		/* 1 read and 1 write channel have not been acquired*/
    443
    444		CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
    445			"%s(%s): REJECTED - inactive channels",
    446					CTCM_FUNTAIL, dev->name);
    447		if (grp->estconnfunc) {
    448			grp->estconnfunc(grp->port_num, -1, 0);
    449			grp->estconnfunc = NULL;
    450		}
    451		break;
    452	case MPCG_STATE_XID2INITW:
    453		/* alloc channel was called but no XID exchange    */
    454		/* has occurred. initiate xside XID exchange	   */
    455		/* make sure yside XID0 processing has not started */
    456
    457		if ((fsm_getstate(rch->fsm) > CH_XID0_PENDING) ||
    458			(fsm_getstate(wch->fsm) > CH_XID0_PENDING)) {
    459			CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
    460				"%s(%s): ABORT - PASSIVE XID",
    461					CTCM_FUNTAIL, dev->name);
    462			break;
    463		}
    464		grp->send_qllc_disc = 1;
    465		fsm_newstate(grp->fsm, MPCG_STATE_XID0IOWAIT);
    466		fsm_deltimer(&grp->timer);
    467		fsm_addtimer(&grp->timer, MPC_XID_TIMEOUT_VALUE,
    468						MPCG_EVENT_TIMER, dev);
    469		grp->outstanding_xid7 = 0;
    470		grp->outstanding_xid7_p2 = 0;
    471		grp->saved_xid2 = NULL;
    472		if ((rch->in_mpcgroup) &&
    473				(fsm_getstate(rch->fsm) == CH_XID0_PENDING))
    474			fsm_event(grp->fsm, MPCG_EVENT_XID0DO, rch);
    475		else {
    476			CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
    477				"%s(%s): RX-%s not ready for ACTIVE XID0",
    478					CTCM_FUNTAIL, dev->name, rch->id);
    479			if (grp->estconnfunc) {
    480				grp->estconnfunc(grp->port_num, -1, 0);
    481				grp->estconnfunc = NULL;
    482			}
    483			fsm_deltimer(&grp->timer);
    484				goto done;
    485		}
    486		if ((wch->in_mpcgroup) &&
    487				(fsm_getstate(wch->fsm) == CH_XID0_PENDING))
    488			fsm_event(grp->fsm, MPCG_EVENT_XID0DO, wch);
    489		else {
    490			CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
    491				"%s(%s): WX-%s not ready for ACTIVE XID0",
    492					CTCM_FUNTAIL, dev->name, wch->id);
    493			if (grp->estconnfunc) {
    494				grp->estconnfunc(grp->port_num, -1, 0);
    495				grp->estconnfunc = NULL;
    496			}
    497			fsm_deltimer(&grp->timer);
    498				goto done;
    499			}
    500		break;
    501	case MPCG_STATE_XID0IOWAIT:
    502		/* already in active XID negotiations */
    503	default:
    504		break;
    505	}
    506
    507done:
    508	CTCM_PR_DEBUG("Exit %s()\n", __func__);
    509	return;
    510}
    511EXPORT_SYMBOL(ctc_mpc_establish_connectivity);
    512
    513/*
    514 * ctc_mpc_dealloc_ch
    515 *	(exported interface)
    516 */
    517void ctc_mpc_dealloc_ch(int port_num)
    518{
    519	struct net_device *dev;
    520	struct ctcm_priv *priv;
    521	struct mpc_group *grp;
    522
    523	dev = ctcmpc_get_dev(port_num);
    524	if (dev == NULL)
    525		return;
    526	priv = dev->ml_priv;
    527	grp = priv->mpcg;
    528
    529	CTCM_DBF_TEXT_(MPC_SETUP, CTC_DBF_DEBUG,
    530			"%s: %s: refcount = %d\n",
    531			CTCM_FUNTAIL, dev->name, netdev_refcnt_read(dev));
    532
    533	fsm_deltimer(&priv->restart_timer);
    534	grp->channels_terminating = 0;
    535	fsm_deltimer(&grp->timer);
    536	grp->allochanfunc = NULL;
    537	grp->estconnfunc = NULL;
    538	grp->port_persist = 0;
    539	grp->send_qllc_disc = 0;
    540	fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
    541
    542	ctcm_close(dev);
    543	return;
    544}
    545EXPORT_SYMBOL(ctc_mpc_dealloc_ch);
    546
    547/*
    548 * ctc_mpc_flow_control
    549 *	(exported interface)
    550 */
    551void ctc_mpc_flow_control(int port_num, int flowc)
    552{
    553	struct ctcm_priv *priv;
    554	struct mpc_group *grp;
    555	struct net_device *dev;
    556	struct channel *rch;
    557	int mpcg_state;
    558
    559	dev = ctcmpc_get_dev(port_num);
    560	if (dev == NULL)
    561		return;
    562	priv = dev->ml_priv;
    563	grp = priv->mpcg;
    564
    565	CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_DEBUG,
    566			"%s: %s: flowc = %d",
    567				CTCM_FUNTAIL, dev->name, flowc);
    568
    569	rch = priv->channel[CTCM_READ];
    570
    571	mpcg_state = fsm_getstate(grp->fsm);
    572	switch (flowc) {
    573	case 1:
    574		if (mpcg_state == MPCG_STATE_FLOWC)
    575			break;
    576		if (mpcg_state == MPCG_STATE_READY) {
    577			if (grp->flow_off_called == 1)
    578				grp->flow_off_called = 0;
    579			else
    580				fsm_newstate(grp->fsm, MPCG_STATE_FLOWC);
    581			break;
    582		}
    583		break;
    584	case 0:
    585		if (mpcg_state == MPCG_STATE_FLOWC) {
    586			fsm_newstate(grp->fsm, MPCG_STATE_READY);
    587			/* ensure any data that has accumulated */
    588			/* on the io_queue will now be sen t	*/
    589			tasklet_schedule(&rch->ch_tasklet);
    590		}
    591		/* possible race condition			*/
    592		if (mpcg_state == MPCG_STATE_READY) {
    593			grp->flow_off_called = 1;
    594			break;
    595		}
    596		break;
    597	}
    598
    599}
    600EXPORT_SYMBOL(ctc_mpc_flow_control);
    601
    602static int mpc_send_qllc_discontact(struct net_device *);
    603
    604/*
    605 * helper function of ctcmpc_unpack_skb
    606*/
    607static void mpc_rcvd_sweep_resp(struct mpcg_info *mpcginfo)
    608{
    609	struct channel	  *rch = mpcginfo->ch;
    610	struct net_device *dev = rch->netdev;
    611	struct ctcm_priv   *priv = dev->ml_priv;
    612	struct mpc_group  *grp = priv->mpcg;
    613	struct channel	  *ch = priv->channel[CTCM_WRITE];
    614
    615	CTCM_PR_DEBUG("%s: ch=0x%p id=%s\n", __func__, ch, ch->id);
    616	CTCM_D3_DUMP((char *)mpcginfo->sweep, TH_SWEEP_LENGTH);
    617
    618	grp->sweep_rsp_pend_num--;
    619
    620	if ((grp->sweep_req_pend_num == 0) &&
    621			(grp->sweep_rsp_pend_num == 0)) {
    622		fsm_deltimer(&ch->sweep_timer);
    623		grp->in_sweep = 0;
    624		rch->th_seq_num = 0x00;
    625		ch->th_seq_num = 0x00;
    626		ctcm_clear_busy_do(dev);
    627	}
    628
    629	return;
    630
    631}
    632
    633/*
    634 * helper function of mpc_rcvd_sweep_req
    635 * which is a helper of ctcmpc_unpack_skb
    636 */
    637static void ctcmpc_send_sweep_resp(struct channel *rch)
    638{
    639	struct net_device *dev = rch->netdev;
    640	struct ctcm_priv *priv = dev->ml_priv;
    641	struct mpc_group *grp = priv->mpcg;
    642	struct th_sweep *header;
    643	struct sk_buff *sweep_skb;
    644	struct channel *ch  = priv->channel[CTCM_WRITE];
    645
    646	CTCM_PR_DEBUG("%s: ch=0x%p id=%s\n", __func__, rch, rch->id);
    647
    648	sweep_skb = __dev_alloc_skb(MPC_BUFSIZE_DEFAULT, GFP_ATOMIC | GFP_DMA);
    649	if (sweep_skb == NULL) {
    650		CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
    651			"%s(%s): sweep_skb allocation ERROR\n",
    652			CTCM_FUNTAIL, rch->id);
    653		goto done;
    654	}
    655
    656	header = skb_put_zero(sweep_skb, TH_SWEEP_LENGTH);
    657	header->th.th_ch_flag	= TH_SWEEP_RESP;
    658	header->sw.th_last_seq	= ch->th_seq_num;
    659
    660	netif_trans_update(dev);
    661	skb_queue_tail(&ch->sweep_queue, sweep_skb);
    662
    663	fsm_addtimer(&ch->sweep_timer, 100, CTC_EVENT_RSWEEP_TIMER, ch);
    664
    665	return;
    666
    667done:
    668	grp->in_sweep = 0;
    669	ctcm_clear_busy_do(dev);
    670	fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
    671
    672	return;
    673}
    674
    675/*
    676 * helper function of ctcmpc_unpack_skb
    677 */
    678static void mpc_rcvd_sweep_req(struct mpcg_info *mpcginfo)
    679{
    680	struct channel	  *rch     = mpcginfo->ch;
    681	struct net_device *dev     = rch->netdev;
    682	struct ctcm_priv  *priv = dev->ml_priv;
    683	struct mpc_group  *grp  = priv->mpcg;
    684	struct channel	  *ch	   = priv->channel[CTCM_WRITE];
    685
    686	if (do_debug)
    687		CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_DEBUG,
    688			" %s(): ch=0x%p id=%s\n", __func__, ch, ch->id);
    689
    690	if (grp->in_sweep == 0) {
    691		grp->in_sweep = 1;
    692		ctcm_test_and_set_busy(dev);
    693		grp->sweep_req_pend_num = grp->active_channels[CTCM_READ];
    694		grp->sweep_rsp_pend_num = grp->active_channels[CTCM_READ];
    695	}
    696
    697	CTCM_D3_DUMP((char *)mpcginfo->sweep, TH_SWEEP_LENGTH);
    698
    699	grp->sweep_req_pend_num--;
    700	ctcmpc_send_sweep_resp(ch);
    701	kfree(mpcginfo);
    702	return;
    703}
    704
    705/*
    706  * MPC Group Station FSM definitions
    707 */
    708static const char *mpcg_event_names[] = {
    709	[MPCG_EVENT_INOP]	= "INOP Condition",
    710	[MPCG_EVENT_DISCONC]	= "Discontact Received",
    711	[MPCG_EVENT_XID0DO]	= "Channel Active - Start XID",
    712	[MPCG_EVENT_XID2]	= "XID2 Received",
    713	[MPCG_EVENT_XID2DONE]	= "XID0 Complete",
    714	[MPCG_EVENT_XID7DONE]	= "XID7 Complete",
    715	[MPCG_EVENT_TIMER]	= "XID Setup Timer",
    716	[MPCG_EVENT_DOIO]	= "XID DoIO",
    717};
    718
    719static const char *mpcg_state_names[] = {
    720	[MPCG_STATE_RESET]	= "Reset",
    721	[MPCG_STATE_INOP]	= "INOP",
    722	[MPCG_STATE_XID2INITW]	= "Passive XID- XID0 Pending Start",
    723	[MPCG_STATE_XID2INITX]	= "Passive XID- XID0 Pending Complete",
    724	[MPCG_STATE_XID7INITW]	= "Passive XID- XID7 Pending P1 Start",
    725	[MPCG_STATE_XID7INITX]	= "Passive XID- XID7 Pending P2 Complete",
    726	[MPCG_STATE_XID0IOWAIT]	= "Active  XID- XID0 Pending Start",
    727	[MPCG_STATE_XID0IOWAIX]	= "Active  XID- XID0 Pending Complete",
    728	[MPCG_STATE_XID7INITI]	= "Active  XID- XID7 Pending Start",
    729	[MPCG_STATE_XID7INITZ]	= "Active  XID- XID7 Pending Complete ",
    730	[MPCG_STATE_XID7INITF]	= "XID        - XID7 Complete ",
    731	[MPCG_STATE_FLOWC]	= "FLOW CONTROL ON",
    732	[MPCG_STATE_READY]	= "READY",
    733};
    734
    735/*
    736 * The MPC Group Station FSM
    737 *   22 events
    738 */
    739static const fsm_node mpcg_fsm[] = {
    740	{ MPCG_STATE_RESET,	MPCG_EVENT_INOP,	mpc_action_go_inop    },
    741	{ MPCG_STATE_INOP,	MPCG_EVENT_INOP,	mpc_action_nop        },
    742	{ MPCG_STATE_FLOWC,	MPCG_EVENT_INOP,	mpc_action_go_inop    },
    743
    744	{ MPCG_STATE_READY,	MPCG_EVENT_DISCONC,	mpc_action_discontact },
    745	{ MPCG_STATE_READY,	MPCG_EVENT_INOP,	mpc_action_go_inop    },
    746
    747	{ MPCG_STATE_XID2INITW,	MPCG_EVENT_XID0DO,	mpc_action_doxid0     },
    748	{ MPCG_STATE_XID2INITW,	MPCG_EVENT_XID2,	mpc_action_rcvd_xid0  },
    749	{ MPCG_STATE_XID2INITW,	MPCG_EVENT_INOP,	mpc_action_go_inop    },
    750	{ MPCG_STATE_XID2INITW,	MPCG_EVENT_TIMER,	mpc_action_timeout    },
    751	{ MPCG_STATE_XID2INITW,	MPCG_EVENT_DOIO,	mpc_action_yside_xid  },
    752
    753	{ MPCG_STATE_XID2INITX,	MPCG_EVENT_XID0DO,	mpc_action_doxid0     },
    754	{ MPCG_STATE_XID2INITX,	MPCG_EVENT_XID2,	mpc_action_rcvd_xid0  },
    755	{ MPCG_STATE_XID2INITX,	MPCG_EVENT_INOP,	mpc_action_go_inop    },
    756	{ MPCG_STATE_XID2INITX,	MPCG_EVENT_TIMER,	mpc_action_timeout    },
    757	{ MPCG_STATE_XID2INITX,	MPCG_EVENT_DOIO,	mpc_action_yside_xid  },
    758
    759	{ MPCG_STATE_XID7INITW,	MPCG_EVENT_XID2DONE,	mpc_action_doxid7     },
    760	{ MPCG_STATE_XID7INITW,	MPCG_EVENT_DISCONC,	mpc_action_discontact },
    761	{ MPCG_STATE_XID7INITW,	MPCG_EVENT_XID2,	mpc_action_rcvd_xid7  },
    762	{ MPCG_STATE_XID7INITW,	MPCG_EVENT_INOP,	mpc_action_go_inop    },
    763	{ MPCG_STATE_XID7INITW,	MPCG_EVENT_TIMER,	mpc_action_timeout    },
    764	{ MPCG_STATE_XID7INITW,	MPCG_EVENT_XID7DONE,	mpc_action_doxid7     },
    765	{ MPCG_STATE_XID7INITW,	MPCG_EVENT_DOIO,	mpc_action_yside_xid  },
    766
    767	{ MPCG_STATE_XID7INITX,	MPCG_EVENT_DISCONC,	mpc_action_discontact },
    768	{ MPCG_STATE_XID7INITX,	MPCG_EVENT_XID2,	mpc_action_rcvd_xid7  },
    769	{ MPCG_STATE_XID7INITX,	MPCG_EVENT_INOP,	mpc_action_go_inop    },
    770	{ MPCG_STATE_XID7INITX,	MPCG_EVENT_XID7DONE,	mpc_action_doxid7     },
    771	{ MPCG_STATE_XID7INITX,	MPCG_EVENT_TIMER,	mpc_action_timeout    },
    772	{ MPCG_STATE_XID7INITX,	MPCG_EVENT_DOIO,	mpc_action_yside_xid  },
    773
    774	{ MPCG_STATE_XID0IOWAIT, MPCG_EVENT_XID0DO,	mpc_action_doxid0     },
    775	{ MPCG_STATE_XID0IOWAIT, MPCG_EVENT_DISCONC,	mpc_action_discontact },
    776	{ MPCG_STATE_XID0IOWAIT, MPCG_EVENT_XID2,	mpc_action_rcvd_xid0  },
    777	{ MPCG_STATE_XID0IOWAIT, MPCG_EVENT_INOP,	mpc_action_go_inop    },
    778	{ MPCG_STATE_XID0IOWAIT, MPCG_EVENT_TIMER,	mpc_action_timeout    },
    779	{ MPCG_STATE_XID0IOWAIT, MPCG_EVENT_DOIO,	mpc_action_xside_xid  },
    780
    781	{ MPCG_STATE_XID0IOWAIX, MPCG_EVENT_XID0DO,	mpc_action_doxid0     },
    782	{ MPCG_STATE_XID0IOWAIX, MPCG_EVENT_DISCONC,	mpc_action_discontact },
    783	{ MPCG_STATE_XID0IOWAIX, MPCG_EVENT_XID2,	mpc_action_rcvd_xid0  },
    784	{ MPCG_STATE_XID0IOWAIX, MPCG_EVENT_INOP,	mpc_action_go_inop    },
    785	{ MPCG_STATE_XID0IOWAIX, MPCG_EVENT_TIMER,	mpc_action_timeout    },
    786	{ MPCG_STATE_XID0IOWAIX, MPCG_EVENT_DOIO,	mpc_action_xside_xid  },
    787
    788	{ MPCG_STATE_XID7INITI,	MPCG_EVENT_XID2DONE,	mpc_action_doxid7     },
    789	{ MPCG_STATE_XID7INITI,	MPCG_EVENT_XID2,	mpc_action_rcvd_xid7  },
    790	{ MPCG_STATE_XID7INITI,	MPCG_EVENT_DISCONC,	mpc_action_discontact },
    791	{ MPCG_STATE_XID7INITI,	MPCG_EVENT_INOP,	mpc_action_go_inop    },
    792	{ MPCG_STATE_XID7INITI,	MPCG_EVENT_TIMER,	mpc_action_timeout    },
    793	{ MPCG_STATE_XID7INITI,	MPCG_EVENT_XID7DONE,	mpc_action_doxid7     },
    794	{ MPCG_STATE_XID7INITI,	MPCG_EVENT_DOIO,	mpc_action_xside_xid  },
    795
    796	{ MPCG_STATE_XID7INITZ,	MPCG_EVENT_XID2,	mpc_action_rcvd_xid7  },
    797	{ MPCG_STATE_XID7INITZ,	MPCG_EVENT_XID7DONE,	mpc_action_doxid7     },
    798	{ MPCG_STATE_XID7INITZ,	MPCG_EVENT_DISCONC,	mpc_action_discontact },
    799	{ MPCG_STATE_XID7INITZ,	MPCG_EVENT_INOP,	mpc_action_go_inop    },
    800	{ MPCG_STATE_XID7INITZ,	MPCG_EVENT_TIMER,	mpc_action_timeout    },
    801	{ MPCG_STATE_XID7INITZ,	MPCG_EVENT_DOIO,	mpc_action_xside_xid  },
    802
    803	{ MPCG_STATE_XID7INITF,	MPCG_EVENT_INOP,	mpc_action_go_inop    },
    804	{ MPCG_STATE_XID7INITF,	MPCG_EVENT_XID7DONE,	mpc_action_go_ready   },
    805};
    806
    807static int mpcg_fsm_len = ARRAY_SIZE(mpcg_fsm);
    808
    809/*
    810 * MPC Group Station FSM action
    811 * CTCM_PROTO_MPC only
    812 */
    813static void mpc_action_go_ready(fsm_instance *fsm, int event, void *arg)
    814{
    815	struct net_device *dev = arg;
    816	struct ctcm_priv *priv = dev->ml_priv;
    817	struct mpc_group *grp = priv->mpcg;
    818
    819	if (grp == NULL) {
    820		CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
    821			"%s(%s): No MPC group",
    822				CTCM_FUNTAIL, dev->name);
    823		return;
    824	}
    825
    826	fsm_deltimer(&grp->timer);
    827
    828	if (grp->saved_xid2->xid2_flag2 == 0x40) {
    829		priv->xid->xid2_flag2 = 0x00;
    830		if (grp->estconnfunc) {
    831			grp->estconnfunc(grp->port_num, 1,
    832					grp->group_max_buflen);
    833			grp->estconnfunc = NULL;
    834		} else if (grp->allochanfunc)
    835			grp->send_qllc_disc = 1;
    836
    837		fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
    838		CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
    839				"%s(%s): fails",
    840					CTCM_FUNTAIL, dev->name);
    841		return;
    842	}
    843
    844	grp->port_persist = 1;
    845	grp->out_of_sequence = 0;
    846	grp->estconn_called = 0;
    847
    848	tasklet_hi_schedule(&grp->mpc_tasklet2);
    849
    850	return;
    851}
    852
    853/*
    854 * helper of ctcm_init_netdevice
    855 * CTCM_PROTO_MPC only
    856 */
    857void mpc_group_ready(unsigned long adev)
    858{
    859	struct net_device *dev = (struct net_device *)adev;
    860	struct ctcm_priv *priv = dev->ml_priv;
    861	struct mpc_group *grp = priv->mpcg;
    862	struct channel *ch = NULL;
    863
    864	if (grp == NULL) {
    865		CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
    866			"%s(%s): No MPC group",
    867				CTCM_FUNTAIL, dev->name);
    868		return;
    869	}
    870
    871	CTCM_DBF_TEXT_(MPC_SETUP, CTC_DBF_NOTICE,
    872		"%s: %s: GROUP TRANSITIONED TO READY, maxbuf = %d\n",
    873			CTCM_FUNTAIL, dev->name, grp->group_max_buflen);
    874
    875	fsm_newstate(grp->fsm, MPCG_STATE_READY);
    876
    877	/* Put up a read on the channel */
    878	ch = priv->channel[CTCM_READ];
    879	ch->pdu_seq = 0;
    880	CTCM_PR_DBGDATA("ctcmpc: %s() ToDCM_pdu_seq= %08x\n" ,
    881			__func__, ch->pdu_seq);
    882
    883	ctcmpc_chx_rxidle(ch->fsm, CTC_EVENT_START, ch);
    884	/* Put the write channel in idle state */
    885	ch = priv->channel[CTCM_WRITE];
    886	if (ch->collect_len > 0) {
    887		spin_lock(&ch->collect_lock);
    888		ctcm_purge_skb_queue(&ch->collect_queue);
    889		ch->collect_len = 0;
    890		spin_unlock(&ch->collect_lock);
    891	}
    892	ctcm_chx_txidle(ch->fsm, CTC_EVENT_START, ch);
    893	ctcm_clear_busy(dev);
    894
    895	if (grp->estconnfunc) {
    896		grp->estconnfunc(grp->port_num, 0,
    897				    grp->group_max_buflen);
    898		grp->estconnfunc = NULL;
    899	} else 	if (grp->allochanfunc)
    900		grp->allochanfunc(grp->port_num, grp->group_max_buflen);
    901
    902	grp->send_qllc_disc = 1;
    903	grp->changed_side = 0;
    904
    905	return;
    906
    907}
    908
    909/*
    910 * Increment the MPC Group Active Channel Counts
    911 * helper of dev_action (called from channel fsm)
    912 */
    913void mpc_channel_action(struct channel *ch, int direction, int action)
    914{
    915	struct net_device  *dev  = ch->netdev;
    916	struct ctcm_priv   *priv = dev->ml_priv;
    917	struct mpc_group   *grp  = priv->mpcg;
    918
    919	if (grp == NULL) {
    920		CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
    921			"%s(%s): No MPC group",
    922				CTCM_FUNTAIL, dev->name);
    923		return;
    924	}
    925
    926	CTCM_PR_DEBUG("enter %s: ch=0x%p id=%s\n", __func__, ch, ch->id);
    927
    928	CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_NOTICE,
    929		"%s: %i / Grp:%s total_channels=%i, active_channels: "
    930		"read=%i, write=%i\n", __func__, action,
    931		fsm_getstate_str(grp->fsm), grp->num_channel_paths,
    932		grp->active_channels[CTCM_READ],
    933		grp->active_channels[CTCM_WRITE]);
    934
    935	if ((action == MPC_CHANNEL_ADD) && (ch->in_mpcgroup == 0)) {
    936		grp->num_channel_paths++;
    937		grp->active_channels[direction]++;
    938		grp->outstanding_xid2++;
    939		ch->in_mpcgroup = 1;
    940
    941		if (ch->xid_skb != NULL)
    942			dev_kfree_skb_any(ch->xid_skb);
    943
    944		ch->xid_skb = __dev_alloc_skb(MPC_BUFSIZE_DEFAULT,
    945					GFP_ATOMIC | GFP_DMA);
    946		if (ch->xid_skb == NULL) {
    947			CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
    948				"%s(%s): Couldn't alloc ch xid_skb\n",
    949				CTCM_FUNTAIL, dev->name);
    950			fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
    951			return;
    952		}
    953		ch->xid_skb_data = ch->xid_skb->data;
    954		ch->xid_th = (struct th_header *)ch->xid_skb->data;
    955		skb_put(ch->xid_skb, TH_HEADER_LENGTH);
    956		ch->xid = (struct xid2 *)skb_tail_pointer(ch->xid_skb);
    957		skb_put(ch->xid_skb, XID2_LENGTH);
    958		ch->xid_id = skb_tail_pointer(ch->xid_skb);
    959		ch->xid_skb->data = ch->xid_skb_data;
    960		skb_reset_tail_pointer(ch->xid_skb);
    961		ch->xid_skb->len = 0;
    962
    963		skb_put_data(ch->xid_skb, grp->xid_skb->data,
    964			     grp->xid_skb->len);
    965
    966		ch->xid->xid2_dlc_type =
    967			((CHANNEL_DIRECTION(ch->flags) == CTCM_READ)
    968				? XID2_READ_SIDE : XID2_WRITE_SIDE);
    969
    970		if (CHANNEL_DIRECTION(ch->flags) == CTCM_WRITE)
    971			ch->xid->xid2_buf_len = 0x00;
    972
    973		ch->xid_skb->data = ch->xid_skb_data;
    974		skb_reset_tail_pointer(ch->xid_skb);
    975		ch->xid_skb->len = 0;
    976
    977		fsm_newstate(ch->fsm, CH_XID0_PENDING);
    978
    979		if ((grp->active_channels[CTCM_READ] > 0) &&
    980		    (grp->active_channels[CTCM_WRITE] > 0) &&
    981			(fsm_getstate(grp->fsm) < MPCG_STATE_XID2INITW)) {
    982			fsm_newstate(grp->fsm, MPCG_STATE_XID2INITW);
    983			CTCM_DBF_TEXT_(MPC_SETUP, CTC_DBF_NOTICE,
    984				"%s: %s: MPC GROUP CHANNELS ACTIVE\n",
    985						__func__, dev->name);
    986		}
    987	} else if ((action == MPC_CHANNEL_REMOVE) &&
    988			(ch->in_mpcgroup == 1)) {
    989		ch->in_mpcgroup = 0;
    990		grp->num_channel_paths--;
    991		grp->active_channels[direction]--;
    992
    993		if (ch->xid_skb != NULL)
    994			dev_kfree_skb_any(ch->xid_skb);
    995		ch->xid_skb = NULL;
    996
    997		if (grp->channels_terminating)
    998					goto done;
    999
   1000		if (((grp->active_channels[CTCM_READ] == 0) &&
   1001					(grp->active_channels[CTCM_WRITE] > 0))
   1002			|| ((grp->active_channels[CTCM_WRITE] == 0) &&
   1003					(grp->active_channels[CTCM_READ] > 0)))
   1004			fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
   1005	}
   1006done:
   1007	CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_DEBUG,
   1008		"exit %s: %i / Grp:%s total_channels=%i, active_channels: "
   1009		"read=%i, write=%i\n", __func__, action,
   1010		fsm_getstate_str(grp->fsm), grp->num_channel_paths,
   1011		grp->active_channels[CTCM_READ],
   1012		grp->active_channels[CTCM_WRITE]);
   1013
   1014	CTCM_PR_DEBUG("exit %s: ch=0x%p id=%s\n", __func__, ch, ch->id);
   1015}
   1016
   1017/*
   1018 * Unpack a just received skb and hand it over to
   1019 * upper layers.
   1020 * special MPC version of unpack_skb.
   1021 *
   1022 * ch		The channel where this skb has been received.
   1023 * pskb		The received skb.
   1024 */
   1025static void ctcmpc_unpack_skb(struct channel *ch, struct sk_buff *pskb)
   1026{
   1027	struct net_device *dev	= ch->netdev;
   1028	struct ctcm_priv *priv = dev->ml_priv;
   1029	struct mpc_group *grp = priv->mpcg;
   1030	struct pdu *curr_pdu;
   1031	struct mpcg_info *mpcginfo;
   1032	struct th_header *header = NULL;
   1033	struct th_sweep *sweep = NULL;
   1034	int pdu_last_seen = 0;
   1035	__u32 new_len;
   1036	struct sk_buff *skb;
   1037	int skblen;
   1038	int sendrc = 0;
   1039
   1040	CTCM_PR_DEBUG("ctcmpc enter: %s() %s cp:%i ch:%s\n",
   1041			__func__, dev->name, smp_processor_id(), ch->id);
   1042
   1043	header = (struct th_header *)pskb->data;
   1044	if ((header->th_seg == 0) &&
   1045		(header->th_ch_flag == 0) &&
   1046		(header->th_blk_flag == 0) &&
   1047		(header->th_seq_num == 0))
   1048		/* nothing for us */	goto done;
   1049
   1050	CTCM_PR_DBGDATA("%s: th_header\n", __func__);
   1051	CTCM_D3_DUMP((char *)header, TH_HEADER_LENGTH);
   1052	CTCM_PR_DBGDATA("%s: pskb len: %04x \n", __func__, pskb->len);
   1053
   1054	pskb->dev = dev;
   1055	pskb->ip_summed = CHECKSUM_UNNECESSARY;
   1056	skb_pull(pskb, TH_HEADER_LENGTH);
   1057
   1058	if (likely(header->th_ch_flag == TH_HAS_PDU)) {
   1059		CTCM_PR_DBGDATA("%s: came into th_has_pdu\n", __func__);
   1060		if ((fsm_getstate(grp->fsm) == MPCG_STATE_FLOWC) ||
   1061		   ((fsm_getstate(grp->fsm) == MPCG_STATE_READY) &&
   1062		    (header->th_seq_num != ch->th_seq_num + 1) &&
   1063		    (ch->th_seq_num != 0))) {
   1064			/* This is NOT the next segment		*
   1065			 * we are not the correct race winner	*
   1066			 * go away and let someone else win	*
   1067			 * BUT..this only applies if xid negot	*
   1068			 * is done				*
   1069			*/
   1070			grp->out_of_sequence += 1;
   1071			__skb_push(pskb, TH_HEADER_LENGTH);
   1072			skb_queue_tail(&ch->io_queue, pskb);
   1073			CTCM_PR_DBGDATA("%s: th_seq_num expect:%08x "
   1074					"got:%08x\n", __func__,
   1075				ch->th_seq_num + 1, header->th_seq_num);
   1076
   1077			return;
   1078		}
   1079		grp->out_of_sequence = 0;
   1080		ch->th_seq_num = header->th_seq_num;
   1081
   1082		CTCM_PR_DBGDATA("ctcmpc: %s() FromVTAM_th_seq=%08x\n",
   1083					__func__, ch->th_seq_num);
   1084
   1085		if (unlikely(fsm_getstate(grp->fsm) != MPCG_STATE_READY))
   1086					goto done;
   1087		while ((pskb->len > 0) && !pdu_last_seen) {
   1088			curr_pdu = (struct pdu *)pskb->data;
   1089
   1090			CTCM_PR_DBGDATA("%s: pdu_header\n", __func__);
   1091			CTCM_D3_DUMP((char *)pskb->data, PDU_HEADER_LENGTH);
   1092			CTCM_PR_DBGDATA("%s: pskb len: %04x \n",
   1093						__func__, pskb->len);
   1094
   1095			skb_pull(pskb, PDU_HEADER_LENGTH);
   1096
   1097			if (curr_pdu->pdu_flag & PDU_LAST)
   1098				pdu_last_seen = 1;
   1099			if (curr_pdu->pdu_flag & PDU_CNTL)
   1100				pskb->protocol = htons(ETH_P_SNAP);
   1101			else
   1102				pskb->protocol = htons(ETH_P_SNA_DIX);
   1103
   1104			if ((pskb->len <= 0) || (pskb->len > ch->max_bufsize)) {
   1105				CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
   1106					"%s(%s): Dropping packet with "
   1107					"illegal siize %d",
   1108					CTCM_FUNTAIL, dev->name, pskb->len);
   1109
   1110				priv->stats.rx_dropped++;
   1111				priv->stats.rx_length_errors++;
   1112					goto done;
   1113			}
   1114			skb_reset_mac_header(pskb);
   1115			new_len = curr_pdu->pdu_offset;
   1116			CTCM_PR_DBGDATA("%s: new_len: %04x \n",
   1117						__func__, new_len);
   1118			if ((new_len == 0) || (new_len > pskb->len)) {
   1119				/* should never happen		    */
   1120				/* pskb len must be hosed...bail out */
   1121				CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
   1122					"%s(%s): non valid pdu_offset: %04x",
   1123					/* "data may be lost", */
   1124					CTCM_FUNTAIL, dev->name, new_len);
   1125				goto done;
   1126			}
   1127			skb = __dev_alloc_skb(new_len+4, GFP_ATOMIC);
   1128
   1129			if (!skb) {
   1130				CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
   1131					"%s(%s): MEMORY allocation error",
   1132						CTCM_FUNTAIL, dev->name);
   1133				priv->stats.rx_dropped++;
   1134				fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
   1135						goto done;
   1136			}
   1137			skb_put_data(skb, pskb->data, new_len);
   1138
   1139			skb_reset_mac_header(skb);
   1140			skb->dev = pskb->dev;
   1141			skb->protocol = pskb->protocol;
   1142			skb->ip_summed = CHECKSUM_UNNECESSARY;
   1143			*((__u32 *) skb_push(skb, 4)) = ch->pdu_seq;
   1144			ch->pdu_seq++;
   1145
   1146			if (do_debug_data) {
   1147				ctcm_pr_debug("%s: ToDCM_pdu_seq= %08x\n",
   1148						__func__, ch->pdu_seq);
   1149				ctcm_pr_debug("%s: skb:%0lx "
   1150					"skb len: %d \n", __func__,
   1151					(unsigned long)skb, skb->len);
   1152				ctcm_pr_debug("%s: up to 32 bytes "
   1153					"of pdu_data sent\n", __func__);
   1154				ctcmpc_dump32((char *)skb->data, skb->len);
   1155			}
   1156
   1157			skblen = skb->len;
   1158			sendrc = netif_rx(skb);
   1159			priv->stats.rx_packets++;
   1160			priv->stats.rx_bytes += skblen;
   1161			skb_pull(pskb, new_len); /* point to next PDU */
   1162		}
   1163	} else {
   1164		mpcginfo = kmalloc(sizeof(struct mpcg_info), GFP_ATOMIC);
   1165		if (mpcginfo == NULL)
   1166					goto done;
   1167
   1168		mpcginfo->ch = ch;
   1169		mpcginfo->th = header;
   1170		mpcginfo->skb = pskb;
   1171		CTCM_PR_DEBUG("%s: Not PDU - may be control pkt\n",
   1172					__func__);
   1173		/*  it's a sweep?   */
   1174		sweep = (struct th_sweep *)pskb->data;
   1175		mpcginfo->sweep = sweep;
   1176		if (header->th_ch_flag == TH_SWEEP_REQ)
   1177			mpc_rcvd_sweep_req(mpcginfo);
   1178		else if (header->th_ch_flag == TH_SWEEP_RESP)
   1179			mpc_rcvd_sweep_resp(mpcginfo);
   1180		else if (header->th_blk_flag == TH_DATA_IS_XID) {
   1181			struct xid2 *thisxid = (struct xid2 *)pskb->data;
   1182			skb_pull(pskb, XID2_LENGTH);
   1183			mpcginfo->xid = thisxid;
   1184			fsm_event(grp->fsm, MPCG_EVENT_XID2, mpcginfo);
   1185		} else if (header->th_blk_flag == TH_DISCONTACT)
   1186			fsm_event(grp->fsm, MPCG_EVENT_DISCONC, mpcginfo);
   1187		else if (header->th_seq_num != 0) {
   1188			CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
   1189				"%s(%s): control pkt expected\n",
   1190						CTCM_FUNTAIL, dev->name);
   1191			priv->stats.rx_dropped++;
   1192			/* mpcginfo only used for non-data transfers */
   1193			if (do_debug_data)
   1194				ctcmpc_dump_skb(pskb, -8);
   1195		}
   1196		kfree(mpcginfo);
   1197	}
   1198done:
   1199
   1200	dev_kfree_skb_any(pskb);
   1201	if (sendrc == NET_RX_DROP) {
   1202		dev_warn(&dev->dev,
   1203			"The network backlog for %s is exceeded, "
   1204			"package dropped\n", __func__);
   1205		fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
   1206	}
   1207
   1208	CTCM_PR_DEBUG("exit %s: %s: ch=0x%p id=%s\n",
   1209			__func__, dev->name, ch, ch->id);
   1210}
   1211
   1212/*
   1213 * tasklet helper for mpc's skb unpacking.
   1214 *
   1215 * ch		The channel to work on.
   1216 * Allow flow control back pressure to occur here.
   1217 * Throttling back channel can result in excessive
   1218 * channel inactivity and system deact of channel
   1219 */
   1220void ctcmpc_bh(unsigned long thischan)
   1221{
   1222	struct channel	  *ch	= (struct channel *)thischan;
   1223	struct sk_buff	  *skb;
   1224	struct net_device *dev	= ch->netdev;
   1225	struct ctcm_priv  *priv	= dev->ml_priv;
   1226	struct mpc_group  *grp	= priv->mpcg;
   1227
   1228	CTCM_PR_DEBUG("%s cp:%i enter:  %s() %s\n",
   1229	       dev->name, smp_processor_id(), __func__, ch->id);
   1230	/* caller has requested driver to throttle back */
   1231	while ((fsm_getstate(grp->fsm) != MPCG_STATE_FLOWC) &&
   1232			(skb = skb_dequeue(&ch->io_queue))) {
   1233		ctcmpc_unpack_skb(ch, skb);
   1234		if (grp->out_of_sequence > 20) {
   1235			/* assume data loss has occurred if */
   1236			/* missing seq_num for extended     */
   1237			/* period of time		    */
   1238			grp->out_of_sequence = 0;
   1239			fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
   1240			break;
   1241		}
   1242		if (skb == skb_peek(&ch->io_queue))
   1243			break;
   1244	}
   1245	CTCM_PR_DEBUG("exit %s: %s: ch=0x%p id=%s\n",
   1246			__func__, dev->name, ch, ch->id);
   1247	return;
   1248}
   1249
   1250/*
   1251 *  MPC Group Initializations
   1252 */
   1253struct mpc_group *ctcmpc_init_mpc_group(struct ctcm_priv *priv)
   1254{
   1255	struct mpc_group *grp;
   1256
   1257	CTCM_DBF_TEXT_(MPC_SETUP, CTC_DBF_INFO,
   1258			"Enter %s(%p)", CTCM_FUNTAIL, priv);
   1259
   1260	grp = kzalloc(sizeof(struct mpc_group), GFP_KERNEL);
   1261	if (grp == NULL)
   1262		return NULL;
   1263
   1264	grp->fsm = init_fsm("mpcg", mpcg_state_names, mpcg_event_names,
   1265			MPCG_NR_STATES, MPCG_NR_EVENTS, mpcg_fsm,
   1266			mpcg_fsm_len, GFP_KERNEL);
   1267	if (grp->fsm == NULL) {
   1268		kfree(grp);
   1269		return NULL;
   1270	}
   1271
   1272	fsm_newstate(grp->fsm, MPCG_STATE_RESET);
   1273	fsm_settimer(grp->fsm, &grp->timer);
   1274
   1275	grp->xid_skb =
   1276		 __dev_alloc_skb(MPC_BUFSIZE_DEFAULT, GFP_ATOMIC | GFP_DMA);
   1277	if (grp->xid_skb == NULL) {
   1278		kfree_fsm(grp->fsm);
   1279		kfree(grp);
   1280		return NULL;
   1281	}
   1282	/*  base xid for all channels in group  */
   1283	grp->xid_skb_data = grp->xid_skb->data;
   1284	grp->xid_th = (struct th_header *)grp->xid_skb->data;
   1285	skb_put_data(grp->xid_skb, &thnorm, TH_HEADER_LENGTH);
   1286
   1287	grp->xid = (struct xid2 *)skb_tail_pointer(grp->xid_skb);
   1288	skb_put_data(grp->xid_skb, &init_xid, XID2_LENGTH);
   1289	grp->xid->xid2_adj_id = jiffies | 0xfff00000;
   1290	grp->xid->xid2_sender_id = jiffies;
   1291
   1292	grp->xid_id = skb_tail_pointer(grp->xid_skb);
   1293	skb_put_data(grp->xid_skb, "VTAM", 4);
   1294
   1295	grp->rcvd_xid_skb =
   1296		__dev_alloc_skb(MPC_BUFSIZE_DEFAULT, GFP_ATOMIC|GFP_DMA);
   1297	if (grp->rcvd_xid_skb == NULL) {
   1298		kfree_fsm(grp->fsm);
   1299		dev_kfree_skb(grp->xid_skb);
   1300		kfree(grp);
   1301		return NULL;
   1302	}
   1303	grp->rcvd_xid_data = grp->rcvd_xid_skb->data;
   1304	grp->rcvd_xid_th = (struct th_header *)grp->rcvd_xid_skb->data;
   1305	skb_put_data(grp->rcvd_xid_skb, &thnorm, TH_HEADER_LENGTH);
   1306	grp->saved_xid2 = NULL;
   1307	priv->xid = grp->xid;
   1308	priv->mpcg = grp;
   1309	return grp;
   1310}
   1311
   1312/*
   1313 * The MPC Group Station FSM
   1314 */
   1315
   1316/*
   1317 * MPC Group Station FSM actions
   1318 * CTCM_PROTO_MPC only
   1319 */
   1320
   1321/*
   1322 * NOP action for statemachines
   1323 */
   1324static void mpc_action_nop(fsm_instance *fi, int event, void *arg)
   1325{
   1326}
   1327
   1328/*
   1329 * invoked when the device transitions to dev_stopped
   1330 * MPC will stop each individual channel if a single XID failure
   1331 * occurs, or will intitiate all channels be stopped if a GROUP
   1332 * level failure occurs.
   1333 */
   1334static void mpc_action_go_inop(fsm_instance *fi, int event, void *arg)
   1335{
   1336	struct net_device  *dev = arg;
   1337	struct ctcm_priv    *priv;
   1338	struct mpc_group *grp;
   1339	struct channel *wch;
   1340
   1341	CTCM_PR_DEBUG("Enter %s: %s\n",	__func__, dev->name);
   1342
   1343	priv  = dev->ml_priv;
   1344	grp =  priv->mpcg;
   1345	grp->flow_off_called = 0;
   1346	fsm_deltimer(&grp->timer);
   1347	if (grp->channels_terminating)
   1348			return;
   1349
   1350	grp->channels_terminating = 1;
   1351	grp->saved_state = fsm_getstate(grp->fsm);
   1352	fsm_newstate(grp->fsm, MPCG_STATE_INOP);
   1353	if (grp->saved_state > MPCG_STATE_XID7INITF)
   1354		CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_NOTICE,
   1355			"%s(%s): MPC GROUP INOPERATIVE",
   1356				CTCM_FUNTAIL, dev->name);
   1357	if ((grp->saved_state != MPCG_STATE_RESET) ||
   1358		/* dealloc_channel has been called */
   1359		(grp->port_persist == 0))
   1360		fsm_deltimer(&priv->restart_timer);
   1361
   1362	wch = priv->channel[CTCM_WRITE];
   1363
   1364	switch (grp->saved_state) {
   1365	case MPCG_STATE_RESET:
   1366	case MPCG_STATE_INOP:
   1367	case MPCG_STATE_XID2INITW:
   1368	case MPCG_STATE_XID0IOWAIT:
   1369	case MPCG_STATE_XID2INITX:
   1370	case MPCG_STATE_XID7INITW:
   1371	case MPCG_STATE_XID7INITX:
   1372	case MPCG_STATE_XID0IOWAIX:
   1373	case MPCG_STATE_XID7INITI:
   1374	case MPCG_STATE_XID7INITZ:
   1375	case MPCG_STATE_XID7INITF:
   1376		break;
   1377	case MPCG_STATE_FLOWC:
   1378	case MPCG_STATE_READY:
   1379	default:
   1380		tasklet_hi_schedule(&wch->ch_disc_tasklet);
   1381	}
   1382
   1383	grp->xid2_tgnum = 0;
   1384	grp->group_max_buflen = 0;  /*min of all received */
   1385	grp->outstanding_xid2 = 0;
   1386	grp->outstanding_xid7 = 0;
   1387	grp->outstanding_xid7_p2 = 0;
   1388	grp->saved_xid2 = NULL;
   1389	grp->xidnogood = 0;
   1390	grp->changed_side = 0;
   1391
   1392	grp->rcvd_xid_skb->data = grp->rcvd_xid_data;
   1393	skb_reset_tail_pointer(grp->rcvd_xid_skb);
   1394	grp->rcvd_xid_skb->len = 0;
   1395	grp->rcvd_xid_th = (struct th_header *)grp->rcvd_xid_skb->data;
   1396	skb_put_data(grp->rcvd_xid_skb, &thnorm, TH_HEADER_LENGTH);
   1397
   1398	if (grp->send_qllc_disc == 1) {
   1399		grp->send_qllc_disc = 0;
   1400		mpc_send_qllc_discontact(dev);
   1401	}
   1402
   1403	/* DO NOT issue DEV_EVENT_STOP directly out of this code */
   1404	/* This can result in INOP of VTAM PU due to halting of  */
   1405	/* outstanding IO which causes a sense to be returned	 */
   1406	/* Only about 3 senses are allowed and then IOS/VTAM will*/
   1407	/* become unreachable without manual intervention	 */
   1408	if ((grp->port_persist == 1) || (grp->alloc_called)) {
   1409		grp->alloc_called = 0;
   1410		fsm_deltimer(&priv->restart_timer);
   1411		fsm_addtimer(&priv->restart_timer, 500, DEV_EVENT_RESTART, dev);
   1412		fsm_newstate(grp->fsm, MPCG_STATE_RESET);
   1413		if (grp->saved_state > MPCG_STATE_XID7INITF)
   1414			CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_ALWAYS,
   1415				"%s(%s): MPC GROUP RECOVERY SCHEDULED",
   1416					CTCM_FUNTAIL, dev->name);
   1417	} else {
   1418		fsm_deltimer(&priv->restart_timer);
   1419		fsm_addtimer(&priv->restart_timer, 500, DEV_EVENT_STOP, dev);
   1420		fsm_newstate(grp->fsm, MPCG_STATE_RESET);
   1421		CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_ALWAYS,
   1422			"%s(%s): NO MPC GROUP RECOVERY ATTEMPTED",
   1423						CTCM_FUNTAIL, dev->name);
   1424	}
   1425}
   1426
   1427/*
   1428 * Handle mpc group  action timeout.
   1429 * MPC Group Station FSM action
   1430 * CTCM_PROTO_MPC only
   1431 *
   1432 * fi		An instance of an mpc_group fsm.
   1433 * event	The event, just happened.
   1434 * arg		Generic pointer, casted from net_device * upon call.
   1435 */
   1436static void mpc_action_timeout(fsm_instance *fi, int event, void *arg)
   1437{
   1438	struct net_device *dev = arg;
   1439	struct ctcm_priv *priv;
   1440	struct mpc_group *grp;
   1441	struct channel *wch;
   1442	struct channel *rch;
   1443
   1444	priv = dev->ml_priv;
   1445	grp = priv->mpcg;
   1446	wch = priv->channel[CTCM_WRITE];
   1447	rch = priv->channel[CTCM_READ];
   1448
   1449	switch (fsm_getstate(grp->fsm)) {
   1450	case MPCG_STATE_XID2INITW:
   1451		/* Unless there is outstanding IO on the  */
   1452		/* channel just return and wait for ATTN  */
   1453		/* interrupt to begin XID negotiations	  */
   1454		if ((fsm_getstate(rch->fsm) == CH_XID0_PENDING) &&
   1455		   (fsm_getstate(wch->fsm) == CH_XID0_PENDING))
   1456			break;
   1457		fallthrough;
   1458	default:
   1459		fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
   1460	}
   1461
   1462	CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_DEBUG,
   1463			"%s: dev=%s exit",
   1464			CTCM_FUNTAIL, dev->name);
   1465	return;
   1466}
   1467
   1468/*
   1469 * MPC Group Station FSM action
   1470 * CTCM_PROTO_MPC only
   1471 */
   1472void mpc_action_discontact(fsm_instance *fi, int event, void *arg)
   1473{
   1474	struct mpcg_info   *mpcginfo   = arg;
   1475	struct channel	   *ch	       = mpcginfo->ch;
   1476	struct net_device  *dev;
   1477	struct ctcm_priv   *priv;
   1478	struct mpc_group   *grp;
   1479
   1480	if (ch) {
   1481		dev = ch->netdev;
   1482		if (dev) {
   1483			priv = dev->ml_priv;
   1484			if (priv) {
   1485				CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_NOTICE,
   1486					"%s: %s: %s\n",
   1487					CTCM_FUNTAIL, dev->name, ch->id);
   1488				grp = priv->mpcg;
   1489				grp->send_qllc_disc = 1;
   1490				fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
   1491			}
   1492		}
   1493	}
   1494
   1495	return;
   1496}
   1497
   1498/*
   1499 * MPC Group Station - not part of FSM
   1500 * CTCM_PROTO_MPC only
   1501 * called from add_channel in ctcm_main.c
   1502 */
   1503void mpc_action_send_discontact(unsigned long thischan)
   1504{
   1505	int rc;
   1506	struct channel	*ch = (struct channel *)thischan;
   1507	unsigned long	saveflags = 0;
   1508
   1509	spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
   1510	rc = ccw_device_start(ch->cdev, &ch->ccw[15], 0, 0xff, 0);
   1511	spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
   1512
   1513	if (rc != 0) {
   1514		ctcm_ccw_check_rc(ch, rc, (char *)__func__);
   1515	}
   1516
   1517	return;
   1518}
   1519
   1520
   1521/*
   1522 * helper function of mpc FSM
   1523 * CTCM_PROTO_MPC only
   1524 * mpc_action_rcvd_xid7
   1525*/
   1526static int mpc_validate_xid(struct mpcg_info *mpcginfo)
   1527{
   1528	struct channel	   *ch	 = mpcginfo->ch;
   1529	struct net_device  *dev  = ch->netdev;
   1530	struct ctcm_priv   *priv = dev->ml_priv;
   1531	struct mpc_group   *grp  = priv->mpcg;
   1532	struct xid2	   *xid  = mpcginfo->xid;
   1533	int	rc	 = 0;
   1534	__u64	our_id   = 0;
   1535	__u64   their_id = 0;
   1536	int	len = TH_HEADER_LENGTH + PDU_HEADER_LENGTH;
   1537
   1538	CTCM_PR_DEBUG("Enter %s: xid=%p\n", __func__, xid);
   1539
   1540	if (xid == NULL) {
   1541		rc = 1;
   1542		/* XID REJECTED: xid == NULL */
   1543		CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
   1544			"%s(%s): xid = NULL",
   1545				CTCM_FUNTAIL, ch->id);
   1546			goto done;
   1547	}
   1548
   1549	CTCM_D3_DUMP((char *)xid, XID2_LENGTH);
   1550
   1551	/*the received direction should be the opposite of ours  */
   1552	if (((CHANNEL_DIRECTION(ch->flags) == CTCM_READ) ? XID2_WRITE_SIDE :
   1553				XID2_READ_SIDE) != xid->xid2_dlc_type) {
   1554		rc = 2;
   1555		/* XID REJECTED: r/w channel pairing mismatch */
   1556		CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
   1557			"%s(%s): r/w channel pairing mismatch",
   1558				CTCM_FUNTAIL, ch->id);
   1559			goto done;
   1560	}
   1561
   1562	if (xid->xid2_dlc_type == XID2_READ_SIDE) {
   1563		CTCM_PR_DEBUG("%s: grpmaxbuf:%d xid2buflen:%d\n", __func__,
   1564				grp->group_max_buflen, xid->xid2_buf_len);
   1565
   1566		if (grp->group_max_buflen == 0 || grp->group_max_buflen >
   1567						xid->xid2_buf_len - len)
   1568			grp->group_max_buflen = xid->xid2_buf_len - len;
   1569	}
   1570
   1571	if (grp->saved_xid2 == NULL) {
   1572		grp->saved_xid2 =
   1573			(struct xid2 *)skb_tail_pointer(grp->rcvd_xid_skb);
   1574
   1575		skb_put_data(grp->rcvd_xid_skb, xid, XID2_LENGTH);
   1576		grp->rcvd_xid_skb->data = grp->rcvd_xid_data;
   1577
   1578		skb_reset_tail_pointer(grp->rcvd_xid_skb);
   1579		grp->rcvd_xid_skb->len = 0;
   1580
   1581		/* convert two 32 bit numbers into 1 64 bit for id compare */
   1582		our_id = (__u64)priv->xid->xid2_adj_id;
   1583		our_id = our_id << 32;
   1584		our_id = our_id + priv->xid->xid2_sender_id;
   1585		their_id = (__u64)xid->xid2_adj_id;
   1586		their_id = their_id << 32;
   1587		their_id = their_id + xid->xid2_sender_id;
   1588		/* lower id assume the xside role */
   1589		if (our_id < their_id) {
   1590			grp->roll = XSIDE;
   1591			CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_NOTICE,
   1592				"%s(%s): WE HAVE LOW ID - TAKE XSIDE",
   1593					CTCM_FUNTAIL, ch->id);
   1594		} else {
   1595			grp->roll = YSIDE;
   1596			CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_NOTICE,
   1597				"%s(%s): WE HAVE HIGH ID - TAKE YSIDE",
   1598					CTCM_FUNTAIL, ch->id);
   1599		}
   1600
   1601	} else {
   1602		if (xid->xid2_flag4 != grp->saved_xid2->xid2_flag4) {
   1603			rc = 3;
   1604			/* XID REJECTED: xid flag byte4 mismatch */
   1605			CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
   1606				"%s(%s): xid flag byte4 mismatch",
   1607					CTCM_FUNTAIL, ch->id);
   1608		}
   1609		if (xid->xid2_flag2 == 0x40) {
   1610			rc = 4;
   1611			/* XID REJECTED - xid NOGOOD */
   1612			CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
   1613				"%s(%s): xid NOGOOD",
   1614					CTCM_FUNTAIL, ch->id);
   1615		}
   1616		if (xid->xid2_adj_id != grp->saved_xid2->xid2_adj_id) {
   1617			rc = 5;
   1618			/* XID REJECTED - Adjacent Station ID Mismatch */
   1619			CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
   1620				"%s(%s): Adjacent Station ID Mismatch",
   1621					CTCM_FUNTAIL, ch->id);
   1622		}
   1623		if (xid->xid2_sender_id != grp->saved_xid2->xid2_sender_id) {
   1624			rc = 6;
   1625			/* XID REJECTED - Sender Address Mismatch */
   1626			CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
   1627				"%s(%s): Sender Address Mismatch",
   1628					CTCM_FUNTAIL, ch->id);
   1629		}
   1630	}
   1631done:
   1632	if (rc) {
   1633		dev_warn(&dev->dev,
   1634			"The XID used in the MPC protocol is not valid, "
   1635			"rc = %d\n", rc);
   1636		priv->xid->xid2_flag2 = 0x40;
   1637		grp->saved_xid2->xid2_flag2 = 0x40;
   1638	}
   1639
   1640	return rc;
   1641}
   1642
   1643/*
   1644 * MPC Group Station FSM action
   1645 * CTCM_PROTO_MPC only
   1646 */
   1647static void mpc_action_side_xid(fsm_instance *fsm, void *arg, int side)
   1648{
   1649	struct channel *ch = arg;
   1650	int rc = 0;
   1651	int gotlock = 0;
   1652	unsigned long saveflags = 0;	/* avoids compiler warning with
   1653					   spin_unlock_irqrestore */
   1654
   1655	CTCM_PR_DEBUG("Enter %s: cp=%i ch=0x%p id=%s\n",
   1656			__func__, smp_processor_id(), ch, ch->id);
   1657
   1658	if (ctcm_checkalloc_buffer(ch))
   1659					goto done;
   1660
   1661	/*
   1662	 * skb data-buffer referencing:
   1663	 */
   1664	ch->trans_skb->data = ch->trans_skb_data;
   1665	skb_reset_tail_pointer(ch->trans_skb);
   1666	ch->trans_skb->len = 0;
   1667	/* result of the previous 3 statements is NOT always
   1668	 * already set after ctcm_checkalloc_buffer
   1669	 * because of possible reuse of the trans_skb
   1670	 */
   1671	memset(ch->trans_skb->data, 0, 16);
   1672	ch->rcvd_xid_th =  (struct th_header *)ch->trans_skb_data;
   1673	/* check is main purpose here: */
   1674	skb_put(ch->trans_skb, TH_HEADER_LENGTH);
   1675	ch->rcvd_xid = (struct xid2 *)skb_tail_pointer(ch->trans_skb);
   1676	/* check is main purpose here: */
   1677	skb_put(ch->trans_skb, XID2_LENGTH);
   1678	ch->rcvd_xid_id = skb_tail_pointer(ch->trans_skb);
   1679	/* cleanup back to startpoint */
   1680	ch->trans_skb->data = ch->trans_skb_data;
   1681	skb_reset_tail_pointer(ch->trans_skb);
   1682	ch->trans_skb->len = 0;
   1683
   1684	/* non-checking rewrite of above skb data-buffer referencing: */
   1685	/*
   1686	memset(ch->trans_skb->data, 0, 16);
   1687	ch->rcvd_xid_th =  (struct th_header *)ch->trans_skb_data;
   1688	ch->rcvd_xid = (struct xid2 *)(ch->trans_skb_data + TH_HEADER_LENGTH);
   1689	ch->rcvd_xid_id = ch->trans_skb_data + TH_HEADER_LENGTH + XID2_LENGTH;
   1690	 */
   1691
   1692	ch->ccw[8].flags	= CCW_FLAG_SLI | CCW_FLAG_CC;
   1693	ch->ccw[8].count	= 0;
   1694	ch->ccw[8].cda		= 0x00;
   1695
   1696	if (!(ch->xid_th && ch->xid && ch->xid_id))
   1697		CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_INFO,
   1698			"%s(%s): xid_th=%p, xid=%p, xid_id=%p",
   1699			CTCM_FUNTAIL, ch->id, ch->xid_th, ch->xid, ch->xid_id);
   1700
   1701	if (side == XSIDE) {
   1702		/* mpc_action_xside_xid */
   1703		if (ch->xid_th == NULL)
   1704				goto done;
   1705		ch->ccw[9].cmd_code	= CCW_CMD_WRITE;
   1706		ch->ccw[9].flags	= CCW_FLAG_SLI | CCW_FLAG_CC;
   1707		ch->ccw[9].count	= TH_HEADER_LENGTH;
   1708		ch->ccw[9].cda		= virt_to_phys(ch->xid_th);
   1709
   1710		if (ch->xid == NULL)
   1711				goto done;
   1712		ch->ccw[10].cmd_code	= CCW_CMD_WRITE;
   1713		ch->ccw[10].flags	= CCW_FLAG_SLI | CCW_FLAG_CC;
   1714		ch->ccw[10].count	= XID2_LENGTH;
   1715		ch->ccw[10].cda		= virt_to_phys(ch->xid);
   1716
   1717		ch->ccw[11].cmd_code	= CCW_CMD_READ;
   1718		ch->ccw[11].flags	= CCW_FLAG_SLI | CCW_FLAG_CC;
   1719		ch->ccw[11].count	= TH_HEADER_LENGTH;
   1720		ch->ccw[11].cda		= virt_to_phys(ch->rcvd_xid_th);
   1721
   1722		ch->ccw[12].cmd_code	= CCW_CMD_READ;
   1723		ch->ccw[12].flags	= CCW_FLAG_SLI | CCW_FLAG_CC;
   1724		ch->ccw[12].count	= XID2_LENGTH;
   1725		ch->ccw[12].cda		= virt_to_phys(ch->rcvd_xid);
   1726
   1727		ch->ccw[13].cmd_code	= CCW_CMD_READ;
   1728		ch->ccw[13].cda		= virt_to_phys(ch->rcvd_xid_id);
   1729
   1730	} else { /* side == YSIDE : mpc_action_yside_xid */
   1731		ch->ccw[9].cmd_code	= CCW_CMD_READ;
   1732		ch->ccw[9].flags	= CCW_FLAG_SLI | CCW_FLAG_CC;
   1733		ch->ccw[9].count	= TH_HEADER_LENGTH;
   1734		ch->ccw[9].cda		= virt_to_phys(ch->rcvd_xid_th);
   1735
   1736		ch->ccw[10].cmd_code	= CCW_CMD_READ;
   1737		ch->ccw[10].flags	= CCW_FLAG_SLI | CCW_FLAG_CC;
   1738		ch->ccw[10].count	= XID2_LENGTH;
   1739		ch->ccw[10].cda		= virt_to_phys(ch->rcvd_xid);
   1740
   1741		if (ch->xid_th == NULL)
   1742				goto done;
   1743		ch->ccw[11].cmd_code	= CCW_CMD_WRITE;
   1744		ch->ccw[11].flags	= CCW_FLAG_SLI | CCW_FLAG_CC;
   1745		ch->ccw[11].count	= TH_HEADER_LENGTH;
   1746		ch->ccw[11].cda		= virt_to_phys(ch->xid_th);
   1747
   1748		if (ch->xid == NULL)
   1749				goto done;
   1750		ch->ccw[12].cmd_code	= CCW_CMD_WRITE;
   1751		ch->ccw[12].flags	= CCW_FLAG_SLI | CCW_FLAG_CC;
   1752		ch->ccw[12].count	= XID2_LENGTH;
   1753		ch->ccw[12].cda		= virt_to_phys(ch->xid);
   1754
   1755		if (ch->xid_id == NULL)
   1756				goto done;
   1757		ch->ccw[13].cmd_code	= CCW_CMD_WRITE;
   1758		ch->ccw[13].cda		= virt_to_phys(ch->xid_id);
   1759
   1760	}
   1761	ch->ccw[13].flags	= CCW_FLAG_SLI | CCW_FLAG_CC;
   1762	ch->ccw[13].count	= 4;
   1763
   1764	ch->ccw[14].cmd_code	= CCW_CMD_NOOP;
   1765	ch->ccw[14].flags	= CCW_FLAG_SLI;
   1766	ch->ccw[14].count	= 0;
   1767	ch->ccw[14].cda		= 0;
   1768
   1769	CTCM_CCW_DUMP((char *)&ch->ccw[8], sizeof(struct ccw1) * 7);
   1770	CTCM_D3_DUMP((char *)ch->xid_th, TH_HEADER_LENGTH);
   1771	CTCM_D3_DUMP((char *)ch->xid, XID2_LENGTH);
   1772	CTCM_D3_DUMP((char *)ch->xid_id, 4);
   1773
   1774	if (!in_hardirq()) {
   1775			 /* Such conditional locking is a known problem for
   1776			  * sparse because its static undeterministic.
   1777			  * Warnings should be ignored here. */
   1778		spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
   1779		gotlock = 1;
   1780	}
   1781
   1782	fsm_addtimer(&ch->timer, 5000 , CTC_EVENT_TIMER, ch);
   1783	rc = ccw_device_start(ch->cdev, &ch->ccw[8], 0, 0xff, 0);
   1784
   1785	if (gotlock)	/* see remark above about conditional locking */
   1786		spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
   1787
   1788	if (rc != 0) {
   1789		ctcm_ccw_check_rc(ch, rc,
   1790				(side == XSIDE) ? "x-side XID" : "y-side XID");
   1791	}
   1792
   1793done:
   1794	CTCM_PR_DEBUG("Exit %s: ch=0x%p id=%s\n",
   1795				__func__, ch, ch->id);
   1796	return;
   1797
   1798}
   1799
   1800/*
   1801 * MPC Group Station FSM action
   1802 * CTCM_PROTO_MPC only
   1803 */
   1804static void mpc_action_xside_xid(fsm_instance *fsm, int event, void *arg)
   1805{
   1806	mpc_action_side_xid(fsm, arg, XSIDE);
   1807}
   1808
   1809/*
   1810 * MPC Group Station FSM action
   1811 * CTCM_PROTO_MPC only
   1812 */
   1813static void mpc_action_yside_xid(fsm_instance *fsm, int event, void *arg)
   1814{
   1815	mpc_action_side_xid(fsm, arg, YSIDE);
   1816}
   1817
   1818/*
   1819 * MPC Group Station FSM action
   1820 * CTCM_PROTO_MPC only
   1821 */
   1822static void mpc_action_doxid0(fsm_instance *fsm, int event, void *arg)
   1823{
   1824	struct channel	   *ch   = arg;
   1825	struct net_device  *dev  = ch->netdev;
   1826	struct ctcm_priv   *priv = dev->ml_priv;
   1827	struct mpc_group   *grp  = priv->mpcg;
   1828
   1829	CTCM_PR_DEBUG("Enter %s: cp=%i ch=0x%p id=%s\n",
   1830			__func__, smp_processor_id(), ch, ch->id);
   1831
   1832	if (ch->xid == NULL) {
   1833		CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
   1834			"%s(%s): ch->xid == NULL",
   1835				CTCM_FUNTAIL, dev->name);
   1836		return;
   1837	}
   1838
   1839	fsm_newstate(ch->fsm, CH_XID0_INPROGRESS);
   1840
   1841	ch->xid->xid2_option =	XID2_0;
   1842
   1843	switch (fsm_getstate(grp->fsm)) {
   1844	case MPCG_STATE_XID2INITW:
   1845	case MPCG_STATE_XID2INITX:
   1846		ch->ccw[8].cmd_code = CCW_CMD_SENSE_CMD;
   1847		break;
   1848	case MPCG_STATE_XID0IOWAIT:
   1849	case MPCG_STATE_XID0IOWAIX:
   1850		ch->ccw[8].cmd_code = CCW_CMD_WRITE_CTL;
   1851		break;
   1852	}
   1853
   1854	fsm_event(grp->fsm, MPCG_EVENT_DOIO, ch);
   1855
   1856	return;
   1857}
   1858
   1859/*
   1860 * MPC Group Station FSM action
   1861 * CTCM_PROTO_MPC only
   1862*/
   1863static void mpc_action_doxid7(fsm_instance *fsm, int event, void *arg)
   1864{
   1865	struct net_device *dev = arg;
   1866	struct ctcm_priv  *priv = dev->ml_priv;
   1867	struct mpc_group  *grp  = NULL;
   1868	int direction;
   1869	int send = 0;
   1870
   1871	if (priv)
   1872		grp = priv->mpcg;
   1873	if (grp == NULL)
   1874		return;
   1875
   1876	for (direction = CTCM_READ; direction <= CTCM_WRITE; direction++) {
   1877		struct channel *ch = priv->channel[direction];
   1878		struct xid2 *thisxid = ch->xid;
   1879		ch->xid_skb->data = ch->xid_skb_data;
   1880		skb_reset_tail_pointer(ch->xid_skb);
   1881		ch->xid_skb->len = 0;
   1882		thisxid->xid2_option = XID2_7;
   1883		send = 0;
   1884
   1885		/* xid7 phase 1 */
   1886		if (grp->outstanding_xid7_p2 > 0) {
   1887			if (grp->roll == YSIDE) {
   1888				if (fsm_getstate(ch->fsm) == CH_XID7_PENDING1) {
   1889					fsm_newstate(ch->fsm, CH_XID7_PENDING2);
   1890					ch->ccw[8].cmd_code = CCW_CMD_SENSE_CMD;
   1891					skb_put_data(ch->xid_skb, &thdummy,
   1892						     TH_HEADER_LENGTH);
   1893					send = 1;
   1894				}
   1895			} else if (fsm_getstate(ch->fsm) < CH_XID7_PENDING2) {
   1896					fsm_newstate(ch->fsm, CH_XID7_PENDING2);
   1897					ch->ccw[8].cmd_code = CCW_CMD_WRITE_CTL;
   1898					skb_put_data(ch->xid_skb, &thnorm,
   1899						     TH_HEADER_LENGTH);
   1900					send = 1;
   1901			}
   1902		} else {
   1903			/* xid7 phase 2 */
   1904			if (grp->roll == YSIDE) {
   1905				if (fsm_getstate(ch->fsm) < CH_XID7_PENDING4) {
   1906					fsm_newstate(ch->fsm, CH_XID7_PENDING4);
   1907					skb_put_data(ch->xid_skb, &thnorm,
   1908						     TH_HEADER_LENGTH);
   1909					ch->ccw[8].cmd_code = CCW_CMD_WRITE_CTL;
   1910					send = 1;
   1911				}
   1912			} else if (fsm_getstate(ch->fsm) == CH_XID7_PENDING3) {
   1913				fsm_newstate(ch->fsm, CH_XID7_PENDING4);
   1914				ch->ccw[8].cmd_code = CCW_CMD_SENSE_CMD;
   1915				skb_put_data(ch->xid_skb, &thdummy,
   1916					     TH_HEADER_LENGTH);
   1917				send = 1;
   1918			}
   1919		}
   1920
   1921		if (send)
   1922			fsm_event(grp->fsm, MPCG_EVENT_DOIO, ch);
   1923	}
   1924
   1925	return;
   1926}
   1927
   1928/*
   1929 * MPC Group Station FSM action
   1930 * CTCM_PROTO_MPC only
   1931 */
   1932static void mpc_action_rcvd_xid0(fsm_instance *fsm, int event, void *arg)
   1933{
   1934
   1935	struct mpcg_info   *mpcginfo  = arg;
   1936	struct channel	   *ch   = mpcginfo->ch;
   1937	struct net_device  *dev  = ch->netdev;
   1938	struct ctcm_priv   *priv = dev->ml_priv;
   1939	struct mpc_group   *grp  = priv->mpcg;
   1940
   1941	CTCM_PR_DEBUG("%s: ch-id:%s xid2:%i xid7:%i xidt_p2:%i \n",
   1942			__func__, ch->id, grp->outstanding_xid2,
   1943			grp->outstanding_xid7, grp->outstanding_xid7_p2);
   1944
   1945	if (fsm_getstate(ch->fsm) < CH_XID7_PENDING)
   1946		fsm_newstate(ch->fsm, CH_XID7_PENDING);
   1947
   1948	grp->outstanding_xid2--;
   1949	grp->outstanding_xid7++;
   1950	grp->outstanding_xid7_p2++;
   1951
   1952	/* must change state before validating xid to */
   1953	/* properly handle interim interrupts received*/
   1954	switch (fsm_getstate(grp->fsm)) {
   1955	case MPCG_STATE_XID2INITW:
   1956		fsm_newstate(grp->fsm, MPCG_STATE_XID2INITX);
   1957		mpc_validate_xid(mpcginfo);
   1958		break;
   1959	case MPCG_STATE_XID0IOWAIT:
   1960		fsm_newstate(grp->fsm, MPCG_STATE_XID0IOWAIX);
   1961		mpc_validate_xid(mpcginfo);
   1962		break;
   1963	case MPCG_STATE_XID2INITX:
   1964		if (grp->outstanding_xid2 == 0) {
   1965			fsm_newstate(grp->fsm, MPCG_STATE_XID7INITW);
   1966			mpc_validate_xid(mpcginfo);
   1967			fsm_event(grp->fsm, MPCG_EVENT_XID2DONE, dev);
   1968		}
   1969		break;
   1970	case MPCG_STATE_XID0IOWAIX:
   1971		if (grp->outstanding_xid2 == 0) {
   1972			fsm_newstate(grp->fsm, MPCG_STATE_XID7INITI);
   1973			mpc_validate_xid(mpcginfo);
   1974			fsm_event(grp->fsm, MPCG_EVENT_XID2DONE, dev);
   1975		}
   1976		break;
   1977	}
   1978
   1979	CTCM_PR_DEBUG("ctcmpc:%s() %s xid2:%i xid7:%i xidt_p2:%i \n",
   1980		__func__, ch->id, grp->outstanding_xid2,
   1981		grp->outstanding_xid7, grp->outstanding_xid7_p2);
   1982	CTCM_PR_DEBUG("ctcmpc:%s() %s grpstate: %s chanstate: %s \n",
   1983		__func__, ch->id,
   1984		fsm_getstate_str(grp->fsm), fsm_getstate_str(ch->fsm));
   1985	return;
   1986
   1987}
   1988
   1989
   1990/*
   1991 * MPC Group Station FSM action
   1992 * CTCM_PROTO_MPC only
   1993 */
   1994static void mpc_action_rcvd_xid7(fsm_instance *fsm, int event, void *arg)
   1995{
   1996	struct mpcg_info   *mpcginfo   = arg;
   1997	struct channel	   *ch	       = mpcginfo->ch;
   1998	struct net_device  *dev        = ch->netdev;
   1999	struct ctcm_priv   *priv    = dev->ml_priv;
   2000	struct mpc_group   *grp     = priv->mpcg;
   2001
   2002	CTCM_PR_DEBUG("Enter %s: cp=%i ch=0x%p id=%s\n",
   2003		__func__, smp_processor_id(), ch, ch->id);
   2004	CTCM_PR_DEBUG("%s: outstanding_xid7: %i, outstanding_xid7_p2: %i\n",
   2005		__func__, grp->outstanding_xid7, grp->outstanding_xid7_p2);
   2006
   2007	grp->outstanding_xid7--;
   2008	ch->xid_skb->data = ch->xid_skb_data;
   2009	skb_reset_tail_pointer(ch->xid_skb);
   2010	ch->xid_skb->len = 0;
   2011
   2012	switch (fsm_getstate(grp->fsm)) {
   2013	case MPCG_STATE_XID7INITI:
   2014		fsm_newstate(grp->fsm, MPCG_STATE_XID7INITZ);
   2015		mpc_validate_xid(mpcginfo);
   2016		break;
   2017	case MPCG_STATE_XID7INITW:
   2018		fsm_newstate(grp->fsm, MPCG_STATE_XID7INITX);
   2019		mpc_validate_xid(mpcginfo);
   2020		break;
   2021	case MPCG_STATE_XID7INITZ:
   2022	case MPCG_STATE_XID7INITX:
   2023		if (grp->outstanding_xid7 == 0) {
   2024			if (grp->outstanding_xid7_p2 > 0) {
   2025				grp->outstanding_xid7 =
   2026					grp->outstanding_xid7_p2;
   2027				grp->outstanding_xid7_p2 = 0;
   2028			} else
   2029				fsm_newstate(grp->fsm, MPCG_STATE_XID7INITF);
   2030
   2031			mpc_validate_xid(mpcginfo);
   2032			fsm_event(grp->fsm, MPCG_EVENT_XID7DONE, dev);
   2033			break;
   2034		}
   2035		mpc_validate_xid(mpcginfo);
   2036		break;
   2037	}
   2038	return;
   2039}
   2040
   2041/*
   2042 * mpc_action helper of an MPC Group Station FSM action
   2043 * CTCM_PROTO_MPC only
   2044 */
   2045static int mpc_send_qllc_discontact(struct net_device *dev)
   2046{
   2047	struct sk_buff   *skb;
   2048	struct qllc      *qllcptr;
   2049	struct ctcm_priv *priv = dev->ml_priv;
   2050	struct mpc_group *grp = priv->mpcg;
   2051
   2052	CTCM_PR_DEBUG("%s: GROUP STATE: %s\n",
   2053		__func__, mpcg_state_names[grp->saved_state]);
   2054
   2055	switch (grp->saved_state) {
   2056	/*
   2057	 * establish conn callback function is
   2058	 * preferred method to report failure
   2059	 */
   2060	case MPCG_STATE_XID0IOWAIT:
   2061	case MPCG_STATE_XID0IOWAIX:
   2062	case MPCG_STATE_XID7INITI:
   2063	case MPCG_STATE_XID7INITZ:
   2064	case MPCG_STATE_XID2INITW:
   2065	case MPCG_STATE_XID2INITX:
   2066	case MPCG_STATE_XID7INITW:
   2067	case MPCG_STATE_XID7INITX:
   2068		if (grp->estconnfunc) {
   2069			grp->estconnfunc(grp->port_num, -1, 0);
   2070			grp->estconnfunc = NULL;
   2071			break;
   2072		}
   2073		fallthrough;
   2074	case MPCG_STATE_FLOWC:
   2075	case MPCG_STATE_READY:
   2076		grp->send_qllc_disc = 2;
   2077
   2078		skb = __dev_alloc_skb(sizeof(struct qllc), GFP_ATOMIC);
   2079		if (skb == NULL) {
   2080			CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
   2081				"%s(%s): skb allocation error",
   2082						CTCM_FUNTAIL, dev->name);
   2083			priv->stats.rx_dropped++;
   2084			return -ENOMEM;
   2085		}
   2086
   2087		qllcptr = skb_put(skb, sizeof(struct qllc));
   2088		qllcptr->qllc_address = 0xcc;
   2089		qllcptr->qllc_commands = 0x03;
   2090
   2091		if (skb_headroom(skb) < 4) {
   2092			CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
   2093				"%s(%s): skb_headroom error",
   2094						CTCM_FUNTAIL, dev->name);
   2095			dev_kfree_skb_any(skb);
   2096			return -ENOMEM;
   2097		}
   2098
   2099		*((__u32 *)skb_push(skb, 4)) =
   2100			priv->channel[CTCM_READ]->pdu_seq;
   2101		priv->channel[CTCM_READ]->pdu_seq++;
   2102		CTCM_PR_DBGDATA("ctcmpc: %s ToDCM_pdu_seq= %08x\n",
   2103				__func__, priv->channel[CTCM_READ]->pdu_seq);
   2104
   2105		/* receipt of CC03 resets anticipated sequence number on
   2106		      receiving side */
   2107		priv->channel[CTCM_READ]->pdu_seq = 0x00;
   2108		skb_reset_mac_header(skb);
   2109		skb->dev = dev;
   2110		skb->protocol = htons(ETH_P_SNAP);
   2111		skb->ip_summed = CHECKSUM_UNNECESSARY;
   2112
   2113		CTCM_D3_DUMP(skb->data, (sizeof(struct qllc) + 4));
   2114
   2115		netif_rx(skb);
   2116		break;
   2117	default:
   2118		break;
   2119
   2120	}
   2121
   2122	return 0;
   2123}
   2124/* --- This is the END my friend --- */
   2125