2 * drivers/s390/net/ctcm_main.c
4 * Copyright IBM Corp. 2001, 2009
6 * Original CTC driver(s):
7 * Fritz Elfert (felfert@millenux.com)
8 * Dieter Wellerdiek (wel@de.ibm.com)
9 * Martin Schwidefsky (schwidefsky@de.ibm.com)
10 * Denis Joseph Barrow (barrow_dj@yahoo.com)
11 * Jochen Roehrig (roehrig@de.ibm.com)
12 * Cornelia Huck <cornelia.huck@de.ibm.com>
14 * Belinda Thompson (belindat@us.ibm.com)
15 * Andy Richter (richtera@us.ibm.com)
17 * Peter Tiedemann (ptiedem@de.ibm.com)
24 #define KMSG_COMPONENT "ctcm"
25 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
27 #include <linux/module.h>
28 #include <linux/init.h>
29 #include <linux/kernel.h>
30 #include <linux/slab.h>
31 #include <linux/errno.h>
32 #include <linux/types.h>
33 #include <linux/interrupt.h>
34 #include <linux/timer.h>
35 #include <linux/bitops.h>
37 #include <linux/signal.h>
38 #include <linux/string.h>
41 #include <linux/if_arp.h>
42 #include <linux/tcp.h>
43 #include <linux/skbuff.h>
44 #include <linux/ctype.h>
48 #include <asm/ccwdev.h>
49 #include <asm/ccwgroup.h>
50 #include <linux/uaccess.h>
52 #include <asm/idals.h>
55 #include "ctcm_fsms.h"
56 #include "ctcm_main.h"
58 /* Some common global variables */
61 * Linked list of all detected channels.
63 struct channel
*channels
;
66 * Unpack a just received skb and hand it over to
69 * ch The channel where this skb has been received.
70 * pskb The received skb.
72 void ctcm_unpack_skb(struct channel
*ch
, struct sk_buff
*pskb
)
74 struct net_device
*dev
= ch
->netdev
;
75 struct ctcm_priv
*priv
= dev
->ml_priv
;
76 __u16 len
= *((__u16
*) pskb
->data
);
78 skb_put(pskb
, 2 + LL_HEADER_LENGTH
);
81 pskb
->ip_summed
= CHECKSUM_UNNECESSARY
;
85 struct ll_header
*header
= (struct ll_header
*)pskb
->data
;
87 skb_pull(pskb
, LL_HEADER_LENGTH
);
88 if ((ch
->protocol
== CTCM_PROTO_S390
) &&
89 (header
->type
!= ETH_P_IP
)) {
90 if (!(ch
->logflags
& LOG_FLAG_ILLEGALPKT
)) {
91 ch
->logflags
|= LOG_FLAG_ILLEGALPKT
;
93 * Check packet type only if we stick strictly
94 * to S/390's protocol of OS390. This only
95 * supports IP. Otherwise allow any packet
98 CTCM_DBF_TEXT_(ERROR
, CTC_DBF_ERROR
,
99 "%s(%s): Illegal packet type 0x%04x"
101 CTCM_FUNTAIL
, dev
->name
, header
->type
);
103 priv
->stats
.rx_dropped
++;
104 priv
->stats
.rx_frame_errors
++;
107 pskb
->protocol
= ntohs(header
->type
);
108 if ((header
->length
<= LL_HEADER_LENGTH
) ||
109 (len
<= LL_HEADER_LENGTH
)) {
110 if (!(ch
->logflags
& LOG_FLAG_ILLEGALSIZE
)) {
111 CTCM_DBF_TEXT_(ERROR
, CTC_DBF_ERROR
,
112 "%s(%s): Illegal packet size %d(%d,%d)"
114 CTCM_FUNTAIL
, dev
->name
,
115 header
->length
, dev
->mtu
, len
);
116 ch
->logflags
|= LOG_FLAG_ILLEGALSIZE
;
119 priv
->stats
.rx_dropped
++;
120 priv
->stats
.rx_length_errors
++;
123 header
->length
-= LL_HEADER_LENGTH
;
124 len
-= LL_HEADER_LENGTH
;
125 if ((header
->length
> skb_tailroom(pskb
)) ||
126 (header
->length
> len
)) {
127 if (!(ch
->logflags
& LOG_FLAG_OVERRUN
)) {
128 CTCM_DBF_TEXT_(ERROR
, CTC_DBF_ERROR
,
129 "%s(%s): Packet size %d (overrun)"
130 " - dropping", CTCM_FUNTAIL
,
131 dev
->name
, header
->length
);
132 ch
->logflags
|= LOG_FLAG_OVERRUN
;
135 priv
->stats
.rx_dropped
++;
136 priv
->stats
.rx_length_errors
++;
139 skb_put(pskb
, header
->length
);
140 skb_reset_mac_header(pskb
);
141 len
-= header
->length
;
142 skb
= dev_alloc_skb(pskb
->len
);
144 if (!(ch
->logflags
& LOG_FLAG_NOMEM
)) {
145 CTCM_DBF_TEXT_(ERROR
, CTC_DBF_ERROR
,
146 "%s(%s): MEMORY allocation error",
147 CTCM_FUNTAIL
, dev
->name
);
148 ch
->logflags
|= LOG_FLAG_NOMEM
;
150 priv
->stats
.rx_dropped
++;
153 skb_copy_from_linear_data(pskb
, skb_put(skb
, pskb
->len
),
155 skb_reset_mac_header(skb
);
156 skb
->dev
= pskb
->dev
;
157 skb
->protocol
= pskb
->protocol
;
158 pskb
->ip_summed
= CHECKSUM_UNNECESSARY
;
164 priv
->stats
.rx_packets
++;
165 priv
->stats
.rx_bytes
+= skblen
;
167 dev
->last_rx
= jiffies
;
169 skb_pull(pskb
, header
->length
);
170 if (skb_tailroom(pskb
) < LL_HEADER_LENGTH
) {
171 CTCM_DBF_DEV_NAME(TRACE
, dev
,
172 "Overrun in ctcm_unpack_skb");
173 ch
->logflags
|= LOG_FLAG_OVERRUN
;
176 skb_put(pskb
, LL_HEADER_LENGTH
);
182 * Release a specific channel in the channel list.
184 * ch Pointer to channel struct to be released.
186 static void channel_free(struct channel
*ch
)
188 CTCM_DBF_TEXT_(SETUP
, CTC_DBF_INFO
, "%s(%s)", CTCM_FUNTAIL
, ch
->id
);
189 ch
->flags
&= ~CHANNEL_FLAGS_INUSE
;
190 fsm_newstate(ch
->fsm
, CTC_STATE_IDLE
);
194 * Remove a specific channel in the channel list.
196 * ch Pointer to channel struct to be released.
198 static void channel_remove(struct channel
*ch
)
200 struct channel
**c
= &channels
;
201 char chid
[CTCM_ID_SIZE
+1];
207 strncpy(chid
, ch
->id
, CTCM_ID_SIZE
);
213 fsm_deltimer(&ch
->timer
);
215 fsm_deltimer(&ch
->sweep_timer
);
218 clear_normalized_cda(&ch
->ccw
[4]);
219 if (ch
->trans_skb
!= NULL
) {
220 clear_normalized_cda(&ch
->ccw
[1]);
221 dev_kfree_skb_any(ch
->trans_skb
);
224 tasklet_kill(&ch
->ch_tasklet
);
225 tasklet_kill(&ch
->ch_disc_tasklet
);
226 kfree(ch
->discontact_th
);
237 CTCM_DBF_TEXT_(SETUP
, CTC_DBF_INFO
, "%s(%s) %s", CTCM_FUNTAIL
,
238 chid
, ok
? "OK" : "failed");
242 * Get a specific channel from the channel list.
244 * type Type of channel we are interested in.
245 * id Id of channel we are interested in.
246 * direction Direction we want to use this channel for.
248 * returns Pointer to a channel or NULL if no matching channel available.
250 static struct channel
*channel_get(enum channel_types type
,
251 char *id
, int direction
)
253 struct channel
*ch
= channels
;
255 while (ch
&& (strncmp(ch
->id
, id
, CTCM_ID_SIZE
) || (ch
->type
!= type
)))
258 CTCM_DBF_TEXT_(ERROR
, CTC_DBF_ERROR
,
259 "%s(%d, %s, %d) not found in channel list\n",
260 CTCM_FUNTAIL
, type
, id
, direction
);
262 if (ch
->flags
& CHANNEL_FLAGS_INUSE
)
265 ch
->flags
|= CHANNEL_FLAGS_INUSE
;
266 ch
->flags
&= ~CHANNEL_FLAGS_RWMASK
;
267 ch
->flags
|= (direction
== WRITE
)
268 ? CHANNEL_FLAGS_WRITE
: CHANNEL_FLAGS_READ
;
269 fsm_newstate(ch
->fsm
, CTC_STATE_STOPPED
);
275 static long ctcm_check_irb_error(struct ccw_device
*cdev
, struct irb
*irb
)
280 CTCM_DBF_TEXT_(ERROR
, CTC_DBF_WARN
,
281 "irb error %ld on device %s\n",
282 PTR_ERR(irb
), dev_name(&cdev
->dev
));
284 switch (PTR_ERR(irb
)) {
287 "An I/O-error occurred on the CTCM device\n");
291 "An adapter hardware operation timed out\n");
295 "An error occurred on the adapter hardware\n");
302 * Check sense of a unit check.
304 * ch The channel, the sense code belongs to.
305 * sense The sense code to inspect.
307 static inline void ccw_unit_check(struct channel
*ch
, __u8 sense
)
309 CTCM_DBF_TEXT_(TRACE
, CTC_DBF_DEBUG
,
311 CTCM_FUNTAIL
, ch
->id
, sense
);
313 if (sense
& SNS0_INTERVENTION_REQ
) {
315 if (ch
->sense_rc
!= 0x01) {
317 "%s: The communication peer has "
318 "disconnected\n", ch
->id
);
321 fsm_event(ch
->fsm
, CTC_EVENT_UC_RCRESET
, ch
);
323 if (ch
->sense_rc
!= SNS0_INTERVENTION_REQ
) {
325 "%s: The remote operating system is "
326 "not available\n", ch
->id
);
327 ch
->sense_rc
= SNS0_INTERVENTION_REQ
;
329 fsm_event(ch
->fsm
, CTC_EVENT_UC_RSRESET
, ch
);
331 } else if (sense
& SNS0_EQUIPMENT_CHECK
) {
332 if (sense
& SNS0_BUS_OUT_CHECK
) {
333 if (ch
->sense_rc
!= SNS0_BUS_OUT_CHECK
) {
334 CTCM_DBF_TEXT_(TRACE
, CTC_DBF_WARN
,
335 "%s(%s): remote HW error %02x",
336 CTCM_FUNTAIL
, ch
->id
, sense
);
337 ch
->sense_rc
= SNS0_BUS_OUT_CHECK
;
339 fsm_event(ch
->fsm
, CTC_EVENT_UC_HWFAIL
, ch
);
341 if (ch
->sense_rc
!= SNS0_EQUIPMENT_CHECK
) {
342 CTCM_DBF_TEXT_(TRACE
, CTC_DBF_WARN
,
343 "%s(%s): remote read parity error %02x",
344 CTCM_FUNTAIL
, ch
->id
, sense
);
345 ch
->sense_rc
= SNS0_EQUIPMENT_CHECK
;
347 fsm_event(ch
->fsm
, CTC_EVENT_UC_RXPARITY
, ch
);
349 } else if (sense
& SNS0_BUS_OUT_CHECK
) {
350 if (ch
->sense_rc
!= SNS0_BUS_OUT_CHECK
) {
351 CTCM_DBF_TEXT_(TRACE
, CTC_DBF_WARN
,
352 "%s(%s): BUS OUT error %02x",
353 CTCM_FUNTAIL
, ch
->id
, sense
);
354 ch
->sense_rc
= SNS0_BUS_OUT_CHECK
;
356 if (sense
& 0x04) /* data-streaming timeout */
357 fsm_event(ch
->fsm
, CTC_EVENT_UC_TXTIMEOUT
, ch
);
358 else /* Data-transfer parity error */
359 fsm_event(ch
->fsm
, CTC_EVENT_UC_TXPARITY
, ch
);
360 } else if (sense
& SNS0_CMD_REJECT
) {
361 if (ch
->sense_rc
!= SNS0_CMD_REJECT
) {
362 CTCM_DBF_TEXT_(TRACE
, CTC_DBF_WARN
,
363 "%s(%s): Command rejected",
364 CTCM_FUNTAIL
, ch
->id
);
365 ch
->sense_rc
= SNS0_CMD_REJECT
;
367 } else if (sense
== 0) {
368 CTCM_DBF_TEXT_(TRACE
, CTC_DBF_WARN
,
369 "%s(%s): Unit check ZERO",
370 CTCM_FUNTAIL
, ch
->id
);
371 fsm_event(ch
->fsm
, CTC_EVENT_UC_ZERO
, ch
);
373 CTCM_DBF_TEXT_(TRACE
, CTC_DBF_WARN
,
374 "%s(%s): Unit check code %02x unknown",
375 CTCM_FUNTAIL
, ch
->id
, sense
);
376 fsm_event(ch
->fsm
, CTC_EVENT_UC_UNKNOWN
, ch
);
380 int ctcm_ch_alloc_buffer(struct channel
*ch
)
382 clear_normalized_cda(&ch
->ccw
[1]);
383 ch
->trans_skb
= __dev_alloc_skb(ch
->max_bufsize
, GFP_ATOMIC
| GFP_DMA
);
384 if (ch
->trans_skb
== NULL
) {
385 CTCM_DBF_TEXT_(ERROR
, CTC_DBF_ERROR
,
386 "%s(%s): %s trans_skb allocation error",
387 CTCM_FUNTAIL
, ch
->id
,
388 (CHANNEL_DIRECTION(ch
->flags
) == READ
) ? "RX" : "TX");
392 ch
->ccw
[1].count
= ch
->max_bufsize
;
393 if (set_normalized_cda(&ch
->ccw
[1], ch
->trans_skb
->data
)) {
394 dev_kfree_skb(ch
->trans_skb
);
395 ch
->trans_skb
= NULL
;
396 CTCM_DBF_TEXT_(ERROR
, CTC_DBF_ERROR
,
397 "%s(%s): %s set norm_cda failed",
398 CTCM_FUNTAIL
, ch
->id
,
399 (CHANNEL_DIRECTION(ch
->flags
) == READ
) ? "RX" : "TX");
403 ch
->ccw
[1].count
= 0;
404 ch
->trans_skb_data
= ch
->trans_skb
->data
;
405 ch
->flags
&= ~CHANNEL_FLAGS_BUFSIZE_CHANGED
;
410 * Interface API for upper network layers
415 * Called from generic network layer when ifconfig up is run.
417 * dev Pointer to interface struct.
419 * returns 0 on success, -ERRNO on failure. (Never fails.)
421 int ctcm_open(struct net_device
*dev
)
423 struct ctcm_priv
*priv
= dev
->ml_priv
;
425 CTCMY_DBF_DEV_NAME(SETUP
, dev
, "");
427 fsm_event(priv
->fsm
, DEV_EVENT_START
, dev
);
432 * Close an interface.
433 * Called from generic network layer when ifconfig down is run.
435 * dev Pointer to interface struct.
437 * returns 0 on success, -ERRNO on failure. (Never fails.)
439 int ctcm_close(struct net_device
*dev
)
441 struct ctcm_priv
*priv
= dev
->ml_priv
;
443 CTCMY_DBF_DEV_NAME(SETUP
, dev
, "");
445 fsm_event(priv
->fsm
, DEV_EVENT_STOP
, dev
);
452 * This is a helper function for ctcm_tx().
454 * ch Channel to be used for sending.
455 * skb Pointer to struct sk_buff of packet to send.
456 * The linklevel header has already been set up
459 * returns 0 on success, -ERRNO on failure. (Never fails.)
461 static int ctcm_transmit_skb(struct channel
*ch
, struct sk_buff
*skb
)
463 unsigned long saveflags
;
464 struct ll_header header
;
468 struct sk_buff
*nskb
;
471 /* we need to acquire the lock for testing the state
472 * otherwise we can have an IRQ changing the state to
473 * TXIDLE after the test but before acquiring the lock.
475 spin_lock_irqsave(&ch
->collect_lock
, saveflags
);
476 if (fsm_getstate(ch
->fsm
) != CTC_STATE_TXIDLE
) {
477 int l
= skb
->len
+ LL_HEADER_LENGTH
;
479 if (ch
->collect_len
+ l
> ch
->max_bufsize
- 2) {
480 spin_unlock_irqrestore(&ch
->collect_lock
, saveflags
);
483 atomic_inc(&skb
->users
);
485 header
.type
= skb
->protocol
;
487 memcpy(skb_push(skb
, LL_HEADER_LENGTH
), &header
,
489 skb_queue_tail(&ch
->collect_queue
, skb
);
490 ch
->collect_len
+= l
;
492 spin_unlock_irqrestore(&ch
->collect_lock
, saveflags
);
495 spin_unlock_irqrestore(&ch
->collect_lock
, saveflags
);
497 * Protect skb against beeing free'd by upper
500 atomic_inc(&skb
->users
);
501 ch
->prof
.txlen
+= skb
->len
;
502 header
.length
= skb
->len
+ LL_HEADER_LENGTH
;
503 header
.type
= skb
->protocol
;
505 memcpy(skb_push(skb
, LL_HEADER_LENGTH
), &header
, LL_HEADER_LENGTH
);
506 block_len
= skb
->len
+ 2;
507 *((__u16
*)skb_push(skb
, 2)) = block_len
;
510 * IDAL support in CTCM is broken, so we have to
511 * care about skb's above 2G ourselves.
513 hi
= ((unsigned long)skb_tail_pointer(skb
) + LL_HEADER_LENGTH
) >> 31;
515 nskb
= alloc_skb(skb
->len
, GFP_ATOMIC
| GFP_DMA
);
517 atomic_dec(&skb
->users
);
518 skb_pull(skb
, LL_HEADER_LENGTH
+ 2);
519 ctcm_clear_busy(ch
->netdev
);
522 memcpy(skb_put(nskb
, skb
->len
), skb
->data
, skb
->len
);
523 atomic_inc(&nskb
->users
);
524 atomic_dec(&skb
->users
);
525 dev_kfree_skb_irq(skb
);
530 ch
->ccw
[4].count
= block_len
;
531 if (set_normalized_cda(&ch
->ccw
[4], skb
->data
)) {
533 * idal allocation failed, try via copying to
534 * trans_skb. trans_skb usually has a pre-allocated
537 if (ctcm_checkalloc_buffer(ch
)) {
539 * Remove our header. It gets added
540 * again on retransmit.
542 atomic_dec(&skb
->users
);
543 skb_pull(skb
, LL_HEADER_LENGTH
+ 2);
544 ctcm_clear_busy(ch
->netdev
);
548 skb_reset_tail_pointer(ch
->trans_skb
);
549 ch
->trans_skb
->len
= 0;
550 ch
->ccw
[1].count
= skb
->len
;
551 skb_copy_from_linear_data(skb
,
552 skb_put(ch
->trans_skb
, skb
->len
), skb
->len
);
553 atomic_dec(&skb
->users
);
554 dev_kfree_skb_irq(skb
);
557 skb_queue_tail(&ch
->io_queue
, skb
);
561 fsm_newstate(ch
->fsm
, CTC_STATE_TX
);
562 fsm_addtimer(&ch
->timer
, CTCM_TIME_5_SEC
, CTC_EVENT_TIMER
, ch
);
563 spin_lock_irqsave(get_ccwdev_lock(ch
->cdev
), saveflags
);
564 ch
->prof
.send_stamp
= current_kernel_time(); /* xtime */
565 rc
= ccw_device_start(ch
->cdev
, &ch
->ccw
[ccw_idx
],
566 (unsigned long)ch
, 0xff, 0);
567 spin_unlock_irqrestore(get_ccwdev_lock(ch
->cdev
), saveflags
);
569 ch
->prof
.doios_single
++;
571 fsm_deltimer(&ch
->timer
);
572 ctcm_ccw_check_rc(ch
, rc
, "single skb TX");
574 skb_dequeue_tail(&ch
->io_queue
);
576 * Remove our header. It gets added
577 * again on retransmit.
579 skb_pull(skb
, LL_HEADER_LENGTH
+ 2);
580 } else if (ccw_idx
== 0) {
581 struct net_device
*dev
= ch
->netdev
;
582 struct ctcm_priv
*priv
= dev
->ml_priv
;
583 priv
->stats
.tx_packets
++;
584 priv
->stats
.tx_bytes
+= skb
->len
- LL_HEADER_LENGTH
;
587 ctcm_clear_busy(ch
->netdev
);
591 static void ctcmpc_send_sweep_req(struct channel
*rch
)
593 struct net_device
*dev
= rch
->netdev
;
594 struct ctcm_priv
*priv
;
595 struct mpc_group
*grp
;
596 struct th_sweep
*header
;
597 struct sk_buff
*sweep_skb
;
603 ch
= priv
->channel
[WRITE
];
605 /* sweep processing is not complete until response and request */
606 /* has completed for all read channels in group */
607 if (grp
->in_sweep
== 0) {
609 grp
->sweep_rsp_pend_num
= grp
->active_channels
[READ
];
610 grp
->sweep_req_pend_num
= grp
->active_channels
[READ
];
613 sweep_skb
= __dev_alloc_skb(MPC_BUFSIZE_DEFAULT
, GFP_ATOMIC
|GFP_DMA
);
615 if (sweep_skb
== NULL
) {
620 header
= kmalloc(TH_SWEEP_LENGTH
, gfp_type());
623 dev_kfree_skb_any(sweep_skb
);
628 header
->th
.th_seg
= 0x00 ;
629 header
->th
.th_ch_flag
= TH_SWEEP_REQ
; /* 0x0f */
630 header
->th
.th_blk_flag
= 0x00;
631 header
->th
.th_is_xid
= 0x00;
632 header
->th
.th_seq_num
= 0x00;
633 header
->sw
.th_last_seq
= ch
->th_seq_num
;
635 memcpy(skb_put(sweep_skb
, TH_SWEEP_LENGTH
), header
, TH_SWEEP_LENGTH
);
639 dev
->trans_start
= jiffies
;
640 skb_queue_tail(&ch
->sweep_queue
, sweep_skb
);
642 fsm_addtimer(&ch
->sweep_timer
, 100, CTC_EVENT_RSWEEP_TIMER
, ch
);
648 ctcm_clear_busy(dev
);
649 fsm_event(grp
->fsm
, MPCG_EVENT_INOP
, dev
);
655 * MPC mode version of transmit_skb
657 static int ctcmpc_transmit_skb(struct channel
*ch
, struct sk_buff
*skb
)
659 struct pdu
*p_header
;
660 struct net_device
*dev
= ch
->netdev
;
661 struct ctcm_priv
*priv
= dev
->ml_priv
;
662 struct mpc_group
*grp
= priv
->mpcg
;
663 struct th_header
*header
;
664 struct sk_buff
*nskb
;
668 unsigned long saveflags
= 0; /* avoids compiler warning */
671 CTCM_PR_DEBUG("Enter %s: %s, cp=%i ch=0x%p id=%s state=%s\n",
672 __func__
, dev
->name
, smp_processor_id(), ch
,
673 ch
->id
, fsm_getstate_str(ch
->fsm
));
675 if ((fsm_getstate(ch
->fsm
) != CTC_STATE_TXIDLE
) || grp
->in_sweep
) {
676 spin_lock_irqsave(&ch
->collect_lock
, saveflags
);
677 atomic_inc(&skb
->users
);
678 p_header
= kmalloc(PDU_HEADER_LENGTH
, gfp_type());
681 spin_unlock_irqrestore(&ch
->collect_lock
, saveflags
);
685 p_header
->pdu_offset
= skb
->len
;
686 p_header
->pdu_proto
= 0x01;
687 p_header
->pdu_flag
= 0x00;
688 if (skb
->protocol
== ntohs(ETH_P_SNAP
)) {
689 p_header
->pdu_flag
|= PDU_FIRST
| PDU_CNTL
;
691 p_header
->pdu_flag
|= PDU_FIRST
;
693 p_header
->pdu_seq
= 0;
694 memcpy(skb_push(skb
, PDU_HEADER_LENGTH
), p_header
,
697 CTCM_PR_DEBUG("%s(%s): Put on collect_q - skb len: %04x \n"
698 "pdu header and data for up to 32 bytes:\n",
699 __func__
, dev
->name
, skb
->len
);
700 CTCM_D3_DUMP((char *)skb
->data
, min_t(int, 32, skb
->len
));
702 skb_queue_tail(&ch
->collect_queue
, skb
);
703 ch
->collect_len
+= skb
->len
;
706 spin_unlock_irqrestore(&ch
->collect_lock
, saveflags
);
711 * Protect skb against beeing free'd by upper
714 atomic_inc(&skb
->users
);
716 block_len
= skb
->len
+ TH_HEADER_LENGTH
+ PDU_HEADER_LENGTH
;
718 * IDAL support in CTCM is broken, so we have to
719 * care about skb's above 2G ourselves.
721 hi
= ((unsigned long)skb
->tail
+ TH_HEADER_LENGTH
) >> 31;
723 nskb
= __dev_alloc_skb(skb
->len
, GFP_ATOMIC
| GFP_DMA
);
727 memcpy(skb_put(nskb
, skb
->len
), skb
->data
, skb
->len
);
728 atomic_inc(&nskb
->users
);
729 atomic_dec(&skb
->users
);
730 dev_kfree_skb_irq(skb
);
735 p_header
= kmalloc(PDU_HEADER_LENGTH
, gfp_type());
740 p_header
->pdu_offset
= skb
->len
;
741 p_header
->pdu_proto
= 0x01;
742 p_header
->pdu_flag
= 0x00;
743 p_header
->pdu_seq
= 0;
744 if (skb
->protocol
== ntohs(ETH_P_SNAP
)) {
745 p_header
->pdu_flag
|= PDU_FIRST
| PDU_CNTL
;
747 p_header
->pdu_flag
|= PDU_FIRST
;
749 memcpy(skb_push(skb
, PDU_HEADER_LENGTH
), p_header
, PDU_HEADER_LENGTH
);
753 if (ch
->collect_len
> 0) {
754 spin_lock_irqsave(&ch
->collect_lock
, saveflags
);
755 skb_queue_tail(&ch
->collect_queue
, skb
);
756 ch
->collect_len
+= skb
->len
;
757 skb
= skb_dequeue(&ch
->collect_queue
);
758 ch
->collect_len
-= skb
->len
;
759 spin_unlock_irqrestore(&ch
->collect_lock
, saveflags
);
762 p_header
= (struct pdu
*)skb
->data
;
763 p_header
->pdu_flag
|= PDU_LAST
;
765 ch
->prof
.txlen
+= skb
->len
- PDU_HEADER_LENGTH
;
767 header
= kmalloc(TH_HEADER_LENGTH
, gfp_type());
771 header
->th_seg
= 0x00;
772 header
->th_ch_flag
= TH_HAS_PDU
; /* Normal data */
773 header
->th_blk_flag
= 0x00;
774 header
->th_is_xid
= 0x00; /* Just data here */
776 header
->th_seq_num
= ch
->th_seq_num
;
778 CTCM_PR_DBGDATA("%s(%s) ToVTAM_th_seq= %08x\n" ,
779 __func__
, dev
->name
, ch
->th_seq_num
);
781 /* put the TH on the packet */
782 memcpy(skb_push(skb
, TH_HEADER_LENGTH
), header
, TH_HEADER_LENGTH
);
786 CTCM_PR_DBGDATA("%s(%s): skb len: %04x\n - pdu header and data for "
787 "up to 32 bytes sent to vtam:\n",
788 __func__
, dev
->name
, skb
->len
);
789 CTCM_D3_DUMP((char *)skb
->data
, min_t(int, 32, skb
->len
));
791 ch
->ccw
[4].count
= skb
->len
;
792 if (set_normalized_cda(&ch
->ccw
[4], skb
->data
)) {
794 * idal allocation failed, try via copying to trans_skb.
795 * trans_skb usually has a pre-allocated idal.
797 if (ctcm_checkalloc_buffer(ch
)) {
800 * It gets added again on retransmit.
805 skb_reset_tail_pointer(ch
->trans_skb
);
806 ch
->trans_skb
->len
= 0;
807 ch
->ccw
[1].count
= skb
->len
;
808 memcpy(skb_put(ch
->trans_skb
, skb
->len
), skb
->data
, skb
->len
);
809 atomic_dec(&skb
->users
);
810 dev_kfree_skb_irq(skb
);
812 CTCM_PR_DBGDATA("%s(%s): trans_skb len: %04x\n"
813 "up to 32 bytes sent to vtam:\n",
814 __func__
, dev
->name
, ch
->trans_skb
->len
);
815 CTCM_D3_DUMP((char *)ch
->trans_skb
->data
,
816 min_t(int, 32, ch
->trans_skb
->len
));
818 skb_queue_tail(&ch
->io_queue
, skb
);
822 fsm_newstate(ch
->fsm
, CTC_STATE_TX
);
823 fsm_addtimer(&ch
->timer
, CTCM_TIME_5_SEC
, CTC_EVENT_TIMER
, ch
);
826 ctcmpc_dumpit((char *)&ch
->ccw
[ccw_idx
],
827 sizeof(struct ccw1
) * 3);
829 spin_lock_irqsave(get_ccwdev_lock(ch
->cdev
), saveflags
);
830 ch
->prof
.send_stamp
= current_kernel_time(); /* xtime */
831 rc
= ccw_device_start(ch
->cdev
, &ch
->ccw
[ccw_idx
],
832 (unsigned long)ch
, 0xff, 0);
833 spin_unlock_irqrestore(get_ccwdev_lock(ch
->cdev
), saveflags
);
835 ch
->prof
.doios_single
++;
837 fsm_deltimer(&ch
->timer
);
838 ctcm_ccw_check_rc(ch
, rc
, "single skb TX");
840 skb_dequeue_tail(&ch
->io_queue
);
841 } else if (ccw_idx
== 0) {
842 priv
->stats
.tx_packets
++;
843 priv
->stats
.tx_bytes
+= skb
->len
- TH_HEADER_LENGTH
;
845 if (ch
->th_seq_num
> 0xf0000000) /* Chose at random. */
846 ctcmpc_send_sweep_req(ch
);
850 CTCM_DBF_TEXT_(MPC_ERROR
, CTC_DBF_CRIT
,
851 "%s(%s): MEMORY allocation ERROR\n",
852 CTCM_FUNTAIL
, ch
->id
);
854 atomic_dec(&skb
->users
);
855 dev_kfree_skb_any(skb
);
856 fsm_event(priv
->mpcg
->fsm
, MPCG_EVENT_INOP
, dev
);
858 CTCM_PR_DEBUG("Exit %s(%s)\n", __func__
, dev
->name
);
863 * Start transmission of a packet.
864 * Called from generic network device layer.
866 * skb Pointer to buffer containing the packet.
867 * dev Pointer to interface struct.
869 * returns 0 if packet consumed, !0 if packet rejected.
870 * Note: If we return !0, then the packet is free'd by
871 * the generic network layer.
873 /* first merge version - leaving both functions separated */
874 static int ctcm_tx(struct sk_buff
*skb
, struct net_device
*dev
)
876 struct ctcm_priv
*priv
= dev
->ml_priv
;
879 CTCM_DBF_TEXT_(ERROR
, CTC_DBF_ERROR
,
880 "%s(%s): NULL sk_buff passed",
881 CTCM_FUNTAIL
, dev
->name
);
882 priv
->stats
.tx_dropped
++;
885 if (skb_headroom(skb
) < (LL_HEADER_LENGTH
+ 2)) {
886 CTCM_DBF_TEXT_(ERROR
, CTC_DBF_ERROR
,
887 "%s(%s): Got sk_buff with head room < %ld bytes",
888 CTCM_FUNTAIL
, dev
->name
, LL_HEADER_LENGTH
+ 2);
890 priv
->stats
.tx_dropped
++;
895 * If channels are not running, try to restart them
896 * and throw away packet.
898 if (fsm_getstate(priv
->fsm
) != DEV_STATE_RUNNING
) {
899 fsm_event(priv
->fsm
, DEV_EVENT_START
, dev
);
901 priv
->stats
.tx_dropped
++;
902 priv
->stats
.tx_errors
++;
903 priv
->stats
.tx_carrier_errors
++;
907 if (ctcm_test_and_set_busy(dev
))
908 return NETDEV_TX_BUSY
;
910 dev
->trans_start
= jiffies
;
911 if (ctcm_transmit_skb(priv
->channel
[WRITE
], skb
) != 0)
912 return NETDEV_TX_BUSY
;
916 /* unmerged MPC variant of ctcm_tx */
917 static int ctcmpc_tx(struct sk_buff
*skb
, struct net_device
*dev
)
920 struct ctcm_priv
*priv
= dev
->ml_priv
;
921 struct mpc_group
*grp
= priv
->mpcg
;
922 struct sk_buff
*newskb
= NULL
;
925 * Some sanity checks ...
928 CTCM_DBF_TEXT_(MPC_ERROR
, CTC_DBF_ERROR
,
929 "%s(%s): NULL sk_buff passed",
930 CTCM_FUNTAIL
, dev
->name
);
931 priv
->stats
.tx_dropped
++;
934 if (skb_headroom(skb
) < (TH_HEADER_LENGTH
+ PDU_HEADER_LENGTH
)) {
935 CTCM_DBF_TEXT_(MPC_TRACE
, CTC_DBF_ERROR
,
936 "%s(%s): Got sk_buff with head room < %ld bytes",
937 CTCM_FUNTAIL
, dev
->name
,
938 TH_HEADER_LENGTH
+ PDU_HEADER_LENGTH
);
940 CTCM_D3_DUMP((char *)skb
->data
, min_t(int, 32, skb
->len
));
942 len
= skb
->len
+ TH_HEADER_LENGTH
+ PDU_HEADER_LENGTH
;
943 newskb
= __dev_alloc_skb(len
, gfp_type() | GFP_DMA
);
946 CTCM_DBF_TEXT_(MPC_TRACE
, CTC_DBF_ERROR
,
947 "%s: %s: __dev_alloc_skb failed",
948 __func__
, dev
->name
);
950 dev_kfree_skb_any(skb
);
951 priv
->stats
.tx_dropped
++;
952 priv
->stats
.tx_errors
++;
953 priv
->stats
.tx_carrier_errors
++;
954 fsm_event(grp
->fsm
, MPCG_EVENT_INOP
, dev
);
957 newskb
->protocol
= skb
->protocol
;
958 skb_reserve(newskb
, TH_HEADER_LENGTH
+ PDU_HEADER_LENGTH
);
959 memcpy(skb_put(newskb
, skb
->len
), skb
->data
, skb
->len
);
960 dev_kfree_skb_any(skb
);
965 * If channels are not running,
966 * notify anybody about a link failure and throw
969 if ((fsm_getstate(priv
->fsm
) != DEV_STATE_RUNNING
) ||
970 (fsm_getstate(grp
->fsm
) < MPCG_STATE_XID2INITW
)) {
971 dev_kfree_skb_any(skb
);
972 CTCM_DBF_TEXT_(MPC_ERROR
, CTC_DBF_ERROR
,
973 "%s(%s): inactive MPCGROUP - dropped",
974 CTCM_FUNTAIL
, dev
->name
);
975 priv
->stats
.tx_dropped
++;
976 priv
->stats
.tx_errors
++;
977 priv
->stats
.tx_carrier_errors
++;
981 if (ctcm_test_and_set_busy(dev
)) {
982 CTCM_DBF_TEXT_(MPC_ERROR
, CTC_DBF_ERROR
,
983 "%s(%s): device busy - dropped",
984 CTCM_FUNTAIL
, dev
->name
);
985 dev_kfree_skb_any(skb
);
986 priv
->stats
.tx_dropped
++;
987 priv
->stats
.tx_errors
++;
988 priv
->stats
.tx_carrier_errors
++;
989 fsm_event(grp
->fsm
, MPCG_EVENT_INOP
, dev
);
993 dev
->trans_start
= jiffies
;
994 if (ctcmpc_transmit_skb(priv
->channel
[WRITE
], skb
) != 0) {
995 CTCM_DBF_TEXT_(MPC_ERROR
, CTC_DBF_ERROR
,
996 "%s(%s): device error - dropped",
997 CTCM_FUNTAIL
, dev
->name
);
998 dev_kfree_skb_any(skb
);
999 priv
->stats
.tx_dropped
++;
1000 priv
->stats
.tx_errors
++;
1001 priv
->stats
.tx_carrier_errors
++;
1002 ctcm_clear_busy(dev
);
1003 fsm_event(grp
->fsm
, MPCG_EVENT_INOP
, dev
);
1006 ctcm_clear_busy(dev
);
1009 MPC_DBF_DEV_NAME(TRACE
, dev
, "exit");
1011 return 0; /* handle freeing of skb here */
1016 * Sets MTU of an interface.
1018 * dev Pointer to interface struct.
1019 * new_mtu The new MTU to use for this interface.
1021 * returns 0 on success, -EINVAL if MTU is out of valid range.
1022 * (valid range is 576 .. 65527). If VM is on the
1023 * remote side, maximum MTU is 32760, however this is
1026 static int ctcm_change_mtu(struct net_device
*dev
, int new_mtu
)
1028 struct ctcm_priv
*priv
;
1031 if (new_mtu
< 576 || new_mtu
> 65527)
1034 priv
= dev
->ml_priv
;
1035 max_bufsize
= priv
->channel
[READ
]->max_bufsize
;
1038 if (new_mtu
> max_bufsize
- TH_HEADER_LENGTH
)
1040 dev
->hard_header_len
= TH_HEADER_LENGTH
+ PDU_HEADER_LENGTH
;
1042 if (new_mtu
> max_bufsize
- LL_HEADER_LENGTH
- 2)
1044 dev
->hard_header_len
= LL_HEADER_LENGTH
+ 2;
1051 * Returns interface statistics of a device.
1053 * dev Pointer to interface struct.
1055 * returns Pointer to stats struct of this interface.
1057 static struct net_device_stats
*ctcm_stats(struct net_device
*dev
)
1059 return &((struct ctcm_priv
*)dev
->ml_priv
)->stats
;
1062 static void ctcm_free_netdevice(struct net_device
*dev
)
1064 struct ctcm_priv
*priv
;
1065 struct mpc_group
*grp
;
1067 CTCM_DBF_TEXT_(SETUP
, CTC_DBF_INFO
,
1068 "%s(%s)", CTCM_FUNTAIL
, dev
->name
);
1069 priv
= dev
->ml_priv
;
1074 kfree_fsm(grp
->fsm
);
1076 dev_kfree_skb(grp
->xid_skb
);
1077 if (grp
->rcvd_xid_skb
)
1078 dev_kfree_skb(grp
->rcvd_xid_skb
);
1079 tasklet_kill(&grp
->mpc_tasklet2
);
1084 kfree_fsm(priv
->fsm
);
1090 * Note: kfree(priv); is done in "opposite" function of
1091 * allocator function probe_device which is remove_device.
1099 struct mpc_group
*ctcmpc_init_mpc_group(struct ctcm_priv
*priv
);
1101 static const struct net_device_ops ctcm_netdev_ops
= {
1102 .ndo_open
= ctcm_open
,
1103 .ndo_stop
= ctcm_close
,
1104 .ndo_get_stats
= ctcm_stats
,
1105 .ndo_change_mtu
= ctcm_change_mtu
,
1106 .ndo_start_xmit
= ctcm_tx
,
1109 static const struct net_device_ops ctcm_mpc_netdev_ops
= {
1110 .ndo_open
= ctcm_open
,
1111 .ndo_stop
= ctcm_close
,
1112 .ndo_get_stats
= ctcm_stats
,
1113 .ndo_change_mtu
= ctcm_change_mtu
,
1114 .ndo_start_xmit
= ctcmpc_tx
,
1117 void static ctcm_dev_setup(struct net_device
*dev
)
1119 dev
->type
= ARPHRD_SLIP
;
1120 dev
->tx_queue_len
= 100;
1121 dev
->flags
= IFF_POINTOPOINT
| IFF_NOARP
;
1125 * Initialize everything of the net device except the name and the
1128 static struct net_device
*ctcm_init_netdevice(struct ctcm_priv
*priv
)
1130 struct net_device
*dev
;
1131 struct mpc_group
*grp
;
1136 dev
= alloc_netdev(0, MPC_DEVICE_GENE
, ctcm_dev_setup
);
1138 dev
= alloc_netdev(0, CTC_DEVICE_GENE
, ctcm_dev_setup
);
1141 CTCM_DBF_TEXT_(ERROR
, CTC_DBF_CRIT
,
1142 "%s: MEMORY allocation ERROR",
1146 dev
->ml_priv
= priv
;
1147 priv
->fsm
= init_fsm("ctcmdev", dev_state_names
, dev_event_names
,
1148 CTCM_NR_DEV_STATES
, CTCM_NR_DEV_EVENTS
,
1149 dev_fsm
, dev_fsm_len
, GFP_KERNEL
);
1150 if (priv
->fsm
== NULL
) {
1151 CTCMY_DBF_DEV(SETUP
, dev
, "init_fsm error");
1155 fsm_newstate(priv
->fsm
, DEV_STATE_STOPPED
);
1156 fsm_settimer(priv
->fsm
, &priv
->restart_timer
);
1159 /* MPC Group Initializations */
1160 grp
= ctcmpc_init_mpc_group(priv
);
1162 MPC_DBF_DEV(SETUP
, dev
, "init_mpc_group error");
1166 tasklet_init(&grp
->mpc_tasklet2
,
1167 mpc_group_ready
, (unsigned long)dev
);
1168 dev
->mtu
= MPC_BUFSIZE_DEFAULT
-
1169 TH_HEADER_LENGTH
- PDU_HEADER_LENGTH
;
1171 dev
->netdev_ops
= &ctcm_mpc_netdev_ops
;
1172 dev
->hard_header_len
= TH_HEADER_LENGTH
+ PDU_HEADER_LENGTH
;
1173 priv
->buffer_size
= MPC_BUFSIZE_DEFAULT
;
1175 dev
->mtu
= CTCM_BUFSIZE_DEFAULT
- LL_HEADER_LENGTH
- 2;
1176 dev
->netdev_ops
= &ctcm_netdev_ops
;
1177 dev
->hard_header_len
= LL_HEADER_LENGTH
+ 2;
1180 CTCMY_DBF_DEV(SETUP
, dev
, "finished");
1188 * cdev The ccw_device the interrupt is for.
1189 * intparm interruption parameter.
1190 * irb interruption response block.
1192 static void ctcm_irq_handler(struct ccw_device
*cdev
,
1193 unsigned long intparm
, struct irb
*irb
)
1196 struct net_device
*dev
;
1197 struct ctcm_priv
*priv
;
1198 struct ccwgroup_device
*cgdev
;
1202 CTCM_DBF_TEXT_(TRACE
, CTC_DBF_DEBUG
,
1203 "Enter %s(%s)", CTCM_FUNTAIL
, dev_name(&cdev
->dev
));
1205 if (ctcm_check_irb_error(cdev
, irb
))
1208 cgdev
= dev_get_drvdata(&cdev
->dev
);
1210 cstat
= irb
->scsw
.cmd
.cstat
;
1211 dstat
= irb
->scsw
.cmd
.dstat
;
1213 /* Check for unsolicited interrupts. */
1214 if (cgdev
== NULL
) {
1215 CTCM_DBF_TEXT_(TRACE
, CTC_DBF_ERROR
,
1216 "%s(%s) unsolicited irq: c-%02x d-%02x\n",
1217 CTCM_FUNTAIL
, dev_name(&cdev
->dev
), cstat
, dstat
);
1218 dev_warn(&cdev
->dev
,
1219 "The adapter received a non-specific IRQ\n");
1223 priv
= dev_get_drvdata(&cgdev
->dev
);
1225 /* Try to extract channel from driver data. */
1226 if (priv
->channel
[READ
]->cdev
== cdev
)
1227 ch
= priv
->channel
[READ
];
1228 else if (priv
->channel
[WRITE
]->cdev
== cdev
)
1229 ch
= priv
->channel
[WRITE
];
1232 "%s: Internal error: Can't determine channel for "
1233 "interrupt device %s\n",
1234 __func__
, dev_name(&cdev
->dev
));
1235 /* Explain: inconsistent internal structures */
1242 "%s Internal error: net_device is NULL, ch = 0x%p\n",
1244 /* Explain: inconsistent internal structures */
1248 /* Copy interruption response block. */
1249 memcpy(ch
->irb
, irb
, sizeof(struct irb
));
1251 /* Issue error message and return on subchannel error code */
1252 if (irb
->scsw
.cmd
.cstat
) {
1253 fsm_event(ch
->fsm
, CTC_EVENT_SC_UNKNOWN
, ch
);
1254 CTCM_DBF_TEXT_(TRACE
, CTC_DBF_WARN
,
1255 "%s(%s): sub-ch check %s: cs=%02x ds=%02x",
1256 CTCM_FUNTAIL
, dev
->name
, ch
->id
, cstat
, dstat
);
1257 dev_warn(&cdev
->dev
,
1258 "A check occurred on the subchannel\n");
1262 /* Check the reason-code of a unit check */
1263 if (irb
->scsw
.cmd
.dstat
& DEV_STAT_UNIT_CHECK
) {
1264 if ((irb
->ecw
[0] & ch
->sense_rc
) == 0)
1265 /* print it only once */
1266 CTCM_DBF_TEXT_(TRACE
, CTC_DBF_WARN
,
1267 "%s(%s): sense=%02x, ds=%02x",
1268 CTCM_FUNTAIL
, ch
->id
, irb
->ecw
[0], dstat
);
1269 ccw_unit_check(ch
, irb
->ecw
[0]);
1272 if (irb
->scsw
.cmd
.dstat
& DEV_STAT_BUSY
) {
1273 if (irb
->scsw
.cmd
.dstat
& DEV_STAT_ATTENTION
)
1274 fsm_event(ch
->fsm
, CTC_EVENT_ATTNBUSY
, ch
);
1276 fsm_event(ch
->fsm
, CTC_EVENT_BUSY
, ch
);
1279 if (irb
->scsw
.cmd
.dstat
& DEV_STAT_ATTENTION
) {
1280 fsm_event(ch
->fsm
, CTC_EVENT_ATTN
, ch
);
1283 if ((irb
->scsw
.cmd
.stctl
& SCSW_STCTL_SEC_STATUS
) ||
1284 (irb
->scsw
.cmd
.stctl
== SCSW_STCTL_STATUS_PEND
) ||
1285 (irb
->scsw
.cmd
.stctl
==
1286 (SCSW_STCTL_ALERT_STATUS
| SCSW_STCTL_STATUS_PEND
)))
1287 fsm_event(ch
->fsm
, CTC_EVENT_FINSTAT
, ch
);
1289 fsm_event(ch
->fsm
, CTC_EVENT_IRQ
, ch
);
1294 * Add ctcm specific attributes.
1295 * Add ctcm private data.
1297 * cgdev pointer to ccwgroup_device just added
1299 * returns 0 on success, !0 on failure.
1301 static int ctcm_probe_device(struct ccwgroup_device
*cgdev
)
1303 struct ctcm_priv
*priv
;
1306 CTCM_DBF_TEXT_(SETUP
, CTC_DBF_INFO
,
1310 if (!get_device(&cgdev
->dev
))
1313 priv
= kzalloc(sizeof(struct ctcm_priv
), GFP_KERNEL
);
1315 CTCM_DBF_TEXT_(ERROR
, CTC_DBF_ERROR
,
1316 "%s: memory allocation failure",
1318 put_device(&cgdev
->dev
);
1322 rc
= ctcm_add_files(&cgdev
->dev
);
1325 put_device(&cgdev
->dev
);
1328 priv
->buffer_size
= CTCM_BUFSIZE_DEFAULT
;
1329 cgdev
->cdev
[0]->handler
= ctcm_irq_handler
;
1330 cgdev
->cdev
[1]->handler
= ctcm_irq_handler
;
1331 dev_set_drvdata(&cgdev
->dev
, priv
);
1337 * Add a new channel to the list of channels.
1338 * Keeps the channel list sorted.
1340 * cdev The ccw_device to be added.
1341 * type The type class of the new channel.
1342 * priv Points to the private data of the ccwgroup_device.
1344 * returns 0 on success, !0 on error.
1346 static int add_channel(struct ccw_device
*cdev
, enum channel_types type
,
1347 struct ctcm_priv
*priv
)
1349 struct channel
**c
= &channels
;
1354 CTCM_DBF_TEXT_(SETUP
, CTC_DBF_INFO
,
1355 "%s(%s), type %d, proto %d",
1356 __func__
, dev_name(&cdev
->dev
), type
, priv
->protocol
);
1358 ch
= kzalloc(sizeof(struct channel
), GFP_KERNEL
);
1362 ch
->protocol
= priv
->protocol
;
1364 ch
->discontact_th
= (struct th_header
*)
1365 kzalloc(TH_HEADER_LENGTH
, gfp_type());
1366 if (ch
->discontact_th
== NULL
)
1369 ch
->discontact_th
->th_blk_flag
= TH_DISCONTACT
;
1370 tasklet_init(&ch
->ch_disc_tasklet
,
1371 mpc_action_send_discontact
, (unsigned long)ch
);
1373 tasklet_init(&ch
->ch_tasklet
, ctcmpc_bh
, (unsigned long)ch
);
1374 ch
->max_bufsize
= (MPC_BUFSIZE_DEFAULT
- 35);
1379 ch
->ccw
= (struct ccw1
*)
1380 kzalloc(ccw_num
* sizeof(struct ccw1
), GFP_KERNEL
| GFP_DMA
);
1381 if (ch
->ccw
== NULL
)
1385 snprintf(ch
->id
, CTCM_ID_SIZE
, "ch-%s", dev_name(&cdev
->dev
));
1389 * "static" ccws are used in the following way:
1391 * ccw[0..2] (Channel program for generic I/O):
1393 * 1: read or write (depending on direction) with fixed
1394 * buffer (idal allocated once when buffer is allocated)
1396 * ccw[3..5] (Channel program for direct write of packets)
1398 * 4: write (idal allocated on every write).
1400 * ccw[6..7] (Channel program for initial channel setup):
1401 * 6: set extended mode
1404 * ch->ccw[0..5] are initialized in ch_action_start because
1405 * the channel's direction is yet unknown here.
1407 * ccws used for xid2 negotiations
1408 * ch-ccw[8-14] need to be used for the XID exchange either
1409 * X side XID2 Processing
1413 * 11: read th from secondary
1414 * 12: read XID from secondary
1415 * 13: read 4 byte ID
1417 * Y side XID Processing
1423 * 13: write 4 byte ID
1426 * ccws used for double noop due to VM timing issues
1427 * which result in unrecoverable Busy on channel
1431 ch
->ccw
[6].cmd_code
= CCW_CMD_SET_EXTENDED
;
1432 ch
->ccw
[6].flags
= CCW_FLAG_SLI
;
1434 ch
->ccw
[7].cmd_code
= CCW_CMD_NOOP
;
1435 ch
->ccw
[7].flags
= CCW_FLAG_SLI
;
1438 ch
->ccw
[15].cmd_code
= CCW_CMD_WRITE
;
1439 ch
->ccw
[15].flags
= CCW_FLAG_SLI
| CCW_FLAG_CC
;
1440 ch
->ccw
[15].count
= TH_HEADER_LENGTH
;
1441 ch
->ccw
[15].cda
= virt_to_phys(ch
->discontact_th
);
1443 ch
->ccw
[16].cmd_code
= CCW_CMD_NOOP
;
1444 ch
->ccw
[16].flags
= CCW_FLAG_SLI
;
1446 ch
->fsm
= init_fsm(ch
->id
, ctc_ch_state_names
,
1447 ctc_ch_event_names
, CTC_MPC_NR_STATES
,
1448 CTC_MPC_NR_EVENTS
, ctcmpc_ch_fsm
,
1449 mpc_ch_fsm_len
, GFP_KERNEL
);
1451 ch
->fsm
= init_fsm(ch
->id
, ctc_ch_state_names
,
1452 ctc_ch_event_names
, CTC_NR_STATES
,
1453 CTC_NR_EVENTS
, ch_fsm
,
1454 ch_fsm_len
, GFP_KERNEL
);
1456 if (ch
->fsm
== NULL
)
1459 fsm_newstate(ch
->fsm
, CTC_STATE_IDLE
);
1461 ch
->irb
= kzalloc(sizeof(struct irb
), GFP_KERNEL
);
1462 if (ch
->irb
== NULL
)
1465 while (*c
&& ctcm_less_than((*c
)->id
, ch
->id
))
1468 if (*c
&& (!strncmp((*c
)->id
, ch
->id
, CTCM_ID_SIZE
))) {
1469 CTCM_DBF_TEXT_(SETUP
, CTC_DBF_INFO
,
1470 "%s (%s) already in list, using old entry",
1471 __func__
, (*c
)->id
);
1476 spin_lock_init(&ch
->collect_lock
);
1478 fsm_settimer(ch
->fsm
, &ch
->timer
);
1479 skb_queue_head_init(&ch
->io_queue
);
1480 skb_queue_head_init(&ch
->collect_queue
);
1483 fsm_settimer(ch
->fsm
, &ch
->sweep_timer
);
1484 skb_queue_head_init(&ch
->sweep_queue
);
1493 free_return
: /* note that all channel pointers are 0 or valid */
1495 kfree(ch
->discontact_th
);
1503 * Return type of a detected device.
1505 static enum channel_types
get_channel_type(struct ccw_device_id
*id
)
1507 enum channel_types type
;
1508 type
= (enum channel_types
)id
->driver_info
;
1510 if (type
== channel_type_ficon
)
1511 type
= channel_type_escon
;
1518 * Setup an interface.
1520 * cgdev Device to be setup.
1522 * returns 0 on success, !0 on failure.
1524 static int ctcm_new_device(struct ccwgroup_device
*cgdev
)
1526 char read_id
[CTCM_ID_SIZE
];
1527 char write_id
[CTCM_ID_SIZE
];
1529 enum channel_types type
;
1530 struct ctcm_priv
*priv
;
1531 struct net_device
*dev
;
1532 struct ccw_device
*cdev0
;
1533 struct ccw_device
*cdev1
;
1536 priv
= dev_get_drvdata(&cgdev
->dev
);
1540 cdev0
= cgdev
->cdev
[0];
1541 cdev1
= cgdev
->cdev
[1];
1543 type
= get_channel_type(&cdev0
->id
);
1545 snprintf(read_id
, CTCM_ID_SIZE
, "ch-%s", dev_name(&cdev0
->dev
));
1546 snprintf(write_id
, CTCM_ID_SIZE
, "ch-%s", dev_name(&cdev1
->dev
));
1548 ret
= add_channel(cdev0
, type
, priv
);
1551 ret
= add_channel(cdev1
, type
, priv
);
1555 ret
= ccw_device_set_online(cdev0
);
1557 /* may be ok to fail now - can be done later */
1558 CTCM_DBF_TEXT_(TRACE
, CTC_DBF_NOTICE
,
1559 "%s(%s) set_online rc=%d",
1560 CTCM_FUNTAIL
, read_id
, ret
);
1563 ret
= ccw_device_set_online(cdev1
);
1565 /* may be ok to fail now - can be done later */
1566 CTCM_DBF_TEXT_(TRACE
, CTC_DBF_NOTICE
,
1567 "%s(%s) set_online rc=%d",
1568 CTCM_FUNTAIL
, write_id
, ret
);
1571 dev
= ctcm_init_netdevice(priv
);
1575 for (direction
= READ
; direction
<= WRITE
; direction
++) {
1576 priv
->channel
[direction
] =
1577 channel_get(type
, direction
== READ
? read_id
: write_id
,
1579 if (priv
->channel
[direction
] == NULL
) {
1580 if (direction
== WRITE
)
1581 channel_free(priv
->channel
[READ
]);
1584 priv
->channel
[direction
]->netdev
= dev
;
1585 priv
->channel
[direction
]->protocol
= priv
->protocol
;
1586 priv
->channel
[direction
]->max_bufsize
= priv
->buffer_size
;
1589 SET_NETDEV_DEV(dev
, &cgdev
->dev
);
1591 if (register_netdev(dev
))
1594 if (ctcm_add_attributes(&cgdev
->dev
)) {
1595 unregister_netdev(dev
);
1599 strlcpy(priv
->fsm
->name
, dev
->name
, sizeof(priv
->fsm
->name
));
1602 "setup OK : r/w = %s/%s, protocol : %d\n",
1603 priv
->channel
[READ
]->id
,
1604 priv
->channel
[WRITE
]->id
, priv
->protocol
);
1606 CTCM_DBF_TEXT_(SETUP
, CTC_DBF_INFO
,
1607 "setup(%s) OK : r/w = %s/%s, protocol : %d", dev
->name
,
1608 priv
->channel
[READ
]->id
,
1609 priv
->channel
[WRITE
]->id
, priv
->protocol
);
1613 ctcm_free_netdevice(dev
);
1615 ccw_device_set_offline(cgdev
->cdev
[1]);
1616 ccw_device_set_offline(cgdev
->cdev
[0]);
1622 * Shutdown an interface.
1624 * cgdev Device to be shut down.
1626 * returns 0 on success, !0 on failure.
1628 static int ctcm_shutdown_device(struct ccwgroup_device
*cgdev
)
1630 struct ctcm_priv
*priv
;
1631 struct net_device
*dev
;
1633 priv
= dev_get_drvdata(&cgdev
->dev
);
1637 if (priv
->channel
[READ
]) {
1638 dev
= priv
->channel
[READ
]->netdev
;
1639 CTCM_DBF_DEV(SETUP
, dev
, "");
1640 /* Close the device */
1642 dev
->flags
&= ~IFF_RUNNING
;
1643 ctcm_remove_attributes(&cgdev
->dev
);
1644 channel_free(priv
->channel
[READ
]);
1648 if (priv
->channel
[WRITE
])
1649 channel_free(priv
->channel
[WRITE
]);
1652 unregister_netdev(dev
);
1653 ctcm_free_netdevice(dev
);
1657 kfree_fsm(priv
->fsm
);
1659 ccw_device_set_offline(cgdev
->cdev
[1]);
1660 ccw_device_set_offline(cgdev
->cdev
[0]);
1662 if (priv
->channel
[READ
])
1663 channel_remove(priv
->channel
[READ
]);
1664 if (priv
->channel
[WRITE
])
1665 channel_remove(priv
->channel
[WRITE
]);
1666 priv
->channel
[READ
] = priv
->channel
[WRITE
] = NULL
;
1673 static void ctcm_remove_device(struct ccwgroup_device
*cgdev
)
1675 struct ctcm_priv
*priv
= dev_get_drvdata(&cgdev
->dev
);
1677 BUG_ON(priv
== NULL
);
1679 CTCM_DBF_TEXT_(SETUP
, CTC_DBF_INFO
,
1680 "removing device %p, proto : %d",
1681 cgdev
, priv
->protocol
);
1683 if (cgdev
->state
== CCWGROUP_ONLINE
)
1684 ctcm_shutdown_device(cgdev
);
1685 ctcm_remove_files(&cgdev
->dev
);
1686 dev_set_drvdata(&cgdev
->dev
, NULL
);
1688 put_device(&cgdev
->dev
);
1691 static int ctcm_pm_suspend(struct ccwgroup_device
*gdev
)
1693 struct ctcm_priv
*priv
= dev_get_drvdata(&gdev
->dev
);
1695 if (gdev
->state
== CCWGROUP_OFFLINE
)
1697 netif_device_detach(priv
->channel
[READ
]->netdev
);
1698 ctcm_close(priv
->channel
[READ
]->netdev
);
1699 ccw_device_set_offline(gdev
->cdev
[1]);
1700 ccw_device_set_offline(gdev
->cdev
[0]);
1704 static int ctcm_pm_resume(struct ccwgroup_device
*gdev
)
1706 struct ctcm_priv
*priv
= dev_get_drvdata(&gdev
->dev
);
1709 if (gdev
->state
== CCWGROUP_OFFLINE
)
1711 rc
= ccw_device_set_online(gdev
->cdev
[1]);
1714 rc
= ccw_device_set_online(gdev
->cdev
[0]);
1717 ctcm_open(priv
->channel
[READ
]->netdev
);
1719 netif_device_attach(priv
->channel
[READ
]->netdev
);
1723 static struct ccwgroup_driver ctcm_group_driver
= {
1724 .owner
= THIS_MODULE
,
1725 .name
= CTC_DRIVER_NAME
,
1727 .driver_id
= 0xC3E3C3D4, /* CTCM */
1728 .probe
= ctcm_probe_device
,
1729 .remove
= ctcm_remove_device
,
1730 .set_online
= ctcm_new_device
,
1731 .set_offline
= ctcm_shutdown_device
,
1732 .freeze
= ctcm_pm_suspend
,
1733 .thaw
= ctcm_pm_resume
,
1734 .restore
= ctcm_pm_resume
,
1739 * Module related routines
1743 * Prepare to be unloaded. Free IRQ's and release all resources.
1744 * This is called just before this module is unloaded. It is
1745 * not called, if the usage count is !0, so we don't need to check
1748 static void __exit
ctcm_exit(void)
1750 unregister_cu3088_discipline(&ctcm_group_driver
);
1751 ctcm_unregister_dbf_views();
1752 pr_info("CTCM driver unloaded\n");
1758 static void print_banner(void)
1760 pr_info("CTCM driver initialized\n");
1764 * Initialize module.
1765 * This is called just after the module is loaded.
1767 * returns 0 on success, !0 on error.
1769 static int __init
ctcm_init(void)
1775 ret
= ctcm_register_dbf_views();
1779 ret
= register_cu3088_discipline(&ctcm_group_driver
);
1781 ctcm_unregister_dbf_views();
1782 pr_err("%s / register_cu3088_discipline failed, ret = %d\n",
1790 module_init(ctcm_init
);
1791 module_exit(ctcm_exit
);
1793 MODULE_AUTHOR("Peter Tiedemann <ptiedem@de.ibm.com>");
1794 MODULE_DESCRIPTION("Network driver for S/390 CTC + CTCMPC (SNA)");
1795 MODULE_LICENSE("GPL");