git.oblomov.eu Git - linux-2.6/blob - drivers/s390/net/ctcmain.c

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