err.no Git - linux-2.6/blob - 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         ch = kzalloc(sizeof(struct channel), GFP_KERNEL);
1642         if (!ch) {
1643                 ctc_pr_warn("ctc: Out of memory in add_channel\n");
1644                 return -1;
1645         }
1646         /* assure all flags and counters are reset */
1647         ch->ccw = kzalloc(8 * sizeof(struct ccw1), GFP_KERNEL | GFP_DMA);
1648         if (!ch->ccw) {
1649                 kfree(ch);
1650                 ctc_pr_warn("ctc: Out of memory in add_channel\n");
1651                 return -1;
1652         }
1653
1654
1655         /**
1656          * "static" ccws are used in the following way:
1657          *
1658          * ccw[0..2] (Channel program for generic I/O):
1659          *           0: prepare
1660          *           1: read or write (depending on direction) with fixed
1661          *              buffer (idal allocated once when buffer is allocated)
1662          *           2: nop
1663          * ccw[3..5] (Channel program for direct write of packets)
1664          *           3: prepare
1665          *           4: write (idal allocated on every write).
1666          *           5: nop
1667          * ccw[6..7] (Channel program for initial channel setup):
1668          *           6: set extended mode
1669          *           7: nop
1670          *
1671          * ch->ccw[0..5] are initialized in ch_action_start because
1672          * the channel's direction is yet unknown here.
1673          */
1674         ch->ccw[6].cmd_code = CCW_CMD_SET_EXTENDED;
1675         ch->ccw[6].flags = CCW_FLAG_SLI;
1676
1677         ch->ccw[7].cmd_code = CCW_CMD_NOOP;
1678         ch->ccw[7].flags = CCW_FLAG_SLI;
1679
1680         ch->cdev = cdev;
1681         snprintf(ch->id, CTC_ID_SIZE, "ch-%s", cdev->dev.bus_id);
1682         ch->type = type;
1683         ch->fsm = init_fsm(ch->id, ch_state_names,
1684                            ch_event_names, NR_CH_STATES, NR_CH_EVENTS,
1685                            ch_fsm, CH_FSM_LEN, GFP_KERNEL);
1686         if (ch->fsm == NULL) {
1687                 ctc_pr_warn("ctc: Could not create FSM in add_channel\n");
1688                 kfree(ch->ccw);
1689                 kfree(ch);
1690                 return -1;
1691         }
1692         fsm_newstate(ch->fsm, CH_STATE_IDLE);
1693         ch->irb = kzalloc(sizeof(struct irb), GFP_KERNEL);
1694         if (!ch->irb) {
1695                 ctc_pr_warn("ctc: Out of memory in add_channel\n");
1696                 kfree_fsm(ch->fsm);
1697                 kfree(ch->ccw);
1698                 kfree(ch);
1699                 return -1;
1700         }
1701         while (*c && less_than((*c)->id, ch->id))
1702                 c = &(*c)->next;
1703         if (*c && (!strncmp((*c)->id, ch->id, CTC_ID_SIZE))) {
1704                 ctc_pr_debug(
1705                         "ctc: add_channel: device %s already in list, "
1706                         "using old entry\n", (*c)->id);
1707                 kfree(ch->irb);
1708                 kfree_fsm(ch->fsm);
1709                 kfree(ch->ccw);
1710                 kfree(ch);
1711                 return 0;
1712         }
1713
1714         spin_lock_init(&ch->collect_lock);
1715
1716         fsm_settimer(ch->fsm, &ch->timer);
1717         skb_queue_head_init(&ch->io_queue);
1718         skb_queue_head_init(&ch->collect_queue);
1719         ch->next = *c;
1720         *c = ch;
1721         return 0;
1722 }
1723
1724 /**
1725  * Release a specific channel in the channel list.
1726  *
1727  * @param ch Pointer to channel struct to be released.
1728  */
1729 static void
1730 channel_free(struct channel *ch)
1731 {
1732         ch->flags &= ~CHANNEL_FLAGS_INUSE;
1733         fsm_newstate(ch->fsm, CH_STATE_IDLE);
1734 }
1735
1736 /**
1737  * Remove a specific channel in the channel list.
1738  *
1739  * @param ch Pointer to channel struct to be released.
1740  */
1741 static void
1742 channel_remove(struct channel *ch)
1743 {
1744         struct channel **c = &channels;
1745
1746         DBF_TEXT(trace, 2, __FUNCTION__);
1747         if (ch == NULL)
1748                 return;
1749
1750         channel_free(ch);
1751         while (*c) {
1752                 if (*c == ch) {
1753                         *c = ch->next;
1754                         fsm_deltimer(&ch->timer);
1755                         kfree_fsm(ch->fsm);
1756                         clear_normalized_cda(&ch->ccw[4]);
1757                         if (ch->trans_skb != NULL) {
1758                                 clear_normalized_cda(&ch->ccw[1]);
1759                                 dev_kfree_skb(ch->trans_skb);
1760                         }
1761                         kfree(ch->ccw);
1762                         kfree(ch->irb);
1763                         kfree(ch);
1764                         return;
1765                 }
1766                 c = &((*c)->next);
1767         }
1768 }
1769
1770 /**
1771  * Get a specific channel from the channel list.
1772  *
1773  * @param type Type of channel we are interested in.
1774  * @param id Id of channel we are interested in.
1775  * @param direction Direction we want to use this channel for.
1776  *
1777  * @return Pointer to a channel or NULL if no matching channel available.
1778  */
1779 static struct channel
1780 *
1781 channel_get(enum channel_types type, char *id, int direction)
1782 {
1783         struct channel *ch = channels;
1784
1785         DBF_TEXT(trace, 3, __FUNCTION__);
1786 #ifdef DEBUG
1787         ctc_pr_debug("ctc: %s(): searching for ch with id %s and type %d\n",
1788                      __func__, id, type);
1789 #endif
1790
1791         while (ch && ((strncmp(ch->id, id, CTC_ID_SIZE)) || (ch->type != type))) {
1792 #ifdef DEBUG
1793                 ctc_pr_debug("ctc: %s(): ch=0x%p (id=%s, type=%d\n",
1794                              __func__, ch, ch->id, ch->type);
1795 #endif
1796                 ch = ch->next;
1797         }
1798 #ifdef DEBUG
1799         ctc_pr_debug("ctc: %s(): ch=0x%pq (id=%s, type=%d\n",
1800                      __func__, ch, ch->id, ch->type);
1801 #endif
1802         if (!ch) {
1803                 ctc_pr_warn("ctc: %s(): channel with id %s "
1804                             "and type %d not found in channel list\n",
1805                             __func__, id, type);
1806         } else {
1807                 if (ch->flags & CHANNEL_FLAGS_INUSE)
1808                         ch = NULL;
1809                 else {
1810                         ch->flags |= CHANNEL_FLAGS_INUSE;
1811                         ch->flags &= ~CHANNEL_FLAGS_RWMASK;
1812                         ch->flags |= (direction == WRITE)
1813                             ? CHANNEL_FLAGS_WRITE : CHANNEL_FLAGS_READ;
1814                         fsm_newstate(ch->fsm, CH_STATE_STOPPED);
1815                 }
1816         }
1817         return ch;
1818 }
1819
1820 /**
1821  * Return the channel type by name.
1822  *
1823  * @param name Name of network interface.
1824  *
1825  * @return Type class of channel to be used for that interface.
1826  */
1827 static enum channel_types inline
1828 extract_channel_media(char *name)
1829 {
1830         enum channel_types ret = channel_type_unknown;
1831
1832         if (name != NULL) {
1833                 if (strncmp(name, "ctc", 3) == 0)
1834                         ret = channel_type_parallel;
1835                 if (strncmp(name, "escon", 5) == 0)
1836                         ret = channel_type_escon;
1837         }
1838         return ret;
1839 }
1840
1841 static long
1842 __ctc_check_irb_error(struct ccw_device *cdev, struct irb *irb)
1843 {
1844         if (!IS_ERR(irb))
1845                 return 0;
1846
1847         switch (PTR_ERR(irb)) {
1848         case -EIO:
1849                 ctc_pr_warn("i/o-error on device %s\n", cdev->dev.bus_id);
1850 //              CTC_DBF_TEXT(trace, 2, "ckirberr");
1851 //              CTC_DBF_TEXT_(trace, 2, "  rc%d", -EIO);
1852                 break;
1853         case -ETIMEDOUT:
1854                 ctc_pr_warn("timeout on device %s\n", cdev->dev.bus_id);
1855 //              CTC_DBF_TEXT(trace, 2, "ckirberr");
1856 //              CTC_DBF_TEXT_(trace, 2, "  rc%d", -ETIMEDOUT);
1857                 break;
1858         default:
1859                 ctc_pr_warn("unknown error %ld on device %s\n", PTR_ERR(irb),
1860                            cdev->dev.bus_id);
1861 //              CTC_DBF_TEXT(trace, 2, "ckirberr");
1862 //              CTC_DBF_TEXT(trace, 2, "  rc???");
1863         }
1864         return PTR_ERR(irb);
1865 }
1866
1867 /**
1868  * Main IRQ handler.
1869  *
1870  * @param cdev    The ccw_device the interrupt is for.
1871  * @param intparm interruption parameter.
1872  * @param irb     interruption response block.
1873  */
1874 static void
1875 ctc_irq_handler(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
1876 {
1877         struct channel *ch;
1878         struct net_device *dev;
1879         struct ctc_priv *priv;
1880
1881         DBF_TEXT(trace, 5, __FUNCTION__);
1882         if (__ctc_check_irb_error(cdev, irb))
1883                 return;
1884
1885         /* Check for unsolicited interrupts. */
1886         if (!cdev->dev.driver_data) {
1887                 ctc_pr_warn("ctc: Got unsolicited irq: %s c-%02x d-%02x\n",
1888                             cdev->dev.bus_id, irb->scsw.cstat,
1889                             irb->scsw.dstat);
1890                 return;
1891         }
1892
1893         priv = ((struct ccwgroup_device *)cdev->dev.driver_data)
1894                 ->dev.driver_data;
1895
1896         /* Try to extract channel from driver data. */
1897         if (priv->channel[READ]->cdev == cdev)
1898                 ch = priv->channel[READ];
1899         else if (priv->channel[WRITE]->cdev == cdev)
1900                 ch = priv->channel[WRITE];
1901         else {
1902                 ctc_pr_err("ctc: Can't determine channel for interrupt, "
1903                            "device %s\n", cdev->dev.bus_id);
1904                 return;
1905         }
1906
1907         dev = (struct net_device *) (ch->netdev);
1908         if (dev == NULL) {
1909                 ctc_pr_crit("ctc: ctc_irq_handler dev=NULL bus_id=%s, ch=0x%p\n",
1910                             cdev->dev.bus_id, ch);
1911                 return;
1912         }
1913
1914 #ifdef DEBUG
1915         ctc_pr_debug("%s: interrupt for device: %s received c-%02x d-%02x\n",
1916                      dev->name, ch->id, irb->scsw.cstat, irb->scsw.dstat);
1917 #endif
1918
1919         /* Copy interruption response block. */
1920         memcpy(ch->irb, irb, sizeof(struct irb));
1921
1922         /* Check for good subchannel return code, otherwise error message */
1923         if (ch->irb->scsw.cstat) {
1924                 fsm_event(ch->fsm, CH_EVENT_SC_UNKNOWN, ch);
1925                 ctc_pr_warn("%s: subchannel check for device: %s - %02x %02x\n",
1926                             dev->name, ch->id, ch->irb->scsw.cstat,
1927                             ch->irb->scsw.dstat);
1928                 return;
1929         }
1930
1931         /* Check the reason-code of a unit check */
1932         if (ch->irb->scsw.dstat & DEV_STAT_UNIT_CHECK) {
1933                 ccw_unit_check(ch, ch->irb->ecw[0]);
1934                 return;
1935         }
1936         if (ch->irb->scsw.dstat & DEV_STAT_BUSY) {
1937                 if (ch->irb->scsw.dstat & DEV_STAT_ATTENTION)
1938                         fsm_event(ch->fsm, CH_EVENT_ATTNBUSY, ch);
1939                 else
1940                         fsm_event(ch->fsm, CH_EVENT_BUSY, ch);
1941                 return;
1942         }
1943         if (ch->irb->scsw.dstat & DEV_STAT_ATTENTION) {
1944                 fsm_event(ch->fsm, CH_EVENT_ATTN, ch);
1945                 return;
1946         }
1947         if ((ch->irb->scsw.stctl & SCSW_STCTL_SEC_STATUS) ||
1948             (ch->irb->scsw.stctl == SCSW_STCTL_STATUS_PEND) ||
1949             (ch->irb->scsw.stctl ==
1950              (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND)))
1951                 fsm_event(ch->fsm, CH_EVENT_FINSTAT, ch);
1952         else
1953                 fsm_event(ch->fsm, CH_EVENT_IRQ, ch);
1954
1955 }
1956
1957 /**
1958  * Actions for interface - statemachine.
1959  *****************************************************************************/
1960
1961 /**
1962  * Startup channels by sending CH_EVENT_START to each channel.
1963  *
1964  * @param fi    An instance of an interface statemachine.
1965  * @param event The event, just happened.
1966  * @param arg   Generic pointer, casted from struct net_device * upon call.
1967  */
1968 static void
1969 dev_action_start(fsm_instance * fi, int event, void *arg)
1970 {
1971         struct net_device *dev = (struct net_device *) arg;
1972         struct ctc_priv *privptr = dev->priv;
1973         int direction;
1974
1975         DBF_TEXT(setup, 3, __FUNCTION__);
1976         fsm_deltimer(&privptr->restart_timer);
1977         fsm_newstate(fi, DEV_STATE_STARTWAIT_RXTX);
1978         for (direction = READ; direction <= WRITE; direction++) {
1979                 struct channel *ch = privptr->channel[direction];
1980                 fsm_event(ch->fsm, CH_EVENT_START, ch);
1981         }
1982 }
1983
1984 /**
1985  * Shutdown channels by sending CH_EVENT_STOP to each channel.
1986  *
1987  * @param fi    An instance of an interface statemachine.
1988  * @param event The event, just happened.
1989  * @param arg   Generic pointer, casted from struct net_device * upon call.
1990  */
1991 static void
1992 dev_action_stop(fsm_instance * fi, int event, void *arg)
1993 {
1994         struct net_device *dev = (struct net_device *) arg;
1995         struct ctc_priv *privptr = dev->priv;
1996         int direction;
1997
1998         DBF_TEXT(trace, 3, __FUNCTION__);
1999         fsm_newstate(fi, DEV_STATE_STOPWAIT_RXTX);
2000         for (direction = READ; direction <= WRITE; direction++) {
2001                 struct channel *ch = privptr->channel[direction];
2002                 fsm_event(ch->fsm, CH_EVENT_STOP, ch);
2003         }
2004 }
2005 static void
2006 dev_action_restart(fsm_instance *fi, int event, void *arg)
2007 {
2008         struct net_device *dev = (struct net_device *)arg;
2009         struct ctc_priv *privptr = dev->priv;
2010
2011         DBF_TEXT(trace, 3, __FUNCTION__);
2012         ctc_pr_debug("%s: Restarting\n", dev->name);
2013         dev_action_stop(fi, event, arg);
2014         fsm_event(privptr->fsm, DEV_EVENT_STOP, dev);
2015         fsm_addtimer(&privptr->restart_timer, CTC_TIMEOUT_5SEC,
2016                      DEV_EVENT_START, dev);
2017 }
2018
2019 /**
2020  * Called from channel statemachine
2021  * when a channel is up and running.
2022  *
2023  * @param fi    An instance of an interface statemachine.
2024  * @param event The event, just happened.
2025  * @param arg   Generic pointer, casted from struct net_device * upon call.
2026  */
2027 static void
2028 dev_action_chup(fsm_instance * fi, int event, void *arg)
2029 {
2030         struct net_device *dev = (struct net_device *) arg;
2031
2032         DBF_TEXT(trace, 3, __FUNCTION__);
2033         switch (fsm_getstate(fi)) {
2034                 case DEV_STATE_STARTWAIT_RXTX:
2035                         if (event == DEV_EVENT_RXUP)
2036                                 fsm_newstate(fi, DEV_STATE_STARTWAIT_TX);
2037                         else
2038                                 fsm_newstate(fi, DEV_STATE_STARTWAIT_RX);
2039                         break;
2040                 case DEV_STATE_STARTWAIT_RX:
2041                         if (event == DEV_EVENT_RXUP) {
2042                                 fsm_newstate(fi, DEV_STATE_RUNNING);
2043                                 ctc_pr_info("%s: connected with remote side\n",
2044                                             dev->name);
2045                                 ctc_clear_busy(dev);
2046                         }
2047                         break;
2048                 case DEV_STATE_STARTWAIT_TX:
2049                         if (event == DEV_EVENT_TXUP) {
2050                                 fsm_newstate(fi, DEV_STATE_RUNNING);
2051                                 ctc_pr_info("%s: connected with remote side\n",
2052                                             dev->name);
2053                                 ctc_clear_busy(dev);
2054                         }
2055                         break;
2056                 case DEV_STATE_STOPWAIT_TX:
2057                         if (event == DEV_EVENT_RXUP)
2058                                 fsm_newstate(fi, DEV_STATE_STOPWAIT_RXTX);
2059                         break;
2060                 case DEV_STATE_STOPWAIT_RX:
2061                         if (event == DEV_EVENT_TXUP)
2062                                 fsm_newstate(fi, DEV_STATE_STOPWAIT_RXTX);
2063                         break;
2064         }
2065 }
2066
2067 /**
2068  * Called from channel statemachine
2069  * when a channel has been shutdown.
2070  *
2071  * @param fi    An instance of an interface statemachine.
2072  * @param event The event, just happened.
2073  * @param arg   Generic pointer, casted from struct net_device * upon call.
2074  */
2075 static void
2076 dev_action_chdown(fsm_instance * fi, int event, void *arg)
2077 {
2078
2079         DBF_TEXT(trace, 3, __FUNCTION__);
2080         switch (fsm_getstate(fi)) {
2081                 case DEV_STATE_RUNNING:
2082                         if (event == DEV_EVENT_TXDOWN)
2083                                 fsm_newstate(fi, DEV_STATE_STARTWAIT_TX);
2084                         else
2085                                 fsm_newstate(fi, DEV_STATE_STARTWAIT_RX);
2086                         break;
2087                 case DEV_STATE_STARTWAIT_RX:
2088                         if (event == DEV_EVENT_TXDOWN)
2089                                 fsm_newstate(fi, DEV_STATE_STARTWAIT_RXTX);
2090                         break;
2091                 case DEV_STATE_STARTWAIT_TX:
2092                         if (event == DEV_EVENT_RXDOWN)
2093                                 fsm_newstate(fi, DEV_STATE_STARTWAIT_RXTX);
2094                         break;
2095                 case DEV_STATE_STOPWAIT_RXTX:
2096                         if (event == DEV_EVENT_TXDOWN)
2097                                 fsm_newstate(fi, DEV_STATE_STOPWAIT_RX);
2098                         else
2099                                 fsm_newstate(fi, DEV_STATE_STOPWAIT_TX);
2100                         break;
2101                 case DEV_STATE_STOPWAIT_RX:
2102                         if (event == DEV_EVENT_RXDOWN)
2103                                 fsm_newstate(fi, DEV_STATE_STOPPED);
2104                         break;
2105                 case DEV_STATE_STOPWAIT_TX:
2106                         if (event == DEV_EVENT_TXDOWN)
2107                                 fsm_newstate(fi, DEV_STATE_STOPPED);
2108                         break;
2109         }
2110 }
2111
2112 static const fsm_node dev_fsm[] = {
2113         {DEV_STATE_STOPPED, DEV_EVENT_START, dev_action_start},
2114
2115         {DEV_STATE_STOPWAIT_RXTX,  DEV_EVENT_START,   dev_action_start   },
2116         {DEV_STATE_STOPWAIT_RXTX,  DEV_EVENT_RXDOWN,  dev_action_chdown  },
2117         {DEV_STATE_STOPWAIT_RXTX,  DEV_EVENT_TXDOWN,  dev_action_chdown  },
2118         {DEV_STATE_STOPWAIT_RXTX,  DEV_EVENT_RESTART, dev_action_restart },
2119
2120         {DEV_STATE_STOPWAIT_RX,    DEV_EVENT_START,   dev_action_start   },
2121         {DEV_STATE_STOPWAIT_RX,    DEV_EVENT_RXUP,    dev_action_chup    },
2122         {DEV_STATE_STOPWAIT_RX,    DEV_EVENT_TXUP,    dev_action_chup    },
2123         {DEV_STATE_STOPWAIT_RX,    DEV_EVENT_RXDOWN,  dev_action_chdown  },
2124         {DEV_STATE_STOPWAIT_RX,    DEV_EVENT_RESTART, dev_action_restart },
2125
2126         {DEV_STATE_STOPWAIT_TX,    DEV_EVENT_START,   dev_action_start   },
2127         {DEV_STATE_STOPWAIT_TX,    DEV_EVENT_RXUP,    dev_action_chup    },
2128         {DEV_STATE_STOPWAIT_TX,    DEV_EVENT_TXUP,    dev_action_chup    },
2129         {DEV_STATE_STOPWAIT_TX,    DEV_EVENT_TXDOWN,  dev_action_chdown  },
2130         {DEV_STATE_STOPWAIT_TX,    DEV_EVENT_RESTART, dev_action_restart },
2131
2132         {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_STOP,    dev_action_stop    },
2133         {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_RXUP,    dev_action_chup    },
2134         {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_TXUP,    dev_action_chup    },
2135         {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_RXDOWN,  dev_action_chdown  },
2136         {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_TXDOWN,  dev_action_chdown  },
2137         {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_RESTART, dev_action_restart },
2138
2139         {DEV_STATE_STARTWAIT_TX,   DEV_EVENT_STOP,    dev_action_stop    },
2140         {DEV_STATE_STARTWAIT_TX,   DEV_EVENT_RXUP,    dev_action_chup    },
2141         {DEV_STATE_STARTWAIT_TX,   DEV_EVENT_TXUP,    dev_action_chup    },
2142         {DEV_STATE_STARTWAIT_TX,   DEV_EVENT_RXDOWN,  dev_action_chdown  },
2143         {DEV_STATE_STARTWAIT_TX,   DEV_EVENT_RESTART, dev_action_restart },
2144
2145         {DEV_STATE_STARTWAIT_RX,   DEV_EVENT_STOP,    dev_action_stop    },
2146         {DEV_STATE_STARTWAIT_RX,   DEV_EVENT_RXUP,    dev_action_chup    },
2147         {DEV_STATE_STARTWAIT_RX,   DEV_EVENT_TXUP,    dev_action_chup    },
2148         {DEV_STATE_STARTWAIT_RX,   DEV_EVENT_TXDOWN,  dev_action_chdown  },
2149         {DEV_STATE_STARTWAIT_RX,   DEV_EVENT_RESTART, dev_action_restart },
2150
2151         {DEV_STATE_RUNNING,        DEV_EVENT_STOP,    dev_action_stop    },
2152         {DEV_STATE_RUNNING,        DEV_EVENT_RXDOWN,  dev_action_chdown  },
2153         {DEV_STATE_RUNNING,        DEV_EVENT_TXDOWN,  dev_action_chdown  },
2154         {DEV_STATE_RUNNING,        DEV_EVENT_TXUP,    fsm_action_nop     },
2155         {DEV_STATE_RUNNING,        DEV_EVENT_RXUP,    fsm_action_nop     },
2156         {DEV_STATE_RUNNING,        DEV_EVENT_RESTART, dev_action_restart },
2157 };
2158
2159 static const int DEV_FSM_LEN = sizeof (dev_fsm) / sizeof (fsm_node);
2160
2161 /**
2162  * Transmit a packet.
2163  * This is a helper function for ctc_tx().
2164  *
2165  * @param ch Channel to be used for sending.
2166  * @param skb Pointer to struct sk_buff of packet to send.
2167  *            The linklevel header has already been set up
2168  *            by ctc_tx().
2169  *
2170  * @return 0 on success, -ERRNO on failure. (Never fails.)
2171  */
2172 static int
2173 transmit_skb(struct channel *ch, struct sk_buff *skb)
2174 {
2175         unsigned long saveflags;
2176         struct ll_header header;
2177         int rc = 0;
2178
2179         DBF_TEXT(trace, 5, __FUNCTION__);
2180         /* we need to acquire the lock for testing the state
2181          * otherwise we can have an IRQ changing the state to
2182          * TXIDLE after the test but before acquiring the lock.
2183          */
2184         spin_lock_irqsave(&ch->collect_lock, saveflags);
2185         if (fsm_getstate(ch->fsm) != CH_STATE_TXIDLE) {
2186                 int l = skb->len + LL_HEADER_LENGTH;
2187
2188                 if (ch->collect_len + l > ch->max_bufsize - 2) {
2189                         spin_unlock_irqrestore(&ch->collect_lock, saveflags);
2190                         return -EBUSY;
2191                 } else {
2192                         atomic_inc(&skb->users);
2193                         header.length = l;
2194                         header.type = skb->protocol;
2195                         header.unused = 0;
2196                         memcpy(skb_push(skb, LL_HEADER_LENGTH), &header,
2197                                LL_HEADER_LENGTH);
2198                         skb_queue_tail(&ch->collect_queue, skb);
2199                         ch->collect_len += l;
2200                 }
2201                 spin_unlock_irqrestore(&ch->collect_lock, saveflags);
2202         } else {
2203                 __u16 block_len;
2204                 int ccw_idx;
2205                 struct sk_buff *nskb;
2206                 unsigned long hi;
2207                 spin_unlock_irqrestore(&ch->collect_lock, saveflags);
2208                 /**
2209                  * Protect skb against beeing free'd by upper
2210                  * layers.
2211                  */
2212                 atomic_inc(&skb->users);
2213                 ch->prof.txlen += skb->len;
2214                 header.length = skb->len + LL_HEADER_LENGTH;
2215                 header.type = skb->protocol;
2216                 header.unused = 0;
2217                 memcpy(skb_push(skb, LL_HEADER_LENGTH), &header,
2218                        LL_HEADER_LENGTH);
2219                 block_len = skb->len + 2;
2220                 *((__u16 *) skb_push(skb, 2)) = block_len;
2221
2222                 /**
2223                  * IDAL support in CTC is broken, so we have to
2224                  * care about skb's above 2G ourselves.
2225                  */
2226                 hi = ((unsigned long) skb->tail + LL_HEADER_LENGTH) >> 31;
2227                 if (hi) {
2228                         nskb = alloc_skb(skb->len, GFP_ATOMIC | GFP_DMA);
2229                         if (!nskb) {
2230                                 atomic_dec(&skb->users);
2231                                 skb_pull(skb, LL_HEADER_LENGTH + 2);
2232                                 ctc_clear_busy(ch->netdev);
2233                                 return -ENOMEM;
2234                         } else {
2235                                 memcpy(skb_put(nskb, skb->len),
2236                                        skb->data, skb->len);
2237                                 atomic_inc(&nskb->users);
2238                                 atomic_dec(&skb->users);
2239                                 dev_kfree_skb_irq(skb);
2240                                 skb = nskb;
2241                         }
2242                 }
2243
2244                 ch->ccw[4].count = block_len;
2245                 if (set_normalized_cda(&ch->ccw[4], skb->data)) {
2246                         /**
2247                          * idal allocation failed, try via copying to
2248                          * trans_skb. trans_skb usually has a pre-allocated
2249                          * idal.
2250                          */
2251                         if (ctc_checkalloc_buffer(ch, 1)) {
2252                                 /**
2253                                  * Remove our header. It gets added
2254                                  * again on retransmit.
2255                                  */
2256                                 atomic_dec(&skb->users);
2257                                 skb_pull(skb, LL_HEADER_LENGTH + 2);
2258                                 ctc_clear_busy(ch->netdev);
2259                                 return -EBUSY;
2260                         }
2261
2262                         ch->trans_skb->tail = ch->trans_skb->data;
2263                         ch->trans_skb->len = 0;
2264                         ch->ccw[1].count = skb->len;
2265                         memcpy(skb_put(ch->trans_skb, skb->len), skb->data,
2266                                skb->len);
2267                         atomic_dec(&skb->users);
2268                         dev_kfree_skb_irq(skb);
2269                         ccw_idx = 0;
2270                 } else {
2271                         skb_queue_tail(&ch->io_queue, skb);
2272                         ccw_idx = 3;
2273                 }
2274                 ch->retry = 0;
2275                 fsm_newstate(ch->fsm, CH_STATE_TX);
2276                 fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC, CH_EVENT_TIMER, ch);
2277                 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
2278                 ch->prof.send_stamp = xtime;
2279                 rc = ccw_device_start(ch->cdev, &ch->ccw[ccw_idx],
2280                                       (unsigned long) ch, 0xff, 0);
2281                 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
2282                 if (ccw_idx == 3)
2283                         ch->prof.doios_single++;
2284                 if (rc != 0) {
2285                         fsm_deltimer(&ch->timer);
2286                         ccw_check_return_code(ch, rc, "single skb TX");
2287                         if (ccw_idx == 3)
2288                                 skb_dequeue_tail(&ch->io_queue);
2289                         /**
2290                          * Remove our header. It gets added
2291                          * again on retransmit.
2292                          */
2293                         skb_pull(skb, LL_HEADER_LENGTH + 2);
2294                 } else {
2295                         if (ccw_idx == 0) {
2296                                 struct net_device *dev = ch->netdev;
2297                                 struct ctc_priv *privptr = dev->priv;
2298                                 privptr->stats.tx_packets++;
2299                                 privptr->stats.tx_bytes +=
2300                                     skb->len - LL_HEADER_LENGTH;
2301                         }
2302                 }
2303         }
2304
2305         ctc_clear_busy(ch->netdev);
2306         return rc;
2307 }
2308
2309 /**
2310  * Interface API for upper network layers
2311  *****************************************************************************/
2312
2313 /**
2314  * Open an interface.
2315  * Called from generic network layer when ifconfig up is run.
2316  *
2317  * @param dev Pointer to interface struct.
2318  *
2319  * @return 0 on success, -ERRNO on failure. (Never fails.)
2320  */
2321 static int
2322 ctc_open(struct net_device * dev)
2323 {
2324         DBF_TEXT(trace, 5, __FUNCTION__);
2325         fsm_event(((struct ctc_priv *) dev->priv)->fsm, DEV_EVENT_START, dev);
2326         return 0;
2327 }
2328
2329 /**
2330  * Close an interface.
2331  * Called from generic network layer when ifconfig down is run.
2332  *
2333  * @param dev Pointer to interface struct.
2334  *
2335  * @return 0 on success, -ERRNO on failure. (Never fails.)
2336  */
2337 static int
2338 ctc_close(struct net_device * dev)
2339 {
2340         DBF_TEXT(trace, 5, __FUNCTION__);
2341         fsm_event(((struct ctc_priv *) dev->priv)->fsm, DEV_EVENT_STOP, dev);
2342         return 0;
2343 }
2344
2345 /**
2346  * Start transmission of a packet.
2347  * Called from generic network device layer.
2348  *
2349  * @param skb Pointer to buffer containing the packet.
2350  * @param dev Pointer to interface struct.
2351  *
2352  * @return 0 if packet consumed, !0 if packet rejected.
2353  *         Note: If we return !0, then the packet is free'd by
2354  *               the generic network layer.
2355  */
2356 static int
2357 ctc_tx(struct sk_buff *skb, struct net_device * dev)
2358 {
2359         int rc = 0;
2360         struct ctc_priv *privptr = (struct ctc_priv *) dev->priv;
2361
2362         DBF_TEXT(trace, 5, __FUNCTION__);
2363         /**
2364          * Some sanity checks ...
2365          */
2366         if (skb == NULL) {
2367                 ctc_pr_warn("%s: NULL sk_buff passed\n", dev->name);
2368                 privptr->stats.tx_dropped++;
2369                 return 0;
2370         }
2371         if (skb_headroom(skb) < (LL_HEADER_LENGTH + 2)) {
2372                 ctc_pr_warn("%s: Got sk_buff with head room < %ld bytes\n",
2373                             dev->name, LL_HEADER_LENGTH + 2);
2374                 dev_kfree_skb(skb);
2375                 privptr->stats.tx_dropped++;
2376                 return 0;
2377         }
2378
2379         /**
2380          * If channels are not running, try to restart them
2381          * and throw away packet.
2382          */
2383         if (fsm_getstate(privptr->fsm) != DEV_STATE_RUNNING) {
2384                 fsm_event(privptr->fsm, DEV_EVENT_START, dev);
2385                 dev_kfree_skb(skb);
2386                 privptr->stats.tx_dropped++;
2387                 privptr->stats.tx_errors++;
2388                 privptr->stats.tx_carrier_errors++;
2389                 return 0;
2390         }
2391
2392         if (ctc_test_and_set_busy(dev))
2393                 return -EBUSY;
2394
2395         dev->trans_start = jiffies;
2396         if (transmit_skb(privptr->channel[WRITE], skb) != 0)
2397                 rc = 1;
2398         return rc;
2399 }
2400
2401 /**
2402  * Sets MTU of an interface.
2403  *
2404  * @param dev     Pointer to interface struct.
2405  * @param new_mtu The new MTU to use for this interface.
2406  *
2407  * @return 0 on success, -EINVAL if MTU is out of valid range.
2408  *         (valid range is 576 .. 65527). If VM is on the
2409  *         remote side, maximum MTU is 32760, however this is
2410  *         <em>not</em> checked here.
2411  */
2412 static int
2413 ctc_change_mtu(struct net_device * dev, int new_mtu)
2414 {
2415         struct ctc_priv *privptr = (struct ctc_priv *) dev->priv;
2416
2417         DBF_TEXT(trace, 3, __FUNCTION__);
2418         if ((new_mtu < 576) || (new_mtu > 65527) ||
2419             (new_mtu > (privptr->channel[READ]->max_bufsize -
2420                         LL_HEADER_LENGTH - 2)))
2421                 return -EINVAL;
2422         dev->mtu = new_mtu;
2423         dev->hard_header_len = LL_HEADER_LENGTH + 2;
2424         return 0;
2425 }
2426
2427 /**
2428  * Returns interface statistics of a device.
2429  *
2430  * @param dev Pointer to interface struct.
2431  *
2432  * @return Pointer to stats struct of this interface.
2433  */
2434 static struct net_device_stats *
2435 ctc_stats(struct net_device * dev)
2436 {
2437         return &((struct ctc_priv *) dev->priv)->stats;
2438 }
2439
2440 /*
2441  * sysfs attributes
2442  */
2443
2444 static ssize_t
2445 buffer_show(struct device *dev, struct device_attribute *attr, char *buf)
2446 {
2447         struct ctc_priv *priv;
2448
2449         priv = dev->driver_data;
2450         if (!priv)
2451                 return -ENODEV;
2452         return sprintf(buf, "%d\n",
2453                         priv->buffer_size);
2454 }
2455
2456 static ssize_t
2457 buffer_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
2458 {
2459         struct ctc_priv *priv;
2460         struct net_device *ndev;
2461         int bs1;
2462         char buffer[16];
2463
2464         DBF_TEXT(trace, 3, __FUNCTION__);
2465         DBF_TEXT(trace, 3, buf);
2466         priv = dev->driver_data;
2467         if (!priv) {
2468                 DBF_TEXT(trace, 3, "bfnopriv");
2469                 return -ENODEV;
2470         }
2471
2472         sscanf(buf, "%u", &bs1);
2473         if (bs1 > CTC_BUFSIZE_LIMIT)
2474                 goto einval;
2475         if (bs1 < (576 + LL_HEADER_LENGTH + 2))
2476                 goto einval;
2477         priv->buffer_size = bs1;        // just to overwrite the default
2478
2479         ndev = priv->channel[READ]->netdev;
2480         if (!ndev) {
2481                 DBF_TEXT(trace, 3, "bfnondev");
2482                 return -ENODEV;
2483         }
2484
2485         if ((ndev->flags & IFF_RUNNING) &&
2486             (bs1 < (ndev->mtu + LL_HEADER_LENGTH + 2)))
2487                 goto einval;
2488
2489         priv->channel[READ]->max_bufsize = bs1;
2490         priv->channel[WRITE]->max_bufsize = bs1;
2491         if (!(ndev->flags & IFF_RUNNING))
2492                 ndev->mtu = bs1 - LL_HEADER_LENGTH - 2;
2493         priv->channel[READ]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
2494         priv->channel[WRITE]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
2495
2496         sprintf(buffer, "%d",priv->buffer_size);
2497         DBF_TEXT(trace, 3, buffer);
2498         return count;
2499
2500 einval:
2501         DBF_TEXT(trace, 3, "buff_err");
2502         return -EINVAL;
2503 }
2504
2505 static ssize_t
2506 loglevel_show(struct device *dev, struct device_attribute *attr, char *buf)
2507 {
2508         return sprintf(buf, "%d\n", loglevel);
2509 }
2510
2511 static ssize_t
2512 loglevel_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
2513 {
2514         int ll1;
2515
2516         DBF_TEXT(trace, 5, __FUNCTION__);
2517         sscanf(buf, "%i", &ll1);
2518
2519         if ((ll1 > CTC_LOGLEVEL_MAX) || (ll1 < 0))
2520                 return -EINVAL;
2521         loglevel = ll1;
2522         return count;
2523 }
2524
2525 static void
2526 ctc_print_statistics(struct ctc_priv *priv)
2527 {
2528         char *sbuf;
2529         char *p;
2530
2531         DBF_TEXT(trace, 4, __FUNCTION__);
2532         if (!priv)
2533                 return;
2534         sbuf = kmalloc(2048, GFP_KERNEL);
2535         if (sbuf == NULL)
2536                 return;
2537         p = sbuf;
2538
2539         p += sprintf(p, "  Device FSM state: %s\n",
2540                      fsm_getstate_str(priv->fsm));
2541         p += sprintf(p, "  RX channel FSM state: %s\n",
2542                      fsm_getstate_str(priv->channel[READ]->fsm));
2543         p += sprintf(p, "  TX channel FSM state: %s\n",
2544                      fsm_getstate_str(priv->channel[WRITE]->fsm));
2545         p += sprintf(p, "  Max. TX buffer used: %ld\n",
2546                      priv->channel[WRITE]->prof.maxmulti);
2547         p += sprintf(p, "  Max. chained SKBs: %ld\n",
2548                      priv->channel[WRITE]->prof.maxcqueue);
2549         p += sprintf(p, "  TX single write ops: %ld\n",
2550                      priv->channel[WRITE]->prof.doios_single);
2551         p += sprintf(p, "  TX multi write ops: %ld\n",
2552                      priv->channel[WRITE]->prof.doios_multi);
2553         p += sprintf(p, "  Netto bytes written: %ld\n",
2554                      priv->channel[WRITE]->prof.txlen);
2555         p += sprintf(p, "  Max. TX IO-time: %ld\n",
2556                      priv->channel[WRITE]->prof.tx_time);
2557
2558         ctc_pr_debug("Statistics for %s:\n%s",
2559                      priv->channel[WRITE]->netdev->name, sbuf);
2560         kfree(sbuf);
2561         return;
2562 }
2563
2564 static ssize_t
2565 stats_show(struct device *dev, struct device_attribute *attr, char *buf)
2566 {
2567         struct ctc_priv *priv = dev->driver_data;
2568         if (!priv)
2569                 return -ENODEV;
2570         ctc_print_statistics(priv);
2571         return sprintf(buf, "0\n");
2572 }
2573
2574 static ssize_t
2575 stats_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
2576 {
2577         struct ctc_priv *priv = dev->driver_data;
2578         if (!priv)
2579                 return -ENODEV;
2580         /* Reset statistics */
2581         memset(&priv->channel[WRITE]->prof, 0,
2582                         sizeof(priv->channel[WRITE]->prof));
2583         return count;
2584 }
2585
2586 static void
2587 ctc_netdev_unregister(struct net_device * dev)
2588 {
2589         struct ctc_priv *privptr;
2590
2591         if (!dev)
2592                 return;
2593         privptr = (struct ctc_priv *) dev->priv;
2594         unregister_netdev(dev);
2595 }
2596
2597 static int
2598 ctc_netdev_register(struct net_device * dev)
2599 {
2600         return register_netdev(dev);
2601 }
2602
2603 static void
2604 ctc_free_netdevice(struct net_device * dev, int free_dev)
2605 {
2606         struct ctc_priv *privptr;
2607         if (!dev)
2608                 return;
2609         privptr = dev->priv;
2610         if (privptr) {
2611                 if (privptr->fsm)
2612                         kfree_fsm(privptr->fsm);
2613                 kfree(privptr);
2614         }
2615 #ifdef MODULE
2616         if (free_dev)
2617                 free_netdev(dev);
2618 #endif
2619 }
2620
2621 static ssize_t
2622 ctc_proto_show(struct device *dev, struct device_attribute *attr, char *buf)
2623 {
2624         struct ctc_priv *priv;
2625
2626         priv = dev->driver_data;
2627         if (!priv)
2628                 return -ENODEV;
2629
2630         return sprintf(buf, "%d\n", priv->protocol);
2631 }
2632
2633 static ssize_t
2634 ctc_proto_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
2635 {
2636         struct ctc_priv *priv;
2637         int value;
2638
2639         DBF_TEXT(trace, 3, __FUNCTION__);
2640         pr_debug("%s() called\n", __FUNCTION__);
2641
2642         priv = dev->driver_data;
2643         if (!priv)
2644                 return -ENODEV;
2645         sscanf(buf, "%u", &value);
2646         if (!((value == CTC_PROTO_S390)  ||
2647               (value == CTC_PROTO_LINUX) ||
2648               (value == CTC_PROTO_OS390)))
2649                 return -EINVAL;
2650         priv->protocol = value;
2651
2652         return count;
2653 }
2654
2655 static ssize_t
2656 ctc_type_show(struct device *dev, struct device_attribute *attr, char *buf)
2657 {
2658         struct ccwgroup_device *cgdev;
2659
2660         cgdev = to_ccwgroupdev(dev);
2661         if (!cgdev)
2662                 return -ENODEV;
2663
2664         return sprintf(buf, "%s\n", cu3088_type[cgdev->cdev[0]->id.driver_info]);
2665 }
2666
2667 static DEVICE_ATTR(buffer, 0644, buffer_show, buffer_write);
2668 static DEVICE_ATTR(protocol, 0644, ctc_proto_show, ctc_proto_store);
2669 static DEVICE_ATTR(type, 0444, ctc_type_show, NULL);
2670
2671 static DEVICE_ATTR(loglevel, 0644, loglevel_show, loglevel_write);
2672 static DEVICE_ATTR(stats, 0644, stats_show, stats_write);
2673
2674 static struct attribute *ctc_attr[] = {
2675         &dev_attr_protocol.attr,
2676         &dev_attr_type.attr,
2677         &dev_attr_buffer.attr,
2678         NULL,
2679 };
2680
2681 static struct attribute_group ctc_attr_group = {
2682         .attrs = ctc_attr,
2683 };
2684
2685 static int
2686 ctc_add_attributes(struct device *dev)
2687 {
2688         int rc;
2689
2690         rc = device_create_file(dev, &dev_attr_loglevel);
2691         if (rc)
2692                 goto out;
2693         rc = device_create_file(dev, &dev_attr_stats);
2694         if (!rc)
2695                 goto out;
2696         device_remove_file(dev, &dev_attr_loglevel);
2697 out:
2698         return rc;
2699 }
2700
2701 static void
2702 ctc_remove_attributes(struct device *dev)
2703 {
2704         device_remove_file(dev, &dev_attr_stats);
2705         device_remove_file(dev, &dev_attr_loglevel);
2706 }
2707
2708 static int
2709 ctc_add_files(struct device *dev)
2710 {
2711         pr_debug("%s() called\n", __FUNCTION__);
2712
2713         return sysfs_create_group(&dev->kobj, &ctc_attr_group);
2714 }
2715
2716 static void
2717 ctc_remove_files(struct device *dev)
2718 {
2719         pr_debug("%s() called\n", __FUNCTION__);
2720
2721         sysfs_remove_group(&dev->kobj, &ctc_attr_group);
2722 }
2723
2724 /**
2725  * Add ctc specific attributes.
2726  * Add ctc private data.
2727  *
2728  * @param cgdev pointer to ccwgroup_device just added
2729  *
2730  * @returns 0 on success, !0 on failure.
2731  */
2732 static int
2733 ctc_probe_device(struct ccwgroup_device *cgdev)
2734 {
2735         struct ctc_priv *priv;
2736         int rc;
2737         char buffer[16];
2738
2739         pr_debug("%s() called\n", __FUNCTION__);
2740         DBF_TEXT(setup, 3, __FUNCTION__);
2741
2742         if (!get_device(&cgdev->dev))
2743                 return -ENODEV;
2744
2745         priv = kzalloc(sizeof(struct ctc_priv), GFP_KERNEL);
2746         if (!priv) {
2747                 ctc_pr_err("%s: Out of memory\n", __func__);
2748                 put_device(&cgdev->dev);
2749                 return -ENOMEM;
2750         }
2751
2752         rc = ctc_add_files(&cgdev->dev);
2753         if (rc) {
2754                 kfree(priv);
2755                 put_device(&cgdev->dev);
2756                 return rc;
2757         }
2758         priv->buffer_size = CTC_BUFSIZE_DEFAULT;
2759         cgdev->cdev[0]->handler = ctc_irq_handler;
2760         cgdev->cdev[1]->handler = ctc_irq_handler;
2761         cgdev->dev.driver_data = priv;
2762
2763         sprintf(buffer, "%p", priv);
2764         DBF_TEXT(data, 3, buffer);
2765
2766         sprintf(buffer, "%u", (unsigned int)sizeof(struct ctc_priv));
2767         DBF_TEXT(data, 3, buffer);
2768
2769         sprintf(buffer, "%p", &channels);
2770         DBF_TEXT(data, 3, buffer);
2771
2772         sprintf(buffer, "%u", (unsigned int)sizeof(struct channel));
2773         DBF_TEXT(data, 3, buffer);
2774
2775         return 0;
2776 }
2777
2778 /**
2779  * Initialize everything of the net device except the name and the
2780  * channel structs.
2781  */
2782 static struct net_device *
2783 ctc_init_netdevice(struct net_device * dev, int alloc_device,
2784                    struct ctc_priv *privptr)
2785 {
2786         if (!privptr)
2787                 return NULL;
2788
2789         DBF_TEXT(setup, 3, __FUNCTION__);
2790
2791         if (alloc_device) {
2792                 dev = kzalloc(sizeof(struct net_device), GFP_KERNEL);
2793                 if (!dev)
2794                         return NULL;
2795         }
2796
2797         dev->priv = privptr;
2798         privptr->fsm = init_fsm("ctcdev", dev_state_names,
2799                                 dev_event_names, CTC_NR_DEV_STATES, CTC_NR_DEV_EVENTS,
2800                                 dev_fsm, DEV_FSM_LEN, GFP_KERNEL);
2801         if (privptr->fsm == NULL) {
2802                 if (alloc_device)
2803                         kfree(dev);
2804                 return NULL;
2805         }
2806         fsm_newstate(privptr->fsm, DEV_STATE_STOPPED);
2807         fsm_settimer(privptr->fsm, &privptr->restart_timer);
2808         if (dev->mtu == 0)
2809                 dev->mtu = CTC_BUFSIZE_DEFAULT - LL_HEADER_LENGTH - 2;
2810         dev->hard_start_xmit = ctc_tx;
2811         dev->open = ctc_open;
2812         dev->stop = ctc_close;
2813         dev->get_stats = ctc_stats;
2814         dev->change_mtu = ctc_change_mtu;
2815         dev->hard_header_len = LL_HEADER_LENGTH + 2;
2816         dev->addr_len = 0;
2817         dev->type = ARPHRD_SLIP;
2818         dev->tx_queue_len = 100;
2819         dev->flags = IFF_POINTOPOINT | IFF_NOARP;
2820         SET_MODULE_OWNER(dev);
2821         return dev;
2822 }
2823
2824
2825 /**
2826  *
2827  * Setup an interface.
2828  *
2829  * @param cgdev  Device to be setup.
2830  *
2831  * @returns 0 on success, !0 on failure.
2832  */
2833 static int
2834 ctc_new_device(struct ccwgroup_device *cgdev)
2835 {
2836         char read_id[CTC_ID_SIZE];
2837         char write_id[CTC_ID_SIZE];
2838         int direction;
2839         enum channel_types type;
2840         struct ctc_priv *privptr;
2841         struct net_device *dev;
2842         int ret;
2843         char buffer[16];
2844
2845         pr_debug("%s() called\n", __FUNCTION__);
2846         DBF_TEXT(setup, 3, __FUNCTION__);
2847
2848         privptr = cgdev->dev.driver_data;
2849         if (!privptr)
2850                 return -ENODEV;
2851
2852         sprintf(buffer, "%d", privptr->buffer_size);
2853         DBF_TEXT(setup, 3, buffer);
2854
2855         type = get_channel_type(&cgdev->cdev[0]->id);
2856
2857         snprintf(read_id, CTC_ID_SIZE, "ch-%s", cgdev->cdev[0]->dev.bus_id);
2858         snprintf(write_id, CTC_ID_SIZE, "ch-%s", cgdev->cdev[1]->dev.bus_id);
2859
2860         if (add_channel(cgdev->cdev[0], type))
2861                 return -ENOMEM;
2862         if (add_channel(cgdev->cdev[1], type))
2863                 return -ENOMEM;
2864
2865         ret = ccw_device_set_online(cgdev->cdev[0]);
2866         if (ret != 0) {
2867                         printk(KERN_WARNING
2868                         "ccw_device_set_online (cdev[0]) failed with ret = %d\n", ret);
2869         }
2870
2871         ret = ccw_device_set_online(cgdev->cdev[1]);
2872         if (ret != 0) {
2873                         printk(KERN_WARNING
2874                         "ccw_device_set_online (cdev[1]) failed with ret = %d\n", ret);
2875         }
2876
2877         dev = ctc_init_netdevice(NULL, 1, privptr);
2878
2879         if (!dev) {
2880                 ctc_pr_warn("ctc_init_netdevice failed\n");
2881                 goto out;
2882         }
2883
2884         strlcpy(dev->name, "ctc%d", IFNAMSIZ);
2885
2886         for (direction = READ; direction <= WRITE; direction++) {
2887                 privptr->channel[direction] =
2888                     channel_get(type, direction == READ ? read_id : write_id,
2889                                 direction);
2890                 if (privptr->channel[direction] == NULL) {
2891                         if (direction == WRITE)
2892                                 channel_free(privptr->channel[READ]);
2893
2894                         ctc_free_netdevice(dev, 1);
2895                         goto out;
2896                 }
2897                 privptr->channel[direction]->netdev = dev;
2898                 privptr->channel[direction]->protocol = privptr->protocol;
2899                 privptr->channel[direction]->max_bufsize = privptr->buffer_size;
2900         }
2901         /* sysfs magic */
2902         SET_NETDEV_DEV(dev, &cgdev->dev);
2903
2904         if (ctc_netdev_register(dev) != 0) {
2905                 ctc_free_netdevice(dev, 1);
2906                 goto out;
2907         }
2908
2909         if (ctc_add_attributes(&cgdev->dev)) {
2910                 ctc_netdev_unregister(dev);
2911                 dev->priv = NULL;
2912                 ctc_free_netdevice(dev, 1);
2913                 goto out;
2914         }
2915
2916         strlcpy(privptr->fsm->name, dev->name, sizeof (privptr->fsm->name));
2917
2918         print_banner();
2919
2920         ctc_pr_info("%s: read: %s, write: %s, proto: %d\n",
2921                     dev->name, privptr->channel[READ]->id,
2922                     privptr->channel[WRITE]->id, privptr->protocol);
2923
2924         return 0;
2925 out:
2926         ccw_device_set_offline(cgdev->cdev[1]);
2927         ccw_device_set_offline(cgdev->cdev[0]);
2928
2929         return -ENODEV;
2930 }
2931
2932 /**
2933  * Shutdown an interface.
2934  *
2935  * @param cgdev  Device to be shut down.
2936  *
2937  * @returns 0 on success, !0 on failure.
2938  */
2939 static int
2940 ctc_shutdown_device(struct ccwgroup_device *cgdev)
2941 {
2942         struct ctc_priv *priv;
2943         struct net_device *ndev;
2944
2945         DBF_TEXT(setup, 3, __FUNCTION__);
2946         pr_debug("%s() called\n", __FUNCTION__);
2947
2948
2949         priv = cgdev->dev.driver_data;
2950         ndev = NULL;
2951         if (!priv)
2952                 return -ENODEV;
2953
2954         if (priv->channel[READ]) {
2955                 ndev = priv->channel[READ]->netdev;
2956
2957                 /* Close the device */
2958                 ctc_close(ndev);
2959                 ndev->flags &=~IFF_RUNNING;
2960
2961                 ctc_remove_attributes(&cgdev->dev);
2962
2963                 channel_free(priv->channel[READ]);
2964         }
2965         if (priv->channel[WRITE])
2966                 channel_free(priv->channel[WRITE]);
2967
2968         if (ndev) {
2969                 ctc_netdev_unregister(ndev);
2970                 ndev->priv = NULL;
2971                 ctc_free_netdevice(ndev, 1);
2972         }
2973
2974         if (priv->fsm)
2975                 kfree_fsm(priv->fsm);
2976
2977         ccw_device_set_offline(cgdev->cdev[1]);
2978         ccw_device_set_offline(cgdev->cdev[0]);
2979
2980         if (priv->channel[READ])
2981                 channel_remove(priv->channel[READ]);
2982         if (priv->channel[WRITE])
2983                 channel_remove(priv->channel[WRITE]);
2984         priv->channel[READ] = priv->channel[WRITE] = NULL;
2985
2986         return 0;
2987
2988 }
2989
2990 static void
2991 ctc_remove_device(struct ccwgroup_device *cgdev)
2992 {
2993         struct ctc_priv *priv;
2994
2995         pr_debug("%s() called\n", __FUNCTION__);
2996         DBF_TEXT(setup, 3, __FUNCTION__);
2997
2998         priv = cgdev->dev.driver_data;
2999         if (!priv)
3000                 return;
3001         if (cgdev->state == CCWGROUP_ONLINE)
3002                 ctc_shutdown_device(cgdev);
3003         ctc_remove_files(&cgdev->dev);
3004         cgdev->dev.driver_data = NULL;
3005         kfree(priv);
3006         put_device(&cgdev->dev);
3007 }
3008
3009 static struct ccwgroup_driver ctc_group_driver = {
3010         .owner       = THIS_MODULE,
3011         .name        = "ctc",
3012         .max_slaves  = 2,
3013         .driver_id   = 0xC3E3C3,
3014         .probe       = ctc_probe_device,
3015         .remove      = ctc_remove_device,
3016         .set_online  = ctc_new_device,
3017         .set_offline = ctc_shutdown_device,
3018 };
3019
3020 /**
3021  * Module related routines
3022  *****************************************************************************/
3023
3024 /**
3025  * Prepare to be unloaded. Free IRQ's and release all resources.
3026  * This is called just before this module is unloaded. It is
3027  * <em>not</em> called, if the usage count is !0, so we don't need to check
3028  * for that.
3029  */
3030 static void __exit
3031 ctc_exit(void)
3032 {
3033         DBF_TEXT(setup, 3, __FUNCTION__);
3034         unregister_cu3088_discipline(&ctc_group_driver);
3035         ctc_unregister_dbf_views();
3036         ctc_pr_info("CTC driver unloaded\n");
3037 }
3038
3039 /**
3040  * Initialize module.
3041  * This is called just after the module is loaded.
3042  *
3043  * @return 0 on success, !0 on error.
3044  */
3045 static int __init
3046 ctc_init(void)
3047 {
3048         int ret = 0;
3049
3050         loglevel = CTC_LOGLEVEL_DEFAULT;
3051
3052         DBF_TEXT(setup, 3, __FUNCTION__);
3053
3054         print_banner();
3055
3056         ret = ctc_register_dbf_views();
3057         if (ret){
3058                 ctc_pr_crit("ctc_init failed with ctc_register_dbf_views rc = %d\n", ret);
3059                 return ret;
3060         }
3061         ret = register_cu3088_discipline(&ctc_group_driver);
3062         if (ret) {
3063                 ctc_unregister_dbf_views();
3064         }
3065         return ret;
3066 }
3067
3068 module_init(ctc_init);
3069 module_exit(ctc_exit);
3070
3071 /* --- This is the END my friend --- */