drivers/s390/net/ctcmain.c

   1 /*
   2  * CTC / ESCON network driver
   3  *
   4  * Copyright (C) 2001 IBM Deutschland Entwicklung GmbH, IBM Corporation
   5  * Author(s): Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com)
   6  * Fixes by : Jochen Röhrig (roehrig@de.ibm.com)
   7  *            Arnaldo Carvalho de Melo <acme@conectiva.com.br>
   8               Peter Tiedemann (ptiedem@de.ibm.com)
   9  * Driver Model stuff by : Cornelia Huck <cornelia.huck@de.ibm.com>
  10  *
  11  * Documentation used:
  12  *  - Principles of Operation (IBM doc#: SA22-7201-06)
  13  *  - Common IO/-Device Commands and Self Description (IBM doc#: SA22-7204-02)
  14  *  - Common IO/-Device Commands and Self Description (IBM doc#: SN22-5535)
  15  *  - ESCON Channel-to-Channel Adapter (IBM doc#: SA22-7203-00)
  16  *  - ESCON I/O Interface (IBM doc#: SA22-7202-029
  17  *
  18  * and the source of the original CTC driver by:
  19  *  Dieter Wellerdiek (wel@de.ibm.com)
  20  *  Martin Schwidefsky (schwidefsky@de.ibm.com)
  21  *  Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
  22  *  Jochen Röhrig (roehrig@de.ibm.com)
  23  *
  24  * This program is free software; you can redistribute it and/or modify
  25  * it under the terms of the GNU General Public License as published by
  26  * the Free Software Foundation; either version 2, or (at your option)
  27  * any later version.
  28  *
  29  * This program is distributed in the hope that it will be useful,
  30  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  31  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  32  * GNU General Public License for more details.
  33  *
  34  * You should have received a copy of the GNU General Public License
  35  * along with this program; if not, write to the Free Software
  36  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  37  *
  38  */
  39 #undef DEBUG
  40 #include <linux/module.h>
  41 #include <linux/init.h>
  42 #include <linux/kernel.h>
  43 #include <linux/slab.h>
  44 #include <linux/errno.h>
  45 #include <linux/types.h>
  46 #include <linux/interrupt.h>
  47 #include <linux/timer.h>
  48 #include <linux/bitops.h>
  49
  50 #include <linux/signal.h>
  51 #include <linux/string.h>
  52
  53 #include <linux/ip.h>
  54 #include <linux/if_arp.h>
  55 #include <linux/tcp.h>
  56 #include <linux/skbuff.h>
  57 #include <linux/ctype.h>
  58 #include <net/dst.h>
  59
  60 #include <asm/io.h>
  61 #include <asm/ccwdev.h>
  62 #include <asm/ccwgroup.h>
  63 #include <asm/uaccess.h>
  64
  65 #include <asm/idals.h>
  66
  67 #include "fsm.h"
  68 #include "cu3088.h"
  69
  70 #include "ctcdbug.h"
  71 #include "ctcmain.h"
  72
  73 MODULE_AUTHOR("(C) 2000 IBM Corp. by Fritz Elfert (felfert@millenux.com)");
  74 MODULE_DESCRIPTION("Linux for S/390 CTC/Escon Driver");
  75 MODULE_LICENSE("GPL");
  76 /**
  77  * States of the interface statemachine.
  78  */
  79 enum dev_states {
  80         DEV_STATE_STOPPED,
  81         DEV_STATE_STARTWAIT_RXTX,
  82         DEV_STATE_STARTWAIT_RX,
  83         DEV_STATE_STARTWAIT_TX,
  84         DEV_STATE_STOPWAIT_RXTX,
  85         DEV_STATE_STOPWAIT_RX,
  86         DEV_STATE_STOPWAIT_TX,
  87         DEV_STATE_RUNNING,
  88         /**
  89          * MUST be always the last element!!
  90          */
  91         CTC_NR_DEV_STATES
  92 };
  93
  94 static const char *dev_state_names[] = {
  95         "Stopped",
  96         "StartWait RXTX",
  97         "StartWait RX",
  98         "StartWait TX",
  99         "StopWait RXTX",
 100         "StopWait RX",
 101         "StopWait TX",
 102         "Running",
 103 };
 104
 105 /**
 106  * Events of the interface statemachine.
 107  */
 108 enum dev_events {
 109         DEV_EVENT_START,
 110         DEV_EVENT_STOP,
 111         DEV_EVENT_RXUP,
 112         DEV_EVENT_TXUP,
 113         DEV_EVENT_RXDOWN,
 114         DEV_EVENT_TXDOWN,
 115         DEV_EVENT_RESTART,
 116         /**
 117          * MUST be always the last element!!
 118          */
 119         CTC_NR_DEV_EVENTS
 120 };
 121
 122 static const char *dev_event_names[] = {
 123         "Start",
 124         "Stop",
 125         "RX up",
 126         "TX up",
 127         "RX down",
 128         "TX down",
 129         "Restart",
 130 };
 131
 132 /**
 133  * Events of the channel statemachine
 134  */
 135 enum ch_events {
 136         /**
 137          * Events, representing return code of
 138          * I/O operations (ccw_device_start, ccw_device_halt et al.)
 139          */
 140         CH_EVENT_IO_SUCCESS,
 141         CH_EVENT_IO_EBUSY,
 142         CH_EVENT_IO_ENODEV,
 143         CH_EVENT_IO_EIO,
 144         CH_EVENT_IO_UNKNOWN,
 145
 146         CH_EVENT_ATTNBUSY,
 147         CH_EVENT_ATTN,
 148         CH_EVENT_BUSY,
 149
 150         /**
 151          * Events, representing unit-check
 152          */
 153         CH_EVENT_UC_RCRESET,
 154         CH_EVENT_UC_RSRESET,
 155         CH_EVENT_UC_TXTIMEOUT,
 156         CH_EVENT_UC_TXPARITY,
 157         CH_EVENT_UC_HWFAIL,
 158         CH_EVENT_UC_RXPARITY,
 159         CH_EVENT_UC_ZERO,
 160         CH_EVENT_UC_UNKNOWN,
 161
 162         /**
 163          * Events, representing subchannel-check
 164          */
 165         CH_EVENT_SC_UNKNOWN,
 166
 167         /**
 168          * Events, representing machine checks
 169          */
 170         CH_EVENT_MC_FAIL,
 171         CH_EVENT_MC_GOOD,
 172
 173         /**
 174          * Event, representing normal IRQ
 175          */
 176         CH_EVENT_IRQ,
 177         CH_EVENT_FINSTAT,
 178
 179         /**
 180          * Event, representing timer expiry.
 181          */
 182         CH_EVENT_TIMER,
 183
 184         /**
 185          * Events, representing commands from upper levels.
 186          */
 187         CH_EVENT_START,
 188         CH_EVENT_STOP,
 189
 190         /**
 191          * MUST be always the last element!!
 192          */
 193         NR_CH_EVENTS,
 194 };
 195
 196 /**
 197  * States of the channel statemachine.
 198  */
 199 enum ch_states {
 200         /**
 201          * Channel not assigned to any device,
 202          * initial state, direction invalid
 203          */
 204         CH_STATE_IDLE,
 205
 206         /**
 207          * Channel assigned but not operating
 208          */
 209         CH_STATE_STOPPED,
 210         CH_STATE_STARTWAIT,
 211         CH_STATE_STARTRETRY,
 212         CH_STATE_SETUPWAIT,
 213         CH_STATE_RXINIT,
 214         CH_STATE_TXINIT,
 215         CH_STATE_RX,
 216         CH_STATE_TX,
 217         CH_STATE_RXIDLE,
 218         CH_STATE_TXIDLE,
 219         CH_STATE_RXERR,
 220         CH_STATE_TXERR,
 221         CH_STATE_TERM,
 222         CH_STATE_DTERM,
 223         CH_STATE_NOTOP,
 224
 225         /**
 226          * MUST be always the last element!!
 227          */
 228         NR_CH_STATES,
 229 };
 230
 231 static int loglevel = CTC_LOGLEVEL_DEFAULT;
 232
 233 /**
 234  * Linked list of all detected channels.
 235  */
 236 static struct channel *channels = NULL;
 237
 238 /**
 239  * Print Banner.
 240  */
 241 static void
 242 print_banner(void)
 243 {
 244         static int printed = 0;
 245
 246         if (printed)
 247                 return;
 248
 249         printk(KERN_INFO "CTC driver initialized\n");
 250         printed = 1;
 251 }
 252
 253 /**
 254  * Return type of a detected device.
 255  */
 256 static enum channel_types
 257 get_channel_type(struct ccw_device_id *id)
 258 {
 259         enum channel_types type = (enum channel_types) id->driver_info;
 260
 261         if (type == channel_type_ficon)
 262                 type = channel_type_escon;
 263
 264         return type;
 265 }
 266
 267 static const char *ch_event_names[] = {
 268         "ccw_device success",
 269         "ccw_device busy",
 270         "ccw_device enodev",
 271         "ccw_device ioerr",
 272         "ccw_device unknown",
 273
 274         "Status ATTN & BUSY",
 275         "Status ATTN",
 276         "Status BUSY",
 277
 278         "Unit check remote reset",
 279         "Unit check remote system reset",
 280         "Unit check TX timeout",
 281         "Unit check TX parity",
 282         "Unit check Hardware failure",
 283         "Unit check RX parity",
 284         "Unit check ZERO",
 285         "Unit check Unknown",
 286
 287         "SubChannel check Unknown",
 288
 289         "Machine check failure",
 290         "Machine check operational",
 291
 292         "IRQ normal",
 293         "IRQ final",
 294
 295         "Timer",
 296
 297         "Start",
 298         "Stop",
 299 };
 300
 301 static const char *ch_state_names[] = {
 302         "Idle",
 303         "Stopped",
 304         "StartWait",
 305         "StartRetry",
 306         "SetupWait",
 307         "RX init",
 308         "TX init",
 309         "RX",
 310         "TX",
 311         "RX idle",
 312         "TX idle",
 313         "RX error",
 314         "TX error",
 315         "Terminating",
 316         "Restarting",
 317         "Not operational",
 318 };
 319
 320 #ifdef DEBUG
 321 /**
 322  * Dump header and first 16 bytes of an sk_buff for debugging purposes.
 323  *
 324  * @param skb    The sk_buff to dump.
 325  * @param offset Offset relative to skb-data, where to start the dump.
 326  */
 327 static void
 328 ctc_dump_skb(struct sk_buff *skb, int offset)
 329 {
 330         unsigned char *p = skb->data;
 331         __u16 bl;
 332         struct ll_header *header;
 333         int i;
 334
 335         if (!(loglevel & CTC_LOGLEVEL_DEBUG))
 336                 return;
 337         p += offset;
 338         bl = *((__u16 *) p);
 339         p += 2;
 340         header = (struct ll_header *) p;
 341         p -= 2;
 342
 343         printk(KERN_DEBUG "dump:\n");
 344         printk(KERN_DEBUG "blocklen=%d %04x\n", bl, bl);
 345
 346         printk(KERN_DEBUG "h->length=%d %04x\n", header->length,
 347                header->length);
 348         printk(KERN_DEBUG "h->type=%04x\n", header->type);
 349         printk(KERN_DEBUG "h->unused=%04x\n", header->unused);
 350         if (bl > 16)
 351                 bl = 16;
 352         printk(KERN_DEBUG "data: ");
 353         for (i = 0; i < bl; i++)
 354                 printk("%02x%s", *p++, (i % 16) ? " " : "\n<7>");
 355         printk("\n");
 356 }
 357 #else
 358 static inline void
 359 ctc_dump_skb(struct sk_buff *skb, int offset)
 360 {
 361 }
 362 #endif
 363
 364 /**
 365  * Unpack a just received skb and hand it over to
 366  * upper layers.
 367  *
 368  * @param ch The channel where this skb has been received.
 369  * @param pskb The received skb.
 370  */
 371 static void
 372 ctc_unpack_skb(struct channel *ch, struct sk_buff *pskb)
 373 {
 374         struct net_device *dev = ch->netdev;
 375         struct ctc_priv *privptr = (struct ctc_priv *) dev->priv;
 376         __u16 len = *((__u16 *) pskb->data);
 377
 378         DBF_TEXT(trace, 4, __FUNCTION__);
 379         skb_put(pskb, 2 + LL_HEADER_LENGTH);
 380         skb_pull(pskb, 2);
 381         pskb->dev = dev;
 382         pskb->ip_summed = CHECKSUM_UNNECESSARY;
 383         while (len > 0) {
 384                 struct sk_buff *skb;
 385                 struct ll_header *header = (struct ll_header *) pskb->data;
 386
 387                 skb_pull(pskb, LL_HEADER_LENGTH);
 388                 if ((ch->protocol == CTC_PROTO_S390) &&
 389                     (header->type != ETH_P_IP)) {
 390
 391 #ifndef DEBUG
 392                         if (!(ch->logflags & LOG_FLAG_ILLEGALPKT)) {
 393 #endif
 394                                 /**
 395                                  * Check packet type only if we stick strictly
 396                                  * to S/390's protocol of OS390. This only
 397                                  * supports IP. Otherwise allow any packet
 398                                  * type.
 399                                  */
 400                                 ctc_pr_warn(
 401                                         "%s Illegal packet type 0x%04x received, dropping\n",
 402                                         dev->name, header->type);
 403                                 ch->logflags |= LOG_FLAG_ILLEGALPKT;
 404 #ifndef DEBUG
 405                         }
 406 #endif
 407 #ifdef DEBUG
 408                         ctc_dump_skb(pskb, -6);
 409 #endif
 410                         privptr->stats.rx_dropped++;
 411                         privptr->stats.rx_frame_errors++;
 412                         return;
 413                 }
 414                 pskb->protocol = ntohs(header->type);
 415                 if (header->length <= LL_HEADER_LENGTH) {
 416 #ifndef DEBUG
 417                         if (!(ch->logflags & LOG_FLAG_ILLEGALSIZE)) {
 418 #endif
 419                                 ctc_pr_warn(
 420                                        "%s Illegal packet size %d "
 421                                        "received (MTU=%d blocklen=%d), "
 422                                        "dropping\n", dev->name, header->length,
 423                                        dev->mtu, len);
 424                                 ch->logflags |= LOG_FLAG_ILLEGALSIZE;
 425 #ifndef DEBUG
 426                         }
 427 #endif
 428 #ifdef DEBUG
 429                         ctc_dump_skb(pskb, -6);
 430 #endif
 431                         privptr->stats.rx_dropped++;
 432                         privptr->stats.rx_length_errors++;
 433                         return;
 434                 }
 435                 header->length -= LL_HEADER_LENGTH;
 436                 len -= LL_HEADER_LENGTH;
 437                 if ((header->length > skb_tailroom(pskb)) ||
 438                     (header->length > len)) {
 439 #ifndef DEBUG
 440                         if (!(ch->logflags & LOG_FLAG_OVERRUN)) {
 441 #endif
 442                                 ctc_pr_warn(
 443                                         "%s Illegal packet size %d "
 444                                         "(beyond the end of received data), "
 445                                         "dropping\n", dev->name, header->length);
 446                                 ch->logflags |= LOG_FLAG_OVERRUN;
 447 #ifndef DEBUG
 448                         }
 449 #endif
 450 #ifdef DEBUG
 451                         ctc_dump_skb(pskb, -6);
 452 #endif
 453                         privptr->stats.rx_dropped++;
 454                         privptr->stats.rx_length_errors++;
 455                         return;
 456                 }
 457                 skb_put(pskb, header->length);
 458                 pskb->mac.raw = pskb->data;
 459                 len -= header->length;
 460                 skb = dev_alloc_skb(pskb->len);
 461                 if (!skb) {
 462 #ifndef DEBUG
 463                         if (!(ch->logflags & LOG_FLAG_NOMEM)) {
 464 #endif
 465                                 ctc_pr_warn(
 466                                         "%s Out of memory in ctc_unpack_skb\n",
 467                                         dev->name);
 468                                 ch->logflags |= LOG_FLAG_NOMEM;
 469 #ifndef DEBUG
 470                         }
 471 #endif
 472                         privptr->stats.rx_dropped++;
 473                         return;
 474                 }
 475                 memcpy(skb_put(skb, pskb->len), pskb->data, pskb->len);
 476                 skb->mac.raw = skb->data;
 477                 skb->dev = pskb->dev;
 478                 skb->protocol = pskb->protocol;
 479                 pskb->ip_summed = CHECKSUM_UNNECESSARY;
 480                 netif_rx_ni(skb);
 481                 /**
 482                  * Successful rx; reset logflags
 483                  */
 484                 ch->logflags = 0;
 485                 dev->last_rx = jiffies;
 486                 privptr->stats.rx_packets++;
 487                 privptr->stats.rx_bytes += skb->len;
 488                 if (len > 0) {
 489                         skb_pull(pskb, header->length);
 490                         if (skb_tailroom(pskb) < LL_HEADER_LENGTH) {
 491 #ifndef DEBUG
 492                                 if (!(ch->logflags & LOG_FLAG_OVERRUN)) {
 493 #endif
 494                                         ctc_pr_warn(
 495                                                 "%s Overrun in ctc_unpack_skb\n",
 496                                                 dev->name);
 497                                         ch->logflags |= LOG_FLAG_OVERRUN;
 498 #ifndef DEBUG
 499                                 }
 500 #endif
 501                                 return;
 502                         }
 503                         skb_put(pskb, LL_HEADER_LENGTH);
 504                 }
 505         }
 506 }
 507
 508 /**
 509  * Check return code of a preceeding ccw_device call, halt_IO etc...
 510  *
 511  * @param ch          The channel, the error belongs to.
 512  * @param return_code The error code to inspect.
 513  */
 514 static void
 515 ccw_check_return_code(struct channel *ch, int return_code, char *msg)
 516 {
 517         DBF_TEXT(trace, 5, __FUNCTION__);
 518         switch (return_code) {
 519                 case 0:
 520                         fsm_event(ch->fsm, CH_EVENT_IO_SUCCESS, ch);
 521                         break;
 522                 case -EBUSY:
 523                         ctc_pr_warn("%s (%s): Busy !\n", ch->id, msg);
 524                         fsm_event(ch->fsm, CH_EVENT_IO_EBUSY, ch);
 525                         break;
 526                 case -ENODEV:
 527                         ctc_pr_emerg("%s (%s): Invalid device called for IO\n",
 528                                      ch->id, msg);
 529                         fsm_event(ch->fsm, CH_EVENT_IO_ENODEV, ch);
 530                         break;
 531                 case -EIO:
 532                         ctc_pr_emerg("%s (%s): Status pending... \n",
 533                                      ch->id, msg);
 534                         fsm_event(ch->fsm, CH_EVENT_IO_EIO, ch);
 535                         break;
 536                 default:
 537                         ctc_pr_emerg("%s (%s): Unknown error in do_IO %04x\n",
 538                                      ch->id, msg, return_code);
 539                         fsm_event(ch->fsm, CH_EVENT_IO_UNKNOWN, ch);
 540         }
 541 }
 542
 543 /**
 544  * Check sense of a unit check.
 545  *
 546  * @param ch    The channel, the sense code belongs to.
 547  * @param sense The sense code to inspect.
 548  */
 549 static void
 550 ccw_unit_check(struct channel *ch, unsigned char sense)
 551 {
 552         DBF_TEXT(trace, 5, __FUNCTION__);
 553         if (sense & SNS0_INTERVENTION_REQ) {
 554                 if (sense & 0x01) {
 555                         ctc_pr_debug("%s: Interface disc. or Sel. reset "
 556                                         "(remote)\n", ch->id);
 557                         fsm_event(ch->fsm, CH_EVENT_UC_RCRESET, ch);
 558                 } else {
 559                         ctc_pr_debug("%s: System reset (remote)\n", ch->id);
 560                         fsm_event(ch->fsm, CH_EVENT_UC_RSRESET, ch);
 561                 }
 562         } else if (sense & SNS0_EQUIPMENT_CHECK) {
 563                 if (sense & SNS0_BUS_OUT_CHECK) {
 564                         ctc_pr_warn("%s: Hardware malfunction (remote)\n",
 565                                     ch->id);
 566                         fsm_event(ch->fsm, CH_EVENT_UC_HWFAIL, ch);
 567                 } else {
 568                         ctc_pr_warn("%s: Read-data parity error (remote)\n",
 569                                     ch->id);
 570                         fsm_event(ch->fsm, CH_EVENT_UC_RXPARITY, ch);
 571                 }
 572         } else if (sense & SNS0_BUS_OUT_CHECK) {
 573                 if (sense & 0x04) {
 574                         ctc_pr_warn("%s: Data-streaming timeout)\n", ch->id);
 575                         fsm_event(ch->fsm, CH_EVENT_UC_TXTIMEOUT, ch);
 576                 } else {
 577                         ctc_pr_warn("%s: Data-transfer parity error\n", ch->id);
 578                         fsm_event(ch->fsm, CH_EVENT_UC_TXPARITY, ch);
 579                 }
 580         } else if (sense & SNS0_CMD_REJECT) {
 581                 ctc_pr_warn("%s: Command reject\n", ch->id);
 582         } else if (sense == 0) {
 583                 ctc_pr_debug("%s: Unit check ZERO\n", ch->id);
 584                 fsm_event(ch->fsm, CH_EVENT_UC_ZERO, ch);
 585         } else {
 586                 ctc_pr_warn("%s: Unit Check with sense code: %02x\n",
 587                             ch->id, sense);
 588                 fsm_event(ch->fsm, CH_EVENT_UC_UNKNOWN, ch);
 589         }
 590 }
 591
 592 static void
 593 ctc_purge_skb_queue(struct sk_buff_head *q)
 594 {
 595         struct sk_buff *skb;
 596
 597         DBF_TEXT(trace, 5, __FUNCTION__);
 598
 599         while ((skb = skb_dequeue(q))) {
 600                 atomic_dec(&skb->users);
 601                 dev_kfree_skb_irq(skb);
 602         }
 603 }
 604
 605 static int
 606 ctc_checkalloc_buffer(struct channel *ch, int warn)
 607 {
 608         DBF_TEXT(trace, 5, __FUNCTION__);
 609         if ((ch->trans_skb == NULL) ||
 610             (ch->flags & CHANNEL_FLAGS_BUFSIZE_CHANGED)) {
 611                 if (ch->trans_skb != NULL)
 612                         dev_kfree_skb(ch->trans_skb);
 613                 clear_normalized_cda(&ch->ccw[1]);
 614                 ch->trans_skb = __dev_alloc_skb(ch->max_bufsize,
 615                                                 GFP_ATOMIC | GFP_DMA);
 616                 if (ch->trans_skb == NULL) {
 617                         if (warn)
 618                                 ctc_pr_warn(
 619                                         "%s: Couldn't alloc %s trans_skb\n",
 620                                         ch->id,
 621                                         (CHANNEL_DIRECTION(ch->flags) == READ) ?
 622                                         "RX" : "TX");
 623                         return -ENOMEM;
 624                 }
 625                 ch->ccw[1].count = ch->max_bufsize;
 626                 if (set_normalized_cda(&ch->ccw[1], ch->trans_skb->data)) {
 627                         dev_kfree_skb(ch->trans_skb);
 628                         ch->trans_skb = NULL;
 629                         if (warn)
 630                                 ctc_pr_warn(
 631                                         "%s: set_normalized_cda for %s "
 632                                         "trans_skb failed, dropping packets\n",
 633                                         ch->id,
 634                                         (CHANNEL_DIRECTION(ch->flags) == READ) ?
 635                                         "RX" : "TX");
 636                         return -ENOMEM;
 637                 }
 638                 ch->ccw[1].count = 0;
 639                 ch->trans_skb_data = ch->trans_skb->data;
 640                 ch->flags &= ~CHANNEL_FLAGS_BUFSIZE_CHANGED;
 641         }
 642         return 0;
 643 }
 644
 645 /**
 646  * Dummy NOP action for statemachines
 647  */
 648 static void
 649 fsm_action_nop(fsm_instance * fi, int event, void *arg)
 650 {
 651 }
 652
 653 /**
 654  * Actions for channel - statemachines.
 655  *****************************************************************************/
 656
 657 /**
 658  * Normal data has been send. Free the corresponding
 659  * skb (it's in io_queue), reset dev->tbusy and
 660  * revert to idle state.
 661  *
 662  * @param fi    An instance of a channel statemachine.
 663  * @param event The event, just happened.
 664  * @param arg   Generic pointer, casted from channel * upon call.
 665  */
 666 static void
 667 ch_action_txdone(fsm_instance * fi, int event, void *arg)
 668 {
 669         struct channel *ch = (struct channel *) arg;
 670         struct net_device *dev = ch->netdev;
 671         struct ctc_priv *privptr = dev->priv;
 672         struct sk_buff *skb;
 673         int first = 1;
 674         int i;
 675         unsigned long duration;
 676         struct timespec done_stamp = xtime;
 677
 678         DBF_TEXT(trace, 4, __FUNCTION__);
 679
 680         duration =
 681             (done_stamp.tv_sec - ch->prof.send_stamp.tv_sec) * 1000000 +
 682             (done_stamp.tv_nsec - ch->prof.send_stamp.tv_nsec) / 1000;
 683         if (duration > ch->prof.tx_time)
 684                 ch->prof.tx_time = duration;
 685
 686         if (ch->irb->scsw.count != 0)
 687                 ctc_pr_debug("%s: TX not complete, remaining %d bytes\n",
 688                              dev->name, ch->irb->scsw.count);
 689         fsm_deltimer(&ch->timer);
 690         while ((skb = skb_dequeue(&ch->io_queue))) {
 691                 privptr->stats.tx_packets++;
 692                 privptr->stats.tx_bytes += skb->len - LL_HEADER_LENGTH;
 693                 if (first) {
 694                         privptr->stats.tx_bytes += 2;
 695                         first = 0;
 696                 }
 697                 atomic_dec(&skb->users);
 698                 dev_kfree_skb_irq(skb);
 699         }
 700         spin_lock(&ch->collect_lock);
 701         clear_normalized_cda(&ch->ccw[4]);
 702         if (ch->collect_len > 0) {
 703                 int rc;
 704
 705                 if (ctc_checkalloc_buffer(ch, 1)) {
 706                         spin_unlock(&ch->collect_lock);
 707                         return;
 708                 }
 709                 ch->trans_skb->tail = ch->trans_skb->data = ch->trans_skb_data;
 710                 ch->trans_skb->len = 0;
 711                 if (ch->prof.maxmulti < (ch->collect_len + 2))
 712                         ch->prof.maxmulti = ch->collect_len + 2;
 713                 if (ch->prof.maxcqueue < skb_queue_len(&ch->collect_queue))
 714                         ch->prof.maxcqueue = skb_queue_len(&ch->collect_queue);
 715                 *((__u16 *) skb_put(ch->trans_skb, 2)) = ch->collect_len + 2;
 716                 i = 0;
 717                 while ((skb = skb_dequeue(&ch->collect_queue))) {
 718                         memcpy(skb_put(ch->trans_skb, skb->len), skb->data,
 719                                skb->len);
 720                         privptr->stats.tx_packets++;
 721                         privptr->stats.tx_bytes += skb->len - LL_HEADER_LENGTH;
 722                         atomic_dec(&skb->users);
 723                         dev_kfree_skb_irq(skb);
 724                         i++;
 725                 }
 726                 ch->collect_len = 0;
 727                 spin_unlock(&ch->collect_lock);
 728                 ch->ccw[1].count = ch->trans_skb->len;
 729                 fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC, CH_EVENT_TIMER, ch);
 730                 ch->prof.send_stamp = xtime;
 731                 rc = ccw_device_start(ch->cdev, &ch->ccw[0],
 732                                       (unsigned long) ch, 0xff, 0);
 733                 ch->prof.doios_multi++;
 734                 if (rc != 0) {
 735                         privptr->stats.tx_dropped += i;
 736                         privptr->stats.tx_errors += i;
 737                         fsm_deltimer(&ch->timer);
 738                         ccw_check_return_code(ch, rc, "chained TX");
 739                 }
 740         } else {
 741                 spin_unlock(&ch->collect_lock);
 742                 fsm_newstate(fi, CH_STATE_TXIDLE);
 743         }
 744         ctc_clear_busy(dev);
 745 }
 746
 747 /**
 748  * Initial data is sent.
 749  * Notify device statemachine that we are up and
 750  * running.
 751  *
 752  * @param fi    An instance of a channel statemachine.
 753  * @param event The event, just happened.
 754  * @param arg   Generic pointer, casted from channel * upon call.
 755  */
 756 static void
 757 ch_action_txidle(fsm_instance * fi, int event, void *arg)
 758 {
 759         struct channel *ch = (struct channel *) arg;
 760
 761         DBF_TEXT(trace, 4, __FUNCTION__);
 762         fsm_deltimer(&ch->timer);
 763         fsm_newstate(fi, CH_STATE_TXIDLE);
 764         fsm_event(((struct ctc_priv *) ch->netdev->priv)->fsm, DEV_EVENT_TXUP,
 765                   ch->netdev);
 766 }
 767
 768 /**
 769  * Got normal data, check for sanity, queue it up, allocate new buffer
 770  * trigger bottom half, and initiate next read.
 771  *
 772  * @param fi    An instance of a channel statemachine.
 773  * @param event The event, just happened.
 774  * @param arg   Generic pointer, casted from channel * upon call.
 775  */
 776 static void
 777 ch_action_rx(fsm_instance * fi, int event, void *arg)
 778 {
 779         struct channel *ch = (struct channel *) arg;
 780         struct net_device *dev = ch->netdev;
 781         struct ctc_priv *privptr = dev->priv;
 782         int len = ch->max_bufsize - ch->irb->scsw.count;
 783         struct sk_buff *skb = ch->trans_skb;
 784         __u16 block_len = *((__u16 *) skb->data);
 785         int check_len;
 786         int rc;
 787
 788         DBF_TEXT(trace, 4, __FUNCTION__);
 789         fsm_deltimer(&ch->timer);
 790         if (len < 8) {
 791                 ctc_pr_debug("%s: got packet with length %d < 8\n",
 792                              dev->name, len);
 793                 privptr->stats.rx_dropped++;
 794                 privptr->stats.rx_length_errors++;
 795                 goto again;
 796         }
 797         if (len > ch->max_bufsize) {
 798                 ctc_pr_debug("%s: got packet with length %d > %d\n",
 799                              dev->name, len, ch->max_bufsize);
 800                 privptr->stats.rx_dropped++;
 801                 privptr->stats.rx_length_errors++;
 802                 goto again;
 803         }
 804
 805         /**
 806          * VM TCP seems to have a bug sending 2 trailing bytes of garbage.
 807          */
 808         switch (ch->protocol) {
 809                 case CTC_PROTO_S390:
 810                 case CTC_PROTO_OS390:
 811                         check_len = block_len + 2;
 812                         break;
 813                 default:
 814                         check_len = block_len;
 815                         break;
 816         }
 817         if ((len < block_len) || (len > check_len)) {
 818                 ctc_pr_debug("%s: got block length %d != rx length %d\n",
 819                              dev->name, block_len, len);
 820 #ifdef DEBUG
 821                 ctc_dump_skb(skb, 0);
 822 #endif
 823                 *((__u16 *) skb->data) = len;
 824                 privptr->stats.rx_dropped++;
 825                 privptr->stats.rx_length_errors++;
 826                 goto again;
 827         }
 828         block_len -= 2;
 829         if (block_len > 0) {
 830                 *((__u16 *) skb->data) = block_len;
 831                 ctc_unpack_skb(ch, skb);
 832         }
 833  again:
 834         skb->data = skb->tail = ch->trans_skb_data;
 835         skb->len = 0;
 836         if (ctc_checkalloc_buffer(ch, 1))
 837                 return;
 838         ch->ccw[1].count = ch->max_bufsize;
 839         rc = ccw_device_start(ch->cdev, &ch->ccw[0], (unsigned long) ch, 0xff, 0);
 840         if (rc != 0)
 841                 ccw_check_return_code(ch, rc, "normal RX");
 842 }
 843
 844 static void ch_action_rxidle(fsm_instance * fi, int event, void *arg);
 845
 846 /**
 847  * Initialize connection by sending a __u16 of value 0.
 848  *
 849  * @param fi    An instance of a channel statemachine.
 850  * @param event The event, just happened.
 851  * @param arg   Generic pointer, casted from channel * upon call.
 852  */
 853 static void
 854 ch_action_firstio(fsm_instance * fi, int event, void *arg)
 855 {
 856         struct channel *ch = (struct channel *) arg;
 857         int rc;
 858
 859         DBF_TEXT(trace, 4, __FUNCTION__);
 860
 861         if (fsm_getstate(fi) == CH_STATE_TXIDLE)
 862                 ctc_pr_debug("%s: remote side issued READ?, init ...\n", ch->id);
 863         fsm_deltimer(&ch->timer);
 864         if (ctc_checkalloc_buffer(ch, 1))
 865                 return;
 866         if ((fsm_getstate(fi) == CH_STATE_SETUPWAIT) &&
 867             (ch->protocol == CTC_PROTO_OS390)) {
 868                 /* OS/390 resp. z/OS */
 869                 if (CHANNEL_DIRECTION(ch->flags) == READ) {
 870                         *((__u16 *) ch->trans_skb->data) = CTC_INITIAL_BLOCKLEN;
 871                         fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC,
 872                                      CH_EVENT_TIMER, ch);
 873                         ch_action_rxidle(fi, event, arg);
 874                 } else {
 875                         struct net_device *dev = ch->netdev;
 876                         fsm_newstate(fi, CH_STATE_TXIDLE);
 877                         fsm_event(((struct ctc_priv *) dev->priv)->fsm,
 878                                   DEV_EVENT_TXUP, dev);
 879                 }
 880                 return;
 881         }
 882
 883         /**
 884          * Don´t setup a timer for receiving the initial RX frame
 885          * if in compatibility mode, since VM TCP delays the initial
 886          * frame until it has some data to send.
 887          */
 888         if ((CHANNEL_DIRECTION(ch->flags) == WRITE) ||
 889             (ch->protocol != CTC_PROTO_S390))
 890                 fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC, CH_EVENT_TIMER, ch);
 891
 892         *((__u16 *) ch->trans_skb->data) = CTC_INITIAL_BLOCKLEN;
 893         ch->ccw[1].count = 2;   /* Transfer only length */
 894
 895         fsm_newstate(fi, (CHANNEL_DIRECTION(ch->flags) == READ)
 896                      ? CH_STATE_RXINIT : CH_STATE_TXINIT);
 897         rc = ccw_device_start(ch->cdev, &ch->ccw[0], (unsigned long) ch, 0xff, 0);
 898         if (rc != 0) {
 899                 fsm_deltimer(&ch->timer);
 900                 fsm_newstate(fi, CH_STATE_SETUPWAIT);
 901                 ccw_check_return_code(ch, rc, "init IO");
 902         }
 903         /**
 904          * If in compatibility mode since we don´t setup a timer, we
 905          * also signal RX channel up immediately. This enables us
 906          * to send packets early which in turn usually triggers some
 907          * reply from VM TCP which brings up the RX channel to it´s
 908          * final state.
 909          */
 910         if ((CHANNEL_DIRECTION(ch->flags) == READ) &&
 911             (ch->protocol == CTC_PROTO_S390)) {
 912                 struct net_device *dev = ch->netdev;
 913                 fsm_event(((struct ctc_priv *) dev->priv)->fsm, DEV_EVENT_RXUP,
 914                           dev);
 915         }
 916 }
 917
 918 /**
 919  * Got initial data, check it. If OK,
 920  * notify device statemachine that we are up and
 921  * running.
 922  *
 923  * @param fi    An instance of a channel statemachine.
 924  * @param event The event, just happened.
 925  * @param arg   Generic pointer, casted from channel * upon call.
 926  */
 927 static void
 928 ch_action_rxidle(fsm_instance * fi, int event, void *arg)
 929 {
 930         struct channel *ch = (struct channel *) arg;
 931         struct net_device *dev = ch->netdev;
 932         __u16 buflen;
 933         int rc;
 934
 935         DBF_TEXT(trace, 4, __FUNCTION__);
 936         fsm_deltimer(&ch->timer);
 937         buflen = *((__u16 *) ch->trans_skb->data);
 938 #ifdef DEBUG
 939         ctc_pr_debug("%s: Initial RX count %d\n", dev->name, buflen);
 940 #endif
 941         if (buflen >= CTC_INITIAL_BLOCKLEN) {
 942                 if (ctc_checkalloc_buffer(ch, 1))
 943                         return;
 944                 ch->ccw[1].count = ch->max_bufsize;
 945                 fsm_newstate(fi, CH_STATE_RXIDLE);
 946                 rc = ccw_device_start(ch->cdev, &ch->ccw[0],
 947                                       (unsigned long) ch, 0xff, 0);
 948                 if (rc != 0) {
 949                         fsm_newstate(fi, CH_STATE_RXINIT);
 950                         ccw_check_return_code(ch, rc, "initial RX");
 951                 } else
 952                         fsm_event(((struct ctc_priv *) dev->priv)->fsm,
 953                                   DEV_EVENT_RXUP, dev);
 954         } else {
 955                 ctc_pr_debug("%s: Initial RX count %d not %d\n",
 956                              dev->name, buflen, CTC_INITIAL_BLOCKLEN);
 957                 ch_action_firstio(fi, event, arg);
 958         }
 959 }
 960
 961 /**
 962  * Set channel into extended mode.
 963  *
 964  * @param fi    An instance of a channel statemachine.
 965  * @param event The event, just happened.
 966  * @param arg   Generic pointer, casted from channel * upon call.
 967  */
 968 static void
 969 ch_action_setmode(fsm_instance * fi, int event, void *arg)
 970 {
 971         struct channel *ch = (struct channel *) arg;
 972         int rc;
 973         unsigned long saveflags;
 974
 975         DBF_TEXT(trace, 4, __FUNCTION__);
 976         fsm_deltimer(&ch->timer);
 977         fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC, CH_EVENT_TIMER, ch);
 978         fsm_newstate(fi, CH_STATE_SETUPWAIT);
 979         saveflags = 0;  /* avoids compiler warning with
 980                            spin_unlock_irqrestore */
 981         if (event == CH_EVENT_TIMER)    // only for timer not yet locked
 982                 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
 983         rc = ccw_device_start(ch->cdev, &ch->ccw[6], (unsigned long) ch, 0xff, 0);
 984         if (event == CH_EVENT_TIMER)
 985                 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
 986         if (rc != 0) {
 987                 fsm_deltimer(&ch->timer);
 988                 fsm_newstate(fi, CH_STATE_STARTWAIT);
 989                 ccw_check_return_code(ch, rc, "set Mode");
 990         } else
 991                 ch->retry = 0;
 992 }
 993
 994 /**
 995  * Setup channel.
 996  *
 997  * @param fi    An instance of a channel statemachine.
 998  * @param event The event, just happened.
 999  * @param arg   Generic pointer, casted from channel * upon call.
1000  */
1001 static void
1002 ch_action_start(fsm_instance * fi, int event, void *arg)
1003 {
1004         struct channel *ch = (struct channel *) arg;
1005         unsigned long saveflags;
1006         int rc;
1007         struct net_device *dev;
1008
1009         DBF_TEXT(trace, 4, __FUNCTION__);
1010         if (ch == NULL) {
1011                 ctc_pr_warn("ch_action_start ch=NULL\n");
1012                 return;
1013         }
1014         if (ch->netdev == NULL) {
1015                 ctc_pr_warn("ch_action_start dev=NULL, id=%s\n", ch->id);
1016                 return;
1017         }
1018         dev = ch->netdev;
1019
1020 #ifdef DEBUG
1021         ctc_pr_debug("%s: %s channel start\n", dev->name,
1022                      (CHANNEL_DIRECTION(ch->flags) == READ) ? "RX" : "TX");
1023 #endif
1024
1025         if (ch->trans_skb != NULL) {
1026                 clear_normalized_cda(&ch->ccw[1]);
1027                 dev_kfree_skb(ch->trans_skb);
1028                 ch->trans_skb = NULL;
1029         }
1030         if (CHANNEL_DIRECTION(ch->flags) == READ) {
1031                 ch->ccw[1].cmd_code = CCW_CMD_READ;
1032                 ch->ccw[1].flags = CCW_FLAG_SLI;
1033                 ch->ccw[1].count = 0;
1034         } else {
1035                 ch->ccw[1].cmd_code = CCW_CMD_WRITE;
1036                 ch->ccw[1].flags = CCW_FLAG_SLI | CCW_FLAG_CC;
1037                 ch->ccw[1].count = 0;
1038         }
1039         if (ctc_checkalloc_buffer(ch, 0)) {
1040                 ctc_pr_notice(
1041                         "%s: Could not allocate %s trans_skb, delaying "
1042                         "allocation until first transfer\n",
1043                         dev->name,
1044                         (CHANNEL_DIRECTION(ch->flags) == READ) ? "RX" : "TX");
1045         }
1046
1047         ch->ccw[0].cmd_code = CCW_CMD_PREPARE;
1048         ch->ccw[0].flags = CCW_FLAG_SLI | CCW_FLAG_CC;
1049         ch->ccw[0].count = 0;
1050         ch->ccw[0].cda = 0;
1051         ch->ccw[2].cmd_code = CCW_CMD_NOOP;     /* jointed CE + DE */
1052         ch->ccw[2].flags = CCW_FLAG_SLI;
1053         ch->ccw[2].count = 0;
1054         ch->ccw[2].cda = 0;
1055         memcpy(&ch->ccw[3], &ch->ccw[0], sizeof (struct ccw1) * 3);
1056         ch->ccw[4].cda = 0;
1057         ch->ccw[4].flags &= ~CCW_FLAG_IDA;
1058
1059         fsm_newstate(fi, CH_STATE_STARTWAIT);
1060         fsm_addtimer(&ch->timer, 1000, CH_EVENT_TIMER, ch);
1061         spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
1062         rc = ccw_device_halt(ch->cdev, (unsigned long) ch);
1063         spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
1064         if (rc != 0) {
1065                 if (rc != -EBUSY)
1066                     fsm_deltimer(&ch->timer);
1067                 ccw_check_return_code(ch, rc, "initial HaltIO");
1068         }
1069 #ifdef DEBUG
1070         ctc_pr_debug("ctc: %s(): leaving\n", __func__);
1071 #endif
1072 }
1073
1074 /**
1075  * Shutdown a channel.
1076  *
1077  * @param fi    An instance of a channel statemachine.
1078  * @param event The event, just happened.
1079  * @param arg   Generic pointer, casted from channel * upon call.
1080  */
1081 static void
1082 ch_action_haltio(fsm_instance * fi, int event, void *arg)
1083 {
1084         struct channel *ch = (struct channel *) arg;
1085         unsigned long saveflags;
1086         int rc;
1087         int oldstate;
1088
1089         DBF_TEXT(trace, 3, __FUNCTION__);
1090         fsm_deltimer(&ch->timer);
1091         fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC, CH_EVENT_TIMER, ch);
1092         saveflags = 0;  /* avoids comp warning with
1093                            spin_unlock_irqrestore */
1094         if (event == CH_EVENT_STOP)     // only for STOP not yet locked
1095                 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
1096         oldstate = fsm_getstate(fi);
1097         fsm_newstate(fi, CH_STATE_TERM);
1098         rc = ccw_device_halt(ch->cdev, (unsigned long) ch);
1099         if (event == CH_EVENT_STOP)
1100                 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
1101         if (rc != 0) {
1102                 if (rc != -EBUSY) {
1103                     fsm_deltimer(&ch->timer);
1104                     fsm_newstate(fi, oldstate);
1105                 }
1106                 ccw_check_return_code(ch, rc, "HaltIO in ch_action_haltio");
1107         }
1108 }
1109
1110 /**
1111  * A channel has successfully been halted.
1112  * Cleanup it's queue and notify interface statemachine.
1113  *
1114  * @param fi    An instance of a channel statemachine.
1115  * @param event The event, just happened.
1116  * @param arg   Generic pointer, casted from channel * upon call.
1117  */
1118 static void
1119 ch_action_stopped(fsm_instance * fi, int event, void *arg)
1120 {
1121         struct channel *ch = (struct channel *) arg;
1122         struct net_device *dev = ch->netdev;
1123
1124         DBF_TEXT(trace, 3, __FUNCTION__);
1125         fsm_deltimer(&ch->timer);
1126         fsm_newstate(fi, CH_STATE_STOPPED);
1127         if (ch->trans_skb != NULL) {
1128                 clear_normalized_cda(&ch->ccw[1]);
1129                 dev_kfree_skb(ch->trans_skb);
1130                 ch->trans_skb = NULL;
1131         }
1132         if (CHANNEL_DIRECTION(ch->flags) == READ) {
1133                 skb_queue_purge(&ch->io_queue);
1134                 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1135                           DEV_EVENT_RXDOWN, dev);
1136         } else {
1137                 ctc_purge_skb_queue(&ch->io_queue);
1138                 spin_lock(&ch->collect_lock);
1139                 ctc_purge_skb_queue(&ch->collect_queue);
1140                 ch->collect_len = 0;
1141                 spin_unlock(&ch->collect_lock);
1142                 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1143                           DEV_EVENT_TXDOWN, dev);
1144         }
1145 }
1146
1147 /**
1148  * A stop command from device statemachine arrived and we are in
1149  * not operational mode. Set state to stopped.
1150  *
1151  * @param fi    An instance of a channel statemachine.
1152  * @param event The event, just happened.
1153  * @param arg   Generic pointer, casted from channel * upon call.
1154  */
1155 static void
1156 ch_action_stop(fsm_instance * fi, int event, void *arg)
1157 {
1158         fsm_newstate(fi, CH_STATE_STOPPED);
1159 }
1160
1161 /**
1162  * A machine check for no path, not operational status or gone device has
1163  * happened.
1164  * Cleanup queue and notify interface statemachine.
1165  *
1166  * @param fi    An instance of a channel statemachine.
1167  * @param event The event, just happened.
1168  * @param arg   Generic pointer, casted from channel * upon call.
1169  */
1170 static void
1171 ch_action_fail(fsm_instance * fi, int event, void *arg)
1172 {
1173         struct channel *ch = (struct channel *) arg;
1174         struct net_device *dev = ch->netdev;
1175
1176         DBF_TEXT(trace, 3, __FUNCTION__);
1177         fsm_deltimer(&ch->timer);
1178         fsm_newstate(fi, CH_STATE_NOTOP);
1179         if (CHANNEL_DIRECTION(ch->flags) == READ) {
1180                 skb_queue_purge(&ch->io_queue);
1181                 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1182                           DEV_EVENT_RXDOWN, dev);
1183         } else {
1184                 ctc_purge_skb_queue(&ch->io_queue);
1185                 spin_lock(&ch->collect_lock);
1186                 ctc_purge_skb_queue(&ch->collect_queue);
1187                 ch->collect_len = 0;
1188                 spin_unlock(&ch->collect_lock);
1189                 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1190                           DEV_EVENT_TXDOWN, dev);
1191         }
1192 }
1193
1194 /**
1195  * Handle error during setup of channel.
1196  *
1197  * @param fi    An instance of a channel statemachine.
1198  * @param event The event, just happened.
1199  * @param arg   Generic pointer, casted from channel * upon call.
1200  */
1201 static void
1202 ch_action_setuperr(fsm_instance * fi, int event, void *arg)
1203 {
1204         struct channel *ch = (struct channel *) arg;
1205         struct net_device *dev = ch->netdev;
1206
1207         DBF_TEXT(setup, 3, __FUNCTION__);
1208         /**
1209          * Special case: Got UC_RCRESET on setmode.
1210          * This means that remote side isn't setup. In this case
1211          * simply retry after some 10 secs...
1212          */
1213         if ((fsm_getstate(fi) == CH_STATE_SETUPWAIT) &&
1214             ((event == CH_EVENT_UC_RCRESET) ||
1215              (event == CH_EVENT_UC_RSRESET))) {
1216                 fsm_newstate(fi, CH_STATE_STARTRETRY);
1217                 fsm_deltimer(&ch->timer);
1218                 fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC, CH_EVENT_TIMER, ch);
1219                 if (CHANNEL_DIRECTION(ch->flags) == READ) {
1220                         int rc = ccw_device_halt(ch->cdev, (unsigned long) ch);
1221                         if (rc != 0)
1222                                 ccw_check_return_code(
1223                                         ch, rc, "HaltIO in ch_action_setuperr");
1224                 }
1225                 return;
1226         }
1227
1228         ctc_pr_debug("%s: Error %s during %s channel setup state=%s\n",
1229                      dev->name, ch_event_names[event],
1230                      (CHANNEL_DIRECTION(ch->flags) == READ) ? "RX" : "TX",
1231                      fsm_getstate_str(fi));
1232         if (CHANNEL_DIRECTION(ch->flags) == READ) {
1233                 fsm_newstate(fi, CH_STATE_RXERR);
1234                 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1235                           DEV_EVENT_RXDOWN, dev);
1236         } else {
1237                 fsm_newstate(fi, CH_STATE_TXERR);
1238                 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1239                           DEV_EVENT_TXDOWN, dev);
1240         }
1241 }
1242
1243 /**
1244  * Restart a channel after an error.
1245  *
1246  * @param fi    An instance of a channel statemachine.
1247  * @param event The event, just happened.
1248  * @param arg   Generic pointer, casted from channel * upon call.
1249  */
1250 static void
1251 ch_action_restart(fsm_instance * fi, int event, void *arg)
1252 {
1253         unsigned long saveflags;
1254         int oldstate;
1255         int rc;
1256
1257         struct channel *ch = (struct channel *) arg;
1258         struct net_device *dev = ch->netdev;
1259
1260         DBF_TEXT(trace, 3, __FUNCTION__);
1261         fsm_deltimer(&ch->timer);
1262         ctc_pr_debug("%s: %s channel restart\n", dev->name,
1263                      (CHANNEL_DIRECTION(ch->flags) == READ) ? "RX" : "TX");
1264         fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC, CH_EVENT_TIMER, ch);
1265         oldstate = fsm_getstate(fi);
1266         fsm_newstate(fi, CH_STATE_STARTWAIT);
1267         saveflags = 0;  /* avoids compiler warning with
1268                            spin_unlock_irqrestore */
1269         if (event == CH_EVENT_TIMER)    // only for timer not yet locked
1270                 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
1271         rc = ccw_device_halt(ch->cdev, (unsigned long) ch);
1272         if (event == CH_EVENT_TIMER)
1273                 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
1274         if (rc != 0) {
1275                 if (rc != -EBUSY) {
1276                     fsm_deltimer(&ch->timer);
1277                     fsm_newstate(fi, oldstate);
1278                 }
1279                 ccw_check_return_code(ch, rc, "HaltIO in ch_action_restart");
1280         }
1281 }
1282
1283 /**
1284  * Handle error during RX initial handshake (exchange of
1285  * 0-length block header)
1286  *
1287  * @param fi    An instance of a channel statemachine.
1288  * @param event The event, just happened.
1289  * @param arg   Generic pointer, casted from channel * upon call.
1290  */
1291 static void
1292 ch_action_rxiniterr(fsm_instance * fi, int event, void *arg)
1293 {
1294         struct channel *ch = (struct channel *) arg;
1295         struct net_device *dev = ch->netdev;
1296
1297         DBF_TEXT(setup, 3, __FUNCTION__);
1298         if (event == CH_EVENT_TIMER) {
1299                 fsm_deltimer(&ch->timer);
1300                 ctc_pr_debug("%s: Timeout during RX init handshake\n", dev->name);
1301                 if (ch->retry++ < 3)
1302                         ch_action_restart(fi, event, arg);
1303                 else {
1304                         fsm_newstate(fi, CH_STATE_RXERR);
1305                         fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1306                                   DEV_EVENT_RXDOWN, dev);
1307                 }
1308         } else
1309                 ctc_pr_warn("%s: Error during RX init handshake\n", dev->name);
1310 }
1311
1312 /**
1313  * Notify device statemachine if we gave up initialization
1314  * of RX channel.
1315  *
1316  * @param fi    An instance of a channel statemachine.
1317  * @param event The event, just happened.
1318  * @param arg   Generic pointer, casted from channel * upon call.
1319  */
1320 static void
1321 ch_action_rxinitfail(fsm_instance * fi, int event, void *arg)
1322 {
1323         struct channel *ch = (struct channel *) arg;
1324         struct net_device *dev = ch->netdev;
1325
1326         DBF_TEXT(setup, 3, __FUNCTION__);
1327         fsm_newstate(fi, CH_STATE_RXERR);
1328         ctc_pr_warn("%s: RX initialization failed\n", dev->name);
1329         ctc_pr_warn("%s: RX <-> RX connection detected\n", dev->name);
1330         fsm_event(((struct ctc_priv *) dev->priv)->fsm, DEV_EVENT_RXDOWN, dev);
1331 }
1332
1333 /**
1334  * Handle RX Unit check remote reset (remote disconnected)
1335  *
1336  * @param fi    An instance of a channel statemachine.
1337  * @param event The event, just happened.
1338  * @param arg   Generic pointer, casted from channel * upon call.
1339  */
1340 static void
1341 ch_action_rxdisc(fsm_instance * fi, int event, void *arg)
1342 {
1343         struct channel *ch = (struct channel *) arg;
1344         struct channel *ch2;
1345         struct net_device *dev = ch->netdev;
1346
1347         DBF_TEXT(trace, 3, __FUNCTION__);
1348         fsm_deltimer(&ch->timer);
1349         ctc_pr_debug("%s: Got remote disconnect, re-initializing ...\n",
1350                      dev->name);
1351
1352         /**
1353          * Notify device statemachine
1354          */
1355         fsm_event(((struct ctc_priv *) dev->priv)->fsm, DEV_EVENT_RXDOWN, dev);
1356         fsm_event(((struct ctc_priv *) dev->priv)->fsm, DEV_EVENT_TXDOWN, dev);
1357
1358         fsm_newstate(fi, CH_STATE_DTERM);
1359         ch2 = ((struct ctc_priv *) dev->priv)->channel[WRITE];
1360         fsm_newstate(ch2->fsm, CH_STATE_DTERM);
1361
1362         ccw_device_halt(ch->cdev, (unsigned long) ch);
1363         ccw_device_halt(ch2->cdev, (unsigned long) ch2);
1364 }
1365
1366 /**
1367  * Handle error during TX channel initialization.
1368  *
1369  * @param fi    An instance of a channel statemachine.
1370  * @param event The event, just happened.
1371  * @param arg   Generic pointer, casted from channel * upon call.
1372  */
1373 static void
1374 ch_action_txiniterr(fsm_instance * fi, int event, void *arg)
1375 {
1376         struct channel *ch = (struct channel *) arg;
1377         struct net_device *dev = ch->netdev;
1378
1379         DBF_TEXT(setup, 2, __FUNCTION__);
1380         if (event == CH_EVENT_TIMER) {
1381                 fsm_deltimer(&ch->timer);
1382                 ctc_pr_debug("%s: Timeout during TX init handshake\n", dev->name);
1383                 if (ch->retry++ < 3)
1384                         ch_action_restart(fi, event, arg);
1385                 else {
1386                         fsm_newstate(fi, CH_STATE_TXERR);
1387                         fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1388                                   DEV_EVENT_TXDOWN, dev);
1389                 }
1390         } else
1391                 ctc_pr_warn("%s: Error during TX init handshake\n", dev->name);
1392 }
1393
1394 /**
1395  * Handle TX timeout by retrying operation.
1396  *
1397  * @param fi    An instance of a channel statemachine.
1398  * @param event The event, just happened.
1399  * @param arg   Generic pointer, casted from channel * upon call.
1400  */
1401 static void
1402 ch_action_txretry(fsm_instance * fi, int event, void *arg)
1403 {
1404         struct channel *ch = (struct channel *) arg;
1405         struct net_device *dev = ch->netdev;
1406         unsigned long saveflags;
1407
1408         DBF_TEXT(trace, 4, __FUNCTION__);
1409         fsm_deltimer(&ch->timer);
1410         if (ch->retry++ > 3) {
1411                 ctc_pr_debug("%s: TX retry failed, restarting channel\n",
1412                              dev->name);
1413                 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1414                           DEV_EVENT_TXDOWN, dev);
1415                 ch_action_restart(fi, event, arg);
1416         } else {
1417                 struct sk_buff *skb;
1418
1419                 ctc_pr_debug("%s: TX retry %d\n", dev->name, ch->retry);
1420                 if ((skb = skb_peek(&ch->io_queue))) {
1421                         int rc = 0;
1422
1423                         clear_normalized_cda(&ch->ccw[4]);
1424                         ch->ccw[4].count = skb->len;
1425                         if (set_normalized_cda(&ch->ccw[4], skb->data)) {
1426                                 ctc_pr_debug(
1427                                         "%s: IDAL alloc failed, chan restart\n",
1428                                         dev->name);
1429                                 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1430                                           DEV_EVENT_TXDOWN, dev);
1431                                 ch_action_restart(fi, event, arg);
1432                                 return;
1433                         }
1434                         fsm_addtimer(&ch->timer, 1000, CH_EVENT_TIMER, ch);
1435                         saveflags = 0;  /* avoids compiler warning with
1436                                            spin_unlock_irqrestore */
1437                         if (event == CH_EVENT_TIMER) // only for TIMER not yet locked
1438                                 spin_lock_irqsave(get_ccwdev_lock(ch->cdev),
1439                                                   saveflags);
1440                         rc = ccw_device_start(ch->cdev, &ch->ccw[3],
1441                                               (unsigned long) ch, 0xff, 0);
1442                         if (event == CH_EVENT_TIMER)
1443                                 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev),
1444                                                        saveflags);
1445                         if (rc != 0) {
1446                                 fsm_deltimer(&ch->timer);
1447                                 ccw_check_return_code(ch, rc, "TX in ch_action_txretry");
1448                                 ctc_purge_skb_queue(&ch->io_queue);
1449                         }
1450                 }
1451         }
1452
1453 }
1454
1455 /**
1456  * Handle fatal errors during an I/O command.
1457  *
1458  * @param fi    An instance of a channel statemachine.
1459  * @param event The event, just happened.
1460  * @param arg   Generic pointer, casted from channel * upon call.
1461  */
1462 static void
1463 ch_action_iofatal(fsm_instance * fi, int event, void *arg)
1464 {
1465         struct channel *ch = (struct channel *) arg;
1466         struct net_device *dev = ch->netdev;
1467
1468         DBF_TEXT(trace, 3, __FUNCTION__);
1469         fsm_deltimer(&ch->timer);
1470         if (CHANNEL_DIRECTION(ch->flags) == READ) {
1471                 ctc_pr_debug("%s: RX I/O error\n", dev->name);
1472                 fsm_newstate(fi, CH_STATE_RXERR);
1473                 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1474                           DEV_EVENT_RXDOWN, dev);
1475         } else {
1476                 ctc_pr_debug("%s: TX I/O error\n", dev->name);
1477                 fsm_newstate(fi, CH_STATE_TXERR);
1478                 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1479                           DEV_EVENT_TXDOWN, dev);
1480         }
1481 }
1482
1483 static void
1484 ch_action_reinit(fsm_instance *fi, int event, void *arg)
1485 {
1486         struct channel *ch = (struct channel *)arg;
1487         struct net_device *dev = ch->netdev;
1488         struct ctc_priv *privptr = dev->priv;
1489
1490         DBF_TEXT(trace, 4, __FUNCTION__);
1491         ch_action_iofatal(fi, event, arg);
1492         fsm_addtimer(&privptr->restart_timer, 1000, DEV_EVENT_RESTART, dev);
1493 }
1494
1495 /**
1496  * The statemachine for a channel.
1497  */
1498 static const fsm_node ch_fsm[] = {
1499         {CH_STATE_STOPPED,    CH_EVENT_STOP,       fsm_action_nop       },
1500         {CH_STATE_STOPPED,    CH_EVENT_START,      ch_action_start      },
1501         {CH_STATE_STOPPED,    CH_EVENT_FINSTAT,    fsm_action_nop       },
1502         {CH_STATE_STOPPED,    CH_EVENT_MC_FAIL,    fsm_action_nop       },
1503
1504         {CH_STATE_NOTOP,      CH_EVENT_STOP,       ch_action_stop       },
1505         {CH_STATE_NOTOP,      CH_EVENT_START,      fsm_action_nop       },
1506         {CH_STATE_NOTOP,      CH_EVENT_FINSTAT,    fsm_action_nop       },
1507         {CH_STATE_NOTOP,      CH_EVENT_MC_FAIL,    fsm_action_nop       },
1508         {CH_STATE_NOTOP,      CH_EVENT_MC_GOOD,    ch_action_start      },
1509
1510         {CH_STATE_STARTWAIT,  CH_EVENT_STOP,       ch_action_haltio     },
1511         {CH_STATE_STARTWAIT,  CH_EVENT_START,      fsm_action_nop       },
1512         {CH_STATE_STARTWAIT,  CH_EVENT_FINSTAT,    ch_action_setmode    },
1513         {CH_STATE_STARTWAIT,  CH_EVENT_TIMER,      ch_action_setuperr   },
1514         {CH_STATE_STARTWAIT,  CH_EVENT_IO_ENODEV,  ch_action_iofatal    },
1515         {CH_STATE_STARTWAIT,  CH_EVENT_IO_EIO,     ch_action_reinit     },
1516         {CH_STATE_STARTWAIT,  CH_EVENT_MC_FAIL,    ch_action_fail       },
1517
1518         {CH_STATE_STARTRETRY, CH_EVENT_STOP,       ch_action_haltio     },
1519         {CH_STATE_STARTRETRY, CH_EVENT_TIMER,      ch_action_setmode    },
1520         {CH_STATE_STARTRETRY, CH_EVENT_FINSTAT,    fsm_action_nop       },
1521         {CH_STATE_STARTRETRY, CH_EVENT_MC_FAIL,    ch_action_fail       },
1522
1523         {CH_STATE_SETUPWAIT,  CH_EVENT_STOP,       ch_action_haltio     },
1524         {CH_STATE_SETUPWAIT,  CH_EVENT_START,      fsm_action_nop       },
1525         {CH_STATE_SETUPWAIT,  CH_EVENT_FINSTAT,    ch_action_firstio    },
1526         {CH_STATE_SETUPWAIT,  CH_EVENT_UC_RCRESET, ch_action_setuperr   },
1527         {CH_STATE_SETUPWAIT,  CH_EVENT_UC_RSRESET, ch_action_setuperr   },
1528         {CH_STATE_SETUPWAIT,  CH_EVENT_TIMER,      ch_action_setmode    },
1529         {CH_STATE_SETUPWAIT,  CH_EVENT_IO_ENODEV,  ch_action_iofatal    },
1530         {CH_STATE_SETUPWAIT,  CH_EVENT_IO_EIO,     ch_action_reinit     },
1531         {CH_STATE_SETUPWAIT,  CH_EVENT_MC_FAIL,    ch_action_fail       },
1532
1533         {CH_STATE_RXINIT,     CH_EVENT_STOP,       ch_action_haltio     },
1534         {CH_STATE_RXINIT,     CH_EVENT_START,      fsm_action_nop       },
1535         {CH_STATE_RXINIT,     CH_EVENT_FINSTAT,    ch_action_rxidle     },
1536         {CH_STATE_RXINIT,     CH_EVENT_UC_RCRESET, ch_action_rxiniterr  },
1537         {CH_STATE_RXINIT,     CH_EVENT_UC_RSRESET, ch_action_rxiniterr  },
1538         {CH_STATE_RXINIT,     CH_EVENT_TIMER,      ch_action_rxiniterr  },
1539         {CH_STATE_RXINIT,     CH_EVENT_ATTNBUSY,   ch_action_rxinitfail },
1540         {CH_STATE_RXINIT,     CH_EVENT_IO_ENODEV,  ch_action_iofatal    },
1541         {CH_STATE_RXINIT,     CH_EVENT_IO_EIO,     ch_action_reinit     },
1542         {CH_STATE_RXINIT,     CH_EVENT_UC_ZERO,    ch_action_firstio    },
1543         {CH_STATE_RXINIT,     CH_EVENT_MC_FAIL,    ch_action_fail       },
1544
1545         {CH_STATE_RXIDLE,     CH_EVENT_STOP,       ch_action_haltio     },
1546         {CH_STATE_RXIDLE,     CH_EVENT_START,      fsm_action_nop       },
1547         {CH_STATE_RXIDLE,     CH_EVENT_FINSTAT,    ch_action_rx         },
1548         {CH_STATE_RXIDLE,     CH_EVENT_UC_RCRESET, ch_action_rxdisc     },
1549 //      {CH_STATE_RXIDLE,     CH_EVENT_UC_RSRESET, ch_action_rxretry    },
1550         {CH_STATE_RXIDLE,     CH_EVENT_IO_ENODEV,  ch_action_iofatal    },
1551         {CH_STATE_RXIDLE,     CH_EVENT_IO_EIO,     ch_action_reinit     },
1552         {CH_STATE_RXIDLE,     CH_EVENT_MC_FAIL,    ch_action_fail       },
1553         {CH_STATE_RXIDLE,     CH_EVENT_UC_ZERO,    ch_action_rx         },
1554
1555         {CH_STATE_TXINIT,     CH_EVENT_STOP,       ch_action_haltio     },
1556         {CH_STATE_TXINIT,     CH_EVENT_START,      fsm_action_nop       },
1557         {CH_STATE_TXINIT,     CH_EVENT_FINSTAT,    ch_action_txidle     },
1558         {CH_STATE_TXINIT,     CH_EVENT_UC_RCRESET, ch_action_txiniterr  },
1559         {CH_STATE_TXINIT,     CH_EVENT_UC_RSRESET, ch_action_txiniterr  },
1560         {CH_STATE_TXINIT,     CH_EVENT_TIMER,      ch_action_txiniterr  },
1561         {CH_STATE_TXINIT,     CH_EVENT_IO_ENODEV,  ch_action_iofatal    },
1562         {CH_STATE_TXINIT,     CH_EVENT_IO_EIO,     ch_action_reinit     },
1563         {CH_STATE_TXINIT,     CH_EVENT_MC_FAIL,    ch_action_fail       },
1564
1565         {CH_STATE_TXIDLE,     CH_EVENT_STOP,       ch_action_haltio     },
1566         {CH_STATE_TXIDLE,     CH_EVENT_START,      fsm_action_nop       },
1567         {CH_STATE_TXIDLE,     CH_EVENT_FINSTAT,    ch_action_firstio    },
1568         {CH_STATE_TXIDLE,     CH_EVENT_UC_RCRESET, fsm_action_nop       },
1569         {CH_STATE_TXIDLE,     CH_EVENT_UC_RSRESET, fsm_action_nop       },
1570         {CH_STATE_TXIDLE,     CH_EVENT_IO_ENODEV,  ch_action_iofatal    },
1571         {CH_STATE_TXIDLE,     CH_EVENT_IO_EIO,     ch_action_reinit     },
1572         {CH_STATE_TXIDLE,     CH_EVENT_MC_FAIL,    ch_action_fail       },
1573
1574         {CH_STATE_TERM,       CH_EVENT_STOP,       fsm_action_nop       },
1575         {CH_STATE_TERM,       CH_EVENT_START,      ch_action_restart    },
1576         {CH_STATE_TERM,       CH_EVENT_FINSTAT,    ch_action_stopped    },
1577         {CH_STATE_TERM,       CH_EVENT_UC_RCRESET, fsm_action_nop       },
1578         {CH_STATE_TERM,       CH_EVENT_UC_RSRESET, fsm_action_nop       },
1579         {CH_STATE_TERM,       CH_EVENT_MC_FAIL,    ch_action_fail       },
1580
1581         {CH_STATE_DTERM,      CH_EVENT_STOP,       ch_action_haltio     },
1582         {CH_STATE_DTERM,      CH_EVENT_START,      ch_action_restart    },
1583         {CH_STATE_DTERM,      CH_EVENT_FINSTAT,    ch_action_setmode    },
1584         {CH_STATE_DTERM,      CH_EVENT_UC_RCRESET, fsm_action_nop       },
1585         {CH_STATE_DTERM,      CH_EVENT_UC_RSRESET, fsm_action_nop       },
1586         {CH_STATE_DTERM,      CH_EVENT_MC_FAIL,    ch_action_fail       },
1587
1588         {CH_STATE_TX,         CH_EVENT_STOP,       ch_action_haltio     },
1589         {CH_STATE_TX,         CH_EVENT_START,      fsm_action_nop       },
1590         {CH_STATE_TX,         CH_EVENT_FINSTAT,    ch_action_txdone     },
1591         {CH_STATE_TX,         CH_EVENT_UC_RCRESET, ch_action_txretry    },
1592         {CH_STATE_TX,         CH_EVENT_UC_RSRESET, ch_action_txretry    },
1593         {CH_STATE_TX,         CH_EVENT_TIMER,      ch_action_txretry    },
1594         {CH_STATE_TX,         CH_EVENT_IO_ENODEV,  ch_action_iofatal    },
1595         {CH_STATE_TX,         CH_EVENT_IO_EIO,     ch_action_reinit     },
1596         {CH_STATE_TX,         CH_EVENT_MC_FAIL,    ch_action_fail       },
1597
1598         {CH_STATE_RXERR,      CH_EVENT_STOP,       ch_action_haltio     },
1599         {CH_STATE_TXERR,      CH_EVENT_STOP,       ch_action_haltio     },
1600         {CH_STATE_TXERR,      CH_EVENT_MC_FAIL,    ch_action_fail       },
1601         {CH_STATE_RXERR,      CH_EVENT_MC_FAIL,    ch_action_fail       },
1602 };
1603
1604 static const int CH_FSM_LEN = sizeof (ch_fsm) / sizeof (fsm_node);
1605
1606 /**
1607  * Functions related to setup and device detection.
1608  *****************************************************************************/
1609
1610 static inline int
1611 less_than(char *id1, char *id2)
1612 {
1613         int dev1, dev2, i;
1614
1615         for (i = 0; i < 5; i++) {
1616                 id1++;
1617                 id2++;
1618         }
1619         dev1 = simple_strtoul(id1, &id1, 16);
1620         dev2 = simple_strtoul(id2, &id2, 16);
1621
1622         return (dev1 < dev2);
1623 }
1624
1625 /**
1626  * Add a new channel to the list of channels.
1627  * Keeps the channel list sorted.
1628  *
1629  * @param cdev  The ccw_device to be added.
1630  * @param type  The type class of the new channel.
1631  *
1632  * @return 0 on success, !0 on error.
1633  */
1634 static int
1635 add_channel(struct ccw_device *cdev, enum channel_types type)
1636 {
1637         struct channel **c = &channels;
1638         struct channel *ch;
1639
1640         DBF_TEXT(trace, 2, __FUNCTION__);
1641         if ((ch =
1642              (struct channel *) kmalloc(sizeof (struct channel),
1643                                         GFP_KERNEL)) == NULL) {
1644                 ctc_pr_warn("ctc: Out of memory in add_channel\n");
1645                 return -1;
1646         }
1647         memset(ch, 0, sizeof (struct channel));
1648         if ((ch->ccw = kmalloc(8*sizeof(struct ccw1),
1649                                                GFP_KERNEL | GFP_DMA)) == NULL) {
1650                 kfree(ch);
1651                 ctc_pr_warn("ctc: Out of memory in add_channel\n");
1652                 return -1;
1653         }
1654
1655         memset(ch->ccw, 0, 8*sizeof(struct ccw1));      // assure all flags and counters are reset
1656
1657         /**
1658          * "static" ccws are used in the following way:
1659          *
1660          * ccw[0..2] (Channel program for generic I/O):
1661          *           0: prepare
1662          *           1: read or write (depending on direction) with fixed
1663          *              buffer (idal allocated once when buffer is allocated)
1664          *           2: nop
1665          * ccw[3..5] (Channel program for direct write of packets)
1666          *           3: prepare
1667          *           4: write (idal allocated on every write).
1668          *           5: nop
1669          * ccw[6..7] (Channel program for initial channel setup):
1670          *           6: set extended mode
1671          *           7: nop
1672          *
1673          * ch->ccw[0..5] are initialized in ch_action_start because
1674          * the channel's direction is yet unknown here.
1675          */
1676         ch->ccw[6].cmd_code = CCW_CMD_SET_EXTENDED;
1677         ch->ccw[6].flags = CCW_FLAG_SLI;
1678
1679         ch->ccw[7].cmd_code = CCW_CMD_NOOP;
1680         ch->ccw[7].flags = CCW_FLAG_SLI;
1681
1682         ch->cdev = cdev;
1683         snprintf(ch->id, CTC_ID_SIZE, "ch-%s", cdev->dev.bus_id);
1684         ch->type = type;
1685         ch->fsm = init_fsm(ch->id, ch_state_names,
1686                            ch_event_names, NR_CH_STATES, NR_CH_EVENTS,
1687                            ch_fsm, CH_FSM_LEN, GFP_KERNEL);
1688         if (ch->fsm == NULL) {
1689                 ctc_pr_warn("ctc: Could not create FSM in add_channel\n");
1690                 kfree(ch->ccw);
1691                 kfree(ch);
1692                 return -1;
1693         }
1694         fsm_newstate(ch->fsm, CH_STATE_IDLE);
1695         if ((ch->irb = kmalloc(sizeof (struct irb),
1696                                               GFP_KERNEL)) == NULL) {
1697                 ctc_pr_warn("ctc: Out of memory in add_channel\n");
1698                 kfree_fsm(ch->fsm);
1699                 kfree(ch->ccw);
1700                 kfree(ch);
1701                 return -1;
1702         }
1703         memset(ch->irb, 0, sizeof (struct irb));
1704         while (*c && less_than((*c)->id, ch->id))
1705                 c = &(*c)->next;
1706         if (*c && (!strncmp((*c)->id, ch->id, CTC_ID_SIZE))) {
1707                 ctc_pr_debug(
1708                         "ctc: add_channel: device %s already in list, "
1709                         "using old entry\n", (*c)->id);
1710                 kfree(ch->irb);
1711                 kfree_fsm(ch->fsm);
1712                 kfree(ch->ccw);
1713                 kfree(ch);
1714                 return 0;
1715         }
1716
1717         spin_lock_init(&ch->collect_lock);
1718
1719         fsm_settimer(ch->fsm, &ch->timer);
1720         skb_queue_head_init(&ch->io_queue);
1721         skb_queue_head_init(&ch->collect_queue);
1722         ch->next = *c;
1723         *c = ch;
1724         return 0;
1725 }
1726
1727 /**
1728  * Release a specific channel in the channel list.
1729  *
1730  * @param ch Pointer to channel struct to be released.
1731  */
1732 static void
1733 channel_free(struct channel *ch)
1734 {
1735         ch->flags &= ~CHANNEL_FLAGS_INUSE;
1736         fsm_newstate(ch->fsm, CH_STATE_IDLE);
1737 }
1738
1739 /**
1740  * Remove a specific channel in the channel list.
1741  *
1742  * @param ch Pointer to channel struct to be released.
1743  */
1744 static void
1745 channel_remove(struct channel *ch)
1746 {
1747         struct channel **c = &channels;
1748
1749         DBF_TEXT(trace, 2, __FUNCTION__);
1750         if (ch == NULL)
1751                 return;
1752
1753         channel_free(ch);
1754         while (*c) {
1755                 if (*c == ch) {
1756                         *c = ch->next;
1757                         fsm_deltimer(&ch->timer);
1758                         kfree_fsm(ch->fsm);
1759                         clear_normalized_cda(&ch->ccw[4]);
1760                         if (ch->trans_skb != NULL) {
1761                                 clear_normalized_cda(&ch->ccw[1]);
1762                                 dev_kfree_skb(ch->trans_skb);
1763                         }
1764                         kfree(ch->ccw);
1765                         kfree(ch->irb);
1766                         kfree(ch);
1767                         return;
1768                 }
1769                 c = &((*c)->next);
1770         }
1771 }
1772
1773 /**
1774  * Get a specific channel from the channel list.
1775  *
1776  * @param type Type of channel we are interested in.
1777  * @param id Id of channel we are interested in.
1778  * @param direction Direction we want to use this channel for.
1779  *
1780  * @return Pointer to a channel or NULL if no matching channel available.
1781  */
1782 static struct channel
1783 *
1784 channel_get(enum channel_types type, char *id, int direction)
1785 {
1786         struct channel *ch = channels;
1787
1788         DBF_TEXT(trace, 3, __FUNCTION__);
1789 #ifdef DEBUG
1790         ctc_pr_debug("ctc: %s(): searching for ch with id %s and type %d\n",
1791                      __func__, id, type);
1792 #endif
1793
1794         while (ch && ((strncmp(ch->id, id, CTC_ID_SIZE)) || (ch->type != type))) {
1795 #ifdef DEBUG
1796                 ctc_pr_debug("ctc: %s(): ch=0x%p (id=%s, type=%d\n",
1797                              __func__, ch, ch->id, ch->type);
1798 #endif
1799                 ch = ch->next;
1800         }
1801 #ifdef DEBUG
1802         ctc_pr_debug("ctc: %s(): ch=0x%pq (id=%s, type=%d\n",
1803                      __func__, ch, ch->id, ch->type);
1804 #endif
1805         if (!ch) {
1806                 ctc_pr_warn("ctc: %s(): channel with id %s "
1807                             "and type %d not found in channel list\n",
1808                             __func__, id, type);
1809         } else {
1810                 if (ch->flags & CHANNEL_FLAGS_INUSE)
1811                         ch = NULL;
1812                 else {
1813                         ch->flags |= CHANNEL_FLAGS_INUSE;
1814                         ch->flags &= ~CHANNEL_FLAGS_RWMASK;
1815                         ch->flags |= (direction == WRITE)
1816                             ? CHANNEL_FLAGS_WRITE : CHANNEL_FLAGS_READ;
1817                         fsm_newstate(ch->fsm, CH_STATE_STOPPED);
1818                 }
1819         }
1820         return ch;
1821 }
1822
1823 /**
1824  * Return the channel type by name.
1825  *
1826  * @param name Name of network interface.
1827  *
1828  * @return Type class of channel to be used for that interface.
1829  */
1830 static enum channel_types inline
1831 extract_channel_media(char *name)
1832 {
1833         enum channel_types ret = channel_type_unknown;
1834
1835         if (name != NULL) {
1836                 if (strncmp(name, "ctc", 3) == 0)
1837                         ret = channel_type_parallel;
1838                 if (strncmp(name, "escon", 5) == 0)
1839                         ret = channel_type_escon;
1840         }
1841         return ret;
1842 }
1843
1844 static long
1845 __ctc_check_irb_error(struct ccw_device *cdev, struct irb *irb)
1846 {
1847         if (!IS_ERR(irb))
1848                 return 0;
1849
1850         switch (PTR_ERR(irb)) {
1851         case -EIO:
1852                 ctc_pr_warn("i/o-error on device %s\n", cdev->dev.bus_id);
1853 //              CTC_DBF_TEXT(trace, 2, "ckirberr");
1854 //              CTC_DBF_TEXT_(trace, 2, "  rc%d", -EIO);
1855                 break;
1856         case -ETIMEDOUT:
1857                 ctc_pr_warn("timeout on device %s\n", cdev->dev.bus_id);
1858 //              CTC_DBF_TEXT(trace, 2, "ckirberr");
1859 //              CTC_DBF_TEXT_(trace, 2, "  rc%d", -ETIMEDOUT);
1860                 break;
1861         default:
1862                 ctc_pr_warn("unknown error %ld on device %s\n", PTR_ERR(irb),
1863                            cdev->dev.bus_id);
1864 //              CTC_DBF_TEXT(trace, 2, "ckirberr");
1865 //              CTC_DBF_TEXT(trace, 2, "  rc???");
1866         }
1867         return PTR_ERR(irb);
1868 }
1869
1870 /**
1871  * Main IRQ handler.
1872  *
1873  * @param cdev    The ccw_device the interrupt is for.
1874  * @param intparm interruption parameter.
1875  * @param irb     interruption response block.
1876  */
1877 static void
1878 ctc_irq_handler(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
1879 {
1880         struct channel *ch;
1881         struct net_device *dev;
1882         struct ctc_priv *priv;
1883
1884         DBF_TEXT(trace, 5, __FUNCTION__);
1885         if (__ctc_check_irb_error(cdev, irb))
1886                 return;
1887
1888         /* Check for unsolicited interrupts. */
1889         if (!cdev->dev.driver_data) {
1890                 ctc_pr_warn("ctc: Got unsolicited irq: %s c-%02x d-%02x\n",
1891                             cdev->dev.bus_id, irb->scsw.cstat,
1892                             irb->scsw.dstat);
1893                 return;
1894         }
1895
1896         priv = ((struct ccwgroup_device *)cdev->dev.driver_data)
1897                 ->dev.driver_data;
1898
1899         /* Try to extract channel from driver data. */
1900         if (priv->channel[READ]->cdev == cdev)
1901                 ch = priv->channel[READ];
1902         else if (priv->channel[WRITE]->cdev == cdev)
1903                 ch = priv->channel[WRITE];
1904         else {
1905                 ctc_pr_err("ctc: Can't determine channel for interrupt, "
1906                            "device %s\n", cdev->dev.bus_id);
1907                 return;
1908         }
1909
1910         dev = (struct net_device *) (ch->netdev);
1911         if (dev == NULL) {
1912                 ctc_pr_crit("ctc: ctc_irq_handler dev=NULL bus_id=%s, ch=0x%p\n",
1913                             cdev->dev.bus_id, ch);
1914                 return;
1915         }
1916
1917 #ifdef DEBUG
1918         ctc_pr_debug("%s: interrupt for device: %s received c-%02x d-%02x\n",
1919                      dev->name, ch->id, irb->scsw.cstat, irb->scsw.dstat);
1920 #endif
1921
1922         /* Copy interruption response block. */
1923         memcpy(ch->irb, irb, sizeof(struct irb));
1924
1925         /* Check for good subchannel return code, otherwise error message */
1926         if (ch->irb->scsw.cstat) {
1927                 fsm_event(ch->fsm, CH_EVENT_SC_UNKNOWN, ch);
1928                 ctc_pr_warn("%s: subchannel check for device: %s - %02x %02x\n",
1929                             dev->name, ch->id, ch->irb->scsw.cstat,
1930                             ch->irb->scsw.dstat);
1931                 return;
1932         }
1933
1934         /* Check the reason-code of a unit check */
1935         if (ch->irb->scsw.dstat & DEV_STAT_UNIT_CHECK) {
1936                 ccw_unit_check(ch, ch->irb->ecw[0]);
1937                 return;
1938         }
1939         if (ch->irb->scsw.dstat & DEV_STAT_BUSY) {
1940                 if (ch->irb->scsw.dstat & DEV_STAT_ATTENTION)
1941                         fsm_event(ch->fsm, CH_EVENT_ATTNBUSY, ch);
1942                 else
1943                         fsm_event(ch->fsm, CH_EVENT_BUSY, ch);
1944                 return;
1945         }
1946         if (ch->irb->scsw.dstat & DEV_STAT_ATTENTION) {
1947                 fsm_event(ch->fsm, CH_EVENT_ATTN, ch);
1948                 return;
1949         }
1950         if ((ch->irb->scsw.stctl & SCSW_STCTL_SEC_STATUS) ||
1951             (ch->irb->scsw.stctl == SCSW_STCTL_STATUS_PEND) ||
1952             (ch->irb->scsw.stctl ==
1953              (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND)))
1954                 fsm_event(ch->fsm, CH_EVENT_FINSTAT, ch);
1955         else
1956                 fsm_event(ch->fsm, CH_EVENT_IRQ, ch);
1957
1958 }
1959
1960 /**
1961  * Actions for interface - statemachine.
1962  *****************************************************************************/
1963
1964 /**
1965  * Startup channels by sending CH_EVENT_START to each channel.
1966  *
1967  * @param fi    An instance of an interface statemachine.
1968  * @param event The event, just happened.
1969  * @param arg   Generic pointer, casted from struct net_device * upon call.
1970  */
1971 static void
1972 dev_action_start(fsm_instance * fi, int event, void *arg)
1973 {
1974         struct net_device *dev = (struct net_device *) arg;
1975         struct ctc_priv *privptr = dev->priv;
1976         int direction;
1977
1978         DBF_TEXT(setup, 3, __FUNCTION__);
1979         fsm_deltimer(&privptr->restart_timer);
1980         fsm_newstate(fi, DEV_STATE_STARTWAIT_RXTX);
1981         for (direction = READ; direction <= WRITE; direction++) {
1982                 struct channel *ch = privptr->channel[direction];
1983                 fsm_event(ch->fsm, CH_EVENT_START, ch);
1984         }
1985 }
1986
1987 /**
1988  * Shutdown channels by sending CH_EVENT_STOP to each channel.
1989  *
1990  * @param fi    An instance of an interface statemachine.
1991  * @param event The event, just happened.
1992  * @param arg   Generic pointer, casted from struct net_device * upon call.
1993  */
1994 static void
1995 dev_action_stop(fsm_instance * fi, int event, void *arg)
1996 {
1997         struct net_device *dev = (struct net_device *) arg;
1998         struct ctc_priv *privptr = dev->priv;
1999         int direction;
2000
2001         DBF_TEXT(trace, 3, __FUNCTION__);
2002         fsm_newstate(fi, DEV_STATE_STOPWAIT_RXTX);
2003         for (direction = READ; direction <= WRITE; direction++) {
2004                 struct channel *ch = privptr->channel[direction];
2005                 fsm_event(ch->fsm, CH_EVENT_STOP, ch);
2006         }
2007 }
2008 static void
2009 dev_action_restart(fsm_instance *fi, int event, void *arg)
2010 {
2011         struct net_device *dev = (struct net_device *)arg;
2012         struct ctc_priv *privptr = dev->priv;
2013
2014         DBF_TEXT(trace, 3, __FUNCTION__);
2015         ctc_pr_debug("%s: Restarting\n", dev->name);
2016         dev_action_stop(fi, event, arg);
2017         fsm_event(privptr->fsm, DEV_EVENT_STOP, dev);
2018         fsm_addtimer(&privptr->restart_timer, CTC_TIMEOUT_5SEC,
2019                      DEV_EVENT_START, dev);
2020 }
2021
2022 /**
2023  * Called from channel statemachine
2024  * when a channel is up and running.
2025  *
2026  * @param fi    An instance of an interface statemachine.
2027  * @param event The event, just happened.
2028  * @param arg   Generic pointer, casted from struct net_device * upon call.
2029  */
2030 static void
2031 dev_action_chup(fsm_instance * fi, int event, void *arg)
2032 {
2033         struct net_device *dev = (struct net_device *) arg;
2034
2035         DBF_TEXT(trace, 3, __FUNCTION__);
2036         switch (fsm_getstate(fi)) {
2037                 case DEV_STATE_STARTWAIT_RXTX:
2038                         if (event == DEV_EVENT_RXUP)
2039                                 fsm_newstate(fi, DEV_STATE_STARTWAIT_TX);
2040                         else
2041                                 fsm_newstate(fi, DEV_STATE_STARTWAIT_RX);
2042                         break;
2043                 case DEV_STATE_STARTWAIT_RX:
2044                         if (event == DEV_EVENT_RXUP) {
2045                                 fsm_newstate(fi, DEV_STATE_RUNNING);
2046                                 ctc_pr_info("%s: connected with remote side\n",
2047                                             dev->name);
2048                                 ctc_clear_busy(dev);
2049                         }
2050                         break;
2051                 case DEV_STATE_STARTWAIT_TX:
2052                         if (event == DEV_EVENT_TXUP) {
2053                                 fsm_newstate(fi, DEV_STATE_RUNNING);
2054                                 ctc_pr_info("%s: connected with remote side\n",
2055                                             dev->name);
2056                                 ctc_clear_busy(dev);
2057                         }
2058                         break;
2059                 case DEV_STATE_STOPWAIT_TX:
2060                         if (event == DEV_EVENT_RXUP)
2061                                 fsm_newstate(fi, DEV_STATE_STOPWAIT_RXTX);
2062                         break;
2063                 case DEV_STATE_STOPWAIT_RX:
2064                         if (event == DEV_EVENT_TXUP)
2065                                 fsm_newstate(fi, DEV_STATE_STOPWAIT_RXTX);
2066                         break;
2067         }
2068 }
2069
2070 /**
2071  * Called from channel statemachine
2072  * when a channel has been shutdown.
2073  *
2074  * @param fi    An instance of an interface statemachine.
2075  * @param event The event, just happened.
2076  * @param arg   Generic pointer, casted from struct net_device * upon call.
2077  */
2078 static void
2079 dev_action_chdown(fsm_instance * fi, int event, void *arg)
2080 {
2081
2082         DBF_TEXT(trace, 3, __FUNCTION__);
2083         switch (fsm_getstate(fi)) {
2084                 case DEV_STATE_RUNNING:
2085                         if (event == DEV_EVENT_TXDOWN)
2086                                 fsm_newstate(fi, DEV_STATE_STARTWAIT_TX);
2087                         else
2088                                 fsm_newstate(fi, DEV_STATE_STARTWAIT_RX);
2089                         break;
2090                 case DEV_STATE_STARTWAIT_RX:
2091                         if (event == DEV_EVENT_TXDOWN)
2092                                 fsm_newstate(fi, DEV_STATE_STARTWAIT_RXTX);
2093                         break;
2094                 case DEV_STATE_STARTWAIT_TX:
2095                         if (event == DEV_EVENT_RXDOWN)
2096                                 fsm_newstate(fi, DEV_STATE_STARTWAIT_RXTX);
2097                         break;
2098                 case DEV_STATE_STOPWAIT_RXTX:
2099                         if (event == DEV_EVENT_TXDOWN)
2100                                 fsm_newstate(fi, DEV_STATE_STOPWAIT_RX);
2101                         else
2102                                 fsm_newstate(fi, DEV_STATE_STOPWAIT_TX);
2103                         break;
2104                 case DEV_STATE_STOPWAIT_RX:
2105                         if (event == DEV_EVENT_RXDOWN)
2106                                 fsm_newstate(fi, DEV_STATE_STOPPED);
2107                         break;
2108                 case DEV_STATE_STOPWAIT_TX:
2109                         if (event == DEV_EVENT_TXDOWN)
2110                                 fsm_newstate(fi, DEV_STATE_STOPPED);
2111                         break;
2112         }
2113 }
2114
2115 static const fsm_node dev_fsm[] = {
2116         {DEV_STATE_STOPPED, DEV_EVENT_START, dev_action_start},
2117
2118         {DEV_STATE_STOPWAIT_RXTX,  DEV_EVENT_START,   dev_action_start   },
2119         {DEV_STATE_STOPWAIT_RXTX,  DEV_EVENT_RXDOWN,  dev_action_chdown  },
2120         {DEV_STATE_STOPWAIT_RXTX,  DEV_EVENT_TXDOWN,  dev_action_chdown  },
2121         {DEV_STATE_STOPWAIT_RXTX,  DEV_EVENT_RESTART, dev_action_restart },
2122
2123         {DEV_STATE_STOPWAIT_RX,    DEV_EVENT_START,   dev_action_start   },
2124         {DEV_STATE_STOPWAIT_RX,    DEV_EVENT_RXUP,    dev_action_chup    },
2125         {DEV_STATE_STOPWAIT_RX,    DEV_EVENT_TXUP,    dev_action_chup    },
2126         {DEV_STATE_STOPWAIT_RX,    DEV_EVENT_RXDOWN,  dev_action_chdown  },
2127         {DEV_STATE_STOPWAIT_RX,    DEV_EVENT_RESTART, dev_action_restart },
2128
2129         {DEV_STATE_STOPWAIT_TX,    DEV_EVENT_START,   dev_action_start   },
2130         {DEV_STATE_STOPWAIT_TX,    DEV_EVENT_RXUP,    dev_action_chup    },
2131         {DEV_STATE_STOPWAIT_TX,    DEV_EVENT_TXUP,    dev_action_chup    },
2132         {DEV_STATE_STOPWAIT_TX,    DEV_EVENT_TXDOWN,  dev_action_chdown  },
2133         {DEV_STATE_STOPWAIT_TX,    DEV_EVENT_RESTART, dev_action_restart },
2134
2135         {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_STOP,    dev_action_stop    },
2136         {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_RXUP,    dev_action_chup    },
2137         {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_TXUP,    dev_action_chup    },
2138         {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_RXDOWN,  dev_action_chdown  },
2139         {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_TXDOWN,  dev_action_chdown  },
2140         {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_RESTART, dev_action_restart },
2141
2142         {DEV_STATE_STARTWAIT_TX,   DEV_EVENT_STOP,    dev_action_stop    },
2143         {DEV_STATE_STARTWAIT_TX,   DEV_EVENT_RXUP,    dev_action_chup    },
2144         {DEV_STATE_STARTWAIT_TX,   DEV_EVENT_TXUP,    dev_action_chup    },
2145         {DEV_STATE_STARTWAIT_TX,   DEV_EVENT_RXDOWN,  dev_action_chdown  },
2146         {DEV_STATE_STARTWAIT_TX,   DEV_EVENT_RESTART, dev_action_restart },
2147
2148         {DEV_STATE_STARTWAIT_RX,   DEV_EVENT_STOP,    dev_action_stop    },
2149         {DEV_STATE_STARTWAIT_RX,   DEV_EVENT_RXUP,    dev_action_chup    },
2150         {DEV_STATE_STARTWAIT_RX,   DEV_EVENT_TXUP,    dev_action_chup    },
2151         {DEV_STATE_STARTWAIT_RX,   DEV_EVENT_TXDOWN,  dev_action_chdown  },
2152         {DEV_STATE_STARTWAIT_RX,   DEV_EVENT_RESTART, dev_action_restart },
2153
2154         {DEV_STATE_RUNNING,        DEV_EVENT_STOP,    dev_action_stop    },
2155         {DEV_STATE_RUNNING,        DEV_EVENT_RXDOWN,  dev_action_chdown  },
2156         {DEV_STATE_RUNNING,        DEV_EVENT_TXDOWN,  dev_action_chdown  },
2157         {DEV_STATE_RUNNING,        DEV_EVENT_TXUP,    fsm_action_nop     },
2158         {DEV_STATE_RUNNING,        DEV_EVENT_RXUP,    fsm_action_nop     },
2159         {DEV_STATE_RUNNING,        DEV_EVENT_RESTART, dev_action_restart },
2160 };
2161
2162 static const int DEV_FSM_LEN = sizeof (dev_fsm) / sizeof (fsm_node);
2163
2164 /**
2165  * Transmit a packet.
2166  * This is a helper function for ctc_tx().
2167  *
2168  * @param ch Channel to be used for sending.
2169  * @param skb Pointer to struct sk_buff of packet to send.
2170  *            The linklevel header has already been set up
2171  *            by ctc_tx().
2172  *
2173  * @return 0 on success, -ERRNO on failure. (Never fails.)
2174  */
2175 static int
2176 transmit_skb(struct channel *ch, struct sk_buff *skb)
2177 {
2178         unsigned long saveflags;
2179         struct ll_header header;
2180         int rc = 0;
2181
2182         DBF_TEXT(trace, 5, __FUNCTION__);
2183         /* we need to acquire the lock for testing the state
2184          * otherwise we can have an IRQ changing the state to
2185          * TXIDLE after the test but before acquiring the lock.
2186          */
2187         spin_lock_irqsave(&ch->collect_lock, saveflags);
2188         if (fsm_getstate(ch->fsm) != CH_STATE_TXIDLE) {
2189                 int l = skb->len + LL_HEADER_LENGTH;
2190
2191                 if (ch->collect_len + l > ch->max_bufsize - 2) {
2192                         spin_unlock_irqrestore(&ch->collect_lock, saveflags);
2193                         return -EBUSY;
2194                 } else {
2195                         atomic_inc(&skb->users);
2196                         header.length = l;
2197                         header.type = skb->protocol;
2198                         header.unused = 0;
2199                         memcpy(skb_push(skb, LL_HEADER_LENGTH), &header,
2200                                LL_HEADER_LENGTH);
2201                         skb_queue_tail(&ch->collect_queue, skb);
2202                         ch->collect_len += l;
2203                 }
2204                 spin_unlock_irqrestore(&ch->collect_lock, saveflags);
2205         } else {
2206                 __u16 block_len;
2207                 int ccw_idx;
2208                 struct sk_buff *nskb;
2209                 unsigned long hi;
2210                 spin_unlock_irqrestore(&ch->collect_lock, saveflags);
2211                 /**
2212                  * Protect skb against beeing free'd by upper
2213                  * layers.
2214                  */
2215                 atomic_inc(&skb->users);
2216                 ch->prof.txlen += skb->len;
2217                 header.length = skb->len + LL_HEADER_LENGTH;
2218                 header.type = skb->protocol;
2219                 header.unused = 0;
2220                 memcpy(skb_push(skb, LL_HEADER_LENGTH), &header,
2221                        LL_HEADER_LENGTH);
2222                 block_len = skb->len + 2;
2223                 *((__u16 *) skb_push(skb, 2)) = block_len;
2224
2225                 /**
2226                  * IDAL support in CTC is broken, so we have to
2227                  * care about skb's above 2G ourselves.
2228                  */
2229                 hi = ((unsigned long) skb->tail + LL_HEADER_LENGTH) >> 31;
2230                 if (hi) {
2231                         nskb = alloc_skb(skb->len, GFP_ATOMIC | GFP_DMA);
2232                         if (!nskb) {
2233                                 atomic_dec(&skb->users);
2234                                 skb_pull(skb, LL_HEADER_LENGTH + 2);
2235                                 ctc_clear_busy(ch->netdev);
2236                                 return -ENOMEM;
2237                         } else {
2238                                 memcpy(skb_put(nskb, skb->len),
2239                                        skb->data, skb->len);
2240                                 atomic_inc(&nskb->users);
2241                                 atomic_dec(&skb->users);
2242                                 dev_kfree_skb_irq(skb);
2243                                 skb = nskb;
2244                         }
2245                 }
2246
2247                 ch->ccw[4].count = block_len;
2248                 if (set_normalized_cda(&ch->ccw[4], skb->data)) {
2249                         /**
2250                          * idal allocation failed, try via copying to
2251                          * trans_skb. trans_skb usually has a pre-allocated
2252                          * idal.
2253                          */
2254                         if (ctc_checkalloc_buffer(ch, 1)) {
2255                                 /**
2256                                  * Remove our header. It gets added
2257                                  * again on retransmit.
2258                                  */
2259                                 atomic_dec(&skb->users);
2260                                 skb_pull(skb, LL_HEADER_LENGTH + 2);
2261                                 ctc_clear_busy(ch->netdev);
2262                                 return -EBUSY;
2263                         }
2264
2265                         ch->trans_skb->tail = ch->trans_skb->data;
2266                         ch->trans_skb->len = 0;
2267                         ch->ccw[1].count = skb->len;
2268                         memcpy(skb_put(ch->trans_skb, skb->len), skb->data,
2269                                skb->len);
2270                         atomic_dec(&skb->users);
2271                         dev_kfree_skb_irq(skb);
2272                         ccw_idx = 0;
2273                 } else {
2274                         skb_queue_tail(&ch->io_queue, skb);
2275                         ccw_idx = 3;
2276                 }
2277                 ch->retry = 0;
2278                 fsm_newstate(ch->fsm, CH_STATE_TX);
2279                 fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC, CH_EVENT_TIMER, ch);
2280                 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
2281                 ch->prof.send_stamp = xtime;
2282                 rc = ccw_device_start(ch->cdev, &ch->ccw[ccw_idx],
2283                                       (unsigned long) ch, 0xff, 0);
2284                 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
2285                 if (ccw_idx == 3)
2286                         ch->prof.doios_single++;
2287                 if (rc != 0) {
2288                         fsm_deltimer(&ch->timer);
2289                         ccw_check_return_code(ch, rc, "single skb TX");
2290                         if (ccw_idx == 3)
2291                                 skb_dequeue_tail(&ch->io_queue);
2292                         /**
2293                          * Remove our header. It gets added
2294                          * again on retransmit.
2295                          */
2296                         skb_pull(skb, LL_HEADER_LENGTH + 2);
2297                 } else {
2298                         if (ccw_idx == 0) {
2299                                 struct net_device *dev = ch->netdev;
2300                                 struct ctc_priv *privptr = dev->priv;
2301                                 privptr->stats.tx_packets++;
2302                                 privptr->stats.tx_bytes +=
2303                                     skb->len - LL_HEADER_LENGTH;
2304                         }
2305                 }
2306         }
2307
2308         ctc_clear_busy(ch->netdev);
2309         return rc;
2310 }
2311
2312 /**
2313  * Interface API for upper network layers
2314  *****************************************************************************/
2315
2316 /**
2317  * Open an interface.
2318  * Called from generic network layer when ifconfig up is run.
2319  *
2320  * @param dev Pointer to interface struct.
2321  *
2322  * @return 0 on success, -ERRNO on failure. (Never fails.)
2323  */
2324 static int
2325 ctc_open(struct net_device * dev)
2326 {
2327         DBF_TEXT(trace, 5, __FUNCTION__);
2328         fsm_event(((struct ctc_priv *) dev->priv)->fsm, DEV_EVENT_START, dev);
2329         return 0;
2330 }
2331
2332 /**
2333  * Close an interface.
2334  * Called from generic network layer when ifconfig down is run.
2335  *
2336  * @param dev Pointer to interface struct.
2337  *
2338  * @return 0 on success, -ERRNO on failure. (Never fails.)
2339  */
2340 static int
2341 ctc_close(struct net_device * dev)
2342 {
2343         DBF_TEXT(trace, 5, __FUNCTION__);
2344         fsm_event(((struct ctc_priv *) dev->priv)->fsm, DEV_EVENT_STOP, dev);
2345         return 0;
2346 }
2347
2348 /**
2349  * Start transmission of a packet.
2350  * Called from generic network device layer.
2351  *
2352  * @param skb Pointer to buffer containing the packet.
2353  * @param dev Pointer to interface struct.
2354  *
2355  * @return 0 if packet consumed, !0 if packet rejected.
2356  *         Note: If we return !0, then the packet is free'd by
2357  *               the generic network layer.
2358  */
2359 static int
2360 ctc_tx(struct sk_buff *skb, struct net_device * dev)
2361 {
2362         int rc = 0;
2363         struct ctc_priv *privptr = (struct ctc_priv *) dev->priv;
2364
2365         DBF_TEXT(trace, 5, __FUNCTION__);
2366         /**
2367          * Some sanity checks ...
2368          */
2369         if (skb == NULL) {
2370                 ctc_pr_warn("%s: NULL sk_buff passed\n", dev->name);
2371                 privptr->stats.tx_dropped++;
2372                 return 0;
2373         }
2374         if (skb_headroom(skb) < (LL_HEADER_LENGTH + 2)) {
2375                 ctc_pr_warn("%s: Got sk_buff with head room < %ld bytes\n",
2376                             dev->name, LL_HEADER_LENGTH + 2);
2377                 dev_kfree_skb(skb);
2378                 privptr->stats.tx_dropped++;
2379                 return 0;
2380         }
2381
2382         /**
2383          * If channels are not running, try to restart them
2384          * and throw away packet.
2385          */
2386         if (fsm_getstate(privptr->fsm) != DEV_STATE_RUNNING) {
2387                 fsm_event(privptr->fsm, DEV_EVENT_START, dev);
2388                 dev_kfree_skb(skb);
2389                 privptr->stats.tx_dropped++;
2390                 privptr->stats.tx_errors++;
2391                 privptr->stats.tx_carrier_errors++;
2392                 return 0;
2393         }
2394
2395         if (ctc_test_and_set_busy(dev))
2396                 return -EBUSY;
2397
2398         dev->trans_start = jiffies;
2399         if (transmit_skb(privptr->channel[WRITE], skb) != 0)
2400                 rc = 1;
2401         return rc;
2402 }
2403
2404 /**
2405  * Sets MTU of an interface.
2406  *
2407  * @param dev     Pointer to interface struct.
2408  * @param new_mtu The new MTU to use for this interface.
2409  *
2410  * @return 0 on success, -EINVAL if MTU is out of valid range.
2411  *         (valid range is 576 .. 65527). If VM is on the
2412  *         remote side, maximum MTU is 32760, however this is
2413  *         <em>not</em> checked here.
2414  */
2415 static int
2416 ctc_change_mtu(struct net_device * dev, int new_mtu)
2417 {
2418         struct ctc_priv *privptr = (struct ctc_priv *) dev->priv;
2419
2420         DBF_TEXT(trace, 3, __FUNCTION__);
2421         if ((new_mtu < 576) || (new_mtu > 65527) ||
2422             (new_mtu > (privptr->channel[READ]->max_bufsize -
2423                         LL_HEADER_LENGTH - 2)))
2424                 return -EINVAL;
2425         dev->mtu = new_mtu;
2426         dev->hard_header_len = LL_HEADER_LENGTH + 2;
2427         return 0;
2428 }
2429
2430 /**
2431  * Returns interface statistics of a device.
2432  *
2433  * @param dev Pointer to interface struct.
2434  *
2435  * @return Pointer to stats struct of this interface.
2436  */
2437 static struct net_device_stats *
2438 ctc_stats(struct net_device * dev)
2439 {
2440         return &((struct ctc_priv *) dev->priv)->stats;
2441 }
2442
2443 /*
2444  * sysfs attributes
2445  */
2446
2447 static ssize_t
2448 buffer_show(struct device *dev, struct device_attribute *attr, char *buf)
2449 {
2450         struct ctc_priv *priv;
2451
2452         priv = dev->driver_data;
2453         if (!priv)
2454                 return -ENODEV;
2455         return sprintf(buf, "%d\n",
2456                         priv->buffer_size);
2457 }
2458
2459 static ssize_t
2460 buffer_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
2461 {
2462         struct ctc_priv *priv;
2463         struct net_device *ndev;
2464         int bs1;
2465         char buffer[16];
2466
2467         DBF_TEXT(trace, 3, __FUNCTION__);
2468         DBF_TEXT(trace, 3, buf);
2469         priv = dev->driver_data;
2470         if (!priv) {
2471                 DBF_TEXT(trace, 3, "bfnopriv");
2472                 return -ENODEV;
2473         }
2474
2475         sscanf(buf, "%u", &bs1);
2476         if (bs1 > CTC_BUFSIZE_LIMIT)
2477                 goto einval;
2478         if (bs1 < (576 + LL_HEADER_LENGTH + 2))
2479                 goto einval;
2480         priv->buffer_size = bs1;        // just to overwrite the default
2481
2482         ndev = priv->channel[READ]->netdev;
2483         if (!ndev) {
2484                 DBF_TEXT(trace, 3, "bfnondev");
2485                 return -ENODEV;
2486         }
2487
2488         if ((ndev->flags & IFF_RUNNING) &&
2489             (bs1 < (ndev->mtu + LL_HEADER_LENGTH + 2)))
2490                 goto einval;
2491
2492         priv->channel[READ]->max_bufsize = bs1;
2493         priv->channel[WRITE]->max_bufsize = bs1;
2494         if (!(ndev->flags & IFF_RUNNING))
2495                 ndev->mtu = bs1 - LL_HEADER_LENGTH - 2;
2496         priv->channel[READ]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
2497         priv->channel[WRITE]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
2498
2499         sprintf(buffer, "%d",priv->buffer_size);
2500         DBF_TEXT(trace, 3, buffer);
2501         return count;
2502
2503 einval:
2504         DBF_TEXT(trace, 3, "buff_err");
2505         return -EINVAL;
2506 }
2507
2508 static ssize_t
2509 loglevel_show(struct device *dev, struct device_attribute *attr, char *buf)
2510 {
2511         return sprintf(buf, "%d\n", loglevel);
2512 }
2513
2514 static ssize_t
2515 loglevel_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
2516 {
2517         int ll1;
2518
2519         DBF_TEXT(trace, 5, __FUNCTION__);
2520         sscanf(buf, "%i", &ll1);
2521
2522         if ((ll1 > CTC_LOGLEVEL_MAX) || (ll1 < 0))
2523                 return -EINVAL;
2524         loglevel = ll1;
2525         return count;
2526 }
2527
2528 static void
2529 ctc_print_statistics(struct ctc_priv *priv)
2530 {
2531         char *sbuf;
2532         char *p;
2533
2534         DBF_TEXT(trace, 4, __FUNCTION__);
2535         if (!priv)
2536                 return;
2537         sbuf = kmalloc(2048, GFP_KERNEL);
2538         if (sbuf == NULL)
2539                 return;
2540         p = sbuf;
2541
2542         p += sprintf(p, "  Device FSM state: %s\n",
2543                      fsm_getstate_str(priv->fsm));
2544         p += sprintf(p, "  RX channel FSM state: %s\n",
2545                      fsm_getstate_str(priv->channel[READ]->fsm));
2546         p += sprintf(p, "  TX channel FSM state: %s\n",
2547                      fsm_getstate_str(priv->channel[WRITE]->fsm));
2548         p += sprintf(p, "  Max. TX buffer used: %ld\n",
2549                      priv->channel[WRITE]->prof.maxmulti);
2550         p += sprintf(p, "  Max. chained SKBs: %ld\n",
2551                      priv->channel[WRITE]->prof.maxcqueue);
2552         p += sprintf(p, "  TX single write ops: %ld\n",
2553                      priv->channel[WRITE]->prof.doios_single);
2554         p += sprintf(p, "  TX multi write ops: %ld\n",
2555                      priv->channel[WRITE]->prof.doios_multi);
2556         p += sprintf(p, "  Netto bytes written: %ld\n",
2557                      priv->channel[WRITE]->prof.txlen);
2558         p += sprintf(p, "  Max. TX IO-time: %ld\n",
2559                      priv->channel[WRITE]->prof.tx_time);
2560
2561         ctc_pr_debug("Statistics for %s:\n%s",
2562                      priv->channel[WRITE]->netdev->name, sbuf);
2563         kfree(sbuf);
2564         return;
2565 }
2566
2567 static ssize_t
2568 stats_show(struct device *dev, struct device_attribute *attr, char *buf)
2569 {
2570         struct ctc_priv *priv = dev->driver_data;
2571         if (!priv)
2572                 return -ENODEV;
2573         ctc_print_statistics(priv);
2574         return sprintf(buf, "0\n");
2575 }
2576
2577 static ssize_t
2578 stats_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
2579 {
2580         struct ctc_priv *priv = dev->driver_data;
2581         if (!priv)
2582                 return -ENODEV;
2583         /* Reset statistics */
2584         memset(&priv->channel[WRITE]->prof, 0,
2585                         sizeof(priv->channel[WRITE]->prof));
2586         return count;
2587 }
2588
2589 static void
2590 ctc_netdev_unregister(struct net_device * dev)
2591 {
2592         struct ctc_priv *privptr;
2593
2594         if (!dev)
2595                 return;
2596         privptr = (struct ctc_priv *) dev->priv;
2597         unregister_netdev(dev);
2598 }
2599
2600 static int
2601 ctc_netdev_register(struct net_device * dev)
2602 {
2603         return register_netdev(dev);
2604 }
2605
2606 static void
2607 ctc_free_netdevice(struct net_device * dev, int free_dev)
2608 {
2609         struct ctc_priv *privptr;
2610         if (!dev)
2611                 return;
2612         privptr = dev->priv;
2613         if (privptr) {
2614                 if (privptr->fsm)
2615                         kfree_fsm(privptr->fsm);
2616                 kfree(privptr);
2617         }
2618 #ifdef MODULE
2619         if (free_dev)
2620                 free_netdev(dev);
2621 #endif
2622 }
2623
2624 static ssize_t
2625 ctc_proto_show(struct device *dev, struct device_attribute *attr, char *buf)
2626 {
2627         struct ctc_priv *priv;
2628
2629         priv = dev->driver_data;
2630         if (!priv)
2631                 return -ENODEV;
2632
2633         return sprintf(buf, "%d\n", priv->protocol);
2634 }
2635
2636 static ssize_t
2637 ctc_proto_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
2638 {
2639         struct ctc_priv *priv;
2640         int value;
2641
2642         DBF_TEXT(trace, 3, __FUNCTION__);
2643         pr_debug("%s() called\n", __FUNCTION__);
2644
2645         priv = dev->driver_data;
2646         if (!priv)
2647                 return -ENODEV;
2648         sscanf(buf, "%u", &value);
2649         if (!((value == CTC_PROTO_S390)  ||
2650               (value == CTC_PROTO_LINUX) ||
2651               (value == CTC_PROTO_OS390)))
2652                 return -EINVAL;
2653         priv->protocol = value;
2654
2655         return count;
2656 }
2657
2658 static ssize_t
2659 ctc_type_show(struct device *dev, struct device_attribute *attr, char *buf)
2660 {
2661         struct ccwgroup_device *cgdev;
2662
2663         cgdev = to_ccwgroupdev(dev);
2664         if (!cgdev)
2665                 return -ENODEV;
2666
2667         return sprintf(buf, "%s\n", cu3088_type[cgdev->cdev[0]->id.driver_info]);
2668 }
2669
2670 static DEVICE_ATTR(buffer, 0644, buffer_show, buffer_write);
2671 static DEVICE_ATTR(protocol, 0644, ctc_proto_show, ctc_proto_store);
2672 static DEVICE_ATTR(type, 0444, ctc_type_show, NULL);
2673
2674 static DEVICE_ATTR(loglevel, 0644, loglevel_show, loglevel_write);
2675 static DEVICE_ATTR(stats, 0644, stats_show, stats_write);
2676
2677 static struct attribute *ctc_attr[] = {
2678         &dev_attr_protocol.attr,
2679         &dev_attr_type.attr,
2680         &dev_attr_buffer.attr,
2681         NULL,
2682 };
2683
2684 static struct attribute_group ctc_attr_group = {
2685         .attrs = ctc_attr,
2686 };
2687
2688 static int
2689 ctc_add_attributes(struct device *dev)
2690 {
2691         int rc;
2692
2693         rc = device_create_file(dev, &dev_attr_loglevel);
2694         if (rc)
2695                 goto out;
2696         rc = device_create_file(dev, &dev_attr_stats);
2697         if (!rc)
2698                 goto out;
2699         device_remove_file(dev, &dev_attr_loglevel);
2700 out:
2701         return rc;
2702 }
2703
2704 static void
2705 ctc_remove_attributes(struct device *dev)
2706 {
2707         device_remove_file(dev, &dev_attr_stats);
2708         device_remove_file(dev, &dev_attr_loglevel);
2709 }
2710
2711 static int
2712 ctc_add_files(struct device *dev)
2713 {
2714         pr_debug("%s() called\n", __FUNCTION__);
2715
2716         return sysfs_create_group(&dev->kobj, &ctc_attr_group);
2717 }
2718
2719 static void
2720 ctc_remove_files(struct device *dev)
2721 {
2722         pr_debug("%s() called\n", __FUNCTION__);
2723
2724         sysfs_remove_group(&dev->kobj, &ctc_attr_group);
2725 }
2726
2727 /**
2728  * Add ctc specific attributes.
2729  * Add ctc private data.
2730  *
2731  * @param cgdev pointer to ccwgroup_device just added
2732  *
2733  * @returns 0 on success, !0 on failure.
2734  */
2735 static int
2736 ctc_probe_device(struct ccwgroup_device *cgdev)
2737 {
2738         struct ctc_priv *priv;
2739         int rc;
2740         char buffer[16];
2741
2742         pr_debug("%s() called\n", __FUNCTION__);
2743         DBF_TEXT(setup, 3, __FUNCTION__);
2744
2745         if (!get_device(&cgdev->dev))
2746                 return -ENODEV;
2747
2748         priv = kmalloc(sizeof (struct ctc_priv), GFP_KERNEL);
2749         if (!priv) {
2750                 ctc_pr_err("%s: Out of memory\n", __func__);
2751                 put_device(&cgdev->dev);
2752                 return -ENOMEM;
2753         }
2754
2755         memset(priv, 0, sizeof (struct ctc_priv));
2756         rc = ctc_add_files(&cgdev->dev);
2757         if (rc) {
2758                 kfree(priv);
2759                 put_device(&cgdev->dev);
2760                 return rc;
2761         }
2762         priv->buffer_size = CTC_BUFSIZE_DEFAULT;
2763         cgdev->cdev[0]->handler = ctc_irq_handler;
2764         cgdev->cdev[1]->handler = ctc_irq_handler;
2765         cgdev->dev.driver_data = priv;
2766
2767         sprintf(buffer, "%p", priv);
2768         DBF_TEXT(data, 3, buffer);
2769
2770         sprintf(buffer, "%u", (unsigned int)sizeof(struct ctc_priv));
2771         DBF_TEXT(data, 3, buffer);
2772
2773         sprintf(buffer, "%p", &channels);
2774         DBF_TEXT(data, 3, buffer);
2775
2776         sprintf(buffer, "%u", (unsigned int)sizeof(struct channel));
2777         DBF_TEXT(data, 3, buffer);
2778
2779         return 0;
2780 }
2781
2782 /**
2783  * Initialize everything of the net device except the name and the
2784  * channel structs.
2785  */
2786 static struct net_device *
2787 ctc_init_netdevice(struct net_device * dev, int alloc_device,
2788                    struct ctc_priv *privptr)
2789 {
2790         if (!privptr)
2791                 return NULL;
2792
2793         DBF_TEXT(setup, 3, __FUNCTION__);
2794
2795         if (alloc_device) {
2796                 dev = kmalloc(sizeof (struct net_device), GFP_KERNEL);
2797                 if (!dev)
2798                         return NULL;
2799                 memset(dev, 0, sizeof (struct net_device));
2800         }
2801
2802         dev->priv = privptr;
2803         privptr->fsm = init_fsm("ctcdev", dev_state_names,
2804                                 dev_event_names, CTC_NR_DEV_STATES, CTC_NR_DEV_EVENTS,
2805                                 dev_fsm, DEV_FSM_LEN, GFP_KERNEL);
2806         if (privptr->fsm == NULL) {
2807                 if (alloc_device)
2808                         kfree(dev);
2809                 return NULL;
2810         }
2811         fsm_newstate(privptr->fsm, DEV_STATE_STOPPED);
2812         fsm_settimer(privptr->fsm, &privptr->restart_timer);
2813         if (dev->mtu == 0)
2814                 dev->mtu = CTC_BUFSIZE_DEFAULT - LL_HEADER_LENGTH - 2;
2815         dev->hard_start_xmit = ctc_tx;
2816         dev->open = ctc_open;
2817         dev->stop = ctc_close;
2818         dev->get_stats = ctc_stats;
2819         dev->change_mtu = ctc_change_mtu;
2820         dev->hard_header_len = LL_HEADER_LENGTH + 2;
2821         dev->addr_len = 0;
2822         dev->type = ARPHRD_SLIP;
2823         dev->tx_queue_len = 100;
2824         dev->flags = IFF_POINTOPOINT | IFF_NOARP;
2825         SET_MODULE_OWNER(dev);
2826         return dev;
2827 }
2828
2829
2830 /**
2831  *
2832  * Setup an interface.
2833  *
2834  * @param cgdev  Device to be setup.
2835  *
2836  * @returns 0 on success, !0 on failure.
2837  */
2838 static int
2839 ctc_new_device(struct ccwgroup_device *cgdev)
2840 {
2841         char read_id[CTC_ID_SIZE];
2842         char write_id[CTC_ID_SIZE];
2843         int direction;
2844         enum channel_types type;
2845         struct ctc_priv *privptr;
2846         struct net_device *dev;
2847         int ret;
2848         char buffer[16];
2849
2850         pr_debug("%s() called\n", __FUNCTION__);
2851         DBF_TEXT(setup, 3, __FUNCTION__);
2852
2853         privptr = cgdev->dev.driver_data;
2854         if (!privptr)
2855                 return -ENODEV;
2856
2857         sprintf(buffer, "%d", privptr->buffer_size);
2858         DBF_TEXT(setup, 3, buffer);
2859
2860         type = get_channel_type(&cgdev->cdev[0]->id);
2861
2862         snprintf(read_id, CTC_ID_SIZE, "ch-%s", cgdev->cdev[0]->dev.bus_id);
2863         snprintf(write_id, CTC_ID_SIZE, "ch-%s", cgdev->cdev[1]->dev.bus_id);
2864
2865         if (add_channel(cgdev->cdev[0], type))
2866                 return -ENOMEM;
2867         if (add_channel(cgdev->cdev[1], type))
2868                 return -ENOMEM;
2869
2870         ret = ccw_device_set_online(cgdev->cdev[0]);
2871         if (ret != 0) {
2872                         printk(KERN_WARNING
2873                         "ccw_device_set_online (cdev[0]) failed with ret = %d\n", ret);
2874         }
2875
2876         ret = ccw_device_set_online(cgdev->cdev[1]);
2877         if (ret != 0) {
2878                         printk(KERN_WARNING
2879                         "ccw_device_set_online (cdev[1]) failed with ret = %d\n", ret);
2880         }
2881
2882         dev = ctc_init_netdevice(NULL, 1, privptr);
2883
2884         if (!dev) {
2885                 ctc_pr_warn("ctc_init_netdevice failed\n");
2886                 goto out;
2887         }
2888
2889         strlcpy(dev->name, "ctc%d", IFNAMSIZ);
2890
2891         for (direction = READ; direction <= WRITE; direction++) {
2892                 privptr->channel[direction] =
2893                     channel_get(type, direction == READ ? read_id : write_id,
2894                                 direction);
2895                 if (privptr->channel[direction] == NULL) {
2896                         if (direction == WRITE)
2897                                 channel_free(privptr->channel[READ]);
2898
2899                         ctc_free_netdevice(dev, 1);
2900                         goto out;
2901                 }
2902                 privptr->channel[direction]->netdev = dev;
2903                 privptr->channel[direction]->protocol = privptr->protocol;
2904                 privptr->channel[direction]->max_bufsize = privptr->buffer_size;
2905         }
2906         /* sysfs magic */
2907         SET_NETDEV_DEV(dev, &cgdev->dev);
2908
2909         if (ctc_netdev_register(dev) != 0) {
2910                 ctc_free_netdevice(dev, 1);
2911                 goto out;
2912         }
2913
2914         if (ctc_add_attributes(&cgdev->dev)) {
2915                 ctc_netdev_unregister(dev);
2916                 dev->priv = NULL;
2917                 ctc_free_netdevice(dev, 1);
2918                 goto out;
2919         }
2920
2921         strlcpy(privptr->fsm->name, dev->name, sizeof (privptr->fsm->name));
2922
2923         print_banner();
2924
2925         ctc_pr_info("%s: read: %s, write: %s, proto: %d\n",
2926                     dev->name, privptr->channel[READ]->id,
2927                     privptr->channel[WRITE]->id, privptr->protocol);
2928
2929         return 0;
2930 out:
2931         ccw_device_set_offline(cgdev->cdev[1]);
2932         ccw_device_set_offline(cgdev->cdev[0]);
2933
2934         return -ENODEV;
2935 }
2936
2937 /**
2938  * Shutdown an interface.
2939  *
2940  * @param cgdev  Device to be shut down.
2941  *
2942  * @returns 0 on success, !0 on failure.
2943  */
2944 static int
2945 ctc_shutdown_device(struct ccwgroup_device *cgdev)
2946 {
2947         struct ctc_priv *priv;
2948         struct net_device *ndev;
2949
2950         DBF_TEXT(setup, 3, __FUNCTION__);
2951         pr_debug("%s() called\n", __FUNCTION__);
2952
2953
2954         priv = cgdev->dev.driver_data;
2955         ndev = NULL;
2956         if (!priv)
2957                 return -ENODEV;
2958
2959         if (priv->channel[READ]) {
2960                 ndev = priv->channel[READ]->netdev;
2961
2962                 /* Close the device */
2963                 ctc_close(ndev);
2964                 ndev->flags &=~IFF_RUNNING;
2965
2966                 ctc_remove_attributes(&cgdev->dev);
2967
2968                 channel_free(priv->channel[READ]);
2969         }
2970         if (priv->channel[WRITE])
2971                 channel_free(priv->channel[WRITE]);
2972
2973         if (ndev) {
2974                 ctc_netdev_unregister(ndev);
2975                 ndev->priv = NULL;
2976                 ctc_free_netdevice(ndev, 1);
2977         }
2978
2979         if (priv->fsm)
2980                 kfree_fsm(priv->fsm);
2981
2982         ccw_device_set_offline(cgdev->cdev[1]);
2983         ccw_device_set_offline(cgdev->cdev[0]);
2984
2985         if (priv->channel[READ])
2986                 channel_remove(priv->channel[READ]);
2987         if (priv->channel[WRITE])
2988                 channel_remove(priv->channel[WRITE]);
2989         priv->channel[READ] = priv->channel[WRITE] = NULL;
2990
2991         return 0;
2992
2993 }
2994
2995 static void
2996 ctc_remove_device(struct ccwgroup_device *cgdev)
2997 {
2998         struct ctc_priv *priv;
2999
3000         pr_debug("%s() called\n", __FUNCTION__);
3001         DBF_TEXT(setup, 3, __FUNCTION__);
3002
3003         priv = cgdev->dev.driver_data;
3004         if (!priv)
3005                 return;
3006         if (cgdev->state == CCWGROUP_ONLINE)
3007                 ctc_shutdown_device(cgdev);
3008         ctc_remove_files(&cgdev->dev);
3009         cgdev->dev.driver_data = NULL;
3010         kfree(priv);
3011         put_device(&cgdev->dev);
3012 }
3013
3014 static struct ccwgroup_driver ctc_group_driver = {
3015         .owner       = THIS_MODULE,
3016         .name        = "ctc",
3017         .max_slaves  = 2,
3018         .driver_id   = 0xC3E3C3,
3019         .probe       = ctc_probe_device,
3020         .remove      = ctc_remove_device,
3021         .set_online  = ctc_new_device,
3022         .set_offline = ctc_shutdown_device,
3023 };
3024
3025 /**
3026  * Module related routines
3027  *****************************************************************************/
3028
3029 /**
3030  * Prepare to be unloaded. Free IRQ's and release all resources.
3031  * This is called just before this module is unloaded. It is
3032  * <em>not</em> called, if the usage count is !0, so we don't need to check
3033  * for that.
3034  */
3035 static void __exit
3036 ctc_exit(void)
3037 {
3038         DBF_TEXT(setup, 3, __FUNCTION__);
3039         unregister_cu3088_discipline(&ctc_group_driver);
3040         ctc_unregister_dbf_views();
3041         ctc_pr_info("CTC driver unloaded\n");
3042 }
3043
3044 /**
3045  * Initialize module.
3046  * This is called just after the module is loaded.
3047  *
3048  * @return 0 on success, !0 on error.
3049  */
3050 static int __init
3051 ctc_init(void)
3052 {
3053         int ret = 0;
3054
3055         loglevel = CTC_LOGLEVEL_DEFAULT;
3056
3057         DBF_TEXT(setup, 3, __FUNCTION__);
3058
3059         print_banner();
3060
3061         ret = ctc_register_dbf_views();
3062         if (ret){
3063                 ctc_pr_crit("ctc_init failed with ctc_register_dbf_views rc = %d\n", ret);
3064                 return ret;
3065         }
3066         ret = register_cu3088_discipline(&ctc_group_driver);
3067         if (ret) {
3068                 ctc_unregister_dbf_views();
3069         }
3070         return ret;
3071 }
3072
3073 module_init(ctc_init);
3074 module_exit(ctc_exit);
3075
3076 /* --- This is the END my friend --- */