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