2 * $Id: ctcmain.c,v 1.61 2004/07/02 16:31:22 ptiedem Exp $
4 * CTC / ESCON network driver
6 * Copyright (C) 2001 IBM Deutschland Entwicklung GmbH, IBM Corporation
7 * Author(s): Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com)
8 * Fixes by : Jochen Röhrig (roehrig@de.ibm.com)
9 * Arnaldo Carvalho de Melo <acme@conectiva.com.br>
10 * Driver Model stuff by : Cornelia Huck <cohuck@de.ibm.com>
13 * - Principles of Operation (IBM doc#: SA22-7201-06)
14 * - Common IO/-Device Commands and Self Description (IBM doc#: SA22-7204-02)
15 * - Common IO/-Device Commands and Self Description (IBM doc#: SN22-5535)
16 * - ESCON Channel-to-Channel Adapter (IBM doc#: SA22-7203-00)
17 * - ESCON I/O Interface (IBM doc#: SA22-7202-029
19 * and the source of the original CTC driver by:
20 * Dieter Wellerdiek (wel@de.ibm.com)
21 * Martin Schwidefsky (schwidefsky@de.ibm.com)
22 * Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
23 * Jochen Röhrig (roehrig@de.ibm.com)
25 * This program is free software; you can redistribute it and/or modify
26 * it under the terms of the GNU General Public License as published by
27 * the Free Software Foundation; either version 2, or (at your option)
30 * This program is distributed in the hope that it will be useful,
31 * but WITHOUT ANY WARRANTY; without even the implied warranty of
32 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
33 * GNU General Public License for more details.
35 * You should have received a copy of the GNU General Public License
36 * along with this program; if not, write to the Free Software
37 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
39 * RELEASE-TAG: CTC/ESCON network driver $Revision: 1.61 $
45 #include <linux/module.h>
46 #include <linux/init.h>
47 #include <linux/kernel.h>
48 #include <linux/slab.h>
49 #include <linux/errno.h>
50 #include <linux/types.h>
51 #include <linux/interrupt.h>
52 #include <linux/timer.h>
53 #include <linux/sched.h>
55 #include <linux/signal.h>
56 #include <linux/string.h>
59 #include <linux/if_arp.h>
60 #include <linux/tcp.h>
61 #include <linux/skbuff.h>
62 #include <linux/ctype.h>
66 #include <asm/ccwdev.h>
67 #include <asm/ccwgroup.h>
68 #include <asm/bitops.h>
69 #include <asm/uaccess.h>
71 #include <asm/idals.h>
78 MODULE_AUTHOR("(C) 2000 IBM Corp. by Fritz Elfert (felfert@millenux.com)");
79 MODULE_DESCRIPTION("Linux for S/390 CTC/Escon Driver");
80 MODULE_LICENSE("GPL");
83 * CCW commands, used in this driver.
85 #define CCW_CMD_WRITE 0x01
86 #define CCW_CMD_READ 0x02
87 #define CCW_CMD_SET_EXTENDED 0xc3
88 #define CCW_CMD_PREPARE 0xe3
90 #define CTC_PROTO_S390 0
91 #define CTC_PROTO_LINUX 1
92 #define CTC_PROTO_LINUX_TTY 2
93 #define CTC_PROTO_OS390 3
94 #define CTC_PROTO_MAX 3
96 #define CTC_BUFSIZE_LIMIT 65535
97 #define CTC_BUFSIZE_DEFAULT 32768
99 #define CTC_TIMEOUT_5SEC 5000
101 #define CTC_INITIAL_BLOCKLEN 2
106 #define CTC_ID_SIZE BUS_ID_SIZE+3
110 unsigned long maxmulti;
111 unsigned long maxcqueue;
112 unsigned long doios_single;
113 unsigned long doios_multi;
115 unsigned long tx_time;
116 struct timespec send_stamp;
120 * Definition of one channel
125 * Pointer to next channel in list.
127 struct channel *next;
128 char id[CTC_ID_SIZE];
129 struct ccw_device *cdev;
132 * Type of this channel.
133 * CTC/A or Escon for valid channels.
135 enum channel_types type;
138 * Misc. flags. See CHANNEL_FLAGS_... below
143 * The protocol of this channel
148 * I/O and irq related stuff
159 * Transmit/Receive buffer.
161 struct sk_buff *trans_skb;
164 * Universal I/O queue.
166 struct sk_buff_head io_queue;
169 * TX queue for collecting skb's during busy.
171 struct sk_buff_head collect_queue;
174 * Amount of data in collect_queue.
179 * spinlock for collect_queue and collect_len
181 spinlock_t collect_lock;
184 * Timer for detecting unresposive
190 * Retry counter for misc. operations.
195 * The finite state machine of this channel
200 * The corresponding net_device this channel
203 struct net_device *netdev;
205 struct ctc_profile prof;
207 unsigned char *trans_skb_data;
212 #define CHANNEL_FLAGS_READ 0
213 #define CHANNEL_FLAGS_WRITE 1
214 #define CHANNEL_FLAGS_INUSE 2
215 #define CHANNEL_FLAGS_BUFSIZE_CHANGED 4
216 #define CHANNEL_FLAGS_FAILED 8
217 #define CHANNEL_FLAGS_WAITIRQ 16
218 #define CHANNEL_FLAGS_RWMASK 1
219 #define CHANNEL_DIRECTION(f) (f & CHANNEL_FLAGS_RWMASK)
221 #define LOG_FLAG_ILLEGALPKT 1
222 #define LOG_FLAG_ILLEGALSIZE 2
223 #define LOG_FLAG_OVERRUN 4
224 #define LOG_FLAG_NOMEM 8
226 #define CTC_LOGLEVEL_INFO 1
227 #define CTC_LOGLEVEL_NOTICE 2
228 #define CTC_LOGLEVEL_WARN 4
229 #define CTC_LOGLEVEL_EMERG 8
230 #define CTC_LOGLEVEL_ERR 16
231 #define CTC_LOGLEVEL_DEBUG 32
232 #define CTC_LOGLEVEL_CRIT 64
234 #define CTC_LOGLEVEL_DEFAULT \
235 (CTC_LOGLEVEL_INFO | CTC_LOGLEVEL_NOTICE | CTC_LOGLEVEL_WARN | CTC_LOGLEVEL_CRIT)
237 #define CTC_LOGLEVEL_MAX ((CTC_LOGLEVEL_CRIT<<1)-1)
239 static int loglevel = CTC_LOGLEVEL_DEFAULT;
241 #define ctc_pr_debug(fmt, arg...) \
242 do { if (loglevel & CTC_LOGLEVEL_DEBUG) printk(KERN_DEBUG fmt,##arg); } while (0)
244 #define ctc_pr_info(fmt, arg...) \
245 do { if (loglevel & CTC_LOGLEVEL_INFO) printk(KERN_INFO fmt,##arg); } while (0)
247 #define ctc_pr_notice(fmt, arg...) \
248 do { if (loglevel & CTC_LOGLEVEL_NOTICE) printk(KERN_NOTICE fmt,##arg); } while (0)
250 #define ctc_pr_warn(fmt, arg...) \
251 do { if (loglevel & CTC_LOGLEVEL_WARN) printk(KERN_WARNING fmt,##arg); } while (0)
253 #define ctc_pr_emerg(fmt, arg...) \
254 do { if (loglevel & CTC_LOGLEVEL_EMERG) printk(KERN_EMERG fmt,##arg); } while (0)
256 #define ctc_pr_err(fmt, arg...) \
257 do { if (loglevel & CTC_LOGLEVEL_ERR) printk(KERN_ERR fmt,##arg); } while (0)
259 #define ctc_pr_crit(fmt, arg...) \
260 do { if (loglevel & CTC_LOGLEVEL_CRIT) printk(KERN_CRIT fmt,##arg); } while (0)
263 * Linked list of all detected channels.
265 static struct channel *channels = NULL;
268 struct net_device_stats stats;
271 * The finite state machine of this interface.
275 * The protocol of this device
279 * Timer for restarting after I/O Errors
281 fsm_timer restart_timer;
283 struct channel *channel[2];
287 * Definition of our link level header.
294 #define LL_HEADER_LENGTH (sizeof(struct ll_header))
297 * Compatibility macros for busy handling
298 * of network devices.
300 static __inline__ void
301 ctc_clear_busy(struct net_device * dev)
303 clear_bit(0, &(((struct ctc_priv *) dev->priv)->tbusy));
304 if (((struct ctc_priv *)dev->priv)->protocol != CTC_PROTO_LINUX_TTY)
305 netif_wake_queue(dev);
308 static __inline__ int
309 ctc_test_and_set_busy(struct net_device * dev)
311 if (((struct ctc_priv *)dev->priv)->protocol != CTC_PROTO_LINUX_TTY)
312 netif_stop_queue(dev);
313 return test_and_set_bit(0, &((struct ctc_priv *) dev->priv)->tbusy);
322 static int printed = 0;
323 char vbuf[] = "$Revision: 1.61 $";
324 char *version = vbuf;
328 if ((version = strchr(version, ':'))) {
329 char *p = strchr(version + 1, '$');
334 printk(KERN_INFO "CTC driver Version%s"
336 " (DEBUG-VERSION, " __DATE__ __TIME__ ")"
338 " initialized\n", version);
343 * Return type of a detected device.
345 static enum channel_types
346 get_channel_type(struct ccw_device_id *id)
348 enum channel_types type = (enum channel_types) id->driver_info;
350 if (type == channel_type_ficon)
351 type = channel_type_escon;
357 * States of the interface statemachine.
361 DEV_STATE_STARTWAIT_RXTX,
362 DEV_STATE_STARTWAIT_RX,
363 DEV_STATE_STARTWAIT_TX,
364 DEV_STATE_STOPWAIT_RXTX,
365 DEV_STATE_STOPWAIT_RX,
366 DEV_STATE_STOPWAIT_TX,
369 * MUST be always the last element!!
374 static const char *dev_state_names[] = {
386 * Events of the interface statemachine.
397 * MUST be always the last element!!
402 static const char *dev_event_names[] = {
413 * Events of the channel statemachine
417 * Events, representing return code of
418 * I/O operations (ccw_device_start, ccw_device_halt et al.)
431 * Events, representing unit-check
435 CH_EVENT_UC_TXTIMEOUT,
436 CH_EVENT_UC_TXPARITY,
438 CH_EVENT_UC_RXPARITY,
443 * Events, representing subchannel-check
448 * Events, representing machine checks
454 * Event, representing normal IRQ
460 * Event, representing timer expiry.
465 * Events, representing commands from upper levels.
471 * MUST be always the last element!!
476 static const char *ch_event_names[] = {
477 "ccw_device success",
481 "ccw_device unknown",
483 "Status ATTN & BUSY",
487 "Unit check remote reset",
488 "Unit check remote system reset",
489 "Unit check TX timeout",
490 "Unit check TX parity",
491 "Unit check Hardware failure",
492 "Unit check RX parity",
494 "Unit check Unknown",
496 "SubChannel check Unknown",
498 "Machine check failure",
499 "Machine check operational",
511 * States of the channel statemachine.
515 * Channel not assigned to any device,
516 * initial state, direction invalid
521 * Channel assigned but not operating
540 * MUST be always the last element!!
545 static const char *ch_state_names[] = {
566 * Dump header and first 16 bytes of an sk_buff for debugging purposes.
568 * @param skb The sk_buff to dump.
569 * @param offset Offset relative to skb-data, where to start the dump.
572 ctc_dump_skb(struct sk_buff *skb, int offset)
574 unsigned char *p = skb->data;
576 struct ll_header *header;
579 if (!(loglevel & CTC_LOGLEVEL_DEBUG))
584 header = (struct ll_header *) p;
587 printk(KERN_DEBUG "dump:\n");
588 printk(KERN_DEBUG "blocklen=%d %04x\n", bl, bl);
590 printk(KERN_DEBUG "h->length=%d %04x\n", header->length,
592 printk(KERN_DEBUG "h->type=%04x\n", header->type);
593 printk(KERN_DEBUG "h->unused=%04x\n", header->unused);
596 printk(KERN_DEBUG "data: ");
597 for (i = 0; i < bl; i++)
598 printk("%02x%s", *p++, (i % 16) ? " " : "\n<7>");
603 ctc_dump_skb(struct sk_buff *skb, int offset)
609 * Unpack a just received skb and hand it over to
612 * @param ch The channel where this skb has been received.
613 * @param pskb The received skb.
615 static __inline__ void
616 ctc_unpack_skb(struct channel *ch, struct sk_buff *pskb)
618 struct net_device *dev = ch->netdev;
619 struct ctc_priv *privptr = (struct ctc_priv *) dev->priv;
620 __u16 len = *((__u16 *) pskb->data);
622 DBF_TEXT(trace, 2, __FUNCTION__);
623 skb_put(pskb, 2 + LL_HEADER_LENGTH);
626 pskb->ip_summed = CHECKSUM_UNNECESSARY;
629 struct ll_header *header = (struct ll_header *) pskb->data;
631 skb_pull(pskb, LL_HEADER_LENGTH);
632 if ((ch->protocol == CTC_PROTO_S390) &&
633 (header->type != ETH_P_IP)) {
636 if (!(ch->logflags & LOG_FLAG_ILLEGALPKT)) {
639 * Check packet type only if we stick strictly
640 * to S/390's protocol of OS390. This only
641 * supports IP. Otherwise allow any packet
645 "%s Illegal packet type 0x%04x received, dropping\n",
646 dev->name, header->type);
647 ch->logflags |= LOG_FLAG_ILLEGALPKT;
652 ctc_dump_skb(pskb, -6);
654 privptr->stats.rx_dropped++;
655 privptr->stats.rx_frame_errors++;
658 pskb->protocol = ntohs(header->type);
659 if (header->length <= LL_HEADER_LENGTH) {
661 if (!(ch->logflags & LOG_FLAG_ILLEGALSIZE)) {
664 "%s Illegal packet size %d "
665 "received (MTU=%d blocklen=%d), "
666 "dropping\n", dev->name, header->length,
668 ch->logflags |= LOG_FLAG_ILLEGALSIZE;
673 ctc_dump_skb(pskb, -6);
675 privptr->stats.rx_dropped++;
676 privptr->stats.rx_length_errors++;
679 header->length -= LL_HEADER_LENGTH;
680 len -= LL_HEADER_LENGTH;
681 if ((header->length > skb_tailroom(pskb)) ||
682 (header->length > len)) {
684 if (!(ch->logflags & LOG_FLAG_OVERRUN)) {
687 "%s Illegal packet size %d "
688 "(beyond the end of received data), "
689 "dropping\n", dev->name, header->length);
690 ch->logflags |= LOG_FLAG_OVERRUN;
695 ctc_dump_skb(pskb, -6);
697 privptr->stats.rx_dropped++;
698 privptr->stats.rx_length_errors++;
701 skb_put(pskb, header->length);
702 pskb->mac.raw = pskb->data;
703 len -= header->length;
704 skb = dev_alloc_skb(pskb->len);
707 if (!(ch->logflags & LOG_FLAG_NOMEM)) {
710 "%s Out of memory in ctc_unpack_skb\n",
712 ch->logflags |= LOG_FLAG_NOMEM;
716 privptr->stats.rx_dropped++;
719 memcpy(skb_put(skb, pskb->len), pskb->data, pskb->len);
720 skb->mac.raw = skb->data;
721 skb->dev = pskb->dev;
722 skb->protocol = pskb->protocol;
723 pskb->ip_summed = CHECKSUM_UNNECESSARY;
724 if (ch->protocol == CTC_PROTO_LINUX_TTY)
725 ctc_tty_netif_rx(skb);
729 * Successful rx; reset logflags
732 dev->last_rx = jiffies;
733 privptr->stats.rx_packets++;
734 privptr->stats.rx_bytes += skb->len;
736 skb_pull(pskb, header->length);
737 if (skb_tailroom(pskb) < LL_HEADER_LENGTH) {
739 if (!(ch->logflags & LOG_FLAG_OVERRUN)) {
742 "%s Overrun in ctc_unpack_skb\n",
744 ch->logflags |= LOG_FLAG_OVERRUN;
750 skb_put(pskb, LL_HEADER_LENGTH);
756 * Check return code of a preceeding ccw_device call, halt_IO etc...
758 * @param ch The channel, the error belongs to.
759 * @param return_code The error code to inspect.
762 ccw_check_return_code(struct channel *ch, int return_code, char *msg)
764 DBF_TEXT(trace, 2, __FUNCTION__);
765 switch (return_code) {
767 fsm_event(ch->fsm, CH_EVENT_IO_SUCCESS, ch);
770 ctc_pr_warn("%s (%s): Busy !\n", ch->id, msg);
771 fsm_event(ch->fsm, CH_EVENT_IO_EBUSY, ch);
774 ctc_pr_emerg("%s (%s): Invalid device called for IO\n",
776 fsm_event(ch->fsm, CH_EVENT_IO_ENODEV, ch);
779 ctc_pr_emerg("%s (%s): Status pending... \n",
781 fsm_event(ch->fsm, CH_EVENT_IO_EIO, ch);
784 ctc_pr_emerg("%s (%s): Unknown error in do_IO %04x\n",
785 ch->id, msg, return_code);
786 fsm_event(ch->fsm, CH_EVENT_IO_UNKNOWN, ch);
791 * Check sense of a unit check.
793 * @param ch The channel, the sense code belongs to.
794 * @param sense The sense code to inspect.
797 ccw_unit_check(struct channel *ch, unsigned char sense)
799 DBF_TEXT(trace, 2, __FUNCTION__);
800 if (sense & SNS0_INTERVENTION_REQ) {
802 if (ch->protocol != CTC_PROTO_LINUX_TTY)
803 ctc_pr_debug("%s: Interface disc. or Sel. reset "
804 "(remote)\n", ch->id);
805 fsm_event(ch->fsm, CH_EVENT_UC_RCRESET, ch);
807 ctc_pr_debug("%s: System reset (remote)\n", ch->id);
808 fsm_event(ch->fsm, CH_EVENT_UC_RSRESET, ch);
810 } else if (sense & SNS0_EQUIPMENT_CHECK) {
811 if (sense & SNS0_BUS_OUT_CHECK) {
812 ctc_pr_warn("%s: Hardware malfunction (remote)\n",
814 fsm_event(ch->fsm, CH_EVENT_UC_HWFAIL, ch);
816 ctc_pr_warn("%s: Read-data parity error (remote)\n",
818 fsm_event(ch->fsm, CH_EVENT_UC_RXPARITY, ch);
820 } else if (sense & SNS0_BUS_OUT_CHECK) {
822 ctc_pr_warn("%s: Data-streaming timeout)\n", ch->id);
823 fsm_event(ch->fsm, CH_EVENT_UC_TXTIMEOUT, ch);
825 ctc_pr_warn("%s: Data-transfer parity error\n", ch->id);
826 fsm_event(ch->fsm, CH_EVENT_UC_TXPARITY, ch);
828 } else if (sense & SNS0_CMD_REJECT) {
829 ctc_pr_warn("%s: Command reject\n", ch->id);
830 } else if (sense == 0) {
831 ctc_pr_debug("%s: Unit check ZERO\n", ch->id);
832 fsm_event(ch->fsm, CH_EVENT_UC_ZERO, ch);
834 ctc_pr_warn("%s: Unit Check with sense code: %02x\n",
836 fsm_event(ch->fsm, CH_EVENT_UC_UNKNOWN, ch);
841 ctc_purge_skb_queue(struct sk_buff_head *q)
845 DBF_TEXT(trace, 2, __FUNCTION__);
847 while ((skb = skb_dequeue(q))) {
848 atomic_dec(&skb->users);
849 dev_kfree_skb_irq(skb);
853 static __inline__ int
854 ctc_checkalloc_buffer(struct channel *ch, int warn)
856 DBF_TEXT(trace, 2, __FUNCTION__);
857 if ((ch->trans_skb == NULL) ||
858 (ch->flags & CHANNEL_FLAGS_BUFSIZE_CHANGED)) {
859 if (ch->trans_skb != NULL)
860 dev_kfree_skb(ch->trans_skb);
861 clear_normalized_cda(&ch->ccw[1]);
862 ch->trans_skb = __dev_alloc_skb(ch->max_bufsize,
863 GFP_ATOMIC | GFP_DMA);
864 if (ch->trans_skb == NULL) {
867 "%s: Couldn't alloc %s trans_skb\n",
869 (CHANNEL_DIRECTION(ch->flags) == READ) ?
873 ch->ccw[1].count = ch->max_bufsize;
874 if (set_normalized_cda(&ch->ccw[1], ch->trans_skb->data)) {
875 dev_kfree_skb(ch->trans_skb);
876 ch->trans_skb = NULL;
879 "%s: set_normalized_cda for %s "
880 "trans_skb failed, dropping packets\n",
882 (CHANNEL_DIRECTION(ch->flags) == READ) ?
886 ch->ccw[1].count = 0;
887 ch->trans_skb_data = ch->trans_skb->data;
888 ch->flags &= ~CHANNEL_FLAGS_BUFSIZE_CHANGED;
894 * Dummy NOP action for statemachines
897 fsm_action_nop(fsm_instance * fi, int event, void *arg)
902 * Actions for channel - statemachines.
903 *****************************************************************************/
906 * Normal data has been send. Free the corresponding
907 * skb (it's in io_queue), reset dev->tbusy and
908 * revert to idle state.
910 * @param fi An instance of a channel statemachine.
911 * @param event The event, just happened.
912 * @param arg Generic pointer, casted from channel * upon call.
915 ch_action_txdone(fsm_instance * fi, int event, void *arg)
917 struct channel *ch = (struct channel *) arg;
918 struct net_device *dev = ch->netdev;
919 struct ctc_priv *privptr = dev->priv;
923 unsigned long duration;
924 struct timespec done_stamp = xtime;
926 DBF_TEXT(trace, 2, __FUNCTION__);
929 (done_stamp.tv_sec - ch->prof.send_stamp.tv_sec) * 1000000 +
930 (done_stamp.tv_nsec - ch->prof.send_stamp.tv_nsec) / 1000;
931 if (duration > ch->prof.tx_time)
932 ch->prof.tx_time = duration;
934 if (ch->irb->scsw.count != 0)
935 ctc_pr_debug("%s: TX not complete, remaining %d bytes\n",
936 dev->name, ch->irb->scsw.count);
937 fsm_deltimer(&ch->timer);
938 while ((skb = skb_dequeue(&ch->io_queue))) {
939 privptr->stats.tx_packets++;
940 privptr->stats.tx_bytes += skb->len - LL_HEADER_LENGTH;
942 privptr->stats.tx_bytes += 2;
945 atomic_dec(&skb->users);
946 dev_kfree_skb_irq(skb);
948 spin_lock(&ch->collect_lock);
949 clear_normalized_cda(&ch->ccw[4]);
950 if (ch->collect_len > 0) {
953 if (ctc_checkalloc_buffer(ch, 1)) {
954 spin_unlock(&ch->collect_lock);
957 ch->trans_skb->tail = ch->trans_skb->data = ch->trans_skb_data;
958 ch->trans_skb->len = 0;
959 if (ch->prof.maxmulti < (ch->collect_len + 2))
960 ch->prof.maxmulti = ch->collect_len + 2;
961 if (ch->prof.maxcqueue < skb_queue_len(&ch->collect_queue))
962 ch->prof.maxcqueue = skb_queue_len(&ch->collect_queue);
963 *((__u16 *) skb_put(ch->trans_skb, 2)) = ch->collect_len + 2;
965 while ((skb = skb_dequeue(&ch->collect_queue))) {
966 memcpy(skb_put(ch->trans_skb, skb->len), skb->data,
968 privptr->stats.tx_packets++;
969 privptr->stats.tx_bytes += skb->len - LL_HEADER_LENGTH;
970 atomic_dec(&skb->users);
971 dev_kfree_skb_irq(skb);
975 spin_unlock(&ch->collect_lock);
976 ch->ccw[1].count = ch->trans_skb->len;
977 fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC, CH_EVENT_TIMER, ch);
978 ch->prof.send_stamp = xtime;
979 rc = ccw_device_start(ch->cdev, &ch->ccw[0],
980 (unsigned long) ch, 0xff, 0);
981 ch->prof.doios_multi++;
983 privptr->stats.tx_dropped += i;
984 privptr->stats.tx_errors += i;
985 fsm_deltimer(&ch->timer);
986 ccw_check_return_code(ch, rc, "chained TX");
989 spin_unlock(&ch->collect_lock);
990 fsm_newstate(fi, CH_STATE_TXIDLE);
996 * Initial data is sent.
997 * Notify device statemachine that we are up and
1000 * @param fi An instance of a channel statemachine.
1001 * @param event The event, just happened.
1002 * @param arg Generic pointer, casted from channel * upon call.
1005 ch_action_txidle(fsm_instance * fi, int event, void *arg)
1007 struct channel *ch = (struct channel *) arg;
1009 DBF_TEXT(trace, 2, __FUNCTION__);
1010 fsm_deltimer(&ch->timer);
1011 fsm_newstate(fi, CH_STATE_TXIDLE);
1012 fsm_event(((struct ctc_priv *) ch->netdev->priv)->fsm, DEV_EVENT_TXUP,
1017 * Got normal data, check for sanity, queue it up, allocate new buffer
1018 * trigger bottom half, and initiate next read.
1020 * @param fi An instance of a channel statemachine.
1021 * @param event The event, just happened.
1022 * @param arg Generic pointer, casted from channel * upon call.
1025 ch_action_rx(fsm_instance * fi, int event, void *arg)
1027 struct channel *ch = (struct channel *) arg;
1028 struct net_device *dev = ch->netdev;
1029 struct ctc_priv *privptr = dev->priv;
1030 int len = ch->max_bufsize - ch->irb->scsw.count;
1031 struct sk_buff *skb = ch->trans_skb;
1032 __u16 block_len = *((__u16 *) skb->data);
1036 DBF_TEXT(trace, 2, __FUNCTION__);
1037 fsm_deltimer(&ch->timer);
1039 ctc_pr_debug("%s: got packet with length %d < 8\n",
1041 privptr->stats.rx_dropped++;
1042 privptr->stats.rx_length_errors++;
1045 if (len > ch->max_bufsize) {
1046 ctc_pr_debug("%s: got packet with length %d > %d\n",
1047 dev->name, len, ch->max_bufsize);
1048 privptr->stats.rx_dropped++;
1049 privptr->stats.rx_length_errors++;
1054 * VM TCP seems to have a bug sending 2 trailing bytes of garbage.
1056 switch (ch->protocol) {
1057 case CTC_PROTO_S390:
1058 case CTC_PROTO_OS390:
1059 check_len = block_len + 2;
1062 check_len = block_len;
1065 if ((len < block_len) || (len > check_len)) {
1066 ctc_pr_debug("%s: got block length %d != rx length %d\n",
1067 dev->name, block_len, len);
1069 ctc_dump_skb(skb, 0);
1071 *((__u16 *) skb->data) = len;
1072 privptr->stats.rx_dropped++;
1073 privptr->stats.rx_length_errors++;
1077 if (block_len > 0) {
1078 *((__u16 *) skb->data) = block_len;
1079 ctc_unpack_skb(ch, skb);
1082 skb->data = skb->tail = ch->trans_skb_data;
1084 if (ctc_checkalloc_buffer(ch, 1))
1086 ch->ccw[1].count = ch->max_bufsize;
1087 rc = ccw_device_start(ch->cdev, &ch->ccw[0], (unsigned long) ch, 0xff, 0);
1089 ccw_check_return_code(ch, rc, "normal RX");
1092 static void ch_action_rxidle(fsm_instance * fi, int event, void *arg);
1095 * Initialize connection by sending a __u16 of value 0.
1097 * @param fi An instance of a channel statemachine.
1098 * @param event The event, just happened.
1099 * @param arg Generic pointer, casted from channel * upon call.
1102 ch_action_firstio(fsm_instance * fi, int event, void *arg)
1104 struct channel *ch = (struct channel *) arg;
1107 DBF_TEXT(trace, 2, __FUNCTION__);
1109 if (fsm_getstate(fi) == CH_STATE_TXIDLE)
1110 ctc_pr_debug("%s: remote side issued READ?, init ...\n", ch->id);
1111 fsm_deltimer(&ch->timer);
1112 if (ctc_checkalloc_buffer(ch, 1))
1114 if ((fsm_getstate(fi) == CH_STATE_SETUPWAIT) &&
1115 (ch->protocol == CTC_PROTO_OS390)) {
1116 /* OS/390 resp. z/OS */
1117 if (CHANNEL_DIRECTION(ch->flags) == READ) {
1118 *((__u16 *) ch->trans_skb->data) = CTC_INITIAL_BLOCKLEN;
1119 fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC,
1120 CH_EVENT_TIMER, ch);
1121 ch_action_rxidle(fi, event, arg);
1123 struct net_device *dev = ch->netdev;
1124 fsm_newstate(fi, CH_STATE_TXIDLE);
1125 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1126 DEV_EVENT_TXUP, dev);
1132 * Don´t setup a timer for receiving the initial RX frame
1133 * if in compatibility mode, since VM TCP delays the initial
1134 * frame until it has some data to send.
1136 if ((CHANNEL_DIRECTION(ch->flags) == WRITE) ||
1137 (ch->protocol != CTC_PROTO_S390))
1138 fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC, CH_EVENT_TIMER, ch);
1140 *((__u16 *) ch->trans_skb->data) = CTC_INITIAL_BLOCKLEN;
1141 ch->ccw[1].count = 2; /* Transfer only length */
1143 fsm_newstate(fi, (CHANNEL_DIRECTION(ch->flags) == READ)
1144 ? CH_STATE_RXINIT : CH_STATE_TXINIT);
1145 rc = ccw_device_start(ch->cdev, &ch->ccw[0], (unsigned long) ch, 0xff, 0);
1147 fsm_deltimer(&ch->timer);
1148 fsm_newstate(fi, CH_STATE_SETUPWAIT);
1149 ccw_check_return_code(ch, rc, "init IO");
1152 * If in compatibility mode since we don´t setup a timer, we
1153 * also signal RX channel up immediately. This enables us
1154 * to send packets early which in turn usually triggers some
1155 * reply from VM TCP which brings up the RX channel to it´s
1158 if ((CHANNEL_DIRECTION(ch->flags) == READ) &&
1159 (ch->protocol == CTC_PROTO_S390)) {
1160 struct net_device *dev = ch->netdev;
1161 fsm_event(((struct ctc_priv *) dev->priv)->fsm, DEV_EVENT_RXUP,
1167 * Got initial data, check it. If OK,
1168 * notify device statemachine that we are up and
1171 * @param fi An instance of a channel statemachine.
1172 * @param event The event, just happened.
1173 * @param arg Generic pointer, casted from channel * upon call.
1176 ch_action_rxidle(fsm_instance * fi, int event, void *arg)
1178 struct channel *ch = (struct channel *) arg;
1179 struct net_device *dev = ch->netdev;
1183 DBF_TEXT(trace, 2, __FUNCTION__);
1184 fsm_deltimer(&ch->timer);
1185 buflen = *((__u16 *) ch->trans_skb->data);
1187 ctc_pr_debug("%s: Initial RX count %d\n", dev->name, buflen);
1189 if (buflen >= CTC_INITIAL_BLOCKLEN) {
1190 if (ctc_checkalloc_buffer(ch, 1))
1192 ch->ccw[1].count = ch->max_bufsize;
1193 fsm_newstate(fi, CH_STATE_RXIDLE);
1194 rc = ccw_device_start(ch->cdev, &ch->ccw[0],
1195 (unsigned long) ch, 0xff, 0);
1197 fsm_newstate(fi, CH_STATE_RXINIT);
1198 ccw_check_return_code(ch, rc, "initial RX");
1200 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1201 DEV_EVENT_RXUP, dev);
1203 ctc_pr_debug("%s: Initial RX count %d not %d\n",
1204 dev->name, buflen, CTC_INITIAL_BLOCKLEN);
1205 ch_action_firstio(fi, event, arg);
1210 * Set channel into extended mode.
1212 * @param fi An instance of a channel statemachine.
1213 * @param event The event, just happened.
1214 * @param arg Generic pointer, casted from channel * upon call.
1217 ch_action_setmode(fsm_instance * fi, int event, void *arg)
1219 struct channel *ch = (struct channel *) arg;
1221 unsigned long saveflags;
1223 DBF_TEXT(trace, 2, __FUNCTION__);
1224 fsm_deltimer(&ch->timer);
1225 fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC, CH_EVENT_TIMER, ch);
1226 fsm_newstate(fi, CH_STATE_SETUPWAIT);
1227 if (event == CH_EVENT_TIMER)
1228 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
1229 rc = ccw_device_start(ch->cdev, &ch->ccw[6], (unsigned long) ch, 0xff, 0);
1230 if (event == CH_EVENT_TIMER)
1231 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
1233 fsm_deltimer(&ch->timer);
1234 fsm_newstate(fi, CH_STATE_STARTWAIT);
1235 ccw_check_return_code(ch, rc, "set Mode");
1243 * @param fi An instance of a channel statemachine.
1244 * @param event The event, just happened.
1245 * @param arg Generic pointer, casted from channel * upon call.
1248 ch_action_start(fsm_instance * fi, int event, void *arg)
1250 struct channel *ch = (struct channel *) arg;
1251 unsigned long saveflags;
1253 struct net_device *dev;
1255 DBF_TEXT(trace, 2, __FUNCTION__);
1257 ctc_pr_warn("ch_action_start ch=NULL\n");
1260 if (ch->netdev == NULL) {
1261 ctc_pr_warn("ch_action_start dev=NULL, id=%s\n", ch->id);
1267 ctc_pr_debug("%s: %s channel start\n", dev->name,
1268 (CHANNEL_DIRECTION(ch->flags) == READ) ? "RX" : "TX");
1271 if (ch->trans_skb != NULL) {
1272 clear_normalized_cda(&ch->ccw[1]);
1273 dev_kfree_skb(ch->trans_skb);
1274 ch->trans_skb = NULL;
1276 if (CHANNEL_DIRECTION(ch->flags) == READ) {
1277 ch->ccw[1].cmd_code = CCW_CMD_READ;
1278 ch->ccw[1].flags = CCW_FLAG_SLI;
1279 ch->ccw[1].count = 0;
1281 ch->ccw[1].cmd_code = CCW_CMD_WRITE;
1282 ch->ccw[1].flags = CCW_FLAG_SLI | CCW_FLAG_CC;
1283 ch->ccw[1].count = 0;
1285 if (ctc_checkalloc_buffer(ch, 0)) {
1287 "%s: Could not allocate %s trans_skb, delaying "
1288 "allocation until first transfer\n",
1290 (CHANNEL_DIRECTION(ch->flags) == READ) ? "RX" : "TX");
1293 ch->ccw[0].cmd_code = CCW_CMD_PREPARE;
1294 ch->ccw[0].flags = CCW_FLAG_SLI | CCW_FLAG_CC;
1295 ch->ccw[0].count = 0;
1297 ch->ccw[2].cmd_code = CCW_CMD_NOOP; /* jointed CE + DE */
1298 ch->ccw[2].flags = CCW_FLAG_SLI;
1299 ch->ccw[2].count = 0;
1301 memcpy(&ch->ccw[3], &ch->ccw[0], sizeof (struct ccw1) * 3);
1303 ch->ccw[4].flags &= ~CCW_FLAG_IDA;
1305 fsm_newstate(fi, CH_STATE_STARTWAIT);
1306 fsm_addtimer(&ch->timer, 1000, CH_EVENT_TIMER, ch);
1307 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
1308 rc = ccw_device_halt(ch->cdev, (unsigned long) ch);
1309 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
1312 fsm_deltimer(&ch->timer);
1313 ccw_check_return_code(ch, rc, "initial HaltIO");
1316 ctc_pr_debug("ctc: %s(): leaving\n", __func__);
1321 * Shutdown a channel.
1323 * @param fi An instance of a channel statemachine.
1324 * @param event The event, just happened.
1325 * @param arg Generic pointer, casted from channel * upon call.
1328 ch_action_haltio(fsm_instance * fi, int event, void *arg)
1330 struct channel *ch = (struct channel *) arg;
1331 unsigned long saveflags;
1335 DBF_TEXT(trace, 2, __FUNCTION__);
1336 fsm_deltimer(&ch->timer);
1337 fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC, CH_EVENT_TIMER, ch);
1338 if (event == CH_EVENT_STOP)
1339 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
1340 oldstate = fsm_getstate(fi);
1341 fsm_newstate(fi, CH_STATE_TERM);
1342 rc = ccw_device_halt(ch->cdev, (unsigned long) ch);
1343 if (event == CH_EVENT_STOP)
1344 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
1347 fsm_deltimer(&ch->timer);
1348 fsm_newstate(fi, oldstate);
1350 ccw_check_return_code(ch, rc, "HaltIO in ch_action_haltio");
1355 * A channel has successfully been halted.
1356 * Cleanup it's queue and notify interface statemachine.
1358 * @param fi An instance of a channel statemachine.
1359 * @param event The event, just happened.
1360 * @param arg Generic pointer, casted from channel * upon call.
1363 ch_action_stopped(fsm_instance * fi, int event, void *arg)
1365 struct channel *ch = (struct channel *) arg;
1366 struct net_device *dev = ch->netdev;
1368 DBF_TEXT(trace, 2, __FUNCTION__);
1369 fsm_deltimer(&ch->timer);
1370 fsm_newstate(fi, CH_STATE_STOPPED);
1371 if (ch->trans_skb != NULL) {
1372 clear_normalized_cda(&ch->ccw[1]);
1373 dev_kfree_skb(ch->trans_skb);
1374 ch->trans_skb = NULL;
1376 if (CHANNEL_DIRECTION(ch->flags) == READ) {
1377 skb_queue_purge(&ch->io_queue);
1378 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1379 DEV_EVENT_RXDOWN, dev);
1381 ctc_purge_skb_queue(&ch->io_queue);
1382 spin_lock(&ch->collect_lock);
1383 ctc_purge_skb_queue(&ch->collect_queue);
1384 ch->collect_len = 0;
1385 spin_unlock(&ch->collect_lock);
1386 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1387 DEV_EVENT_TXDOWN, dev);
1392 * A stop command from device statemachine arrived and we are in
1393 * not operational mode. Set state to stopped.
1395 * @param fi An instance of a channel statemachine.
1396 * @param event The event, just happened.
1397 * @param arg Generic pointer, casted from channel * upon call.
1400 ch_action_stop(fsm_instance * fi, int event, void *arg)
1402 fsm_newstate(fi, CH_STATE_STOPPED);
1406 * A machine check for no path, not operational status or gone device has
1408 * Cleanup queue and notify interface statemachine.
1410 * @param fi An instance of a channel statemachine.
1411 * @param event The event, just happened.
1412 * @param arg Generic pointer, casted from channel * upon call.
1415 ch_action_fail(fsm_instance * fi, int event, void *arg)
1417 struct channel *ch = (struct channel *) arg;
1418 struct net_device *dev = ch->netdev;
1420 DBF_TEXT(trace, 2, __FUNCTION__);
1421 fsm_deltimer(&ch->timer);
1422 fsm_newstate(fi, CH_STATE_NOTOP);
1423 if (CHANNEL_DIRECTION(ch->flags) == READ) {
1424 skb_queue_purge(&ch->io_queue);
1425 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1426 DEV_EVENT_RXDOWN, dev);
1428 ctc_purge_skb_queue(&ch->io_queue);
1429 spin_lock(&ch->collect_lock);
1430 ctc_purge_skb_queue(&ch->collect_queue);
1431 ch->collect_len = 0;
1432 spin_unlock(&ch->collect_lock);
1433 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1434 DEV_EVENT_TXDOWN, dev);
1439 * Handle error during setup of channel.
1441 * @param fi An instance of a channel statemachine.
1442 * @param event The event, just happened.
1443 * @param arg Generic pointer, casted from channel * upon call.
1446 ch_action_setuperr(fsm_instance * fi, int event, void *arg)
1448 struct channel *ch = (struct channel *) arg;
1449 struct net_device *dev = ch->netdev;
1451 DBF_TEXT(setup, 2, __FUNCTION__);
1453 * Special case: Got UC_RCRESET on setmode.
1454 * This means that remote side isn't setup. In this case
1455 * simply retry after some 10 secs...
1457 if ((fsm_getstate(fi) == CH_STATE_SETUPWAIT) &&
1458 ((event == CH_EVENT_UC_RCRESET) ||
1459 (event == CH_EVENT_UC_RSRESET))) {
1460 fsm_newstate(fi, CH_STATE_STARTRETRY);
1461 fsm_deltimer(&ch->timer);
1462 fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC, CH_EVENT_TIMER, ch);
1463 if (CHANNEL_DIRECTION(ch->flags) == READ) {
1464 int rc = ccw_device_halt(ch->cdev, (unsigned long) ch);
1466 ccw_check_return_code(
1467 ch, rc, "HaltIO in ch_action_setuperr");
1472 ctc_pr_debug("%s: Error %s during %s channel setup state=%s\n",
1473 dev->name, ch_event_names[event],
1474 (CHANNEL_DIRECTION(ch->flags) == READ) ? "RX" : "TX",
1475 fsm_getstate_str(fi));
1476 if (CHANNEL_DIRECTION(ch->flags) == READ) {
1477 fsm_newstate(fi, CH_STATE_RXERR);
1478 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1479 DEV_EVENT_RXDOWN, dev);
1481 fsm_newstate(fi, CH_STATE_TXERR);
1482 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1483 DEV_EVENT_TXDOWN, dev);
1488 * Restart a channel after an error.
1490 * @param fi An instance of a channel statemachine.
1491 * @param event The event, just happened.
1492 * @param arg Generic pointer, casted from channel * upon call.
1495 ch_action_restart(fsm_instance * fi, int event, void *arg)
1497 unsigned long saveflags;
1501 struct channel *ch = (struct channel *) arg;
1502 struct net_device *dev = ch->netdev;
1504 DBF_TEXT(trace, 2, __FUNCTION__);
1505 fsm_deltimer(&ch->timer);
1506 ctc_pr_debug("%s: %s channel restart\n", dev->name,
1507 (CHANNEL_DIRECTION(ch->flags) == READ) ? "RX" : "TX");
1508 fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC, CH_EVENT_TIMER, ch);
1509 oldstate = fsm_getstate(fi);
1510 fsm_newstate(fi, CH_STATE_STARTWAIT);
1511 if (event == CH_EVENT_TIMER)
1512 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
1513 rc = ccw_device_halt(ch->cdev, (unsigned long) ch);
1514 if (event == CH_EVENT_TIMER)
1515 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
1518 fsm_deltimer(&ch->timer);
1519 fsm_newstate(fi, oldstate);
1521 ccw_check_return_code(ch, rc, "HaltIO in ch_action_restart");
1526 * Handle error during RX initial handshake (exchange of
1527 * 0-length block header)
1529 * @param fi An instance of a channel statemachine.
1530 * @param event The event, just happened.
1531 * @param arg Generic pointer, casted from channel * upon call.
1534 ch_action_rxiniterr(fsm_instance * fi, int event, void *arg)
1536 struct channel *ch = (struct channel *) arg;
1537 struct net_device *dev = ch->netdev;
1539 DBF_TEXT(setup, 2, __FUNCTION__);
1540 if (event == CH_EVENT_TIMER) {
1541 fsm_deltimer(&ch->timer);
1542 ctc_pr_debug("%s: Timeout during RX init handshake\n", dev->name);
1543 if (ch->retry++ < 3)
1544 ch_action_restart(fi, event, arg);
1546 fsm_newstate(fi, CH_STATE_RXERR);
1547 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1548 DEV_EVENT_RXDOWN, dev);
1551 ctc_pr_warn("%s: Error during RX init handshake\n", dev->name);
1555 * Notify device statemachine if we gave up initialization
1558 * @param fi An instance of a channel statemachine.
1559 * @param event The event, just happened.
1560 * @param arg Generic pointer, casted from channel * upon call.
1563 ch_action_rxinitfail(fsm_instance * fi, int event, void *arg)
1565 struct channel *ch = (struct channel *) arg;
1566 struct net_device *dev = ch->netdev;
1568 DBF_TEXT(setup, 2, __FUNCTION__);
1569 fsm_newstate(fi, CH_STATE_RXERR);
1570 ctc_pr_warn("%s: RX initialization failed\n", dev->name);
1571 ctc_pr_warn("%s: RX <-> RX connection detected\n", dev->name);
1572 fsm_event(((struct ctc_priv *) dev->priv)->fsm, DEV_EVENT_RXDOWN, dev);
1576 * Handle RX Unit check remote reset (remote disconnected)
1578 * @param fi An instance of a channel statemachine.
1579 * @param event The event, just happened.
1580 * @param arg Generic pointer, casted from channel * upon call.
1583 ch_action_rxdisc(fsm_instance * fi, int event, void *arg)
1585 struct channel *ch = (struct channel *) arg;
1586 struct channel *ch2;
1587 struct net_device *dev = ch->netdev;
1589 DBF_TEXT(trace, 2, __FUNCTION__);
1590 fsm_deltimer(&ch->timer);
1591 ctc_pr_debug("%s: Got remote disconnect, re-initializing ...\n",
1595 * Notify device statemachine
1597 fsm_event(((struct ctc_priv *) dev->priv)->fsm, DEV_EVENT_RXDOWN, dev);
1598 fsm_event(((struct ctc_priv *) dev->priv)->fsm, DEV_EVENT_TXDOWN, dev);
1600 fsm_newstate(fi, CH_STATE_DTERM);
1601 ch2 = ((struct ctc_priv *) dev->priv)->channel[WRITE];
1602 fsm_newstate(ch2->fsm, CH_STATE_DTERM);
1604 ccw_device_halt(ch->cdev, (unsigned long) ch);
1605 ccw_device_halt(ch2->cdev, (unsigned long) ch2);
1609 * Handle error during TX channel initialization.
1611 * @param fi An instance of a channel statemachine.
1612 * @param event The event, just happened.
1613 * @param arg Generic pointer, casted from channel * upon call.
1616 ch_action_txiniterr(fsm_instance * fi, int event, void *arg)
1618 struct channel *ch = (struct channel *) arg;
1619 struct net_device *dev = ch->netdev;
1621 DBF_TEXT(setup, 2, __FUNCTION__);
1622 if (event == CH_EVENT_TIMER) {
1623 fsm_deltimer(&ch->timer);
1624 ctc_pr_debug("%s: Timeout during TX init handshake\n", dev->name);
1625 if (ch->retry++ < 3)
1626 ch_action_restart(fi, event, arg);
1628 fsm_newstate(fi, CH_STATE_TXERR);
1629 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1630 DEV_EVENT_TXDOWN, dev);
1633 ctc_pr_warn("%s: Error during TX init handshake\n", dev->name);
1637 * Handle TX timeout by retrying operation.
1639 * @param fi An instance of a channel statemachine.
1640 * @param event The event, just happened.
1641 * @param arg Generic pointer, casted from channel * upon call.
1644 ch_action_txretry(fsm_instance * fi, int event, void *arg)
1646 struct channel *ch = (struct channel *) arg;
1647 struct net_device *dev = ch->netdev;
1648 unsigned long saveflags;
1650 DBF_TEXT(trace, 2, __FUNCTION__);
1651 fsm_deltimer(&ch->timer);
1652 if (ch->retry++ > 3) {
1653 ctc_pr_debug("%s: TX retry failed, restarting channel\n",
1655 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1656 DEV_EVENT_TXDOWN, dev);
1657 ch_action_restart(fi, event, arg);
1659 struct sk_buff *skb;
1661 ctc_pr_debug("%s: TX retry %d\n", dev->name, ch->retry);
1662 if ((skb = skb_peek(&ch->io_queue))) {
1665 clear_normalized_cda(&ch->ccw[4]);
1666 ch->ccw[4].count = skb->len;
1667 if (set_normalized_cda(&ch->ccw[4], skb->data)) {
1669 "%s: IDAL alloc failed, chan restart\n",
1671 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1672 DEV_EVENT_TXDOWN, dev);
1673 ch_action_restart(fi, event, arg);
1676 fsm_addtimer(&ch->timer, 1000, CH_EVENT_TIMER, ch);
1677 if (event == CH_EVENT_TIMER)
1678 spin_lock_irqsave(get_ccwdev_lock(ch->cdev),
1680 rc = ccw_device_start(ch->cdev, &ch->ccw[3],
1681 (unsigned long) ch, 0xff, 0);
1682 if (event == CH_EVENT_TIMER)
1683 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev),
1686 fsm_deltimer(&ch->timer);
1687 ccw_check_return_code(ch, rc, "TX in ch_action_txretry");
1688 ctc_purge_skb_queue(&ch->io_queue);
1696 * Handle fatal errors during an I/O command.
1698 * @param fi An instance of a channel statemachine.
1699 * @param event The event, just happened.
1700 * @param arg Generic pointer, casted from channel * upon call.
1703 ch_action_iofatal(fsm_instance * fi, int event, void *arg)
1705 struct channel *ch = (struct channel *) arg;
1706 struct net_device *dev = ch->netdev;
1708 DBF_TEXT(trace, 2, __FUNCTION__);
1709 fsm_deltimer(&ch->timer);
1710 if (CHANNEL_DIRECTION(ch->flags) == READ) {
1711 ctc_pr_debug("%s: RX I/O error\n", dev->name);
1712 fsm_newstate(fi, CH_STATE_RXERR);
1713 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1714 DEV_EVENT_RXDOWN, dev);
1716 ctc_pr_debug("%s: TX I/O error\n", dev->name);
1717 fsm_newstate(fi, CH_STATE_TXERR);
1718 fsm_event(((struct ctc_priv *) dev->priv)->fsm,
1719 DEV_EVENT_TXDOWN, dev);
1724 ch_action_reinit(fsm_instance *fi, int event, void *arg)
1726 struct channel *ch = (struct channel *)arg;
1727 struct net_device *dev = ch->netdev;
1728 struct ctc_priv *privptr = dev->priv;
1730 DBF_TEXT(trace, 2, __FUNCTION__);
1731 ch_action_iofatal(fi, event, arg);
1732 fsm_addtimer(&privptr->restart_timer, 1000, DEV_EVENT_RESTART, dev);
1737 * The statemachine for a channel.
1739 static const fsm_node ch_fsm[] = {
1740 {CH_STATE_STOPPED, CH_EVENT_STOP, fsm_action_nop },
1741 {CH_STATE_STOPPED, CH_EVENT_START, ch_action_start },
1742 {CH_STATE_STOPPED, CH_EVENT_FINSTAT, fsm_action_nop },
1743 {CH_STATE_STOPPED, CH_EVENT_MC_FAIL, fsm_action_nop },
1745 {CH_STATE_NOTOP, CH_EVENT_STOP, ch_action_stop },
1746 {CH_STATE_NOTOP, CH_EVENT_START, fsm_action_nop },
1747 {CH_STATE_NOTOP, CH_EVENT_FINSTAT, fsm_action_nop },
1748 {CH_STATE_NOTOP, CH_EVENT_MC_FAIL, fsm_action_nop },
1749 {CH_STATE_NOTOP, CH_EVENT_MC_GOOD, ch_action_start },
1751 {CH_STATE_STARTWAIT, CH_EVENT_STOP, ch_action_haltio },
1752 {CH_STATE_STARTWAIT, CH_EVENT_START, fsm_action_nop },
1753 {CH_STATE_STARTWAIT, CH_EVENT_FINSTAT, ch_action_setmode },
1754 {CH_STATE_STARTWAIT, CH_EVENT_TIMER, ch_action_setuperr },
1755 {CH_STATE_STARTWAIT, CH_EVENT_IO_ENODEV, ch_action_iofatal },
1756 {CH_STATE_STARTWAIT, CH_EVENT_IO_EIO, ch_action_reinit },
1757 {CH_STATE_STARTWAIT, CH_EVENT_MC_FAIL, ch_action_fail },
1759 {CH_STATE_STARTRETRY, CH_EVENT_STOP, ch_action_haltio },
1760 {CH_STATE_STARTRETRY, CH_EVENT_TIMER, ch_action_setmode },
1761 {CH_STATE_STARTRETRY, CH_EVENT_FINSTAT, fsm_action_nop },
1762 {CH_STATE_STARTRETRY, CH_EVENT_MC_FAIL, ch_action_fail },
1764 {CH_STATE_SETUPWAIT, CH_EVENT_STOP, ch_action_haltio },
1765 {CH_STATE_SETUPWAIT, CH_EVENT_START, fsm_action_nop },
1766 {CH_STATE_SETUPWAIT, CH_EVENT_FINSTAT, ch_action_firstio },
1767 {CH_STATE_SETUPWAIT, CH_EVENT_UC_RCRESET, ch_action_setuperr },
1768 {CH_STATE_SETUPWAIT, CH_EVENT_UC_RSRESET, ch_action_setuperr },
1769 {CH_STATE_SETUPWAIT, CH_EVENT_TIMER, ch_action_setmode },
1770 {CH_STATE_SETUPWAIT, CH_EVENT_IO_ENODEV, ch_action_iofatal },
1771 {CH_STATE_SETUPWAIT, CH_EVENT_IO_EIO, ch_action_reinit },
1772 {CH_STATE_SETUPWAIT, CH_EVENT_MC_FAIL, ch_action_fail },
1774 {CH_STATE_RXINIT, CH_EVENT_STOP, ch_action_haltio },
1775 {CH_STATE_RXINIT, CH_EVENT_START, fsm_action_nop },
1776 {CH_STATE_RXINIT, CH_EVENT_FINSTAT, ch_action_rxidle },
1777 {CH_STATE_RXINIT, CH_EVENT_UC_RCRESET, ch_action_rxiniterr },
1778 {CH_STATE_RXINIT, CH_EVENT_UC_RSRESET, ch_action_rxiniterr },
1779 {CH_STATE_RXINIT, CH_EVENT_TIMER, ch_action_rxiniterr },
1780 {CH_STATE_RXINIT, CH_EVENT_ATTNBUSY, ch_action_rxinitfail },
1781 {CH_STATE_RXINIT, CH_EVENT_IO_ENODEV, ch_action_iofatal },
1782 {CH_STATE_RXINIT, CH_EVENT_IO_EIO, ch_action_reinit },
1783 {CH_STATE_RXINIT, CH_EVENT_UC_ZERO, ch_action_firstio },
1784 {CH_STATE_RXINIT, CH_EVENT_MC_FAIL, ch_action_fail },
1786 {CH_STATE_RXIDLE, CH_EVENT_STOP, ch_action_haltio },
1787 {CH_STATE_RXIDLE, CH_EVENT_START, fsm_action_nop },
1788 {CH_STATE_RXIDLE, CH_EVENT_FINSTAT, ch_action_rx },
1789 {CH_STATE_RXIDLE, CH_EVENT_UC_RCRESET, ch_action_rxdisc },
1790 // {CH_STATE_RXIDLE, CH_EVENT_UC_RSRESET, ch_action_rxretry },
1791 {CH_STATE_RXIDLE, CH_EVENT_IO_ENODEV, ch_action_iofatal },
1792 {CH_STATE_RXIDLE, CH_EVENT_IO_EIO, ch_action_reinit },
1793 {CH_STATE_RXIDLE, CH_EVENT_MC_FAIL, ch_action_fail },
1794 {CH_STATE_RXIDLE, CH_EVENT_UC_ZERO, ch_action_rx },
1796 {CH_STATE_TXINIT, CH_EVENT_STOP, ch_action_haltio },
1797 {CH_STATE_TXINIT, CH_EVENT_START, fsm_action_nop },
1798 {CH_STATE_TXINIT, CH_EVENT_FINSTAT, ch_action_txidle },
1799 {CH_STATE_TXINIT, CH_EVENT_UC_RCRESET, ch_action_txiniterr },
1800 {CH_STATE_TXINIT, CH_EVENT_UC_RSRESET, ch_action_txiniterr },
1801 {CH_STATE_TXINIT, CH_EVENT_TIMER, ch_action_txiniterr },
1802 {CH_STATE_TXINIT, CH_EVENT_IO_ENODEV, ch_action_iofatal },
1803 {CH_STATE_TXINIT, CH_EVENT_IO_EIO, ch_action_reinit },
1804 {CH_STATE_TXINIT, CH_EVENT_MC_FAIL, ch_action_fail },
1806 {CH_STATE_TXIDLE, CH_EVENT_STOP, ch_action_haltio },
1807 {CH_STATE_TXIDLE, CH_EVENT_START, fsm_action_nop },
1808 {CH_STATE_TXIDLE, CH_EVENT_FINSTAT, ch_action_firstio },
1809 {CH_STATE_TXIDLE, CH_EVENT_UC_RCRESET, fsm_action_nop },
1810 {CH_STATE_TXIDLE, CH_EVENT_UC_RSRESET, fsm_action_nop },
1811 {CH_STATE_TXIDLE, CH_EVENT_IO_ENODEV, ch_action_iofatal },
1812 {CH_STATE_TXIDLE, CH_EVENT_IO_EIO, ch_action_reinit },
1813 {CH_STATE_TXIDLE, CH_EVENT_MC_FAIL, ch_action_fail },
1815 {CH_STATE_TERM, CH_EVENT_STOP, fsm_action_nop },
1816 {CH_STATE_TERM, CH_EVENT_START, ch_action_restart },
1817 {CH_STATE_TERM, CH_EVENT_FINSTAT, ch_action_stopped },
1818 {CH_STATE_TERM, CH_EVENT_UC_RCRESET, fsm_action_nop },
1819 {CH_STATE_TERM, CH_EVENT_UC_RSRESET, fsm_action_nop },
1820 {CH_STATE_TERM, CH_EVENT_MC_FAIL, ch_action_fail },
1822 {CH_STATE_DTERM, CH_EVENT_STOP, ch_action_haltio },
1823 {CH_STATE_DTERM, CH_EVENT_START, ch_action_restart },
1824 {CH_STATE_DTERM, CH_EVENT_FINSTAT, ch_action_setmode },
1825 {CH_STATE_DTERM, CH_EVENT_UC_RCRESET, fsm_action_nop },
1826 {CH_STATE_DTERM, CH_EVENT_UC_RSRESET, fsm_action_nop },
1827 {CH_STATE_DTERM, CH_EVENT_MC_FAIL, ch_action_fail },
1829 {CH_STATE_TX, CH_EVENT_STOP, ch_action_haltio },
1830 {CH_STATE_TX, CH_EVENT_START, fsm_action_nop },
1831 {CH_STATE_TX, CH_EVENT_FINSTAT, ch_action_txdone },
1832 {CH_STATE_TX, CH_EVENT_UC_RCRESET, ch_action_txretry },
1833 {CH_STATE_TX, CH_EVENT_UC_RSRESET, ch_action_txretry },
1834 {CH_STATE_TX, CH_EVENT_TIMER, ch_action_txretry },
1835 {CH_STATE_TX, CH_EVENT_IO_ENODEV, ch_action_iofatal },
1836 {CH_STATE_TX, CH_EVENT_IO_EIO, ch_action_reinit },
1837 {CH_STATE_TX, CH_EVENT_MC_FAIL, ch_action_fail },
1839 {CH_STATE_RXERR, CH_EVENT_STOP, ch_action_haltio },
1840 {CH_STATE_TXERR, CH_EVENT_STOP, ch_action_haltio },
1841 {CH_STATE_TXERR, CH_EVENT_MC_FAIL, ch_action_fail },
1842 {CH_STATE_RXERR, CH_EVENT_MC_FAIL, ch_action_fail },
1845 static const int CH_FSM_LEN = sizeof (ch_fsm) / sizeof (fsm_node);
1848 * Functions related to setup and device detection.
1849 *****************************************************************************/
1852 less_than(char *id1, char *id2)
1856 for (i = 0; i < 5; i++) {
1860 dev1 = simple_strtoul(id1, &id1, 16);
1861 dev2 = simple_strtoul(id2, &id2, 16);
1863 return (dev1 < dev2);
1867 * Add a new channel to the list of channels.
1868 * Keeps the channel list sorted.
1870 * @param cdev The ccw_device to be added.
1871 * @param type The type class of the new channel.
1873 * @return 0 on success, !0 on error.
1876 add_channel(struct ccw_device *cdev, enum channel_types type)
1878 struct channel **c = &channels;
1881 DBF_TEXT(trace, 2, __FUNCTION__);
1883 (struct channel *) kmalloc(sizeof (struct channel),
1884 GFP_KERNEL)) == NULL) {
1885 ctc_pr_warn("ctc: Out of memory in add_channel\n");
1888 memset(ch, 0, sizeof (struct channel));
1889 if ((ch->ccw = (struct ccw1 *) kmalloc(sizeof (struct ccw1) * 8,
1890 GFP_KERNEL | GFP_DMA)) == NULL) {
1892 ctc_pr_warn("ctc: Out of memory in add_channel\n");
1897 * "static" ccws are used in the following way:
1899 * ccw[0..2] (Channel program for generic I/O):
1901 * 1: read or write (depending on direction) with fixed
1902 * buffer (idal allocated once when buffer is allocated)
1904 * ccw[3..5] (Channel program for direct write of packets)
1906 * 4: write (idal allocated on every write).
1908 * ccw[6..7] (Channel program for initial channel setup):
1909 * 3: set extended mode
1912 * ch->ccw[0..5] are initialized in ch_action_start because
1913 * the channel's direction is yet unknown here.
1915 ch->ccw[6].cmd_code = CCW_CMD_SET_EXTENDED;
1916 ch->ccw[6].flags = CCW_FLAG_SLI;
1917 ch->ccw[6].count = 0;
1920 ch->ccw[7].cmd_code = CCW_CMD_NOOP;
1921 ch->ccw[7].flags = CCW_FLAG_SLI;
1922 ch->ccw[7].count = 0;
1926 snprintf(ch->id, CTC_ID_SIZE, "ch-%s", cdev->dev.bus_id);
1928 loglevel = CTC_LOGLEVEL_DEFAULT;
1929 ch->fsm = init_fsm(ch->id, ch_state_names,
1930 ch_event_names, NR_CH_STATES, NR_CH_EVENTS,
1931 ch_fsm, CH_FSM_LEN, GFP_KERNEL);
1932 if (ch->fsm == NULL) {
1933 ctc_pr_warn("ctc: Could not create FSM in add_channel\n");
1937 fsm_newstate(ch->fsm, CH_STATE_IDLE);
1938 if ((ch->irb = (struct irb *) kmalloc(sizeof (struct irb),
1939 GFP_KERNEL)) == NULL) {
1940 ctc_pr_warn("ctc: Out of memory in add_channel\n");
1945 memset(ch->irb, 0, sizeof (struct irb));
1946 while (*c && less_than((*c)->id, ch->id))
1948 if (!strncmp((*c)->id, ch->id, CTC_ID_SIZE)) {
1950 "ctc: add_channel: device %s already in list, "
1951 "using old entry\n", (*c)->id);
1957 fsm_settimer(ch->fsm, &ch->timer);
1958 skb_queue_head_init(&ch->io_queue);
1959 skb_queue_head_init(&ch->collect_queue);
1966 * Release a specific channel in the channel list.
1968 * @param ch Pointer to channel struct to be released.
1971 channel_free(struct channel *ch)
1973 ch->flags &= ~CHANNEL_FLAGS_INUSE;
1974 fsm_newstate(ch->fsm, CH_STATE_IDLE);
1978 * Remove a specific channel in the channel list.
1980 * @param ch Pointer to channel struct to be released.
1983 channel_remove(struct channel *ch)
1985 struct channel **c = &channels;
1987 DBF_TEXT(trace, 2, __FUNCTION__);
1995 fsm_deltimer(&ch->timer);
1997 clear_normalized_cda(&ch->ccw[4]);
1998 if (ch->trans_skb != NULL) {
1999 clear_normalized_cda(&ch->ccw[1]);
2000 dev_kfree_skb(ch->trans_skb);
2010 * Get a specific channel from the channel list.
2012 * @param type Type of channel we are interested in.
2013 * @param id Id of channel we are interested in.
2014 * @param direction Direction we want to use this channel for.
2016 * @return Pointer to a channel or NULL if no matching channel available.
2018 static struct channel
2020 channel_get(enum channel_types type, char *id, int direction)
2022 struct channel *ch = channels;
2024 DBF_TEXT(trace, 2, __FUNCTION__);
2026 ctc_pr_debug("ctc: %s(): searching for ch with id %s and type %d\n",
2027 __func__, id, type);
2030 while (ch && ((strncmp(ch->id, id, CTC_ID_SIZE)) || (ch->type != type))) {
2032 ctc_pr_debug("ctc: %s(): ch=0x%p (id=%s, type=%d\n",
2033 __func__, ch, ch->id, ch->type);
2038 ctc_pr_debug("ctc: %s(): ch=0x%pq (id=%s, type=%d\n",
2039 __func__, ch, ch->id, ch->type);
2042 ctc_pr_warn("ctc: %s(): channel with id %s "
2043 "and type %d not found in channel list\n",
2044 __func__, id, type);
2046 if (ch->flags & CHANNEL_FLAGS_INUSE)
2049 ch->flags |= CHANNEL_FLAGS_INUSE;
2050 ch->flags &= ~CHANNEL_FLAGS_RWMASK;
2051 ch->flags |= (direction == WRITE)
2052 ? CHANNEL_FLAGS_WRITE : CHANNEL_FLAGS_READ;
2053 fsm_newstate(ch->fsm, CH_STATE_STOPPED);
2060 * Return the channel type by name.
2062 * @param name Name of network interface.
2064 * @return Type class of channel to be used for that interface.
2066 static enum channel_types inline
2067 extract_channel_media(char *name)
2069 enum channel_types ret = channel_type_unknown;
2072 if (strncmp(name, "ctc", 3) == 0)
2073 ret = channel_type_parallel;
2074 if (strncmp(name, "escon", 5) == 0)
2075 ret = channel_type_escon;
2081 __ctc_check_irb_error(struct ccw_device *cdev, struct irb *irb)
2086 switch (PTR_ERR(irb)) {
2088 ctc_pr_warn("i/o-error on device %s\n", cdev->dev.bus_id);
2089 // CTC_DBF_TEXT(trace, 2, "ckirberr");
2090 // CTC_DBF_TEXT_(trace, 2, " rc%d", -EIO);
2093 ctc_pr_warn("timeout on device %s\n", cdev->dev.bus_id);
2094 // CTC_DBF_TEXT(trace, 2, "ckirberr");
2095 // CTC_DBF_TEXT_(trace, 2, " rc%d", -ETIMEDOUT);
2098 ctc_pr_warn("unknown error %ld on device %s\n", PTR_ERR(irb),
2100 // CTC_DBF_TEXT(trace, 2, "ckirberr");
2101 // CTC_DBF_TEXT(trace, 2, " rc???");
2103 return PTR_ERR(irb);
2109 * @param cdev The ccw_device the interrupt is for.
2110 * @param intparm interruption parameter.
2111 * @param irb interruption response block.
2114 ctc_irq_handler(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
2117 struct net_device *dev;
2118 struct ctc_priv *priv;
2120 DBF_TEXT(trace, 2, __FUNCTION__);
2121 if (__ctc_check_irb_error(cdev, irb))
2124 /* Check for unsolicited interrupts. */
2125 if (!cdev->dev.driver_data) {
2126 ctc_pr_warn("ctc: Got unsolicited irq: %s c-%02x d-%02x\n",
2127 cdev->dev.bus_id, irb->scsw.cstat,
2132 priv = ((struct ccwgroup_device *)cdev->dev.driver_data)
2135 /* Try to extract channel from driver data. */
2136 if (priv->channel[READ]->cdev == cdev)
2137 ch = priv->channel[READ];
2138 else if (priv->channel[WRITE]->cdev == cdev)
2139 ch = priv->channel[WRITE];
2141 ctc_pr_err("ctc: Can't determine channel for interrupt, "
2142 "device %s\n", cdev->dev.bus_id);
2146 dev = (struct net_device *) (ch->netdev);
2148 ctc_pr_crit("ctc: ctc_irq_handler dev=NULL bus_id=%s, ch=0x%p\n",
2149 cdev->dev.bus_id, ch);
2154 ctc_pr_debug("%s: interrupt for device: %s received c-%02x d-%02x\n",
2155 dev->name, ch->id, irb->scsw.cstat, irb->scsw.dstat);
2158 /* Copy interruption response block. */
2159 memcpy(ch->irb, irb, sizeof(struct irb));
2161 /* Check for good subchannel return code, otherwise error message */
2162 if (ch->irb->scsw.cstat) {
2163 fsm_event(ch->fsm, CH_EVENT_SC_UNKNOWN, ch);
2164 ctc_pr_warn("%s: subchannel check for device: %s - %02x %02x\n",
2165 dev->name, ch->id, ch->irb->scsw.cstat,
2166 ch->irb->scsw.dstat);
2170 /* Check the reason-code of a unit check */
2171 if (ch->irb->scsw.dstat & DEV_STAT_UNIT_CHECK) {
2172 ccw_unit_check(ch, ch->irb->ecw[0]);
2175 if (ch->irb->scsw.dstat & DEV_STAT_BUSY) {
2176 if (ch->irb->scsw.dstat & DEV_STAT_ATTENTION)
2177 fsm_event(ch->fsm, CH_EVENT_ATTNBUSY, ch);
2179 fsm_event(ch->fsm, CH_EVENT_BUSY, ch);
2182 if (ch->irb->scsw.dstat & DEV_STAT_ATTENTION) {
2183 fsm_event(ch->fsm, CH_EVENT_ATTN, ch);
2186 if ((ch->irb->scsw.stctl & SCSW_STCTL_SEC_STATUS) ||
2187 (ch->irb->scsw.stctl == SCSW_STCTL_STATUS_PEND) ||
2188 (ch->irb->scsw.stctl ==
2189 (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND)))
2190 fsm_event(ch->fsm, CH_EVENT_FINSTAT, ch);
2192 fsm_event(ch->fsm, CH_EVENT_IRQ, ch);
2197 * Actions for interface - statemachine.
2198 *****************************************************************************/
2201 * Startup channels by sending CH_EVENT_START to each channel.
2203 * @param fi An instance of an interface statemachine.
2204 * @param event The event, just happened.
2205 * @param arg Generic pointer, casted from struct net_device * upon call.
2208 dev_action_start(fsm_instance * fi, int event, void *arg)
2210 struct net_device *dev = (struct net_device *) arg;
2211 struct ctc_priv *privptr = dev->priv;
2214 DBF_TEXT(setup, 2, __FUNCTION__);
2215 fsm_deltimer(&privptr->restart_timer);
2216 fsm_newstate(fi, DEV_STATE_STARTWAIT_RXTX);
2217 for (direction = READ; direction <= WRITE; direction++) {
2218 struct channel *ch = privptr->channel[direction];
2219 fsm_event(ch->fsm, CH_EVENT_START, ch);
2224 * Shutdown channels by sending CH_EVENT_STOP to each channel.
2226 * @param fi An instance of an interface statemachine.
2227 * @param event The event, just happened.
2228 * @param arg Generic pointer, casted from struct net_device * upon call.
2231 dev_action_stop(fsm_instance * fi, int event, void *arg)
2233 struct net_device *dev = (struct net_device *) arg;
2234 struct ctc_priv *privptr = dev->priv;
2237 DBF_TEXT(trace, 2, __FUNCTION__);
2238 fsm_newstate(fi, DEV_STATE_STOPWAIT_RXTX);
2239 for (direction = READ; direction <= WRITE; direction++) {
2240 struct channel *ch = privptr->channel[direction];
2241 fsm_event(ch->fsm, CH_EVENT_STOP, ch);
2245 dev_action_restart(fsm_instance *fi, int event, void *arg)
2247 struct net_device *dev = (struct net_device *)arg;
2248 struct ctc_priv *privptr = dev->priv;
2250 DBF_TEXT(trace, 2, __FUNCTION__);
2251 ctc_pr_debug("%s: Restarting\n", dev->name);
2252 dev_action_stop(fi, event, arg);
2253 fsm_event(privptr->fsm, DEV_EVENT_STOP, dev);
2254 fsm_addtimer(&privptr->restart_timer, CTC_TIMEOUT_5SEC,
2255 DEV_EVENT_START, dev);
2259 * Called from channel statemachine
2260 * when a channel is up and running.
2262 * @param fi An instance of an interface statemachine.
2263 * @param event The event, just happened.
2264 * @param arg Generic pointer, casted from struct net_device * upon call.
2267 dev_action_chup(fsm_instance * fi, int event, void *arg)
2269 struct net_device *dev = (struct net_device *) arg;
2270 struct ctc_priv *privptr = dev->priv;
2272 DBF_TEXT(trace, 2, __FUNCTION__);
2273 switch (fsm_getstate(fi)) {
2274 case DEV_STATE_STARTWAIT_RXTX:
2275 if (event == DEV_EVENT_RXUP)
2276 fsm_newstate(fi, DEV_STATE_STARTWAIT_TX);
2278 fsm_newstate(fi, DEV_STATE_STARTWAIT_RX);
2280 case DEV_STATE_STARTWAIT_RX:
2281 if (event == DEV_EVENT_RXUP) {
2282 fsm_newstate(fi, DEV_STATE_RUNNING);
2283 ctc_pr_info("%s: connected with remote side\n",
2285 if (privptr->protocol == CTC_PROTO_LINUX_TTY)
2286 ctc_tty_setcarrier(dev, 1);
2287 ctc_clear_busy(dev);
2290 case DEV_STATE_STARTWAIT_TX:
2291 if (event == DEV_EVENT_TXUP) {
2292 fsm_newstate(fi, DEV_STATE_RUNNING);
2293 ctc_pr_info("%s: connected with remote side\n",
2295 if (privptr->protocol == CTC_PROTO_LINUX_TTY)
2296 ctc_tty_setcarrier(dev, 1);
2297 ctc_clear_busy(dev);
2300 case DEV_STATE_STOPWAIT_TX:
2301 if (event == DEV_EVENT_RXUP)
2302 fsm_newstate(fi, DEV_STATE_STOPWAIT_RXTX);
2304 case DEV_STATE_STOPWAIT_RX:
2305 if (event == DEV_EVENT_TXUP)
2306 fsm_newstate(fi, DEV_STATE_STOPWAIT_RXTX);
2312 * Called from channel statemachine
2313 * when a channel has been shutdown.
2315 * @param fi An instance of an interface statemachine.
2316 * @param event The event, just happened.
2317 * @param arg Generic pointer, casted from struct net_device * upon call.
2320 dev_action_chdown(fsm_instance * fi, int event, void *arg)
2322 struct net_device *dev = (struct net_device *) arg;
2323 struct ctc_priv *privptr = dev->priv;
2325 DBF_TEXT(trace, 2, __FUNCTION__);
2326 switch (fsm_getstate(fi)) {
2327 case DEV_STATE_RUNNING:
2328 if (privptr->protocol == CTC_PROTO_LINUX_TTY)
2329 ctc_tty_setcarrier(dev, 0);
2330 if (event == DEV_EVENT_TXDOWN)
2331 fsm_newstate(fi, DEV_STATE_STARTWAIT_TX);
2333 fsm_newstate(fi, DEV_STATE_STARTWAIT_RX);
2335 case DEV_STATE_STARTWAIT_RX:
2336 if (event == DEV_EVENT_TXDOWN)
2337 fsm_newstate(fi, DEV_STATE_STARTWAIT_RXTX);
2339 case DEV_STATE_STARTWAIT_TX:
2340 if (event == DEV_EVENT_RXDOWN)
2341 fsm_newstate(fi, DEV_STATE_STARTWAIT_RXTX);
2343 case DEV_STATE_STOPWAIT_RXTX:
2344 if (event == DEV_EVENT_TXDOWN)
2345 fsm_newstate(fi, DEV_STATE_STOPWAIT_RX);
2347 fsm_newstate(fi, DEV_STATE_STOPWAIT_TX);
2349 case DEV_STATE_STOPWAIT_RX:
2350 if (event == DEV_EVENT_RXDOWN)
2351 fsm_newstate(fi, DEV_STATE_STOPPED);
2353 case DEV_STATE_STOPWAIT_TX:
2354 if (event == DEV_EVENT_TXDOWN)
2355 fsm_newstate(fi, DEV_STATE_STOPPED);
2360 static const fsm_node dev_fsm[] = {
2361 {DEV_STATE_STOPPED, DEV_EVENT_START, dev_action_start},
2363 {DEV_STATE_STOPWAIT_RXTX, DEV_EVENT_START, dev_action_start },
2364 {DEV_STATE_STOPWAIT_RXTX, DEV_EVENT_RXDOWN, dev_action_chdown },
2365 {DEV_STATE_STOPWAIT_RXTX, DEV_EVENT_TXDOWN, dev_action_chdown },
2366 {DEV_STATE_STOPWAIT_RXTX, DEV_EVENT_RESTART, dev_action_restart },
2368 {DEV_STATE_STOPWAIT_RX, DEV_EVENT_START, dev_action_start },
2369 {DEV_STATE_STOPWAIT_RX, DEV_EVENT_RXUP, dev_action_chup },
2370 {DEV_STATE_STOPWAIT_RX, DEV_EVENT_TXUP, dev_action_chup },
2371 {DEV_STATE_STOPWAIT_RX, DEV_EVENT_RXDOWN, dev_action_chdown },
2372 {DEV_STATE_STOPWAIT_RX, DEV_EVENT_RESTART, dev_action_restart },
2374 {DEV_STATE_STOPWAIT_TX, DEV_EVENT_START, dev_action_start },
2375 {DEV_STATE_STOPWAIT_TX, DEV_EVENT_RXUP, dev_action_chup },
2376 {DEV_STATE_STOPWAIT_TX, DEV_EVENT_TXUP, dev_action_chup },
2377 {DEV_STATE_STOPWAIT_TX, DEV_EVENT_TXDOWN, dev_action_chdown },
2378 {DEV_STATE_STOPWAIT_TX, DEV_EVENT_RESTART, dev_action_restart },
2380 {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_STOP, dev_action_stop },
2381 {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_RXUP, dev_action_chup },
2382 {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_TXUP, dev_action_chup },
2383 {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_RXDOWN, dev_action_chdown },
2384 {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_TXDOWN, dev_action_chdown },
2385 {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_RESTART, dev_action_restart },
2387 {DEV_STATE_STARTWAIT_TX, DEV_EVENT_STOP, dev_action_stop },
2388 {DEV_STATE_STARTWAIT_TX, DEV_EVENT_RXUP, dev_action_chup },
2389 {DEV_STATE_STARTWAIT_TX, DEV_EVENT_TXUP, dev_action_chup },
2390 {DEV_STATE_STARTWAIT_TX, DEV_EVENT_RXDOWN, dev_action_chdown },
2391 {DEV_STATE_STARTWAIT_TX, DEV_EVENT_RESTART, dev_action_restart },
2393 {DEV_STATE_STARTWAIT_RX, DEV_EVENT_STOP, dev_action_stop },
2394 {DEV_STATE_STARTWAIT_RX, DEV_EVENT_RXUP, dev_action_chup },
2395 {DEV_STATE_STARTWAIT_RX, DEV_EVENT_TXUP, dev_action_chup },
2396 {DEV_STATE_STARTWAIT_RX, DEV_EVENT_TXDOWN, dev_action_chdown },
2397 {DEV_STATE_STARTWAIT_RX, DEV_EVENT_RESTART, dev_action_restart },
2399 {DEV_STATE_RUNNING, DEV_EVENT_STOP, dev_action_stop },
2400 {DEV_STATE_RUNNING, DEV_EVENT_RXDOWN, dev_action_chdown },
2401 {DEV_STATE_RUNNING, DEV_EVENT_TXDOWN, dev_action_chdown },
2402 {DEV_STATE_RUNNING, DEV_EVENT_TXUP, fsm_action_nop },
2403 {DEV_STATE_RUNNING, DEV_EVENT_RXUP, fsm_action_nop },
2404 {DEV_STATE_RUNNING, DEV_EVENT_RESTART, dev_action_restart },
2407 static const int DEV_FSM_LEN = sizeof (dev_fsm) / sizeof (fsm_node);
2410 * Transmit a packet.
2411 * This is a helper function for ctc_tx().
2413 * @param ch Channel to be used for sending.
2414 * @param skb Pointer to struct sk_buff of packet to send.
2415 * The linklevel header has already been set up
2418 * @return 0 on success, -ERRNO on failure. (Never fails.)
2421 transmit_skb(struct channel *ch, struct sk_buff *skb)
2423 unsigned long saveflags;
2424 struct ll_header header;
2427 DBF_TEXT(trace, 2, __FUNCTION__);
2428 if (fsm_getstate(ch->fsm) != CH_STATE_TXIDLE) {
2429 int l = skb->len + LL_HEADER_LENGTH;
2431 spin_lock_irqsave(&ch->collect_lock, saveflags);
2432 if (ch->collect_len + l > ch->max_bufsize - 2)
2435 atomic_inc(&skb->users);
2437 header.type = skb->protocol;
2439 memcpy(skb_push(skb, LL_HEADER_LENGTH), &header,
2441 skb_queue_tail(&ch->collect_queue, skb);
2442 ch->collect_len += l;
2444 spin_unlock_irqrestore(&ch->collect_lock, saveflags);
2448 struct sk_buff *nskb;
2452 * Protect skb against beeing free'd by upper
2455 atomic_inc(&skb->users);
2456 ch->prof.txlen += skb->len;
2457 header.length = skb->len + LL_HEADER_LENGTH;
2458 header.type = skb->protocol;
2460 memcpy(skb_push(skb, LL_HEADER_LENGTH), &header,
2462 block_len = skb->len + 2;
2463 *((__u16 *) skb_push(skb, 2)) = block_len;
2466 * IDAL support in CTC is broken, so we have to
2467 * care about skb's above 2G ourselves.
2469 hi = ((unsigned long) skb->tail + LL_HEADER_LENGTH) >> 31;
2471 nskb = alloc_skb(skb->len, GFP_ATOMIC | GFP_DMA);
2473 atomic_dec(&skb->users);
2474 skb_pull(skb, LL_HEADER_LENGTH + 2);
2477 memcpy(skb_put(nskb, skb->len),
2478 skb->data, skb->len);
2479 atomic_inc(&nskb->users);
2480 atomic_dec(&skb->users);
2481 dev_kfree_skb_irq(skb);
2486 ch->ccw[4].count = block_len;
2487 if (set_normalized_cda(&ch->ccw[4], skb->data)) {
2489 * idal allocation failed, try via copying to
2490 * trans_skb. trans_skb usually has a pre-allocated
2493 if (ctc_checkalloc_buffer(ch, 1)) {
2495 * Remove our header. It gets added
2496 * again on retransmit.
2498 atomic_dec(&skb->users);
2499 skb_pull(skb, LL_HEADER_LENGTH + 2);
2503 ch->trans_skb->tail = ch->trans_skb->data;
2504 ch->trans_skb->len = 0;
2505 ch->ccw[1].count = skb->len;
2506 memcpy(skb_put(ch->trans_skb, skb->len), skb->data,
2508 atomic_dec(&skb->users);
2509 dev_kfree_skb_irq(skb);
2512 skb_queue_tail(&ch->io_queue, skb);
2516 fsm_newstate(ch->fsm, CH_STATE_TX);
2517 fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC, CH_EVENT_TIMER, ch);
2518 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
2519 ch->prof.send_stamp = xtime;
2520 rc = ccw_device_start(ch->cdev, &ch->ccw[ccw_idx],
2521 (unsigned long) ch, 0xff, 0);
2522 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
2524 ch->prof.doios_single++;
2526 fsm_deltimer(&ch->timer);
2527 ccw_check_return_code(ch, rc, "single skb TX");
2529 skb_dequeue_tail(&ch->io_queue);
2531 * Remove our header. It gets added
2532 * again on retransmit.
2534 skb_pull(skb, LL_HEADER_LENGTH + 2);
2537 struct net_device *dev = ch->netdev;
2538 struct ctc_priv *privptr = dev->priv;
2539 privptr->stats.tx_packets++;
2540 privptr->stats.tx_bytes +=
2541 skb->len - LL_HEADER_LENGTH;
2550 * Interface API for upper network layers
2551 *****************************************************************************/
2554 * Open an interface.
2555 * Called from generic network layer when ifconfig up is run.
2557 * @param dev Pointer to interface struct.
2559 * @return 0 on success, -ERRNO on failure. (Never fails.)
2562 ctc_open(struct net_device * dev)
2564 fsm_event(((struct ctc_priv *) dev->priv)->fsm, DEV_EVENT_START, dev);
2569 * Close an interface.
2570 * Called from generic network layer when ifconfig down is run.
2572 * @param dev Pointer to interface struct.
2574 * @return 0 on success, -ERRNO on failure. (Never fails.)
2577 ctc_close(struct net_device * dev)
2579 fsm_event(((struct ctc_priv *) dev->priv)->fsm, DEV_EVENT_STOP, dev);
2584 * Start transmission of a packet.
2585 * Called from generic network device layer.
2587 * @param skb Pointer to buffer containing the packet.
2588 * @param dev Pointer to interface struct.
2590 * @return 0 if packet consumed, !0 if packet rejected.
2591 * Note: If we return !0, then the packet is free'd by
2592 * the generic network layer.
2595 ctc_tx(struct sk_buff *skb, struct net_device * dev)
2598 struct ctc_priv *privptr = (struct ctc_priv *) dev->priv;
2600 DBF_TEXT(trace, 2, __FUNCTION__);
2602 * Some sanity checks ...
2605 ctc_pr_warn("%s: NULL sk_buff passed\n", dev->name);
2606 privptr->stats.tx_dropped++;
2609 if (skb_headroom(skb) < (LL_HEADER_LENGTH + 2)) {
2610 ctc_pr_warn("%s: Got sk_buff with head room < %ld bytes\n",
2611 dev->name, LL_HEADER_LENGTH + 2);
2613 privptr->stats.tx_dropped++;
2618 * If channels are not running, try to restart them
2619 * and throw away packet.
2621 if (fsm_getstate(privptr->fsm) != DEV_STATE_RUNNING) {
2622 fsm_event(privptr->fsm, DEV_EVENT_START, dev);
2623 if (privptr->protocol == CTC_PROTO_LINUX_TTY)
2626 privptr->stats.tx_dropped++;
2627 privptr->stats.tx_errors++;
2628 privptr->stats.tx_carrier_errors++;
2632 if (ctc_test_and_set_busy(dev))
2635 dev->trans_start = jiffies;
2636 if (transmit_skb(privptr->channel[WRITE], skb) != 0)
2638 ctc_clear_busy(dev);
2643 * Sets MTU of an interface.
2645 * @param dev Pointer to interface struct.
2646 * @param new_mtu The new MTU to use for this interface.
2648 * @return 0 on success, -EINVAL if MTU is out of valid range.
2649 * (valid range is 576 .. 65527). If VM is on the
2650 * remote side, maximum MTU is 32760, however this is
2651 * <em>not</em> checked here.
2654 ctc_change_mtu(struct net_device * dev, int new_mtu)
2656 struct ctc_priv *privptr = (struct ctc_priv *) dev->priv;
2658 DBF_TEXT(trace, 2, __FUNCTION__);
2659 if ((new_mtu < 576) || (new_mtu > 65527) ||
2660 (new_mtu > (privptr->channel[READ]->max_bufsize -
2661 LL_HEADER_LENGTH - 2)))
2664 dev->hard_header_len = LL_HEADER_LENGTH + 2;
2669 * Returns interface statistics of a device.
2671 * @param dev Pointer to interface struct.
2673 * @return Pointer to stats struct of this interface.
2675 static struct net_device_stats *
2676 ctc_stats(struct net_device * dev)
2678 return &((struct ctc_priv *) dev->priv)->stats;
2685 buffer_show(struct device *dev, char *buf)
2687 struct ctc_priv *priv;
2689 priv = dev->driver_data;
2692 return sprintf(buf, "%d\n",
2693 priv->channel[READ]->max_bufsize);
2697 buffer_write(struct device *dev, const char *buf, size_t count)
2699 struct ctc_priv *priv;
2700 struct net_device *ndev;
2703 DBF_TEXT(trace, 2, __FUNCTION__);
2704 priv = dev->driver_data;
2707 ndev = priv->channel[READ]->netdev;
2710 sscanf(buf, "%u", &bs1);
2712 if (bs1 > CTC_BUFSIZE_LIMIT)
2714 if ((ndev->flags & IFF_RUNNING) &&
2715 (bs1 < (ndev->mtu + LL_HEADER_LENGTH + 2)))
2717 if (bs1 < (576 + LL_HEADER_LENGTH + 2))
2720 priv->channel[READ]->max_bufsize =
2721 priv->channel[WRITE]->max_bufsize = bs1;
2722 if (!(ndev->flags & IFF_RUNNING))
2723 ndev->mtu = bs1 - LL_HEADER_LENGTH - 2;
2724 priv->channel[READ]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
2725 priv->channel[WRITE]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
2732 loglevel_show(struct device *dev, char *buf)
2734 struct ctc_priv *priv;
2736 priv = dev->driver_data;
2739 return sprintf(buf, "%d\n", loglevel);
2743 loglevel_write(struct device *dev, const char *buf, size_t count)
2745 struct ctc_priv *priv;
2748 DBF_TEXT(trace, 2, __FUNCTION__);
2749 priv = dev->driver_data;
2752 sscanf(buf, "%i", &ll1);
2754 if ((ll1 > CTC_LOGLEVEL_MAX) || (ll1 < 0))
2761 ctc_print_statistics(struct ctc_priv *priv)
2766 DBF_TEXT(trace, 2, __FUNCTION__);
2769 sbuf = (char *)kmalloc(2048, GFP_KERNEL);
2774 p += sprintf(p, " Device FSM state: %s\n",
2775 fsm_getstate_str(priv->fsm));
2776 p += sprintf(p, " RX channel FSM state: %s\n",
2777 fsm_getstate_str(priv->channel[READ]->fsm));
2778 p += sprintf(p, " TX channel FSM state: %s\n",
2779 fsm_getstate_str(priv->channel[WRITE]->fsm));
2780 p += sprintf(p, " Max. TX buffer used: %ld\n",
2781 priv->channel[WRITE]->prof.maxmulti);
2782 p += sprintf(p, " Max. chained SKBs: %ld\n",
2783 priv->channel[WRITE]->prof.maxcqueue);
2784 p += sprintf(p, " TX single write ops: %ld\n",
2785 priv->channel[WRITE]->prof.doios_single);
2786 p += sprintf(p, " TX multi write ops: %ld\n",
2787 priv->channel[WRITE]->prof.doios_multi);
2788 p += sprintf(p, " Netto bytes written: %ld\n",
2789 priv->channel[WRITE]->prof.txlen);
2790 p += sprintf(p, " Max. TX IO-time: %ld\n",
2791 priv->channel[WRITE]->prof.tx_time);
2793 ctc_pr_debug("Statistics for %s:\n%s",
2794 priv->channel[WRITE]->netdev->name, sbuf);
2800 stats_show(struct device *dev, char *buf)
2802 struct ctc_priv *priv = dev->driver_data;
2805 ctc_print_statistics(priv);
2806 return sprintf(buf, "0\n");
2810 stats_write(struct device *dev, const char *buf, size_t count)
2812 struct ctc_priv *priv = dev->driver_data;
2815 /* Reset statistics */
2816 memset(&priv->channel[WRITE]->prof, 0,
2817 sizeof(priv->channel[WRITE]->prof));
2821 static DEVICE_ATTR(buffer, 0644, buffer_show, buffer_write);
2822 static DEVICE_ATTR(loglevel, 0644, loglevel_show, loglevel_write);
2823 static DEVICE_ATTR(stats, 0644, stats_show, stats_write);
2826 ctc_add_attributes(struct device *dev)
2828 device_create_file(dev, &dev_attr_buffer);
2829 device_create_file(dev, &dev_attr_loglevel);
2830 device_create_file(dev, &dev_attr_stats);
2835 ctc_remove_attributes(struct device *dev)
2837 device_remove_file(dev, &dev_attr_stats);
2838 device_remove_file(dev, &dev_attr_loglevel);
2839 device_remove_file(dev, &dev_attr_buffer);
2844 ctc_netdev_unregister(struct net_device * dev)
2846 struct ctc_priv *privptr;
2850 privptr = (struct ctc_priv *) dev->priv;
2851 if (privptr->protocol != CTC_PROTO_LINUX_TTY)
2852 unregister_netdev(dev);
2854 ctc_tty_unregister_netdev(dev);
2858 ctc_netdev_register(struct net_device * dev)
2860 struct ctc_priv *privptr = (struct ctc_priv *) dev->priv;
2861 if (privptr->protocol != CTC_PROTO_LINUX_TTY)
2862 return register_netdev(dev);
2864 return ctc_tty_register_netdev(dev);
2868 ctc_free_netdevice(struct net_device * dev, int free_dev)
2870 struct ctc_priv *privptr;
2873 privptr = dev->priv;
2876 kfree_fsm(privptr->fsm);
2886 * Initialize everything of the net device except the name and the
2889 static struct net_device *
2890 ctc_init_netdevice(struct net_device * dev, int alloc_device,
2891 struct ctc_priv *privptr)
2896 DBF_TEXT(setup, 2, __FUNCTION__);
2898 dev = kmalloc(sizeof (struct net_device), GFP_KERNEL);
2901 memset(dev, 0, sizeof (struct net_device));
2904 dev->priv = privptr;
2905 privptr->fsm = init_fsm("ctcdev", dev_state_names,
2906 dev_event_names, NR_DEV_STATES, NR_DEV_EVENTS,
2907 dev_fsm, DEV_FSM_LEN, GFP_KERNEL);
2908 if (privptr->fsm == NULL) {
2913 fsm_newstate(privptr->fsm, DEV_STATE_STOPPED);
2914 fsm_settimer(privptr->fsm, &privptr->restart_timer);
2915 dev->mtu = CTC_BUFSIZE_DEFAULT - LL_HEADER_LENGTH - 2;
2916 dev->hard_start_xmit = ctc_tx;
2917 dev->open = ctc_open;
2918 dev->stop = ctc_close;
2919 dev->get_stats = ctc_stats;
2920 dev->change_mtu = ctc_change_mtu;
2921 dev->hard_header_len = LL_HEADER_LENGTH + 2;
2923 dev->type = ARPHRD_SLIP;
2924 dev->tx_queue_len = 100;
2925 dev->flags = IFF_POINTOPOINT | IFF_NOARP;
2926 SET_MODULE_OWNER(dev);
2931 ctc_proto_show(struct device *dev, char *buf)
2933 struct ctc_priv *priv;
2935 priv = dev->driver_data;
2939 return sprintf(buf, "%d\n", priv->protocol);
2943 ctc_proto_store(struct device *dev, const char *buf, size_t count)
2945 struct ctc_priv *priv;
2948 DBF_TEXT(trace, 2, __FUNCTION__);
2949 pr_debug("%s() called\n", __FUNCTION__);
2951 priv = dev->driver_data;
2954 sscanf(buf, "%u", &value);
2955 if ((value < 0) || (value > CTC_PROTO_MAX))
2957 priv->protocol = value;
2962 static DEVICE_ATTR(protocol, 0644, ctc_proto_show, ctc_proto_store);
2965 ctc_type_show(struct device *dev, char *buf)
2967 struct ccwgroup_device *cgdev;
2969 cgdev = to_ccwgroupdev(dev);
2973 return sprintf(buf, "%s\n", cu3088_type[cgdev->cdev[0]->id.driver_info]);
2976 static DEVICE_ATTR(type, 0444, ctc_type_show, NULL);
2978 static struct attribute *ctc_attr[] = {
2979 &dev_attr_protocol.attr,
2980 &dev_attr_type.attr,
2984 static struct attribute_group ctc_attr_group = {
2989 ctc_add_files(struct device *dev)
2991 pr_debug("%s() called\n", __FUNCTION__);
2993 return sysfs_create_group(&dev->kobj, &ctc_attr_group);
2997 ctc_remove_files(struct device *dev)
2999 pr_debug("%s() called\n", __FUNCTION__);
3001 sysfs_remove_group(&dev->kobj, &ctc_attr_group);
3005 * Add ctc specific attributes.
3006 * Add ctc private data.
3008 * @param cgdev pointer to ccwgroup_device just added
3010 * @returns 0 on success, !0 on failure.
3014 ctc_probe_device(struct ccwgroup_device *cgdev)
3016 struct ctc_priv *priv;
3019 pr_debug("%s() called\n", __FUNCTION__);
3020 DBF_TEXT(trace, 2, __FUNCTION__);
3022 if (!get_device(&cgdev->dev))
3025 priv = kmalloc(sizeof (struct ctc_priv), GFP_KERNEL);
3027 ctc_pr_err("%s: Out of memory\n", __func__);
3028 put_device(&cgdev->dev);
3032 memset(priv, 0, sizeof (struct ctc_priv));
3033 rc = ctc_add_files(&cgdev->dev);
3036 put_device(&cgdev->dev);
3040 cgdev->cdev[0]->handler = ctc_irq_handler;
3041 cgdev->cdev[1]->handler = ctc_irq_handler;
3042 cgdev->dev.driver_data = priv;
3049 * Setup an interface.
3051 * @param cgdev Device to be setup.
3053 * @returns 0 on success, !0 on failure.
3056 ctc_new_device(struct ccwgroup_device *cgdev)
3058 char read_id[CTC_ID_SIZE];
3059 char write_id[CTC_ID_SIZE];
3061 enum channel_types type;
3062 struct ctc_priv *privptr;
3063 struct net_device *dev;
3066 pr_debug("%s() called\n", __FUNCTION__);
3067 DBF_TEXT(setup, 2, __FUNCTION__);
3069 privptr = cgdev->dev.driver_data;
3073 type = get_channel_type(&cgdev->cdev[0]->id);
3075 snprintf(read_id, CTC_ID_SIZE, "ch-%s", cgdev->cdev[0]->dev.bus_id);
3076 snprintf(write_id, CTC_ID_SIZE, "ch-%s", cgdev->cdev[1]->dev.bus_id);
3078 if (add_channel(cgdev->cdev[0], type))
3080 if (add_channel(cgdev->cdev[1], type))
3083 ret = ccw_device_set_online(cgdev->cdev[0]);
3086 "ccw_device_set_online (cdev[0]) failed with ret = %d\n", ret);
3089 ret = ccw_device_set_online(cgdev->cdev[1]);
3092 "ccw_device_set_online (cdev[1]) failed with ret = %d\n", ret);
3095 dev = ctc_init_netdevice(NULL, 1, privptr);
3098 ctc_pr_warn("ctc_init_netdevice failed\n");
3102 if (privptr->protocol == CTC_PROTO_LINUX_TTY)
3103 strlcpy(dev->name, "ctctty%d", IFNAMSIZ);
3105 strlcpy(dev->name, "ctc%d", IFNAMSIZ);
3107 for (direction = READ; direction <= WRITE; direction++) {
3108 privptr->channel[direction] =
3109 channel_get(type, direction == READ ? read_id : write_id,
3111 if (privptr->channel[direction] == NULL) {
3112 if (direction == WRITE)
3113 channel_free(privptr->channel[READ]);
3115 ctc_free_netdevice(dev, 1);
3118 privptr->channel[direction]->netdev = dev;
3119 privptr->channel[direction]->protocol = privptr->protocol;
3120 privptr->channel[direction]->max_bufsize = CTC_BUFSIZE_DEFAULT;
3123 SET_NETDEV_DEV(dev, &cgdev->dev);
3125 if (ctc_netdev_register(dev) != 0) {
3126 ctc_free_netdevice(dev, 1);
3130 ctc_add_attributes(&cgdev->dev);
3132 strlcpy(privptr->fsm->name, dev->name, sizeof (privptr->fsm->name));
3136 ctc_pr_info("%s: read: %s, write: %s, proto: %d\n",
3137 dev->name, privptr->channel[READ]->id,
3138 privptr->channel[WRITE]->id, privptr->protocol);
3142 ccw_device_set_offline(cgdev->cdev[1]);
3143 ccw_device_set_offline(cgdev->cdev[0]);
3149 * Shutdown an interface.
3151 * @param cgdev Device to be shut down.
3153 * @returns 0 on success, !0 on failure.
3156 ctc_shutdown_device(struct ccwgroup_device *cgdev)
3158 struct ctc_priv *priv;
3159 struct net_device *ndev;
3161 DBF_TEXT(trace, 2, __FUNCTION__);
3162 pr_debug("%s() called\n", __FUNCTION__);
3164 priv = cgdev->dev.driver_data;
3169 if (priv->channel[READ]) {
3170 ndev = priv->channel[READ]->netdev;
3172 /* Close the device */
3174 ndev->flags &=~IFF_RUNNING;
3176 ctc_remove_attributes(&cgdev->dev);
3178 channel_free(priv->channel[READ]);
3180 if (priv->channel[WRITE])
3181 channel_free(priv->channel[WRITE]);
3184 ctc_netdev_unregister(ndev);
3186 ctc_free_netdevice(ndev, 1);
3190 kfree_fsm(priv->fsm);
3192 ccw_device_set_offline(cgdev->cdev[1]);
3193 ccw_device_set_offline(cgdev->cdev[0]);
3195 if (priv->channel[READ])
3196 channel_remove(priv->channel[READ]);
3197 if (priv->channel[WRITE])
3198 channel_remove(priv->channel[WRITE]);
3200 priv->channel[READ] = priv->channel[WRITE] = NULL;
3207 ctc_remove_device(struct ccwgroup_device *cgdev)
3209 struct ctc_priv *priv;
3211 pr_debug("%s() called\n", __FUNCTION__);
3212 DBF_TEXT(trace, 2, __FUNCTION__);
3214 priv = cgdev->dev.driver_data;
3217 if (cgdev->state == CCWGROUP_ONLINE)
3218 ctc_shutdown_device(cgdev);
3219 ctc_remove_files(&cgdev->dev);
3220 cgdev->dev.driver_data = NULL;
3222 put_device(&cgdev->dev);
3225 static struct ccwgroup_driver ctc_group_driver = {
3226 .owner = THIS_MODULE,
3229 .driver_id = 0xC3E3C3,
3230 .probe = ctc_probe_device,
3231 .remove = ctc_remove_device,
3232 .set_online = ctc_new_device,
3233 .set_offline = ctc_shutdown_device,
3237 * Module related routines
3238 *****************************************************************************/
3241 * Prepare to be unloaded. Free IRQ's and release all resources.
3242 * This is called just before this module is unloaded. It is
3243 * <em>not</em> called, if the usage count is !0, so we don't need to check
3249 unregister_cu3088_discipline(&ctc_group_driver);
3251 unregister_dbf_views();
3252 ctc_pr_info("CTC driver unloaded\n");
3256 * Initialize module.
3257 * This is called just after the module is loaded.
3259 * @return 0 on success, !0 on error.
3268 ret = register_dbf_views();
3270 ctc_pr_crit("ctc_init failed with register_dbf_views rc = %d\n", ret);
3274 ret = register_cu3088_discipline(&ctc_group_driver);
3277 unregister_dbf_views();
3282 module_init(ctc_init);
3283 module_exit(ctc_exit);
3285 /* --- This is the END my friend --- */