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