xref: /openbmc/linux/drivers/s390/net/ctcm_main.c (revision 22246614)
1 /*
2  * drivers/s390/net/ctcm_main.c
3  *
4  * Copyright IBM Corp. 2001, 2007
5  * Author(s):
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>
13  *	MPC additions:
14  *		Belinda Thompson (belindat@us.ibm.com)
15  *		Andy Richter (richtera@us.ibm.com)
16  *	Revived by:
17  *		Peter Tiedemann (ptiedem@de.ibm.com)
18  */
19 
20 #undef DEBUG
21 #undef DEBUGDATA
22 #undef DEBUGCCW
23 
24 #include <linux/module.h>
25 #include <linux/init.h>
26 #include <linux/kernel.h>
27 #include <linux/slab.h>
28 #include <linux/errno.h>
29 #include <linux/types.h>
30 #include <linux/interrupt.h>
31 #include <linux/timer.h>
32 #include <linux/bitops.h>
33 
34 #include <linux/signal.h>
35 #include <linux/string.h>
36 
37 #include <linux/ip.h>
38 #include <linux/if_arp.h>
39 #include <linux/tcp.h>
40 #include <linux/skbuff.h>
41 #include <linux/ctype.h>
42 #include <net/dst.h>
43 
44 #include <linux/io.h>
45 #include <asm/ccwdev.h>
46 #include <asm/ccwgroup.h>
47 #include <linux/uaccess.h>
48 
49 #include <asm/idals.h>
50 
51 #include "cu3088.h"
52 #include "ctcm_fsms.h"
53 #include "ctcm_main.h"
54 
55 /* Some common global variables */
56 
57 /*
58  * Linked list of all detected channels.
59  */
60 struct channel *channels;
61 
62 /**
63  * Unpack a just received skb and hand it over to
64  * upper layers.
65  *
66  *  ch		The channel where this skb has been received.
67  *  pskb	The received skb.
68  */
69 void ctcm_unpack_skb(struct channel *ch, struct sk_buff *pskb)
70 {
71 	struct net_device *dev = ch->netdev;
72 	struct ctcm_priv *priv = dev->priv;
73 	__u16 len = *((__u16 *) pskb->data);
74 
75 	skb_put(pskb, 2 + LL_HEADER_LENGTH);
76 	skb_pull(pskb, 2);
77 	pskb->dev = dev;
78 	pskb->ip_summed = CHECKSUM_UNNECESSARY;
79 	while (len > 0) {
80 		struct sk_buff *skb;
81 		int skblen;
82 		struct ll_header *header = (struct ll_header *)pskb->data;
83 
84 		skb_pull(pskb, LL_HEADER_LENGTH);
85 		if ((ch->protocol == CTCM_PROTO_S390) &&
86 		    (header->type != ETH_P_IP)) {
87 
88 			if (!(ch->logflags & LOG_FLAG_ILLEGALPKT)) {
89 				/*
90 				 * Check packet type only if we stick strictly
91 				 * to S/390's protocol of OS390. This only
92 				 * supports IP. Otherwise allow any packet
93 				 * type.
94 				 */
95 				ctcm_pr_warn("%s Illegal packet type 0x%04x "
96 						"received, dropping\n",
97 						dev->name, header->type);
98 				ch->logflags |= LOG_FLAG_ILLEGALPKT;
99 			}
100 
101 			priv->stats.rx_dropped++;
102 			priv->stats.rx_frame_errors++;
103 			return;
104 		}
105 		pskb->protocol = ntohs(header->type);
106 		if (header->length <= LL_HEADER_LENGTH) {
107 			if (!(ch->logflags & LOG_FLAG_ILLEGALSIZE)) {
108 				ctcm_pr_warn(
109 					"%s Illegal packet size %d "
110 					"received (MTU=%d blocklen=%d), "
111 					"dropping\n", dev->name, header->length,
112 					dev->mtu, len);
113 				ch->logflags |= LOG_FLAG_ILLEGALSIZE;
114 			}
115 
116 			priv->stats.rx_dropped++;
117 			priv->stats.rx_length_errors++;
118 			return;
119 		}
120 		header->length -= LL_HEADER_LENGTH;
121 		len -= LL_HEADER_LENGTH;
122 		if ((header->length > skb_tailroom(pskb)) ||
123 			(header->length > len)) {
124 			if (!(ch->logflags & LOG_FLAG_OVERRUN)) {
125 				ctcm_pr_warn(
126 					"%s Illegal packet size %d (beyond the"
127 					" end of received data), dropping\n",
128 					dev->name, header->length);
129 				ch->logflags |= LOG_FLAG_OVERRUN;
130 			}
131 
132 			priv->stats.rx_dropped++;
133 			priv->stats.rx_length_errors++;
134 			return;
135 		}
136 		skb_put(pskb, header->length);
137 		skb_reset_mac_header(pskb);
138 		len -= header->length;
139 		skb = dev_alloc_skb(pskb->len);
140 		if (!skb) {
141 			if (!(ch->logflags & LOG_FLAG_NOMEM)) {
142 				ctcm_pr_warn(
143 					"%s Out of memory in ctcm_unpack_skb\n",
144 					dev->name);
145 				ch->logflags |= LOG_FLAG_NOMEM;
146 			}
147 			priv->stats.rx_dropped++;
148 			return;
149 		}
150 		skb_copy_from_linear_data(pskb, skb_put(skb, pskb->len),
151 					  pskb->len);
152 		skb_reset_mac_header(skb);
153 		skb->dev = pskb->dev;
154 		skb->protocol = pskb->protocol;
155 		pskb->ip_summed = CHECKSUM_UNNECESSARY;
156 		skblen = skb->len;
157 		/*
158 		 * reset logflags
159 		 */
160 		ch->logflags = 0;
161 		priv->stats.rx_packets++;
162 		priv->stats.rx_bytes += skblen;
163 		netif_rx_ni(skb);
164 		dev->last_rx = jiffies;
165 		if (len > 0) {
166 			skb_pull(pskb, header->length);
167 			if (skb_tailroom(pskb) < LL_HEADER_LENGTH) {
168 				if (!(ch->logflags & LOG_FLAG_OVERRUN)) {
169 					CTCM_DBF_DEV_NAME(TRACE, dev,
170 						"Overrun in ctcm_unpack_skb");
171 					ch->logflags |= LOG_FLAG_OVERRUN;
172 				}
173 				return;
174 			}
175 			skb_put(pskb, LL_HEADER_LENGTH);
176 		}
177 	}
178 }
179 
180 /**
181  * Release a specific channel in the channel list.
182  *
183  *  ch		Pointer to channel struct to be released.
184  */
185 static void channel_free(struct channel *ch)
186 {
187 	CTCM_DBF_TEXT(TRACE, 2, __FUNCTION__);
188 	ch->flags &= ~CHANNEL_FLAGS_INUSE;
189 	fsm_newstate(ch->fsm, CTC_STATE_IDLE);
190 }
191 
192 /**
193  * Remove a specific channel in the channel list.
194  *
195  *  ch		Pointer to channel struct to be released.
196  */
197 static void channel_remove(struct channel *ch)
198 {
199 	struct channel **c = &channels;
200 	char chid[CTCM_ID_SIZE+1];
201 	int ok = 0;
202 
203 	if (ch == NULL)
204 		return;
205 	else
206 		strncpy(chid, ch->id, CTCM_ID_SIZE);
207 
208 	channel_free(ch);
209 	while (*c) {
210 		if (*c == ch) {
211 			*c = ch->next;
212 			fsm_deltimer(&ch->timer);
213 			if (IS_MPC(ch))
214 				fsm_deltimer(&ch->sweep_timer);
215 
216 			kfree_fsm(ch->fsm);
217 			clear_normalized_cda(&ch->ccw[4]);
218 			if (ch->trans_skb != NULL) {
219 				clear_normalized_cda(&ch->ccw[1]);
220 				dev_kfree_skb_any(ch->trans_skb);
221 			}
222 			if (IS_MPC(ch)) {
223 				tasklet_kill(&ch->ch_tasklet);
224 				tasklet_kill(&ch->ch_disc_tasklet);
225 				kfree(ch->discontact_th);
226 			}
227 			kfree(ch->ccw);
228 			kfree(ch->irb);
229 			kfree(ch);
230 			ok = 1;
231 			break;
232 		}
233 		c = &((*c)->next);
234 	}
235 
236 	CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO, "%s(%s) %s", CTCM_FUNTAIL,
237 			chid, ok ? "OK" : "failed");
238 }
239 
240 /**
241  * Get a specific channel from the channel list.
242  *
243  *  type	Type of channel we are interested in.
244  *  id		Id of channel we are interested in.
245  *  direction	Direction we want to use this channel for.
246  *
247  * returns Pointer to a channel or NULL if no matching channel available.
248  */
249 static struct channel *channel_get(enum channel_types type,
250 					char *id, int direction)
251 {
252 	struct channel *ch = channels;
253 
254 	if (do_debug) {
255 		char buf[64];
256 		sprintf(buf, "%s(%d, %s, %d)\n",
257 				CTCM_FUNTAIL, type, id, direction);
258 		CTCM_DBF_TEXT(TRACE, CTC_DBF_INFO, buf);
259 	}
260 	while (ch && (strncmp(ch->id, id, CTCM_ID_SIZE) || (ch->type != type)))
261 		ch = ch->next;
262 	if (!ch) {
263 		char buf[64];
264 		sprintf(buf, "%s(%d, %s, %d) not found in channel list\n",
265 				CTCM_FUNTAIL, type, id, direction);
266 		CTCM_DBF_TEXT(ERROR, CTC_DBF_ERROR, buf);
267 	} else {
268 		if (ch->flags & CHANNEL_FLAGS_INUSE)
269 			ch = NULL;
270 		else {
271 			ch->flags |= CHANNEL_FLAGS_INUSE;
272 			ch->flags &= ~CHANNEL_FLAGS_RWMASK;
273 			ch->flags |= (direction == WRITE)
274 			    ? CHANNEL_FLAGS_WRITE : CHANNEL_FLAGS_READ;
275 			fsm_newstate(ch->fsm, CTC_STATE_STOPPED);
276 		}
277 	}
278 	return ch;
279 }
280 
281 static long ctcm_check_irb_error(struct ccw_device *cdev, struct irb *irb)
282 {
283 	if (!IS_ERR(irb))
284 		return 0;
285 
286 	CTCM_DBF_TEXT_(ERROR, CTC_DBF_WARN, "irb error %ld on device %s\n",
287 			PTR_ERR(irb), cdev->dev.bus_id);
288 
289 	switch (PTR_ERR(irb)) {
290 	case -EIO:
291 		ctcm_pr_warn("i/o-error on device %s\n", cdev->dev.bus_id);
292 		break;
293 	case -ETIMEDOUT:
294 		ctcm_pr_warn("timeout on device %s\n", cdev->dev.bus_id);
295 		break;
296 	default:
297 		ctcm_pr_warn("unknown error %ld on device %s\n",
298 				PTR_ERR(irb), cdev->dev.bus_id);
299 	}
300 	return PTR_ERR(irb);
301 }
302 
303 
304 /**
305  * Check sense of a unit check.
306  *
307  *  ch		The channel, the sense code belongs to.
308  *  sense	The sense code to inspect.
309  */
310 static inline void ccw_unit_check(struct channel *ch, unsigned char sense)
311 {
312 	CTCM_DBF_TEXT(TRACE, 5, __FUNCTION__);
313 	if (sense & SNS0_INTERVENTION_REQ) {
314 		if (sense & 0x01) {
315 			ctcm_pr_debug("%s: Interface disc. or Sel. reset "
316 					"(remote)\n", ch->id);
317 			fsm_event(ch->fsm, CTC_EVENT_UC_RCRESET, ch);
318 		} else {
319 			ctcm_pr_debug("%s: System reset (remote)\n", ch->id);
320 			fsm_event(ch->fsm, CTC_EVENT_UC_RSRESET, ch);
321 		}
322 	} else if (sense & SNS0_EQUIPMENT_CHECK) {
323 		if (sense & SNS0_BUS_OUT_CHECK) {
324 			ctcm_pr_warn("%s: Hardware malfunction (remote)\n",
325 				ch->id);
326 			fsm_event(ch->fsm, CTC_EVENT_UC_HWFAIL, ch);
327 		} else {
328 			ctcm_pr_warn("%s: Read-data parity error (remote)\n",
329 				ch->id);
330 			fsm_event(ch->fsm, CTC_EVENT_UC_RXPARITY, ch);
331 		}
332 	} else if (sense & SNS0_BUS_OUT_CHECK) {
333 		if (sense & 0x04) {
334 			ctcm_pr_warn("%s: Data-streaming timeout)\n", ch->id);
335 			fsm_event(ch->fsm, CTC_EVENT_UC_TXTIMEOUT, ch);
336 		} else {
337 			ctcm_pr_warn("%s: Data-transfer parity error\n",
338 					ch->id);
339 			fsm_event(ch->fsm, CTC_EVENT_UC_TXPARITY, ch);
340 		}
341 	} else if (sense & SNS0_CMD_REJECT) {
342 		ctcm_pr_warn("%s: Command reject\n", ch->id);
343 	} else if (sense == 0) {
344 		ctcm_pr_debug("%s: Unit check ZERO\n", ch->id);
345 		fsm_event(ch->fsm, CTC_EVENT_UC_ZERO, ch);
346 	} else {
347 		ctcm_pr_warn("%s: Unit Check with sense code: %02x\n",
348 			    ch->id, sense);
349 		fsm_event(ch->fsm, CTC_EVENT_UC_UNKNOWN, ch);
350 	}
351 }
352 
353 int ctcm_ch_alloc_buffer(struct channel *ch)
354 {
355 	CTCM_DBF_TEXT(TRACE, 5, __FUNCTION__);
356 
357 	clear_normalized_cda(&ch->ccw[1]);
358 	ch->trans_skb = __dev_alloc_skb(ch->max_bufsize, GFP_ATOMIC | GFP_DMA);
359 	if (ch->trans_skb == NULL) {
360 		ctcm_pr_warn("%s: Couldn't alloc %s trans_skb\n",
361 			ch->id,
362 			(CHANNEL_DIRECTION(ch->flags) == READ) ? "RX" : "TX");
363 		return -ENOMEM;
364 	}
365 
366 	ch->ccw[1].count = ch->max_bufsize;
367 	if (set_normalized_cda(&ch->ccw[1], ch->trans_skb->data)) {
368 		dev_kfree_skb(ch->trans_skb);
369 		ch->trans_skb = NULL;
370 		ctcm_pr_warn("%s: set_normalized_cda for %s "
371 			"trans_skb failed, dropping packets\n",
372 			ch->id,
373 			(CHANNEL_DIRECTION(ch->flags) == READ) ? "RX" : "TX");
374 		return -ENOMEM;
375 	}
376 
377 	ch->ccw[1].count = 0;
378 	ch->trans_skb_data = ch->trans_skb->data;
379 	ch->flags &= ~CHANNEL_FLAGS_BUFSIZE_CHANGED;
380 	return 0;
381 }
382 
383 /*
384  * Interface API for upper network layers
385  */
386 
387 /**
388  * Open an interface.
389  * Called from generic network layer when ifconfig up is run.
390  *
391  *  dev		Pointer to interface struct.
392  *
393  * returns 0 on success, -ERRNO on failure. (Never fails.)
394  */
395 int ctcm_open(struct net_device *dev)
396 {
397 	struct ctcm_priv *priv = dev->priv;
398 
399 	CTCMY_DBF_DEV_NAME(SETUP, dev, "");
400 	if (!IS_MPC(priv))
401 		fsm_event(priv->fsm,	DEV_EVENT_START, dev);
402 	return 0;
403 }
404 
405 /**
406  * Close an interface.
407  * Called from generic network layer when ifconfig down is run.
408  *
409  *  dev		Pointer to interface struct.
410  *
411  * returns 0 on success, -ERRNO on failure. (Never fails.)
412  */
413 int ctcm_close(struct net_device *dev)
414 {
415 	struct ctcm_priv *priv = dev->priv;
416 
417 	CTCMY_DBF_DEV_NAME(SETUP, dev, "");
418 	if (!IS_MPC(priv))
419 		fsm_event(priv->fsm, DEV_EVENT_STOP, dev);
420 	return 0;
421 }
422 
423 
424 /**
425  * Transmit a packet.
426  * This is a helper function for ctcm_tx().
427  *
428  *  ch		Channel to be used for sending.
429  *  skb		Pointer to struct sk_buff of packet to send.
430  *            The linklevel header has already been set up
431  *            by ctcm_tx().
432  *
433  * returns 0 on success, -ERRNO on failure. (Never fails.)
434  */
435 static int ctcm_transmit_skb(struct channel *ch, struct sk_buff *skb)
436 {
437 	unsigned long saveflags;
438 	struct ll_header header;
439 	int rc = 0;
440 	__u16 block_len;
441 	int ccw_idx;
442 	struct sk_buff *nskb;
443 	unsigned long hi;
444 
445 	/* we need to acquire the lock for testing the state
446 	 * otherwise we can have an IRQ changing the state to
447 	 * TXIDLE after the test but before acquiring the lock.
448 	 */
449 	spin_lock_irqsave(&ch->collect_lock, saveflags);
450 	if (fsm_getstate(ch->fsm) != CTC_STATE_TXIDLE) {
451 		int l = skb->len + LL_HEADER_LENGTH;
452 
453 		if (ch->collect_len + l > ch->max_bufsize - 2) {
454 			spin_unlock_irqrestore(&ch->collect_lock, saveflags);
455 			return -EBUSY;
456 		} else {
457 			atomic_inc(&skb->users);
458 			header.length = l;
459 			header.type = skb->protocol;
460 			header.unused = 0;
461 			memcpy(skb_push(skb, LL_HEADER_LENGTH), &header,
462 			       LL_HEADER_LENGTH);
463 			skb_queue_tail(&ch->collect_queue, skb);
464 			ch->collect_len += l;
465 		}
466 		spin_unlock_irqrestore(&ch->collect_lock, saveflags);
467 				goto done;
468 	}
469 	spin_unlock_irqrestore(&ch->collect_lock, saveflags);
470 	/*
471 	 * Protect skb against beeing free'd by upper
472 	 * layers.
473 	 */
474 	atomic_inc(&skb->users);
475 	ch->prof.txlen += skb->len;
476 	header.length = skb->len + LL_HEADER_LENGTH;
477 	header.type = skb->protocol;
478 	header.unused = 0;
479 	memcpy(skb_push(skb, LL_HEADER_LENGTH), &header, LL_HEADER_LENGTH);
480 	block_len = skb->len + 2;
481 	*((__u16 *)skb_push(skb, 2)) = block_len;
482 
483 	/*
484 	 * IDAL support in CTCM is broken, so we have to
485 	 * care about skb's above 2G ourselves.
486 	 */
487 	hi = ((unsigned long)skb_tail_pointer(skb) + LL_HEADER_LENGTH) >> 31;
488 	if (hi) {
489 		nskb = alloc_skb(skb->len, GFP_ATOMIC | GFP_DMA);
490 		if (!nskb) {
491 			atomic_dec(&skb->users);
492 			skb_pull(skb, LL_HEADER_LENGTH + 2);
493 			ctcm_clear_busy(ch->netdev);
494 			return -ENOMEM;
495 		} else {
496 			memcpy(skb_put(nskb, skb->len), skb->data, skb->len);
497 			atomic_inc(&nskb->users);
498 			atomic_dec(&skb->users);
499 			dev_kfree_skb_irq(skb);
500 			skb = nskb;
501 		}
502 	}
503 
504 	ch->ccw[4].count = block_len;
505 	if (set_normalized_cda(&ch->ccw[4], skb->data)) {
506 		/*
507 		 * idal allocation failed, try via copying to
508 		 * trans_skb. trans_skb usually has a pre-allocated
509 		 * idal.
510 		 */
511 		if (ctcm_checkalloc_buffer(ch)) {
512 			/*
513 			 * Remove our header. It gets added
514 			 * again on retransmit.
515 			 */
516 			atomic_dec(&skb->users);
517 			skb_pull(skb, LL_HEADER_LENGTH + 2);
518 			ctcm_clear_busy(ch->netdev);
519 			return -EBUSY;
520 		}
521 
522 		skb_reset_tail_pointer(ch->trans_skb);
523 		ch->trans_skb->len = 0;
524 		ch->ccw[1].count = skb->len;
525 		skb_copy_from_linear_data(skb,
526 				skb_put(ch->trans_skb, skb->len), skb->len);
527 		atomic_dec(&skb->users);
528 		dev_kfree_skb_irq(skb);
529 		ccw_idx = 0;
530 	} else {
531 		skb_queue_tail(&ch->io_queue, skb);
532 		ccw_idx = 3;
533 	}
534 	ch->retry = 0;
535 	fsm_newstate(ch->fsm, CTC_STATE_TX);
536 	fsm_addtimer(&ch->timer, CTCM_TIME_5_SEC, CTC_EVENT_TIMER, ch);
537 	spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
538 	ch->prof.send_stamp = current_kernel_time(); /* xtime */
539 	rc = ccw_device_start(ch->cdev, &ch->ccw[ccw_idx],
540 					(unsigned long)ch, 0xff, 0);
541 	spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
542 	if (ccw_idx == 3)
543 		ch->prof.doios_single++;
544 	if (rc != 0) {
545 		fsm_deltimer(&ch->timer);
546 		ctcm_ccw_check_rc(ch, rc, "single skb TX");
547 		if (ccw_idx == 3)
548 			skb_dequeue_tail(&ch->io_queue);
549 		/*
550 		 * Remove our header. It gets added
551 		 * again on retransmit.
552 		 */
553 		skb_pull(skb, LL_HEADER_LENGTH + 2);
554 	} else if (ccw_idx == 0) {
555 		struct net_device *dev = ch->netdev;
556 		struct ctcm_priv *priv = dev->priv;
557 		priv->stats.tx_packets++;
558 		priv->stats.tx_bytes += skb->len - LL_HEADER_LENGTH;
559 	}
560 done:
561 	ctcm_clear_busy(ch->netdev);
562 	return rc;
563 }
564 
565 static void ctcmpc_send_sweep_req(struct channel *rch)
566 {
567 	struct net_device *dev = rch->netdev;
568 	struct ctcm_priv *priv;
569 	struct mpc_group *grp;
570 	struct th_sweep *header;
571 	struct sk_buff *sweep_skb;
572 	struct channel *ch;
573 	int rc = 0;
574 
575 	priv = dev->priv;
576 	grp = priv->mpcg;
577 	ch = priv->channel[WRITE];
578 
579 	if (do_debug)
580 		MPC_DBF_DEV_NAME(TRACE, dev, ch->id);
581 
582 	/* sweep processing is not complete until response and request */
583 	/* has completed for all read channels in group		       */
584 	if (grp->in_sweep == 0) {
585 		grp->in_sweep = 1;
586 		grp->sweep_rsp_pend_num = grp->active_channels[READ];
587 		grp->sweep_req_pend_num = grp->active_channels[READ];
588 	}
589 
590 	sweep_skb = __dev_alloc_skb(MPC_BUFSIZE_DEFAULT, GFP_ATOMIC|GFP_DMA);
591 
592 	if (sweep_skb == NULL)	{
593 		printk(KERN_INFO "Couldn't alloc sweep_skb\n");
594 		rc = -ENOMEM;
595 					goto done;
596 	}
597 
598 	header = kmalloc(TH_SWEEP_LENGTH, gfp_type());
599 
600 	if (!header) {
601 		dev_kfree_skb_any(sweep_skb);
602 		rc = -ENOMEM;
603 					goto done;
604 	}
605 
606 	header->th.th_seg	= 0x00 ;
607 	header->th.th_ch_flag	= TH_SWEEP_REQ;  /* 0x0f */
608 	header->th.th_blk_flag	= 0x00;
609 	header->th.th_is_xid	= 0x00;
610 	header->th.th_seq_num	= 0x00;
611 	header->sw.th_last_seq	= ch->th_seq_num;
612 
613 	memcpy(skb_put(sweep_skb, TH_SWEEP_LENGTH), header, TH_SWEEP_LENGTH);
614 
615 	kfree(header);
616 
617 	dev->trans_start = jiffies;
618 	skb_queue_tail(&ch->sweep_queue, sweep_skb);
619 
620 	fsm_addtimer(&ch->sweep_timer, 100, CTC_EVENT_RSWEEP_TIMER, ch);
621 
622 	return;
623 
624 done:
625 	if (rc != 0) {
626 		grp->in_sweep = 0;
627 		ctcm_clear_busy(dev);
628 		fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
629 	}
630 
631 	return;
632 }
633 
634 /*
635  * MPC mode version of transmit_skb
636  */
637 static int ctcmpc_transmit_skb(struct channel *ch, struct sk_buff *skb)
638 {
639 	struct pdu *p_header;
640 	struct net_device *dev = ch->netdev;
641 	struct ctcm_priv *priv = dev->priv;
642 	struct mpc_group *grp = priv->mpcg;
643 	struct th_header *header;
644 	struct sk_buff *nskb;
645 	int rc = 0;
646 	int ccw_idx;
647 	unsigned long hi;
648 	unsigned long saveflags = 0;	/* avoids compiler warning */
649 	__u16 block_len;
650 
651 	if (do_debug)
652 		ctcm_pr_debug(
653 			"ctcm enter: %s(): %s cp=%i ch=0x%p id=%s state=%s\n",
654 			__FUNCTION__, dev->name, smp_processor_id(), ch,
655 			ch->id, fsm_getstate_str(ch->fsm));
656 
657 	if ((fsm_getstate(ch->fsm) != CTC_STATE_TXIDLE) || grp->in_sweep) {
658 		spin_lock_irqsave(&ch->collect_lock, saveflags);
659 		atomic_inc(&skb->users);
660 		p_header = kmalloc(PDU_HEADER_LENGTH, gfp_type());
661 
662 		if (!p_header) {
663 			printk(KERN_WARNING "ctcm: OUT OF MEMORY IN %s():"
664 			       " Data Lost \n", __FUNCTION__);
665 
666 			atomic_dec(&skb->users);
667 			dev_kfree_skb_any(skb);
668 			spin_unlock_irqrestore(&ch->collect_lock, saveflags);
669 			fsm_event(priv->mpcg->fsm, MPCG_EVENT_INOP, dev);
670 					goto done;
671 		}
672 
673 		p_header->pdu_offset = skb->len;
674 		p_header->pdu_proto = 0x01;
675 		p_header->pdu_flag = 0x00;
676 		if (skb->protocol == ntohs(ETH_P_SNAP)) {
677 			p_header->pdu_flag |= PDU_FIRST | PDU_CNTL;
678 		} else {
679 			p_header->pdu_flag |= PDU_FIRST;
680 		}
681 		p_header->pdu_seq = 0;
682 		memcpy(skb_push(skb, PDU_HEADER_LENGTH), p_header,
683 		       PDU_HEADER_LENGTH);
684 
685 		if (do_debug_data) {
686 			ctcm_pr_debug("ctcm: %s() Putting on collect_q"
687 			       " - skb len: %04x \n", __FUNCTION__, skb->len);
688 			ctcm_pr_debug("ctcm: %s() pdu header and data"
689 			       " for up to 32 bytes\n", __FUNCTION__);
690 			ctcmpc_dump32((char *)skb->data, skb->len);
691 		}
692 
693 		skb_queue_tail(&ch->collect_queue, skb);
694 		ch->collect_len += skb->len;
695 		kfree(p_header);
696 
697 		spin_unlock_irqrestore(&ch->collect_lock, saveflags);
698 			goto done;
699 	}
700 
701 	/*
702 	 * Protect skb against beeing free'd by upper
703 	 * layers.
704 	 */
705 	atomic_inc(&skb->users);
706 
707 	block_len = skb->len + TH_HEADER_LENGTH + PDU_HEADER_LENGTH;
708 	/*
709 	 * IDAL support in CTCM is broken, so we have to
710 	 * care about skb's above 2G ourselves.
711 	 */
712 	hi = ((unsigned long)skb->tail + TH_HEADER_LENGTH) >> 31;
713 	if (hi) {
714 		nskb = __dev_alloc_skb(skb->len, GFP_ATOMIC | GFP_DMA);
715 		if (!nskb) {
716 			printk(KERN_WARNING "ctcm: %s() OUT OF MEMORY"
717 				"-  Data Lost \n", __FUNCTION__);
718 			atomic_dec(&skb->users);
719 			dev_kfree_skb_any(skb);
720 			fsm_event(priv->mpcg->fsm, MPCG_EVENT_INOP, dev);
721 				goto done;
722 		} else {
723 			memcpy(skb_put(nskb, skb->len), skb->data, skb->len);
724 			atomic_inc(&nskb->users);
725 			atomic_dec(&skb->users);
726 			dev_kfree_skb_irq(skb);
727 			skb = nskb;
728 		}
729 	}
730 
731 	p_header = kmalloc(PDU_HEADER_LENGTH, gfp_type());
732 
733 	if (!p_header) {
734 		printk(KERN_WARNING "ctcm: %s() OUT OF MEMORY"
735 		       ": Data Lost \n", __FUNCTION__);
736 
737 		atomic_dec(&skb->users);
738 		dev_kfree_skb_any(skb);
739 		fsm_event(priv->mpcg->fsm, MPCG_EVENT_INOP, dev);
740 				goto done;
741 	}
742 
743 	p_header->pdu_offset = skb->len;
744 	p_header->pdu_proto = 0x01;
745 	p_header->pdu_flag = 0x00;
746 	p_header->pdu_seq = 0;
747 	if (skb->protocol == ntohs(ETH_P_SNAP)) {
748 		p_header->pdu_flag |= PDU_FIRST | PDU_CNTL;
749 	} else {
750 		p_header->pdu_flag |= PDU_FIRST;
751 	}
752 	memcpy(skb_push(skb, PDU_HEADER_LENGTH), p_header, PDU_HEADER_LENGTH);
753 
754 	kfree(p_header);
755 
756 	if (ch->collect_len > 0) {
757 		spin_lock_irqsave(&ch->collect_lock, saveflags);
758 		skb_queue_tail(&ch->collect_queue, skb);
759 		ch->collect_len += skb->len;
760 		skb = skb_dequeue(&ch->collect_queue);
761 		ch->collect_len -= skb->len;
762 		spin_unlock_irqrestore(&ch->collect_lock, saveflags);
763 	}
764 
765 	p_header = (struct pdu *)skb->data;
766 	p_header->pdu_flag |= PDU_LAST;
767 
768 	ch->prof.txlen += skb->len - PDU_HEADER_LENGTH;
769 
770 	header = kmalloc(TH_HEADER_LENGTH, gfp_type());
771 
772 	if (!header) {
773 		printk(KERN_WARNING "ctcm: %s() OUT OF MEMORY: Data Lost \n",
774 				__FUNCTION__);
775 		atomic_dec(&skb->users);
776 		dev_kfree_skb_any(skb);
777 		fsm_event(priv->mpcg->fsm, MPCG_EVENT_INOP, dev);
778 				goto done;
779 	}
780 
781 	header->th_seg = 0x00;
782 	header->th_ch_flag = TH_HAS_PDU;  /* Normal data */
783 	header->th_blk_flag = 0x00;
784 	header->th_is_xid = 0x00;          /* Just data here */
785 	ch->th_seq_num++;
786 	header->th_seq_num = ch->th_seq_num;
787 
788 	if (do_debug_data)
789 		ctcm_pr_debug("ctcm: %s() ToVTAM_th_seq= %08x\n" ,
790 		       __FUNCTION__, ch->th_seq_num);
791 
792 	/* put the TH on the packet */
793 	memcpy(skb_push(skb, TH_HEADER_LENGTH), header, TH_HEADER_LENGTH);
794 
795 	kfree(header);
796 
797 	if (do_debug_data) {
798 		ctcm_pr_debug("ctcm: %s(): skb len: %04x \n",
799 				__FUNCTION__, skb->len);
800 		ctcm_pr_debug("ctcm: %s(): pdu header and data for up to 32 "
801 				"bytes sent to vtam\n", __FUNCTION__);
802 		ctcmpc_dump32((char *)skb->data, skb->len);
803 	}
804 
805 	ch->ccw[4].count = skb->len;
806 	if (set_normalized_cda(&ch->ccw[4], skb->data)) {
807 		/*
808 		 * idal allocation failed, try via copying to
809 		 * trans_skb. trans_skb usually has a pre-allocated
810 		 * idal.
811 		 */
812 		if (ctcm_checkalloc_buffer(ch)) {
813 			/*
814 			 * Remove our header. It gets added
815 			 * again on retransmit.
816 			 */
817 			atomic_dec(&skb->users);
818 			dev_kfree_skb_any(skb);
819 			printk(KERN_WARNING "ctcm: %s()OUT OF MEMORY:"
820 					" Data Lost \n", __FUNCTION__);
821 			fsm_event(priv->mpcg->fsm, MPCG_EVENT_INOP, dev);
822 				goto done;
823 		}
824 
825 		skb_reset_tail_pointer(ch->trans_skb);
826 		ch->trans_skb->len = 0;
827 		ch->ccw[1].count = skb->len;
828 		memcpy(skb_put(ch->trans_skb, skb->len), skb->data, skb->len);
829 		atomic_dec(&skb->users);
830 		dev_kfree_skb_irq(skb);
831 		ccw_idx = 0;
832 		if (do_debug_data) {
833 			ctcm_pr_debug("ctcm: %s() TRANS skb len: %d \n",
834 			       __FUNCTION__, ch->trans_skb->len);
835 			ctcm_pr_debug("ctcm: %s up to 32 bytes of data"
836 				" sent to vtam\n", __FUNCTION__);
837 			ctcmpc_dump32((char *)ch->trans_skb->data,
838 					ch->trans_skb->len);
839 		}
840 	} else {
841 		skb_queue_tail(&ch->io_queue, skb);
842 		ccw_idx = 3;
843 	}
844 	ch->retry = 0;
845 	fsm_newstate(ch->fsm, CTC_STATE_TX);
846 	fsm_addtimer(&ch->timer, CTCM_TIME_5_SEC, CTC_EVENT_TIMER, ch);
847 
848 	if (do_debug_ccw)
849 		ctcmpc_dumpit((char *)&ch->ccw[ccw_idx],
850 					sizeof(struct ccw1) * 3);
851 
852 	spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
853 	ch->prof.send_stamp = current_kernel_time(); /* xtime */
854 	rc = ccw_device_start(ch->cdev, &ch->ccw[ccw_idx],
855 					(unsigned long)ch, 0xff, 0);
856 	spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
857 	if (ccw_idx == 3)
858 		ch->prof.doios_single++;
859 	if (rc != 0) {
860 		fsm_deltimer(&ch->timer);
861 		ctcm_ccw_check_rc(ch, rc, "single skb TX");
862 		if (ccw_idx == 3)
863 			skb_dequeue_tail(&ch->io_queue);
864 	} else if (ccw_idx == 0) {
865 		priv->stats.tx_packets++;
866 		priv->stats.tx_bytes += skb->len - TH_HEADER_LENGTH;
867 	}
868 	if (ch->th_seq_num > 0xf0000000)	/* Chose 4Billion at random. */
869 		ctcmpc_send_sweep_req(ch);
870 
871 done:
872 	if (do_debug)
873 		ctcm_pr_debug("ctcm exit: %s  %s()\n", dev->name, __FUNCTION__);
874 	return 0;
875 }
876 
877 /**
878  * Start transmission of a packet.
879  * Called from generic network device layer.
880  *
881  *  skb		Pointer to buffer containing the packet.
882  *  dev		Pointer to interface struct.
883  *
884  * returns 0 if packet consumed, !0 if packet rejected.
885  *         Note: If we return !0, then the packet is free'd by
886  *               the generic network layer.
887  */
888 /* first merge version - leaving both functions separated */
889 static int ctcm_tx(struct sk_buff *skb, struct net_device *dev)
890 {
891 	int rc = 0;
892 	struct ctcm_priv *priv;
893 
894 	CTCM_DBF_TEXT(TRACE, 5, __FUNCTION__);
895 	priv = dev->priv;
896 
897 	if (skb == NULL) {
898 		ctcm_pr_warn("%s: NULL sk_buff passed\n", dev->name);
899 		priv->stats.tx_dropped++;
900 		return 0;
901 	}
902 	if (skb_headroom(skb) < (LL_HEADER_LENGTH + 2)) {
903 		ctcm_pr_warn("%s: Got sk_buff with head room < %ld bytes\n",
904 			    dev->name, LL_HEADER_LENGTH + 2);
905 		dev_kfree_skb(skb);
906 		priv->stats.tx_dropped++;
907 		return 0;
908 	}
909 
910 	/*
911 	 * If channels are not running, try to restart them
912 	 * and throw away packet.
913 	 */
914 	if (fsm_getstate(priv->fsm) != DEV_STATE_RUNNING) {
915 		fsm_event(priv->fsm, DEV_EVENT_START, dev);
916 		dev_kfree_skb(skb);
917 		priv->stats.tx_dropped++;
918 		priv->stats.tx_errors++;
919 		priv->stats.tx_carrier_errors++;
920 		return 0;
921 	}
922 
923 	if (ctcm_test_and_set_busy(dev))
924 		return -EBUSY;
925 
926 	dev->trans_start = jiffies;
927 	if (ctcm_transmit_skb(priv->channel[WRITE], skb) != 0)
928 		rc = 1;
929 	return rc;
930 }
931 
932 /* unmerged MPC variant of ctcm_tx */
933 static int ctcmpc_tx(struct sk_buff *skb, struct net_device *dev)
934 {
935 	int len = 0;
936 	struct ctcm_priv *priv = NULL;
937 	struct mpc_group *grp  = NULL;
938 	struct sk_buff *newskb = NULL;
939 
940 	if (do_debug)
941 		ctcm_pr_debug("ctcmpc enter: %s(): skb:%0lx\n",
942 			__FUNCTION__, (unsigned long)skb);
943 
944 	CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_DEBUG,
945 			"ctcmpc enter: %s(): skb:%0lx\n",
946 			__FUNCTION__, (unsigned long)skb);
947 
948 	priv = dev->priv;
949 	grp  = priv->mpcg;
950 	/*
951 	 * Some sanity checks ...
952 	 */
953 	if (skb == NULL) {
954 		ctcm_pr_warn("ctcmpc: %s: NULL sk_buff passed\n", dev->name);
955 		priv->stats.tx_dropped++;
956 					goto done;
957 	}
958 	if (skb_headroom(skb) < (TH_HEADER_LENGTH + PDU_HEADER_LENGTH)) {
959 		CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_WARN,
960 			"%s: Got sk_buff with head room < %ld bytes\n",
961 			dev->name, TH_HEADER_LENGTH + PDU_HEADER_LENGTH);
962 
963 		if (do_debug_data)
964 			ctcmpc_dump32((char *)skb->data, skb->len);
965 
966 		len =  skb->len + TH_HEADER_LENGTH + PDU_HEADER_LENGTH;
967 		newskb = __dev_alloc_skb(len, gfp_type() | GFP_DMA);
968 
969 		if (!newskb) {
970 			printk(KERN_WARNING "ctcmpc: %s() OUT OF MEMORY-"
971 			       "Data Lost\n",
972 			       __FUNCTION__);
973 
974 			dev_kfree_skb_any(skb);
975 			priv->stats.tx_dropped++;
976 			priv->stats.tx_errors++;
977 			priv->stats.tx_carrier_errors++;
978 			fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
979 					goto done;
980 		}
981 		newskb->protocol = skb->protocol;
982 		skb_reserve(newskb, TH_HEADER_LENGTH + PDU_HEADER_LENGTH);
983 		memcpy(skb_put(newskb, skb->len), skb->data, skb->len);
984 		dev_kfree_skb_any(skb);
985 		skb = newskb;
986 	}
987 
988 	/*
989 	 * If channels are not running,
990 	 * notify anybody about a link failure and throw
991 	 * away packet.
992 	 */
993 	if ((fsm_getstate(priv->fsm) != DEV_STATE_RUNNING) ||
994 	   (fsm_getstate(grp->fsm) <  MPCG_STATE_XID2INITW)) {
995 		dev_kfree_skb_any(skb);
996 		printk(KERN_INFO "ctcmpc: %s() DATA RCVD - MPC GROUP "
997 		       "NOT ACTIVE - DROPPED\n",
998 		       __FUNCTION__);
999 		priv->stats.tx_dropped++;
1000 		priv->stats.tx_errors++;
1001 		priv->stats.tx_carrier_errors++;
1002 					goto done;
1003 	}
1004 
1005 	if (ctcm_test_and_set_busy(dev)) {
1006 		printk(KERN_WARNING "%s:DEVICE ERR - UNRECOVERABLE DATA LOSS\n",
1007 		       __FUNCTION__);
1008 		dev_kfree_skb_any(skb);
1009 		priv->stats.tx_dropped++;
1010 		priv->stats.tx_errors++;
1011 		priv->stats.tx_carrier_errors++;
1012 		fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
1013 					goto done;
1014 	}
1015 
1016 	dev->trans_start = jiffies;
1017 	if (ctcmpc_transmit_skb(priv->channel[WRITE], skb) != 0) {
1018 		printk(KERN_WARNING "ctcmpc: %s() DEVICE ERROR"
1019 		       ": Data Lost \n",
1020 		       __FUNCTION__);
1021 		printk(KERN_WARNING "ctcmpc: %s() DEVICE ERROR"
1022 		       " - UNRECOVERABLE DATA LOSS\n",
1023 		       __FUNCTION__);
1024 		dev_kfree_skb_any(skb);
1025 		priv->stats.tx_dropped++;
1026 		priv->stats.tx_errors++;
1027 		priv->stats.tx_carrier_errors++;
1028 		ctcm_clear_busy(dev);
1029 		fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
1030 					goto done;
1031 	}
1032 	ctcm_clear_busy(dev);
1033 done:
1034 	if (do_debug)
1035 		MPC_DBF_DEV_NAME(TRACE, dev, "exit");
1036 
1037 	return 0;	/* handle freeing of skb here */
1038 }
1039 
1040 
1041 /**
1042  * Sets MTU of an interface.
1043  *
1044  *  dev		Pointer to interface struct.
1045  *  new_mtu	The new MTU to use for this interface.
1046  *
1047  * returns 0 on success, -EINVAL if MTU is out of valid range.
1048  *         (valid range is 576 .. 65527). If VM is on the
1049  *         remote side, maximum MTU is 32760, however this is
1050  *         not checked here.
1051  */
1052 static int ctcm_change_mtu(struct net_device *dev, int new_mtu)
1053 {
1054 	struct ctcm_priv *priv;
1055 	int max_bufsize;
1056 
1057 	CTCM_DBF_TEXT(SETUP, CTC_DBF_INFO, __FUNCTION__);
1058 
1059 	if (new_mtu < 576 || new_mtu > 65527)
1060 		return -EINVAL;
1061 
1062 	priv = dev->priv;
1063 	max_bufsize = priv->channel[READ]->max_bufsize;
1064 
1065 	if (IS_MPC(priv)) {
1066 		if (new_mtu > max_bufsize - TH_HEADER_LENGTH)
1067 			return -EINVAL;
1068 		dev->hard_header_len = TH_HEADER_LENGTH + PDU_HEADER_LENGTH;
1069 	} else {
1070 		if (new_mtu > max_bufsize - LL_HEADER_LENGTH - 2)
1071 			return -EINVAL;
1072 		dev->hard_header_len = LL_HEADER_LENGTH + 2;
1073 	}
1074 	dev->mtu = new_mtu;
1075 	return 0;
1076 }
1077 
1078 /**
1079  * Returns interface statistics of a device.
1080  *
1081  *  dev		Pointer to interface struct.
1082  *
1083  * returns Pointer to stats struct of this interface.
1084  */
1085 static struct net_device_stats *ctcm_stats(struct net_device *dev)
1086 {
1087 	return &((struct ctcm_priv *)dev->priv)->stats;
1088 }
1089 
1090 
1091 static void ctcm_netdev_unregister(struct net_device *dev)
1092 {
1093 	CTCM_DBF_TEXT(SETUP, CTC_DBF_INFO, __FUNCTION__);
1094 	if (!dev)
1095 		return;
1096 	unregister_netdev(dev);
1097 }
1098 
1099 static int ctcm_netdev_register(struct net_device *dev)
1100 {
1101 	CTCM_DBF_TEXT(SETUP, CTC_DBF_INFO, __FUNCTION__);
1102 	return register_netdev(dev);
1103 }
1104 
1105 static void ctcm_free_netdevice(struct net_device *dev)
1106 {
1107 	struct ctcm_priv *priv;
1108 	struct mpc_group *grp;
1109 
1110 	CTCM_DBF_TEXT(SETUP, CTC_DBF_INFO, __FUNCTION__);
1111 
1112 	if (!dev)
1113 		return;
1114 	priv = dev->priv;
1115 	if (priv) {
1116 		grp = priv->mpcg;
1117 		if (grp) {
1118 			if (grp->fsm)
1119 				kfree_fsm(grp->fsm);
1120 			if (grp->xid_skb)
1121 				dev_kfree_skb(grp->xid_skb);
1122 			if (grp->rcvd_xid_skb)
1123 				dev_kfree_skb(grp->rcvd_xid_skb);
1124 			tasklet_kill(&grp->mpc_tasklet2);
1125 			kfree(grp);
1126 			priv->mpcg = NULL;
1127 		}
1128 		if (priv->fsm) {
1129 			kfree_fsm(priv->fsm);
1130 			priv->fsm = NULL;
1131 		}
1132 		kfree(priv->xid);
1133 		priv->xid = NULL;
1134 	/*
1135 	 * Note: kfree(priv); is done in "opposite" function of
1136 	 * allocator function probe_device which is remove_device.
1137 	 */
1138 	}
1139 #ifdef MODULE
1140 	free_netdev(dev);
1141 #endif
1142 }
1143 
1144 struct mpc_group *ctcmpc_init_mpc_group(struct ctcm_priv *priv);
1145 
1146 void static ctcm_dev_setup(struct net_device *dev)
1147 {
1148 	dev->open = ctcm_open;
1149 	dev->stop = ctcm_close;
1150 	dev->get_stats = ctcm_stats;
1151 	dev->change_mtu = ctcm_change_mtu;
1152 	dev->type = ARPHRD_SLIP;
1153 	dev->tx_queue_len = 100;
1154 	dev->flags = IFF_POINTOPOINT | IFF_NOARP;
1155 }
1156 
1157 /*
1158  * Initialize everything of the net device except the name and the
1159  * channel structs.
1160  */
1161 static struct net_device *ctcm_init_netdevice(struct ctcm_priv *priv)
1162 {
1163 	struct net_device *dev;
1164 	struct mpc_group *grp;
1165 	if (!priv)
1166 		return NULL;
1167 
1168 	if (IS_MPC(priv))
1169 		dev = alloc_netdev(0, MPC_DEVICE_GENE, ctcm_dev_setup);
1170 	else
1171 		dev = alloc_netdev(0, CTC_DEVICE_GENE, ctcm_dev_setup);
1172 
1173 	if (!dev) {
1174 		ctcm_pr_err("%s: Out of memory\n", __FUNCTION__);
1175 		return NULL;
1176 	}
1177 	dev->priv = priv;
1178 	priv->fsm = init_fsm("ctcmdev", dev_state_names, dev_event_names,
1179 				CTCM_NR_DEV_STATES, CTCM_NR_DEV_EVENTS,
1180 				dev_fsm, dev_fsm_len, GFP_KERNEL);
1181 	if (priv->fsm == NULL) {
1182 		CTCMY_DBF_DEV(SETUP, dev, "init_fsm error");
1183 		kfree(dev);
1184 		return NULL;
1185 	}
1186 	fsm_newstate(priv->fsm, DEV_STATE_STOPPED);
1187 	fsm_settimer(priv->fsm, &priv->restart_timer);
1188 
1189 	if (IS_MPC(priv)) {
1190 		/*  MPC Group Initializations  */
1191 		grp = ctcmpc_init_mpc_group(priv);
1192 		if (grp == NULL) {
1193 			MPC_DBF_DEV(SETUP, dev, "init_mpc_group error");
1194 			kfree(dev);
1195 			return NULL;
1196 		}
1197 		tasklet_init(&grp->mpc_tasklet2,
1198 				mpc_group_ready, (unsigned long)dev);
1199 		dev->mtu = MPC_BUFSIZE_DEFAULT -
1200 				TH_HEADER_LENGTH - PDU_HEADER_LENGTH;
1201 
1202 		dev->hard_start_xmit = ctcmpc_tx;
1203 		dev->hard_header_len = TH_HEADER_LENGTH + PDU_HEADER_LENGTH;
1204 		priv->buffer_size = MPC_BUFSIZE_DEFAULT;
1205 	} else {
1206 		dev->mtu = CTCM_BUFSIZE_DEFAULT - LL_HEADER_LENGTH - 2;
1207 		dev->hard_start_xmit = ctcm_tx;
1208 		dev->hard_header_len = LL_HEADER_LENGTH + 2;
1209 	}
1210 
1211 	CTCMY_DBF_DEV(SETUP, dev, "finished");
1212 	return dev;
1213 }
1214 
1215 /**
1216  * Main IRQ handler.
1217  *
1218  *  cdev	The ccw_device the interrupt is for.
1219  *  intparm	interruption parameter.
1220  *  irb		interruption response block.
1221  */
1222 static void ctcm_irq_handler(struct ccw_device *cdev,
1223 				unsigned long intparm, struct irb *irb)
1224 {
1225 	struct channel		*ch;
1226 	struct net_device	*dev;
1227 	struct ctcm_priv	*priv;
1228 	struct ccwgroup_device	*cgdev;
1229 
1230 	CTCM_DBF_TEXT(TRACE, CTC_DBF_DEBUG, __FUNCTION__);
1231 	if (ctcm_check_irb_error(cdev, irb))
1232 		return;
1233 
1234 	cgdev = dev_get_drvdata(&cdev->dev);
1235 
1236 	/* Check for unsolicited interrupts. */
1237 	if (cgdev == NULL) {
1238 		ctcm_pr_warn("ctcm: Got unsolicited irq: %s c-%02x d-%02x\n",
1239 			    cdev->dev.bus_id, irb->scsw.cstat,
1240 			    irb->scsw.dstat);
1241 		return;
1242 	}
1243 
1244 	priv = dev_get_drvdata(&cgdev->dev);
1245 
1246 	/* Try to extract channel from driver data. */
1247 	if (priv->channel[READ]->cdev == cdev)
1248 		ch = priv->channel[READ];
1249 	else if (priv->channel[WRITE]->cdev == cdev)
1250 		ch = priv->channel[WRITE];
1251 	else {
1252 		ctcm_pr_err("ctcm: Can't determine channel for interrupt, "
1253 			   "device %s\n", cdev->dev.bus_id);
1254 		return;
1255 	}
1256 
1257 	dev = (struct net_device *)(ch->netdev);
1258 	if (dev == NULL) {
1259 		ctcm_pr_crit("ctcm: %s dev=NULL bus_id=%s, ch=0x%p\n",
1260 				__FUNCTION__, cdev->dev.bus_id, ch);
1261 		return;
1262 	}
1263 
1264 	if (do_debug)
1265 		ctcm_pr_debug("%s: interrupt for device: %s "
1266 				"received c-%02x d-%02x\n",
1267 				dev->name,
1268 				ch->id,
1269 				irb->scsw.cstat,
1270 				irb->scsw.dstat);
1271 
1272 	/* Copy interruption response block. */
1273 	memcpy(ch->irb, irb, sizeof(struct irb));
1274 
1275 	/* Check for good subchannel return code, otherwise error message */
1276 	if (irb->scsw.cstat) {
1277 		fsm_event(ch->fsm, CTC_EVENT_SC_UNKNOWN, ch);
1278 		ctcm_pr_warn("%s: subchannel check for dev: %s - %02x %02x\n",
1279 			    dev->name, ch->id, irb->scsw.cstat,
1280 			    irb->scsw.dstat);
1281 		return;
1282 	}
1283 
1284 	/* Check the reason-code of a unit check */
1285 	if (irb->scsw.dstat & DEV_STAT_UNIT_CHECK) {
1286 		ccw_unit_check(ch, irb->ecw[0]);
1287 		return;
1288 	}
1289 	if (irb->scsw.dstat & DEV_STAT_BUSY) {
1290 		if (irb->scsw.dstat & DEV_STAT_ATTENTION)
1291 			fsm_event(ch->fsm, CTC_EVENT_ATTNBUSY, ch);
1292 		else
1293 			fsm_event(ch->fsm, CTC_EVENT_BUSY, ch);
1294 		return;
1295 	}
1296 	if (irb->scsw.dstat & DEV_STAT_ATTENTION) {
1297 		fsm_event(ch->fsm, CTC_EVENT_ATTN, ch);
1298 		return;
1299 	}
1300 	if ((irb->scsw.stctl & SCSW_STCTL_SEC_STATUS) ||
1301 	    (irb->scsw.stctl == SCSW_STCTL_STATUS_PEND) ||
1302 	    (irb->scsw.stctl ==
1303 	     (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND)))
1304 		fsm_event(ch->fsm, CTC_EVENT_FINSTAT, ch);
1305 	else
1306 		fsm_event(ch->fsm, CTC_EVENT_IRQ, ch);
1307 
1308 }
1309 
1310 /**
1311  * Add ctcm specific attributes.
1312  * Add ctcm private data.
1313  *
1314  *  cgdev	pointer to ccwgroup_device just added
1315  *
1316  * returns 0 on success, !0 on failure.
1317  */
1318 static int ctcm_probe_device(struct ccwgroup_device *cgdev)
1319 {
1320 	struct ctcm_priv *priv;
1321 	int rc;
1322 
1323 	CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO, "%s %p", __FUNCTION__, cgdev);
1324 
1325 	if (!get_device(&cgdev->dev))
1326 		return -ENODEV;
1327 
1328 	priv = kzalloc(sizeof(struct ctcm_priv), GFP_KERNEL);
1329 	if (!priv) {
1330 		ctcm_pr_err("%s: Out of memory\n", __FUNCTION__);
1331 		put_device(&cgdev->dev);
1332 		return -ENOMEM;
1333 	}
1334 
1335 	rc = ctcm_add_files(&cgdev->dev);
1336 	if (rc) {
1337 		kfree(priv);
1338 		put_device(&cgdev->dev);
1339 		return rc;
1340 	}
1341 	priv->buffer_size = CTCM_BUFSIZE_DEFAULT;
1342 	cgdev->cdev[0]->handler = ctcm_irq_handler;
1343 	cgdev->cdev[1]->handler = ctcm_irq_handler;
1344 	dev_set_drvdata(&cgdev->dev, priv);
1345 
1346 	return 0;
1347 }
1348 
1349 /**
1350  * Add a new channel to the list of channels.
1351  * Keeps the channel list sorted.
1352  *
1353  *  cdev	The ccw_device to be added.
1354  *  type	The type class of the new channel.
1355  *  priv	Points to the private data of the ccwgroup_device.
1356  *
1357  * returns 0 on success, !0 on error.
1358  */
1359 static int add_channel(struct ccw_device *cdev, enum channel_types type,
1360 				struct ctcm_priv *priv)
1361 {
1362 	struct channel **c = &channels;
1363 	struct channel *ch;
1364 	int ccw_num;
1365 	int rc = 0;
1366 
1367 	CTCM_DBF_TEXT(TRACE, 2, __FUNCTION__);
1368 	ch = kzalloc(sizeof(struct channel), GFP_KERNEL);
1369 	if (ch == NULL)
1370 					goto nomem_return;
1371 
1372 	ch->protocol = priv->protocol;
1373 	if (IS_MPC(priv)) {
1374 		ch->discontact_th = (struct th_header *)
1375 				kzalloc(TH_HEADER_LENGTH, gfp_type());
1376 		if (ch->discontact_th == NULL)
1377 					goto nomem_return;
1378 
1379 		ch->discontact_th->th_blk_flag = TH_DISCONTACT;
1380 		tasklet_init(&ch->ch_disc_tasklet,
1381 			mpc_action_send_discontact, (unsigned long)ch);
1382 
1383 		tasklet_init(&ch->ch_tasklet, ctcmpc_bh, (unsigned long)ch);
1384 		ch->max_bufsize = (MPC_BUFSIZE_DEFAULT - 35);
1385 		ccw_num = 17;
1386 	} else
1387 		ccw_num = 8;
1388 
1389 	ch->ccw = (struct ccw1 *)
1390 		kzalloc(ccw_num * sizeof(struct ccw1), GFP_KERNEL | GFP_DMA);
1391 	if (ch->ccw == NULL)
1392 					goto nomem_return;
1393 
1394 	ch->cdev = cdev;
1395 	snprintf(ch->id, CTCM_ID_SIZE, "ch-%s", cdev->dev.bus_id);
1396 	ch->type = type;
1397 
1398 	/**
1399 	 * "static" ccws are used in the following way:
1400 	 *
1401 	 * ccw[0..2] (Channel program for generic I/O):
1402 	 *           0: prepare
1403 	 *           1: read or write (depending on direction) with fixed
1404 	 *              buffer (idal allocated once when buffer is allocated)
1405 	 *           2: nop
1406 	 * ccw[3..5] (Channel program for direct write of packets)
1407 	 *           3: prepare
1408 	 *           4: write (idal allocated on every write).
1409 	 *           5: nop
1410 	 * ccw[6..7] (Channel program for initial channel setup):
1411 	 *           6: set extended mode
1412 	 *           7: nop
1413 	 *
1414 	 * ch->ccw[0..5] are initialized in ch_action_start because
1415 	 * the channel's direction is yet unknown here.
1416 	 *
1417 	 * ccws used for xid2 negotiations
1418 	 *  ch-ccw[8-14] need to be used for the XID exchange either
1419 	 *    X side XID2 Processing
1420 	 *       8:  write control
1421 	 *       9:  write th
1422 	 *	     10: write XID
1423 	 *	     11: read th from secondary
1424 	 *	     12: read XID   from secondary
1425 	 *	     13: read 4 byte ID
1426 	 *	     14: nop
1427 	 *    Y side XID Processing
1428 	 *	     8:  sense
1429 	 *       9:  read th
1430 	 *	     10: read XID
1431 	 *	     11: write th
1432 	 *	     12: write XID
1433 	 *	     13: write 4 byte ID
1434 	 *	     14: nop
1435 	 *
1436 	 *  ccws used for double noop due to VM timing issues
1437 	 *  which result in unrecoverable Busy on channel
1438 	 *       15: nop
1439 	 *       16: nop
1440 	 */
1441 	ch->ccw[6].cmd_code	= CCW_CMD_SET_EXTENDED;
1442 	ch->ccw[6].flags	= CCW_FLAG_SLI;
1443 
1444 	ch->ccw[7].cmd_code	= CCW_CMD_NOOP;
1445 	ch->ccw[7].flags	= CCW_FLAG_SLI;
1446 
1447 	if (IS_MPC(priv)) {
1448 		ch->ccw[15].cmd_code = CCW_CMD_WRITE;
1449 		ch->ccw[15].flags    = CCW_FLAG_SLI | CCW_FLAG_CC;
1450 		ch->ccw[15].count    = TH_HEADER_LENGTH;
1451 		ch->ccw[15].cda      = virt_to_phys(ch->discontact_th);
1452 
1453 		ch->ccw[16].cmd_code = CCW_CMD_NOOP;
1454 		ch->ccw[16].flags    = CCW_FLAG_SLI;
1455 
1456 		ch->fsm = init_fsm(ch->id, ctc_ch_state_names,
1457 				ctc_ch_event_names, CTC_MPC_NR_STATES,
1458 				CTC_MPC_NR_EVENTS, ctcmpc_ch_fsm,
1459 				mpc_ch_fsm_len, GFP_KERNEL);
1460 	} else {
1461 		ch->fsm = init_fsm(ch->id, ctc_ch_state_names,
1462 				ctc_ch_event_names, CTC_NR_STATES,
1463 				CTC_NR_EVENTS, ch_fsm,
1464 				ch_fsm_len, GFP_KERNEL);
1465 	}
1466 	if (ch->fsm == NULL)
1467 				goto free_return;
1468 
1469 	fsm_newstate(ch->fsm, CTC_STATE_IDLE);
1470 
1471 	ch->irb = kzalloc(sizeof(struct irb), GFP_KERNEL);
1472 	if (ch->irb == NULL)
1473 				goto nomem_return;
1474 
1475 	while (*c && ctcm_less_than((*c)->id, ch->id))
1476 		c = &(*c)->next;
1477 
1478 	if (*c && (!strncmp((*c)->id, ch->id, CTCM_ID_SIZE))) {
1479 		CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO,
1480 				"%s (%s) already in list, using old entry",
1481 				__FUNCTION__, (*c)->id);
1482 
1483 				goto free_return;
1484 	}
1485 
1486 	spin_lock_init(&ch->collect_lock);
1487 
1488 	fsm_settimer(ch->fsm, &ch->timer);
1489 	skb_queue_head_init(&ch->io_queue);
1490 	skb_queue_head_init(&ch->collect_queue);
1491 
1492 	if (IS_MPC(priv)) {
1493 		fsm_settimer(ch->fsm, &ch->sweep_timer);
1494 		skb_queue_head_init(&ch->sweep_queue);
1495 	}
1496 	ch->next = *c;
1497 	*c = ch;
1498 	return 0;
1499 
1500 nomem_return:
1501 	ctcm_pr_warn("ctcm: Out of memory in %s\n", __FUNCTION__);
1502 	rc = -ENOMEM;
1503 
1504 free_return:	/* note that all channel pointers are 0 or valid */
1505 	kfree(ch->ccw);		/* TODO: check that again */
1506 	kfree(ch->discontact_th);
1507 	kfree_fsm(ch->fsm);
1508 	kfree(ch->irb);
1509 	kfree(ch);
1510 	return rc;
1511 }
1512 
1513 /*
1514  * Return type of a detected device.
1515  */
1516 static enum channel_types get_channel_type(struct ccw_device_id *id)
1517 {
1518 	enum channel_types type;
1519 	type = (enum channel_types)id->driver_info;
1520 
1521 	if (type == channel_type_ficon)
1522 		type = channel_type_escon;
1523 
1524 	return type;
1525 }
1526 
1527 /**
1528  *
1529  * Setup an interface.
1530  *
1531  *  cgdev	Device to be setup.
1532  *
1533  * returns 0 on success, !0 on failure.
1534  */
1535 static int ctcm_new_device(struct ccwgroup_device *cgdev)
1536 {
1537 	char read_id[CTCM_ID_SIZE];
1538 	char write_id[CTCM_ID_SIZE];
1539 	int direction;
1540 	enum channel_types type;
1541 	struct ctcm_priv *priv;
1542 	struct net_device *dev;
1543 	int ret;
1544 
1545 	CTCM_DBF_TEXT(SETUP, CTC_DBF_INFO, __FUNCTION__);
1546 
1547 	priv = dev_get_drvdata(&cgdev->dev);
1548 	if (!priv)
1549 		return -ENODEV;
1550 
1551 	type = get_channel_type(&cgdev->cdev[0]->id);
1552 
1553 	snprintf(read_id, CTCM_ID_SIZE, "ch-%s", cgdev->cdev[0]->dev.bus_id);
1554 	snprintf(write_id, CTCM_ID_SIZE, "ch-%s", cgdev->cdev[1]->dev.bus_id);
1555 
1556 	ret = add_channel(cgdev->cdev[0], type, priv);
1557 	if (ret)
1558 		return ret;
1559 	ret = add_channel(cgdev->cdev[1], type, priv);
1560 	if (ret)
1561 		return ret;
1562 
1563 	ret = ccw_device_set_online(cgdev->cdev[0]);
1564 	if (ret != 0) {
1565 		CTCM_DBF_TEXT(SETUP, CTC_DBF_WARN,
1566 				"ccw_device_set_online (cdev[0]) failed ");
1567 		ctcm_pr_warn("ccw_device_set_online (cdev[0]) failed "
1568 				"with ret = %d\n", ret);
1569 	}
1570 
1571 	ret = ccw_device_set_online(cgdev->cdev[1]);
1572 	if (ret != 0) {
1573 		CTCM_DBF_TEXT(SETUP, CTC_DBF_WARN,
1574 				"ccw_device_set_online (cdev[1]) failed ");
1575 		ctcm_pr_warn("ccw_device_set_online (cdev[1]) failed "
1576 				"with ret = %d\n", ret);
1577 	}
1578 
1579 	dev = ctcm_init_netdevice(priv);
1580 
1581 	if (dev == NULL) {
1582 		ctcm_pr_warn("ctcm_init_netdevice failed\n");
1583 					goto out;
1584 	}
1585 
1586 	for (direction = READ; direction <= WRITE; direction++) {
1587 		priv->channel[direction] =
1588 		    channel_get(type, direction == READ ? read_id : write_id,
1589 				direction);
1590 		if (priv->channel[direction] == NULL) {
1591 			if (direction == WRITE)
1592 				channel_free(priv->channel[READ]);
1593 			ctcm_free_netdevice(dev);
1594 					goto out;
1595 		}
1596 		priv->channel[direction]->netdev = dev;
1597 		priv->channel[direction]->protocol = priv->protocol;
1598 		priv->channel[direction]->max_bufsize = priv->buffer_size;
1599 	}
1600 	/* sysfs magic */
1601 	SET_NETDEV_DEV(dev, &cgdev->dev);
1602 
1603 	if (ctcm_netdev_register(dev) != 0) {
1604 		ctcm_free_netdevice(dev);
1605 					goto out;
1606 	}
1607 
1608 	if (ctcm_add_attributes(&cgdev->dev)) {
1609 		ctcm_netdev_unregister(dev);
1610 /*		dev->priv = NULL;	why that ????	*/
1611 		ctcm_free_netdevice(dev);
1612 					goto out;
1613 	}
1614 
1615 	strlcpy(priv->fsm->name, dev->name, sizeof(priv->fsm->name));
1616 
1617 	CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO,
1618 			"setup(%s) ok : r/w = %s / %s, proto : %d",
1619 			dev->name, priv->channel[READ]->id,
1620 			priv->channel[WRITE]->id, priv->protocol);
1621 
1622 	return 0;
1623 out:
1624 	ccw_device_set_offline(cgdev->cdev[1]);
1625 	ccw_device_set_offline(cgdev->cdev[0]);
1626 
1627 	return -ENODEV;
1628 }
1629 
1630 /**
1631  * Shutdown an interface.
1632  *
1633  *  cgdev	Device to be shut down.
1634  *
1635  * returns 0 on success, !0 on failure.
1636  */
1637 static int ctcm_shutdown_device(struct ccwgroup_device *cgdev)
1638 {
1639 	struct ctcm_priv *priv;
1640 	struct net_device *dev;
1641 
1642 	priv = dev_get_drvdata(&cgdev->dev);
1643 	if (!priv)
1644 		return -ENODEV;
1645 
1646 	if (priv->channel[READ]) {
1647 		dev = priv->channel[READ]->netdev;
1648 		CTCM_DBF_DEV(SETUP, dev, "");
1649 		/* Close the device */
1650 		ctcm_close(dev);
1651 		dev->flags &= ~IFF_RUNNING;
1652 		ctcm_remove_attributes(&cgdev->dev);
1653 		channel_free(priv->channel[READ]);
1654 	} else
1655 		dev = NULL;
1656 
1657 	if (priv->channel[WRITE])
1658 		channel_free(priv->channel[WRITE]);
1659 
1660 	if (dev) {
1661 		ctcm_netdev_unregister(dev);
1662 /*		dev->priv = NULL;	why that ???	*/
1663 		ctcm_free_netdevice(dev);
1664 	}
1665 
1666 	if (priv->fsm)
1667 		kfree_fsm(priv->fsm);
1668 
1669 	ccw_device_set_offline(cgdev->cdev[1]);
1670 	ccw_device_set_offline(cgdev->cdev[0]);
1671 
1672 	if (priv->channel[READ])
1673 		channel_remove(priv->channel[READ]);
1674 	if (priv->channel[WRITE])
1675 		channel_remove(priv->channel[WRITE]);
1676 	priv->channel[READ] = priv->channel[WRITE] = NULL;
1677 
1678 	return 0;
1679 
1680 }
1681 
1682 
1683 static void ctcm_remove_device(struct ccwgroup_device *cgdev)
1684 {
1685 	struct ctcm_priv *priv;
1686 
1687 	CTCM_DBF_TEXT(SETUP, CTC_DBF_ERROR, __FUNCTION__);
1688 
1689 	priv = dev_get_drvdata(&cgdev->dev);
1690 	if (!priv)
1691 		return;
1692 	if (cgdev->state == CCWGROUP_ONLINE)
1693 		ctcm_shutdown_device(cgdev);
1694 	ctcm_remove_files(&cgdev->dev);
1695 	dev_set_drvdata(&cgdev->dev, NULL);
1696 	kfree(priv);
1697 	put_device(&cgdev->dev);
1698 }
1699 
1700 static struct ccwgroup_driver ctcm_group_driver = {
1701 	.owner       = THIS_MODULE,
1702 	.name        = CTC_DRIVER_NAME,
1703 	.max_slaves  = 2,
1704 	.driver_id   = 0xC3E3C3D4,	/* CTCM */
1705 	.probe       = ctcm_probe_device,
1706 	.remove      = ctcm_remove_device,
1707 	.set_online  = ctcm_new_device,
1708 	.set_offline = ctcm_shutdown_device,
1709 };
1710 
1711 
1712 /*
1713  * Module related routines
1714  */
1715 
1716 /*
1717  * Prepare to be unloaded. Free IRQ's and release all resources.
1718  * This is called just before this module is unloaded. It is
1719  * not called, if the usage count is !0, so we don't need to check
1720  * for that.
1721  */
1722 static void __exit ctcm_exit(void)
1723 {
1724 	unregister_cu3088_discipline(&ctcm_group_driver);
1725 	ctcm_unregister_dbf_views();
1726 	ctcm_pr_info("CTCM driver unloaded\n");
1727 }
1728 
1729 /*
1730  * Print Banner.
1731  */
1732 static void print_banner(void)
1733 {
1734 	printk(KERN_INFO "CTCM driver initialized\n");
1735 }
1736 
1737 /**
1738  * Initialize module.
1739  * This is called just after the module is loaded.
1740  *
1741  * returns 0 on success, !0 on error.
1742  */
1743 static int __init ctcm_init(void)
1744 {
1745 	int ret;
1746 
1747 	channels = NULL;
1748 
1749 	ret = ctcm_register_dbf_views();
1750 	if (ret) {
1751 		ctcm_pr_crit("ctcm_init failed with ctcm_register_dbf_views "
1752 				"rc = %d\n", ret);
1753 		return ret;
1754 	}
1755 	ret = register_cu3088_discipline(&ctcm_group_driver);
1756 	if (ret) {
1757 		ctcm_unregister_dbf_views();
1758 		ctcm_pr_crit("ctcm_init failed with register_cu3088_discipline "
1759 				"(rc = %d)\n", ret);
1760 		return ret;
1761 	}
1762 	print_banner();
1763 	return ret;
1764 }
1765 
1766 module_init(ctcm_init);
1767 module_exit(ctcm_exit);
1768 
1769 MODULE_AUTHOR("Peter Tiedemann <ptiedem@de.ibm.com>");
1770 MODULE_DESCRIPTION("Network driver for S/390 CTC + CTCMPC (SNA)");
1771 MODULE_LICENSE("GPL");
1772 
1773