drivers/s390/net/ctcmain.c

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