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