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