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