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