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