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],
573 (unsigned long)ch, 0xff, 0);
574 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
575 if (ccw_idx == 3)
576 ch->prof.doios_single++;
577 if (rc != 0) {
578 fsm_deltimer(&ch->timer);
579 ctcm_ccw_check_rc(ch, rc, "single skb TX");
580 if (ccw_idx == 3)
581 skb_dequeue_tail(&ch->io_queue);
582
583
584
585
586 skb_pull(skb, LL_HEADER_LENGTH + 2);
587 } else if (ccw_idx == 0) {
588 struct net_device *dev = ch->netdev;
589 struct ctcm_priv *priv = dev->ml_priv;
590 priv->stats.tx_packets++;
591 priv->stats.tx_bytes += skb->len - LL_HEADER_LENGTH;
592 }
593done:
594 ctcm_clear_busy(ch->netdev);
595 return rc;
596}
597
598static void ctcmpc_send_sweep_req(struct channel *rch)
599{
600 struct net_device *dev = rch->netdev;
601 struct ctcm_priv *priv;
602 struct mpc_group *grp;
603 struct th_sweep *header;
604 struct sk_buff *sweep_skb;
605 struct channel *ch;
606
607
608 priv = dev->ml_priv;
609 grp = priv->mpcg;
610 ch = priv->channel[CTCM_WRITE];
611
612
613
614 if (grp->in_sweep == 0) {
615 grp->in_sweep = 1;
616 grp->sweep_rsp_pend_num = grp->active_channels[CTCM_READ];
617 grp->sweep_req_pend_num = grp->active_channels[CTCM_READ];
618 }
619
620 sweep_skb = __dev_alloc_skb(MPC_BUFSIZE_DEFAULT, GFP_ATOMIC|GFP_DMA);
621
622 if (sweep_skb == NULL) {
623
624 goto nomem;
625 }
626
627 header = kmalloc(TH_SWEEP_LENGTH, gfp_type());
628
629 if (!header) {
630 dev_kfree_skb_any(sweep_skb);
631
632 goto nomem;
633 }
634
635 header->th.th_seg = 0x00 ;
636 header->th.th_ch_flag = TH_SWEEP_REQ;
637 header->th.th_blk_flag = 0x00;
638 header->th.th_is_xid = 0x00;
639 header->th.th_seq_num = 0x00;
640 header->sw.th_last_seq = ch->th_seq_num;
641
642 skb_put_data(sweep_skb, header, TH_SWEEP_LENGTH);
643
644 kfree(header);
645
646 netif_trans_update(dev);
647 skb_queue_tail(&ch->sweep_queue, sweep_skb);
648
649 fsm_addtimer(&ch->sweep_timer, 100, CTC_EVENT_RSWEEP_TIMER, ch);
650
651 return;
652
653nomem:
654 grp->in_sweep = 0;
655 ctcm_clear_busy(dev);
656 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
657
658 return;
659}
660
661
662
663
664static int ctcmpc_transmit_skb(struct channel *ch, struct sk_buff *skb)
665{
666 struct pdu *p_header;
667 struct net_device *dev = ch->netdev;
668 struct ctcm_priv *priv = dev->ml_priv;
669 struct mpc_group *grp = priv->mpcg;
670 struct th_header *header;
671 struct sk_buff *nskb;
672 int rc = 0;
673 int ccw_idx;
674 unsigned long hi;
675 unsigned long saveflags = 0;
676
677 CTCM_PR_DEBUG("Enter %s: %s, cp=%i ch=0x%p id=%s state=%s\n",
678 __func__, dev->name, smp_processor_id(), ch,
679 ch->id, fsm_getstate_str(ch->fsm));
680
681 if ((fsm_getstate(ch->fsm) != CTC_STATE_TXIDLE) || grp->in_sweep) {
682 spin_lock_irqsave(&ch->collect_lock, saveflags);
683 refcount_inc(&skb->users);
684 p_header = kmalloc(PDU_HEADER_LENGTH, gfp_type());
685
686 if (!p_header) {
687 spin_unlock_irqrestore(&ch->collect_lock, saveflags);
688 goto nomem_exit;
689 }
690
691 p_header->pdu_offset = skb->len;
692 p_header->pdu_proto = 0x01;
693 p_header->pdu_flag = 0x00;
694 if (be16_to_cpu(skb->protocol) == ETH_P_SNAP) {
695 p_header->pdu_flag |= PDU_FIRST | PDU_CNTL;
696 } else {
697 p_header->pdu_flag |= PDU_FIRST;
698 }
699 p_header->pdu_seq = 0;
700 memcpy(skb_push(skb, PDU_HEADER_LENGTH), p_header,
701 PDU_HEADER_LENGTH);
702
703 CTCM_PR_DEBUG("%s(%s): Put on collect_q - skb len: %04x \n"
704 "pdu header and data for up to 32 bytes:\n",
705 __func__, dev->name, skb->len);
706 CTCM_D3_DUMP((char *)skb->data, min_t(int, 32, skb->len));
707
708 skb_queue_tail(&ch->collect_queue, skb);
709 ch->collect_len += skb->len;
710 kfree(p_header);
711
712 spin_unlock_irqrestore(&ch->collect_lock, saveflags);
713 goto done;
714 }
715
716
717
718
719
720 refcount_inc(&skb->users);
721
722
723
724
725
726 hi = ((unsigned long)skb->tail + TH_HEADER_LENGTH) >> 31;
727 if (hi) {
728 nskb = __dev_alloc_skb(skb->len, GFP_ATOMIC | GFP_DMA);
729 if (!nskb) {
730 goto nomem_exit;
731 } else {
732 skb_put_data(nskb, skb->data, skb->len);
733 refcount_inc(&nskb->users);
734 refcount_dec(&skb->users);
735 dev_kfree_skb_irq(skb);
736 skb = nskb;
737 }
738 }
739
740 p_header = kmalloc(PDU_HEADER_LENGTH, gfp_type());
741
742 if (!p_header)
743 goto nomem_exit;
744
745 p_header->pdu_offset = skb->len;
746 p_header->pdu_proto = 0x01;
747 p_header->pdu_flag = 0x00;
748 p_header->pdu_seq = 0;
749 if (be16_to_cpu(skb->protocol) == ETH_P_SNAP) {
750 p_header->pdu_flag |= PDU_FIRST | PDU_CNTL;
751 } else {
752 p_header->pdu_flag |= PDU_FIRST;
753 }
754 memcpy(skb_push(skb, PDU_HEADER_LENGTH), p_header, PDU_HEADER_LENGTH);
755
756 kfree(p_header);
757
758 if (ch->collect_len > 0) {
759 spin_lock_irqsave(&ch->collect_lock, saveflags);
760 skb_queue_tail(&ch->collect_queue, skb);
761 ch->collect_len += skb->len;
762 skb = skb_dequeue(&ch->collect_queue);
763 ch->collect_len -= skb->len;
764 spin_unlock_irqrestore(&ch->collect_lock, saveflags);
765 }
766
767 p_header = (struct pdu *)skb->data;
768 p_header->pdu_flag |= PDU_LAST;
769
770 ch->prof.txlen += skb->len - PDU_HEADER_LENGTH;
771
772 header = kmalloc(TH_HEADER_LENGTH, gfp_type());
773 if (!header)
774 goto nomem_exit;
775
776 header->th_seg = 0x00;
777 header->th_ch_flag = TH_HAS_PDU;
778 header->th_blk_flag = 0x00;
779 header->th_is_xid = 0x00;
780 ch->th_seq_num++;
781 header->th_seq_num = ch->th_seq_num;
782
783 CTCM_PR_DBGDATA("%s(%s) ToVTAM_th_seq= %08x\n" ,
784 __func__, dev->name, ch->th_seq_num);
785
786
787 memcpy(skb_push(skb, TH_HEADER_LENGTH), header, TH_HEADER_LENGTH);
788
789 kfree(header);
790
791 CTCM_PR_DBGDATA("%s(%s): skb len: %04x\n - pdu header and data for "
792 "up to 32 bytes sent to vtam:\n",
793 __func__, dev->name, skb->len);
794 CTCM_D3_DUMP((char *)skb->data, min_t(int, 32, skb->len));
795
796 ch->ccw[4].count = skb->len;
797 if (set_normalized_cda(&ch->ccw[4], skb->data)) {
798
799
800
801
802 if (ctcm_checkalloc_buffer(ch)) {
803
804
805
806
807 goto nomem_exit;
808 }
809
810 skb_reset_tail_pointer(ch->trans_skb);
811 ch->trans_skb->len = 0;
812 ch->ccw[1].count = skb->len;
813 skb_put_data(ch->trans_skb, skb->data, skb->len);
814 refcount_dec(&skb->users);
815 dev_kfree_skb_irq(skb);
816 ccw_idx = 0;
817 CTCM_PR_DBGDATA("%s(%s): trans_skb len: %04x\n"
818 "up to 32 bytes sent to vtam:\n",
819 __func__, dev->name, ch->trans_skb->len);
820 CTCM_D3_DUMP((char *)ch->trans_skb->data,
821 min_t(int, 32, ch->trans_skb->len));
822 } else {
823 skb_queue_tail(&ch->io_queue, skb);
824 ccw_idx = 3;
825 }
826 ch->retry = 0;
827 fsm_newstate(ch->fsm, CTC_STATE_TX);
828 fsm_addtimer(&ch->timer, CTCM_TIME_5_SEC, CTC_EVENT_TIMER, ch);
829
830 if (do_debug_ccw)
831 ctcmpc_dumpit((char *)&ch->ccw[ccw_idx],
832 sizeof(struct ccw1) * 3);
833
834 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
835 ch->prof.send_stamp = jiffies;
836 rc = ccw_device_start(ch->cdev, &ch->ccw[ccw_idx],
837 (unsigned long)ch, 0xff, 0);
838 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
839 if (ccw_idx == 3)
840 ch->prof.doios_single++;
841 if (rc != 0) {
842 fsm_deltimer(&ch->timer);
843 ctcm_ccw_check_rc(ch, rc, "single skb TX");
844 if (ccw_idx == 3)
845 skb_dequeue_tail(&ch->io_queue);
846 } else if (ccw_idx == 0) {
847 priv->stats.tx_packets++;
848 priv->stats.tx_bytes += skb->len - TH_HEADER_LENGTH;
849 }
850 if (ch->th_seq_num > 0xf0000000)
851 ctcmpc_send_sweep_req(ch);
852
853 goto done;
854nomem_exit:
855 CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_CRIT,
856 "%s(%s): MEMORY allocation ERROR\n",
857 CTCM_FUNTAIL, ch->id);
858 rc = -ENOMEM;
859 refcount_dec(&skb->users);
860 dev_kfree_skb_any(skb);
861 fsm_event(priv->mpcg->fsm, MPCG_EVENT_INOP, dev);
862done:
863 CTCM_PR_DEBUG("Exit %s(%s)\n", __func__, dev->name);
864 return rc;
865}
866
867
868
869
870
871
872
873
874
875
876
877
878
879static int ctcm_tx(struct sk_buff *skb, struct net_device *dev)
880{
881 struct ctcm_priv *priv = dev->ml_priv;
882
883 if (skb == NULL) {
884 CTCM_DBF_TEXT_(ERROR, CTC_DBF_ERROR,
885 "%s(%s): NULL sk_buff passed",
886 CTCM_FUNTAIL, dev->name);
887 priv->stats.tx_dropped++;
888 return NETDEV_TX_OK;
889 }
890 if (skb_headroom(skb) < (LL_HEADER_LENGTH + 2)) {
891 CTCM_DBF_TEXT_(ERROR, CTC_DBF_ERROR,
892 "%s(%s): Got sk_buff with head room < %ld bytes",
893 CTCM_FUNTAIL, dev->name, LL_HEADER_LENGTH + 2);
894 dev_kfree_skb(skb);
895 priv->stats.tx_dropped++;
896 return NETDEV_TX_OK;
897 }
898
899
900
901
902
903 if (fsm_getstate(priv->fsm) != DEV_STATE_RUNNING) {
904 fsm_event(priv->fsm, DEV_EVENT_START, dev);
905 dev_kfree_skb(skb);
906 priv->stats.tx_dropped++;
907 priv->stats.tx_errors++;
908 priv->stats.tx_carrier_errors++;
909 return NETDEV_TX_OK;
910 }
911
912 if (ctcm_test_and_set_busy(dev))
913 return NETDEV_TX_BUSY;
914
915 netif_trans_update(dev);
916 if (ctcm_transmit_skb(priv->channel[CTCM_WRITE], skb) != 0)
917 return NETDEV_TX_BUSY;
918 return NETDEV_TX_OK;
919}
920
921
922static int ctcmpc_tx(struct sk_buff *skb, struct net_device *dev)
923{
924 int len = 0;
925 struct ctcm_priv *priv = dev->ml_priv;
926 struct mpc_group *grp = priv->mpcg;
927 struct sk_buff *newskb = NULL;
928
929
930
931
932 if (skb == NULL) {
933 CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
934 "%s(%s): NULL sk_buff passed",
935 CTCM_FUNTAIL, dev->name);
936 priv->stats.tx_dropped++;
937 goto done;
938 }
939 if (skb_headroom(skb) < (TH_HEADER_LENGTH + PDU_HEADER_LENGTH)) {
940 CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_ERROR,
941 "%s(%s): Got sk_buff with head room < %ld bytes",
942 CTCM_FUNTAIL, dev->name,
943 TH_HEADER_LENGTH + PDU_HEADER_LENGTH);
944
945 CTCM_D3_DUMP((char *)skb->data, min_t(int, 32, skb->len));
946
947 len = skb->len + TH_HEADER_LENGTH + PDU_HEADER_LENGTH;
948 newskb = __dev_alloc_skb(len, gfp_type() | GFP_DMA);
949
950 if (!newskb) {
951 CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_ERROR,
952 "%s: %s: __dev_alloc_skb failed",
953 __func__, dev->name);
954
955 dev_kfree_skb_any(skb);
956 priv->stats.tx_dropped++;
957 priv->stats.tx_errors++;
958 priv->stats.tx_carrier_errors++;
959 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
960 goto done;
961 }
962 newskb->protocol = skb->protocol;
963 skb_reserve(newskb, TH_HEADER_LENGTH + PDU_HEADER_LENGTH);
964 skb_put_data(newskb, skb->data, skb->len);
965 dev_kfree_skb_any(skb);
966 skb = newskb;
967 }
968
969
970
971
972
973
974 if ((fsm_getstate(priv->fsm) != DEV_STATE_RUNNING) ||
975 (fsm_getstate(grp->fsm) < MPCG_STATE_XID2INITW)) {
976 dev_kfree_skb_any(skb);
977 CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
978 "%s(%s): inactive MPCGROUP - dropped",
979 CTCM_FUNTAIL, dev->name);
980 priv->stats.tx_dropped++;
981 priv->stats.tx_errors++;
982 priv->stats.tx_carrier_errors++;
983 goto done;
984 }
985
986 if (ctcm_test_and_set_busy(dev)) {
987 CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
988 "%s(%s): device busy - dropped",
989 CTCM_FUNTAIL, dev->name);
990 dev_kfree_skb_any(skb);
991 priv->stats.tx_dropped++;
992 priv->stats.tx_errors++;
993 priv->stats.tx_carrier_errors++;
994 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
995 goto done;
996 }
997
998 netif_trans_update(dev);
999 if (ctcmpc_transmit_skb(priv->channel[CTCM_WRITE], skb) != 0) {
1000 CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
1001 "%s(%s): device error - dropped",
1002 CTCM_FUNTAIL, dev->name);
1003 dev_kfree_skb_any(skb);
1004 priv->stats.tx_dropped++;
1005 priv->stats.tx_errors++;
1006 priv->stats.tx_carrier_errors++;
1007 ctcm_clear_busy(dev);
1008 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
1009 goto done;
1010 }
1011 ctcm_clear_busy(dev);
1012done:
1013 if (do_debug)
1014 MPC_DBF_DEV_NAME(TRACE, dev, "exit");
1015
1016 return NETDEV_TX_OK;
1017}
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031static int ctcm_change_mtu(struct net_device *dev, int new_mtu)
1032{
1033 struct ctcm_priv *priv;
1034 int max_bufsize;
1035
1036 priv = dev->ml_priv;
1037 max_bufsize = priv->channel[CTCM_READ]->max_bufsize;
1038
1039 if (IS_MPC(priv)) {
1040 if (new_mtu > max_bufsize - TH_HEADER_LENGTH)
1041 return -EINVAL;
1042 dev->hard_header_len = TH_HEADER_LENGTH + PDU_HEADER_LENGTH;
1043 } else {
1044 if (new_mtu > max_bufsize - LL_HEADER_LENGTH - 2)
1045 return -EINVAL;
1046 dev->hard_header_len = LL_HEADER_LENGTH + 2;
1047 }
1048 dev->mtu = new_mtu;
1049 return 0;
1050}
1051
1052
1053
1054
1055
1056
1057
1058
1059static struct net_device_stats *ctcm_stats(struct net_device *dev)
1060{
1061 return &((struct ctcm_priv *)dev->ml_priv)->stats;
1062}
1063
1064static void ctcm_free_netdevice(struct net_device *dev)
1065{
1066 struct ctcm_priv *priv;
1067 struct mpc_group *grp;
1068
1069 CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO,
1070 "%s(%s)", CTCM_FUNTAIL, dev->name);
1071 priv = dev->ml_priv;
1072 if (priv) {
1073 grp = priv->mpcg;
1074 if (grp) {
1075 if (grp->fsm)
1076 kfree_fsm(grp->fsm);
1077 if (grp->xid_skb)
1078 dev_kfree_skb(grp->xid_skb);
1079 if (grp->rcvd_xid_skb)
1080 dev_kfree_skb(grp->rcvd_xid_skb);
1081 tasklet_kill(&grp->mpc_tasklet2);
1082 kfree(grp);
1083 priv->mpcg = NULL;
1084 }
1085 if (priv->fsm) {
1086 kfree_fsm(priv->fsm);
1087 priv->fsm = NULL;
1088 }
1089 kfree(priv->xid);
1090 priv->xid = NULL;
1091
1092
1093
1094
1095 }
1096#ifdef MODULE
1097 free_netdev(dev);
1098#endif
1099}
1100
1101struct mpc_group *ctcmpc_init_mpc_group(struct ctcm_priv *priv);
1102
1103static const struct net_device_ops ctcm_netdev_ops = {
1104 .ndo_open = ctcm_open,
1105 .ndo_stop = ctcm_close,
1106 .ndo_get_stats = ctcm_stats,
1107 .ndo_change_mtu = ctcm_change_mtu,
1108 .ndo_start_xmit = ctcm_tx,
1109};
1110
1111static const struct net_device_ops ctcm_mpc_netdev_ops = {
1112 .ndo_open = ctcm_open,
1113 .ndo_stop = ctcm_close,
1114 .ndo_get_stats = ctcm_stats,
1115 .ndo_change_mtu = ctcm_change_mtu,
1116 .ndo_start_xmit = ctcmpc_tx,
1117};
1118
1119static void ctcm_dev_setup(struct net_device *dev)
1120{
1121 dev->type = ARPHRD_SLIP;
1122 dev->tx_queue_len = 100;
1123 dev->flags = IFF_POINTOPOINT | IFF_NOARP;
1124 dev->min_mtu = 576;
1125 dev->max_mtu = 65527;
1126}
1127
1128
1129
1130
1131
1132static struct net_device *ctcm_init_netdevice(struct ctcm_priv *priv)
1133{
1134 struct net_device *dev;
1135 struct mpc_group *grp;
1136 if (!priv)
1137 return NULL;
1138
1139 if (IS_MPC(priv))
1140 dev = alloc_netdev(0, MPC_DEVICE_GENE, NET_NAME_UNKNOWN,
1141 ctcm_dev_setup);
1142 else
1143 dev = alloc_netdev(0, CTC_DEVICE_GENE, NET_NAME_UNKNOWN,
1144 ctcm_dev_setup);
1145
1146 if (!dev) {
1147 CTCM_DBF_TEXT_(ERROR, CTC_DBF_CRIT,
1148 "%s: MEMORY allocation ERROR",
1149 CTCM_FUNTAIL);
1150 return NULL;
1151 }
1152 dev->ml_priv = priv;
1153 priv->fsm = init_fsm("ctcmdev", dev_state_names, dev_event_names,
1154 CTCM_NR_DEV_STATES, CTCM_NR_DEV_EVENTS,
1155 dev_fsm, dev_fsm_len, GFP_KERNEL);
1156 if (priv->fsm == NULL) {
1157 CTCMY_DBF_DEV(SETUP, dev, "init_fsm error");
1158 free_netdev(dev);
1159 return NULL;
1160 }
1161 fsm_newstate(priv->fsm, DEV_STATE_STOPPED);
1162 fsm_settimer(priv->fsm, &priv->restart_timer);
1163
1164 if (IS_MPC(priv)) {
1165
1166 grp = ctcmpc_init_mpc_group(priv);
1167 if (grp == NULL) {
1168 MPC_DBF_DEV(SETUP, dev, "init_mpc_group error");
1169 free_netdev(dev);
1170 return NULL;
1171 }
1172 tasklet_init(&grp->mpc_tasklet2,
1173 mpc_group_ready, (unsigned long)dev);
1174 dev->mtu = MPC_BUFSIZE_DEFAULT -
1175 TH_HEADER_LENGTH - PDU_HEADER_LENGTH;
1176
1177 dev->netdev_ops = &ctcm_mpc_netdev_ops;
1178 dev->hard_header_len = TH_HEADER_LENGTH + PDU_HEADER_LENGTH;
1179 priv->buffer_size = MPC_BUFSIZE_DEFAULT;
1180 } else {
1181 dev->mtu = CTCM_BUFSIZE_DEFAULT - LL_HEADER_LENGTH - 2;
1182 dev->netdev_ops = &ctcm_netdev_ops;
1183 dev->hard_header_len = LL_HEADER_LENGTH + 2;
1184 }
1185
1186 CTCMY_DBF_DEV(SETUP, dev, "finished");
1187
1188 return dev;
1189}
1190
1191
1192
1193
1194
1195
1196
1197
1198static void ctcm_irq_handler(struct ccw_device *cdev,
1199 unsigned long intparm, struct irb *irb)
1200{
1201 struct channel *ch;
1202 struct net_device *dev;
1203 struct ctcm_priv *priv;
1204 struct ccwgroup_device *cgdev;
1205 int cstat;
1206 int dstat;
1207
1208 CTCM_DBF_TEXT_(TRACE, CTC_DBF_DEBUG,
1209 "Enter %s(%s)", CTCM_FUNTAIL, dev_name(&cdev->dev));
1210
1211 if (ctcm_check_irb_error(cdev, irb))
1212 return;
1213
1214 cgdev = dev_get_drvdata(&cdev->dev);
1215
1216 cstat = irb->scsw.cmd.cstat;
1217 dstat = irb->scsw.cmd.dstat;
1218
1219
1220 if (cgdev == NULL) {
1221 CTCM_DBF_TEXT_(TRACE, CTC_DBF_ERROR,
1222 "%s(%s) unsolicited irq: c-%02x d-%02x\n",
1223 CTCM_FUNTAIL, dev_name(&cdev->dev), cstat, dstat);
1224 dev_warn(&cdev->dev,
1225 "The adapter received a non-specific IRQ\n");
1226 return;
1227 }
1228
1229 priv = dev_get_drvdata(&cgdev->dev);
1230
1231
1232 if (priv->channel[CTCM_READ]->cdev == cdev)
1233 ch = priv->channel[CTCM_READ];
1234 else if (priv->channel[CTCM_WRITE]->cdev == cdev)
1235 ch = priv->channel[CTCM_WRITE];
1236 else {
1237 dev_err(&cdev->dev,
1238 "%s: Internal error: Can't determine channel for "
1239 "interrupt device %s\n",
1240 __func__, dev_name(&cdev->dev));
1241
1242 return;
1243 }
1244
1245 dev = ch->netdev;
1246 if (dev == NULL) {
1247 dev_err(&cdev->dev,
1248 "%s Internal error: net_device is NULL, ch = 0x%p\n",
1249 __func__, ch);
1250
1251 return;
1252 }
1253
1254
1255 memcpy(ch->irb, irb, sizeof(struct irb));
1256
1257
1258 if (irb->scsw.cmd.cstat) {
1259 fsm_event(ch->fsm, CTC_EVENT_SC_UNKNOWN, ch);
1260 CTCM_DBF_TEXT_(TRACE, CTC_DBF_WARN,
1261 "%s(%s): sub-ch check %s: cs=%02x ds=%02x",
1262 CTCM_FUNTAIL, dev->name, ch->id, cstat, dstat);
1263 dev_warn(&cdev->dev,
1264 "A check occurred on the subchannel\n");
1265 return;
1266 }
1267
1268
1269 if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
1270 if ((irb->ecw[0] & ch->sense_rc) == 0)
1271
1272 CTCM_DBF_TEXT_(TRACE, CTC_DBF_WARN,
1273 "%s(%s): sense=%02x, ds=%02x",
1274 CTCM_FUNTAIL, ch->id, irb->ecw[0], dstat);
1275 ccw_unit_check(ch, irb->ecw[0]);
1276 return;
1277 }
1278 if (irb->scsw.cmd.dstat & DEV_STAT_BUSY) {
1279 if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION)
1280 fsm_event(ch->fsm, CTC_EVENT_ATTNBUSY, ch);
1281 else
1282 fsm_event(ch->fsm, CTC_EVENT_BUSY, ch);
1283 return;
1284 }
1285 if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
1286 fsm_event(ch->fsm, CTC_EVENT_ATTN, ch);
1287 return;
1288 }
1289 if ((irb->scsw.cmd.stctl & SCSW_STCTL_SEC_STATUS) ||
1290 (irb->scsw.cmd.stctl == SCSW_STCTL_STATUS_PEND) ||
1291 (irb->scsw.cmd.stctl ==
1292 (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND)))
1293 fsm_event(ch->fsm, CTC_EVENT_FINSTAT, ch);
1294 else
1295 fsm_event(ch->fsm, CTC_EVENT_IRQ, ch);
1296
1297}
1298
1299static const struct device_type ctcm_devtype = {
1300 .name = "ctcm",
1301 .groups = ctcm_attr_groups,
1302};
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312static int ctcm_probe_device(struct ccwgroup_device *cgdev)
1313{
1314 struct ctcm_priv *priv;
1315
1316 CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO,
1317 "%s %p",
1318 __func__, cgdev);
1319
1320 if (!get_device(&cgdev->dev))
1321 return -ENODEV;
1322
1323 priv = kzalloc(sizeof(struct ctcm_priv), GFP_KERNEL);
1324 if (!priv) {
1325 CTCM_DBF_TEXT_(ERROR, CTC_DBF_ERROR,
1326 "%s: memory allocation failure",
1327 CTCM_FUNTAIL);
1328 put_device(&cgdev->dev);
1329 return -ENOMEM;
1330 }
1331 priv->buffer_size = CTCM_BUFSIZE_DEFAULT;
1332 cgdev->cdev[0]->handler = ctcm_irq_handler;
1333 cgdev->cdev[1]->handler = ctcm_irq_handler;
1334 dev_set_drvdata(&cgdev->dev, priv);
1335 cgdev->dev.type = &ctcm_devtype;
1336
1337 return 0;
1338}
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350static int add_channel(struct ccw_device *cdev, enum ctcm_channel_types type,
1351 struct ctcm_priv *priv)
1352{
1353 struct channel **c = &channels;
1354 struct channel *ch;
1355 int ccw_num;
1356 int rc = 0;
1357
1358 CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO,
1359 "%s(%s), type %d, proto %d",
1360 __func__, dev_name(&cdev->dev), type, priv->protocol);
1361
1362 ch = kzalloc(sizeof(struct channel), GFP_KERNEL);
1363 if (ch == NULL)
1364 return -ENOMEM;
1365
1366 ch->protocol = priv->protocol;
1367 if (IS_MPC(priv)) {
1368 ch->discontact_th = kzalloc(TH_HEADER_LENGTH, gfp_type());
1369 if (ch->discontact_th == NULL)
1370 goto nomem_return;
1371
1372 ch->discontact_th->th_blk_flag = TH_DISCONTACT;
1373 tasklet_init(&ch->ch_disc_tasklet,
1374 mpc_action_send_discontact, (unsigned long)ch);
1375
1376 tasklet_init(&ch->ch_tasklet, ctcmpc_bh, (unsigned long)ch);
1377 ch->max_bufsize = (MPC_BUFSIZE_DEFAULT - 35);
1378 ccw_num = 17;
1379 } else
1380 ccw_num = 8;
1381
1382 ch->ccw = kcalloc(ccw_num, sizeof(struct ccw1), GFP_KERNEL | GFP_DMA);
1383 if (ch->ccw == NULL)
1384 goto nomem_return;
1385
1386 ch->cdev = cdev;
1387 snprintf(ch->id, CTCM_ID_SIZE, "ch-%s", dev_name(&cdev->dev));
1388 ch->type = type;
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433 ch->ccw[6].cmd_code = CCW_CMD_SET_EXTENDED;
1434 ch->ccw[6].flags = CCW_FLAG_SLI;
1435
1436 ch->ccw[7].cmd_code = CCW_CMD_NOOP;
1437 ch->ccw[7].flags = CCW_FLAG_SLI;
1438
1439 if (IS_MPC(priv)) {
1440 ch->ccw[15].cmd_code = CCW_CMD_WRITE;
1441 ch->ccw[15].flags = CCW_FLAG_SLI | CCW_FLAG_CC;
1442 ch->ccw[15].count = TH_HEADER_LENGTH;
1443 ch->ccw[15].cda = virt_to_phys(ch->discontact_th);
1444
1445 ch->ccw[16].cmd_code = CCW_CMD_NOOP;
1446 ch->ccw[16].flags = CCW_FLAG_SLI;
1447
1448 ch->fsm = init_fsm(ch->id, ctc_ch_state_names,
1449 ctc_ch_event_names, CTC_MPC_NR_STATES,
1450 CTC_MPC_NR_EVENTS, ctcmpc_ch_fsm,
1451 mpc_ch_fsm_len, GFP_KERNEL);
1452 } else {
1453 ch->fsm = init_fsm(ch->id, ctc_ch_state_names,
1454 ctc_ch_event_names, CTC_NR_STATES,
1455 CTC_NR_EVENTS, ch_fsm,
1456 ch_fsm_len, GFP_KERNEL);
1457 }
1458 if (ch->fsm == NULL)
1459 goto nomem_return;
1460
1461 fsm_newstate(ch->fsm, CTC_STATE_IDLE);
1462
1463 ch->irb = kzalloc(sizeof(struct irb), GFP_KERNEL);
1464 if (ch->irb == NULL)
1465 goto nomem_return;
1466
1467 while (*c && ctcm_less_than((*c)->id, ch->id))
1468 c = &(*c)->next;
1469
1470 if (*c && (!strncmp((*c)->id, ch->id, CTCM_ID_SIZE))) {
1471 CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO,
1472 "%s (%s) already in list, using old entry",
1473 __func__, (*c)->id);
1474
1475 goto free_return;
1476 }
1477
1478 spin_lock_init(&ch->collect_lock);
1479
1480 fsm_settimer(ch->fsm, &ch->timer);
1481 skb_queue_head_init(&ch->io_queue);
1482 skb_queue_head_init(&ch->collect_queue);
1483
1484 if (IS_MPC(priv)) {
1485 fsm_settimer(ch->fsm, &ch->sweep_timer);
1486 skb_queue_head_init(&ch->sweep_queue);
1487 }
1488 ch->next = *c;
1489 *c = ch;
1490 return 0;
1491
1492nomem_return:
1493 rc = -ENOMEM;
1494
1495free_return:
1496 kfree(ch->ccw);
1497 kfree(ch->discontact_th);
1498 kfree_fsm(ch->fsm);
1499 kfree(ch->irb);
1500 kfree(ch);
1501 return rc;
1502}
1503
1504
1505
1506
1507static enum ctcm_channel_types get_channel_type(struct ccw_device_id *id)
1508{
1509 enum ctcm_channel_types type;
1510 type = (enum ctcm_channel_types)id->driver_info;
1511
1512 if (type == ctcm_channel_type_ficon)
1513 type = ctcm_channel_type_escon;
1514
1515 return type;
1516}
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526static int ctcm_new_device(struct ccwgroup_device *cgdev)
1527{
1528 char read_id[CTCM_ID_SIZE];
1529 char write_id[CTCM_ID_SIZE];
1530 int direction;
1531 enum ctcm_channel_types type;
1532 struct ctcm_priv *priv;
1533 struct net_device *dev;
1534 struct ccw_device *cdev0;
1535 struct ccw_device *cdev1;
1536 struct channel *readc;
1537 struct channel *writec;
1538 int ret;
1539 int result;
1540
1541 priv = dev_get_drvdata(&cgdev->dev);
1542 if (!priv) {
1543 result = -ENODEV;
1544 goto out_err_result;
1545 }
1546
1547 cdev0 = cgdev->cdev[0];
1548 cdev1 = cgdev->cdev[1];
1549
1550 type = get_channel_type(&cdev0->id);
1551
1552 snprintf(read_id, CTCM_ID_SIZE, "ch-%s", dev_name(&cdev0->dev));
1553 snprintf(write_id, CTCM_ID_SIZE, "ch-%s", dev_name(&cdev1->dev));
1554
1555 ret = add_channel(cdev0, type, priv);
1556 if (ret) {
1557 result = ret;
1558 goto out_err_result;
1559 }
1560 ret = add_channel(cdev1, type, priv);
1561 if (ret) {
1562 result = ret;
1563 goto out_remove_channel1;
1564 }
1565
1566 ret = ccw_device_set_online(cdev0);
1567 if (ret != 0) {
1568 CTCM_DBF_TEXT_(TRACE, CTC_DBF_NOTICE,
1569 "%s(%s) set_online rc=%d",
1570 CTCM_FUNTAIL, read_id, ret);
1571 result = -EIO;
1572 goto out_remove_channel2;
1573 }
1574
1575 ret = ccw_device_set_online(cdev1);
1576 if (ret != 0) {
1577 CTCM_DBF_TEXT_(TRACE, CTC_DBF_NOTICE,
1578 "%s(%s) set_online rc=%d",
1579 CTCM_FUNTAIL, write_id, ret);
1580
1581 result = -EIO;
1582 goto out_ccw1;
1583 }
1584
1585 dev = ctcm_init_netdevice(priv);
1586 if (dev == NULL) {
1587 result = -ENODEV;
1588 goto out_ccw2;
1589 }
1590
1591 for (direction = CTCM_READ; direction <= CTCM_WRITE; direction++) {
1592 priv->channel[direction] =
1593 channel_get(type, direction == CTCM_READ ?
1594 read_id : write_id, direction);
1595 if (priv->channel[direction] == NULL) {
1596 if (direction == CTCM_WRITE)
1597 channel_free(priv->channel[CTCM_READ]);
1598 result = -ENODEV;
1599 goto out_dev;
1600 }
1601 priv->channel[direction]->netdev = dev;
1602 priv->channel[direction]->protocol = priv->protocol;
1603 priv->channel[direction]->max_bufsize = priv->buffer_size;
1604 }
1605
1606 SET_NETDEV_DEV(dev, &cgdev->dev);
1607
1608 if (register_netdev(dev)) {
1609 result = -ENODEV;
1610 goto out_dev;
1611 }
1612
1613 strlcpy(priv->fsm->name, dev->name, sizeof(priv->fsm->name));
1614
1615 dev_info(&dev->dev,
1616 "setup OK : r/w = %s/%s, protocol : %d\n",
1617 priv->channel[CTCM_READ]->id,
1618 priv->channel[CTCM_WRITE]->id, priv->protocol);
1619
1620 CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO,
1621 "setup(%s) OK : r/w = %s/%s, protocol : %d", dev->name,
1622 priv->channel[CTCM_READ]->id,
1623 priv->channel[CTCM_WRITE]->id, priv->protocol);
1624
1625 return 0;
1626out_dev:
1627 ctcm_free_netdevice(dev);
1628out_ccw2:
1629 ccw_device_set_offline(cgdev->cdev[1]);
1630out_ccw1:
1631 ccw_device_set_offline(cgdev->cdev[0]);
1632out_remove_channel2:
1633 readc = channel_get(type, read_id, CTCM_READ);
1634 channel_remove(readc);
1635out_remove_channel1:
1636 writec = channel_get(type, write_id, CTCM_WRITE);
1637 channel_remove(writec);
1638out_err_result:
1639 return result;
1640}
1641
1642
1643
1644
1645
1646
1647
1648
1649static int ctcm_shutdown_device(struct ccwgroup_device *cgdev)
1650{
1651 struct ctcm_priv *priv;
1652 struct net_device *dev;
1653
1654 priv = dev_get_drvdata(&cgdev->dev);
1655 if (!priv)
1656 return -ENODEV;
1657
1658 if (priv->channel[CTCM_READ]) {
1659 dev = priv->channel[CTCM_READ]->netdev;
1660 CTCM_DBF_DEV(SETUP, dev, "");
1661
1662 ctcm_close(dev);
1663 dev->flags &= ~IFF_RUNNING;
1664 channel_free(priv->channel[CTCM_READ]);
1665 } else
1666 dev = NULL;
1667
1668 if (priv->channel[CTCM_WRITE])
1669 channel_free(priv->channel[CTCM_WRITE]);
1670
1671 if (dev) {
1672 unregister_netdev(dev);
1673 ctcm_free_netdevice(dev);
1674 }
1675
1676 if (priv->fsm)
1677 kfree_fsm(priv->fsm);
1678
1679 ccw_device_set_offline(cgdev->cdev[1]);
1680 ccw_device_set_offline(cgdev->cdev[0]);
1681 channel_remove(priv->channel[CTCM_READ]);
1682 channel_remove(priv->channel[CTCM_WRITE]);
1683 priv->channel[CTCM_READ] = priv->channel[CTCM_WRITE] = NULL;
1684
1685 return 0;
1686
1687}
1688
1689
1690static void ctcm_remove_device(struct ccwgroup_device *cgdev)
1691{
1692 struct ctcm_priv *priv = dev_get_drvdata(&cgdev->dev);
1693
1694 CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO,
1695 "removing device %p, proto : %d",
1696 cgdev, priv->protocol);
1697
1698 if (cgdev->state == CCWGROUP_ONLINE)
1699 ctcm_shutdown_device(cgdev);
1700 dev_set_drvdata(&cgdev->dev, NULL);
1701 kfree(priv);
1702 put_device(&cgdev->dev);
1703}
1704
1705static int ctcm_pm_suspend(struct ccwgroup_device *gdev)
1706{
1707 struct ctcm_priv *priv = dev_get_drvdata(&gdev->dev);
1708
1709 if (gdev->state == CCWGROUP_OFFLINE)
1710 return 0;
1711 netif_device_detach(priv->channel[CTCM_READ]->netdev);
1712 ctcm_close(priv->channel[CTCM_READ]->netdev);
1713 if (!wait_event_timeout(priv->fsm->wait_q,
1714 fsm_getstate(priv->fsm) == DEV_STATE_STOPPED, CTCM_TIME_5_SEC)) {
1715 netif_device_attach(priv->channel[CTCM_READ]->netdev);
1716 return -EBUSY;
1717 }
1718 ccw_device_set_offline(gdev->cdev[1]);
1719 ccw_device_set_offline(gdev->cdev[0]);
1720 return 0;
1721}
1722
1723static int ctcm_pm_resume(struct ccwgroup_device *gdev)
1724{
1725 struct ctcm_priv *priv = dev_get_drvdata(&gdev->dev);
1726 int rc;
1727
1728 if (gdev->state == CCWGROUP_OFFLINE)
1729 return 0;
1730 rc = ccw_device_set_online(gdev->cdev[1]);
1731 if (rc)
1732 goto err_out;
1733 rc = ccw_device_set_online(gdev->cdev[0]);
1734 if (rc)
1735 goto err_out;
1736 ctcm_open(priv->channel[CTCM_READ]->netdev);
1737err_out:
1738 netif_device_attach(priv->channel[CTCM_READ]->netdev);
1739 return rc;
1740}
1741
1742static struct ccw_device_id ctcm_ids[] = {
1743 {CCW_DEVICE(0x3088, 0x08), .driver_info = ctcm_channel_type_parallel},
1744 {CCW_DEVICE(0x3088, 0x1e), .driver_info = ctcm_channel_type_ficon},
1745 {CCW_DEVICE(0x3088, 0x1f), .driver_info = ctcm_channel_type_escon},
1746 {},
1747};
1748MODULE_DEVICE_TABLE(ccw, ctcm_ids);
1749
1750static struct ccw_driver ctcm_ccw_driver = {
1751 .driver = {
1752 .owner = THIS_MODULE,
1753 .name = "ctcm",
1754 },
1755 .ids = ctcm_ids,
1756 .probe = ccwgroup_probe_ccwdev,
1757 .remove = ccwgroup_remove_ccwdev,
1758 .int_class = IRQIO_CTC,
1759};
1760
1761static struct ccwgroup_driver ctcm_group_driver = {
1762 .driver = {
1763 .owner = THIS_MODULE,
1764 .name = CTC_DRIVER_NAME,
1765 },
1766 .ccw_driver = &ctcm_ccw_driver,
1767 .setup = ctcm_probe_device,
1768 .remove = ctcm_remove_device,
1769 .set_online = ctcm_new_device,
1770 .set_offline = ctcm_shutdown_device,
1771 .freeze = ctcm_pm_suspend,
1772 .thaw = ctcm_pm_resume,
1773 .restore = ctcm_pm_resume,
1774};
1775
1776static ssize_t group_store(struct device_driver *ddrv, const char *buf,
1777 size_t count)
1778{
1779 int err;
1780
1781 err = ccwgroup_create_dev(ctcm_root_dev, &ctcm_group_driver, 2, buf);
1782 return err ? err : count;
1783}
1784static DRIVER_ATTR_WO(group);
1785
1786static struct attribute *ctcm_drv_attrs[] = {
1787 &driver_attr_group.attr,
1788 NULL,
1789};
1790static struct attribute_group ctcm_drv_attr_group = {
1791 .attrs = ctcm_drv_attrs,
1792};
1793static const struct attribute_group *ctcm_drv_attr_groups[] = {
1794 &ctcm_drv_attr_group,
1795 NULL,
1796};
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808static void __exit ctcm_exit(void)
1809{
1810 ccwgroup_driver_unregister(&ctcm_group_driver);
1811 ccw_driver_unregister(&ctcm_ccw_driver);
1812 root_device_unregister(ctcm_root_dev);
1813 ctcm_unregister_dbf_views();
1814 pr_info("CTCM driver unloaded\n");
1815}
1816
1817
1818
1819
1820static void print_banner(void)
1821{
1822 pr_info("CTCM driver initialized\n");
1823}
1824
1825
1826
1827
1828
1829
1830
1831static int __init ctcm_init(void)
1832{
1833 int ret;
1834
1835 channels = NULL;
1836
1837 ret = ctcm_register_dbf_views();
1838 if (ret)
1839 goto out_err;
1840 ctcm_root_dev = root_device_register("ctcm");
1841 ret = PTR_ERR_OR_ZERO(ctcm_root_dev);
1842 if (ret)
1843 goto register_err;
1844 ret = ccw_driver_register(&ctcm_ccw_driver);
1845 if (ret)
1846 goto ccw_err;
1847 ctcm_group_driver.driver.groups = ctcm_drv_attr_groups;
1848 ret = ccwgroup_driver_register(&ctcm_group_driver);
1849 if (ret)
1850 goto ccwgroup_err;
1851 print_banner();
1852 return 0;
1853
1854ccwgroup_err:
1855 ccw_driver_unregister(&ctcm_ccw_driver);
1856ccw_err:
1857 root_device_unregister(ctcm_root_dev);
1858register_err:
1859 ctcm_unregister_dbf_views();
1860out_err:
1861 pr_err("%s / Initializing the ctcm device driver failed, ret = %d\n",
1862 __func__, ret);
1863 return ret;
1864}
1865
1866module_init(ctcm_init);
1867module_exit(ctcm_exit);
1868
1869MODULE_AUTHOR("Peter Tiedemann <ptiedem@de.ibm.com>");
1870MODULE_DESCRIPTION("Network driver for S/390 CTC + CTCMPC (SNA)");
1871MODULE_LICENSE("GPL");
1872
1873
