1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
57
58
59
60
61static struct device *ctcm_root_dev;
62
63
64
65
66struct channel *channels;
67
68
69
70
71
72
73
74
75void 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(pskb, 2 + LL_HEADER_LENGTH);
82 skb_pull(pskb, 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(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
97
98
99
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(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(pskb, header->length);
143 skb_reset_mac_header(pskb);
144 len -= header->length;
145 skb = dev_alloc_skb(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(pskb, skb_put(skb, pskb->len),
157 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
165
166 ch->logflags = 0;
167 priv->stats.rx_packets++;
168 priv->stats.rx_bytes += skblen;
169 netif_rx_ni(skb);
170 if (len > 0) {
171 skb_pull(pskb, header->length);
172 if (skb_tailroom(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(pskb, LL_HEADER_LENGTH);
179 }
180 }
181}
182
183
184
185
186
187
188static 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(ch->fsm, CTC_STATE_IDLE);
193}
194
195
196
197
198
199
200static void channel_remove(struct channel *ch)
201{
202 struct channel **c = &channels;
203 char chid[CTCM_ID_SIZE+1];
204 int ok = 0;
205
206 if (ch == NULL)
207 return;
208 else
209 strncpy(chid, ch->id, CTCM_ID_SIZE);
210
211 channel_free(ch);
212 while (*c) {
213 if (*c == ch) {
214 *c = ch->next;
215 fsm_deltimer(&ch->timer);
216 if (IS_MPC(ch))
217 fsm_deltimer(&ch->sweep_timer);
218
219 kfree_fsm(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(ch->trans_skb);
224 }
225 if (IS_MPC(ch)) {
226 tasklet_kill(&ch->ch_tasklet);
227 tasklet_kill(&ch->ch_disc_tasklet);
228 kfree(ch->discontact_th);
229 }
230 kfree(ch->ccw);
231 kfree(ch->irb);
232 kfree(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
245
246
247
248
249
250
251
252static 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(ch->fsm, CTC_STATE_STOPPED);
272 }
273 }
274 return ch;
275}
276
277static long ctcm_check_irb_error(struct ccw_device *cdev, struct irb *irb)
278{
279 if (!IS_ERR(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(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(irb);
300}
301
302
303
304
305
306
307
308
309static 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(ch->fsm, CTC_EVENT_UC_RCRESET, 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(ch->fsm, CTC_EVENT_UC_RSRESET, 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(ch->fsm, CTC_EVENT_UC_HWFAIL, 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(ch->fsm, CTC_EVENT_UC_RXPARITY, 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)
359 fsm_event(ch->fsm, CTC_EVENT_UC_TXTIMEOUT, ch);
360 else
361 fsm_event(ch->fsm, CTC_EVENT_UC_TXPARITY, 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(ch->fsm, CTC_EVENT_UC_ZERO, 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(ch->fsm, CTC_EVENT_UC_UNKNOWN, ch);
379 }
380}
381
382int ctcm_ch_alloc_buffer(struct channel *ch)
383{
384 clear_normalized_cda(&ch->ccw[1]);
385 ch->trans_skb = __dev_alloc_skb(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
415
416
417
418
419
420
421
422
423
424
425int 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(priv->fsm, DEV_EVENT_START, dev);
432 return 0;
433}
434
435
436
437
438
439
440
441
442
443int 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(priv->fsm, DEV_EVENT_STOP, dev);
450 return 0;
451}
452
453
454
455
456
457
458
459
460
461
462
463
464
465static 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
476
477
478
479 spin_lock_irqsave(&ch->collect_lock, saveflags);
480 if (fsm_getstate(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(&ch->collect_lock, saveflags);
485 return -EBUSY;
486 } else {
487 refcount_inc(&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(&ch->collect_queue, skb);
494 ch->collect_len += l;
495 }
496 spin_unlock_irqrestore(&ch->collect_lock, saveflags);
497 goto done;
498 }
499 spin_unlock_irqrestore(&ch->collect_lock, saveflags);
500
501
502
503
504 refcount_inc(&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, 2)) = block_len;
512
513
514
515
516
517 hi = ((unsigned long)skb_tail_pointer(skb) + LL_HEADER_LENGTH) >> 31;
518 if (hi) {
519 nskb = alloc_skb(skb->len, GFP_ATOMIC | GFP_DMA);
520 if (!nskb) {
521 refcount_dec(&skb->users);
522 skb_pull(skb, LL_HEADER_LENGTH + 2);
523 ctcm_clear_busy(ch->netdev);
524 return -ENOMEM;
525 } else {
526 skb_put_data(nskb, skb->data, skb->len);
527 refcount_inc(&nskb->users);
528 refcount_dec(&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
538
539
540
541 if (ctcm_checkalloc_buffer(ch)) {
542
543
544
545
546 refcount_dec(&skb->users);
547 skb_pull(skb, LL_HEADER_LENGTH + 2);
548 ctcm_clear_busy(ch->netdev);
549 return -ENOMEM;
550 }
551
552 skb_reset_tail_pointer(ch->trans_skb);
553 ch->trans_skb->len = 0;
554 ch->ccw[1].count = skb->len;
555 skb_copy_from_linear_data(skb,
556 skb_put(ch->trans_skb, skb->len), skb->len);
557 refcount_dec(&skb->users);
558 dev_kfree_skb_irq(skb);
559 ccw_idx = 0;
560 } else {
561 skb_queue_tail(&ch->io_queue, 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(ch->fsm, CTC_STATE_TX);
569 fsm_addtimer(&ch->timer, CTCM_TIME_5_SEC, CTC_EVENT_TIMER, 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(get_ccwdev_lock(ch->cdev), saveflags);
574 if (ccw_idx == 3)
575 ch->prof.doios_single++;
576 if (rc != 0) {
577 fsm_deltimer(&ch->timer);
578 ctcm_ccw_check_rc(ch, rc, "single skb TX");
579 if (ccw_idx == 3)
580 skb_dequeue_tail(&ch->io_queue);
581
582
583
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 }
592done:
593 ctcm_clear_busy(ch->netdev);
594 return rc;
595}
596
597static 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
606
607 priv = dev->ml_priv;
608 grp = priv->mpcg;
609 ch = priv->channel[CTCM_WRITE];
610
611
612
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
623 goto nomem;
624 }
625
626 header = skb_put_zero(sweep_skb, TH_SWEEP_LENGTH);
627 header->th.th_ch_flag = TH_SWEEP_REQ;
628 header->sw.th_last_seq = ch->th_seq_num;
629
630 netif_trans_update(dev);
631 skb_queue_tail(&ch->sweep_queue, sweep_skb);
632
633 fsm_addtimer(&ch->sweep_timer, 100, CTC_EVENT_RSWEEP_TIMER, ch);
634
635 return;
636
637nomem:
638 grp->in_sweep = 0;
639 ctcm_clear_busy(dev);
640 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
641
642 return;
643}
644
645
646
647
648static 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;
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(ch->fsm) != CTC_STATE_TXIDLE) || grp->in_sweep) {
666 spin_lock_irqsave(&ch->collect_lock, saveflags);
667 refcount_inc(&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(&ch->collect_queue, skb);
685 ch->collect_len += skb->len;
686
687 spin_unlock_irqrestore(&ch->collect_lock, saveflags);
688 goto done;
689 }
690
691
692
693
694
695 refcount_inc(&skb->users);
696
697
698
699
700
701 hi = ((unsigned long)skb->tail + TH_HEADER_LENGTH) >> 31;
702 if (hi) {
703 nskb = __dev_alloc_skb(skb->len, GFP_ATOMIC | GFP_DMA);
704 if (!nskb) {
705 goto nomem_exit;
706 } else {
707 skb_put_data(nskb, skb->data, skb->len);
708 refcount_inc(&nskb->users);
709 refcount_dec(&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(&ch->collect_queue, skb);
728 ch->collect_len += skb->len;
729 skb = skb_dequeue(&ch->collect_queue);
730 ch->collect_len -= skb->len;
731 spin_unlock_irqrestore(&ch->collect_lock, 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
740 header = skb_push(skb, TH_HEADER_LENGTH);
741 memset(header, 0, TH_HEADER_LENGTH);
742
743 header->th_ch_flag = TH_HAS_PDU;
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
759
760
761 if (ctcm_checkalloc_buffer(ch)) {
762
763
764
765
766 goto nomem_exit;
767 }
768
769 skb_reset_tail_pointer(ch->trans_skb);
770 ch->trans_skb->len = 0;
771 ch->ccw[1].count = skb->len;
772 skb_put_data(ch->trans_skb, skb->data, skb->len);
773 refcount_dec(&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(&ch->io_queue, skb);
783 ccw_idx = 3;
784 }
785 ch->retry = 0;
786 fsm_newstate(ch->fsm, CTC_STATE_TX);
787 fsm_addtimer(&ch->timer, CTCM_TIME_5_SEC, CTC_EVENT_TIMER, 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(get_ccwdev_lock(ch->cdev), saveflags);
797 if (ccw_idx == 3)
798 ch->prof.doios_single++;
799 if (rc != 0) {
800 fsm_deltimer(&ch->timer);
801 ctcm_ccw_check_rc(ch, rc, "single skb TX");
802 if (ccw_idx == 3)
803 skb_dequeue_tail(&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)
809 ctcmpc_send_sweep_req(ch);
810
811 goto done;
812nomem_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(&skb->users);
818 dev_kfree_skb_any(skb);
819 fsm_event(priv->mpcg->fsm, MPCG_EVENT_INOP, dev);
820done:
821 CTCM_PR_DEBUG("Exit %s(%s)\n", __func__, dev->name);
822 return rc;
823}
824
825
826
827
828
829
830
831
832
833
834
835
836
837static int ctcm_tx(struct sk_buff *skb, struct net_device *dev)
838{
839 struct ctcm_priv *priv = dev->ml_priv;
840
841 if (skb == NULL) {
842 CTCM_DBF_TEXT_(ERROR, CTC_DBF_ERROR,
843 "%s(%s): NULL sk_buff passed",
844 CTCM_FUNTAIL, dev->name);
845 priv->stats.tx_dropped++;
846 return NETDEV_TX_OK;
847 }
848 if (skb_headroom(skb) < (LL_HEADER_LENGTH + 2)) {
849 CTCM_DBF_TEXT_(ERROR, CTC_DBF_ERROR,
850 "%s(%s): Got sk_buff with head room < %ld bytes",
851 CTCM_FUNTAIL, dev->name, LL_HEADER_LENGTH + 2);
852 dev_kfree_skb(skb);
853 priv->stats.tx_dropped++;
854 return NETDEV_TX_OK;
855 }
856
857
858
859
860
861 if (fsm_getstate(priv->fsm) != DEV_STATE_RUNNING) {
862 fsm_event(priv->fsm, DEV_EVENT_START, dev);
863 dev_kfree_skb(skb);
864 priv->stats.tx_dropped++;
865 priv->stats.tx_errors++;
866 priv->stats.tx_carrier_errors++;
867 return NETDEV_TX_OK;
868 }
869
870 if (ctcm_test_and_set_busy(dev))
871 return NETDEV_TX_BUSY;
872
873 netif_trans_update(dev);
874 if (ctcm_transmit_skb(priv->channel[CTCM_WRITE], skb) != 0)
875 return NETDEV_TX_BUSY;
876 return NETDEV_TX_OK;
877}
878
879
880static int ctcmpc_tx(struct sk_buff *skb, struct net_device *dev)
881{
882 int len = 0;
883 struct ctcm_priv *priv = dev->ml_priv;
884 struct mpc_group *grp = priv->mpcg;
885 struct sk_buff *newskb = NULL;
886
887
888
889
890 if (skb == NULL) {
891 CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
892 "%s(%s): NULL sk_buff passed",
893 CTCM_FUNTAIL, dev->name);
894 priv->stats.tx_dropped++;
895 goto done;
896 }
897 if (skb_headroom(skb) < (TH_HEADER_LENGTH + PDU_HEADER_LENGTH)) {
898 CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_ERROR,
899 "%s(%s): Got sk_buff with head room < %ld bytes",
900 CTCM_FUNTAIL, dev->name,
901 TH_HEADER_LENGTH + PDU_HEADER_LENGTH);
902
903 CTCM_D3_DUMP((char *)skb->data, min_t(int, 32, skb->len));
904
905 len = skb->len + TH_HEADER_LENGTH + PDU_HEADER_LENGTH;
906 newskb = __dev_alloc_skb(len, GFP_ATOMIC | GFP_DMA);
907
908 if (!newskb) {
909 CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_ERROR,
910 "%s: %s: __dev_alloc_skb failed",
911 __func__, dev->name);
912
913 dev_kfree_skb_any(skb);
914 priv->stats.tx_dropped++;
915 priv->stats.tx_errors++;
916 priv->stats.tx_carrier_errors++;
917 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
918 goto done;
919 }
920 newskb->protocol = skb->protocol;
921 skb_reserve(newskb, TH_HEADER_LENGTH + PDU_HEADER_LENGTH);
922 skb_put_data(newskb, skb->data, skb->len);
923 dev_kfree_skb_any(skb);
924 skb = newskb;
925 }
926
927
928
929
930
931
932 if ((fsm_getstate(priv->fsm) != DEV_STATE_RUNNING) ||
933 (fsm_getstate(grp->fsm) < MPCG_STATE_XID2INITW)) {
934 dev_kfree_skb_any(skb);
935 CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
936 "%s(%s): inactive MPCGROUP - dropped",
937 CTCM_FUNTAIL, dev->name);
938 priv->stats.tx_dropped++;
939 priv->stats.tx_errors++;
940 priv->stats.tx_carrier_errors++;
941 goto done;
942 }
943
944 if (ctcm_test_and_set_busy(dev)) {
945 CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
946 "%s(%s): device busy - dropped",
947 CTCM_FUNTAIL, dev->name);
948 dev_kfree_skb_any(skb);
949 priv->stats.tx_dropped++;
950 priv->stats.tx_errors++;
951 priv->stats.tx_carrier_errors++;
952 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
953 goto done;
954 }
955
956 netif_trans_update(dev);
957 if (ctcmpc_transmit_skb(priv->channel[CTCM_WRITE], skb) != 0) {
958 CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
959 "%s(%s): device error - dropped",
960 CTCM_FUNTAIL, dev->name);
961 dev_kfree_skb_any(skb);
962 priv->stats.tx_dropped++;
963 priv->stats.tx_errors++;
964 priv->stats.tx_carrier_errors++;
965 ctcm_clear_busy(dev);
966 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
967 goto done;
968 }
969 ctcm_clear_busy(dev);
970done:
971 if (do_debug)
972 MPC_DBF_DEV_NAME(TRACE, dev, "exit");
973
974 return NETDEV_TX_OK;
975}
976
977
978
979
980
981
982
983
984
985
986
987
988
989static int ctcm_change_mtu(struct net_device *dev, int new_mtu)
990{
991 struct ctcm_priv *priv;
992 int max_bufsize;
993
994 priv = dev->ml_priv;
995 max_bufsize = priv->channel[CTCM_READ]->max_bufsize;
996
997 if (IS_MPC(priv)) {
998 if (new_mtu > max_bufsize - TH_HEADER_LENGTH)
999 return -EINVAL;
1000 dev->hard_header_len = TH_HEADER_LENGTH + PDU_HEADER_LENGTH;
1001 } else {
1002 if (new_mtu > max_bufsize - LL_HEADER_LENGTH - 2)
1003 return -EINVAL;
1004 dev->hard_header_len = LL_HEADER_LENGTH + 2;
1005 }
1006 dev->mtu = new_mtu;
1007 return 0;
1008}
1009
1010
1011
1012
1013
1014
1015
1016
1017static struct net_device_stats *ctcm_stats(struct net_device *dev)
1018{
1019 return &((struct ctcm_priv *)dev->ml_priv)->stats;
1020}
1021
1022static void ctcm_free_netdevice(struct net_device *dev)
1023{
1024 struct ctcm_priv *priv;
1025 struct mpc_group *grp;
1026
1027 CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO,
1028 "%s(%s)", CTCM_FUNTAIL, dev->name);
1029 priv = dev->ml_priv;
1030 if (priv) {
1031 grp = priv->mpcg;
1032 if (grp) {
1033 if (grp->fsm)
1034 kfree_fsm(grp->fsm);
1035 dev_kfree_skb(grp->xid_skb);
1036 dev_kfree_skb(grp->rcvd_xid_skb);
1037 tasklet_kill(&grp->mpc_tasklet2);
1038 kfree(grp);
1039 priv->mpcg = NULL;
1040 }
1041 if (priv->fsm) {
1042 kfree_fsm(priv->fsm);
1043 priv->fsm = NULL;
1044 }
1045 kfree(priv->xid);
1046 priv->xid = NULL;
1047
1048
1049
1050
1051 }
1052#ifdef MODULE
1053 free_netdev(dev);
1054#endif
1055}
1056
1057struct mpc_group *ctcmpc_init_mpc_group(struct ctcm_priv *priv);
1058
1059static const struct net_device_ops ctcm_netdev_ops = {
1060 .ndo_open = ctcm_open,
1061 .ndo_stop = ctcm_close,
1062 .ndo_get_stats = ctcm_stats,
1063 .ndo_change_mtu = ctcm_change_mtu,
1064 .ndo_start_xmit = ctcm_tx,
1065};
1066
1067static const struct net_device_ops ctcm_mpc_netdev_ops = {
1068 .ndo_open = ctcm_open,
1069 .ndo_stop = ctcm_close,
1070 .ndo_get_stats = ctcm_stats,
1071 .ndo_change_mtu = ctcm_change_mtu,
1072 .ndo_start_xmit = ctcmpc_tx,
1073};
1074
1075static void ctcm_dev_setup(struct net_device *dev)
1076{
1077 dev->type = ARPHRD_SLIP;
1078 dev->tx_queue_len = 100;
1079 dev->flags = IFF_POINTOPOINT | IFF_NOARP;
1080 dev->min_mtu = 576;
1081 dev->max_mtu = 65527;
1082}
1083
1084
1085
1086
1087
1088static struct net_device *ctcm_init_netdevice(struct ctcm_priv *priv)
1089{
1090 struct net_device *dev;
1091 struct mpc_group *grp;
1092 if (!priv)
1093 return NULL;
1094
1095 if (IS_MPC(priv))
1096 dev = alloc_netdev(0, MPC_DEVICE_GENE, NET_NAME_UNKNOWN,
1097 ctcm_dev_setup);
1098 else
1099 dev = alloc_netdev(0, CTC_DEVICE_GENE, NET_NAME_UNKNOWN,
1100 ctcm_dev_setup);
1101
1102 if (!dev) {
1103 CTCM_DBF_TEXT_(ERROR, CTC_DBF_CRIT,
1104 "%s: MEMORY allocation ERROR",
1105 CTCM_FUNTAIL);
1106 return NULL;
1107 }
1108 dev->ml_priv = priv;
1109 priv->fsm = init_fsm("ctcmdev", dev_state_names, dev_event_names,
1110 CTCM_NR_DEV_STATES, CTCM_NR_DEV_EVENTS,
1111 dev_fsm, dev_fsm_len, GFP_KERNEL);
1112 if (priv->fsm == NULL) {
1113 CTCMY_DBF_DEV(SETUP, dev, "init_fsm error");
1114 free_netdev(dev);
1115 return NULL;
1116 }
1117 fsm_newstate(priv->fsm, DEV_STATE_STOPPED);
1118 fsm_settimer(priv->fsm, &priv->restart_timer);
1119
1120 if (IS_MPC(priv)) {
1121
1122 grp = ctcmpc_init_mpc_group(priv);
1123 if (grp == NULL) {
1124 MPC_DBF_DEV(SETUP, dev, "init_mpc_group error");
1125 free_netdev(dev);
1126 return NULL;
1127 }
1128 tasklet_init(&grp->mpc_tasklet2,
1129 mpc_group_ready, (unsigned long)dev);
1130 dev->mtu = MPC_BUFSIZE_DEFAULT -
1131 TH_HEADER_LENGTH - PDU_HEADER_LENGTH;
1132
1133 dev->netdev_ops = &ctcm_mpc_netdev_ops;
1134 dev->hard_header_len = TH_HEADER_LENGTH + PDU_HEADER_LENGTH;
1135 priv->buffer_size = MPC_BUFSIZE_DEFAULT;
1136 } else {
1137 dev->mtu = CTCM_BUFSIZE_DEFAULT - LL_HEADER_LENGTH - 2;
1138 dev->netdev_ops = &ctcm_netdev_ops;
1139 dev->hard_header_len = LL_HEADER_LENGTH + 2;
1140 }
1141
1142 CTCMY_DBF_DEV(SETUP, dev, "finished");
1143
1144 return dev;
1145}
1146
1147
1148
1149
1150
1151
1152
1153
1154static void ctcm_irq_handler(struct ccw_device *cdev,
1155 unsigned long intparm, struct irb *irb)
1156{
1157 struct channel *ch;
1158 struct net_device *dev;
1159 struct ctcm_priv *priv;
1160 struct ccwgroup_device *cgdev;
1161 int cstat;
1162 int dstat;
1163
1164 CTCM_DBF_TEXT_(TRACE, CTC_DBF_DEBUG,
1165 "Enter %s(%s)", CTCM_FUNTAIL, dev_name(&cdev->dev));
1166
1167 if (ctcm_check_irb_error(cdev, irb))
1168 return;
1169
1170 cgdev = dev_get_drvdata(&cdev->dev);
1171
1172 cstat = irb->scsw.cmd.cstat;
1173 dstat = irb->scsw.cmd.dstat;
1174
1175
1176 if (cgdev == NULL) {
1177 CTCM_DBF_TEXT_(TRACE, CTC_DBF_ERROR,
1178 "%s(%s) unsolicited irq: c-%02x d-%02x\n",
1179 CTCM_FUNTAIL, dev_name(&cdev->dev), cstat, dstat);
1180 dev_warn(&cdev->dev,
1181 "The adapter received a non-specific IRQ\n");
1182 return;
1183 }
1184
1185 priv = dev_get_drvdata(&cgdev->dev);
1186
1187
1188 if (priv->channel[CTCM_READ]->cdev == cdev)
1189 ch = priv->channel[CTCM_READ];
1190 else if (priv->channel[CTCM_WRITE]->cdev == cdev)
1191 ch = priv->channel[CTCM_WRITE];
1192 else {
1193 dev_err(&cdev->dev,
1194 "%s: Internal error: Can't determine channel for "
1195 "interrupt device %s\n",
1196 __func__, dev_name(&cdev->dev));
1197
1198 return;
1199 }
1200
1201 dev = ch->netdev;
1202 if (dev == NULL) {
1203 dev_err(&cdev->dev,
1204 "%s Internal error: net_device is NULL, ch = 0x%p\n",
1205 __func__, ch);
1206
1207 return;
1208 }
1209
1210
1211 memcpy(ch->irb, irb, sizeof(struct irb));
1212
1213
1214 if (irb->scsw.cmd.cstat) {
1215 fsm_event(ch->fsm, CTC_EVENT_SC_UNKNOWN, ch);
1216 CTCM_DBF_TEXT_(TRACE, CTC_DBF_WARN,
1217 "%s(%s): sub-ch check %s: cs=%02x ds=%02x",
1218 CTCM_FUNTAIL, dev->name, ch->id, cstat, dstat);
1219 dev_warn(&cdev->dev,
1220 "A check occurred on the subchannel\n");
1221 return;
1222 }
1223
1224
1225 if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
1226 if ((irb->ecw[0] & ch->sense_rc) == 0)
1227
1228 CTCM_DBF_TEXT_(TRACE, CTC_DBF_WARN,
1229 "%s(%s): sense=%02x, ds=%02x",
1230 CTCM_FUNTAIL, ch->id, irb->ecw[0], dstat);
1231 ccw_unit_check(ch, irb->ecw[0]);
1232 return;
1233 }
1234 if (irb->scsw.cmd.dstat & DEV_STAT_BUSY) {
1235 if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION)
1236 fsm_event(ch->fsm, CTC_EVENT_ATTNBUSY, ch);
1237 else
1238 fsm_event(ch->fsm, CTC_EVENT_BUSY, ch);
1239 return;
1240 }
1241 if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
1242 fsm_event(ch->fsm, CTC_EVENT_ATTN, ch);
1243 return;
1244 }
1245 if ((irb->scsw.cmd.stctl & SCSW_STCTL_SEC_STATUS) ||
1246 (irb->scsw.cmd.stctl == SCSW_STCTL_STATUS_PEND) ||
1247 (irb->scsw.cmd.stctl ==
1248 (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND)))
1249 fsm_event(ch->fsm, CTC_EVENT_FINSTAT, ch);
1250 else
1251 fsm_event(ch->fsm, CTC_EVENT_IRQ, ch);
1252
1253}
1254
1255static const struct device_type ctcm_devtype = {
1256 .name = "ctcm",
1257 .groups = ctcm_attr_groups,
1258};
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268static int ctcm_probe_device(struct ccwgroup_device *cgdev)
1269{
1270 struct ctcm_priv *priv;
1271
1272 CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO,
1273 "%s %p",
1274 __func__, cgdev);
1275
1276 if (!get_device(&cgdev->dev))
1277 return -ENODEV;
1278
1279 priv = kzalloc(sizeof(struct ctcm_priv), GFP_KERNEL);
1280 if (!priv) {
1281 CTCM_DBF_TEXT_(ERROR, CTC_DBF_ERROR,
1282 "%s: memory allocation failure",
1283 CTCM_FUNTAIL);
1284 put_device(&cgdev->dev);
1285 return -ENOMEM;
1286 }
1287 priv->buffer_size = CTCM_BUFSIZE_DEFAULT;
1288 cgdev->cdev[0]->handler = ctcm_irq_handler;
1289 cgdev->cdev[1]->handler = ctcm_irq_handler;
1290 dev_set_drvdata(&cgdev->dev, priv);
1291 cgdev->dev.type = &ctcm_devtype;
1292
1293 return 0;
1294}
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306static int add_channel(struct ccw_device *cdev, enum ctcm_channel_types type,
1307 struct ctcm_priv *priv)
1308{
1309 struct channel **c = &channels;
1310 struct channel *ch;
1311 int ccw_num;
1312 int rc = 0;
1313
1314 CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO,
1315 "%s(%s), type %d, proto %d",
1316 __func__, dev_name(&cdev->dev), type, priv->protocol);
1317
1318 ch = kzalloc(sizeof(struct channel), GFP_KERNEL);
1319 if (ch == NULL)
1320 return -ENOMEM;
1321
1322 ch->protocol = priv->protocol;
1323 if (IS_MPC(priv)) {
1324 ch->discontact_th = kzalloc(TH_HEADER_LENGTH, GFP_KERNEL);
1325 if (ch->discontact_th == NULL)
1326 goto nomem_return;
1327
1328 ch->discontact_th->th_blk_flag = TH_DISCONTACT;
1329 tasklet_init(&ch->ch_disc_tasklet,
1330 mpc_action_send_discontact, (unsigned long)ch);
1331
1332 tasklet_init(&ch->ch_tasklet, ctcmpc_bh, (unsigned long)ch);
1333 ch->max_bufsize = (MPC_BUFSIZE_DEFAULT - 35);
1334 ccw_num = 17;
1335 } else
1336 ccw_num = 8;
1337
1338 ch->ccw = kcalloc(ccw_num, sizeof(struct ccw1), GFP_KERNEL | GFP_DMA);
1339 if (ch->ccw == NULL)
1340 goto nomem_return;
1341
1342 ch->cdev = cdev;
1343 snprintf(ch->id, CTCM_ID_SIZE, "ch-%s", dev_name(&cdev->dev));
1344 ch->type = type;
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389 ch->ccw[6].cmd_code = CCW_CMD_SET_EXTENDED;
1390 ch->ccw[6].flags = CCW_FLAG_SLI;
1391
1392 ch->ccw[7].cmd_code = CCW_CMD_NOOP;
1393 ch->ccw[7].flags = CCW_FLAG_SLI;
1394
1395 if (IS_MPC(priv)) {
1396 ch->ccw[15].cmd_code = CCW_CMD_WRITE;
1397 ch->ccw[15].flags = CCW_FLAG_SLI | CCW_FLAG_CC;
1398 ch->ccw[15].count = TH_HEADER_LENGTH;
1399 ch->ccw[15].cda = virt_to_phys(ch->discontact_th);
1400
1401 ch->ccw[16].cmd_code = CCW_CMD_NOOP;
1402 ch->ccw[16].flags = CCW_FLAG_SLI;
1403
1404 ch->fsm = init_fsm(ch->id, ctc_ch_state_names,
1405 ctc_ch_event_names, CTC_MPC_NR_STATES,
1406 CTC_MPC_NR_EVENTS, ctcmpc_ch_fsm,
1407 mpc_ch_fsm_len, GFP_KERNEL);
1408 } else {
1409 ch->fsm = init_fsm(ch->id, ctc_ch_state_names,
1410 ctc_ch_event_names, CTC_NR_STATES,
1411 CTC_NR_EVENTS, ch_fsm,
1412 ch_fsm_len, GFP_KERNEL);
1413 }
1414 if (ch->fsm == NULL)
1415 goto nomem_return;
1416
1417 fsm_newstate(ch->fsm, CTC_STATE_IDLE);
1418
1419 ch->irb = kzalloc(sizeof(struct irb), GFP_KERNEL);
1420 if (ch->irb == NULL)
1421 goto nomem_return;
1422
1423 while (*c && ctcm_less_than((*c)->id, ch->id))
1424 c = &(*c)->next;
1425
1426 if (*c && (!strncmp((*c)->id, ch->id, CTCM_ID_SIZE))) {
1427 CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO,
1428 "%s (%s) already in list, using old entry",
1429 __func__, (*c)->id);
1430
1431 goto free_return;
1432 }
1433
1434 spin_lock_init(&ch->collect_lock);
1435
1436 fsm_settimer(ch->fsm, &ch->timer);
1437 skb_queue_head_init(&ch->io_queue);
1438 skb_queue_head_init(&ch->collect_queue);
1439
1440 if (IS_MPC(priv)) {
1441 fsm_settimer(ch->fsm, &ch->sweep_timer);
1442 skb_queue_head_init(&ch->sweep_queue);
1443 }
1444 ch->next = *c;
1445 *c = ch;
1446 return 0;
1447
1448nomem_return:
1449 rc = -ENOMEM;
1450
1451free_return:
1452 kfree(ch->ccw);
1453 kfree(ch->discontact_th);
1454 kfree_fsm(ch->fsm);
1455 kfree(ch->irb);
1456 kfree(ch);
1457 return rc;
1458}
1459
1460
1461
1462
1463static enum ctcm_channel_types get_channel_type(struct ccw_device_id *id)
1464{
1465 enum ctcm_channel_types type;
1466 type = (enum ctcm_channel_types)id->driver_info;
1467
1468 if (type == ctcm_channel_type_ficon)
1469 type = ctcm_channel_type_escon;
1470
1471 return type;
1472}
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482static int ctcm_new_device(struct ccwgroup_device *cgdev)
1483{
1484 char read_id[CTCM_ID_SIZE];
1485 char write_id[CTCM_ID_SIZE];
1486 int direction;
1487 enum ctcm_channel_types type;
1488 struct ctcm_priv *priv;
1489 struct net_device *dev;
1490 struct ccw_device *cdev0;
1491 struct ccw_device *cdev1;
1492 struct channel *readc;
1493 struct channel *writec;
1494 int ret;
1495 int result;
1496
1497 priv = dev_get_drvdata(&cgdev->dev);
1498 if (!priv) {
1499 result = -ENODEV;
1500 goto out_err_result;
1501 }
1502
1503 cdev0 = cgdev->cdev[0];
1504 cdev1 = cgdev->cdev[1];
1505
1506 type = get_channel_type(&cdev0->id);
1507
1508 snprintf(read_id, CTCM_ID_SIZE, "ch-%s", dev_name(&cdev0->dev));
1509 snprintf(write_id, CTCM_ID_SIZE, "ch-%s", dev_name(&cdev1->dev));
1510
1511 ret = add_channel(cdev0, type, priv);
1512 if (ret) {
1513 result = ret;
1514 goto out_err_result;
1515 }
1516 ret = add_channel(cdev1, type, priv);
1517 if (ret) {
1518 result = ret;
1519 goto out_remove_channel1;
1520 }
1521
1522 ret = ccw_device_set_online(cdev0);
1523 if (ret != 0) {
1524 CTCM_DBF_TEXT_(TRACE, CTC_DBF_NOTICE,
1525 "%s(%s) set_online rc=%d",
1526 CTCM_FUNTAIL, read_id, ret);
1527 result = -EIO;
1528 goto out_remove_channel2;
1529 }
1530
1531 ret = ccw_device_set_online(cdev1);
1532 if (ret != 0) {
1533 CTCM_DBF_TEXT_(TRACE, CTC_DBF_NOTICE,
1534 "%s(%s) set_online rc=%d",
1535 CTCM_FUNTAIL, write_id, ret);
1536
1537 result = -EIO;
1538 goto out_ccw1;
1539 }
1540
1541 dev = ctcm_init_netdevice(priv);
1542 if (dev == NULL) {
1543 result = -ENODEV;
1544 goto out_ccw2;
1545 }
1546
1547 for (direction = CTCM_READ; direction <= CTCM_WRITE; direction++) {
1548 priv->channel[direction] =
1549 channel_get(type, direction == CTCM_READ ?
1550 read_id : write_id, direction);
1551 if (priv->channel[direction] == NULL) {
1552 if (direction == CTCM_WRITE)
1553 channel_free(priv->channel[CTCM_READ]);
1554 result = -ENODEV;
1555 goto out_dev;
1556 }
1557 priv->channel[direction]->netdev = dev;
1558 priv->channel[direction]->protocol = priv->protocol;
1559 priv->channel[direction]->max_bufsize = priv->buffer_size;
1560 }
1561
1562 SET_NETDEV_DEV(dev, &cgdev->dev);
1563
1564 if (register_netdev(dev)) {
1565 result = -ENODEV;
1566 goto out_dev;
1567 }
1568
1569 strlcpy(priv->fsm->name, dev->name, sizeof(priv->fsm->name));
1570
1571 dev_info(&dev->dev,
1572 "setup OK : r/w = %s/%s, protocol : %d\n",
1573 priv->channel[CTCM_READ]->id,
1574 priv->channel[CTCM_WRITE]->id, priv->protocol);
1575
1576 CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO,
1577 "setup(%s) OK : r/w = %s/%s, protocol : %d", dev->name,
1578 priv->channel[CTCM_READ]->id,
1579 priv->channel[CTCM_WRITE]->id, priv->protocol);
1580
1581 return 0;
1582out_dev:
1583 ctcm_free_netdevice(dev);
1584out_ccw2:
1585 ccw_device_set_offline(cgdev->cdev[1]);
1586out_ccw1:
1587 ccw_device_set_offline(cgdev->cdev[0]);
1588out_remove_channel2:
1589 readc = channel_get(type, read_id, CTCM_READ);
1590 channel_remove(readc);
1591out_remove_channel1:
1592 writec = channel_get(type, write_id, CTCM_WRITE);
1593 channel_remove(writec);
1594out_err_result:
1595 return result;
1596}
1597
1598
1599
1600
1601
1602
1603
1604
1605static int ctcm_shutdown_device(struct ccwgroup_device *cgdev)
1606{
1607 struct ctcm_priv *priv;
1608 struct net_device *dev;
1609
1610 priv = dev_get_drvdata(&cgdev->dev);
1611 if (!priv)
1612 return -ENODEV;
1613
1614 if (priv->channel[CTCM_READ]) {
1615 dev = priv->channel[CTCM_READ]->netdev;
1616 CTCM_DBF_DEV(SETUP, dev, "");
1617
1618 ctcm_close(dev);
1619 dev->flags &= ~IFF_RUNNING;
1620 channel_free(priv->channel[CTCM_READ]);
1621 } else
1622 dev = NULL;
1623
1624 if (priv->channel[CTCM_WRITE])
1625 channel_free(priv->channel[CTCM_WRITE]);
1626
1627 if (dev) {
1628 unregister_netdev(dev);
1629 ctcm_free_netdevice(dev);
1630 }
1631
1632 if (priv->fsm)
1633 kfree_fsm(priv->fsm);
1634
1635 ccw_device_set_offline(cgdev->cdev[1]);
1636 ccw_device_set_offline(cgdev->cdev[0]);
1637 channel_remove(priv->channel[CTCM_READ]);
1638 channel_remove(priv->channel[CTCM_WRITE]);
1639 priv->channel[CTCM_READ] = priv->channel[CTCM_WRITE] = NULL;
1640
1641 return 0;
1642
1643}
1644
1645
1646static void ctcm_remove_device(struct ccwgroup_device *cgdev)
1647{
1648 struct ctcm_priv *priv = dev_get_drvdata(&cgdev->dev);
1649
1650 CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO,
1651 "removing device %p, proto : %d",
1652 cgdev, priv->protocol);
1653
1654 if (cgdev->state == CCWGROUP_ONLINE)
1655 ctcm_shutdown_device(cgdev);
1656 dev_set_drvdata(&cgdev->dev, NULL);
1657 kfree(priv);
1658 put_device(&cgdev->dev);
1659}
1660
1661static struct ccw_device_id ctcm_ids[] = {
1662 {CCW_DEVICE(0x3088, 0x08), .driver_info = ctcm_channel_type_parallel},
1663 {CCW_DEVICE(0x3088, 0x1e), .driver_info = ctcm_channel_type_ficon},
1664 {CCW_DEVICE(0x3088, 0x1f), .driver_info = ctcm_channel_type_escon},
1665 {},
1666};
1667MODULE_DEVICE_TABLE(ccw, ctcm_ids);
1668
1669static struct ccw_driver ctcm_ccw_driver = {
1670 .driver = {
1671 .owner = THIS_MODULE,
1672 .name = "ctcm",
1673 },
1674 .ids = ctcm_ids,
1675 .probe = ccwgroup_probe_ccwdev,
1676 .remove = ccwgroup_remove_ccwdev,
1677 .int_class = IRQIO_CTC,
1678};
1679
1680static struct ccwgroup_driver ctcm_group_driver = {
1681 .driver = {
1682 .owner = THIS_MODULE,
1683 .name = CTC_DRIVER_NAME,
1684 },
1685 .ccw_driver = &ctcm_ccw_driver,
1686 .setup = ctcm_probe_device,
1687 .remove = ctcm_remove_device,
1688 .set_online = ctcm_new_device,
1689 .set_offline = ctcm_shutdown_device,
1690};
1691
1692static ssize_t group_store(struct device_driver *ddrv, const char *buf,
1693 size_t count)
1694{
1695 int err;
1696
1697 err = ccwgroup_create_dev(ctcm_root_dev, &ctcm_group_driver, 2, buf);
1698 return err ? err : count;
1699}
1700static DRIVER_ATTR_WO(group);
1701
1702static struct attribute *ctcm_drv_attrs[] = {
1703 &driver_attr_group.attr,
1704 NULL,
1705};
1706static struct attribute_group ctcm_drv_attr_group = {
1707 .attrs = ctcm_drv_attrs,
1708};
1709static const struct attribute_group *ctcm_drv_attr_groups[] = {
1710 &ctcm_drv_attr_group,
1711 NULL,
1712};
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724static void __exit ctcm_exit(void)
1725{
1726 ccwgroup_driver_unregister(&ctcm_group_driver);
1727 ccw_driver_unregister(&ctcm_ccw_driver);
1728 root_device_unregister(ctcm_root_dev);
1729 ctcm_unregister_dbf_views();
1730 pr_info("CTCM driver unloaded\n");
1731}
1732
1733
1734
1735
1736static void print_banner(void)
1737{
1738 pr_info("CTCM driver initialized\n");
1739}
1740
1741
1742
1743
1744
1745
1746
1747static int __init ctcm_init(void)
1748{
1749 int ret;
1750
1751 channels = NULL;
1752
1753 ret = ctcm_register_dbf_views();
1754 if (ret)
1755 goto out_err;
1756 ctcm_root_dev = root_device_register("ctcm");
1757 ret = PTR_ERR_OR_ZERO(ctcm_root_dev);
1758 if (ret)
1759 goto register_err;
1760 ret = ccw_driver_register(&ctcm_ccw_driver);
1761 if (ret)
1762 goto ccw_err;
1763 ctcm_group_driver.driver.groups = ctcm_drv_attr_groups;
1764 ret = ccwgroup_driver_register(&ctcm_group_driver);
1765 if (ret)
1766 goto ccwgroup_err;
1767 print_banner();
1768 return 0;
1769
1770ccwgroup_err:
1771 ccw_driver_unregister(&ctcm_ccw_driver);
1772ccw_err:
1773 root_device_unregister(ctcm_root_dev);
1774register_err:
1775 ctcm_unregister_dbf_views();
1776out_err:
1777 pr_err("%s / Initializing the ctcm device driver failed, ret = %d\n",
1778 __func__, ret);
1779 return ret;
1780}
1781
1782module_init(ctcm_init);
1783module_exit(ctcm_exit);
1784
1785MODULE_AUTHOR("Peter Tiedemann <ptiedem@de.ibm.com>");
1786MODULE_DESCRIPTION("Network driver for S/390 CTC + CTCMPC (SNA)");
1787MODULE_LICENSE("GPL");
1788
1789
