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