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