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