drivers/s390/net/ctcm_mpc.c

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