]> 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 branch 'master' into upstream
[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
1718 spin_lock_init(&ch->collect_lock);
1719
1720 fsm_settimer(ch->fsm, &ch->timer);
1721 skb_queue_head_init(&ch->io_queue);
1722 skb_queue_head_init(&ch->collect_queue);
1723 ch->next = *c;
1724 *c = ch;
1725 return 0;
1726 }
1727
1728 /**
1729 * Release a specific channel in the channel list.
1730 *
1731 * @param ch Pointer to channel struct to be released.
1732 */
1733 static void
1734 channel_free(struct channel *ch)
1735 {
1736 ch->flags &= ~CHANNEL_FLAGS_INUSE;
1737 fsm_newstate(ch->fsm, CH_STATE_IDLE);
1738 }
1739
1740 /**
1741 * Remove a specific channel in the channel list.
1742 *
1743 * @param ch Pointer to channel struct to be released.
1744 */
1745 static void
1746 channel_remove(struct channel *ch)
1747 {
1748 struct channel **c = &channels;
1749
1750 DBF_TEXT(trace, 2, __FUNCTION__);
1751 if (ch == NULL)
1752 return;
1753
1754 channel_free(ch);
1755 while (*c) {
1756 if (*c == ch) {
1757 *c = ch->next;
1758 fsm_deltimer(&ch->timer);
1759 kfree_fsm(ch->fsm);
1760 clear_normalized_cda(&ch->ccw[4]);
1761 if (ch->trans_skb != NULL) {
1762 clear_normalized_cda(&ch->ccw[1]);
1763 dev_kfree_skb(ch->trans_skb);
1764 }
1765 kfree(ch->ccw);
1766 kfree(ch->irb);
1767 kfree(ch);
1768 return;
1769 }
1770 c = &((*c)->next);
1771 }
1772 }
1773
1774 /**
1775 * Get a specific channel from the channel list.
1776 *
1777 * @param type Type of channel we are interested in.
1778 * @param id Id of channel we are interested in.
1779 * @param direction Direction we want to use this channel for.
1780 *
1781 * @return Pointer to a channel or NULL if no matching channel available.
1782 */
1783 static struct channel
1784 *
1785 channel_get(enum channel_types type, char *id, int direction)
1786 {
1787 struct channel *ch = channels;
1788
1789 DBF_TEXT(trace, 3, __FUNCTION__);
1790 #ifdef DEBUG
1791 ctc_pr_debug("ctc: %s(): searching for ch with id %s and type %d\n",
1792 __func__, id, type);
1793 #endif
1794
1795 while (ch && ((strncmp(ch->id, id, CTC_ID_SIZE)) || (ch->type != type))) {
1796 #ifdef DEBUG
1797 ctc_pr_debug("ctc: %s(): ch=0x%p (id=%s, type=%d\n",
1798 __func__, ch, ch->id, ch->type);
1799 #endif
1800 ch = ch->next;
1801 }
1802 #ifdef DEBUG
1803 ctc_pr_debug("ctc: %s(): ch=0x%pq (id=%s, type=%d\n",
1804 __func__, ch, ch->id, ch->type);
1805 #endif
1806 if (!ch) {
1807 ctc_pr_warn("ctc: %s(): channel with id %s "
1808 "and type %d not found in channel list\n",
1809 __func__, id, type);
1810 } else {
1811 if (ch->flags & CHANNEL_FLAGS_INUSE)
1812 ch = NULL;
1813 else {
1814 ch->flags |= CHANNEL_FLAGS_INUSE;
1815 ch->flags &= ~CHANNEL_FLAGS_RWMASK;
1816 ch->flags |= (direction == WRITE)
1817 ? CHANNEL_FLAGS_WRITE : CHANNEL_FLAGS_READ;
1818 fsm_newstate(ch->fsm, CH_STATE_STOPPED);
1819 }
1820 }
1821 return ch;
1822 }
1823
1824 /**
1825 * Return the channel type by name.
1826 *
1827 * @param name Name of network interface.
1828 *
1829 * @return Type class of channel to be used for that interface.
1830 */
1831 static enum channel_types inline
1832 extract_channel_media(char *name)
1833 {
1834 enum channel_types ret = channel_type_unknown;
1835
1836 if (name != NULL) {
1837 if (strncmp(name, "ctc", 3) == 0)
1838 ret = channel_type_parallel;
1839 if (strncmp(name, "escon", 5) == 0)
1840 ret = channel_type_escon;
1841 }
1842 return ret;
1843 }
1844
1845 static long
1846 __ctc_check_irb_error(struct ccw_device *cdev, struct irb *irb)
1847 {
1848 if (!IS_ERR(irb))
1849 return 0;
1850
1851 switch (PTR_ERR(irb)) {
1852 case -EIO:
1853 ctc_pr_warn("i/o-error on device %s\n", cdev->dev.bus_id);
1854 // CTC_DBF_TEXT(trace, 2, "ckirberr");
1855 // CTC_DBF_TEXT_(trace, 2, " rc%d", -EIO);
1856 break;
1857 case -ETIMEDOUT:
1858 ctc_pr_warn("timeout on device %s\n", cdev->dev.bus_id);
1859 // CTC_DBF_TEXT(trace, 2, "ckirberr");
1860 // CTC_DBF_TEXT_(trace, 2, " rc%d", -ETIMEDOUT);
1861 break;
1862 default:
1863 ctc_pr_warn("unknown error %ld on device %s\n", PTR_ERR(irb),
1864 cdev->dev.bus_id);
1865 // CTC_DBF_TEXT(trace, 2, "ckirberr");
1866 // CTC_DBF_TEXT(trace, 2, " rc???");
1867 }
1868 return PTR_ERR(irb);
1869 }
1870
1871 /**
1872 * Main IRQ handler.
1873 *
1874 * @param cdev The ccw_device the interrupt is for.
1875 * @param intparm interruption parameter.
1876 * @param irb interruption response block.
1877 */
1878 static void
1879 ctc_irq_handler(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
1880 {
1881 struct channel *ch;
1882 struct net_device *dev;
1883 struct ctc_priv *priv;
1884
1885 DBF_TEXT(trace, 5, __FUNCTION__);
1886 if (__ctc_check_irb_error(cdev, irb))
1887 return;
1888
1889 /* Check for unsolicited interrupts. */
1890 if (!cdev->dev.driver_data) {
1891 ctc_pr_warn("ctc: Got unsolicited irq: %s c-%02x d-%02x\n",
1892 cdev->dev.bus_id, irb->scsw.cstat,
1893 irb->scsw.dstat);
1894 return;
1895 }
1896
1897 priv = ((struct ccwgroup_device *)cdev->dev.driver_data)
1898 ->dev.driver_data;
1899
1900 /* Try to extract channel from driver data. */
1901 if (priv->channel[READ]->cdev == cdev)
1902 ch = priv->channel[READ];
1903 else if (priv->channel[WRITE]->cdev == cdev)
1904 ch = priv->channel[WRITE];
1905 else {
1906 ctc_pr_err("ctc: Can't determine channel for interrupt, "
1907 "device %s\n", cdev->dev.bus_id);
1908 return;
1909 }
1910
1911 dev = (struct net_device *) (ch->netdev);
1912 if (dev == NULL) {
1913 ctc_pr_crit("ctc: ctc_irq_handler dev=NULL bus_id=%s, ch=0x%p\n",
1914 cdev->dev.bus_id, ch);
1915 return;
1916 }
1917
1918 #ifdef DEBUG
1919 ctc_pr_debug("%s: interrupt for device: %s received c-%02x d-%02x\n",
1920 dev->name, ch->id, irb->scsw.cstat, irb->scsw.dstat);
1921 #endif
1922
1923 /* Copy interruption response block. */
1924 memcpy(ch->irb, irb, sizeof(struct irb));
1925
1926 /* Check for good subchannel return code, otherwise error message */
1927 if (ch->irb->scsw.cstat) {
1928 fsm_event(ch->fsm, CH_EVENT_SC_UNKNOWN, ch);
1929 ctc_pr_warn("%s: subchannel check for device: %s - %02x %02x\n",
1930 dev->name, ch->id, ch->irb->scsw.cstat,
1931 ch->irb->scsw.dstat);
1932 return;
1933 }
1934
1935 /* Check the reason-code of a unit check */
1936 if (ch->irb->scsw.dstat & DEV_STAT_UNIT_CHECK) {
1937 ccw_unit_check(ch, ch->irb->ecw[0]);
1938 return;
1939 }
1940 if (ch->irb->scsw.dstat & DEV_STAT_BUSY) {
1941 if (ch->irb->scsw.dstat & DEV_STAT_ATTENTION)
1942 fsm_event(ch->fsm, CH_EVENT_ATTNBUSY, ch);
1943 else
1944 fsm_event(ch->fsm, CH_EVENT_BUSY, ch);
1945 return;
1946 }
1947 if (ch->irb->scsw.dstat & DEV_STAT_ATTENTION) {
1948 fsm_event(ch->fsm, CH_EVENT_ATTN, ch);
1949 return;
1950 }
1951 if ((ch->irb->scsw.stctl & SCSW_STCTL_SEC_STATUS) ||
1952 (ch->irb->scsw.stctl == SCSW_STCTL_STATUS_PEND) ||
1953 (ch->irb->scsw.stctl ==
1954 (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND)))
1955 fsm_event(ch->fsm, CH_EVENT_FINSTAT, ch);
1956 else
1957 fsm_event(ch->fsm, CH_EVENT_IRQ, ch);
1958
1959 }
1960
1961 /**
1962 * Actions for interface - statemachine.
1963 *****************************************************************************/
1964
1965 /**
1966 * Startup channels by sending CH_EVENT_START to each channel.
1967 *
1968 * @param fi An instance of an interface statemachine.
1969 * @param event The event, just happened.
1970 * @param arg Generic pointer, casted from struct net_device * upon call.
1971 */
1972 static void
1973 dev_action_start(fsm_instance * fi, int event, void *arg)
1974 {
1975 struct net_device *dev = (struct net_device *) arg;
1976 struct ctc_priv *privptr = dev->priv;
1977 int direction;
1978
1979 DBF_TEXT(setup, 3, __FUNCTION__);
1980 fsm_deltimer(&privptr->restart_timer);
1981 fsm_newstate(fi, DEV_STATE_STARTWAIT_RXTX);
1982 for (direction = READ; direction <= WRITE; direction++) {
1983 struct channel *ch = privptr->channel[direction];
1984 fsm_event(ch->fsm, CH_EVENT_START, ch);
1985 }
1986 }
1987
1988 /**
1989 * Shutdown channels by sending CH_EVENT_STOP to each channel.
1990 *
1991 * @param fi An instance of an interface statemachine.
1992 * @param event The event, just happened.
1993 * @param arg Generic pointer, casted from struct net_device * upon call.
1994 */
1995 static void
1996 dev_action_stop(fsm_instance * fi, int event, void *arg)
1997 {
1998 struct net_device *dev = (struct net_device *) arg;
1999 struct ctc_priv *privptr = dev->priv;
2000 int direction;
2001
2002 DBF_TEXT(trace, 3, __FUNCTION__);
2003 fsm_newstate(fi, DEV_STATE_STOPWAIT_RXTX);
2004 for (direction = READ; direction <= WRITE; direction++) {
2005 struct channel *ch = privptr->channel[direction];
2006 fsm_event(ch->fsm, CH_EVENT_STOP, ch);
2007 }
2008 }
2009 static void
2010 dev_action_restart(fsm_instance *fi, int event, void *arg)
2011 {
2012 struct net_device *dev = (struct net_device *)arg;
2013 struct ctc_priv *privptr = dev->priv;
2014
2015 DBF_TEXT(trace, 3, __FUNCTION__);
2016 ctc_pr_debug("%s: Restarting\n", dev->name);
2017 dev_action_stop(fi, event, arg);
2018 fsm_event(privptr->fsm, DEV_EVENT_STOP, dev);
2019 fsm_addtimer(&privptr->restart_timer, CTC_TIMEOUT_5SEC,
2020 DEV_EVENT_START, dev);
2021 }
2022
2023 /**
2024 * Called from channel statemachine
2025 * when a channel is up and running.
2026 *
2027 * @param fi An instance of an interface statemachine.
2028 * @param event The event, just happened.
2029 * @param arg Generic pointer, casted from struct net_device * upon call.
2030 */
2031 static void
2032 dev_action_chup(fsm_instance * fi, int event, void *arg)
2033 {
2034 struct net_device *dev = (struct net_device *) arg;
2035
2036 DBF_TEXT(trace, 3, __FUNCTION__);
2037 switch (fsm_getstate(fi)) {
2038 case DEV_STATE_STARTWAIT_RXTX:
2039 if (event == DEV_EVENT_RXUP)
2040 fsm_newstate(fi, DEV_STATE_STARTWAIT_TX);
2041 else
2042 fsm_newstate(fi, DEV_STATE_STARTWAIT_RX);
2043 break;
2044 case DEV_STATE_STARTWAIT_RX:
2045 if (event == DEV_EVENT_RXUP) {
2046 fsm_newstate(fi, DEV_STATE_RUNNING);
2047 ctc_pr_info("%s: connected with remote side\n",
2048 dev->name);
2049 ctc_clear_busy(dev);
2050 }
2051 break;
2052 case DEV_STATE_STARTWAIT_TX:
2053 if (event == DEV_EVENT_TXUP) {
2054 fsm_newstate(fi, DEV_STATE_RUNNING);
2055 ctc_pr_info("%s: connected with remote side\n",
2056 dev->name);
2057 ctc_clear_busy(dev);
2058 }
2059 break;
2060 case DEV_STATE_STOPWAIT_TX:
2061 if (event == DEV_EVENT_RXUP)
2062 fsm_newstate(fi, DEV_STATE_STOPWAIT_RXTX);
2063 break;
2064 case DEV_STATE_STOPWAIT_RX:
2065 if (event == DEV_EVENT_TXUP)
2066 fsm_newstate(fi, DEV_STATE_STOPWAIT_RXTX);
2067 break;
2068 }
2069 }
2070
2071 /**
2072 * Called from channel statemachine
2073 * when a channel has been shutdown.
2074 *
2075 * @param fi An instance of an interface statemachine.
2076 * @param event The event, just happened.
2077 * @param arg Generic pointer, casted from struct net_device * upon call.
2078 */
2079 static void
2080 dev_action_chdown(fsm_instance * fi, int event, void *arg)
2081 {
2082
2083 DBF_TEXT(trace, 3, __FUNCTION__);
2084 switch (fsm_getstate(fi)) {
2085 case DEV_STATE_RUNNING:
2086 if (event == DEV_EVENT_TXDOWN)
2087 fsm_newstate(fi, DEV_STATE_STARTWAIT_TX);
2088 else
2089 fsm_newstate(fi, DEV_STATE_STARTWAIT_RX);
2090 break;
2091 case DEV_STATE_STARTWAIT_RX:
2092 if (event == DEV_EVENT_TXDOWN)
2093 fsm_newstate(fi, DEV_STATE_STARTWAIT_RXTX);
2094 break;
2095 case DEV_STATE_STARTWAIT_TX:
2096 if (event == DEV_EVENT_RXDOWN)
2097 fsm_newstate(fi, DEV_STATE_STARTWAIT_RXTX);
2098 break;
2099 case DEV_STATE_STOPWAIT_RXTX:
2100 if (event == DEV_EVENT_TXDOWN)
2101 fsm_newstate(fi, DEV_STATE_STOPWAIT_RX);
2102 else
2103 fsm_newstate(fi, DEV_STATE_STOPWAIT_TX);
2104 break;
2105 case DEV_STATE_STOPWAIT_RX:
2106 if (event == DEV_EVENT_RXDOWN)
2107 fsm_newstate(fi, DEV_STATE_STOPPED);
2108 break;
2109 case DEV_STATE_STOPWAIT_TX:
2110 if (event == DEV_EVENT_TXDOWN)
2111 fsm_newstate(fi, DEV_STATE_STOPPED);
2112 break;
2113 }
2114 }
2115
2116 static const fsm_node dev_fsm[] = {
2117 {DEV_STATE_STOPPED, DEV_EVENT_START, dev_action_start},
2118
2119 {DEV_STATE_STOPWAIT_RXTX, DEV_EVENT_START, dev_action_start },
2120 {DEV_STATE_STOPWAIT_RXTX, DEV_EVENT_RXDOWN, dev_action_chdown },
2121 {DEV_STATE_STOPWAIT_RXTX, DEV_EVENT_TXDOWN, dev_action_chdown },
2122 {DEV_STATE_STOPWAIT_RXTX, DEV_EVENT_RESTART, dev_action_restart },
2123
2124 {DEV_STATE_STOPWAIT_RX, DEV_EVENT_START, dev_action_start },
2125 {DEV_STATE_STOPWAIT_RX, DEV_EVENT_RXUP, dev_action_chup },
2126 {DEV_STATE_STOPWAIT_RX, DEV_EVENT_TXUP, dev_action_chup },
2127 {DEV_STATE_STOPWAIT_RX, DEV_EVENT_RXDOWN, dev_action_chdown },
2128 {DEV_STATE_STOPWAIT_RX, DEV_EVENT_RESTART, dev_action_restart },
2129
2130 {DEV_STATE_STOPWAIT_TX, DEV_EVENT_START, dev_action_start },
2131 {DEV_STATE_STOPWAIT_TX, DEV_EVENT_RXUP, dev_action_chup },
2132 {DEV_STATE_STOPWAIT_TX, DEV_EVENT_TXUP, dev_action_chup },
2133 {DEV_STATE_STOPWAIT_TX, DEV_EVENT_TXDOWN, dev_action_chdown },
2134 {DEV_STATE_STOPWAIT_TX, DEV_EVENT_RESTART, dev_action_restart },
2135
2136 {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_STOP, dev_action_stop },
2137 {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_RXUP, dev_action_chup },
2138 {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_TXUP, dev_action_chup },
2139 {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_RXDOWN, dev_action_chdown },
2140 {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_TXDOWN, dev_action_chdown },
2141 {DEV_STATE_STARTWAIT_RXTX, DEV_EVENT_RESTART, dev_action_restart },
2142
2143 {DEV_STATE_STARTWAIT_TX, DEV_EVENT_STOP, dev_action_stop },
2144 {DEV_STATE_STARTWAIT_TX, DEV_EVENT_RXUP, dev_action_chup },
2145 {DEV_STATE_STARTWAIT_TX, DEV_EVENT_TXUP, dev_action_chup },
2146 {DEV_STATE_STARTWAIT_TX, DEV_EVENT_RXDOWN, dev_action_chdown },
2147 {DEV_STATE_STARTWAIT_TX, DEV_EVENT_RESTART, dev_action_restart },
2148
2149 {DEV_STATE_STARTWAIT_RX, DEV_EVENT_STOP, dev_action_stop },
2150 {DEV_STATE_STARTWAIT_RX, DEV_EVENT_RXUP, dev_action_chup },
2151 {DEV_STATE_STARTWAIT_RX, DEV_EVENT_TXUP, dev_action_chup },
2152 {DEV_STATE_STARTWAIT_RX, DEV_EVENT_TXDOWN, dev_action_chdown },
2153 {DEV_STATE_STARTWAIT_RX, DEV_EVENT_RESTART, dev_action_restart },
2154
2155 {DEV_STATE_RUNNING, DEV_EVENT_STOP, dev_action_stop },
2156 {DEV_STATE_RUNNING, DEV_EVENT_RXDOWN, dev_action_chdown },
2157 {DEV_STATE_RUNNING, DEV_EVENT_TXDOWN, dev_action_chdown },
2158 {DEV_STATE_RUNNING, DEV_EVENT_TXUP, fsm_action_nop },
2159 {DEV_STATE_RUNNING, DEV_EVENT_RXUP, fsm_action_nop },
2160 {DEV_STATE_RUNNING, DEV_EVENT_RESTART, dev_action_restart },
2161 };
2162
2163 static const int DEV_FSM_LEN = sizeof (dev_fsm) / sizeof (fsm_node);
2164
2165 /**
2166 * Transmit a packet.
2167 * This is a helper function for ctc_tx().
2168 *
2169 * @param ch Channel to be used for sending.
2170 * @param skb Pointer to struct sk_buff of packet to send.
2171 * The linklevel header has already been set up
2172 * by ctc_tx().
2173 *
2174 * @return 0 on success, -ERRNO on failure. (Never fails.)
2175 */
2176 static int
2177 transmit_skb(struct channel *ch, struct sk_buff *skb)
2178 {
2179 unsigned long saveflags;
2180 struct ll_header header;
2181 int rc = 0;
2182
2183 DBF_TEXT(trace, 5, __FUNCTION__);
2184 /* we need to acquire the lock for testing the state
2185 * otherwise we can have an IRQ changing the state to
2186 * TXIDLE after the test but before acquiring the lock.
2187 */
2188 spin_lock_irqsave(&ch->collect_lock, saveflags);
2189 if (fsm_getstate(ch->fsm) != CH_STATE_TXIDLE) {
2190 int l = skb->len + LL_HEADER_LENGTH;
2191
2192 if (ch->collect_len + l > ch->max_bufsize - 2) {
2193 spin_unlock_irqrestore(&ch->collect_lock, saveflags);
2194 return -EBUSY;
2195 } else {
2196 atomic_inc(&skb->users);
2197 header.length = l;
2198 header.type = skb->protocol;
2199 header.unused = 0;
2200 memcpy(skb_push(skb, LL_HEADER_LENGTH), &header,
2201 LL_HEADER_LENGTH);
2202 skb_queue_tail(&ch->collect_queue, skb);
2203 ch->collect_len += l;
2204 }
2205 spin_unlock_irqrestore(&ch->collect_lock, saveflags);
2206 } else {
2207 __u16 block_len;
2208 int ccw_idx;
2209 struct sk_buff *nskb;
2210 unsigned long hi;
2211 spin_unlock_irqrestore(&ch->collect_lock, saveflags);
2212 /**
2213 * Protect skb against beeing free'd by upper
2214 * layers.
2215 */
2216 atomic_inc(&skb->users);
2217 ch->prof.txlen += skb->len;
2218 header.length = skb->len + LL_HEADER_LENGTH;
2219 header.type = skb->protocol;
2220 header.unused = 0;
2221 memcpy(skb_push(skb, LL_HEADER_LENGTH), &header,
2222 LL_HEADER_LENGTH);
2223 block_len = skb->len + 2;
2224 *((__u16 *) skb_push(skb, 2)) = block_len;
2225
2226 /**
2227 * IDAL support in CTC is broken, so we have to
2228 * care about skb's above 2G ourselves.
2229 */
2230 hi = ((unsigned long) skb->tail + LL_HEADER_LENGTH) >> 31;
2231 if (hi) {
2232 nskb = alloc_skb(skb->len, GFP_ATOMIC | GFP_DMA);
2233 if (!nskb) {
2234 atomic_dec(&skb->users);
2235 skb_pull(skb, LL_HEADER_LENGTH + 2);
2236 ctc_clear_busy(ch->netdev);
2237 return -ENOMEM;
2238 } else {
2239 memcpy(skb_put(nskb, skb->len),
2240 skb->data, skb->len);
2241 atomic_inc(&nskb->users);
2242 atomic_dec(&skb->users);
2243 dev_kfree_skb_irq(skb);
2244 skb = nskb;
2245 }
2246 }
2247
2248 ch->ccw[4].count = block_len;
2249 if (set_normalized_cda(&ch->ccw[4], skb->data)) {
2250 /**
2251 * idal allocation failed, try via copying to
2252 * trans_skb. trans_skb usually has a pre-allocated
2253 * idal.
2254 */
2255 if (ctc_checkalloc_buffer(ch, 1)) {
2256 /**
2257 * Remove our header. It gets added
2258 * again on retransmit.
2259 */
2260 atomic_dec(&skb->users);
2261 skb_pull(skb, LL_HEADER_LENGTH + 2);
2262 ctc_clear_busy(ch->netdev);
2263 return -EBUSY;
2264 }
2265
2266 ch->trans_skb->tail = ch->trans_skb->data;
2267 ch->trans_skb->len = 0;
2268 ch->ccw[1].count = skb->len;
2269 memcpy(skb_put(ch->trans_skb, skb->len), skb->data,
2270 skb->len);
2271 atomic_dec(&skb->users);
2272 dev_kfree_skb_irq(skb);
2273 ccw_idx = 0;
2274 } else {
2275 skb_queue_tail(&ch->io_queue, skb);
2276 ccw_idx = 3;
2277 }
2278 ch->retry = 0;
2279 fsm_newstate(ch->fsm, CH_STATE_TX);
2280 fsm_addtimer(&ch->timer, CTC_TIMEOUT_5SEC, CH_EVENT_TIMER, ch);
2281 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
2282 ch->prof.send_stamp = xtime;
2283 rc = ccw_device_start(ch->cdev, &ch->ccw[ccw_idx],
2284 (unsigned long) ch, 0xff, 0);
2285 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
2286 if (ccw_idx == 3)
2287 ch->prof.doios_single++;
2288 if (rc != 0) {
2289 fsm_deltimer(&ch->timer);
2290 ccw_check_return_code(ch, rc, "single skb TX");
2291 if (ccw_idx == 3)
2292 skb_dequeue_tail(&ch->io_queue);
2293 /**
2294 * Remove our header. It gets added
2295 * again on retransmit.
2296 */
2297 skb_pull(skb, LL_HEADER_LENGTH + 2);
2298 } else {
2299 if (ccw_idx == 0) {
2300 struct net_device *dev = ch->netdev;
2301 struct ctc_priv *privptr = dev->priv;
2302 privptr->stats.tx_packets++;
2303 privptr->stats.tx_bytes +=
2304 skb->len - LL_HEADER_LENGTH;
2305 }
2306 }
2307 }
2308
2309 ctc_clear_busy(ch->netdev);
2310 return rc;
2311 }
2312
2313 /**
2314 * Interface API for upper network layers
2315 *****************************************************************************/
2316
2317 /**
2318 * Open an interface.
2319 * Called from generic network layer when ifconfig up is run.
2320 *
2321 * @param dev Pointer to interface struct.
2322 *
2323 * @return 0 on success, -ERRNO on failure. (Never fails.)
2324 */
2325 static int
2326 ctc_open(struct net_device * dev)
2327 {
2328 DBF_TEXT(trace, 5, __FUNCTION__);
2329 fsm_event(((struct ctc_priv *) dev->priv)->fsm, DEV_EVENT_START, dev);
2330 return 0;
2331 }
2332
2333 /**
2334 * Close an interface.
2335 * Called from generic network layer when ifconfig down is run.
2336 *
2337 * @param dev Pointer to interface struct.
2338 *
2339 * @return 0 on success, -ERRNO on failure. (Never fails.)
2340 */
2341 static int
2342 ctc_close(struct net_device * dev)
2343 {
2344 DBF_TEXT(trace, 5, __FUNCTION__);
2345 fsm_event(((struct ctc_priv *) dev->priv)->fsm, DEV_EVENT_STOP, dev);
2346 return 0;
2347 }
2348
2349 /**
2350 * Start transmission of a packet.
2351 * Called from generic network device layer.
2352 *
2353 * @param skb Pointer to buffer containing the packet.
2354 * @param dev Pointer to interface struct.
2355 *
2356 * @return 0 if packet consumed, !0 if packet rejected.
2357 * Note: If we return !0, then the packet is free'd by
2358 * the generic network layer.
2359 */
2360 static int
2361 ctc_tx(struct sk_buff *skb, struct net_device * dev)
2362 {
2363 int rc = 0;
2364 struct ctc_priv *privptr = (struct ctc_priv *) dev->priv;
2365
2366 DBF_TEXT(trace, 5, __FUNCTION__);
2367 /**
2368 * Some sanity checks ...
2369 */
2370 if (skb == NULL) {
2371 ctc_pr_warn("%s: NULL sk_buff passed\n", dev->name);
2372 privptr->stats.tx_dropped++;
2373 return 0;
2374 }
2375 if (skb_headroom(skb) < (LL_HEADER_LENGTH + 2)) {
2376 ctc_pr_warn("%s: Got sk_buff with head room < %ld bytes\n",
2377 dev->name, LL_HEADER_LENGTH + 2);
2378 dev_kfree_skb(skb);
2379 privptr->stats.tx_dropped++;
2380 return 0;
2381 }
2382
2383 /**
2384 * If channels are not running, try to restart them
2385 * and throw away packet.
2386 */
2387 if (fsm_getstate(privptr->fsm) != DEV_STATE_RUNNING) {
2388 fsm_event(privptr->fsm, DEV_EVENT_START, dev);
2389 dev_kfree_skb(skb);
2390 privptr->stats.tx_dropped++;
2391 privptr->stats.tx_errors++;
2392 privptr->stats.tx_carrier_errors++;
2393 return 0;
2394 }
2395
2396 if (ctc_test_and_set_busy(dev))
2397 return -EBUSY;
2398
2399 dev->trans_start = jiffies;
2400 if (transmit_skb(privptr->channel[WRITE], skb) != 0)
2401 rc = 1;
2402 return rc;
2403 }
2404
2405 /**
2406 * Sets MTU of an interface.
2407 *
2408 * @param dev Pointer to interface struct.
2409 * @param new_mtu The new MTU to use for this interface.
2410 *
2411 * @return 0 on success, -EINVAL if MTU is out of valid range.
2412 * (valid range is 576 .. 65527). If VM is on the
2413 * remote side, maximum MTU is 32760, however this is
2414 * <em>not</em> checked here.
2415 */
2416 static int
2417 ctc_change_mtu(struct net_device * dev, int new_mtu)
2418 {
2419 struct ctc_priv *privptr = (struct ctc_priv *) dev->priv;
2420
2421 DBF_TEXT(trace, 3, __FUNCTION__);
2422 if ((new_mtu < 576) || (new_mtu > 65527) ||
2423 (new_mtu > (privptr->channel[READ]->max_bufsize -
2424 LL_HEADER_LENGTH - 2)))
2425 return -EINVAL;
2426 dev->mtu = new_mtu;
2427 dev->hard_header_len = LL_HEADER_LENGTH + 2;
2428 return 0;
2429 }
2430
2431 /**
2432 * Returns interface statistics of a device.
2433 *
2434 * @param dev Pointer to interface struct.
2435 *
2436 * @return Pointer to stats struct of this interface.
2437 */
2438 static struct net_device_stats *
2439 ctc_stats(struct net_device * dev)
2440 {
2441 return &((struct ctc_priv *) dev->priv)->stats;
2442 }
2443
2444 /*
2445 * sysfs attributes
2446 */
2447
2448 static ssize_t
2449 buffer_show(struct device *dev, struct device_attribute *attr, char *buf)
2450 {
2451 struct ctc_priv *priv;
2452
2453 priv = dev->driver_data;
2454 if (!priv)
2455 return -ENODEV;
2456 return sprintf(buf, "%d\n",
2457 priv->buffer_size);
2458 }
2459
2460 static ssize_t
2461 buffer_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
2462 {
2463 struct ctc_priv *priv;
2464 struct net_device *ndev;
2465 int bs1;
2466 char buffer[16];
2467
2468 DBF_TEXT(trace, 3, __FUNCTION__);
2469 DBF_TEXT(trace, 3, buf);
2470 priv = dev->driver_data;
2471 if (!priv) {
2472 DBF_TEXT(trace, 3, "bfnopriv");
2473 return -ENODEV;
2474 }
2475
2476 sscanf(buf, "%u", &bs1);
2477 if (bs1 > CTC_BUFSIZE_LIMIT)
2478 goto einval;
2479 if (bs1 < (576 + LL_HEADER_LENGTH + 2))
2480 goto einval;
2481 priv->buffer_size = bs1; // just to overwrite the default
2482
2483 ndev = priv->channel[READ]->netdev;
2484 if (!ndev) {
2485 DBF_TEXT(trace, 3, "bfnondev");
2486 return -ENODEV;
2487 }
2488
2489 if ((ndev->flags & IFF_RUNNING) &&
2490 (bs1 < (ndev->mtu + LL_HEADER_LENGTH + 2)))
2491 goto einval;
2492
2493 priv->channel[READ]->max_bufsize = bs1;
2494 priv->channel[WRITE]->max_bufsize = bs1;
2495 if (!(ndev->flags & IFF_RUNNING))
2496 ndev->mtu = bs1 - LL_HEADER_LENGTH - 2;
2497 priv->channel[READ]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
2498 priv->channel[WRITE]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
2499
2500 sprintf(buffer, "%d",priv->buffer_size);
2501 DBF_TEXT(trace, 3, buffer);
2502 return count;
2503
2504 einval:
2505 DBF_TEXT(trace, 3, "buff_err");
2506 return -EINVAL;
2507 }
2508
2509 static ssize_t
2510 loglevel_show(struct device *dev, struct device_attribute *attr, char *buf)
2511 {
2512 return sprintf(buf, "%d\n", loglevel);
2513 }
2514
2515 static ssize_t
2516 loglevel_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
2517 {
2518 int ll1;
2519
2520 DBF_TEXT(trace, 5, __FUNCTION__);
2521 sscanf(buf, "%i", &ll1);
2522
2523 if ((ll1 > CTC_LOGLEVEL_MAX) || (ll1 < 0))
2524 return -EINVAL;
2525 loglevel = ll1;
2526 return count;
2527 }
2528
2529 static void
2530 ctc_print_statistics(struct ctc_priv *priv)
2531 {
2532 char *sbuf;
2533 char *p;
2534
2535 DBF_TEXT(trace, 4, __FUNCTION__);
2536 if (!priv)
2537 return;
2538 sbuf = (char *)kmalloc(2048, GFP_KERNEL);
2539 if (sbuf == NULL)
2540 return;
2541 p = sbuf;
2542
2543 p += sprintf(p, " Device FSM state: %s\n",
2544 fsm_getstate_str(priv->fsm));
2545 p += sprintf(p, " RX channel FSM state: %s\n",
2546 fsm_getstate_str(priv->channel[READ]->fsm));
2547 p += sprintf(p, " TX channel FSM state: %s\n",
2548 fsm_getstate_str(priv->channel[WRITE]->fsm));
2549 p += sprintf(p, " Max. TX buffer used: %ld\n",
2550 priv->channel[WRITE]->prof.maxmulti);
2551 p += sprintf(p, " Max. chained SKBs: %ld\n",
2552 priv->channel[WRITE]->prof.maxcqueue);
2553 p += sprintf(p, " TX single write ops: %ld\n",
2554 priv->channel[WRITE]->prof.doios_single);
2555 p += sprintf(p, " TX multi write ops: %ld\n",
2556 priv->channel[WRITE]->prof.doios_multi);
2557 p += sprintf(p, " Netto bytes written: %ld\n",
2558 priv->channel[WRITE]->prof.txlen);
2559 p += sprintf(p, " Max. TX IO-time: %ld\n",
2560 priv->channel[WRITE]->prof.tx_time);
2561
2562 ctc_pr_debug("Statistics for %s:\n%s",
2563 priv->channel[WRITE]->netdev->name, sbuf);
2564 kfree(sbuf);
2565 return;
2566 }
2567
2568 static ssize_t
2569 stats_show(struct device *dev, struct device_attribute *attr, char *buf)
2570 {
2571 struct ctc_priv *priv = dev->driver_data;
2572 if (!priv)
2573 return -ENODEV;
2574 ctc_print_statistics(priv);
2575 return sprintf(buf, "0\n");
2576 }
2577
2578 static ssize_t
2579 stats_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
2580 {
2581 struct ctc_priv *priv = dev->driver_data;
2582 if (!priv)
2583 return -ENODEV;
2584 /* Reset statistics */
2585 memset(&priv->channel[WRITE]->prof, 0,
2586 sizeof(priv->channel[WRITE]->prof));
2587 return count;
2588 }
2589
2590 static void
2591 ctc_netdev_unregister(struct net_device * dev)
2592 {
2593 struct ctc_priv *privptr;
2594
2595 if (!dev)
2596 return;
2597 privptr = (struct ctc_priv *) dev->priv;
2598 unregister_netdev(dev);
2599 }
2600
2601 static int
2602 ctc_netdev_register(struct net_device * dev)
2603 {
2604 return register_netdev(dev);
2605 }
2606
2607 static void
2608 ctc_free_netdevice(struct net_device * dev, int free_dev)
2609 {
2610 struct ctc_priv *privptr;
2611 if (!dev)
2612 return;
2613 privptr = dev->priv;
2614 if (privptr) {
2615 if (privptr->fsm)
2616 kfree_fsm(privptr->fsm);
2617 kfree(privptr);
2618 }
2619 #ifdef MODULE
2620 if (free_dev)
2621 free_netdev(dev);
2622 #endif
2623 }
2624
2625 static ssize_t
2626 ctc_proto_show(struct device *dev, struct device_attribute *attr, char *buf)
2627 {
2628 struct ctc_priv *priv;
2629
2630 priv = dev->driver_data;
2631 if (!priv)
2632 return -ENODEV;
2633
2634 return sprintf(buf, "%d\n", priv->protocol);
2635 }
2636
2637 static ssize_t
2638 ctc_proto_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
2639 {
2640 struct ctc_priv *priv;
2641 int value;
2642
2643 DBF_TEXT(trace, 3, __FUNCTION__);
2644 pr_debug("%s() called\n", __FUNCTION__);
2645
2646 priv = dev->driver_data;
2647 if (!priv)
2648 return -ENODEV;
2649 sscanf(buf, "%u", &value);
2650 if (!((value == CTC_PROTO_S390) ||
2651 (value == CTC_PROTO_LINUX) ||
2652 (value == CTC_PROTO_OS390)))
2653 return -EINVAL;
2654 priv->protocol = value;
2655
2656 return count;
2657 }
2658
2659 static ssize_t
2660 ctc_type_show(struct device *dev, struct device_attribute *attr, char *buf)
2661 {
2662 struct ccwgroup_device *cgdev;
2663
2664 cgdev = to_ccwgroupdev(dev);
2665 if (!cgdev)
2666 return -ENODEV;
2667
2668 return sprintf(buf, "%s\n", cu3088_type[cgdev->cdev[0]->id.driver_info]);
2669 }
2670
2671 static DEVICE_ATTR(buffer, 0644, buffer_show, buffer_write);
2672 static DEVICE_ATTR(protocol, 0644, ctc_proto_show, ctc_proto_store);
2673 static DEVICE_ATTR(type, 0444, ctc_type_show, NULL);
2674
2675 static DEVICE_ATTR(loglevel, 0644, loglevel_show, loglevel_write);
2676 static DEVICE_ATTR(stats, 0644, stats_show, stats_write);
2677
2678 static struct attribute *ctc_attr[] = {
2679 &dev_attr_protocol.attr,
2680 &dev_attr_type.attr,
2681 &dev_attr_buffer.attr,
2682 NULL,
2683 };
2684
2685 static struct attribute_group ctc_attr_group = {
2686 .attrs = ctc_attr,
2687 };
2688
2689 static int
2690 ctc_add_attributes(struct device *dev)
2691 {
2692 int rc;
2693
2694 rc = device_create_file(dev, &dev_attr_loglevel);
2695 if (rc)
2696 goto out;
2697 rc = device_create_file(dev, &dev_attr_stats);
2698 if (!rc)
2699 goto out;
2700 device_remove_file(dev, &dev_attr_loglevel);
2701 out:
2702 return rc;
2703 }
2704
2705 static void
2706 ctc_remove_attributes(struct device *dev)
2707 {
2708 device_remove_file(dev, &dev_attr_stats);
2709 device_remove_file(dev, &dev_attr_loglevel);
2710 }
2711
2712 static int
2713 ctc_add_files(struct device *dev)
2714 {
2715 pr_debug("%s() called\n", __FUNCTION__);
2716
2717 return sysfs_create_group(&dev->kobj, &ctc_attr_group);
2718 }
2719
2720 static void
2721 ctc_remove_files(struct device *dev)
2722 {
2723 pr_debug("%s() called\n", __FUNCTION__);
2724
2725 sysfs_remove_group(&dev->kobj, &ctc_attr_group);
2726 }
2727
2728 /**
2729 * Add ctc specific attributes.
2730 * Add ctc private data.
2731 *
2732 * @param cgdev pointer to ccwgroup_device just added
2733 *
2734 * @returns 0 on success, !0 on failure.
2735 */
2736 static int
2737 ctc_probe_device(struct ccwgroup_device *cgdev)
2738 {
2739 struct ctc_priv *priv;
2740 int rc;
2741 char buffer[16];
2742
2743 pr_debug("%s() called\n", __FUNCTION__);
2744 DBF_TEXT(setup, 3, __FUNCTION__);
2745
2746 if (!get_device(&cgdev->dev))
2747 return -ENODEV;
2748
2749 priv = kmalloc(sizeof (struct ctc_priv), GFP_KERNEL);
2750 if (!priv) {
2751 ctc_pr_err("%s: Out of memory\n", __func__);
2752 put_device(&cgdev->dev);
2753 return -ENOMEM;
2754 }
2755
2756 memset(priv, 0, sizeof (struct ctc_priv));
2757 rc = ctc_add_files(&cgdev->dev);
2758 if (rc) {
2759 kfree(priv);
2760 put_device(&cgdev->dev);
2761 return rc;
2762 }
2763 priv->buffer_size = CTC_BUFSIZE_DEFAULT;
2764 cgdev->cdev[0]->handler = ctc_irq_handler;
2765 cgdev->cdev[1]->handler = ctc_irq_handler;
2766 cgdev->dev.driver_data = priv;
2767
2768 sprintf(buffer, "%p", priv);
2769 DBF_TEXT(data, 3, buffer);
2770
2771 sprintf(buffer, "%u", (unsigned int)sizeof(struct ctc_priv));
2772 DBF_TEXT(data, 3, buffer);
2773
2774 sprintf(buffer, "%p", &channels);
2775 DBF_TEXT(data, 3, buffer);
2776
2777 sprintf(buffer, "%u", (unsigned int)sizeof(struct channel));
2778 DBF_TEXT(data, 3, buffer);
2779
2780 return 0;
2781 }
2782
2783 /**
2784 * Initialize everything of the net device except the name and the
2785 * channel structs.
2786 */
2787 static struct net_device *
2788 ctc_init_netdevice(struct net_device * dev, int alloc_device,
2789 struct ctc_priv *privptr)
2790 {
2791 if (!privptr)
2792 return NULL;
2793
2794 DBF_TEXT(setup, 3, __FUNCTION__);
2795
2796 if (alloc_device) {
2797 dev = kmalloc(sizeof (struct net_device), GFP_KERNEL);
2798 if (!dev)
2799 return NULL;
2800 memset(dev, 0, sizeof (struct net_device));
2801 }
2802
2803 dev->priv = privptr;
2804 privptr->fsm = init_fsm("ctcdev", dev_state_names,
2805 dev_event_names, CTC_NR_DEV_STATES, CTC_NR_DEV_EVENTS,
2806 dev_fsm, DEV_FSM_LEN, GFP_KERNEL);
2807 if (privptr->fsm == NULL) {
2808 if (alloc_device)
2809 kfree(dev);
2810 return NULL;
2811 }
2812 fsm_newstate(privptr->fsm, DEV_STATE_STOPPED);
2813 fsm_settimer(privptr->fsm, &privptr->restart_timer);
2814 if (dev->mtu == 0)
2815 dev->mtu = CTC_BUFSIZE_DEFAULT - LL_HEADER_LENGTH - 2;
2816 dev->hard_start_xmit = ctc_tx;
2817 dev->open = ctc_open;
2818 dev->stop = ctc_close;
2819 dev->get_stats = ctc_stats;
2820 dev->change_mtu = ctc_change_mtu;
2821 dev->hard_header_len = LL_HEADER_LENGTH + 2;
2822 dev->addr_len = 0;
2823 dev->type = ARPHRD_SLIP;
2824 dev->tx_queue_len = 100;
2825 dev->flags = IFF_POINTOPOINT | IFF_NOARP;
2826 SET_MODULE_OWNER(dev);
2827 return dev;
2828 }
2829
2830
2831 /**
2832 *
2833 * Setup an interface.
2834 *
2835 * @param cgdev Device to be setup.
2836 *
2837 * @returns 0 on success, !0 on failure.
2838 */
2839 static int
2840 ctc_new_device(struct ccwgroup_device *cgdev)
2841 {
2842 char read_id[CTC_ID_SIZE];
2843 char write_id[CTC_ID_SIZE];
2844 int direction;
2845 enum channel_types type;
2846 struct ctc_priv *privptr;
2847 struct net_device *dev;
2848 int ret;
2849 char buffer[16];
2850
2851 pr_debug("%s() called\n", __FUNCTION__);
2852 DBF_TEXT(setup, 3, __FUNCTION__);
2853
2854 privptr = cgdev->dev.driver_data;
2855 if (!privptr)
2856 return -ENODEV;
2857
2858 sprintf(buffer, "%d", privptr->buffer_size);
2859 DBF_TEXT(setup, 3, buffer);
2860
2861 type = get_channel_type(&cgdev->cdev[0]->id);
2862
2863 snprintf(read_id, CTC_ID_SIZE, "ch-%s", cgdev->cdev[0]->dev.bus_id);
2864 snprintf(write_id, CTC_ID_SIZE, "ch-%s", cgdev->cdev[1]->dev.bus_id);
2865
2866 if (add_channel(cgdev->cdev[0], type))
2867 return -ENOMEM;
2868 if (add_channel(cgdev->cdev[1], type))
2869 return -ENOMEM;
2870
2871 ret = ccw_device_set_online(cgdev->cdev[0]);
2872 if (ret != 0) {
2873 printk(KERN_WARNING
2874 "ccw_device_set_online (cdev[0]) failed with ret = %d\n", ret);
2875 }
2876
2877 ret = ccw_device_set_online(cgdev->cdev[1]);
2878 if (ret != 0) {
2879 printk(KERN_WARNING
2880 "ccw_device_set_online (cdev[1]) failed with ret = %d\n", ret);
2881 }
2882
2883 dev = ctc_init_netdevice(NULL, 1, privptr);
2884
2885 if (!dev) {
2886 ctc_pr_warn("ctc_init_netdevice failed\n");
2887 goto out;
2888 }
2889
2890 strlcpy(dev->name, "ctc%d", IFNAMSIZ);
2891
2892 for (direction = READ; direction <= WRITE; direction++) {
2893 privptr->channel[direction] =
2894 channel_get(type, direction == READ ? read_id : write_id,
2895 direction);
2896 if (privptr->channel[direction] == NULL) {
2897 if (direction == WRITE)
2898 channel_free(privptr->channel[READ]);
2899
2900 ctc_free_netdevice(dev, 1);
2901 goto out;
2902 }
2903 privptr->channel[direction]->netdev = dev;
2904 privptr->channel[direction]->protocol = privptr->protocol;
2905 privptr->channel[direction]->max_bufsize = privptr->buffer_size;
2906 }
2907 /* sysfs magic */
2908 SET_NETDEV_DEV(dev, &cgdev->dev);
2909
2910 if (ctc_netdev_register(dev) != 0) {
2911 ctc_free_netdevice(dev, 1);
2912 goto out;
2913 }
2914
2915 if (ctc_add_attributes(&cgdev->dev)) {
2916 ctc_netdev_unregister(dev);
2917 dev->priv = NULL;
2918 ctc_free_netdevice(dev, 1);
2919 goto out;
2920 }
2921
2922 strlcpy(privptr->fsm->name, dev->name, sizeof (privptr->fsm->name));
2923
2924 print_banner();
2925
2926 ctc_pr_info("%s: read: %s, write: %s, proto: %d\n",
2927 dev->name, privptr->channel[READ]->id,
2928 privptr->channel[WRITE]->id, privptr->protocol);
2929
2930 return 0;
2931 out:
2932 ccw_device_set_offline(cgdev->cdev[1]);
2933 ccw_device_set_offline(cgdev->cdev[0]);
2934
2935 return -ENODEV;
2936 }
2937
2938 /**
2939 * Shutdown an interface.
2940 *
2941 * @param cgdev Device to be shut down.
2942 *
2943 * @returns 0 on success, !0 on failure.
2944 */
2945 static int
2946 ctc_shutdown_device(struct ccwgroup_device *cgdev)
2947 {
2948 struct ctc_priv *priv;
2949 struct net_device *ndev;
2950
2951 DBF_TEXT(setup, 3, __FUNCTION__);
2952 pr_debug("%s() called\n", __FUNCTION__);
2953
2954
2955 priv = cgdev->dev.driver_data;
2956 ndev = NULL;
2957 if (!priv)
2958 return -ENODEV;
2959
2960 if (priv->channel[READ]) {
2961 ndev = priv->channel[READ]->netdev;
2962
2963 /* Close the device */
2964 ctc_close(ndev);
2965 ndev->flags &=~IFF_RUNNING;
2966
2967 ctc_remove_attributes(&cgdev->dev);
2968
2969 channel_free(priv->channel[READ]);
2970 }
2971 if (priv->channel[WRITE])
2972 channel_free(priv->channel[WRITE]);
2973
2974 if (ndev) {
2975 ctc_netdev_unregister(ndev);
2976 ndev->priv = NULL;
2977 ctc_free_netdevice(ndev, 1);
2978 }
2979
2980 if (priv->fsm)
2981 kfree_fsm(priv->fsm);
2982
2983 ccw_device_set_offline(cgdev->cdev[1]);
2984 ccw_device_set_offline(cgdev->cdev[0]);
2985
2986 if (priv->channel[READ])
2987 channel_remove(priv->channel[READ]);
2988 if (priv->channel[WRITE])
2989 channel_remove(priv->channel[WRITE]);
2990 priv->channel[READ] = priv->channel[WRITE] = NULL;
2991
2992 return 0;
2993
2994 }
2995
2996 static void
2997 ctc_remove_device(struct ccwgroup_device *cgdev)
2998 {
2999 struct ctc_priv *priv;
3000
3001 pr_debug("%s() called\n", __FUNCTION__);
3002 DBF_TEXT(setup, 3, __FUNCTION__);
3003
3004 priv = cgdev->dev.driver_data;
3005 if (!priv)
3006 return;
3007 if (cgdev->state == CCWGROUP_ONLINE)
3008 ctc_shutdown_device(cgdev);
3009 ctc_remove_files(&cgdev->dev);
3010 cgdev->dev.driver_data = NULL;
3011 kfree(priv);
3012 put_device(&cgdev->dev);
3013 }
3014
3015 static struct ccwgroup_driver ctc_group_driver = {
3016 .owner = THIS_MODULE,
3017 .name = "ctc",
3018 .max_slaves = 2,
3019 .driver_id = 0xC3E3C3,
3020 .probe = ctc_probe_device,
3021 .remove = ctc_remove_device,
3022 .set_online = ctc_new_device,
3023 .set_offline = ctc_shutdown_device,
3024 };
3025
3026 /**
3027 * Module related routines
3028 *****************************************************************************/
3029
3030 /**
3031 * Prepare to be unloaded. Free IRQ's and release all resources.
3032 * This is called just before this module is unloaded. It is
3033 * <em>not</em> called, if the usage count is !0, so we don't need to check
3034 * for that.
3035 */
3036 static void __exit
3037 ctc_exit(void)
3038 {
3039 DBF_TEXT(setup, 3, __FUNCTION__);
3040 unregister_cu3088_discipline(&ctc_group_driver);
3041 ctc_unregister_dbf_views();
3042 ctc_pr_info("CTC driver unloaded\n");
3043 }
3044
3045 /**
3046 * Initialize module.
3047 * This is called just after the module is loaded.
3048 *
3049 * @return 0 on success, !0 on error.
3050 */
3051 static int __init
3052 ctc_init(void)
3053 {
3054 int ret = 0;
3055
3056 loglevel = CTC_LOGLEVEL_DEFAULT;
3057
3058 DBF_TEXT(setup, 3, __FUNCTION__);
3059
3060 print_banner();
3061
3062 ret = ctc_register_dbf_views();
3063 if (ret){
3064 ctc_pr_crit("ctc_init failed with ctc_register_dbf_views rc = %d\n", ret);
3065 return ret;
3066 }
3067 ret = register_cu3088_discipline(&ctc_group_driver);
3068 if (ret) {
3069 ctc_unregister_dbf_views();
3070 }
3071 return ret;
3072 }
3073
3074 module_init(ctc_init);
3075 module_exit(ctc_exit);
3076
3077 /* --- This is the END my friend --- */
ubuntu-bionic-kernel mirror