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