1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79#define CYCLOMX_X25_DEBUG 1
80
81#include <linux/ctype.h>
82#include <linux/errno.h>
83#include <linux/if_arp.h>
84#include <linux/kernel.h>
85#include <linux/module.h>
86#include <linux/string.h>
87#include <linux/sched.h>
88#include <linux/slab.h>
89#include <linux/stddef.h>
90#include <linux/wanrouter.h>
91
92#include <asm/byteorder.h>
93
94#include <linux/cyclomx.h>
95#include <linux/cycx_x25.h>
96
97#include <net/x25device.h>
98
99
100#define CYCX_X25_MAX_CMD_RETRY 5
101#define CYCX_X25_CHAN_MTU 2048
102
103
104
105
106struct cycx_x25_channel {
107
108 struct net_device *slave;
109
110 char name[WAN_IFNAME_SZ+1];
111 char addr[WAN_ADDRESS_SZ+1];
112 char *local_addr;
113
114 s16 lcn;
115 u8 link;
116 struct timer_list timer;
117 u16 protocol;
118 u8 svc;
119 u8 state;
120 u8 drop_sequence;
121 u32 idle_tmout;
122 struct sk_buff *rx_skb;
123 struct cycx_device *card;
124 struct net_device_stats ifstats;
125};
126
127
128
129static int cycx_wan_update(struct wan_device *wandev),
130 cycx_wan_new_if(struct wan_device *wandev, struct net_device *dev,
131 wanif_conf_t *conf),
132 cycx_wan_del_if(struct wan_device *wandev, struct net_device *dev);
133
134
135static int cycx_netdevice_init(struct net_device *dev);
136static int cycx_netdevice_open(struct net_device *dev);
137static int cycx_netdevice_stop(struct net_device *dev);
138static int cycx_netdevice_hard_header(struct sk_buff *skb,
139 struct net_device *dev, u16 type,
140 const void *daddr, const void *saddr,
141 unsigned len);
142static int cycx_netdevice_rebuild_header(struct sk_buff *skb);
143static netdev_tx_t cycx_netdevice_hard_start_xmit(struct sk_buff *skb,
144 struct net_device *dev);
145
146static struct net_device_stats *
147 cycx_netdevice_get_stats(struct net_device *dev);
148
149
150static void cycx_x25_irq_handler(struct cycx_device *card),
151 cycx_x25_irq_tx(struct cycx_device *card, struct cycx_x25_cmd *cmd),
152 cycx_x25_irq_rx(struct cycx_device *card, struct cycx_x25_cmd *cmd),
153 cycx_x25_irq_log(struct cycx_device *card,
154 struct cycx_x25_cmd *cmd),
155 cycx_x25_irq_stat(struct cycx_device *card,
156 struct cycx_x25_cmd *cmd),
157 cycx_x25_irq_connect_confirm(struct cycx_device *card,
158 struct cycx_x25_cmd *cmd),
159 cycx_x25_irq_disconnect_confirm(struct cycx_device *card,
160 struct cycx_x25_cmd *cmd),
161 cycx_x25_irq_connect(struct cycx_device *card,
162 struct cycx_x25_cmd *cmd),
163 cycx_x25_irq_disconnect(struct cycx_device *card,
164 struct cycx_x25_cmd *cmd),
165 cycx_x25_irq_spurious(struct cycx_device *card,
166 struct cycx_x25_cmd *cmd);
167
168
169static int cycx_x25_configure(struct cycx_device *card,
170 struct cycx_x25_config *conf),
171 cycx_x25_get_stats(struct cycx_device *card),
172 cycx_x25_send(struct cycx_device *card, u8 link, u8 lcn, u8 bitm,
173 int len, void *buf),
174 cycx_x25_connect_response(struct cycx_device *card,
175 struct cycx_x25_channel *chan),
176 cycx_x25_disconnect_response(struct cycx_device *card, u8 link,
177 u8 lcn);
178
179
180static int cycx_x25_chan_connect(struct net_device *dev),
181 cycx_x25_chan_send(struct net_device *dev, struct sk_buff *skb);
182
183static void cycx_x25_chan_disconnect(struct net_device *dev),
184 cycx_x25_chan_send_event(struct net_device *dev, u8 event);
185
186
187static void cycx_x25_set_chan_state(struct net_device *dev, u8 state),
188 cycx_x25_chan_timer(unsigned long d);
189
190static void nibble_to_byte(u8 *s, u8 *d, u8 len, u8 nibble),
191 reset_timer(struct net_device *dev);
192
193static u8 bps_to_speed_code(u32 bps);
194static u8 cycx_log2(u32 n);
195
196static unsigned dec_to_uint(u8 *str, int len);
197
198static struct net_device *cycx_x25_get_dev_by_lcn(struct wan_device *wandev,
199 s16 lcn);
200static struct net_device *
201 cycx_x25_get_dev_by_dte_addr(struct wan_device *wandev, char *dte);
202
203static void cycx_x25_chan_setup(struct net_device *dev);
204
205#ifdef CYCLOMX_X25_DEBUG
206static void hex_dump(char *msg, unsigned char *p, int len);
207static void cycx_x25_dump_config(struct cycx_x25_config *conf);
208static void cycx_x25_dump_stats(struct cycx_x25_stats *stats);
209static void cycx_x25_dump_devs(struct wan_device *wandev);
210#else
211#define hex_dump(msg, p, len)
212#define cycx_x25_dump_config(conf)
213#define cycx_x25_dump_stats(stats)
214#define cycx_x25_dump_devs(wandev)
215#endif
216
217
218
219
220
221
222
223
224
225
226
227int cycx_x25_wan_init(struct cycx_device *card, wandev_conf_t *conf)
228{
229 struct cycx_x25_config cfg;
230
231
232 if (conf->config_id != WANCONFIG_X25) {
233 printk(KERN_INFO "%s: invalid configuration ID %u!\n",
234 card->devname, conf->config_id);
235 return -EINVAL;
236 }
237
238
239 card->mbox = card->hw.dpmbase + X25_MBOX_OFFS;
240 card->u.x.connection_keys = 0;
241 spin_lock_init(&card->u.x.lock);
242
243
244
245
246
247
248 memset(&cfg, 0, sizeof(cfg));
249 cfg.link = 0;
250 cfg.clock = conf->clocking == WANOPT_EXTERNAL ? 8 : 55;
251 cfg.speed = bps_to_speed_code(conf->bps);
252 cfg.n3win = 7;
253 cfg.n2win = 2;
254 cfg.n2 = 5;
255 cfg.nvc = 1;
256 cfg.npvc = 1;
257 cfg.flags = 0x02;
258 cfg.t1 = 10;
259 cfg.t2 = 29;
260 cfg.t21 = 180;
261 cfg.t23 = 180;
262
263
264 if (!conf->mtu || conf->mtu >= 512)
265 card->wandev.mtu = 512;
266 else if (conf->mtu >= 256)
267 card->wandev.mtu = 256;
268 else if (conf->mtu >= 128)
269 card->wandev.mtu = 128;
270 else
271 card->wandev.mtu = 64;
272
273 cfg.pktlen = cycx_log2(card->wandev.mtu);
274
275 if (conf->station == WANOPT_DTE) {
276 cfg.locaddr = 3;
277 cfg.remaddr = 1;
278 } else {
279 cfg.locaddr = 1;
280 cfg.remaddr = 3;
281 }
282
283 if (conf->interface == WANOPT_RS232)
284 cfg.flags = 0;
285
286 if (conf->u.x25.hi_pvc) {
287 card->u.x.hi_pvc = min_t(unsigned int, conf->u.x25.hi_pvc, 4095);
288 card->u.x.lo_pvc = min_t(unsigned int, conf->u.x25.lo_pvc, card->u.x.hi_pvc);
289 }
290
291 if (conf->u.x25.hi_svc) {
292 card->u.x.hi_svc = min_t(unsigned int, conf->u.x25.hi_svc, 4095);
293 card->u.x.lo_svc = min_t(unsigned int, conf->u.x25.lo_svc, card->u.x.hi_svc);
294 }
295
296 if (card->u.x.lo_pvc == 255)
297 cfg.npvc = 0;
298 else
299 cfg.npvc = card->u.x.hi_pvc - card->u.x.lo_pvc + 1;
300
301 cfg.nvc = card->u.x.hi_svc - card->u.x.lo_svc + 1 + cfg.npvc;
302
303 if (conf->u.x25.hdlc_window)
304 cfg.n2win = min_t(unsigned int, conf->u.x25.hdlc_window, 7);
305
306 if (conf->u.x25.pkt_window)
307 cfg.n3win = min_t(unsigned int, conf->u.x25.pkt_window, 7);
308
309 if (conf->u.x25.t1)
310 cfg.t1 = min_t(unsigned int, conf->u.x25.t1, 30);
311
312 if (conf->u.x25.t2)
313 cfg.t2 = min_t(unsigned int, conf->u.x25.t2, 30);
314
315 if (conf->u.x25.t11_t21)
316 cfg.t21 = min_t(unsigned int, conf->u.x25.t11_t21, 30);
317
318 if (conf->u.x25.t13_t23)
319 cfg.t23 = min_t(unsigned int, conf->u.x25.t13_t23, 30);
320
321 if (conf->u.x25.n2)
322 cfg.n2 = min_t(unsigned int, conf->u.x25.n2, 30);
323
324
325 if (cycx_x25_configure(card, &cfg))
326 return -EIO;
327
328
329 card->wandev.bps = conf->bps;
330 card->wandev.interface = conf->interface;
331 card->wandev.clocking = conf->clocking;
332 card->wandev.station = conf->station;
333 card->isr = cycx_x25_irq_handler;
334 card->exec = NULL;
335 card->wandev.update = cycx_wan_update;
336 card->wandev.new_if = cycx_wan_new_if;
337 card->wandev.del_if = cycx_wan_del_if;
338 card->wandev.state = WAN_DISCONNECTED;
339
340 return 0;
341}
342
343
344
345static int cycx_wan_update(struct wan_device *wandev)
346{
347
348 if (!wandev || !wandev->private)
349 return -EFAULT;
350
351 if (wandev->state == WAN_UNCONFIGURED)
352 return -ENODEV;
353
354 cycx_x25_get_stats(wandev->private);
355
356 return 0;
357}
358
359
360
361
362
363
364
365
366
367
368
369static int cycx_wan_new_if(struct wan_device *wandev, struct net_device *dev,
370 wanif_conf_t *conf)
371{
372 struct cycx_device *card = wandev->private;
373 struct cycx_x25_channel *chan;
374 int err = 0;
375
376 if (!conf->name[0] || strlen(conf->name) > WAN_IFNAME_SZ) {
377 printk(KERN_INFO "%s: invalid interface name!\n",
378 card->devname);
379 return -EINVAL;
380 }
381
382 dev = alloc_netdev(sizeof(struct cycx_x25_channel), conf->name,
383 cycx_x25_chan_setup);
384 if (!dev)
385 return -ENOMEM;
386
387 chan = netdev_priv(dev);
388 strcpy(chan->name, conf->name);
389 chan->card = card;
390 chan->link = conf->port;
391 chan->protocol = conf->protocol ? ETH_P_X25 : ETH_P_IP;
392 chan->rx_skb = NULL;
393
394 chan->local_addr = NULL;
395
396 if (conf->addr[0] == '@') {
397 int len = strlen(conf->local_addr);
398
399 if (len) {
400 if (len > WAN_ADDRESS_SZ) {
401 printk(KERN_ERR "%s: %s local addr too long!\n",
402 wandev->name, chan->name);
403 err = -EINVAL;
404 goto error;
405 } else {
406 chan->local_addr = kmalloc(len + 1, GFP_KERNEL);
407
408 if (!chan->local_addr) {
409 err = -ENOMEM;
410 goto error;
411 }
412 }
413
414 strncpy(chan->local_addr, conf->local_addr,
415 WAN_ADDRESS_SZ);
416 }
417
418 chan->svc = 1;
419 strncpy(chan->addr, &conf->addr[1], WAN_ADDRESS_SZ);
420 init_timer(&chan->timer);
421 chan->timer.function = cycx_x25_chan_timer;
422 chan->timer.data = (unsigned long)dev;
423
424
425 chan->idle_tmout = conf->idle_timeout ? conf->idle_timeout : 90;
426 } else if (isdigit(conf->addr[0])) {
427 s16 lcn = dec_to_uint(conf->addr, 0);
428
429 if (lcn >= card->u.x.lo_pvc && lcn <= card->u.x.hi_pvc)
430 chan->lcn = lcn;
431 else {
432 printk(KERN_ERR
433 "%s: PVC %u is out of range on interface %s!\n",
434 wandev->name, lcn, chan->name);
435 err = -EINVAL;
436 goto error;
437 }
438 } else {
439 printk(KERN_ERR "%s: invalid media address on interface %s!\n",
440 wandev->name, chan->name);
441 err = -EINVAL;
442 goto error;
443 }
444
445 return 0;
446
447error:
448 free_netdev(dev);
449 return err;
450}
451
452
453static int cycx_wan_del_if(struct wan_device *wandev, struct net_device *dev)
454{
455 struct cycx_x25_channel *chan = netdev_priv(dev);
456
457 if (chan->svc) {
458 kfree(chan->local_addr);
459 if (chan->state == WAN_CONNECTED)
460 del_timer(&chan->timer);
461 }
462
463 return 0;
464}
465
466
467
468
469static const struct header_ops cycx_header_ops = {
470 .create = cycx_netdevice_hard_header,
471 .rebuild = cycx_netdevice_rebuild_header,
472};
473
474static const struct net_device_ops cycx_netdev_ops = {
475 .ndo_init = cycx_netdevice_init,
476 .ndo_open = cycx_netdevice_open,
477 .ndo_stop = cycx_netdevice_stop,
478 .ndo_start_xmit = cycx_netdevice_hard_start_xmit,
479 .ndo_get_stats = cycx_netdevice_get_stats,
480};
481
482static void cycx_x25_chan_setup(struct net_device *dev)
483{
484
485 dev->netdev_ops = &cycx_netdev_ops;
486 dev->header_ops = &cycx_header_ops;
487
488
489 dev->mtu = CYCX_X25_CHAN_MTU;
490 dev->type = ARPHRD_HWX25;
491 dev->hard_header_len = 0;
492 dev->addr_len = 0;
493}
494
495
496
497
498
499
500static int cycx_netdevice_init(struct net_device *dev)
501{
502 struct cycx_x25_channel *chan = netdev_priv(dev);
503 struct cycx_device *card = chan->card;
504 struct wan_device *wandev = &card->wandev;
505
506 if (!chan->svc)
507 *(__be16*)dev->dev_addr = htons(chan->lcn);
508
509
510 dev->irq = wandev->irq;
511 dev->dma = wandev->dma;
512 dev->base_addr = wandev->ioport;
513 dev->mem_start = (unsigned long)wandev->maddr;
514 dev->mem_end = (unsigned long)(wandev->maddr +
515 wandev->msize - 1);
516 dev->flags |= IFF_NOARP;
517
518
519 dev->tx_queue_len = 10;
520
521
522 cycx_x25_set_chan_state(dev, WAN_DISCONNECTED);
523
524 return 0;
525}
526
527
528
529
530
531
532static int cycx_netdevice_open(struct net_device *dev)
533{
534 if (netif_running(dev))
535 return -EBUSY;
536
537 netif_start_queue(dev);
538 return 0;
539}
540
541
542
543
544static int cycx_netdevice_stop(struct net_device *dev)
545{
546 struct cycx_x25_channel *chan = netdev_priv(dev);
547
548 netif_stop_queue(dev);
549
550 if (chan->state == WAN_CONNECTED || chan->state == WAN_CONNECTING)
551 cycx_x25_chan_disconnect(dev);
552
553 return 0;
554}
555
556
557
558
559
560
561
562
563
564static int cycx_netdevice_hard_header(struct sk_buff *skb,
565 struct net_device *dev, u16 type,
566 const void *daddr, const void *saddr,
567 unsigned len)
568{
569 skb->protocol = htons(type);
570
571 return dev->hard_header_len;
572}
573
574
575
576
577static int cycx_netdevice_rebuild_header(struct sk_buff *skb)
578{
579 return 1;
580}
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597static netdev_tx_t cycx_netdevice_hard_start_xmit(struct sk_buff *skb,
598 struct net_device *dev)
599{
600 struct cycx_x25_channel *chan = netdev_priv(dev);
601 struct cycx_device *card = chan->card;
602
603 if (!chan->svc)
604 chan->protocol = ntohs(skb->protocol);
605
606 if (card->wandev.state != WAN_CONNECTED)
607 ++chan->ifstats.tx_dropped;
608 else if (chan->svc && chan->protocol &&
609 chan->protocol != ntohs(skb->protocol)) {
610 printk(KERN_INFO
611 "%s: unsupported Ethertype 0x%04X on interface %s!\n",
612 card->devname, ntohs(skb->protocol), dev->name);
613 ++chan->ifstats.tx_errors;
614 } else if (chan->protocol == ETH_P_IP) {
615 switch (chan->state) {
616 case WAN_DISCONNECTED:
617 if (cycx_x25_chan_connect(dev)) {
618 netif_stop_queue(dev);
619 return NETDEV_TX_BUSY;
620 }
621
622 case WAN_CONNECTED:
623 reset_timer(dev);
624 dev->trans_start = jiffies;
625 netif_stop_queue(dev);
626
627 if (cycx_x25_chan_send(dev, skb))
628 return NETDEV_TX_BUSY;
629
630 break;
631 default:
632 ++chan->ifstats.tx_dropped;
633 ++card->wandev.stats.tx_dropped;
634 }
635 } else {
636 switch (skb->data[0]) {
637 case 0: break;
638 case 1:
639 cycx_x25_chan_connect(dev);
640 goto free_packet;
641 case 2:
642 cycx_x25_chan_disconnect(dev);
643 goto free_packet;
644 default:
645 printk(KERN_INFO
646 "%s: unknown %d x25-iface request on %s!\n",
647 card->devname, skb->data[0], dev->name);
648 ++chan->ifstats.tx_errors;
649 goto free_packet;
650 }
651
652 skb_pull(skb, 1);
653 reset_timer(dev);
654 dev->trans_start = jiffies;
655 netif_stop_queue(dev);
656
657 if (cycx_x25_chan_send(dev, skb)) {
658
659 skb_push(skb, 1);
660 return NETDEV_TX_BUSY;
661 }
662 }
663
664free_packet:
665 dev_kfree_skb(skb);
666
667 return NETDEV_TX_OK;
668}
669
670
671
672static struct net_device_stats *cycx_netdevice_get_stats(struct net_device *dev)
673{
674 struct cycx_x25_channel *chan = netdev_priv(dev);
675
676 return chan ? &chan->ifstats : NULL;
677}
678
679
680
681static void cycx_x25_irq_handler(struct cycx_device *card)
682{
683 struct cycx_x25_cmd cmd;
684 u16 z = 0;
685
686 card->in_isr = 1;
687 card->buff_int_mode_unbusy = 0;
688 cycx_peek(&card->hw, X25_RXMBOX_OFFS, &cmd, sizeof(cmd));
689
690 switch (cmd.command) {
691 case X25_DATA_INDICATION:
692 cycx_x25_irq_rx(card, &cmd);
693 break;
694 case X25_ACK_FROM_VC:
695 cycx_x25_irq_tx(card, &cmd);
696 break;
697 case X25_LOG:
698 cycx_x25_irq_log(card, &cmd);
699 break;
700 case X25_STATISTIC:
701 cycx_x25_irq_stat(card, &cmd);
702 break;
703 case X25_CONNECT_CONFIRM:
704 cycx_x25_irq_connect_confirm(card, &cmd);
705 break;
706 case X25_CONNECT_INDICATION:
707 cycx_x25_irq_connect(card, &cmd);
708 break;
709 case X25_DISCONNECT_INDICATION:
710 cycx_x25_irq_disconnect(card, &cmd);
711 break;
712 case X25_DISCONNECT_CONFIRM:
713 cycx_x25_irq_disconnect_confirm(card, &cmd);
714 break;
715 case X25_LINE_ON:
716 cycx_set_state(card, WAN_CONNECTED);
717 break;
718 case X25_LINE_OFF:
719 cycx_set_state(card, WAN_DISCONNECTED);
720 break;
721 default:
722 cycx_x25_irq_spurious(card, &cmd);
723 break;
724 }
725
726 cycx_poke(&card->hw, 0, &z, sizeof(z));
727 cycx_poke(&card->hw, X25_RXMBOX_OFFS, &z, sizeof(z));
728 card->in_isr = 0;
729}
730
731
732
733
734static void cycx_x25_irq_tx(struct cycx_device *card, struct cycx_x25_cmd *cmd)
735{
736 struct net_device *dev;
737 struct wan_device *wandev = &card->wandev;
738 u8 lcn;
739
740 cycx_peek(&card->hw, cmd->buf, &lcn, sizeof(lcn));
741
742
743 dev = cycx_x25_get_dev_by_lcn(wandev, lcn);
744 if (dev) {
745 card->buff_int_mode_unbusy = 1;
746 netif_wake_queue(dev);
747 } else
748 printk(KERN_ERR "%s:ackvc for inexistent lcn %d\n",
749 card->devname, lcn);
750}
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766static void cycx_x25_irq_rx(struct cycx_device *card, struct cycx_x25_cmd *cmd)
767{
768 struct wan_device *wandev = &card->wandev;
769 struct net_device *dev;
770 struct cycx_x25_channel *chan;
771 struct sk_buff *skb;
772 u8 bitm, lcn;
773 int pktlen = cmd->len - 5;
774
775 cycx_peek(&card->hw, cmd->buf, &lcn, sizeof(lcn));
776 cycx_peek(&card->hw, cmd->buf + 4, &bitm, sizeof(bitm));
777 bitm &= 0x10;
778
779 dev = cycx_x25_get_dev_by_lcn(wandev, lcn);
780 if (!dev) {
781
782 printk(KERN_INFO "%s: receiving on orphaned LCN %d!\n",
783 card->devname, lcn);
784 return;
785 }
786
787 chan = netdev_priv(dev);
788 reset_timer(dev);
789
790 if (chan->drop_sequence) {
791 if (!bitm)
792 chan->drop_sequence = 0;
793 else
794 return;
795 }
796
797 if ((skb = chan->rx_skb) == NULL) {
798
799 int bufsize = bitm ? dev->mtu : pktlen;
800
801 if ((skb = dev_alloc_skb((chan->protocol == ETH_P_X25 ? 1 : 0) +
802 bufsize +
803 dev->hard_header_len)) == NULL) {
804 printk(KERN_INFO "%s: no socket buffers available!\n",
805 card->devname);
806 chan->drop_sequence = 1;
807 ++chan->ifstats.rx_dropped;
808 return;
809 }
810
811 if (chan->protocol == ETH_P_X25)
812
813 skb_put(skb, 1);
814
815 skb->dev = dev;
816 skb->protocol = htons(chan->protocol);
817 chan->rx_skb = skb;
818 }
819
820 if (skb_tailroom(skb) < pktlen) {
821
822 dev_kfree_skb_irq(skb);
823 chan->rx_skb = NULL;
824
825 if (bitm)
826 chan->drop_sequence = 1;
827
828 printk(KERN_INFO "%s: unexpectedly long packet sequence "
829 "on interface %s!\n", card->devname, dev->name);
830 ++chan->ifstats.rx_length_errors;
831 return;
832 }
833
834
835 cycx_peek(&card->hw, cmd->buf + 5, skb_put(skb, pktlen), pktlen);
836
837 if (bitm)
838 return;
839
840 chan->rx_skb = NULL;
841
842 ++chan->ifstats.rx_packets;
843 chan->ifstats.rx_bytes += pktlen;
844
845 skb_reset_mac_header(skb);
846 netif_rx(skb);
847}
848
849
850static void cycx_x25_irq_connect(struct cycx_device *card,
851 struct cycx_x25_cmd *cmd)
852{
853 struct wan_device *wandev = &card->wandev;
854 struct net_device *dev = NULL;
855 struct cycx_x25_channel *chan;
856 u8 d[32],
857 loc[24],
858 rem[24];
859 u8 lcn, sizeloc, sizerem;
860
861 cycx_peek(&card->hw, cmd->buf, &lcn, sizeof(lcn));
862 cycx_peek(&card->hw, cmd->buf + 5, &sizeloc, sizeof(sizeloc));
863 cycx_peek(&card->hw, cmd->buf + 6, d, cmd->len - 6);
864
865 sizerem = sizeloc >> 4;
866 sizeloc &= 0x0F;
867
868 loc[0] = rem[0] = '\0';
869
870 if (sizeloc)
871 nibble_to_byte(d, loc, sizeloc, 0);
872
873 if (sizerem)
874 nibble_to_byte(d + (sizeloc >> 1), rem, sizerem, sizeloc & 1);
875
876 dprintk(1, KERN_INFO "%s:lcn=%d, local=%s, remote=%s\n",
877 __func__, lcn, loc, rem);
878
879 dev = cycx_x25_get_dev_by_dte_addr(wandev, rem);
880 if (!dev) {
881
882 printk(KERN_INFO "%s: connect not expected: remote %s!\n",
883 card->devname, rem);
884 return;
885 }
886
887 chan = netdev_priv(dev);
888 chan->lcn = lcn;
889 cycx_x25_connect_response(card, chan);
890 cycx_x25_set_chan_state(dev, WAN_CONNECTED);
891}
892
893
894static void cycx_x25_irq_connect_confirm(struct cycx_device *card,
895 struct cycx_x25_cmd *cmd)
896{
897 struct wan_device *wandev = &card->wandev;
898 struct net_device *dev;
899 struct cycx_x25_channel *chan;
900 u8 lcn, key;
901
902 cycx_peek(&card->hw, cmd->buf, &lcn, sizeof(lcn));
903 cycx_peek(&card->hw, cmd->buf + 1, &key, sizeof(key));
904 dprintk(1, KERN_INFO "%s: %s:lcn=%d, key=%d\n",
905 card->devname, __func__, lcn, key);
906
907 dev = cycx_x25_get_dev_by_lcn(wandev, -key);
908 if (!dev) {
909
910 clear_bit(--key, (void*)&card->u.x.connection_keys);
911 printk(KERN_INFO "%s: connect confirm not expected: lcn %d, "
912 "key=%d!\n", card->devname, lcn, key);
913 return;
914 }
915
916 clear_bit(--key, (void*)&card->u.x.connection_keys);
917 chan = netdev_priv(dev);
918 chan->lcn = lcn;
919 cycx_x25_set_chan_state(dev, WAN_CONNECTED);
920}
921
922
923static void cycx_x25_irq_disconnect_confirm(struct cycx_device *card,
924 struct cycx_x25_cmd *cmd)
925{
926 struct wan_device *wandev = &card->wandev;
927 struct net_device *dev;
928 u8 lcn;
929
930 cycx_peek(&card->hw, cmd->buf, &lcn, sizeof(lcn));
931 dprintk(1, KERN_INFO "%s: %s:lcn=%d\n",
932 card->devname, __func__, lcn);
933 dev = cycx_x25_get_dev_by_lcn(wandev, lcn);
934 if (!dev) {
935
936 printk(KERN_INFO "%s:disconnect confirm not expected!:lcn %d\n",
937 card->devname, lcn);
938 return;
939 }
940
941 cycx_x25_set_chan_state(dev, WAN_DISCONNECTED);
942}
943
944
945static void cycx_x25_irq_disconnect(struct cycx_device *card,
946 struct cycx_x25_cmd *cmd)
947{
948 struct wan_device *wandev = &card->wandev;
949 struct net_device *dev;
950 u8 lcn;
951
952 cycx_peek(&card->hw, cmd->buf, &lcn, sizeof(lcn));
953 dprintk(1, KERN_INFO "%s:lcn=%d\n", __func__, lcn);
954
955 dev = cycx_x25_get_dev_by_lcn(wandev, lcn);
956 if (dev) {
957 struct cycx_x25_channel *chan = netdev_priv(dev);
958
959 cycx_x25_disconnect_response(card, chan->link, lcn);
960 cycx_x25_set_chan_state(dev, WAN_DISCONNECTED);
961 } else
962 cycx_x25_disconnect_response(card, 0, lcn);
963}
964
965
966static void cycx_x25_irq_log(struct cycx_device *card, struct cycx_x25_cmd *cmd)
967{
968#if CYCLOMX_X25_DEBUG
969 char bf[20];
970 u16 size, toread, link, msg_code;
971 u8 code, routine;
972
973 cycx_peek(&card->hw, cmd->buf, &msg_code, sizeof(msg_code));
974 cycx_peek(&card->hw, cmd->buf + 2, &link, sizeof(link));
975 cycx_peek(&card->hw, cmd->buf + 4, &size, sizeof(size));
976
977 toread = size < 20 ? size : 20;
978 cycx_peek(&card->hw, cmd->buf + 10, &bf, toread);
979 cycx_peek(&card->hw, cmd->buf + 10 + toread, &code, 1);
980 cycx_peek(&card->hw, cmd->buf + 10 + toread + 1, &routine, 1);
981
982 printk(KERN_INFO "cycx_x25_irq_handler: X25_LOG (0x4500) indic.:\n");
983 printk(KERN_INFO "cmd->buf=0x%X\n", cmd->buf);
984 printk(KERN_INFO "Log message code=0x%X\n", msg_code);
985 printk(KERN_INFO "Link=%d\n", link);
986 printk(KERN_INFO "log code=0x%X\n", code);
987 printk(KERN_INFO "log routine=0x%X\n", routine);
988 printk(KERN_INFO "Message size=%d\n", size);
989 hex_dump("Message", bf, toread);
990#endif
991}
992
993
994static void cycx_x25_irq_stat(struct cycx_device *card,
995 struct cycx_x25_cmd *cmd)
996{
997 cycx_peek(&card->hw, cmd->buf, &card->u.x.stats,
998 sizeof(card->u.x.stats));
999 hex_dump("cycx_x25_irq_stat", (unsigned char*)&card->u.x.stats,
1000 sizeof(card->u.x.stats));
1001 cycx_x25_dump_stats(&card->u.x.stats);
1002 wake_up_interruptible(&card->wait_stats);
1003}
1004
1005
1006
1007
1008static void cycx_x25_irq_spurious(struct cycx_device *card,
1009 struct cycx_x25_cmd *cmd)
1010{
1011 printk(KERN_INFO "%s: spurious interrupt (0x%X)!\n",
1012 card->devname, cmd->command);
1013}
1014#ifdef CYCLOMX_X25_DEBUG
1015static void hex_dump(char *msg, unsigned char *p, int len)
1016{
1017 unsigned char hex[1024],
1018 * phex = hex;
1019
1020 if (len >= (sizeof(hex) / 2))
1021 len = (sizeof(hex) / 2) - 1;
1022
1023 while (len--) {
1024 sprintf(phex, "%02x", *p++);
1025 phex += 2;
1026 }
1027
1028 printk(KERN_INFO "%s: %s\n", msg, hex);
1029}
1030#endif
1031
1032
1033
1034static int x25_exec(struct cycx_device *card, int command, int link,
1035 void *d1, int len1, void *d2, int len2)
1036{
1037 struct cycx_x25_cmd c;
1038 unsigned long flags;
1039 u32 addr = 0x1200 + 0x2E0 * link + 0x1E2;
1040 u8 retry = CYCX_X25_MAX_CMD_RETRY;
1041 int err = 0;
1042
1043 c.command = command;
1044 c.link = link;
1045 c.len = len1 + len2;
1046
1047 spin_lock_irqsave(&card->u.x.lock, flags);
1048
1049
1050 cycx_poke(&card->hw, X25_MBOX_OFFS, &c, sizeof(c) - sizeof(c.buf));
1051
1052
1053 if (d1) {
1054 cycx_poke(&card->hw, addr, d1, len1);
1055
1056 if (d2) {
1057 if (len2 > 254) {
1058 u32 addr1 = 0xA00 + 0x400 * link;
1059
1060 cycx_poke(&card->hw, addr + len1, d2, 249);
1061 cycx_poke(&card->hw, addr1, ((u8*)d2) + 249,
1062 len2 - 249);
1063 } else
1064 cycx_poke(&card->hw, addr + len1, d2, len2);
1065 }
1066 }
1067
1068
1069 cycx_intr(&card->hw);
1070
1071
1072 do {
1073 err = cycx_exec(card->mbox);
1074 } while (retry-- && err);
1075
1076 spin_unlock_irqrestore(&card->u.x.lock, flags);
1077
1078 return err;
1079}
1080
1081
1082static int cycx_x25_configure(struct cycx_device *card,
1083 struct cycx_x25_config *conf)
1084{
1085 struct {
1086 u16 nlinks;
1087 struct cycx_x25_config conf[2];
1088 } x25_cmd_conf;
1089
1090 memset(&x25_cmd_conf, 0, sizeof(x25_cmd_conf));
1091 x25_cmd_conf.nlinks = 2;
1092 x25_cmd_conf.conf[0] = *conf;
1093
1094
1095
1096
1097
1098 x25_cmd_conf.conf[1] = *conf;
1099 x25_cmd_conf.conf[1].link = 1;
1100 x25_cmd_conf.conf[1].speed = 5;
1101 x25_cmd_conf.conf[1].clock = 8;
1102 x25_cmd_conf.conf[1].flags = 0;
1103
1104 cycx_x25_dump_config(&x25_cmd_conf.conf[0]);
1105 cycx_x25_dump_config(&x25_cmd_conf.conf[1]);
1106
1107 return x25_exec(card, X25_CONFIG, 0,
1108 &x25_cmd_conf, sizeof(x25_cmd_conf), NULL, 0);
1109}
1110
1111
1112static int cycx_x25_get_stats(struct cycx_device *card)
1113{
1114
1115
1116 int err = x25_exec(card, X25_STATISTIC, 0, NULL, 20, NULL, 0);
1117
1118 if (err)
1119 return err;
1120
1121 interruptible_sleep_on(&card->wait_stats);
1122
1123 if (signal_pending(current))
1124 return -EINTR;
1125
1126 card->wandev.stats.rx_packets = card->u.x.stats.n2_rx_frames;
1127 card->wandev.stats.rx_over_errors = card->u.x.stats.rx_over_errors;
1128 card->wandev.stats.rx_crc_errors = card->u.x.stats.rx_crc_errors;
1129 card->wandev.stats.rx_length_errors = 0;
1130 card->wandev.stats.rx_frame_errors = 0;
1131 card->wandev.stats.rx_missed_errors = card->u.x.stats.rx_aborts;
1132 card->wandev.stats.rx_dropped = 0;
1133 card->wandev.stats.rx_errors = 0;
1134 card->wandev.stats.tx_packets = card->u.x.stats.n2_tx_frames;
1135 card->wandev.stats.tx_aborted_errors = card->u.x.stats.tx_aborts;
1136 card->wandev.stats.tx_dropped = 0;
1137 card->wandev.stats.collisions = 0;
1138 card->wandev.stats.tx_errors = 0;
1139
1140 cycx_x25_dump_devs(&card->wandev);
1141
1142 return 0;
1143}
1144
1145
1146static int byte_to_nibble(u8 *s, u8 *d, char *nibble)
1147{
1148 int i = 0;
1149
1150 if (*nibble && *s) {
1151 d[i] |= *s++ - '0';
1152 *nibble = 0;
1153 ++i;
1154 }
1155
1156 while (*s) {
1157 d[i] = (*s - '0') << 4;
1158 if (*(s + 1))
1159 d[i] |= *(s + 1) - '0';
1160 else {
1161 *nibble = 1;
1162 break;
1163 }
1164 ++i;
1165 s += 2;
1166 }
1167
1168 return i;
1169}
1170
1171static void nibble_to_byte(u8 *s, u8 *d, u8 len, u8 nibble)
1172{
1173 if (nibble) {
1174 *d++ = '0' + (*s++ & 0x0F);
1175 --len;
1176 }
1177
1178 while (len) {
1179 *d++ = '0' + (*s >> 4);
1180
1181 if (--len) {
1182 *d++ = '0' + (*s & 0x0F);
1183 --len;
1184 } else break;
1185
1186 ++s;
1187 }
1188
1189 *d = '\0';
1190}
1191
1192
1193static int x25_place_call(struct cycx_device *card,
1194 struct cycx_x25_channel *chan)
1195{
1196 int err = 0,
1197 len;
1198 char d[64],
1199 nibble = 0,
1200 mylen = chan->local_addr ? strlen(chan->local_addr) : 0,
1201 remotelen = strlen(chan->addr);
1202 u8 key;
1203
1204 if (card->u.x.connection_keys == ~0U) {
1205 printk(KERN_INFO "%s: too many simultaneous connection "
1206 "requests!\n", card->devname);
1207 return -EAGAIN;
1208 }
1209
1210 key = ffz(card->u.x.connection_keys);
1211 set_bit(key, (void*)&card->u.x.connection_keys);
1212 ++key;
1213 dprintk(1, KERN_INFO "%s:x25_place_call:key=%d\n", card->devname, key);
1214 memset(d, 0, sizeof(d));
1215 d[1] = key;
1216 d[2] = 0x10;
1217 d[4] = 0x0B;
1218
1219 len = byte_to_nibble(chan->addr, d + 6, &nibble);
1220
1221 if (chan->local_addr)
1222 len += byte_to_nibble(chan->local_addr, d + 6 + len, &nibble);
1223
1224 if (nibble)
1225 ++len;
1226
1227 d[5] = mylen << 4 | remotelen;
1228 d[6 + len + 1] = 0xCC;
1229
1230 if ((err = x25_exec(card, X25_CONNECT_REQUEST, chan->link,
1231 &d, 7 + len + 1, NULL, 0)) != 0)
1232 clear_bit(--key, (void*)&card->u.x.connection_keys);
1233 else
1234 chan->lcn = -key;
1235
1236 return err;
1237}
1238
1239
1240static int cycx_x25_connect_response(struct cycx_device *card,
1241 struct cycx_x25_channel *chan)
1242{
1243 u8 d[8];
1244
1245 memset(d, 0, sizeof(d));
1246 d[0] = d[3] = chan->lcn;
1247 d[2] = 0x10;
1248 d[4] = 0x0F;
1249 d[7] = 0xCC;
1250
1251 return x25_exec(card, X25_CONNECT_RESPONSE, chan->link, &d, 8, NULL, 0);
1252}
1253
1254
1255static int cycx_x25_disconnect_response(struct cycx_device *card, u8 link,
1256 u8 lcn)
1257{
1258 char d[5];
1259
1260 memset(d, 0, sizeof(d));
1261 d[0] = d[3] = lcn;
1262 d[2] = 0x10;
1263 d[4] = 0x17;
1264
1265 return x25_exec(card, X25_DISCONNECT_RESPONSE, link, &d, 5, NULL, 0);
1266}
1267
1268
1269static int x25_clear_call(struct cycx_device *card, u8 link, u8 lcn, u8 cause,
1270 u8 diagn)
1271{
1272 u8 d[7];
1273
1274 memset(d, 0, sizeof(d));
1275 d[0] = d[3] = lcn;
1276 d[2] = 0x10;
1277 d[4] = 0x13;
1278 d[5] = cause;
1279 d[6] = diagn;
1280
1281 return x25_exec(card, X25_DISCONNECT_REQUEST, link, d, 7, NULL, 0);
1282}
1283
1284
1285static int cycx_x25_send(struct cycx_device *card, u8 link, u8 lcn, u8 bitm,
1286 int len, void *buf)
1287{
1288 u8 d[] = "?\xFF\x10??";
1289
1290 d[0] = d[3] = lcn;
1291 d[4] = bitm;
1292
1293 return x25_exec(card, X25_DATA_REQUEST, link, &d, 5, buf, len);
1294}
1295
1296
1297
1298static struct net_device *cycx_x25_get_dev_by_lcn(struct wan_device *wandev,
1299 s16 lcn)
1300{
1301 struct net_device *dev = wandev->dev;
1302 struct cycx_x25_channel *chan;
1303
1304 while (dev) {
1305 chan = netdev_priv(dev);
1306
1307 if (chan->lcn == lcn)
1308 break;
1309 dev = chan->slave;
1310 }
1311 return dev;
1312}
1313
1314
1315static struct net_device *
1316 cycx_x25_get_dev_by_dte_addr(struct wan_device *wandev, char *dte)
1317{
1318 struct net_device *dev = wandev->dev;
1319 struct cycx_x25_channel *chan;
1320
1321 while (dev) {
1322 chan = netdev_priv(dev);
1323
1324 if (!strcmp(chan->addr, dte))
1325 break;
1326 dev = chan->slave;
1327 }
1328 return dev;
1329}
1330
1331
1332
1333
1334
1335
1336
1337
1338static int cycx_x25_chan_connect(struct net_device *dev)
1339{
1340 struct cycx_x25_channel *chan = netdev_priv(dev);
1341 struct cycx_device *card = chan->card;
1342
1343 if (chan->svc) {
1344 if (!chan->addr[0])
1345 return -EINVAL;
1346
1347 dprintk(1, KERN_INFO "%s: placing X.25 call to %s...\n",
1348 card->devname, chan->addr);
1349
1350 if (x25_place_call(card, chan))
1351 return -EIO;
1352
1353 cycx_x25_set_chan_state(dev, WAN_CONNECTING);
1354 return 1;
1355 } else
1356 cycx_x25_set_chan_state(dev, WAN_CONNECTED);
1357
1358 return 0;
1359}
1360
1361
1362
1363static void cycx_x25_chan_disconnect(struct net_device *dev)
1364{
1365 struct cycx_x25_channel *chan = netdev_priv(dev);
1366
1367 if (chan->svc) {
1368 x25_clear_call(chan->card, chan->link, chan->lcn, 0, 0);
1369 cycx_x25_set_chan_state(dev, WAN_DISCONNECTING);
1370 } else
1371 cycx_x25_set_chan_state(dev, WAN_DISCONNECTED);
1372}
1373
1374
1375static void cycx_x25_chan_timer(unsigned long d)
1376{
1377 struct net_device *dev = (struct net_device *)d;
1378 struct cycx_x25_channel *chan = netdev_priv(dev);
1379
1380 if (chan->state == WAN_CONNECTED)
1381 cycx_x25_chan_disconnect(dev);
1382 else
1383 printk(KERN_ERR "%s: %s for svc (%s) not connected!\n",
1384 chan->card->devname, __func__, dev->name);
1385}
1386
1387
1388static void cycx_x25_set_chan_state(struct net_device *dev, u8 state)
1389{
1390 struct cycx_x25_channel *chan = netdev_priv(dev);
1391 struct cycx_device *card = chan->card;
1392 unsigned long flags;
1393 char *string_state = NULL;
1394
1395 spin_lock_irqsave(&card->lock, flags);
1396
1397 if (chan->state != state) {
1398 if (chan->svc && chan->state == WAN_CONNECTED)
1399 del_timer(&chan->timer);
1400
1401 switch (state) {
1402 case WAN_CONNECTED:
1403 string_state = "connected!";
1404 *(__be16*)dev->dev_addr = htons(chan->lcn);
1405 netif_wake_queue(dev);
1406 reset_timer(dev);
1407
1408 if (chan->protocol == ETH_P_X25)
1409 cycx_x25_chan_send_event(dev, 1);
1410
1411 break;
1412 case WAN_CONNECTING:
1413 string_state = "connecting...";
1414 break;
1415 case WAN_DISCONNECTING:
1416 string_state = "disconnecting...";
1417 break;
1418 case WAN_DISCONNECTED:
1419 string_state = "disconnected!";
1420
1421 if (chan->svc) {
1422 *(unsigned short*)dev->dev_addr = 0;
1423 chan->lcn = 0;
1424 }
1425
1426 if (chan->protocol == ETH_P_X25)
1427 cycx_x25_chan_send_event(dev, 2);
1428
1429 netif_wake_queue(dev);
1430 break;
1431 }
1432
1433 printk(KERN_INFO "%s: interface %s %s\n", card->devname,
1434 dev->name, string_state);
1435 chan->state = state;
1436 }
1437
1438 spin_unlock_irqrestore(&card->lock, flags);
1439}
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454static int cycx_x25_chan_send(struct net_device *dev, struct sk_buff *skb)
1455{
1456 struct cycx_x25_channel *chan = netdev_priv(dev);
1457 struct cycx_device *card = chan->card;
1458 int bitm = 0;
1459 unsigned len = skb->len;
1460
1461 if (skb->len > card->wandev.mtu) {
1462 len = card->wandev.mtu;
1463 bitm = 0x10;
1464 }
1465
1466 if (cycx_x25_send(card, chan->link, chan->lcn, bitm, len, skb->data))
1467 return 1;
1468
1469 if (bitm) {
1470 skb_pull(skb, len);
1471 return 1;
1472 }
1473
1474 ++chan->ifstats.tx_packets;
1475 chan->ifstats.tx_bytes += len;
1476
1477 return 0;
1478}
1479
1480
1481
1482static void cycx_x25_chan_send_event(struct net_device *dev, u8 event)
1483{
1484 struct sk_buff *skb;
1485 unsigned char *ptr;
1486
1487 if ((skb = dev_alloc_skb(1)) == NULL) {
1488 printk(KERN_ERR "%s: out of memory\n", __func__);
1489 return;
1490 }
1491
1492 ptr = skb_put(skb, 1);
1493 *ptr = event;
1494
1495 skb->protocol = x25_type_trans(skb, dev);
1496 netif_rx(skb);
1497}
1498
1499
1500static u8 bps_to_speed_code(u32 bps)
1501{
1502 u8 number = 0;
1503
1504 if (bps >= 512000) number = 8;
1505 else if (bps >= 256000) number = 7;
1506 else if (bps >= 64000) number = 6;
1507 else if (bps >= 38400) number = 5;
1508 else if (bps >= 19200) number = 4;
1509 else if (bps >= 9600) number = 3;
1510 else if (bps >= 4800) number = 2;
1511 else if (bps >= 2400) number = 1;
1512
1513 return number;
1514}
1515
1516
1517static u8 cycx_log2(u32 n)
1518{
1519 u8 log = 0;
1520
1521 if (!n)
1522 return 0;
1523
1524 while (n > 1) {
1525 n >>= 1;
1526 ++log;
1527 }
1528
1529 return log;
1530}
1531
1532
1533
1534static unsigned dec_to_uint(u8 *str, int len)
1535{
1536 unsigned val = 0;
1537
1538 if (!len)
1539 len = strlen(str);
1540
1541 for (; len && isdigit(*str); ++str, --len)
1542 val = (val * 10) + (*str - (unsigned) '0');
1543
1544 return val;
1545}
1546
1547static void reset_timer(struct net_device *dev)
1548{
1549 struct cycx_x25_channel *chan = netdev_priv(dev);
1550
1551 if (chan->svc)
1552 mod_timer(&chan->timer, jiffies+chan->idle_tmout*HZ);
1553}
1554#ifdef CYCLOMX_X25_DEBUG
1555static void cycx_x25_dump_config(struct cycx_x25_config *conf)
1556{
1557 printk(KERN_INFO "X.25 configuration\n");
1558 printk(KERN_INFO "-----------------\n");
1559 printk(KERN_INFO "link number=%d\n", conf->link);
1560 printk(KERN_INFO "line speed=%d\n", conf->speed);
1561 printk(KERN_INFO "clock=%sternal\n", conf->clock == 8 ? "Ex" : "In");
1562 printk(KERN_INFO "# level 2 retransm.=%d\n", conf->n2);
1563 printk(KERN_INFO "level 2 window=%d\n", conf->n2win);
1564 printk(KERN_INFO "level 3 window=%d\n", conf->n3win);
1565 printk(KERN_INFO "# logical channels=%d\n", conf->nvc);
1566 printk(KERN_INFO "level 3 pkt len=%d\n", conf->pktlen);
1567 printk(KERN_INFO "my address=%d\n", conf->locaddr);
1568 printk(KERN_INFO "remote address=%d\n", conf->remaddr);
1569 printk(KERN_INFO "t1=%d seconds\n", conf->t1);
1570 printk(KERN_INFO "t2=%d seconds\n", conf->t2);
1571 printk(KERN_INFO "t21=%d seconds\n", conf->t21);
1572 printk(KERN_INFO "# PVCs=%d\n", conf->npvc);
1573 printk(KERN_INFO "t23=%d seconds\n", conf->t23);
1574 printk(KERN_INFO "flags=0x%x\n", conf->flags);
1575}
1576
1577static void cycx_x25_dump_stats(struct cycx_x25_stats *stats)
1578{
1579 printk(KERN_INFO "X.25 statistics\n");
1580 printk(KERN_INFO "--------------\n");
1581 printk(KERN_INFO "rx_crc_errors=%d\n", stats->rx_crc_errors);
1582 printk(KERN_INFO "rx_over_errors=%d\n", stats->rx_over_errors);
1583 printk(KERN_INFO "n2_tx_frames=%d\n", stats->n2_tx_frames);
1584 printk(KERN_INFO "n2_rx_frames=%d\n", stats->n2_rx_frames);
1585 printk(KERN_INFO "tx_timeouts=%d\n", stats->tx_timeouts);
1586 printk(KERN_INFO "rx_timeouts=%d\n", stats->rx_timeouts);
1587 printk(KERN_INFO "n3_tx_packets=%d\n", stats->n3_tx_packets);
1588 printk(KERN_INFO "n3_rx_packets=%d\n", stats->n3_rx_packets);
1589 printk(KERN_INFO "tx_aborts=%d\n", stats->tx_aborts);
1590 printk(KERN_INFO "rx_aborts=%d\n", stats->rx_aborts);
1591}
1592
1593static void cycx_x25_dump_devs(struct wan_device *wandev)
1594{
1595 struct net_device *dev = wandev->dev;
1596
1597 printk(KERN_INFO "X.25 dev states\n");
1598 printk(KERN_INFO "name: addr: txoff: protocol:\n");
1599 printk(KERN_INFO "---------------------------------------\n");
1600
1601 while(dev) {
1602 struct cycx_x25_channel *chan = netdev_priv(dev);
1603
1604 printk(KERN_INFO "%-5.5s %-15.15s %d ETH_P_%s\n",
1605 chan->name, chan->addr, netif_queue_stopped(dev),
1606 chan->protocol == ETH_P_IP ? "IP" : "X25");
1607 dev = chan->slave;
1608 }
1609}
1610
1611#endif
1612
1613